/* * ***** BEGIN GPL LICENSE BLOCK ***** * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software Foundation, * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. * All rights reserved. * * The Original Code is: all of this file. * * Contributor(s): none yet. * * ***** END GPL LICENSE BLOCK ***** * Convert blender data to ketsji */ /** \file gameengine/Converter/BL_BlenderDataConversion.cpp * \ingroup bgeconv */ #ifdef _MSC_VER # pragma warning (disable:4786) #endif /* Since threaded object update we've disabled in-place * curve evaluation (in cases when applying curve modifier * with target curve non-evaluated yet). * * This requires game engine to take care of DAG and object * evaluation (currently it's designed to export only objects * it able to render). * * This workaround will make sure that curve_cache for curves * is up-to-date. */ #define THREADED_DAG_WORKAROUND #include #include #include #include "BL_BlenderDataConversion.h" #include "KX_BlenderScalarInterpolator.h" #include "RAS_IPolygonMaterial.h" // Expressions #include "ListValue.h" #include "IntValue.h" // Collision & Fuzzics LTD #include "PHY_Pro.h" #include "PHY_IPhysicsEnvironment.h" #include "PHY_DynamicTypes.h" #include "KX_Scene.h" #include "KX_GameObject.h" #include "RAS_FramingManager.h" #include "RAS_MeshObject.h" #include "RAS_IRasterizer.h" #include "RAS_ILightObject.h" #include "KX_ConvertActuators.h" #include "KX_ConvertControllers.h" #include "KX_ConvertSensors.h" #include "SCA_LogicManager.h" #include "SCA_EventManager.h" #include "SCA_TimeEventManager.h" #include "KX_Light.h" #include "KX_Camera.h" #include "KX_ClientObjectInfo.h" #include "KX_EmptyObject.h" #include "KX_FontObject.h" #include "MT_Point3.h" #include "MT_Transform.h" #include "MT_MinMax.h" #include "SCA_IInputDevice.h" #include "RAS_TexMatrix.h" #include "RAS_ICanvas.h" #include "RAS_MaterialBucket.h" //#include "KX_BlenderPolyMaterial.h" #include "RAS_Polygon.h" #include "RAS_TexVert.h" #include "RAS_BucketManager.h" #include "BL_Material.h" #include "KX_BlenderMaterial.h" #include "BL_Texture.h" #include "DNA_action_types.h" #include "BKE_main.h" #include "BKE_global.h" #include "BKE_object.h" #include "BL_ModifierDeformer.h" #include "BL_ShapeDeformer.h" #include "BL_SkinDeformer.h" #include "BL_MeshDeformer.h" #include "KX_SoftBodyDeformer.h" //#include "BL_ArmatureController.h" #include "BLI_utildefines.h" #include "BLI_listbase.h" #include "BlenderWorldInfo.h" #include "KX_KetsjiEngine.h" #include "KX_BlenderSceneConverter.h" /* This little block needed for linking to Blender... */ #ifdef WIN32 #include "BLI_winstuff.h" #endif /* This list includes only data type definitions */ #include "DNA_object_types.h" #include "DNA_material_types.h" #include "DNA_texture_types.h" #include "DNA_image_types.h" #include "DNA_lamp_types.h" #include "DNA_group_types.h" #include "DNA_scene_types.h" #include "DNA_camera_types.h" #include "DNA_property_types.h" #include "DNA_text_types.h" #include "DNA_sensor_types.h" #include "DNA_controller_types.h" #include "DNA_actuator_types.h" #include "DNA_mesh_types.h" #include "DNA_meshdata_types.h" #include "DNA_view3d_types.h" #include "DNA_world_types.h" #include "DNA_sound_types.h" #include "DNA_key_types.h" #include "DNA_armature_types.h" #include "DNA_object_force.h" #include "MEM_guardedalloc.h" #include "BKE_key.h" #include "BKE_mesh.h" #include "MT_Point3.h" #include "BLI_math.h" extern "C" { #include "BKE_scene.h" #include "BKE_customdata.h" #include "BKE_cdderivedmesh.h" #include "BKE_DerivedMesh.h" #include "BKE_material.h" /* give_current_material */ #include "BKE_image.h" #include "IMB_imbuf_types.h" #include "BKE_displist.h" extern Material defmaterial; /* material.c */ } /* end of blender include block */ #include "KX_BlenderInputDevice.h" #include "KX_ConvertProperties.h" #include "KX_HashedPtr.h" #include "KX_ScalarInterpolator.h" #include "KX_IpoConvert.h" #include "BL_System.h" #include "SG_Node.h" #include "SG_BBox.h" #include "SG_Tree.h" #ifdef WITH_BULLET #include "CcdPhysicsEnvironment.h" #include "CcdGraphicController.h" #endif #include "KX_MotionState.h" // This file defines relationships between parents and children // in the game engine. #include "KX_SG_NodeRelationships.h" #include "KX_SG_BoneParentNodeRelationship.h" #include "BL_ArmatureObject.h" #include "BL_DeformableGameObject.h" #include "KX_NavMeshObject.h" #include "KX_ObstacleSimulation.h" #ifdef __cplusplus extern "C" { #endif //XXX void update_for_newframe(); //void BKE_scene_update_for_newframe(struct Scene *sce, unsigned int lay); //void do_all_data_ipos(void); #ifdef __cplusplus } #endif #include "BLI_threads.h" static bool default_light_mode = 0; static std::map create_translate_table() { std::map m; /* The reverse table. In order to not confuse ourselves, we */ /* immediately convert all events that come in to KX codes. */ m[LEFTMOUSE ] = SCA_IInputDevice::KX_LEFTMOUSE; m[MIDDLEMOUSE ] = SCA_IInputDevice::KX_MIDDLEMOUSE; m[RIGHTMOUSE ] = SCA_IInputDevice::KX_RIGHTMOUSE; m[WHEELUPMOUSE ] = SCA_IInputDevice::KX_WHEELUPMOUSE; m[WHEELDOWNMOUSE ] = SCA_IInputDevice::KX_WHEELDOWNMOUSE; m[MOUSEX ] = SCA_IInputDevice::KX_MOUSEX; m[MOUSEY ] = SCA_IInputDevice::KX_MOUSEY; // TIMERS m[TIMER0 ] = SCA_IInputDevice::KX_TIMER0; m[TIMER1 ] = SCA_IInputDevice::KX_TIMER1; m[TIMER2 ] = SCA_IInputDevice::KX_TIMER2; // SYSTEM #if 0 /* **** XXX **** */ m[KEYBD ] = SCA_IInputDevice::KX_KEYBD; m[RAWKEYBD ] = SCA_IInputDevice::KX_RAWKEYBD; m[REDRAW ] = SCA_IInputDevice::KX_REDRAW; m[INPUTCHANGE ] = SCA_IInputDevice::KX_INPUTCHANGE; m[QFULL ] = SCA_IInputDevice::KX_QFULL; m[WINFREEZE ] = SCA_IInputDevice::KX_WINFREEZE; m[WINTHAW ] = SCA_IInputDevice::KX_WINTHAW; m[WINCLOSE ] = SCA_IInputDevice::KX_WINCLOSE; m[WINQUIT ] = SCA_IInputDevice::KX_WINQUIT; m[Q_FIRSTTIME ] = SCA_IInputDevice::KX_Q_FIRSTTIME; /* **** XXX **** */ #endif // standard keyboard m[AKEY ] = SCA_IInputDevice::KX_AKEY; m[BKEY ] = SCA_IInputDevice::KX_BKEY; m[CKEY ] = SCA_IInputDevice::KX_CKEY; m[DKEY ] = SCA_IInputDevice::KX_DKEY; m[EKEY ] = SCA_IInputDevice::KX_EKEY; m[FKEY ] = SCA_IInputDevice::KX_FKEY; m[GKEY ] = SCA_IInputDevice::KX_GKEY; //XXX clean up #ifdef WIN32 #define HKEY 'h' #endif m[HKEY ] = SCA_IInputDevice::KX_HKEY; //XXX clean up #ifdef WIN32 #undef HKEY #endif m[IKEY ] = SCA_IInputDevice::KX_IKEY; m[JKEY ] = SCA_IInputDevice::KX_JKEY; m[KKEY ] = SCA_IInputDevice::KX_KKEY; m[LKEY ] = SCA_IInputDevice::KX_LKEY; m[MKEY ] = SCA_IInputDevice::KX_MKEY; m[NKEY ] = SCA_IInputDevice::KX_NKEY; m[OKEY ] = SCA_IInputDevice::KX_OKEY; m[PKEY ] = SCA_IInputDevice::KX_PKEY; m[QKEY ] = SCA_IInputDevice::KX_QKEY; m[RKEY ] = SCA_IInputDevice::KX_RKEY; m[SKEY ] = SCA_IInputDevice::KX_SKEY; m[TKEY ] = SCA_IInputDevice::KX_TKEY; m[UKEY ] = SCA_IInputDevice::KX_UKEY; m[VKEY ] = SCA_IInputDevice::KX_VKEY; m[WKEY ] = SCA_IInputDevice::KX_WKEY; m[XKEY ] = SCA_IInputDevice::KX_XKEY; m[YKEY ] = SCA_IInputDevice::KX_YKEY; m[ZKEY ] = SCA_IInputDevice::KX_ZKEY; m[ZEROKEY ] = SCA_IInputDevice::KX_ZEROKEY; m[ONEKEY ] = SCA_IInputDevice::KX_ONEKEY; m[TWOKEY ] = SCA_IInputDevice::KX_TWOKEY; m[THREEKEY ] = SCA_IInputDevice::KX_THREEKEY; m[FOURKEY ] = SCA_IInputDevice::KX_FOURKEY; m[FIVEKEY ] = SCA_IInputDevice::KX_FIVEKEY; m[SIXKEY ] = SCA_IInputDevice::KX_SIXKEY; m[SEVENKEY ] = SCA_IInputDevice::KX_SEVENKEY; m[EIGHTKEY ] = SCA_IInputDevice::KX_EIGHTKEY; m[NINEKEY ] = SCA_IInputDevice::KX_NINEKEY; m[CAPSLOCKKEY ] = SCA_IInputDevice::KX_CAPSLOCKKEY; m[LEFTCTRLKEY ] = SCA_IInputDevice::KX_LEFTCTRLKEY; m[LEFTALTKEY ] = SCA_IInputDevice::KX_LEFTALTKEY; m[RIGHTALTKEY ] = SCA_IInputDevice::KX_RIGHTALTKEY; m[RIGHTCTRLKEY ] = SCA_IInputDevice::KX_RIGHTCTRLKEY; m[RIGHTSHIFTKEY ] = SCA_IInputDevice::KX_RIGHTSHIFTKEY; m[LEFTSHIFTKEY ] = SCA_IInputDevice::KX_LEFTSHIFTKEY; m[ESCKEY ] = SCA_IInputDevice::KX_ESCKEY; m[TABKEY ] = SCA_IInputDevice::KX_TABKEY; m[RETKEY ] = SCA_IInputDevice::KX_RETKEY; m[SPACEKEY ] = SCA_IInputDevice::KX_SPACEKEY; m[LINEFEEDKEY ] = SCA_IInputDevice::KX_LINEFEEDKEY; m[BACKSPACEKEY ] = SCA_IInputDevice::KX_BACKSPACEKEY; m[DELKEY ] = SCA_IInputDevice::KX_DELKEY; m[SEMICOLONKEY ] = SCA_IInputDevice::KX_SEMICOLONKEY; m[PERIODKEY ] = SCA_IInputDevice::KX_PERIODKEY; m[COMMAKEY ] = SCA_IInputDevice::KX_COMMAKEY; m[QUOTEKEY ] = SCA_IInputDevice::KX_QUOTEKEY; m[ACCENTGRAVEKEY ] = SCA_IInputDevice::KX_ACCENTGRAVEKEY; m[MINUSKEY ] = SCA_IInputDevice::KX_MINUSKEY; m[SLASHKEY ] = SCA_IInputDevice::KX_SLASHKEY; m[BACKSLASHKEY ] = SCA_IInputDevice::KX_BACKSLASHKEY; m[EQUALKEY ] = SCA_IInputDevice::KX_EQUALKEY; m[LEFTBRACKETKEY ] = SCA_IInputDevice::KX_LEFTBRACKETKEY; m[RIGHTBRACKETKEY ] = SCA_IInputDevice::KX_RIGHTBRACKETKEY; m[LEFTARROWKEY ] = SCA_IInputDevice::KX_LEFTARROWKEY; m[DOWNARROWKEY ] = SCA_IInputDevice::KX_DOWNARROWKEY; m[RIGHTARROWKEY ] = SCA_IInputDevice::KX_RIGHTARROWKEY; m[UPARROWKEY ] = SCA_IInputDevice::KX_UPARROWKEY; m[PAD2 ] = SCA_IInputDevice::KX_PAD2; m[PAD4 ] = SCA_IInputDevice::KX_PAD4; m[PAD6 ] = SCA_IInputDevice::KX_PAD6; m[PAD8 ] = SCA_IInputDevice::KX_PAD8; m[PAD1 ] = SCA_IInputDevice::KX_PAD1; m[PAD3 ] = SCA_IInputDevice::KX_PAD3; m[PAD5 ] = SCA_IInputDevice::KX_PAD5; m[PAD7 ] = SCA_IInputDevice::KX_PAD7; m[PAD9 ] = SCA_IInputDevice::KX_PAD9; m[PADPERIOD ] = SCA_IInputDevice::KX_PADPERIOD; m[PADSLASHKEY ] = SCA_IInputDevice::KX_PADSLASHKEY; m[PADASTERKEY ] = SCA_IInputDevice::KX_PADASTERKEY; m[PAD0 ] = SCA_IInputDevice::KX_PAD0; m[PADMINUS ] = SCA_IInputDevice::KX_PADMINUS; m[PADENTER ] = SCA_IInputDevice::KX_PADENTER; m[PADPLUSKEY ] = SCA_IInputDevice::KX_PADPLUSKEY; m[F1KEY ] = SCA_IInputDevice::KX_F1KEY; m[F2KEY ] = SCA_IInputDevice::KX_F2KEY; m[F3KEY ] = SCA_IInputDevice::KX_F3KEY; m[F4KEY ] = SCA_IInputDevice::KX_F4KEY; m[F5KEY ] = SCA_IInputDevice::KX_F5KEY; m[F6KEY ] = SCA_IInputDevice::KX_F6KEY; m[F7KEY ] = SCA_IInputDevice::KX_F7KEY; m[F8KEY ] = SCA_IInputDevice::KX_F8KEY; m[F9KEY ] = SCA_IInputDevice::KX_F9KEY; m[F10KEY ] = SCA_IInputDevice::KX_F10KEY; m[F11KEY ] = SCA_IInputDevice::KX_F11KEY; m[F12KEY ] = SCA_IInputDevice::KX_F12KEY; m[F13KEY ] = SCA_IInputDevice::KX_F13KEY; m[F14KEY ] = SCA_IInputDevice::KX_F14KEY; m[F15KEY ] = SCA_IInputDevice::KX_F15KEY; m[F16KEY ] = SCA_IInputDevice::KX_F16KEY; m[F17KEY ] = SCA_IInputDevice::KX_F17KEY; m[F18KEY ] = SCA_IInputDevice::KX_F18KEY; m[F19KEY ] = SCA_IInputDevice::KX_F19KEY; m[OSKEY ] = SCA_IInputDevice::KX_OSKEY; m[PAUSEKEY ] = SCA_IInputDevice::KX_PAUSEKEY; m[INSERTKEY ] = SCA_IInputDevice::KX_INSERTKEY; m[HOMEKEY ] = SCA_IInputDevice::KX_HOMEKEY; m[PAGEUPKEY ] = SCA_IInputDevice::KX_PAGEUPKEY; m[PAGEDOWNKEY ] = SCA_IInputDevice::KX_PAGEDOWNKEY; m[ENDKEY ] = SCA_IInputDevice::KX_ENDKEY; return m; } static std::map gReverseKeyTranslateTable = create_translate_table(); static unsigned int KX_rgbaint2uint_new(unsigned int icol) { union { unsigned int integer; unsigned char cp[4]; } out_color, in_color; in_color.integer = icol; out_color.cp[0] = in_color.cp[3]; // red out_color.cp[1] = in_color.cp[2]; // green out_color.cp[2] = in_color.cp[1]; // blue out_color.cp[3] = in_color.cp[0]; // alpha return out_color.integer; } /* Now the real converting starts... */ static unsigned int KX_Mcol2uint_new(MCol col) { /* color has to be converted without endian sensitivity. So no shifting! */ union { MCol col; unsigned int integer; unsigned char cp[4]; } out_color, in_color; in_color.col = col; out_color.cp[0] = in_color.cp[3]; // red out_color.cp[1] = in_color.cp[2]; // green out_color.cp[2] = in_color.cp[1]; // blue out_color.cp[3] = in_color.cp[0]; // alpha return out_color.integer; } static void SetDefaultLightMode(Scene* scene) { default_light_mode = false; Scene *sce_iter; Base *base; for (SETLOOPER(scene, sce_iter, base)) { if (base->object->type == OB_LAMP) { default_light_mode = true; return; } } } static bool GetMaterialUseVColor(Material *ma, const bool glslmat) { if (ma) { /* glsl uses vertex colors, otherwise use material setting * defmaterial doesn't have VERTEXCOLP as default [#34505] */ return (glslmat || ma == &defmaterial || (ma->mode & MA_VERTEXCOLP) != 0); } else { /* no material, use vertex colors */ return true; } } // -- static void GetRGB( const bool use_vcol, MFace* mface, MCol* mmcol, Material *mat, unsigned int c[4]) { unsigned int color = 0xFFFFFFFFL; if (use_vcol == true) { if (mmcol) { c[0] = KX_Mcol2uint_new(mmcol[0]); c[1] = KX_Mcol2uint_new(mmcol[1]); c[2] = KX_Mcol2uint_new(mmcol[2]); if (mface->v4) c[3] = KX_Mcol2uint_new(mmcol[3]); } else { // backup white c[0] = KX_rgbaint2uint_new(color); c[1] = KX_rgbaint2uint_new(color); c[2] = KX_rgbaint2uint_new(color); if (mface->v4) c[3] = KX_rgbaint2uint_new( color ); } } else { /* material rgba */ if (mat) { union { unsigned char cp[4]; unsigned int integer; } col_converter; col_converter.cp[3] = (unsigned char) (mat->r * 255.0f); col_converter.cp[2] = (unsigned char) (mat->g * 255.0f); col_converter.cp[1] = (unsigned char) (mat->b * 255.0f); col_converter.cp[0] = (unsigned char) (mat->alpha * 255.0f); color = col_converter.integer; } c[0] = KX_rgbaint2uint_new(color); c[1] = KX_rgbaint2uint_new(color); c[2] = KX_rgbaint2uint_new(color); if (mface->v4) { c[3] = KX_rgbaint2uint_new(color); } } #if 0 /* white, unused */ { c[0] = KX_rgbaint2uint_new(color); c[1] = KX_rgbaint2uint_new(color); c[2] = KX_rgbaint2uint_new(color); if (mface->v4) c[3] = KX_rgbaint2uint_new(color); } #endif } typedef struct MTF_localLayer { MTFace *face; const char *name; } MTF_localLayer; static void GetUVs(BL_Material *material, MTF_localLayer *layers, MFace *mface, MTFace *tface, MT_Point2 uvs[4][MAXTEX]) { int unit = 0; if (tface) { uvs[0][0].setValue(tface->uv[0]); uvs[1][0].setValue(tface->uv[1]); uvs[2][0].setValue(tface->uv[2]); if (mface->v4) uvs[3][0].setValue(tface->uv[3]); } else { uvs[0][0] = uvs[1][0] = uvs[2][0] = uvs[3][0] = MT_Point2(0.f, 0.f); } vector found_layers; for (int vind = 0; vindmapping[vind]; if (!(map.mapping & USEUV)) continue; if (std::find(found_layers.begin(), found_layers.end(), map.uvCoName) != found_layers.end()) continue; //If no UVSet is specified, try grabbing one from the UV/Image editor if (map.uvCoName.IsEmpty() && tface) { uvs[0][unit].setValue(tface->uv[0]); uvs[1][unit].setValue(tface->uv[1]); uvs[2][unit].setValue(tface->uv[2]); if (mface->v4) uvs[3][unit].setValue(tface->uv[3]); ++unit; continue; } for (int lay=0; layuv[0]); uvs[1][unit].setValue(layer.face->uv[1]); uvs[2][unit].setValue(layer.face->uv[2]); if (mface->v4) uvs[3][unit].setValue(layer.face->uv[3]); else uvs[3][unit].setValue(0.0f, 0.0f); ++unit; found_layers.push_back(map.uvCoName); break; } } } } // ------------------------------------ static bool ConvertMaterial( BL_Material *material, Material *mat, MTFace* tface, const char *tfaceName, MFace* mface, MCol* mmcol, bool glslmat) { material->Initialize(); int texalpha = 0; const bool validmat = (mat != NULL); const bool validface = (tface != NULL); const bool use_vcol = GetMaterialUseVColor(mat, glslmat); material->IdMode = DEFAULT_BLENDER; material->glslmat = (validmat) ? glslmat: false; material->materialindex = mface->mat_nr; // -------------------------------- if (validmat) { // use lighting? material->ras_mode |= ( mat->mode & MA_SHLESS )?0:USE_LIGHT; material->ras_mode |= ( mat->game.flag & GEMAT_BACKCULL )?0:TWOSIDED; // cast shadows? material->ras_mode |= ( (mat->mode2 & MA_CASTSHADOW) && (mat->mode & MA_SHADBUF) )?CAST_SHADOW:0; // only shadows? material->ras_mode |= ( mat->mode & MA_ONLYCAST )?ONLY_SHADOW:0; MTex *mttmp = 0; int valid_index = 0; /* In Multitexture use the face texture if and only if * it is set in the buttons * In GLSL is not working yet :/ 3.2011 */ bool facetex = false; if (validface && mat->mode &MA_FACETEXTURE) facetex = true; // foreach MTex for (int i=0; itpage); if (tmp) { material->img[i] = tmp; material->texname[i] = material->img[i]->id.name; material->flag[i] |= MIPMAP; material->flag[i] |= ( mat->game.alpha_blend & GEMAT_ALPHA_SORT )?USEALPHA:0; material->flag[i] |= ( mat->game.alpha_blend & GEMAT_ALPHA )?USEALPHA:0; material->flag[i] |= ( mat->game.alpha_blend & GEMAT_ADD )?CALCALPHA:0; if (material->img[i]->flag & IMA_REFLECT) { material->mapping[i].mapping |= USEREFL; } else { mttmp = getMTexFromMaterial(mat, i); if (mttmp && (mttmp->texco & TEXCO_UV)) { /* string may be "" but thats detected as empty after */ material->mapping[i].uvCoName = mttmp->uvname; } material->mapping[i].mapping |= USEUV; } valid_index++; } else { material->img[i] = 0; material->texname[i] = ""; } continue; } mttmp = getMTexFromMaterial(mat, i); if (mttmp) { if (mttmp->tex) { if ( mttmp->tex->type == TEX_IMAGE ) { material->mtexname[i] = mttmp->tex->id.name; material->img[i] = mttmp->tex->ima; if ( material->img[i] ) { material->texname[i] = material->img[i]->id.name; material->flag[i] |= ( mttmp->tex->imaflag &TEX_MIPMAP )?MIPMAP:0; // ----------------------- if (material->img[i] && (material->img[i]->flag & IMA_IGNORE_ALPHA) == 0) material->flag[i] |= USEALPHA; // ----------------------- if ( mttmp->tex->imaflag &TEX_CALCALPHA ) { material->flag[i] |= CALCALPHA; } else if (mttmp->tex->flag &TEX_NEGALPHA) { material->flag[i] |= USENEGALPHA; } material->color_blend[i] = mttmp->colfac; material->flag[i] |= ( mttmp->mapto & MAP_ALPHA )?TEXALPHA:0; material->flag[i] |= ( mttmp->texflag& MTEX_NEGATIVE )?TEXNEG:0; if (!glslmat && (material->flag[i] & TEXALPHA)) texalpha = 1; } } else if (mttmp->tex->type == TEX_ENVMAP) { if ( mttmp->tex->env->stype == ENV_LOAD ) { material->mtexname[i] = mttmp->tex->id.name; EnvMap *env = mttmp->tex->env; env->ima = mttmp->tex->ima; material->cubemap[i] = env; if (material->cubemap[i]) { if (!material->cubemap[i]->cube[0]) BL_Texture::SplitEnvMap(material->cubemap[i]); material->texname[i] = material->cubemap[i]->ima->id.name; material->mapping[i].mapping |= USEENV; } } } #if 0 /* this flag isn't used anymore */ material->flag[i] |= (BKE_animdata_from_id(mat->id) != NULL) ? HASIPO : 0; #endif /// -------------------------------- // mapping methods if (mat->septex & (1 << i)) { // If this texture slot isn't in use, set it to disabled to prevent multi-uv problems material->mapping[i].mapping = DISABLE; } else { material->mapping[i].mapping |= ( mttmp->texco & TEXCO_REFL )?USEREFL:0; if (mttmp->texco & TEXCO_OBJECT) { material->mapping[i].mapping |= USEOBJ; if (mttmp->object) material->mapping[i].objconame = mttmp->object->id.name; } else if (mttmp->texco &TEXCO_REFL) material->mapping[i].mapping |= USEREFL; else if (mttmp->texco &(TEXCO_ORCO|TEXCO_GLOB)) material->mapping[i].mapping |= USEORCO; else if (mttmp->texco & TEXCO_UV) { /* string may be "" but thats detected as empty after */ material->mapping[i].uvCoName = mttmp->uvname; material->mapping[i].mapping |= USEUV; } else if (mttmp->texco &TEXCO_NORM) material->mapping[i].mapping |= USENORM; else if (mttmp->texco &TEXCO_TANGENT) material->mapping[i].mapping |= USETANG; else material->mapping[i].mapping |= DISABLE; material->mapping[i].scale[0] = mttmp->size[0]; material->mapping[i].scale[1] = mttmp->size[1]; material->mapping[i].scale[2] = mttmp->size[2]; material->mapping[i].offsets[0] = mttmp->ofs[0]; material->mapping[i].offsets[1] = mttmp->ofs[1]; material->mapping[i].offsets[2] = mttmp->ofs[2]; material->mapping[i].projplane[0] = mttmp->projx; material->mapping[i].projplane[1] = mttmp->projy; material->mapping[i].projplane[2] = mttmp->projz; } /// -------------------------------- switch (mttmp->blendtype) { case MTEX_BLEND: material->blend_mode[i] = BLEND_MIX; break; case MTEX_MUL: material->blend_mode[i] = BLEND_MUL; break; case MTEX_ADD: material->blend_mode[i] = BLEND_ADD; break; case MTEX_SUB: material->blend_mode[i] = BLEND_SUB; break; case MTEX_SCREEN: material->blend_mode[i] = BLEND_SCR; break; } valid_index++; } } } // above one tex the switches here // are not used switch (valid_index) { case 0: material->IdMode = DEFAULT_BLENDER; break; case 1: material->IdMode = ONETEX; break; default: material->IdMode = GREATERTHAN2; break; } material->SetUsers(mat->id.us); material->num_enabled = valid_index; material->speccolor[0] = mat->specr; material->speccolor[1] = mat->specg; material->speccolor[2] = mat->specb; material->hard = (float)mat->har/4.0f; material->matcolor[0] = mat->r; material->matcolor[1] = mat->g; material->matcolor[2] = mat->b; material->matcolor[3] = mat->alpha; material->alpha = mat->alpha; material->emit = mat->emit; material->spec_f = mat->spec; material->ref = mat->ref; material->amb = mat->amb; material->ras_mode |= (mat->material_type == MA_TYPE_WIRE)? WIRE: 0; } else { // No Material int valid = 0; // check for tface tex to fallback on if ( validface ) { material->img[0] = (Image*)(tface->tpage); // ------------------------ if (material->img[0]) { material->texname[0] = material->img[0]->id.name; material->mapping[0].mapping |= ( (material->img[0]->flag & IMA_REFLECT)!=0 )?USEREFL:0; /* see if depth of the image is 32bits */ if (BKE_image_has_alpha(material->img[0])) { material->flag[0] |= USEALPHA; material->alphablend = GEMAT_ALPHA; } else material->alphablend = GEMAT_SOLID; valid++; } } else material->alphablend = GEMAT_SOLID; material->SetUsers(-1); material->num_enabled = valid; material->IdMode = TEXFACE; material->speccolor[0] = 1.f; material->speccolor[1] = 1.f; material->speccolor[2] = 1.f; material->hard = 35.f; material->matcolor[0] = 0.5f; material->matcolor[1] = 0.5f; material->matcolor[2] = 0.5f; material->spec_f = 0.5f; material->ref = 0.8f; // No material - old default TexFace properties material->ras_mode |= USE_LIGHT; } /* No material, what to do? let's see what is in the UV and set the material accordingly * light and visible is always on */ if ( validface ) { material->tile = tface->tile; } else { // nothing at all material->alphablend = GEMAT_SOLID; material->tile = 0; } if (validmat && validface) { material->alphablend = mat->game.alpha_blend; } // with ztransp enabled, enforce alpha blending mode if (validmat && (mat->mode & MA_TRANSP) && (mat->mode & MA_ZTRANSP) && (material->alphablend == GEMAT_SOLID)) material->alphablend = GEMAT_ALPHA; // always zsort alpha + add if ((ELEM(material->alphablend, GEMAT_ALPHA, GEMAT_ALPHA_SORT, GEMAT_ADD) || texalpha) && (material->alphablend != GEMAT_CLIP )) { material->ras_mode |= ALPHA; material->ras_mode |= (mat && (mat->game.alpha_blend & GEMAT_ALPHA_SORT))? ZSORT: 0; } // XXX The RGB values here were meant to be temporary storage for the conversion process, // but fonts now make use of them too, so we leave them in for now. unsigned int rgb[4]; GetRGB(use_vcol, mface, mmcol, mat, rgb); // swap the material color, so MCol on bitmap font works if (validmat && (use_vcol == false) && (mat->game.flag & GEMAT_TEXT)) { rgb[0] = KX_rgbaint2uint_new(rgb[0]); rgb[1] = KX_rgbaint2uint_new(rgb[1]); rgb[2] = KX_rgbaint2uint_new(rgb[2]); rgb[3] = KX_rgbaint2uint_new(rgb[3]); } if (validmat) material->matname =(mat->id.name); if (tface) { material->tface = *tface; } else { memset(&material->tface, 0, sizeof(material->tface)); } material->material = mat; return true; } static RAS_MaterialBucket *material_from_mesh(Material *ma, MFace *mface, MTFace *tface, MCol *mcol, MTF_localLayer *layers, int lightlayer, unsigned int *rgb, MT_Point2 uvs[4][RAS_TexVert::MAX_UNIT], const char *tfaceName, KX_Scene* scene, KX_BlenderSceneConverter *converter) { RAS_IPolyMaterial* polymat = converter->FindCachedPolyMaterial(scene, ma); BL_Material* bl_mat = converter->FindCachedBlenderMaterial(scene, ma); KX_BlenderMaterial* kx_blmat = NULL; /* first is the BL_Material */ if (!bl_mat) { bl_mat = new BL_Material(); ConvertMaterial(bl_mat, ma, tface, tfaceName, mface, mcol, converter->GetGLSLMaterials()); if (ma && (ma->mode & MA_FACETEXTURE) == 0) converter->CacheBlenderMaterial(scene, ma, bl_mat); } const bool use_vcol = GetMaterialUseVColor(ma, bl_mat->glslmat); GetRGB(use_vcol, mface, mcol, ma, rgb); GetUVs(bl_mat, layers, mface, tface, uvs); /* then the KX_BlenderMaterial */ if (polymat == NULL) { kx_blmat = new KX_BlenderMaterial(); kx_blmat->Initialize(scene, bl_mat, (ma?&ma->game:NULL), lightlayer); polymat = static_cast(kx_blmat); if (ma && (ma->mode & MA_FACETEXTURE) == 0) converter->CachePolyMaterial(scene, ma, polymat); } // see if a bucket was reused or a new one was created // this way only one KX_BlenderMaterial object has to exist per bucket bool bucketCreated; RAS_MaterialBucket* bucket = scene->FindBucket(polymat, bucketCreated); // this is needed to free up memory afterwards. // the converter will also prevent duplicates from being registered, // so just register everything. converter->RegisterPolyMaterial(polymat); converter->RegisterBlenderMaterial(bl_mat); return bucket; } /* blenderobj can be NULL, make sure its checked for */ RAS_MeshObject* BL_ConvertMesh(Mesh* mesh, Object* blenderobj, KX_Scene* scene, KX_BlenderSceneConverter *converter, bool libloading) { RAS_MeshObject *meshobj; int lightlayer = blenderobj ? blenderobj->lay:(1<<20)-1; // all layers if no object. // Without checking names, we get some reuse we don't want that can cause // problems with material LoDs. if (blenderobj && ((meshobj = converter->FindGameMesh(mesh/*, ob->lay*/)) != NULL)) { const char *bge_name = meshobj->GetName().ReadPtr(); const char *blender_name = ((ID *)blenderobj->data)->name + 2; if (STREQ(bge_name, blender_name)) { return meshobj; } } // Get DerivedMesh data DerivedMesh *dm = CDDM_from_mesh(mesh); DM_ensure_tessface(dm); MVert *mvert = dm->getVertArray(dm); int totvert = dm->getNumVerts(dm); MFace *mface = dm->getTessFaceArray(dm); MTFace *tface = static_cast(dm->getTessFaceDataArray(dm, CD_MTFACE)); MCol *mcol = static_cast(dm->getTessFaceDataArray(dm, CD_MCOL)); float (*tangent)[4] = NULL; int totface = dm->getNumTessFaces(dm); const char *tfaceName = ""; if (tface) { DM_add_tangent_layer(dm); tangent = (float(*)[4])dm->getTessFaceDataArray(dm, CD_TANGENT); } meshobj = new RAS_MeshObject(mesh); // Extract avaiable layers MTF_localLayer *layers = new MTF_localLayer[MAX_MTFACE]; for (int lay=0; layfaceData.totlayer; i++) { if (dm->faceData.layers[i].type == CD_MTFACE) { if (validLayers >= MAX_MTFACE) { printf("%s: corrupted mesh %s - too many CD_MTFACE layers\n", __func__, mesh->id.name); break; } layers[validLayers].face = (MTFace*)(dm->faceData.layers[i].data); layers[validLayers].name = dm->faceData.layers[i].name; if (tface == layers[validLayers].face) tfaceName = layers[validLayers].name; validLayers++; } } meshobj->SetName(mesh->id.name + 2); meshobj->m_sharedvertex_map.resize(totvert); Material* ma = 0; bool collider = true; MT_Point2 uvs[4][RAS_TexVert::MAX_UNIT]; unsigned int rgb[4] = {0}; MT_Point3 pt[4]; MT_Vector3 no[4]; MT_Vector4 tan[4]; /* ugh, if there is a less annoying way to do this please use that. * since these are converted from floats to floats, theres no real * advantage to use MT_ types - campbell */ for (unsigned int i = 0; i < 4; i++) { const float zero_vec[4] = {0.0f}; pt[i].setValue(zero_vec); no[i].setValue(zero_vec); tan[i].setValue(zero_vec); } /* we need to manually initialize the uvs (MoTo doesn't do that) [#34550] */ for (unsigned int i = 0; i < RAS_TexVert::MAX_UNIT; i++) { uvs[0][i] = uvs[1][i] = uvs[2][i] = uvs[3][i] = MT_Point2(0.f, 0.f); } for (int f=0;fv1].co); pt[1].setValue(mvert[mface->v2].co); pt[2].setValue(mvert[mface->v3].co); if (mface->v4) pt[3].setValue(mvert[mface->v4].co); if (mface->flag & ME_SMOOTH) { float n0[3], n1[3], n2[3], n3[3]; normal_short_to_float_v3(n0, mvert[mface->v1].no); normal_short_to_float_v3(n1, mvert[mface->v2].no); normal_short_to_float_v3(n2, mvert[mface->v3].no); no[0] = n0; no[1] = n1; no[2] = n2; if (mface->v4) { normal_short_to_float_v3(n3, mvert[mface->v4].no); no[3] = n3; } } else { float fno[3]; if (mface->v4) normal_quad_v3(fno,mvert[mface->v1].co, mvert[mface->v2].co, mvert[mface->v3].co, mvert[mface->v4].co); else normal_tri_v3(fno,mvert[mface->v1].co, mvert[mface->v2].co, mvert[mface->v3].co); no[0] = no[1] = no[2] = no[3] = MT_Vector3(fno); } if (tangent) { tan[0] = tangent[f*4 + 0]; tan[1] = tangent[f*4 + 1]; tan[2] = tangent[f*4 + 2]; if (mface->v4) tan[3] = tangent[f*4 + 3]; } if (blenderobj) ma = give_current_material(blenderobj, mface->mat_nr+1); else ma = mesh->mat ? mesh->mat[mface->mat_nr]:NULL; /* ckeck for texface since texface _only_ is used as a fallback */ if (ma == NULL && tface == NULL) { ma= &defmaterial; } { bool visible = true; bool twoside = false; RAS_MaterialBucket* bucket = material_from_mesh(ma, mface, tface, mcol, layers, lightlayer, rgb, uvs, tfaceName, scene, converter); // set render flags if (ma) { visible = ((ma->game.flag & GEMAT_INVISIBLE)==0); twoside = ((ma->game.flag & GEMAT_BACKCULL)==0); collider = ((ma->game.flag & GEMAT_NOPHYSICS)==0); } else { visible = true; twoside = false; collider = true; } /* mark face as flat, so vertices are split */ bool flat = (mface->flag & ME_SMOOTH) == 0; int nverts = (mface->v4)? 4: 3; RAS_Polygon *poly = meshobj->AddPolygon(bucket, nverts); poly->SetVisible(visible); poly->SetCollider(collider); poly->SetTwoside(twoside); //poly->SetEdgeCode(mface->edcode); meshobj->AddVertex(poly,0,pt[0],uvs[0],tan[0],rgb[0],no[0],flat,mface->v1); meshobj->AddVertex(poly,1,pt[1],uvs[1],tan[1],rgb[1],no[1],flat,mface->v2); meshobj->AddVertex(poly,2,pt[2],uvs[2],tan[2],rgb[2],no[2],flat,mface->v3); if (nverts==4) meshobj->AddVertex(poly,3,pt[3],uvs[3],tan[3],rgb[3],no[3],flat,mface->v4); } if (tface) tface++; if (mcol) mcol+=4; for (int lay=0; laym_sharedvertex_map for reinstance phys mesh. // 2.49a and before it did: meshobj->m_sharedvertex_map.clear(); // but this didnt save much ram. - Campbell meshobj->EndConversion(); // pre calculate texture generation // However, we want to delay this if we're libloading so we can make sure we have the right scene. if (!libloading) { for (list::iterator mit = meshobj->GetFirstMaterial(); mit != meshobj->GetLastMaterial(); ++ mit) { mit->m_bucket->GetPolyMaterial()->OnConstruction(); } } if (layers) delete []layers; dm->release(dm); converter->RegisterGameMesh(meshobj, mesh); return meshobj; } static PHY_MaterialProps *CreateMaterialFromBlenderObject(struct Object* blenderobject) { PHY_MaterialProps *materialProps = new PHY_MaterialProps; MT_assert(materialProps && "Create physics material properties failed"); Material* blendermat = give_current_material(blenderobject, 1); if (blendermat) { MT_assert(0.0f <= blendermat->reflect && blendermat->reflect <= 1.0f); materialProps->m_restitution = blendermat->reflect; materialProps->m_friction = blendermat->friction; materialProps->m_fh_spring = blendermat->fh; materialProps->m_fh_damping = blendermat->xyfrict; materialProps->m_fh_distance = blendermat->fhdist; materialProps->m_fh_normal = (blendermat->dynamode & MA_FH_NOR) != 0; } else { //give some defaults materialProps->m_restitution = 0.f; materialProps->m_friction = 0.5; materialProps->m_fh_spring = 0.f; materialProps->m_fh_damping = 0.f; materialProps->m_fh_distance = 0.f; materialProps->m_fh_normal = false; } return materialProps; } static PHY_ShapeProps *CreateShapePropsFromBlenderObject(struct Object* blenderobject) { PHY_ShapeProps *shapeProps = new PHY_ShapeProps; MT_assert(shapeProps); shapeProps->m_mass = blenderobject->mass; // This needs to be fixed in blender. For now, we use: // in Blender, inertia stands for the size value which is equivalent to // the sphere radius shapeProps->m_inertia = blenderobject->formfactor; MT_assert(0.0f <= blenderobject->damping && blenderobject->damping <= 1.0f); MT_assert(0.0f <= blenderobject->rdamping && blenderobject->rdamping <= 1.0f); shapeProps->m_lin_drag = 1.0f - blenderobject->damping; shapeProps->m_ang_drag = 1.0f - blenderobject->rdamping; shapeProps->m_friction_scaling[0] = blenderobject->anisotropicFriction[0]; shapeProps->m_friction_scaling[1] = blenderobject->anisotropicFriction[1]; shapeProps->m_friction_scaling[2] = blenderobject->anisotropicFriction[2]; shapeProps->m_do_anisotropic = ((blenderobject->gameflag & OB_ANISOTROPIC_FRICTION) != 0); shapeProps->m_do_fh = (blenderobject->gameflag & OB_DO_FH) != 0; shapeProps->m_do_rot_fh = (blenderobject->gameflag & OB_ROT_FH) != 0; // velocity clamping XXX shapeProps->m_clamp_vel_min = blenderobject->min_vel; shapeProps->m_clamp_vel_max = blenderobject->max_vel; // Character physics properties shapeProps->m_step_height = blenderobject->step_height; shapeProps->m_jump_speed = blenderobject->jump_speed; shapeProps->m_fall_speed = blenderobject->fall_speed; return shapeProps; } ////////////////////////////////////////////////////////// static float my_boundbox_mesh(Mesh *me, float *loc, float *size) { MVert *mvert; BoundBox *bb; float min[3], max[3]; float mloc[3], msize[3]; float radius_sq=0.0f, vert_radius_sq, *co; int a; if (me->bb==0) { me->bb = BKE_boundbox_alloc_unit(); } bb= me->bb; INIT_MINMAX(min, max); if (!loc) loc= mloc; if (!size) size= msize; mvert= me->mvert; for (a = 0; atotvert; a++, mvert++) { co = mvert->co; /* bounds */ minmax_v3v3_v3(min, max, co); /* radius */ vert_radius_sq = len_squared_v3(co); if (vert_radius_sq > radius_sq) radius_sq = vert_radius_sq; } if (me->totvert) { loc[0] = (min[0] + max[0]) / 2.0f; loc[1] = (min[1] + max[1]) / 2.0f; loc[2] = (min[2] + max[2]) / 2.0f; size[0] = (max[0] - min[0]) / 2.0f; size[1] = (max[1] - min[1]) / 2.0f; size[2] = (max[2] - min[2]) / 2.0f; } else { loc[0] = loc[1] = loc[2] = 0.0f; size[0] = size[1] = size[2] = 0.0f; } bb->vec[0][0] = bb->vec[1][0] = bb->vec[2][0] = bb->vec[3][0] = loc[0]-size[0]; bb->vec[4][0] = bb->vec[5][0] = bb->vec[6][0] = bb->vec[7][0] = loc[0]+size[0]; bb->vec[0][1] = bb->vec[1][1] = bb->vec[4][1] = bb->vec[5][1] = loc[1]-size[1]; bb->vec[2][1] = bb->vec[3][1] = bb->vec[6][1] = bb->vec[7][1] = loc[1]+size[1]; bb->vec[0][2] = bb->vec[3][2] = bb->vec[4][2] = bb->vec[7][2] = loc[2]-size[2]; bb->vec[1][2] = bb->vec[2][2] = bb->vec[5][2] = bb->vec[6][2] = loc[2]+size[2]; return sqrtf_signed(radius_sq); } ////////////////////////////////////////////////////// static void BL_CreateGraphicObjectNew(KX_GameObject* gameobj, const MT_Point3& localAabbMin, const MT_Point3& localAabbMax, KX_Scene* kxscene, bool isActive, e_PhysicsEngine physics_engine) { if (gameobj->GetMeshCount() > 0) { switch (physics_engine) { #ifdef WITH_BULLET case UseBullet: { CcdPhysicsEnvironment* env = (CcdPhysicsEnvironment*)kxscene->GetPhysicsEnvironment(); assert(env); PHY_IMotionState* motionstate = new KX_MotionState(gameobj->GetSGNode()); CcdGraphicController* ctrl = new CcdGraphicController(env, motionstate); gameobj->SetGraphicController(ctrl); ctrl->SetNewClientInfo(gameobj->getClientInfo()); ctrl->SetLocalAabb(localAabbMin, localAabbMax); if (isActive) { // add first, this will create the proxy handle, only if the object is visible if (gameobj->GetVisible()) env->AddCcdGraphicController(ctrl); // update the mesh if there is a deformer, this will also update the bounding box for modifiers RAS_Deformer* deformer = gameobj->GetDeformer(); if (deformer) deformer->UpdateBuckets(); } } break; #endif default: break; } } } static void BL_CreatePhysicsObjectNew(KX_GameObject* gameobj, struct Object* blenderobject, RAS_MeshObject* meshobj, KX_Scene* kxscene, int activeLayerBitInfo, KX_BlenderSceneConverter *converter, bool processCompoundChildren ) { //SYS_SystemHandle syshandle = SYS_GetSystem(); /*unused*/ //int userigidbody = SYS_GetCommandLineInt(syshandle,"norigidbody",0); //bool bRigidBody = (userigidbody == 0); // object has physics representation? if (!(blenderobject->gameflag & OB_COLLISION)) { // Respond to all collisions so that Near sensors work on No Collision // objects. gameobj->SetUserCollisionGroup(0xff); gameobj->SetUserCollisionMask(0xff); return; } gameobj->SetUserCollisionGroup(blenderobject->col_group); gameobj->SetUserCollisionMask(blenderobject->col_mask); // get Root Parent of blenderobject struct Object* parent= blenderobject->parent; while (parent && parent->parent) { parent= parent->parent; } bool isCompoundChild = false; bool hasCompoundChildren = !parent && (blenderobject->gameflag & OB_CHILD); /* When the parent is not OB_DYNAMIC and has no OB_COLLISION then it gets no bullet controller * and cant be apart of the parents compound shape */ if (parent && (parent->gameflag & (OB_DYNAMIC | OB_COLLISION))) { if ((parent->gameflag & OB_CHILD) != 0 && (blenderobject->gameflag & OB_CHILD)) { isCompoundChild = true; } } if (processCompoundChildren != isCompoundChild) return; PHY_ShapeProps* shapeprops = CreateShapePropsFromBlenderObject(blenderobject); PHY_MaterialProps* smmaterial = CreateMaterialFromBlenderObject(blenderobject); DerivedMesh* dm = NULL; if (gameobj->GetDeformer()) dm = gameobj->GetDeformer()->GetPhysicsMesh(); class PHY_IMotionState* motionstate = new KX_MotionState(gameobj->GetSGNode()); kxscene->GetPhysicsEnvironment()->ConvertObject(gameobj, meshobj, dm, kxscene, shapeprops, smmaterial, motionstate, activeLayerBitInfo, isCompoundChild, hasCompoundChildren); bool isActor = (blenderobject->gameflag & OB_ACTOR)!=0; bool isSensor = (blenderobject->gameflag & OB_SENSOR) != 0; gameobj->getClientInfo()->m_type = (isSensor) ? ((isActor) ? KX_ClientObjectInfo::OBACTORSENSOR : KX_ClientObjectInfo::OBSENSOR) : (isActor) ? KX_ClientObjectInfo::ACTOR : KX_ClientObjectInfo::STATIC; // should we record animation for this object? if ((blenderobject->gameflag & OB_RECORD_ANIMATION) != 0) gameobj->SetRecordAnimation(true); // store materialname in auxinfo, needed for touchsensors if (meshobj) { const STR_String& matname=meshobj->GetMaterialName(0); gameobj->getClientInfo()->m_auxilary_info = (matname.Length() ? (void*)(matname.ReadPtr()+2) : NULL); } else { gameobj->getClientInfo()->m_auxilary_info = 0; } delete shapeprops; delete smmaterial; if (dm) { dm->needsFree = 1; dm->release(dm); } } static KX_LightObject *gamelight_from_blamp(Object *ob, Lamp *la, unsigned int layerflag, KX_Scene *kxscene, RAS_IRasterizer *rasterizer, KX_BlenderSceneConverter *converter) { RAS_ILightObject *lightobj = rasterizer->CreateLight(); KX_LightObject *gamelight; lightobj->m_att1 = la->att1; lightobj->m_att2 = (la->mode & LA_QUAD) ? la->att2 : 0.0f; lightobj->m_color[0] = la->r; lightobj->m_color[1] = la->g; lightobj->m_color[2] = la->b; lightobj->m_distance = la->dist; lightobj->m_energy = la->energy; lightobj->m_layer = layerflag; lightobj->m_spotblend = la->spotblend; lightobj->m_spotsize = la->spotsize; lightobj->m_nodiffuse = (la->mode & LA_NO_DIFF) != 0; lightobj->m_nospecular = (la->mode & LA_NO_SPEC) != 0; bool glslmat = converter->GetGLSLMaterials(); // in GLSL NEGATIVE LAMP is handled inside the lamp update function if (glslmat==0) { if (la->mode & LA_NEG) { lightobj->m_color[0] = -lightobj->m_color[0]; lightobj->m_color[1] = -lightobj->m_color[1]; lightobj->m_color[2] = -lightobj->m_color[2]; } } if (la->type==LA_SUN) { lightobj->m_type = RAS_ILightObject::LIGHT_SUN; } else if (la->type==LA_SPOT) { lightobj->m_type = RAS_ILightObject::LIGHT_SPOT; } else { lightobj->m_type = RAS_ILightObject::LIGHT_NORMAL; } gamelight = new KX_LightObject(kxscene, KX_Scene::m_callbacks, rasterizer, lightobj, glslmat); return gamelight; } static KX_Camera *gamecamera_from_bcamera(Object *ob, KX_Scene *kxscene, KX_BlenderSceneConverter *converter) { Camera* ca = static_cast(ob->data); RAS_CameraData camdata(ca->lens, ca->ortho_scale, ca->sensor_x, ca->sensor_y, ca->sensor_fit, ca->clipsta, ca->clipend, ca->type == CAM_PERSP, ca->YF_dofdist); KX_Camera *gamecamera; gamecamera= new KX_Camera(kxscene, KX_Scene::m_callbacks, camdata); gamecamera->SetName(ca->id.name + 2); return gamecamera; } static KX_GameObject *gameobject_from_blenderobject( Object *ob, KX_Scene *kxscene, RAS_IRasterizer *rendertools, KX_BlenderSceneConverter *converter, bool libloading) { KX_GameObject *gameobj = NULL; Scene *blenderscene = kxscene->GetBlenderScene(); switch (ob->type) { case OB_LAMP: { KX_LightObject* gamelight = gamelight_from_blamp(ob, static_cast(ob->data), ob->lay, kxscene, rendertools, converter); gameobj = gamelight; if (blenderscene->lay & ob->lay) { gamelight->AddRef(); kxscene->GetLightList()->Add(gamelight); } break; } case OB_CAMERA: { KX_Camera* gamecamera = gamecamera_from_bcamera(ob, kxscene, converter); gameobj = gamecamera; //don't add a reference: the camera list in kxscene->m_cameras is not released at the end //gamecamera->AddRef(); kxscene->AddCamera(gamecamera); break; } case OB_MESH: { Mesh* mesh = static_cast(ob->data); float center[3], extents[3]; float radius = my_boundbox_mesh((Mesh*) ob->data, center, extents); RAS_MeshObject* meshobj = BL_ConvertMesh(mesh,ob,kxscene,converter, libloading); // needed for python scripting kxscene->GetLogicManager()->RegisterMeshName(meshobj->GetName(),meshobj); if (ob->gameflag & OB_NAVMESH) { gameobj = new KX_NavMeshObject(kxscene,KX_Scene::m_callbacks); gameobj->AddMesh(meshobj); break; } gameobj = new BL_DeformableGameObject(ob,kxscene,KX_Scene::m_callbacks); // set transformation gameobj->AddMesh(meshobj); // gather levels of detail if (BLI_listbase_count_ex(&ob->lodlevels, 2) > 1) { LodLevel *lod = ((LodLevel*)ob->lodlevels.first)->next; Mesh* lodmesh = mesh; Object* lodmatob = ob; gameobj->AddLodMesh(meshobj); for (; lod; lod = lod->next) { if (!lod->source || lod->source->type != OB_MESH) continue; if (lod->flags & OB_LOD_USE_MESH) { lodmesh = static_cast(lod->source->data); } if (lod->flags & OB_LOD_USE_MAT) { lodmatob = lod->source; } gameobj->AddLodMesh(BL_ConvertMesh(lodmesh, lodmatob, kxscene, converter, libloading)); } } // for all objects: check whether they want to // respond to updates bool ignoreActivityCulling = ((ob->gameflag2 & OB_NEVER_DO_ACTIVITY_CULLING)!=0); gameobj->SetIgnoreActivityCulling(ignoreActivityCulling); gameobj->SetOccluder((ob->gameflag & OB_OCCLUDER) != 0, false); // we only want obcolor used if there is a material in the mesh // that requires it Material *mat= NULL; bool bUseObjectColor=false; for (int i=0;itotcol;i++) { mat=mesh->mat[i]; if (!mat) break; if ((mat->shade_flag & MA_OBCOLOR)) { bUseObjectColor = true; break; } } if (bUseObjectColor) gameobj->SetObjectColor(ob->col); // two options exists for deform: shape keys and armature // only support relative shape key bool bHasShapeKey = mesh->key != NULL && mesh->key->type==KEY_RELATIVE; bool bHasDvert = mesh->dvert != NULL && ob->defbase.first; bool bHasArmature = (BL_ModifierDeformer::HasArmatureDeformer(ob) && ob->parent && ob->parent->type == OB_ARMATURE && bHasDvert); bool bHasModifier = BL_ModifierDeformer::HasCompatibleDeformer(ob); #ifdef WITH_BULLET bool bHasSoftBody = (!ob->parent && (ob->gameflag & OB_SOFT_BODY)); #endif if (bHasModifier) { BL_ModifierDeformer *dcont = new BL_ModifierDeformer((BL_DeformableGameObject *)gameobj, kxscene->GetBlenderScene(), ob, meshobj); ((BL_DeformableGameObject*)gameobj)->SetDeformer(dcont); } else if (bHasShapeKey) { // not that we can have shape keys without dvert! BL_ShapeDeformer *dcont = new BL_ShapeDeformer((BL_DeformableGameObject*)gameobj, ob, meshobj); ((BL_DeformableGameObject*)gameobj)->SetDeformer(dcont); } else if (bHasArmature) { BL_SkinDeformer *dcont = new BL_SkinDeformer((BL_DeformableGameObject*)gameobj, ob, meshobj); ((BL_DeformableGameObject*)gameobj)->SetDeformer(dcont); } else if (bHasDvert) { // this case correspond to a mesh that can potentially deform but not with the // object to which it is attached for the moment. A skin mesh was created in // BL_ConvertMesh() so must create a deformer too! BL_MeshDeformer *dcont = new BL_MeshDeformer((BL_DeformableGameObject*)gameobj, ob, meshobj); ((BL_DeformableGameObject*)gameobj)->SetDeformer(dcont); #ifdef WITH_BULLET } else if (bHasSoftBody) { KX_SoftBodyDeformer *dcont = new KX_SoftBodyDeformer(meshobj, (BL_DeformableGameObject*)gameobj); ((BL_DeformableGameObject*)gameobj)->SetDeformer(dcont); #endif } MT_Point3 min = MT_Point3(center) - MT_Vector3(extents); MT_Point3 max = MT_Point3(center) + MT_Vector3(extents); SG_BBox bbox = SG_BBox(min, max); gameobj->GetSGNode()->SetBBox(bbox); gameobj->GetSGNode()->SetRadius(radius); break; } case OB_ARMATURE: { bArmature *arm = (bArmature*)ob->data; gameobj = new BL_ArmatureObject( kxscene, KX_Scene::m_callbacks, ob, kxscene->GetBlenderScene(), // handle arm->gevertdeformer ); /* Get the current pose from the armature object and apply it as the rest pose */ break; } case OB_EMPTY: { gameobj = new KX_EmptyObject(kxscene,KX_Scene::m_callbacks); // set transformation break; } case OB_FONT: { bool do_color_management = !(blenderscene->gm.flag & GAME_GLSL_NO_COLOR_MANAGEMENT); /* font objects have no bounding box */ gameobj = new KX_FontObject(kxscene,KX_Scene::m_callbacks, rendertools, ob, do_color_management); /* add to the list only the visible fonts */ if ((ob->lay & kxscene->GetBlenderScene()->lay) != 0) kxscene->AddFont(static_cast(gameobj)); break; } #ifdef THREADED_DAG_WORKAROUND case OB_CURVE: { if (ob->curve_cache == NULL) { BKE_displist_make_curveTypes(blenderscene, ob, false); } } #endif } if (gameobj) { gameobj->SetLayer(ob->lay); gameobj->SetBlenderObject(ob); /* set the visibility state based on the objects render option in the outliner */ if (ob->restrictflag & OB_RESTRICT_RENDER) gameobj->SetVisible(0, 0); } return gameobj; } struct parentChildLink { struct Object* m_blenderchild; SG_Node* m_gamechildnode; }; #include "DNA_constraint_types.h" //XXX #include "BIF_editconstraint.h" static bPoseChannel *get_active_posechannel2(Object *ob) { bArmature *arm= (bArmature*)ob->data; bPoseChannel *pchan; /* find active */ for (pchan= (bPoseChannel *)ob->pose->chanbase.first; pchan; pchan= pchan->next) { if (pchan->bone && (pchan->bone == arm->act_bone) && (pchan->bone->layer & arm->layer)) return pchan; } return NULL; } static ListBase *get_active_constraints2(Object *ob) { if (!ob) return NULL; // XXX - shouldnt we care about the pose data and not the mode??? if (ob->mode & OB_MODE_POSE) { bPoseChannel *pchan; pchan = get_active_posechannel2(ob); if (pchan) return &pchan->constraints; } else return &ob->constraints; return NULL; } static void UNUSED_FUNCTION(RBJconstraints)(Object *ob)//not used { ListBase *conlist; bConstraint *curcon; conlist = get_active_constraints2(ob); if (conlist) { for (curcon = (bConstraint *)conlist->first; curcon; curcon = (bConstraint *)curcon->next) { printf("%i\n",curcon->type); } } } static KX_GameObject* getGameOb(STR_String busc,CListValue* sumolist) { for (int j=0;jGetCount();j++) { KX_GameObject* gameobje = (KX_GameObject*) sumolist->GetValue(j); if (gameobje->GetName()==busc) return gameobje; } return 0; } /* helper for BL_ConvertBlenderObjects, avoids code duplication * note: all var names match args are passed from the caller */ static void bl_ConvertBlenderObject_Single( KX_BlenderSceneConverter *converter, Scene *blenderscene, Object *blenderobject, vector &inivel, vector &iniang, vector &vec_parent_child, CListValue* logicbrick_conversionlist, CListValue* objectlist, CListValue* inactivelist, CListValue* sumolist, KX_Scene* kxscene, KX_GameObject* gameobj, SCA_LogicManager* logicmgr, SCA_TimeEventManager* timemgr, bool isInActiveLayer ) { MT_Point3 posPrev; MT_Matrix3x3 angor; if (converter->addInitFromFrame) blenderscene->r.cfra=blenderscene->r.sfra; MT_Point3 pos( blenderobject->loc[0]+blenderobject->dloc[0], blenderobject->loc[1]+blenderobject->dloc[1], blenderobject->loc[2]+blenderobject->dloc[2] ); MT_Matrix3x3 rotation; float rotmat[3][3]; BKE_object_rot_to_mat3(blenderobject, rotmat, false); rotation.setValue3x3((float*)rotmat); MT_Vector3 scale(blenderobject->size); if (converter->addInitFromFrame) {//rcruiz blenderscene->r.cfra=blenderscene->r.sfra-1; //XXX update_for_newframe(); MT_Vector3 tmp=pos-MT_Point3(blenderobject->loc[0]+blenderobject->dloc[0], blenderobject->loc[1]+blenderobject->dloc[1], blenderobject->loc[2]+blenderobject->dloc[2] ); float rotmatPrev[3][3]; BKE_object_rot_to_mat3(blenderobject, rotmatPrev, false); float eulxyz[3], eulxyzPrev[3]; mat3_to_eul(eulxyz, rotmat); mat3_to_eul(eulxyzPrev, rotmatPrev); double fps = (double) blenderscene->r.frs_sec/ (double) blenderscene->r.frs_sec_base; tmp.scale(fps, fps, fps); inivel.push_back(tmp); tmp[0]=eulxyz[0]-eulxyzPrev[0]; tmp[1]=eulxyz[1]-eulxyzPrev[1]; tmp[2]=eulxyz[2]-eulxyzPrev[2]; tmp.scale(fps, fps, fps); iniang.push_back(tmp); blenderscene->r.cfra=blenderscene->r.sfra; //XXX update_for_newframe(); } gameobj->NodeSetLocalPosition(pos); gameobj->NodeSetLocalOrientation(rotation); gameobj->NodeSetLocalScale(scale); gameobj->NodeUpdateGS(0); sumolist->Add(gameobj->AddRef()); BL_ConvertProperties(blenderobject,gameobj,timemgr,kxscene,isInActiveLayer); gameobj->SetName(blenderobject->id.name + 2); // update children/parent hierarchy if ((blenderobject->parent != 0)&&(!converter->addInitFromFrame)) { // blender has an additional 'parentinverse' offset in each object SG_Callbacks callback(NULL,NULL,NULL,KX_Scene::KX_ScenegraphUpdateFunc,KX_Scene::KX_ScenegraphRescheduleFunc); SG_Node* parentinversenode = new SG_Node(NULL,kxscene,callback); // define a normal parent relationship for this node. KX_NormalParentRelation * parent_relation = KX_NormalParentRelation::New(); parentinversenode->SetParentRelation(parent_relation); parentChildLink pclink; pclink.m_blenderchild = blenderobject; pclink.m_gamechildnode = parentinversenode; vec_parent_child.push_back(pclink); float* fl = (float*) blenderobject->parentinv; MT_Transform parinvtrans(fl); parentinversenode->SetLocalPosition(parinvtrans.getOrigin()); // problem here: the parent inverse transform combines scaling and rotation // in the basis but the scenegraph needs separate rotation and scaling. // This is not important for OpenGL (it uses 4x4 matrix) but it is important // for the physic engine that needs a separate scaling //parentinversenode->SetLocalOrientation(parinvtrans.getBasis()); // Extract the rotation and the scaling from the basis MT_Matrix3x3 ori(parinvtrans.getBasis()); MT_Vector3 x(ori.getColumn(0)); MT_Vector3 y(ori.getColumn(1)); MT_Vector3 z(ori.getColumn(2)); MT_Vector3 parscale(x.length(), y.length(), z.length()); if (!MT_fuzzyZero(parscale[0])) x /= parscale[0]; if (!MT_fuzzyZero(parscale[1])) y /= parscale[1]; if (!MT_fuzzyZero(parscale[2])) z /= parscale[2]; ori.setColumn(0, x); ori.setColumn(1, y); ori.setColumn(2, z); parentinversenode->SetLocalOrientation(ori); parentinversenode->SetLocalScale(parscale); parentinversenode->AddChild(gameobj->GetSGNode()); } // needed for python scripting logicmgr->RegisterGameObjectName(gameobj->GetName(),gameobj); // needed for group duplication logicmgr->RegisterGameObj(blenderobject, gameobj); for (int i = 0; i < gameobj->GetMeshCount(); i++) logicmgr->RegisterGameMeshName(gameobj->GetMesh(i)->GetName(), blenderobject); converter->RegisterGameObject(gameobj, blenderobject); // this was put in rapidly, needs to be looked at more closely // only draw/use objects in active 'blender' layers logicbrick_conversionlist->Add(gameobj->AddRef()); if (converter->addInitFromFrame) { posPrev=gameobj->NodeGetWorldPosition(); angor=gameobj->NodeGetWorldOrientation(); } if (isInActiveLayer) { objectlist->Add(gameobj->AddRef()); //tf.Add(gameobj->GetSGNode()); gameobj->NodeUpdateGS(0); gameobj->AddMeshUser(); } else { //we must store this object otherwise it will be deleted //at the end of this function if it is not a root object inactivelist->Add(gameobj->AddRef()); } if (converter->addInitFromFrame) { gameobj->NodeSetLocalPosition(posPrev); gameobj->NodeSetLocalOrientation(angor); } } // convert blender objects into ketsji gameobjects void BL_ConvertBlenderObjects(struct Main* maggie, KX_Scene* kxscene, KX_KetsjiEngine* ketsjiEngine, e_PhysicsEngine physics_engine, RAS_IRasterizer* rendertools, RAS_ICanvas* canvas, KX_BlenderSceneConverter* converter, bool alwaysUseExpandFraming, bool libloading ) { #define BL_CONVERTBLENDEROBJECT_SINGLE \ bl_ConvertBlenderObject_Single(converter, \ blenderscene, blenderobject, \ inivel, iniang, \ vec_parent_child, \ logicbrick_conversionlist, \ objectlist, inactivelist, sumolist, \ kxscene, gameobj, \ logicmgr, timemgr, \ isInActiveLayer \ ) Scene *blenderscene = kxscene->GetBlenderScene(); // for SETLOOPER Scene *sce_iter; Base *base; // Get the frame settings of the canvas. // Get the aspect ratio of the canvas as designed by the user. RAS_FrameSettings::RAS_FrameType frame_type; int aspect_width; int aspect_height; vector inivel,iniang; set grouplist; // list of groups to be converted set allblobj; // all objects converted set groupobj; // objects from groups (never in active layer) // This is bad, but we use this to make sure the first time this is called // is not in a separate thread. BL_Texture::GetMaxUnits(); if (alwaysUseExpandFraming) { frame_type = RAS_FrameSettings::e_frame_extend; aspect_width = canvas->GetWidth(); aspect_height = canvas->GetHeight(); } else { if (blenderscene->gm.framing.type == SCE_GAMEFRAMING_BARS) { frame_type = RAS_FrameSettings::e_frame_bars; } else if (blenderscene->gm.framing.type == SCE_GAMEFRAMING_EXTEND) { frame_type = RAS_FrameSettings::e_frame_extend; } else { frame_type = RAS_FrameSettings::e_frame_scale; } aspect_width = (int)(blenderscene->r.xsch * blenderscene->r.xasp); aspect_height = (int)(blenderscene->r.ysch * blenderscene->r.yasp); } RAS_FrameSettings frame_settings( frame_type, blenderscene->gm.framing.col[0], blenderscene->gm.framing.col[1], blenderscene->gm.framing.col[2], aspect_width, aspect_height ); kxscene->SetFramingType(frame_settings); kxscene->SetGravity(MT_Vector3(0,0, -blenderscene->gm.gravity)); /* set activity culling parameters */ kxscene->SetActivityCulling( (blenderscene->gm.mode & WO_ACTIVITY_CULLING) != 0); kxscene->SetActivityCullingRadius(blenderscene->gm.activityBoxRadius); kxscene->SetDbvtCulling((blenderscene->gm.mode & WO_DBVT_CULLING) != 0); // no occlusion culling by default kxscene->SetDbvtOcclusionRes(0); int activeLayerBitInfo = blenderscene->lay; // list of all object converted, active and inactive CListValue* sumolist = new CListValue(); vector vec_parent_child; CListValue* objectlist = kxscene->GetObjectList(); CListValue* inactivelist = kxscene->GetInactiveList(); CListValue* parentlist = kxscene->GetRootParentList(); SCA_LogicManager* logicmgr = kxscene->GetLogicManager(); SCA_TimeEventManager* timemgr = kxscene->GetTimeEventManager(); CListValue* logicbrick_conversionlist = new CListValue(); //SG_TreeFactory tf; // Convert actions to actionmap bAction *curAct; for (curAct = (bAction*)maggie->action.first; curAct; curAct=(bAction*)curAct->id.next) { logicmgr->RegisterActionName(curAct->id.name + 2, curAct); } SetDefaultLightMode(blenderscene); // Let's support scene set. // Beware of name conflict in linked data, it will not crash but will create confusion // in Python scripting and in certain actuators (replace mesh). Linked scene *should* have // no conflicting name for Object, Object data and Action. for (SETLOOPER(blenderscene, sce_iter, base)) { Object* blenderobject = base->object; allblobj.insert(blenderobject); KX_GameObject* gameobj = gameobject_from_blenderobject( base->object, kxscene, rendertools, converter, libloading); bool isInActiveLayer = (blenderobject->lay & activeLayerBitInfo) !=0; bool addobj=true; if (converter->addInitFromFrame) if (!isInActiveLayer) addobj=false; if (gameobj) { if (addobj) { /* macro calls object conversion funcs */ BL_CONVERTBLENDEROBJECT_SINGLE; if (gameobj->IsDupliGroup()) { grouplist.insert(blenderobject->dup_group); } } /* Note about memory leak issues: * When a CValue derived class is created, m_refcount is initialized to 1 * so the class must be released after being used to make sure that it won't * hang in memory. If the object needs to be stored for a long time, * use AddRef() so that this Release() does not free the object. * Make sure that for any AddRef() there is a Release()!!!! * Do the same for any object derived from CValue, CExpression and NG_NetworkMessage */ gameobj->Release(); } } if (!grouplist.empty()) { // now convert the group referenced by dupli group object // keep track of all groups already converted set allgrouplist = grouplist; set tempglist; // recurse while (!grouplist.empty()) { set::iterator git; tempglist.clear(); tempglist.swap(grouplist); for (git=tempglist.begin(); git!=tempglist.end(); git++) { Group* group = *git; GroupObject* go; for (go=(GroupObject*)group->gobject.first; go; go=(GroupObject*)go->next) { Object* blenderobject = go->ob; if (converter->FindGameObject(blenderobject) == NULL) { allblobj.insert(blenderobject); groupobj.insert(blenderobject); KX_GameObject* gameobj = gameobject_from_blenderobject( blenderobject, kxscene, rendertools, converter, libloading); // this code is copied from above except that // object from groups are never in active layer bool isInActiveLayer = false; bool addobj=true; if (converter->addInitFromFrame) if (!isInActiveLayer) addobj=false; if (gameobj) { if (addobj) { /* macro calls object conversion funcs */ BL_CONVERTBLENDEROBJECT_SINGLE; } if (gameobj->IsDupliGroup()) { if (allgrouplist.insert(blenderobject->dup_group).second) { grouplist.insert(blenderobject->dup_group); } } /* see comment above re: mem leaks */ gameobj->Release(); } } } } } } // non-camera objects not supported as camera currently if (blenderscene->camera && blenderscene->camera->type == OB_CAMERA) { KX_Camera *gamecamera= (KX_Camera*) converter->FindGameObject(blenderscene->camera); if (gamecamera) kxscene->SetActiveCamera(gamecamera); } // Set up armatures set::iterator oit; for (oit=allblobj.begin(); oit!=allblobj.end(); oit++) { Object* blenderobj = *oit; if (blenderobj->type==OB_MESH) { Mesh *me = (Mesh*)blenderobj->data; if (me->dvert) { BL_DeformableGameObject *obj = (BL_DeformableGameObject*)converter->FindGameObject(blenderobj); if (obj && BL_ModifierDeformer::HasArmatureDeformer(blenderobj) && blenderobj->parent && blenderobj->parent->type==OB_ARMATURE) { KX_GameObject *par = converter->FindGameObject(blenderobj->parent); if (par && obj->GetDeformer()) ((BL_SkinDeformer*)obj->GetDeformer())->SetArmature((BL_ArmatureObject*) par); } } } } // create hierarchy information int i; vector::iterator pcit; for (pcit = vec_parent_child.begin();!(pcit==vec_parent_child.end());++pcit) { struct Object* blenderchild = pcit->m_blenderchild; struct Object* blenderparent = blenderchild->parent; KX_GameObject* parentobj = converter->FindGameObject(blenderparent); KX_GameObject* childobj = converter->FindGameObject(blenderchild); assert(childobj); if (!parentobj || objectlist->SearchValue(childobj) != objectlist->SearchValue(parentobj)) { // special case: the parent and child object are not in the same layer. // This weird situation is used in Apricot for test purposes. // Resolve it by not converting the child childobj->GetSGNode()->DisconnectFromParent(); delete pcit->m_gamechildnode; // Now destroy the child object but also all its descendent that may already be linked // Remove the child reference in the local list! // Note: there may be descendents already if the children of the child were processed // by this loop before the child. In that case, we must remove the children also CListValue* childrenlist = childobj->GetChildrenRecursive(); childrenlist->Add(childobj->AddRef()); for ( i=0;iGetCount();i++) { KX_GameObject* obj = static_cast(childrenlist->GetValue(i)); if (sumolist->RemoveValue(obj)) obj->Release(); if (logicbrick_conversionlist->RemoveValue(obj)) obj->Release(); } childrenlist->Release(); // now destroy recursively converter->UnregisterGameObject(childobj); // removing objects during conversion make sure this runs too kxscene->RemoveObject(childobj); continue; } switch (blenderchild->partype) { case PARVERT1: { // creat a new vertex parent relationship for this node. KX_VertexParentRelation * vertex_parent_relation = KX_VertexParentRelation::New(); pcit->m_gamechildnode->SetParentRelation(vertex_parent_relation); break; } case PARSLOW: { // creat a new slow parent relationship for this node. KX_SlowParentRelation * slow_parent_relation = KX_SlowParentRelation::New(blenderchild->sf); pcit->m_gamechildnode->SetParentRelation(slow_parent_relation); break; } case PARBONE: { // parent this to a bone Bone *parent_bone = BKE_armature_find_bone_name(BKE_armature_from_object(blenderchild->parent), blenderchild->parsubstr); if (parent_bone) { KX_BoneParentRelation *bone_parent_relation = KX_BoneParentRelation::New(parent_bone); pcit->m_gamechildnode->SetParentRelation(bone_parent_relation); } break; } case PARSKEL: // skinned - ignore break; case PAROBJECT: case PARCURVE: case PARKEY: case PARVERT3: default: // unhandled break; } parentobj-> GetSGNode()->AddChild(pcit->m_gamechildnode); } vec_parent_child.clear(); // find 'root' parents (object that has not parents in SceneGraph) for (i=0;iGetCount();++i) { KX_GameObject* gameobj = (KX_GameObject*) sumolist->GetValue(i); if (gameobj->GetSGNode()->GetSGParent() == 0) { parentlist->Add(gameobj->AddRef()); gameobj->NodeUpdateGS(0); } } // create graphic controller for culling if (kxscene->GetDbvtCulling()) { bool occlusion = false; for (i=0; iGetCount();i++) { KX_GameObject* gameobj = (KX_GameObject*) sumolist->GetValue(i); if (gameobj->GetMeshCount() > 0) { MT_Point3 box[2]; gameobj->GetSGNode()->BBox().getmm(box, MT_Transform::Identity()); // box[0] is the min, box[1] is the max bool isactive = objectlist->SearchValue(gameobj); BL_CreateGraphicObjectNew(gameobj,box[0],box[1],kxscene,isactive,physics_engine); if (gameobj->GetOccluder()) occlusion = true; } } if (occlusion) kxscene->SetDbvtOcclusionRes(blenderscene->gm.occlusionRes); } if (blenderscene->world) kxscene->GetPhysicsEnvironment()->SetNumTimeSubSteps(blenderscene->gm.physubstep); // now that the scenegraph is complete, let's instantiate the deformers. // We need that to create reusable derived mesh and physic shapes for (i=0;iGetCount();++i) { KX_GameObject* gameobj = (KX_GameObject*) sumolist->GetValue(i); if (gameobj->GetDeformer()) gameobj->GetDeformer()->UpdateBuckets(); } // Set up armature constraints and shapekey drivers for (i=0;iGetCount();++i) { KX_GameObject* gameobj = (KX_GameObject*) sumolist->GetValue(i); if (gameobj->GetGameObjectType() == SCA_IObject::OBJ_ARMATURE) { BL_ArmatureObject *armobj = (BL_ArmatureObject*)gameobj; armobj->LoadConstraints(converter); CListValue *children = armobj->GetChildren(); for (int j=0; jGetCount();++j) { BL_ShapeDeformer *deform = dynamic_cast(((KX_GameObject*)children->GetValue(j))->GetDeformer()); if (deform) deform->LoadShapeDrivers(armobj); } children->Release(); } } bool processCompoundChildren = false; // create physics information for (i=0;iGetCount();i++) { KX_GameObject* gameobj = (KX_GameObject*) sumolist->GetValue(i); struct Object* blenderobject = gameobj->GetBlenderObject(); int nummeshes = gameobj->GetMeshCount(); RAS_MeshObject* meshobj = 0; if (nummeshes > 0) { meshobj = gameobj->GetMesh(0); } int layerMask = (groupobj.find(blenderobject) == groupobj.end()) ? activeLayerBitInfo : 0; BL_CreatePhysicsObjectNew(gameobj,blenderobject,meshobj,kxscene,layerMask,converter,processCompoundChildren); } processCompoundChildren = true; // create physics information for (i=0;iGetCount();i++) { KX_GameObject* gameobj = (KX_GameObject*) sumolist->GetValue(i); struct Object* blenderobject = gameobj->GetBlenderObject(); int nummeshes = gameobj->GetMeshCount(); RAS_MeshObject* meshobj = 0; if (nummeshes > 0) { meshobj = gameobj->GetMesh(0); } int layerMask = (groupobj.find(blenderobject) == groupobj.end()) ? activeLayerBitInfo : 0; BL_CreatePhysicsObjectNew(gameobj,blenderobject,meshobj,kxscene,layerMask,converter,processCompoundChildren); } //set ini linearVel and int angularVel //rcruiz if (converter->addInitFromFrame) for (i=0;iGetCount();i++) { KX_GameObject* gameobj = (KX_GameObject*) sumolist->GetValue(i); if (gameobj->IsDynamic()) { gameobj->setLinearVelocity(inivel[i],false); gameobj->setAngularVelocity(iniang[i],false); } } // create physics joints for (i=0;iGetCount();i++) { KX_GameObject* gameobj = (KX_GameObject*) sumolist->GetValue(i); struct Object* blenderobject = gameobj->GetBlenderObject(); ListBase *conlist; bConstraint *curcon; conlist = get_active_constraints2(blenderobject); if ((gameobj->GetLayer()&activeLayerBitInfo)==0) continue; if (conlist) { for (curcon = (bConstraint *)conlist->first; curcon; curcon = (bConstraint *)curcon->next) { if (curcon->type==CONSTRAINT_TYPE_RIGIDBODYJOINT) { bRigidBodyJointConstraint *dat=(bRigidBodyJointConstraint *)curcon->data; if (!dat->child && !(curcon->flag & CONSTRAINT_OFF)) { PHY_IPhysicsController* physctr2 = 0; if (dat->tar) { KX_GameObject *gotar=getGameOb(dat->tar->id.name+2,sumolist); if (gotar && ((gotar->GetLayer()&activeLayerBitInfo)!=0) && gotar->GetPhysicsController()) physctr2 = gotar->GetPhysicsController(); } if (gameobj->GetPhysicsController()) { PHY_IPhysicsController* physctrl = gameobj->GetPhysicsController(); //we need to pass a full constraint frame, not just axis //localConstraintFrameBasis MT_Matrix3x3 localCFrame(MT_Vector3(dat->axX,dat->axY,dat->axZ)); MT_Vector3 axis0 = localCFrame.getColumn(0); MT_Vector3 axis1 = localCFrame.getColumn(1); MT_Vector3 axis2 = localCFrame.getColumn(2); int constraintId = kxscene->GetPhysicsEnvironment()->CreateConstraint(physctrl,physctr2,(PHY_ConstraintType)dat->type,(float)dat->pivX, (float)dat->pivY,(float)dat->pivZ, (float)axis0.x(),(float)axis0.y(),(float)axis0.z(), (float)axis1.x(),(float)axis1.y(),(float)axis1.z(), (float)axis2.x(),(float)axis2.y(),(float)axis2.z(),dat->flag); if (constraintId) { //if it is a generic 6DOF constraint, set all the limits accordingly if (dat->type == PHY_GENERIC_6DOF_CONSTRAINT) { int dof; int dofbit=1; for (dof=0;dof<6;dof++) { if (dat->flag & dofbit) { kxscene->GetPhysicsEnvironment()->SetConstraintParam(constraintId,dof,dat->minLimit[dof],dat->maxLimit[dof]); } else { //minLimit > maxLimit means free(disabled limit) for this degree of freedom kxscene->GetPhysicsEnvironment()->SetConstraintParam(constraintId,dof,1,-1); } dofbit<<=1; } } else if (dat->type == PHY_CONE_TWIST_CONSTRAINT) { int dof; int dofbit = 1<<3; // bitflag use_angular_limit_x for (dof=3;dof<6;dof++) { if (dat->flag & dofbit) { kxscene->GetPhysicsEnvironment()->SetConstraintParam(constraintId,dof,dat->minLimit[dof],dat->maxLimit[dof]); } else { //maxLimit < 0 means free(disabled limit) for this degree of freedom kxscene->GetPhysicsEnvironment()->SetConstraintParam(constraintId,dof,1,-1); } dofbit<<=1; } } else if (dat->type == PHY_LINEHINGE_CONSTRAINT) { int dof = 3; // dof for angular x int dofbit = 1<<3; // bitflag use_angular_limit_x if (dat->flag & dofbit) { kxscene->GetPhysicsEnvironment()->SetConstraintParam(constraintId,dof, dat->minLimit[dof],dat->maxLimit[dof]); } else { //minLimit > maxLimit means free(disabled limit) for this degree of freedom kxscene->GetPhysicsEnvironment()->SetConstraintParam(constraintId,dof,1,-1); } } } } } } } } } sumolist->Release(); // convert world KX_WorldInfo* worldinfo = new BlenderWorldInfo(blenderscene, blenderscene->world); converter->RegisterWorldInfo(worldinfo); kxscene->SetWorldInfo(worldinfo); //create object representations for obstacle simulation KX_ObstacleSimulation* obssimulation = kxscene->GetObstacleSimulation(); if (obssimulation) { for ( i=0;iGetCount();i++) { KX_GameObject* gameobj = static_cast(objectlist->GetValue(i)); struct Object* blenderobject = gameobj->GetBlenderObject(); if (blenderobject->gameflag & OB_HASOBSTACLE) { obssimulation->AddObstacleForObj(gameobj); } } } //process navigation mesh objects for ( i=0; iGetCount();i++) { KX_GameObject* gameobj = static_cast(objectlist->GetValue(i)); struct Object* blenderobject = gameobj->GetBlenderObject(); if (blenderobject->type==OB_MESH && (blenderobject->gameflag & OB_NAVMESH)) { KX_NavMeshObject* navmesh = static_cast(gameobj); navmesh->SetVisible(0, true); navmesh->BuildNavMesh(); if (obssimulation) obssimulation->AddObstaclesForNavMesh(navmesh); } } for ( i=0; iGetCount();i++) { KX_GameObject* gameobj = static_cast(inactivelist->GetValue(i)); struct Object* blenderobject = gameobj->GetBlenderObject(); if (blenderobject->type==OB_MESH && (blenderobject->gameflag & OB_NAVMESH)) { KX_NavMeshObject* navmesh = static_cast(gameobj); navmesh->SetVisible(0, true); } } #define CONVERT_LOGIC #ifdef CONVERT_LOGIC // convert logic bricks, sensors, controllers and actuators for (i=0;iGetCount();i++) { KX_GameObject* gameobj = static_cast(logicbrick_conversionlist->GetValue(i)); struct Object* blenderobj = gameobj->GetBlenderObject(); int layerMask = (groupobj.find(blenderobj) == groupobj.end()) ? activeLayerBitInfo : 0; bool isInActiveLayer = (blenderobj->lay & layerMask)!=0; BL_ConvertActuators(maggie->name, blenderobj,gameobj,logicmgr,kxscene,ketsjiEngine,layerMask,isInActiveLayer,converter); } for ( i=0;iGetCount();i++) { KX_GameObject* gameobj = static_cast(logicbrick_conversionlist->GetValue(i)); struct Object* blenderobj = gameobj->GetBlenderObject(); int layerMask = (groupobj.find(blenderobj) == groupobj.end()) ? activeLayerBitInfo : 0; bool isInActiveLayer = (blenderobj->lay & layerMask)!=0; BL_ConvertControllers(blenderobj,gameobj,logicmgr, layerMask,isInActiveLayer,converter, libloading); } for ( i=0;iGetCount();i++) { KX_GameObject* gameobj = static_cast(logicbrick_conversionlist->GetValue(i)); struct Object* blenderobj = gameobj->GetBlenderObject(); int layerMask = (groupobj.find(blenderobj) == groupobj.end()) ? activeLayerBitInfo : 0; bool isInActiveLayer = (blenderobj->lay & layerMask)!=0; BL_ConvertSensors(blenderobj,gameobj,logicmgr,kxscene,ketsjiEngine,layerMask,isInActiveLayer,canvas,converter); // set the init state to all objects gameobj->SetInitState((blenderobj->init_state)?blenderobj->init_state:blenderobj->state); } // apply the initial state to controllers, only on the active objects as this registers the sensors for ( i=0;iGetCount();i++) { KX_GameObject* gameobj = static_cast(objectlist->GetValue(i)); gameobj->ResetState(); } #endif //CONVERT_LOGIC logicbrick_conversionlist->Release(); // Calculate the scene btree - // too slow - commented out. //kxscene->SetNodeTree(tf.MakeTree()); // instantiate dupli group, we will loop trough the object // that are in active layers. Note that duplicating group // has the effect of adding objects at the end of objectlist. // Only loop through the first part of the list. int objcount = objectlist->GetCount(); for (i=0;iGetValue(i); if (gameobj->IsDupliGroup()) { kxscene->DupliGroupRecurse(gameobj, 0); } } KX_Camera *activecam = kxscene->GetActiveCamera(); MT_Scalar distance = (activecam)? activecam->GetCameraFar() - activecam->GetCameraNear(): 100.0f; RAS_BucketManager *bucketmanager = kxscene->GetBucketManager(); bucketmanager->OptimizeBuckets(distance); } SCA_IInputDevice::KX_EnumInputs ConvertKeyCode(int key_code) { return gReverseKeyTranslateTable[key_code]; }