Cosa stai codando ADESSO? - Indie Vault Forum

Modo discussione \| Modo lineare Cosa stai codando ADESSO?
Autore	Messaggio

Gabriele
Posting Freak

Messaggi: 4,384
Registrato: Oct 2010
Offline Offline

#1291 RE: Cosa stai codando ADESSO?

bene ho wappato chipmunk, ora ho tutti gli oggetti chipmunk rinchiusi in delle classi:

Codice:

      Physics::Space space(Vec2(0,GRAVITY));

      Vec2 v1(0,300),v2(700,0);

      Vec2 v3(480,0),v4(480,700);

      Physics::SegmentShape segment(space.GetStaticBody(),v1,v2,0);

      segment.SetFriction(1);

      space.AddShape(&segment);

      Physics::SegmentShape segment2(space.GetStaticBody(),v3,v4,0);

      segment2.SetFriction(1);

      space.AddShape(&segment2);

[...]

l'ultima fatica è stato wappare le callback delle collsioni/hash

la soluzione che ho trovato è la seguente.

struct che si salva i miei puntatori a funzione

Codice:

                 typedef bool (* fun_CollisionBegin)(Space *self, Arbiter *arb, void *data);

                 typedef bool (* fun_CollisionPreSolve)(Space *self,Arbiter *arb, void *data);

                 typedef void (* fun_CollisionPostSolve)(Space *self, Arbiter *arb, void *data);

                 typedef void (* fun_CollisionSeparate)(Space *self, Arbiter *arb, void *data);

//data calls

struct call_hs{ 

                Space::fun_CollisionBegin BeginCall;

                Space::fun_CollisionPreSolve PreSolveCall;

                Space::fun_CollisionPostSolve PostSolveCall;

                Space::fun_CollisionSeparate SeparateCall;

                void* data; 

                call_hs(

                Space::fun_CollisionBegin BeginCall,

                Space::fun_CollisionPreSolve PreSolveCall,

                Space::fun_CollisionPostSolve PostSolveCall,

                Space::fun_CollisionSeparate SeparateCall,

                void* data):BeginCall(BeginCall),

                            PreSolveCall(PreSolveCall),

                            PostSolveCall(PostSolveCall),

                            SeparateCall(SeparateCall),

                            data(data){}

};

funzioni che cancellano dall'hash di chipmunk

Codice:

void

cpSpaceRemoveCollisionHandler_OOP(cpSpace *space, cpCollisionType a, cpCollisionType b)

{

    cpAssertSpaceUnlocked(space);

    struct { cpCollisionType a, b; } ids = {a, b};

    cpCollisionHandler *old_handler = (cpCollisionHandler *) cpHashSetRemove(space->collisionHandlers, CP_HASH_PAIR(a, b), &ids);

    call_hs *m_data=(call_hs*)(old_handler->data);

    delete m_data;

    cpfree(old_handler);

}

//REMOVE ALL

void cpSpaceALLRemoveCollisionHandler_OOP_Func(void *ptr, void *none){ 

    call_hs *m_data=(call_hs*)(((cpCollisionHandler *)ptr)->data);

    delete m_data;

}

dove inserisco le call:

Codice:

cpBool fun_BeginCall(cpArbiter *a,cpSpace *space,void *vals){

            call_hs* data=(call_hs*)(vals);

            return data->BeginCall((Turtles::Physics::Space*)(space->data),(Arbiter*)a,data->data);

}

cpBool fun_PreSolveCall(cpArbiter *a,cpSpace *space,void *vals){

            call_hs* data=(call_hs*)(vals);

            return data->PreSolveCall((Turtles::Physics::Space*)(space->data),(Arbiter*)a,data->data);

}

void fun_PostSolveCall(cpArbiter *a,cpSpace *space,void *vals){

            call_hs* data=(call_hs*)(vals);

            data->PostSolveCall((Turtles::Physics::Space*)(space->data),(Arbiter*)a,data->data);

}

void fun_SeparateCall(cpArbiter *a,cpSpace *space,void *vals){

            call_hs* data=(call_hs*)(vals);

            data->SeparateCall((Turtles::Physics::Space*)(space->data),(Arbiter*)a,data->data);

}

void Space::AddCollisionHandler (  unsigned long int a, 

                                   unsigned long int b,

                                   const fun_CollisionBegin  begin , 

                                   const fun_CollisionPreSolve  preSolve ,

                                   const fun_CollisionPostSolve  postSolve,

                                   const fun_CollisionSeparate  separate,

                                   void *data){

        cpSpaceAddCollisionHandler(

            this->space, 

            a,

            b,

            (cpCollisionBeginFunc)(begin ? fun_BeginCall : NULL) , 

            (cpCollisionPreSolveFunc)(preSolve ? fun_PreSolveCall : NULL) ,

            (cpCollisionPostSolveFunc)(postSolve ? fun_PostSolveCall : NULL) , 

            (cpCollisionSeparateFunc)(separate ? fun_SeparateCall : NULL) ,

            new call_hs( begin ,preSolve,postSolve,separate, data));

}

distruttore:

Codice:

Space::~Space(){

                    __static.body=0;

                    //delete structs data_hs

                    cpHashSetEach(space->collisionHandlers, cpSpaceALLRemoveCollisionHandler_OOP_Func, NULL);

                    //

                    cpSpaceFree(space);

                }