new game-menu option 'Record Game Physics to Ipo'
authorErwin Coumans <blender@erwincoumans.com>
Tue, 23 Aug 2005 13:16:02 +0000 (13:16 +0000)
committerErwin Coumans <blender@erwincoumans.com>
Tue, 23 Aug 2005 13:16:02 +0000 (13:16 +0000)
including implementation. hope it works, and doesn't break to much.
it bakes physics objects transform into ipo, every frame of the running gameengine.
When you disable and run the game again, it clears the ipo's again. just for physics objects at the moment.

(perhaps some better UI in the future?)

15 files changed:
source/blender/blenkernel/BKE_global.h
source/blender/blenkernel/bad_level_call_stubs/stubs.c
source/blender/src/header_info.c
source/blender/src/space.c
source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp
source/gameengine/Converter/BL_BlenderDataConversion.cpp
source/gameengine/Converter/KX_BlenderSceneConverter.cpp
source/gameengine/Converter/KX_BlenderSceneConverter.h
source/gameengine/GamePlayer/common/GPC_Engine.cpp
source/gameengine/GamePlayer/ghost/GPG_Application.cpp
source/gameengine/GamePlayer/ghost/GPG_Application.h
source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp
source/gameengine/Ketsji/KX_KetsjiEngine.cpp
source/gameengine/Ketsji/KX_KetsjiEngine.h
source/gameengine/Ketsji/KX_TrackToActuator.cpp

index 000878d..5ea8b39 100644 (file)
@@ -182,6 +182,7 @@ typedef struct Global {
 #define G_FILE_SIGN              (1 << 8)
 #define G_FILE_PUBLISH                  (1 << 9)
 #define G_FILE_NO_UI                    (1 << 10)
+#define G_FILE_GAME_TO_IPO              (1 << 11)
 
 /* G.windowstate */
 #define G_WINDOWSTATE_USERDEF          0
index 163fc71..04371fb 100644 (file)
@@ -55,6 +55,22 @@ void freeAllRad(void){}
 void free_editText(void){}
 void free_editArmature(void){}
 
+char* getIpoCurveName( struct IpoCurve * icu ) 
+{
+       return 0;
+};
+
+struct IpoCurve *get_ipocurve(struct ID *from, short type, int adrcode, struct Ipo *useipo)
+{
+       return 0;
+}
+
+void insert_vert_ipo(struct IpoCurve *icu, float x, float y)
+{
+
+}
+
+
 
 void setscreen(struct bScreen *sc){}
 void force_draw_all(int header){}
index 6d984f5..d7944ab 100644 (file)
@@ -1262,6 +1262,7 @@ static void do_info_gamemenu(void *arg, int event)
        case G_FILE_SHOW_FRAMERATE:
        case G_FILE_SHOW_DEBUG_PROPS:
        case G_FILE_AUTOPLAY:
+       case G_FILE_GAME_TO_IPO:
                G.fileflags ^= event;
                break;
        default:
@@ -1289,6 +1290,15 @@ static uiBlock *info_gamemenu(void *arg_unused)
        } else {
                uiDefIconTextBut(block, BUTM, 1, ICON_CHECKBOX_DEHLT, "Enable All Frames",       0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 1, G_FILE_ENABLE_ALL_FRAMES, "");
        }
+       
+       if(G.fileflags & G_FILE_GAME_TO_IPO) {
+               uiDefIconTextBut(block, BUTM, 1, ICON_CHECKBOX_HLT, "Record Game Physics to IPO",        0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 1, G_FILE_GAME_TO_IPO, "");
+       } else {
+               uiDefIconTextBut(block, BUTM, 1, ICON_CHECKBOX_DEHLT, "Record Game Physics to IPO",      0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 1, G_FILE_GAME_TO_IPO, "");
+       }
+       
+       
+
 
        if(G.fileflags & G_FILE_SHOW_FRAMERATE) {
                uiDefIconTextBut(block, BUTM, 1, ICON_CHECKBOX_HLT, "Show Framerate and Profile",        0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 1, G_FILE_SHOW_FRAMERATE, "");
index ac8fd80..e9bfc2a 100644 (file)
 
 #include "SYS_System.h" /* for the user def menu ... should move elsewhere. */
 
-extern void StartKetsjiShell(ScrArea *area, char* startscenename, struct Main* maggie, int always_use_expand_framing);
+
+extern void StartKetsjiShell(ScrArea *area, char* startscenename, struct Main* maggie, struct SpaceIpo* sipo,int always_use_expand_framing);
 
 /**
  * When the mipmap setting changes, we want to redraw the view right
@@ -358,6 +359,11 @@ void space_set_commmandline_options(void) {
 
                a= (G.fileflags & G_FILE_ENABLE_ALL_FRAMES);
                SYS_WriteCommandLineInt(syshandle, "fixedtime", a);
+
+               a= (G.fileflags & G_FILE_GAME_TO_IPO);
+               SYS_WriteCommandLineInt(syshandle, "game2ipo", a);
+
+
        }
 }
 
@@ -399,7 +405,9 @@ static LinkNode *save_and_reset_all_scene_cfra(void)
        
        for (sc= G.main->scene.first; sc; sc= sc->id.next) {
                BLI_linklist_prepend(&storelist, (void*) (long) sc->r.cfra);
-               sc->r.cfra= 1;
+
+               //why is this reset to 1 ?
+               //sc->r.cfra= 1;
 
                set_scene_bg(sc);
        }
@@ -472,7 +480,7 @@ void start_game(void)
        space_set_commmandline_options();
 
        SaveState();
-       StartKetsjiShell(curarea, startscene->id.name+2, G.main, 1);
+       StartKetsjiShell(curarea, startscene->id.name+2, G.main,G.sipo, 1);
        RestoreState();
 
        /* Restart BPY - unload the game engine modules. */
index ca908f8..2948c45 100644 (file)
@@ -91,10 +91,13 @@ static BlendFileData *load_game_data(char *filename) {
 extern "C" void StartKetsjiShell(struct ScrArea *area,
                                                                 char* scenename,
                                                                 struct Main* maggie,
+                                                                struct SpaceIpo *sipo,
                                                                 int always_use_expand_framing)
 {
        int exitrequested = KX_EXIT_REQUEST_NO_REQUEST;
+       
        Main* blenderdata = maggie;
+
        char* startscenename = scenename;
        char pathname[160];
        strcpy (pathname, maggie->name);
@@ -113,7 +116,8 @@ extern "C" void StartKetsjiShell(struct ScrArea *area,
                bool usefixed = (SYS_GetCommandLineInt(syshandle, "fixedtime", 0) != 0);
                bool profile = (SYS_GetCommandLineInt(syshandle, "show_profile", 0) != 0);
                bool frameRate = (SYS_GetCommandLineInt(syshandle, "show_framerate", 0) != 0);
-               
+               bool game2ipo = (SYS_GetCommandLineInt(syshandle, "game2ipo", 0) != 0);
+
                // create the canvas, rasterizer and rendertools
                RAS_ICanvas* canvas = new KX_BlenderCanvas(area);
                canvas->SetMouseState(RAS_ICanvas::MOUSE_INVISIBLE);
@@ -159,7 +163,9 @@ extern "C" void StartKetsjiShell(struct ScrArea *area,
                ketsjiengine->SetAudioDevice(audiodevice);
                ketsjiengine->SetUseFixedTime(usefixed);
                ketsjiengine->SetTimingDisplay(frameRate, profile, properties);
+
                
+       
                // some blender stuff
                MT_CmMatrix4x4 projmat;
                MT_CmMatrix4x4 viewmat;
@@ -239,6 +245,13 @@ extern "C" void StartKetsjiShell(struct ScrArea *area,
                        blscene = bfd->curscene;
                }
 
+               if (blscene)
+               {
+                       int startFrame = blscene->r.cfra;
+                       ketsjiengine->SetGame2IpoMode(game2ipo,startFrame);
+               }
+
+
                // Quad buffered needs a special window.
                if (blscene->r.stereomode != RAS_IRasterizer::RAS_STEREO_QUADBUFFERED)
                        rasterizer->SetStereoMode((RAS_IRasterizer::StereoMode) blscene->r.stereomode);
@@ -254,7 +267,7 @@ extern "C" void StartKetsjiShell(struct ScrArea *area,
                        }
                        
                        // create a scene converter, create and convert the startingscene
-                       KX_ISceneConverter* sceneconverter = new KX_BlenderSceneConverter(blenderdata, ketsjiengine);
+                       KX_ISceneConverter* sceneconverter = new KX_BlenderSceneConverter(maggie,sipo, ketsjiengine);
                        ketsjiengine->SetSceneConverter(sceneconverter);
                        
                        if (always_use_expand_framing)
index 49e7c94..f6136d5 100644 (file)
@@ -1032,6 +1032,7 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
                                                          bool alwaysUseExpandFraming
                                                          )
 {      
+
        Scene *blenderscene = GetSceneForName(maggie, scenename);
 
        // Get the frame settings of the canvas.
index b7942fd..b42cf01 100644 (file)
 #include "DNA_world_types.h"
 #include "BKE_main.h"
 
+extern "C"
+{
 #include "DNA_object_types.h"
-#include "DNA_ipo_types.h"
 #include "DNA_curve_types.h"
+#include "BLI_blenlib.h"
+#include "MEM_guardedalloc.h"
+#include "BSE_editipo.h"
+#include "BSE_editipo_types.h"
+#include "DNA_ipo_types.h"
+#include "BKE_global.h"
+#include "DNA_space_types.h"
+}
 
 
 KX_BlenderSceneConverter::KX_BlenderSceneConverter(
                                                        struct Main* maggie,
+                                                       struct SpaceIpo*        sipo,
                                                        class KX_KetsjiEngine* engine
                                                        )
                                                        : m_maggie(maggie),
+                                                       m_sipo(sipo),
                                                        m_ketsjiEngine(engine),
                                                        m_alwaysUseExpandFraming(false)
 {
@@ -472,6 +483,68 @@ void KX_BlenderSceneConverter::RegisterWorldInfo(
        m_worldinfos.push_back(worldinfo);
 }
 
+/*
+ * When deleting an IPO curve from Python, check if the IPO is being
+ * edited and if so clear the pointer to the old curve.
+ */
+void KX_BlenderSceneConverter::localDel_ipoCurve ( IpoCurve * icu ,struct SpaceIpo*    sipo)
+{
+       if (!sipo)
+               return;
+
+       int i;
+       EditIpo *ei= (EditIpo *)sipo->editipo;
+       if (!ei) return;
+
+       for(i=0; i<G.sipo->totipo; i++, ei++) {
+                if ( ei->icu == icu ) {
+                       ei->flag &= ~(IPO_SELECT | IPO_EDIT);
+                       ei->icu= 0;
+                       return;
+               }
+       }
+}
+
+//quick hack
+extern "C"
+{
+       Ipo *add_ipo( char *name, int idcode );
+       char *getIpoCurveName( IpoCurve * icu );
+       struct IpoCurve *get_ipocurve(struct ID *from, short type, int adrcode, struct Ipo *useipo);
+       void testhandles_ipocurve(struct IpoCurve *icu);
+       void Mat3ToEul(float tmat[][3], float *eul);
+
+}
+
+IpoCurve* findIpoCurve(IpoCurve* first,char* searchName)
+{
+       IpoCurve* icu1;
+       for( icu1 = first; icu1; icu1 = icu1->next ) 
+       {
+               char* curveName = getIpoCurveName( icu1 );
+               if( !strcmp( curveName, searchName) )
+               {
+                       return icu1;
+               }
+       }
+       return 0;
+}
+
+Ipo* KX_BlenderSceneConverter::findIpoForName(char* objName)
+{
+       Ipo* ipo_iter = (Ipo*)m_maggie->ipo.first;
+
+       while( ipo_iter )
+       {
+               if( strcmp( objName, ipo_iter->id.name + 2 ) == 0 ) 
+               {
+                       return ipo_iter;
+               }
+               ipo_iter = (Ipo*)ipo_iter->id.next;
+       }
+       return 0;
+}
+
 
 void   KX_BlenderSceneConverter::ResetPhysicsObjectsAnimationIpo()
 {
@@ -498,18 +571,35 @@ void      KX_BlenderSceneConverter::ResetPhysicsObjectsAnimationIpo()
                                if (blenderObject)
                                {
                                        //erase existing ipo's
-                                       Ipo* ipo = blenderObject->ipo;
+                                       Ipo* ipo = findIpoForName(blenderObject->id.name+2);
                                        if (ipo)
                                        {
-
-                                               IpoCurve *icu;
+                                               //clear the curve data
+                                               IpoCurve *icu1;
                                                int numCurves = 0;
-                                               for( icu = (IpoCurve*)ipo->curve.first; icu; icu = icu->next ) {
-                                                       numCurves++;
+                                               for( icu1 = (IpoCurve*)ipo->curve.first; icu1;  ) {
                                                        
+                                                       IpoCurve* tmpicu = icu1;
+                                                       icu1 = icu1->next;
+                                                       numCurves++;
+                       
+                                                       BLI_remlink( &( blenderObject->ipo->curve ), tmpicu );
+                                                       if( tmpicu->bezt )
+                                                               MEM_freeN( tmpicu->bezt );
+                                                       MEM_freeN( tmpicu );
+                                                       localDel_ipoCurve( tmpicu ,m_sipo);
                                                }
+                                       } else
+                                       {
+                                               ipo = add_ipo(blenderObject->id.name+2, ID_OB);
+                                               blenderObject->ipo = ipo;
 
                                        }
+                               
+                                       
+
+                                       
+
                                }
                        }
 
@@ -522,9 +612,146 @@ void      KX_BlenderSceneConverter::ResetPhysicsObjectsAnimationIpo()
 
 }
 
+
+
+
        ///this generates ipo curves for position, rotation, allowing to use game physics in animation
 void   KX_BlenderSceneConverter::WritePhysicsObjectToAnimationIpo(int frameNumber)
 {
+
+       KX_SceneList* scenes = m_ketsjiEngine->CurrentScenes();
+       int numScenes = scenes->size();
+       int i;
+       for (i=0;i<numScenes;i++)
+       {
+               KX_Scene* scene = scenes->at(i);
+               //PHY_IPhysicsEnvironment* physEnv = scene->GetPhysicsEnvironment();
+               CListValue* parentList = scene->GetRootParentList();
+               int numObjects = parentList->GetCount();
+               int g;
+               for (g=0;g<numObjects;g++)
+               {
+                       KX_GameObject* gameObj = (KX_GameObject*)parentList->GetValue(g);
+                       if (gameObj->IsDynamic())
+                       {
+                               KX_IPhysicsController* physCtrl = gameObj->GetPhysicsController();
+                               
+                               Object* blenderObject = FindBlenderObject(gameObj);
+                               if (blenderObject)
+                               {
+
+                                       const MT_Matrix3x3& orn = gameObj->NodeGetWorldOrientation();
+                                       float eulerAngles[3];   
+                                       float tmat[3][3];
+                                       for (int r=0;r<3;r++)
+                                       {
+                                               for (int c=0;c<3;c++)
+                                               {
+                                                       tmat[r][c] = orn[c][r];
+                                               }
+                                       }
+                                       Mat3ToEul(tmat, eulerAngles);
+                                       
+                                       for(int x = 0; x < 3; x++) {
+                                               eulerAngles[x] *= (float) (180 / 3.14159265f);
+                                       }
+
+                                       eulerAngles[0]/=10.f;
+                                       eulerAngles[1]/=10.f;
+                                       eulerAngles[2]/=10.f;
+
+
+
+                                       const MT_Vector3& scale = gameObj->NodeGetWorldScaling();
+                                       const MT_Point3& position = gameObj->NodeGetWorldPosition();
+                                       
+                                       Ipo* ipo = blenderObject->ipo;
+                                       if (ipo)
+                                       {
+
+                                               //create the curves, if not existing
+
+                                       IpoCurve *icu1 = findIpoCurve((IpoCurve *)ipo->curve.first,"LocX");
+                                       if (!icu1)
+                                               icu1 = get_ipocurve( NULL, ipo->blocktype, OB_LOC_X, ipo );
+                                       
+                                       icu1 = findIpoCurve((IpoCurve *)ipo->curve.first,"LocY");
+                                       if (!icu1)
+                                               icu1 = get_ipocurve( NULL, ipo->blocktype, OB_LOC_Y, ipo );
+                                       
+                                       icu1 = findIpoCurve((IpoCurve *)ipo->curve.first,"LocZ");
+                                       if (!icu1)
+                                               icu1 = get_ipocurve( NULL, ipo->blocktype, OB_LOC_Z, ipo );
+
+                                       icu1 = findIpoCurve((IpoCurve *)ipo->curve.first,"RotX");
+                                       if (!icu1)
+                                               icu1 = get_ipocurve( NULL, ipo->blocktype, OB_ROT_X, ipo );
+
+                                       icu1 = findIpoCurve((IpoCurve *)ipo->curve.first,"RotY");
+                                       if (!icu1)
+                                               icu1 = get_ipocurve( NULL, ipo->blocktype, OB_ROT_Y, ipo );
+
+                                       icu1 = findIpoCurve((IpoCurve *)ipo->curve.first,"RotZ");
+                                       if (!icu1)
+                                               icu1 = get_ipocurve( NULL, ipo->blocktype, OB_ROT_Z, ipo );
+
+
+
+                                       //fill the curves with data
+
+                                               icu1 = findIpoCurve((IpoCurve *)ipo->curve.first,"LocX");
+                                               if (icu1)
+                                               {
+                                                       float curVal = position.x();
+                                                       insert_vert_ipo(icu1, frameNumber, curVal);
+                                                       testhandles_ipocurve(icu1);
+                                               }
+                                               icu1 = findIpoCurve((IpoCurve *)ipo->curve.first,"LocY");
+                                               if (icu1)
+                                               {
+                                                       float curVal = position.y();
+                                                       insert_vert_ipo(icu1, frameNumber, curVal);
+                                                       testhandles_ipocurve(icu1);
+                                               }
+                                               icu1 = findIpoCurve((IpoCurve *)ipo->curve.first,"LocZ");
+                                               if (icu1)
+                                               {
+                                                       float curVal = position.z();
+                                                       insert_vert_ipo(icu1, frameNumber, curVal);
+                                                       testhandles_ipocurve(icu1);
+                                               }
+                                               icu1 = findIpoCurve((IpoCurve *)ipo->curve.first,"RotX");
+                                               if (icu1)
+                                               {
+                                                       float curVal = eulerAngles[0];
+                                                       insert_vert_ipo(icu1, frameNumber, curVal);
+                                                       testhandles_ipocurve(icu1);
+                                               }
+                                               icu1 = findIpoCurve((IpoCurve *)ipo->curve.first,"RotY");
+                                               if (icu1)
+                                               {
+                                                       float curVal = eulerAngles[1];
+                                                       insert_vert_ipo(icu1, frameNumber, curVal);
+                                                       testhandles_ipocurve(icu1);
+                                               }
+                                               icu1 = findIpoCurve((IpoCurve *)ipo->curve.first,"RotZ");
+                                               if (icu1)
+                                               {
+                                                       float curVal = eulerAngles[2];
+                                                       insert_vert_ipo(icu1, frameNumber, curVal);
+                                                       testhandles_ipocurve(icu1);
+                                               }
+
+                                       }
+                               }
+                       }
+
+               }
+               
+       
+       }
+
+
        //todo, before 2.38/2.40 release, Erwin
 #ifdef TURN_THIS_PYTHON_CODE_INTO_CPP
 
index d4048ce..dd7c31a 100644 (file)
@@ -44,6 +44,9 @@ class SCA_IController;
 class RAS_MeshObject;
 class RAS_IPolyMaterial;
 class BL_InterpolatorList;
+struct IpoCurve;
+struct Main;
+struct SpaceIpo;
 
 class KX_BlenderSceneConverter : public KX_ISceneConverter
 {
@@ -62,14 +65,20 @@ class KX_BlenderSceneConverter : public KX_ISceneConverter
        
        GEN_Map<CHashedPtr,BL_InterpolatorList*> m_map_blender_to_gameipolist;
        
-       struct Main*                    m_maggie;
+       Main*                                   m_maggie;
+       SpaceIpo*                               m_sipo;
+
        STR_String                              m_newfilename;
        class KX_KetsjiEngine*  m_ketsjiEngine;
        bool                                    m_alwaysUseExpandFraming;
        
+       void localDel_ipoCurve ( IpoCurve * icu ,struct SpaceIpo*       sipo);
+       struct Ipo* findIpoForName(char* objName);
+
 public:
        KX_BlenderSceneConverter(
-               struct Main* maggie,
+               Main* maggie,
+               SpaceIpo *sipo,
                class KX_KetsjiEngine* engine
        );
 
index 7316c62..0986b8c 100644 (file)
@@ -185,7 +185,7 @@ bool GPC_Engine::StartKetsji(void)
        m_portal = new KetsjiPortal(ketsjieng);
        m_portal->setSecurity(psl_Highest);
                
-       KX_ISceneConverter *sceneconverter = new KX_BlenderSceneConverter(G.main, ketsjieng);
+       KX_ISceneConverter *sceneconverter = new KX_BlenderSceneConverter(&G, ketsjieng);
                
        m_portal->Enter(
                        startSceneName,
index 52bee8e..b1c4a4d 100644 (file)
@@ -107,9 +107,9 @@ static void frameTimerProc(GHOST_ITimerTask* task, GHOST_TUns64 time);
 static GHOST_ISystem* fSystem = 0;
 static const int kTimerFreq = 10;
 
-GPG_Application::GPG_Application(GHOST_ISystem* system, struct Main *maggie, STR_String startSceneName)
+GPG_Application::GPG_Application(GHOST_ISystem* system, struct Mainmaggie, STR_String startSceneName)
        : m_startSceneName(startSceneName), 
-         m_maggie(maggie), 
+         m_maggie(maggie),
          m_exitRequested(0),
          m_system(system), 
          m_mainWindow(0), 
@@ -141,7 +141,7 @@ GPG_Application::~GPG_Application(void)
 
 
 
-bool GPG_Application::SetGameEngineData(struct Main *maggie, STR_String startSceneName)
+bool GPG_Application::SetGameEngineData(struct Mainmaggie, STR_String startSceneName)
 {
        bool result = false;
 
@@ -598,7 +598,7 @@ bool GPG_Application::startEngine(void)
        */
        
        // create a scene converter, create and convert the stratingscene
-       m_sceneconverter = new KX_BlenderSceneConverter(m_maggie, m_ketsjiengine);
+       m_sceneconverter = new KX_BlenderSceneConverter(m_maggie,0, m_ketsjiengine);
        if (m_sceneconverter)
        {
                STR_String startscenename = m_startSceneName.Ptr();
index 183ca43..2724b5a 100644 (file)
@@ -57,10 +57,10 @@ struct Main;
 class GPG_Application : public GHOST_IEventConsumer
 {
 public:
-       GPG_Application(GHOST_ISystem* system, struct Main *maggie, STR_String startSceneName);
+       GPG_Application(GHOST_ISystem* system, struct Mainmaggie, STR_String startSceneName);
        ~GPG_Application(void);
 
-                       bool SetGameEngineData(struct Main *maggie, STR_String startSceneName);
+                       bool SetGameEngineData(struct Main* maggie,STR_String startSceneName);
                        bool startWindow(STR_String& title, int windowLeft, int windowTop, int windowWidth, int windowHeight,
                        const bool stereoVisual, const int stereoMode);
                        bool startFullScreen(int width, int height, int bpp, int frequency, const bool stereoVisual, const int stereoMode);
index b5aea65..e9a6c24 100644 (file)
@@ -866,7 +866,7 @@ void        KX_ConvertBulletObject( class   KX_GameObject* gameobj,
        assert(env);
        
 
-       bool dyna = false;
+       bool isbulletdyna = false;
        CcdConstructionInfo ci;
        class PHY_IMotionState* motionstate = new KX_MotionState(gameobj->GetSGNode());
 
@@ -874,7 +874,8 @@ void        KX_ConvertBulletObject( class   KX_GameObject* gameobj,
        ci.m_gravity = SimdVector3(0,0,0);
        ci.m_localInertiaTensor =SimdVector3(0,0,0);
        ci.m_mass = objprop->m_dyna ? shapeprops->m_mass : 0.f;
-       
+       isbulletdyna = objprop->m_dyna;
+
        ci.m_localInertiaTensor = SimdVector3(ci.m_mass/3.f,ci.m_mass/3.f,ci.m_mass/3.f);
        
        SimdTransform trans;
@@ -1008,11 +1009,11 @@ void    KX_ConvertBulletObject( class   KX_GameObject* gameobj,
        //need a bit of damping, else system doesn't behave well
        
 
-       KX_BulletPhysicsController* physicscontroller = new KX_BulletPhysicsController(ci,dyna);
+       KX_BulletPhysicsController* physicscontroller = new KX_BulletPhysicsController(ci,isbulletdyna);
        env->addCcdPhysicsController( physicscontroller);
 
        
-       gameobj->SetPhysicsController(physicscontroller,dyna);
+       gameobj->SetPhysicsController(physicscontroller,isbulletdyna);
        physicscontroller->setNewClientInfo(gameobj->getClientInfo());          
        bool isActor = objprop->m_isactor;
        gameobj->getClientInfo()->m_type = (isActor ? KX_ClientObjectInfo::ACTOR : KX_ClientObjectInfo::STATIC);
index 24c3497..3c2f3e0 100644 (file)
@@ -120,6 +120,7 @@ KX_KetsjiEngine::KX_KetsjiEngine(KX_ISystem* system)
        m_bInitialized(false),
        m_activecam(0),
        m_bFixedTime(false),
+       m_game2ipo(false),
        
        m_firstframe(true),
        
@@ -397,7 +398,10 @@ void KX_KetsjiEngine::NextFrame()
                                scene->GetPhysicsEnvironment()->proceedDeltaTime(localtime,realDeltaTime);
                                m_previoustime = curtime;
 
-                               m_sceneconverter->WritePhysicsObjectToAnimationIpo(m_currentFrame++);
+                               if (m_game2ipo)
+                               {
+                                       m_sceneconverter->WritePhysicsObjectToAnimationIpo(m_currentFrame++);
+                               }
 
                        } // suspended
        
@@ -1197,6 +1201,11 @@ void KX_KetsjiEngine::SetUseFixedTime(bool bUseFixedTime)
 }
 
 
+void   KX_KetsjiEngine::SetGame2IpoMode(bool game2ipo,int startFrame)
+{
+       m_game2ipo = game2ipo;
+       m_currentFrame = startFrame;
+}
 
 bool KX_KetsjiEngine::GetUseFixedTime(void) const
 {
index 5af694f..7f0b4fd 100644 (file)
@@ -155,6 +155,9 @@ private:
 
        bool                                    m_show_debug_properties;
 
+       /** record physics into keyframes */
+       bool                                    m_game2ipo;
+
        /** Hide cursor every frame? */
        bool                                    m_hideCursor;
 
@@ -189,6 +192,8 @@ public:
        void                    SetRasterizer(RAS_IRasterizer* rasterizer);
        void                    SetPythonDictionary(PyObject* pythondictionary);
        void                    SetSceneConverter(KX_ISceneConverter* sceneconverter);
+       void                    SetGame2IpoMode(bool game2ipo,int startFrame);
+
 
        void                    NextFrame();
        void                    Render();
index 2c4d028..0b16ff1 100644 (file)
@@ -107,7 +107,7 @@ MT_Matrix3x3 EulToMat3(float *eul)
 
 
 /* old function from Blender */
-void Mat3ToEul(MT_Matrix3x3 mat, float *eul)
+void Mat3ToEulOld(MT_Matrix3x3 mat, float *eul)
 {
        MT_Scalar cy;
        
@@ -154,8 +154,8 @@ MT_Matrix3x3 matrix3x3_interpol(MT_Matrix3x3 oldmat, MT_Matrix3x3 mat, int m_tim
 {
        float eul[3], oldeul[3];        
 
-       Mat3ToEul(oldmat, oldeul);
-       Mat3ToEul(mat, eul);
+       Mat3ToEulOld(oldmat, oldeul);
+       Mat3ToEulOld(mat, eul);
        compatible_eulFast(eul, oldeul);
        
        eul[0]= (m_time*oldeul[0] + eul[0])/(1.0+m_time);