← Back to branch summary

~diresu/blender/blender-command-port

« back to all changes in this revision

Viewing changes to source/gameengine/Ketsji/KX_Scene.cpp

  • Committer: Dietrich Bollmann
  • Date: 2009-07-26 14:27:44 UTC
  • mfrom: (184.1.1008)
  • Revision ID: dietrich@formgames.org-20090726142744-75hivjratygfz7q3
Update to state of blender repository from 2009-07-26 revision 21911 (launchpad: 1192).

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/gameengine/Ketsji/KX_Scene.cpp
1
1
/*
2
 
 * $Id: KX_Scene.cpp 20352 2009-05-23 04:56:37Z campbellbarton $
 
2
 * $Id: KX_Scene.cpp 21910 2009-07-26 01:32:37Z campbellbarton $
3
3
 *
4
4
 * ***** BEGIN GPL LICENSE BLOCK *****
5
5
 *
207
207
        m_rootnode = NULL;
208
208
 
209
209
        m_bucketmanager=new RAS_BucketManager();
210
 
 
211
 
        m_canvasDesignWidth = 0;
212
 
        m_canvasDesignHeight = 0;
213
210
        
214
211
        m_attr_dict = PyDict_New(); /* new ref */
215
212
}
1020
1017
 
1021
1018
 
1022
1019
 
1023
 
void KX_Scene::ReplaceMesh(class CValue* obj,void* meshobj)
 
1020
void KX_Scene::ReplaceMesh(class CValue* obj,void* meshobj, bool use_gfx, bool use_phys)
1024
1021
{
1025
1022
        KX_GameObject* gameobj = static_cast<KX_GameObject*>(obj);
1026
1023
        RAS_MeshObject* mesh = static_cast<RAS_MeshObject*>(meshobj);
1027
1024
 
1028
 
        if(!gameobj || !mesh)
1029
 
        {
1030
 
                std::cout << "warning: invalid object, mesh will not be replaced" << std::endl;
 
1025
        if(!gameobj) {
 
1026
                std::cout << "KX_Scene::ReplaceMesh Warning: invalid object, doing nothing" << std::endl;
1031
1027
                return;
1032
1028
        }
1033
 
 
1034
 
        gameobj->RemoveMeshes();
1035
 
        gameobj->AddMesh(mesh);
1036
1029
        
1037
 
        if (gameobj->m_isDeformable)
1038
 
        {
1039
 
                BL_DeformableGameObject* newobj = static_cast<BL_DeformableGameObject*>( gameobj );
 
1030
        if(use_gfx && mesh != NULL)
 
1031
        {               
 
1032
                gameobj->RemoveMeshes();
 
1033
                gameobj->AddMesh(mesh);
1040
1034
                
1041
 
                if (newobj->GetDeformer())
1042
 
                {
1043
 
                        delete newobj->GetDeformer();
1044
 
                        newobj->SetDeformer(NULL);
1045
 
                }
1046
 
 
1047
 
                if (mesh->IsDeformed())
1048
 
                {
1049
 
                        // we must create a new deformer but which one?
1050
 
                        KX_GameObject* parentobj = newobj->GetParent();
1051
 
                        // this always return the original game object (also for replicate)
1052
 
                        Object* blendobj = newobj->GetBlenderObject();
1053
 
                        // object that owns the new mesh
1054
 
                        Object* oldblendobj = static_cast<struct Object*>(m_logicmgr->FindBlendObjByGameMeshName(mesh->GetName()));
1055
 
                        Mesh* blendmesh = mesh->GetMesh();
1056
 
 
1057
 
                        bool bHasModifier = BL_ModifierDeformer::HasCompatibleDeformer(blendobj);
1058
 
                        bool bHasShapeKey = blendmesh->key != NULL && blendmesh->key->type==KEY_RELATIVE;
1059
 
                        bool bHasDvert = blendmesh->dvert != NULL;
1060
 
                        bool bHasArmature = 
1061
 
                                parentobj &&                                                            // current parent is armature
1062
 
                                parentobj->GetGameObjectType() == SCA_IObject::OBJ_ARMATURE &&
1063
 
                                oldblendobj &&                                                          // needed for mesh deform
1064
 
                                blendobj->parent &&                                                     // original object had armature (not sure this test is needed)
1065
 
                                blendobj->parent->type == OB_ARMATURE && 
1066
 
                                blendobj->partype==PARSKEL && 
1067
 
                                blendmesh->dvert!=NULL;                                         // mesh has vertex group
1068
 
                        bool releaseParent = true;
1069
 
 
1070
 
                        
1071
 
                        if (oldblendobj==NULL) {
1072
 
                                std::cout << "warning: ReplaceMesh() new mesh is not used in an object from the current scene, you will get incorrect behavior" << std::endl;
1073
 
                                bHasShapeKey= bHasDvert= bHasArmature=bHasModifier= false;
1074
 
                        }
1075
 
                        
1076
 
                        if (bHasModifier)
1077
 
                        {
1078
 
                                BL_ModifierDeformer* modifierDeformer;
1079
 
                                if (bHasShapeKey || bHasArmature)
1080
 
                                {
1081
 
                                        modifierDeformer = new BL_ModifierDeformer(
1082
 
                                                newobj,
1083
 
                                                oldblendobj, blendobj,
1084
 
                                                static_cast<BL_SkinMeshObject*>(mesh),
1085
 
                                                true,
1086
 
                                                static_cast<BL_ArmatureObject*>( parentobj )
1087
 
                                        );
1088
 
                                        releaseParent= false;
1089
 
                                        modifierDeformer->LoadShapeDrivers(blendobj->parent);
1090
 
                                }
1091
 
                                else
1092
 
                                {
1093
 
                                        modifierDeformer = new BL_ModifierDeformer(
1094
 
                                                newobj,
1095
 
                                                oldblendobj, blendobj,
1096
 
                                                static_cast<BL_SkinMeshObject*>(mesh),
1097
 
                                                false,
1098
 
                                                NULL
1099
 
                                        );
1100
 
                                }
1101
 
                                newobj->SetDeformer(modifierDeformer);
1102
 
                        } 
1103
 
                        else    if (bHasShapeKey)
1104
 
                        {
1105
 
                                BL_ShapeDeformer* shapeDeformer;
1106
 
                                if (bHasArmature) 
1107
 
                                {
1108
 
                                        shapeDeformer = new BL_ShapeDeformer(
1109
 
                                                newobj,
1110
 
                                                oldblendobj, blendobj,
1111
 
                                                static_cast<BL_SkinMeshObject*>(mesh),
1112
 
                                                true,
1113
 
                                                true,
1114
 
                                                static_cast<BL_ArmatureObject*>( parentobj )
1115
 
                                        );
1116
 
                                        releaseParent= false;
1117
 
                                        shapeDeformer->LoadShapeDrivers(blendobj->parent);
1118
 
                                }
1119
 
                                else
1120
 
                                {
1121
 
                                        shapeDeformer = new BL_ShapeDeformer(
1122
 
                                                newobj,
1123
 
                                                oldblendobj, blendobj,
1124
 
                                                static_cast<BL_SkinMeshObject*>(mesh),
1125
 
                                                false,
1126
 
                                                true,
1127
 
                                                NULL
1128
 
                                        );
1129
 
                                }
1130
 
                                newobj->SetDeformer( shapeDeformer);
1131
 
                        }
1132
 
                        else if (bHasArmature) 
1133
 
                        {
1134
 
                                BL_SkinDeformer* skinDeformer = new BL_SkinDeformer(
1135
 
                                        newobj,
1136
 
                                        oldblendobj, blendobj,
1137
 
                                        static_cast<BL_SkinMeshObject*>(mesh),
1138
 
                                        true,
1139
 
                                        true,
1140
 
                                        static_cast<BL_ArmatureObject*>( parentobj )
1141
 
                                );
1142
 
                                releaseParent= false;
1143
 
                                newobj->SetDeformer(skinDeformer);
1144
 
                        }
1145
 
                        else if (bHasDvert)
1146
 
                        {
1147
 
                                BL_MeshDeformer* meshdeformer = new BL_MeshDeformer(
1148
 
                                        newobj, oldblendobj, static_cast<BL_SkinMeshObject*>(mesh)
1149
 
                                );
1150
 
                                newobj->SetDeformer(meshdeformer);
1151
 
                        }
1152
 
 
1153
 
                        // release parent reference if its not being used 
1154
 
                        if( releaseParent && parentobj)
1155
 
                                parentobj->Release();
1156
 
                }
1157
 
        }
1158
 
 
1159
 
        gameobj->AddMeshUser();
 
1035
                if (gameobj->m_isDeformable)
 
1036
                {
 
1037
                        BL_DeformableGameObject* newobj = static_cast<BL_DeformableGameObject*>( gameobj );
 
1038
                        
 
1039
                        if (newobj->GetDeformer())
 
1040
                        {
 
1041
                                delete newobj->GetDeformer();
 
1042
                                newobj->SetDeformer(NULL);
 
1043
                        }
 
1044
        
 
1045
                        if (mesh->IsDeformed())
 
1046
                        {
 
1047
                                // we must create a new deformer but which one?
 
1048
                                KX_GameObject* parentobj = newobj->GetParent();
 
1049
                                // this always return the original game object (also for replicate)
 
1050
                                Object* blendobj = newobj->GetBlenderObject();
 
1051
                                // object that owns the new mesh
 
1052
                                Object* oldblendobj = static_cast<struct Object*>(m_logicmgr->FindBlendObjByGameMeshName(mesh->GetName()));
 
1053
                                Mesh* blendmesh = mesh->GetMesh();
 
1054
        
 
1055
                                bool bHasModifier = BL_ModifierDeformer::HasCompatibleDeformer(blendobj);
 
1056
                                bool bHasShapeKey = blendmesh->key != NULL && blendmesh->key->type==KEY_RELATIVE;
 
1057
                                bool bHasDvert = blendmesh->dvert != NULL;
 
1058
                                bool bHasArmature = 
 
1059
                                        parentobj &&                                                            // current parent is armature
 
1060
                                        parentobj->GetGameObjectType() == SCA_IObject::OBJ_ARMATURE &&
 
1061
                                        oldblendobj &&                                                          // needed for mesh deform
 
1062
                                        blendobj->parent &&                                                     // original object had armature (not sure this test is needed)
 
1063
                                        blendobj->parent->type == OB_ARMATURE && 
 
1064
                                        blendobj->partype==PARSKEL && 
 
1065
                                        blendmesh->dvert!=NULL;                                         // mesh has vertex group
 
1066
                                bool releaseParent = true;
 
1067
        
 
1068
                                
 
1069
                                if (oldblendobj==NULL) {
 
1070
                                        std::cout << "warning: ReplaceMesh() new mesh is not used in an object from the current scene, you will get incorrect behavior" << std::endl;
 
1071
                                        bHasShapeKey= bHasDvert= bHasArmature=bHasModifier= false;
 
1072
                                }
 
1073
                                
 
1074
                                if (bHasModifier)
 
1075
                                {
 
1076
                                        BL_ModifierDeformer* modifierDeformer;
 
1077
                                        if (bHasShapeKey || bHasArmature)
 
1078
                                        {
 
1079
                                                modifierDeformer = new BL_ModifierDeformer(
 
1080
                                                        newobj,
 
1081
                                                        oldblendobj, blendobj,
 
1082
                                                        static_cast<BL_SkinMeshObject*>(mesh),
 
1083
                                                        true,
 
1084
                                                        static_cast<BL_ArmatureObject*>( parentobj )
 
1085
                                                );
 
1086
                                                releaseParent= false;
 
1087
                                                modifierDeformer->LoadShapeDrivers(blendobj->parent);
 
1088
                                        }
 
1089
                                        else
 
1090
                                        {
 
1091
                                                modifierDeformer = new BL_ModifierDeformer(
 
1092
                                                        newobj,
 
1093
                                                        oldblendobj, blendobj,
 
1094
                                                        static_cast<BL_SkinMeshObject*>(mesh),
 
1095
                                                        false,
 
1096
                                                        NULL
 
1097
                                                );
 
1098
                                        }
 
1099
                                        newobj->SetDeformer(modifierDeformer);
 
1100
                                } 
 
1101
                                else    if (bHasShapeKey)
 
1102
                                {
 
1103
                                        BL_ShapeDeformer* shapeDeformer;
 
1104
                                        if (bHasArmature) 
 
1105
                                        {
 
1106
                                                shapeDeformer = new BL_ShapeDeformer(
 
1107
                                                        newobj,
 
1108
                                                        oldblendobj, blendobj,
 
1109
                                                        static_cast<BL_SkinMeshObject*>(mesh),
 
1110
                                                        true,
 
1111
                                                        true,
 
1112
                                                        static_cast<BL_ArmatureObject*>( parentobj )
 
1113
                                                );
 
1114
                                                releaseParent= false;
 
1115
                                                shapeDeformer->LoadShapeDrivers(blendobj->parent);
 
1116
                                        }
 
1117
                                        else
 
1118
                                        {
 
1119
                                                shapeDeformer = new BL_ShapeDeformer(
 
1120
                                                        newobj,
 
1121
                                                        oldblendobj, blendobj,
 
1122
                                                        static_cast<BL_SkinMeshObject*>(mesh),
 
1123
                                                        false,
 
1124
                                                        true,
 
1125
                                                        NULL
 
1126
                                                );
 
1127
                                        }
 
1128
                                        newobj->SetDeformer( shapeDeformer);
 
1129
                                }
 
1130
                                else if (bHasArmature) 
 
1131
                                {
 
1132
                                        BL_SkinDeformer* skinDeformer = new BL_SkinDeformer(
 
1133
                                                newobj,
 
1134
                                                oldblendobj, blendobj,
 
1135
                                                static_cast<BL_SkinMeshObject*>(mesh),
 
1136
                                                true,
 
1137
                                                true,
 
1138
                                                static_cast<BL_ArmatureObject*>( parentobj )
 
1139
                                        );
 
1140
                                        releaseParent= false;
 
1141
                                        newobj->SetDeformer(skinDeformer);
 
1142
                                }
 
1143
                                else if (bHasDvert)
 
1144
                                {
 
1145
                                        BL_MeshDeformer* meshdeformer = new BL_MeshDeformer(
 
1146
                                                newobj, oldblendobj, static_cast<BL_SkinMeshObject*>(mesh)
 
1147
                                        );
 
1148
                                        newobj->SetDeformer(meshdeformer);
 
1149
                                }
 
1150
        
 
1151
                                // release parent reference if its not being used 
 
1152
                                if( releaseParent && parentobj)
 
1153
                                        parentobj->Release();
 
1154
                        }
 
1155
                }
 
1156
 
 
1157
                gameobj->AddMeshUser();
 
1158
        }
 
1159
        
 
1160
        if(use_phys) { /* update the new assigned mesh with the physics mesh */
 
1161
                KX_ReInstanceBulletShapeFromMesh(gameobj, NULL, use_gfx?NULL:mesh);
 
1162
        }
1160
1163
}
1161
1164
 
1162
1165
KX_Camera* KX_Scene::FindCamera(KX_Camera* cam)
1847
1850
        // the object is added to the scene so we dont want python to own a reference
1848
1851
        replica->Release();
1849
1852
        return replica->GetProxy();
1850
 
}
 
 
b'\\ No newline at end of file'
 
1853
}