Applied patch #18446, to do versions on damping
authorErwin Coumans <blender@erwincoumans.com>
Sun, 29 Mar 2009 19:54:05 +0000 (19:54 +0000)
committerErwin Coumans <blender@erwincoumans.com>
Sun, 29 Mar 2009 19:54:05 +0000 (19:54 +0000)
Re-enable vertex welding, only for soft bodies. They require it. Future versions could expose such vertexWeldingThreshold.

source/blender/blenkernel/BKE_blender.h
source/blender/blenloader/intern/readfile.c
source/blender/src/buttons_logic.c
source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp
source/gameengine/Physics/Bullet/CcdPhysicsController.cpp
source/gameengine/Physics/Bullet/CcdPhysicsController.h

index a6334e665d1076a438ed9853f473e20175599520..db6d4762b17f7a01a6a33e65e2c1e7461eedca05 100644 (file)
@@ -41,7 +41,7 @@ struct ListBase;
 struct MemFile;
 
 #define BLENDER_VERSION                        248
-#define BLENDER_SUBVERSION             2
+#define BLENDER_SUBVERSION             3
 
 #define BLENDER_MINVERSION             245
 #define BLENDER_MINSUBVERSION  15
index 2c6a2f2bb3a8ecf7c3d66aa5bf37205d07b4a604..c2eaae011c87d59dcf1c1ca4a7c87a93770d45ff 100644 (file)
@@ -8024,6 +8024,16 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
                        sce->toolsettings->skgen_retarget_roll = SK_RETARGET_ROLL_VIEW;
                }
        }
+
+       if (main->versionfile < 248 || (main->versionfile == 248 && main->subversionfile < 3)) {
+               Object *ob;
+
+               /* Adjustments needed after Bullets update */
+               for(ob = main->object.first; ob; ob= ob->id.next) {
+                       ob->damping *= 0.635f;
+                       ob->rdamping = 0.1 + (0.59f * ob->rdamping);
+               }
+       }
        
        /* WATCH IT!!!: pointers from libdata have not been converted yet here! */
        /* WATCH IT 2!: Userdef struct init has to be in src/usiblender.c! */
index 01520061a198618c4e85817ac65e8075ead36cb2..cf6d29da0d3b9c736ac87c4bb00771efbedac318 100644 (file)
@@ -3122,30 +3122,32 @@ static uiBlock *advanced_bullet_menu(void *arg_ob)
                                        "Collision margin");
                        yco -= 20;
 
-                       uiDefButBitI(block, TOG, OB_LOCK_RIGID_BODY_X_AXIS, 0, "Lock X Axis", 
-                               xco, yco, 180, 19, &ob->gameflag2, 0, 0, 0, 0, 
-                               "Disable simulation of linear motion along the X axis");
-                       uiDefButBitI(block, TOG, OB_LOCK_RIGID_BODY_X_ROT_AXIS, 0, "Lock X Rot Xxis", 
-                               xco+=180, yco, 180, 19, &ob->gameflag2, 0, 0, 0, 0, 
-                               "Disable simulation of angular motion along the X axis");
-                       yco -= 20;
-                       xco=0;
-                       uiDefButBitI(block, TOG, OB_LOCK_RIGID_BODY_Y_AXIS, 0, "Lock Y Axis", 
-                               xco, yco, 180, 19, &ob->gameflag2, 0, 0, 0, 0, 
-                               "Disable simulation of linear motion along the Y axis");
-                       uiDefButBitI(block, TOG, OB_LOCK_RIGID_BODY_Y_ROT_AXIS, 0, "Lock Y Rot Axis", 
-                               xco+=180, yco, 180, 19, &ob->gameflag2, 0, 0, 0, 0, 
-                               "Disable simulation of angular motion along the Y axis");
-
-                       yco -= 20;
-                       xco=0;
-                       uiDefButBitI(block, TOG, OB_LOCK_RIGID_BODY_Z_AXIS, 0, "Lock Z Axis", 
-                               xco, yco, 180, 19, &ob->gameflag2, 0, 0, 0, 0, 
-                               "Disable simulation of linear motion along the Z axis");
-                       uiDefButBitI(block, TOG, OB_LOCK_RIGID_BODY_Z_ROT_AXIS, 0, "Lock Z Rot Axis", 
-                               xco+=180, yco, 180, 19, &ob->gameflag2, 0, 0, 0, 0, 
-                               "Disable simulation of angular motion along the Z axis");
-
+                       if (ob->gameflag & OB_RIGID_BODY)
+                       {
+                               uiDefButBitI(block, TOG, OB_LOCK_RIGID_BODY_X_AXIS, 0, "Lock X Axis", 
+                                       xco, yco, 180, 19, &ob->gameflag2, 0, 0, 0, 0, 
+                                       "Disable simulation of linear motion along the X axis");
+                               uiDefButBitI(block, TOG, OB_LOCK_RIGID_BODY_X_ROT_AXIS, 0, "Lock X Rot Xxis", 
+                                       xco+=180, yco, 180, 19, &ob->gameflag2, 0, 0, 0, 0, 
+                                       "Disable simulation of angular motion along the X axis");
+                               yco -= 20;
+                               xco=0;
+                               uiDefButBitI(block, TOG, OB_LOCK_RIGID_BODY_Y_AXIS, 0, "Lock Y Axis", 
+                                       xco, yco, 180, 19, &ob->gameflag2, 0, 0, 0, 0, 
+                                       "Disable simulation of linear motion along the Y axis");
+                               uiDefButBitI(block, TOG, OB_LOCK_RIGID_BODY_Y_ROT_AXIS, 0, "Lock Y Rot Axis", 
+                                       xco+=180, yco, 180, 19, &ob->gameflag2, 0, 0, 0, 0, 
+                                       "Disable simulation of angular motion along the Y axis");
+
+                               yco -= 20;
+                               xco=0;
+                               uiDefButBitI(block, TOG, OB_LOCK_RIGID_BODY_Z_AXIS, 0, "Lock Z Axis", 
+                                       xco, yco, 180, 19, &ob->gameflag2, 0, 0, 0, 0, 
+                                       "Disable simulation of linear motion along the Z axis");
+                               uiDefButBitI(block, TOG, OB_LOCK_RIGID_BODY_Z_ROT_AXIS, 0, "Lock Z Rot Axis", 
+                                       xco+=180, yco, 180, 19, &ob->gameflag2, 0, 0, 0, 0, 
+                                       "Disable simulation of angular motion along the Z axis");
+                       }
                        /*
                        uiDefButBitI(block, TOG, OB_BSB_COL_CL_RS, 0, "Cluster Collision RS", 
                                xco, yco, 180, 19, &ob->bsoft->collisionflags, 0, 0, 0, 0, 
index 8002da6b8d4e942fcf534a5ce069ca5a6e373740..03149859f4d2d40c782b87ae7e308b0cada3be15 100644 (file)
@@ -882,10 +882,9 @@ void       KX_ConvertBulletObject( class   KX_GameObject* gameobj,
                                        shapeInfo->SetMesh(meshobj, false,false);
                                }
 
-                               // Note! since 2.48a bullet mesh conversion has been sped up not to remove doubles
-                               // if softbody needs this there should be some post processing filter for softbody meshes.
+                               // Soft bodies require welding. Only avoid remove doubles for non-soft bodies!
                                if (objprop->m_softbody)
-                                       shapeInfo->setVertexWeldingThreshold(0.01f); //todo: expose this to the UI
+                                       shapeInfo->setVertexWeldingThreshold1(0.01f); //todo: expose this to the UI
 
                                bm = shapeInfo->CreateBulletShape();
                                //no moving concave meshes, so don't bother calculating inertia
index 35602b4095a85c2980914716845e917341258f14..cc6be9a7ae3ab250fe7bfe550c347f344237ebd6 100644 (file)
@@ -1569,14 +1569,31 @@ btCollisionShape* CcdShapeConstructionInfo::CreateBulletShape()
                        if (!m_unscaledShape)
                        {
                        
-                               btTriangleIndexVertexArray* indexVertexArrays = new btTriangleIndexVertexArray(
-                                               m_polygonIndexArray.size(),
-                                               &m_triFaceArray[0],
-                                               3*sizeof(int),
-                                               m_vertexArray.size(),
-                                               (btScalar*) &m_vertexArray[0].x(),
-                                               sizeof(btVector3)
-                               );
+                               btTriangleIndexVertexArray* indexVertexArrays = 0;
+
+                               ///enable welding, only for the objects that need it (such as soft bodies)
+                               if (0.f != m_weldingThreshold1)
+                               {
+                                       btTriangleMesh* collisionMeshData = new btTriangleMesh(true,false);
+                                       collisionMeshData->m_weldingThreshold = m_weldingThreshold1;
+                                       bool removeDuplicateVertices=true;
+                                       // m_vertexArray is necessarily a multiple of 3
+                                       for (int i=0;i<m_vertexArray.size(); i+=3 )
+                                       {
+                                               collisionMeshData->addTriangle(m_vertexArray[i+2],m_vertexArray[i+1],m_vertexArray[i],removeDuplicateVertices);
+                                       }
+                                       indexVertexArrays = collisionMeshData;
+
+                               } else
+                               {
+                                       indexVertexArrays = new btTriangleIndexVertexArray(
+                                                       m_polygonIndexArray.size(),
+                                                       &m_triFaceArray[0],
+                                                       3*sizeof(int),
+                                                       m_vertexArray.size(),
+                                                       (btScalar*) &m_vertexArray[0].x(),
+                                                       sizeof(btVector3));
+                               }
                                
                                // this shape will be shared and not deleted until shapeInfo is deleted
                                m_unscaledShape = new btBvhTriangleMeshShape( indexVertexArrays, true );
index 67dd82db5cc17add818a4d66b7829d46afc19ded..510454a7b630b61c41e0913dd3210fbbb74430fc 100644 (file)
@@ -72,7 +72,7 @@ public:
                m_meshObject(NULL),
                m_unscaledShape(NULL),
                m_useGimpact(false),
-               m_weldingThreshold(0.f),
+               m_weldingThreshold1(0.f),
                m_shapeProxy(NULL)
        {
                m_childTrans.setIdentity();
@@ -171,13 +171,13 @@ public:
        std::vector<int>                m_triFaceArray; // Contains an array of triplets of face indicies
                                                                                        // quads turn into 2 tris
 
-       void    setVertexWeldingThreshold(float threshold)
+       void    setVertexWeldingThreshold1(float threshold)
        {
-               m_weldingThreshold  = threshold;
+               m_weldingThreshold1  = threshold;
        }
-       float   getVertexWeldingThreshold() const
+       float   getVertexWeldingThreshold1() const
        {
-               return m_weldingThreshold;
+               return m_weldingThreshold1;
        }
 protected:
        static std::map<RAS_MeshObject*, CcdShapeConstructionInfo*> m_meshShapeMap;
@@ -188,7 +188,7 @@ protected:
                                                                                        // the actual shape is of type btScaledBvhTriangleMeshShape
        std::vector<CcdShapeConstructionInfo*> m_shapeArray;    // for compound shapes
        bool    m_useGimpact; //use gimpact for concave dynamic/moving collision detection
-       float   m_weldingThreshold;     //welding closeby vertices together can improve softbody stability etc. // Not used at the moment, maybe remove?
+       float   m_weldingThreshold1;    //welding closeby vertices together can improve softbody stability etc.
        CcdShapeConstructionInfo* m_shapeProxy; // only used for PHY_SHAPE_PROXY, pointer to actual shape info
 };