játékfejlesztés.hu
FórumGarázsprojectekCikkekSegédletekJf.hu versenyekKapcsolatokEgyebek
Legaktívabb fórumozók:
Asylum:    5471
FZoli:    4892
Kuz:    4455
gaborlabor:    4449
kicsy:    4304
TPG:    3402
monostoria:    3284
DMG:    3172
HomeGnome:    2919
Matzi:    2525

Pretender:    2498
szeki:    2440
Seeting:    2306
Geri:    2194
Orphy:    1893
Joga:    1791
Bacce:    1783
MaNiAc:    1735
ddbwo:    1654
syam:    1491
Frissebbek | Korábbi postok
[1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [15] [20] > 25 < [30] [35] [40] [45] [50] [55] [60] [65] [70] [75] [80] [85] [90] [95] [100] [105] [110] [115] [120] [125] [130] [135] [140] [142]
Asylum - Törzstag | 5471 hsz       Online status #177927   2012.04.08 17:00 GMT+1 óra  
Erröl a << röl jutott eszembe hogy anno irtam egy collective_ptr osztályt ami olyan shared_ptr aminek le lehet cserélni az általa mutatott értéket. És még müködött is. Közszemlére felteszem minnyá
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
bit.0x8000 - Törzstag | 574 hsz       Online status #177926   2012.04.08 16:58 GMT+1 óra  
Idézet
Asylum :
Jajj ez a sok vonal ááh...tegye fel a kezét aki lát ebböl bármit is, mert én nem...


És így?
(Arra nem veszek mérget, hogy működik is, mivel csak ad hoc írtam át, meg mostanában nem is C++-oztam.)
Kód:
#pragma once

#include "Memory.h"

class Reference
{   public:
        unsigned short ReferenceValue = 0;
};

template <class T> class PTR
{   public:
        T *Base;

    public:
        inline PTR() : Base(new T()) { }
   
        inline PTR(const PTR &s) : Base(s.Base)
        {
            Base->ReferenceValue++;
        }
   
        inline ~PTR()
        {
            if (Base->ReferenceValue) Base->ReferenceValue--;
            else delete Base;
        }
   
        inline void operator=(PTR s)
        {
            if (Base)
            {   if (Base->ReferenceValue) Base->ReferenceValue--;
                else delete Base;
            }
            (Base = s.Base)->ReferenceValue++;
        }
   
        inline T *operator->()
        {
            return Base;
        }
   
        inline void operator<<(PTR s)
        {
            if (Base->ReferenceValue) Base->ReferenceValue--;
            else delete Base;
            *(Base = new T())  = *s;
            Base->ReferenceValue = 0;
        }
   
        inline void CreateArray(int i) : Base(new T[i]) { }
   
        inline void DeleteArray()
        {
            delete[] Base;
        }
   
        inline void operator=(T *s)
        {
            if (Base)
            {   if (Base->ReferenceValue) Base->ReferenceValue--;
                else delete Base;
            }
            (Base = s)->ReferenceValue++;
        }
};

Ezt a hozzászólást bit.0x8000 módosította (2012.04.08 17:24 GMT+1 óra, ---)
   
Asylum - Törzstag | 5471 hsz       Online status #177925   2012.04.08 16:55 GMT+1 óra  
De nem annyit mint te wázegh Pl. minek kiirni hogy itt jönnek a konstruktorok, mikor ugyis mindenki látja, hogy konstruktor Meg ha egy-két soros fv van akkor aközé nem teszek vonalat, inkább a) inlineositom b) többet rakok egymás alá. És header fájlba se rakok vonalat Annyira jó ez a smiley

Olyat szoktam még hogy

Kód:
//===========================
// Rövid ismertetö a fvröl
//===========================
void fuggveny()
{
}

//===========================
// Rövid ismertetö a masik fvrol
//===========================
void fuggveny2()
{
}


De alapvetöen a pucér fájlokat szeretem, csak egy 75 ezer soros kódot már nem fogok végig baszkurálni (még regkiflivel sem).
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
versio - Tag | 673 hsz       Online status #177924   2012.04.08 16:53 GMT+1 óra  
Asylum: te is hasznalsz vonalat , akkor nemertem a dobbenetet
   
versio - Tag | 673 hsz       Online status #177923   2012.04.08 16:50 GMT+1 óra  
sirpalee: xd, a pointer osztaly durvan optimalizalt ,mivel minden valtozo meghivja ha tortenik vele valami, pl fuggveny parameter aradaskor, adatelem eleresnel, masolaskor stb
ez a kod 3 het munka eredmenye, es csak 30%-al lassabb mint a sima c, es ez adattombre is ervenyes, merd le a c# sebesseget es csodalkozz
   
Asylum - Törzstag | 5471 hsz       Online status #177921   2012.04.08 16:47 GMT+1 óra  


So far ennyi. Header fájlokba még szoktam doxygen kommentet.
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
sirpalee - Tag | 1282 hsz       Online status #177920   2012.04.08 16:46 GMT+1 óra  
versio : akkor ezért fordult olyan gyorsan a c# kódod, mert csak kommentből állt az egész

mondtam én, hogy van ott valami turpis-turpis
raytraceisten és übermedic
   
versio - Tag | 673 hsz       Online status #177919   2012.04.08 16:41 GMT+1 óra  
Asylum: nade te hasznalsz cpp filokat ahol definialod a fuggvenyeket, azt mutasd meg
   
Asylum - Törzstag | 5471 hsz       Online status #177917   2012.04.08 16:32 GMT+1 óra  
Mármint szép foszöld
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Pretender - Törzstag | 2498 hsz       Online status #177916   2012.04.08 16:31 GMT+1 óra  
Fura, nekem változó. Ha úgy vagyok vele, hogy később nem fogom tudni, vagy nagyon egybefolyna, akkor használok kommentet, mert szép zöld.

   
Asylum - Törzstag | 5471 hsz       Online status #177915   2012.04.08 16:28 GMT+1 óra  
Hát valamivel jobb, de az én filozófiám szerint a kód lényege a kód és nem a komment, márpedig a nagybetü és a 2 km-es vonal eléggé megvezeti a szemet. És különbenis a meztelenkedés jó a kódban is

C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
versio - Tag | 673 hsz       Online status #177914   2012.04.08 16:22 GMT+1 óra  
persze mert igy szoktam meg, most 1 sor vagy szaz mindegy
ha bemasolod vc-be eleg jol atlathato a kod
persze elobb jelold ki az egeszet es nyomj ALT+F8-at, a tabulatorokat visszahozza
   
Asylum - Törzstag | 5471 hsz       Online status #177913   2012.04.08 16:18 GMT+1 óra  
Najó de itt egysoros deklarációkhoz meg fvekhez rakod oda. Nem is tudom hogy hivják ezt szépen...segédvonal? Vezérvonal?
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
versio - Tag | 673 hsz       Online status #177912   2012.04.08 16:14 GMT+1 óra  
azert ha egy osztaly tobb mint ezer sor, jol jonnek a vonalak
en attol tudod kifutni a vilagbol ha omlesztve van minden, plusz meg cpp file
   
Asylum - Törzstag | 5471 hsz       Online status #177910   2012.04.08 16:09 GMT+1 óra  
És van még munkád?
Az enyémet is szidják agyba föbe, ettöl sztem kirohannának a világbol
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
versio - Tag | 673 hsz       Online status #177909   2012.04.08 16:08 GMT+1 óra  
mindenkinek megvan a sajat kodolasi stilusa, az enyem ilyen
   
Asylum - Törzstag | 5471 hsz       Online status #177908   2012.04.08 16:06 GMT+1 óra  
Jajj ez a sok vonal ááh...tegye fel a kezét aki lát ebböl bármit is, mert én nem...
És egyébként is ez intrusive_ptr.
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
versio - Tag | 673 hsz       Online status #177906   2012.04.08 15:56 GMT+1 óra  
itt van a pointer osztaly ha valaki ki akarja probalni

Kód:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Pointer
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma once
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include "Memory.h"
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class Reference
{
public:

//***************************************************************************************************************************************************************
// DATA MEMBERS
//***************************************************************************************************************************************************************
unsigned short ReferenceValue;
//***************************************************************************************************************************************************************
//===============================================================================================================================================================
//CONSTRUCTORS
//===============================================================================================================================================================
Reference() : ReferenceValue(0) {}
//===============================================================================================================================================================

};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template <class T> class PTR
{
public:

//***************************************************************************************************************************************************************
// DATA MEMBERS
//***************************************************************************************************************************************************************
T* Base;
//***************************************************************************************************************************************************************

public:

//===============================================================================================================================================================
//CONSTRUCTORS
//===============================================================================================================================================================
inline PTR() : Base(0)
{
Base=new T;
}
//===============================================================================================================================================================
//DESTRUCTOR
//===============================================================================================================================================================
inline ~PTR()
{
if(Base->ReferenceValue == 0)
{
delete Base;
}
else Base->ReferenceValue--;
}
//===============================================================================================================================================================
//COPY CONSTRUCTOR
//===============================================================================================================================================================
inline PTR(const PTR &s)
{
Base=s.Base;
Base->ReferenceValue++;
}
//===============================================================================================================================================================
//FUNCTIONS
//===============================================================================================================================================================
inline void operator=(PTR s)
{
if(Base != 0)
{
if(Base->ReferenceValue == 0)
{

delete Base;
}
else Base->ReferenceValue--;
}
Base=s.Base;
Base->ReferenceValue++;
}
//===============================================================================================================================================================
inline T* operator->() { return Base; }
//===============================================================================================================================================================
inline void operator<<(PTR s)
{
if(Base->ReferenceValue == 0)
{
delete Base;
}
else Base->ReferenceValue--;
Base=new T;
*Base=*s;
Base->ReferenceValue=0;
}
//===============================================================================================================================================================
inline void CreateArray(int i)
{
Base=new T[i];
}
//===============================================================================================================================================================
inline void DeleteArray()
{
delete [] Base;
}
//===============================================================================================================================================================
inline void operator=(T* s)
{
if(Base != 0)
{
if(Base->ReferenceValue == 0)
{
delete Base;
}
else Base->ReferenceValue--;
}
Base=s;
Base->ReferenceValue++;
}
//===============================================================================================================================================================
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   
bit.0x8000 - Törzstag | 574 hsz       Online status #177905   2012.04.08 15:53 GMT+1 óra  
Idézet
Seeting :
Vagy például bit, az amiket felsoroltál, írnál melléjük egy-egy példát, hogy egy engine-ben ezeket milyen feladatokra tudnám felhasználni?


A smart pointer és a pointer container a kód átláthatóságát növeli, a lexical_cast-tal szövegfájlokból lehet értékeket beolvasni, a named_mutex-el elérhető (platformfüggetlenül), hogy a programból csak egy példány fusson. De ez csak az, amire én használtam, igazából szerintem neked kéne tudnod, hogyan akarod felépíteni az engine-t, mi az ami "illeszkedik" ehhez, mennyire fontos a platformfüggetlenség, stb.. Mondjuk a C/C++ ilyen szempontból kicsit kaotikus, ugyanazt sokféleképpen is meg lehet oldani, de pont ez adja az erejét...
   
versio - Tag | 673 hsz       Online status #177904   2012.04.08 15:52 GMT+1 óra  
jobb mint a c#, mivel nem kellett new-al sem szarakodni
   
Seeting - Törzstag | 2306 hsz       Online status #177900   2012.04.08 15:42 GMT+1 óra  
Idézet
versio :
ahogy megcsinaltam kiba jo volt programozni vele, semmilyen pointer tipusra nem volt szukseg ,sem referenciara, minden valtozo pointer volt



Akkor olyan volt mint a c#, nem?
   
versio - Tag | 673 hsz       Online status #177899   2012.04.08 15:36 GMT+1 óra  
abszolut nem szokas kerdese, ha peldaul atadsz egy pointert 10 helyre , honnan tudod mikor torolheted? ha kitorlod es valaki megis meghivja elszall a programod, mig smart pointernel automatikusan torlodik ha a referenciak megszunnek

ahogy megcsinaltam kiba jo volt programozni vele, semmilyen pointer tipusra nem volt szukseg ,sem referenciara, minden valtozo pointer volt, es igy nem igenyelt extra jelolest, a az egyetlen problema a lassusag volt, azt sajnos nem tudtam megoldani , de ha rajovok egybol atterek erre mert hihetetlenul fantasztikus
   
Pretender - Törzstag | 2498 hsz       Online status #177898   2012.04.08 15:28 GMT+1 óra  
én nagyon jól megvagyok ilyen bohóckodások nélkül, szerintem meg lehet szokni, hogy new, delete, és kész.

   
versio - Tag | 673 hsz       Online status #177897   2012.04.08 15:16 GMT+1 óra  
Asylum: nekem az volt a celom hogy minden valtozo deklaralaskor letrejojjon, es ne kelljen a new -al letrehozni es termeszetesen deletere sem volt szukseg, a programozas altala nagyon ertheto es egyszeru volt, csak megbukott a sebessegen, sajnos a tobb processzor kozotti cache urites es szinkronizalas kinyirta, pedig nem kellene sok hogy rendesen mukodjon, ha kitudnam olvasni valahonnan hogy az adott kod hanyas magon fut, megoldhato lenne de ilyet nem talaltam, a win8metro meg az assemblyt tiltja
   
Asylum - Törzstag | 5471 hsz       Online status #177894   2012.04.08 14:58 GMT+1 óra  
Ésszel kell használni öket; nem azért vannak, hogy ne kelljen figyelni a deallokálásra, hanem azért hogy bizonyos nehéz esetekben ne kelljen.
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
versio - Tag | 673 hsz       Online status #177893   2012.04.08 14:56 GMT+1 óra  
az a baj ezekkel a smart pointerekkel hogy lassuak , es korulmenyesebbe teszik a debuggolast, en probaltam sajatot irni, es sikerult 30%-os sebesseg csokkenes mellett megoldani, de csakis egy processzormag hasznalatnal., tobbnel a sebesseg exponencialisan csokken ,
a konkluzio az lett hogy fordito tamogatas nelkul lehetetlen megoldani jol, es csak minimalis szinten hasznalom , ahol lehet kerulom
   
Seeting - Törzstag | 2306 hsz       Online status #177891   2012.04.08 14:43 GMT+1 óra  
Idézet
bit.0x8000 :
Egyébként szerintem az a járható út, ha az ember átnézi, és kiválasztja magának...



Thx Asy & bit, de nekem ez még elég új. A pointer containerrel pl csinálhatnék C# szintű ( vagy azt megközelítő ) garbage collectort?

Vagy például bit, az amiket felsoroltál, írnál melléjük egy-egy példát, hogy egy engine-ben ezeket milyen feladatokra tudnám felhasználni?

Szerk: Vagy mi a helyzet a Boost::Geometry-val? Azt miért nem írtad a listába?
   
bit.0x8000 - Törzstag | 574 hsz       Online status #177883   2012.04.08 14:06 GMT+1 óra  
Idézet
Seeting :
Van valakinek tapasztalata a Boost-al? Milyen libeket érdemes belőle használni játék- vagy engine fejlesztéshez?


Igazából a boost-ban nem csak lib-ek vannak, hanem egy csomó template is, ami hasznos lehet.

Amik nekem hasznosak voltak, és most eszembe jutnak:
smart pointer
pointer container
lexical_cast
named_mutex

Egyébként szerintem az a járható út, ha az ember átnézi, és kiválasztja magának...
   
Asylum - Törzstag | 5471 hsz       Online status #177882   2012.04.08 13:58 GMT+1 óra  
Shared_ptr-t lehet (de megirni se nehezebb mint megtanulni). A többit meg vagy használod vagy nem (tipikusan nem).
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Seeting - Törzstag | 2306 hsz       Online status #177881   2012.04.08 13:36 GMT+1 óra  
Hali!

Van valakinek tapasztalata a Boost-al? Milyen libeket érdemes belőle használni játék- vagy engine fejlesztéshez?
   
Dookle - Tag | 478 hsz       Online status #177840   2012.04.07 15:12 GMT+1 óra  
Megpróbálom ... de most pihenek egyet mert már hányok ettől... ... A gond az hogy az is osszezavar hogy a vonalak felbontása limitált tehát ha 2 pont között a távolság 0.02 azt akkor is 1 pixel különbséggel fogja kirajzolni és ha a távolság 1.0 akkor is 1 pixel különbséggel fogja kirajzolni...

Vagy nem... ?


Szerk :

Na működik !!! Beszoroztam az offsetet de az még nem volt elég neki ... kirajzoltattam vele az offsetet , és rájöttem hogy eltolódik a zoomnál , mert kefelejtettem a translate-et

Ez így nem jó
Kód:
offsetx = offsetx *1.1f;
offsety = offsety *1.1f;


Ez már jó
Kód:
offsetx = ((offsetx - cusrsorpos.x) * 1.1f) + cusrsorpos.x;
offsety = ((offsety - cusrsorpos.y) * 1.1f) + cusrsorpos.y;

Ezt a hozzászólást Dookle módosította (2012.04.07 17:44 GMT+1 óra, ---)
STEVIE RAY VAUGHAN FOREVER !!!!!

http://pinkcatgames.ucoz.com/
   
Asylum - Törzstag | 5471 hsz       Online status #177839   2012.04.07 15:01 GMT+1 óra  
Egérkoordinátát is skálázd be? Meg szerintem az offsetet is.
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Dookle - Tag | 478 hsz       Online status #177837   2012.04.07 14:47 GMT+1 óra  
Ja elnézést : az offset a teljes kép (graph) elmozdulását mutatja , azaz ha a középső egérgombal mozgatom a képet jobbra balra fel le ( mint a scroll bar)

Nem az nincs rászámolva


nyilván szabványos mátrixokkal könnyebb lenne számolni , de azért választottam ezt a fapados verziót mert sehol a progiban nem fogok mátrixokat használni , ezért külön írni hozzá matek osztályt felesleges lenne... és akkor sem tudnám megoldani
STEVIE RAY VAUGHAN FOREVER !!!!!

http://pinkcatgames.ucoz.com/
   
Asylum - Törzstag | 5471 hsz       Online status #177836   2012.04.07 14:42 GMT+1 óra  
Az offset az mi? Azt is beskálázod zoomoláskor?
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Dookle - Tag | 478 hsz       Online status #177835   2012.04.07 14:31 GMT+1 óra  


a pontok számítása :

Kód:
void zoomIn()
{
    // pt = cursor client coordinata

    for (std::vector<sPointData>::iterator it = points.begin(); it != points.end(); it++)
    {
        (*it).posx = (((*it).posx - pt.x ) *1.1f) + pt.x;
        (*it).posy = (((*it).posy - pt.y)  *1.1f) + pt.y;
    };
}

void insertPoint()
{
       // pt = cursor client coordinata
       newPoint.x = (pt.x - offsetx);
       newPoint.y = (offsety - pt.y);
}


az insertPoint() addig jó amíg egyszer meg nem hívom a zoomIn()-t onnantól nem stimmelnek a koordináták. Azt szeretném hogy legyen ilyen "finom hangolás" mert ugye amíg
egy egység == egy pixel addig működik a dolog , de amint
egy egység != egy pixel akkor már nem jó a számítás, vagy ha jó akkor rosszul rajzolja ki a pontot (feljebb - lejjebb)


EDIT : Ja az offset a teljes kép (graph) elmozdulását mutatja , azaz ha a középső egérgombal mozgatom a képet jobbra balra fel le ( mint a scroll bar)

Ezt a hozzászólást Dookle módosította (2012.04.07 14:46 GMT+1 óra, ---)
STEVIE RAY VAUGHAN FOREVER !!!!!

http://pinkcatgames.ucoz.com/
   
Asylum - Törzstag | 5471 hsz       Online status #177833   2012.04.07 14:10 GMT+1 óra  
Tudsz mutatni egy képet? Hogyan számolod ki az egérböl hogy hova kerüljön a pont?
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Dookle - Tag | 478 hsz       Online status #177827   2012.04.07 12:43 GMT+1 óra  
Heló matek zsenik ! Egy kicsit elakadtam. szóval egyszerű grafikont készítek , az alábbi featureokkel :
- a grafikon 2 pontal jön létre , amelyek közé tetszőleges helyre újabb pont illeszthető egér duplaklikkel.
- zoom-in zoom-out (ahol az egér aktuális poziciója a 0,0 , tehát mindíg innen indul a zoomolás)
- egér középső gombal jobbra balra , fel ,le mozdítható a grafikon (offset)

A probléma a következő (remélem érthető lesz)
a zoomolás és a pontok mozgatása már tökéletesen működik ,a pont beillésztés is , mindadigg amíg bele nem zoomolok a grafikonba.... Hogy lehet kiszámolni az új pont koordinátáit ha mondjuk a zoom ratio 1.1f ( azaz a pontok koordinátái-t szorzom be ezzel a számmal így jön létre a zoom .Ha nincs zoomolva akkor értelemszerűen 1.0f a zoom ratio ) Bárhogy próbálom sohasem jó a pont koordinátája.
Biztos vagyok benne hogy van valami aránylag triviális megoldás de egyszerűen nem tudok rájönni

A netet is átkerestem de semmi használhatót nem találtam... az az igázság hogy nem is tudom mit kellene pontosan keresni

Előre is köszi
STEVIE RAY VAUGHAN FOREVER !!!!!

http://pinkcatgames.ucoz.com/
   
Asylum - Törzstag | 5471 hsz       Online status #177818   2012.04.07 10:02 GMT+1 óra  
Az a probléma, hogy C++ tanulás helyett textúrázik...
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Pretender - Törzstag | 2498 hsz       Online status #177806   2012.04.07 00:22 GMT+1 óra  
fura, nekem nem másolódik...
Kód:
#include <vector>
#include <iostream>

struct apple
{
    int foo;

    apple(const int& _foo)
    {
        foo = _foo;
    }

    void write()
    {
        std::cout << foo << std::endl;
    }
};

int main()
{
    std::vector<apple*> apples;

    apple* egy = new apple(10);
    apple* ketto = new apple(15);

    egy->write(); // 10
    ketto->write(); // 15

    apples.push_back(egy);
    apples.push_back(ketto);

    apples[0]->write(); // 10
    apples[1]->write(); // 15

    egy->foo = 20;

    egy->write(); // 20
    ketto->write(); // 15
    apples[0]->write(); // 20
    apples[1]->write(); // 15

    system("pause");
    return 0;
}


szerk.:
oké, késő van, felfogtam, hogy mi a probléma

   
sheridan - Tag | 55 hsz       Online status #177805   2012.04.06 22:52 GMT+1 óra  
Köszi a válaszokat, gondoltam hogy e miatt van. Megvan az oka miért kell ezt használnom.

   
Parallax - Tag | 603 hsz       Online status #177802   2012.04.06 22:44 GMT+1 óra  
A megoldás vector<CTexture ^> textureList; és nem leak se. Ja, de ez egy másik topicba való.

   
versio - Tag | 673 hsz       Online status #177801   2012.04.06 22:35 GMT+1 óra  
a megoldas :

vector<CTexture**> texturak;

csak ne lokalis valtozo legyen , mert elszall mint gyozelmi
   
Parallax - Tag | 603 hsz       Online status #177799   2012.04.06 22:29 GMT+1 óra  
Kód:
CTexture* egy = new CTexture(.......);
CTexture* harom = new CTexture(.......);

egy = harom;


Én még annyit fűznék ehhez, hogy nem értem ez mire jó. Ha csak nem használsz valamilyen memória managert ez egy szép memory leak lesz.

   
gaborlabor - Moderátor | 4449 hsz       Online status #177796   2012.04.06 22:12 GMT+1 óra  
Idézet
sheridan :
Megtudjátok mondani mit csinál vele az STL vector, hogy nem lehet lecserélni? Hogyan oldható meg?


Amikor az STL vectorba push_back-elsz egy változót, akkor annak az értéke lemásolódik és az kerül be. Tehát később hiába módosítod a pointert, a vectorban lévő pointer ugyanoda fog mutatni, mint előtte.
Le lehet cserélni, csak akkor a vectorban lévő pointert kell módosítani, az meg kb ugyanúgy történik, mintha egy sima tömb egy elemét módosítanád. (megkeresed, felülírod...)

   
gaborlabor - Moderátor | 4449 hsz       Online status #177795   2012.04.06 22:06 GMT+1 óra  
Idézet
Asylum :
Kohhh....ezer byteos packet? Az szerintem fajdalmas lesz...en 64, 128, 256 ot engednek (udp + ip headerrel egyutt).


Miért lesz fájdalmas?
Ha valahol útközben olyan linken halad át a packet, ahol kisebb az MTU mint a packet mérete, csak akkor lesz darabolva.
Manapság meg simán 1000 feletti MTU-kkal találkozni, 1400-1500 körüliek a jellemző értékek.

   
sheridan - Tag | 55 hsz       Online status #177786   2012.04.06 20:50 GMT+1 óra  
Sziasztok!

Lenne egy STL-es kérdésem. Van egy saját textúra osztályom: CTexture. És egy TextureManager osztályom, ahol vector<CTexture*>-ban tárolom a betöltött textúrákat. Egy olyat szerettem volna csinálni röviden írva, hogy pl:

vector<CTexture*> texturak;

CTexture* egy = new CTexture(.......);
CTexture* ketto = new CTexture(.......);

texturak.push_back(egy);
texturak.push_back(ketto);

CTexture* harom = new CTexture(.......);

// Azt szeretném mondjuk az első egy masik textura objektumra mutasson
egy = harom;

Lefordul meg minden, de a texttúra nem cserélődik le.

De ha ezt írom, akkor jó (nyílván):

egy->openglID = harom->openglID;

Megtudjátok mondani mit csinál vele az STL vector, hogy nem lehet lecserélni? Hogyan oldható meg?

   
Pretender - Törzstag | 2498 hsz       Online status #177744   2012.04.06 14:02 GMT+1 óra  
mondtam, hogy lehet, hogy sok kevesebb lesz az, viszont teszthez inkább legyen túl-, mint alábecsülve viszont ha jól számoltam, akkor még 5000 kliens mellett is < 256mb-t foglalna az összes packet

   
Asylum - Törzstag | 5471 hsz       Online status #177741   2012.04.06 13:41 GMT+1 óra  
Kohhh....ezer byteos packet? Az szerintem fajdalmas lesz...en 64, 128, 256 ot engednek (udp + ip headerrel egyutt).
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Pretender - Törzstag | 2498 hsz       Online status #177734   2012.04.06 12:14 GMT+1 óra  
Valami ilyesmi jutott eszembe nekem is, csak dinamikusan
Előre lefoglalok egy nagy méretű Packet vectort, amelyiknek mindegyik elemének a legnagyobb méretű tömböt foglalom le. Így menet közben nem lesz new meg delete, csak memcpyzgetek mondjuk.

szerk.:
Mondjuk meg van határozva, hogy max. 1000 byte adatot tárolhat egy packet (ami még lehet, hogy túl sok is). Ekkora mennyiséget minden packetnek lefoglalok, azaz kb. 1kb-ot.
Minden egyes klienshez előre elkészítem a packeteket, mondjuk 50db-ot, azaz 1 klienshez 50*1kb = 50kb fog tartozni.
Azaz valami ilyesmi (vázlat)
Kód:
sturct Packet
{
    unsigned char* data;

    Packet()
    {
        data = new unsigned char[HEADER_SIZE + MAX_SIZE]; // ~ 1kb
    }
};

class Connection
{
    vector<Packet*> packets;

    void foo()
    {
        packets.resize(50);
        for (int i = 0; i < 50; i++)
            packets[i] = new Packet();

        // és itt lesz nagyjából 50kb adat.
    }
};

Ezzel kicsit számolgatva, ha 1 kliens ~ 50 kb, akkor ~20 kliens 1mb, azaz mondjuk egy 2gb-s rammal rendelkező szerver esetén ilyen szempontból az akár 5120 kliens (~256mb) meg sem kottyan

Ezt a hozzászólást Pretender módosította (2012.04.06 13:04 GMT+1 óra, ---)

   
Asylum - Törzstag | 5471 hsz       Online status #177730   2012.04.06 11:40 GMT+1 óra  
Csak brainstormolok.
Csinalhatnal minden kliensnek egy cachet ahova csak folytonosan fosodik be az adat (egy circular buffer pl.). Ha nincs tobb hely akkor blokkoljon. A szerver vegigmegy ezeken es mindig kiveszi a legkorabbit mindegyik buffbol (igy kb. mindenki ugyanannyira fog laggolni), es feldolgozza.
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Frissebbek | Korábbi postok
[1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [15] [20] > 25 < [30] [35] [40] [45] [50] [55] [60] [65] [70] [75] [80] [85] [90] [95] [100] [105] [110] [115] [120] [125] [130] [135] [140] [142]