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 000878d5b6a3daaebf7b5075e7a7ca126f32b983..5ea8b3983638e6aacf89407cb31a1b436ed6d62f 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 163fc716b708e509cbc08b1a9045963402f805b7..04371fbb0d0691b7f8d368ec0d723b7c6594491d 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 6d984f55e71575a087ebb5e0aa3f7f9d58b3262a..d7944ab3d93c6f8f6d1b1020b8baf86caa2c68e8 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 ac8fd8081fdcaf91c5ce814f024b3fc03e0eb884..e9bfc2a3e781606bff3ee94677f2b7785c1dcb04 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 ca908f86344b2b8236855c8e6ae667b1d9904297..2948c45de71f40a82b57b8b4ce0a97d5a53840c4 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 49e7c94743147dfb7ffc07f5bb6430d550d6c16f..f6136d5268485e954f7a65eb6b0bc34a921672a8 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 b7942fd91a005fde773e48449f89756f96c307b5..b42cf0122fee61d256f9667b0961ea9c9fbce73b 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 d4048ce3ed29cbde6d5cfa38cede6393e2b09347..dd7c31abee7a8ef2d409e7c60d5729a7c17d76e0 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 7316c62f88ee367593c02732bd1e2fffa4256faf..0986b8cee55fd38296dff39da22139c441bfccd8 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 52bee8e81dd7ae50e5ca11a1c0e9123bb6f8981e..b1c4a4d6d2560c43d93f2a0332fa2408ba6a7db8 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 183ca4318a9d5c82fba6ca1a9a982465fcdcc172..2724b5ac2e36333ca590ddc4086d87fa72e765b9 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 b5aea65cfe4ac919fb6fb4cbe7b8173ed98c36f9..e9a6c2442b07b2d9f70f8fd4b6948e53d2da429f 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 24c34976ce8423fc034bc9f37658629b22d80153..3c2f3e04aac8b68e6d140dce771af1b09713b5d7 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 5af694f5f1ffdf9d2b1fbc9e7d1f4c16dd749d3a..7f0b4fd59f9523c61697c6e1fd36358f2f2355a6 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 2c4d02854ade14d98d67beb5bfce16dd54eba090..0b16ff14f720b616df32baac4de7593865d90e3c 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);