|
Blender
V2.59
|
00001 /* 00002 * $Id: KX_ConvertActuators.cpp 37750 2011-06-23 09:27:56Z campbellbarton $ 00003 * 00004 * ***** BEGIN GPL LICENSE BLOCK ***** 00005 * 00006 * This program is free software; you can redistribute it and/or 00007 * modify it under the terms of the GNU General Public License 00008 * as published by the Free Software Foundation; either version 2 00009 * of the License, or (at your option) any later version. 00010 * 00011 * This program is distributed in the hope that it will be useful, 00012 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00013 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00014 * GNU General Public License for more details. 00015 * 00016 * You should have received a copy of the GNU General Public License 00017 * along with this program; if not, write to the Free Software Foundation, 00018 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 00019 * 00020 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. 00021 * All rights reserved. 00022 * 00023 * The Original Code is: all of this file. 00024 * 00025 * Contributor(s): none yet. 00026 * 00027 * ***** END GPL LICENSE BLOCK ***** 00028 * Convert Blender actuators for use in the GameEngine 00029 */ 00030 00036 #if defined(WIN32) && !defined(FREE_WINDOWS) 00037 #pragma warning (disable : 4786) 00038 #endif //WIN32 00039 00040 #include <math.h> 00041 00042 #include "MEM_guardedalloc.h" 00043 00044 #include "KX_BlenderSceneConverter.h" 00045 #include "KX_ConvertActuators.h" 00046 00047 #ifdef WITH_AUDASPACE 00048 # include "AUD_C-API.h" 00049 #endif 00050 00051 // Actuators 00052 //SCA logiclibrary native logicbricks 00053 #include "SCA_PropertyActuator.h" 00054 #include "SCA_LogicManager.h" 00055 #include "SCA_RandomActuator.h" 00056 #include "SCA_2DFilterActuator.h" 00057 00058 // Ketsji specific logicbricks 00059 #include "KX_SceneActuator.h" 00060 #include "KX_IpoActuator.h" 00061 #include "KX_SoundActuator.h" 00062 #include "KX_ObjectActuator.h" 00063 #include "KX_TrackToActuator.h" 00064 #include "KX_ConstraintActuator.h" 00065 #include "KX_CameraActuator.h" 00066 #include "KX_GameActuator.h" 00067 #include "KX_StateActuator.h" 00068 #include "KX_VisibilityActuator.h" 00069 #include "KX_SCA_AddObjectActuator.h" 00070 #include "KX_SCA_EndObjectActuator.h" 00071 #include "KX_SCA_ReplaceMeshActuator.h" 00072 #include "KX_ParentActuator.h" 00073 #include "KX_SCA_DynamicActuator.h" 00074 00075 #include "KX_Scene.h" 00076 #include "KX_KetsjiEngine.h" 00077 00078 #include "IntValue.h" 00079 #include "KX_GameObject.h" 00080 00081 /* This little block needed for linking to Blender... */ 00082 #include "BKE_text.h" 00083 #include "BLI_blenlib.h" 00084 #include "BLI_math_base.h" 00085 00086 #define FILE_MAX 240 // repeated here to avoid dependency from BKE_utildefines.h 00087 00088 #include "KX_NetworkMessageActuator.h" 00089 00090 #ifdef WIN32 00091 #include "BLI_winstuff.h" 00092 #endif 00093 00094 #include "DNA_object_types.h" 00095 #include "DNA_sound_types.h" 00096 #include "DNA_scene_types.h" 00097 #include "DNA_actuator_types.h" 00098 #include "DNA_packedFile_types.h" 00099 #include "BL_ActionActuator.h" 00100 #include "BL_ShapeActionActuator.h" 00101 #include "BL_ArmatureActuator.h" 00102 /* end of blender include block */ 00103 00104 #include "BL_BlenderDataConversion.h" 00105 00110 #define KX_BLENDERTRUNC(x) (( x < 0.0001 && x > -0.0001 ) ? 0.0 : x) 00111 00112 void BL_ConvertActuators(char* maggiename, 00113 struct Object* blenderobject, 00114 KX_GameObject* gameobj, 00115 SCA_LogicManager* logicmgr, 00116 KX_Scene* scene, 00117 KX_KetsjiEngine* ketsjiEngine, 00118 int activeLayerBitInfo, 00119 bool isInActiveLayer, 00120 RAS_IRenderTools* rendertools, 00121 KX_BlenderSceneConverter* converter 00122 ) 00123 { 00124 00125 int uniqueint = 0; 00126 int actcount = 0; 00127 int executePriority = 0; 00128 bActuator* bact = (bActuator*) blenderobject->actuators.first; 00129 while (bact) 00130 { 00131 actcount++; 00132 bact = bact->next; 00133 } 00134 gameobj->ReserveActuator(actcount); 00135 bact = (bActuator*) blenderobject->actuators.first; 00136 while(bact) 00137 { 00138 STR_String uniquename = bact->name; 00139 STR_String& objectname = gameobj->GetName(); 00140 00141 SCA_IActuator* baseact = NULL; 00142 switch (bact->type) 00143 { 00144 case ACT_OBJECT: 00145 { 00146 bObjectActuator* obact = (bObjectActuator*) bact->data; 00147 KX_GameObject* obref = NULL; 00148 MT_Vector3 forcevec(KX_BLENDERTRUNC(obact->forceloc[0]), 00149 KX_BLENDERTRUNC(obact->forceloc[1]), 00150 KX_BLENDERTRUNC(obact->forceloc[2])); 00151 MT_Vector3 torquevec(obact->forcerot[0],obact->forcerot[1],obact->forcerot[2]); 00152 MT_Vector3 dlocvec ( KX_BLENDERTRUNC(obact->dloc[0]), 00153 KX_BLENDERTRUNC(obact->dloc[1]), 00154 KX_BLENDERTRUNC(obact->dloc[2])); 00155 MT_Vector3 drotvec ( KX_BLENDERTRUNC(obact->drot[0]),obact->drot[1],obact->drot[2]); 00156 MT_Vector3 linvelvec ( KX_BLENDERTRUNC(obact->linearvelocity[0]), 00157 KX_BLENDERTRUNC(obact->linearvelocity[1]), 00158 KX_BLENDERTRUNC(obact->linearvelocity[2])); 00159 MT_Vector3 angvelvec ( KX_BLENDERTRUNC(obact->angularvelocity[0]), 00160 KX_BLENDERTRUNC(obact->angularvelocity[1]), 00161 KX_BLENDERTRUNC(obact->angularvelocity[2])); 00162 short damping = obact->damping; 00163 00164 /* Blender uses a bit vector internally for the local-flags. In */ 00165 /* KX, we have four bools. The compiler should be smart enough */ 00166 /* to do the right thing. We need to explicitly convert here! */ 00167 00168 KX_LocalFlags bitLocalFlag; 00169 00170 bitLocalFlag.Force = bool((obact->flag & ACT_FORCE_LOCAL)!=0); 00171 bitLocalFlag.Torque = bool((obact->flag & ACT_TORQUE_LOCAL) !=0);//rlocal; 00172 bitLocalFlag.DLoc = bool((obact->flag & ACT_DLOC_LOCAL)!=0); 00173 bitLocalFlag.DRot = bool((obact->flag & ACT_DROT_LOCAL)!=0); 00174 bitLocalFlag.LinearVelocity = bool((obact->flag & ACT_LIN_VEL_LOCAL)!=0); 00175 bitLocalFlag.AngularVelocity = bool((obact->flag & ACT_ANG_VEL_LOCAL)!=0); 00176 bitLocalFlag.ServoControl = bool(obact->type == ACT_OBJECT_SERVO); 00177 bitLocalFlag.AddOrSetLinV = bool((obact->flag & ACT_ADD_LIN_VEL)!=0); 00178 if (obact->reference && bitLocalFlag.ServoControl) 00179 { 00180 obref = converter->FindGameObject(obact->reference); 00181 } 00182 00183 KX_ObjectActuator* tmpbaseact = new KX_ObjectActuator(gameobj, 00184 obref, 00185 forcevec.getValue(), 00186 torquevec.getValue(), 00187 dlocvec.getValue(), 00188 drotvec.getValue(), 00189 linvelvec.getValue(), 00190 angvelvec.getValue(), 00191 damping, 00192 bitLocalFlag 00193 ); 00194 baseact = tmpbaseact; 00195 break; 00196 } 00197 case ACT_ACTION: 00198 { 00199 if (blenderobject->type==OB_ARMATURE){ 00200 bActionActuator* actact = (bActionActuator*) bact->data; 00201 STR_String propname = (actact->name ? actact->name : ""); 00202 STR_String propframe = (actact->frameProp ? actact->frameProp : ""); 00203 00204 BL_ActionActuator* tmpbaseact = new BL_ActionActuator( 00205 gameobj, 00206 propname, 00207 propframe, 00208 actact->sta, 00209 actact->end, 00210 actact->act, 00211 actact->type, // + 1, because Blender starts to count at zero, 00212 actact->blendin, 00213 actact->priority, 00214 actact->end_reset, 00215 actact->stridelength 00216 // Ketsji at 1, because zero is reserved for "NoDef" 00217 ); 00218 baseact= tmpbaseact; 00219 break; 00220 } 00221 else 00222 printf ("Discarded action actuator from non-armature object [%s]\n", blenderobject->id.name+2); 00223 } 00224 case ACT_SHAPEACTION: 00225 { 00226 if (blenderobject->type==OB_MESH){ 00227 bActionActuator* actact = (bActionActuator*) bact->data; 00228 STR_String propname = (actact->name ? actact->name : ""); 00229 STR_String propframe = (actact->frameProp ? actact->frameProp : ""); 00230 00231 BL_ShapeActionActuator* tmpbaseact = new BL_ShapeActionActuator( 00232 gameobj, 00233 propname, 00234 propframe, 00235 actact->sta, 00236 actact->end, 00237 actact->act, 00238 actact->type, // + 1, because Blender starts to count at zero, 00239 actact->blendin, 00240 actact->priority, 00241 actact->stridelength 00242 // Ketsji at 1, because zero is reserved for "NoDef" 00243 ); 00244 baseact= tmpbaseact; 00245 break; 00246 } 00247 else 00248 printf ("Discarded shape action actuator from non-mesh object [%s]\n", blenderobject->id.name+2); 00249 } 00250 case ACT_IPO: 00251 { 00252 bIpoActuator* ipoact = (bIpoActuator*) bact->data; 00253 bool ipochild = (ipoact->flag & ACT_IPOCHILD) !=0; 00254 STR_String propname = ipoact->name; 00255 STR_String frameProp = ipoact->frameProp; 00256 // first bit? 00257 bool ipo_as_force = (ipoact->flag & ACT_IPOFORCE); 00258 bool local = (ipoact->flag & ACT_IPOLOCAL); 00259 bool ipo_add = (ipoact->flag & ACT_IPOADD); 00260 00261 KX_IpoActuator* tmpbaseact = new KX_IpoActuator( 00262 gameobj, 00263 propname , 00264 frameProp, 00265 ipoact->sta, 00266 ipoact->end, 00267 ipochild, 00268 ipoact->type + 1, // + 1, because Blender starts to count at zero, 00269 // Ketsji at 1, because zero is reserved for "NoDef" 00270 ipo_as_force, 00271 ipo_add, 00272 local); 00273 baseact = tmpbaseact; 00274 break; 00275 } 00276 case ACT_LAMP: 00277 { 00278 break; 00279 } 00280 case ACT_CAMERA: 00281 { 00282 bCameraActuator *camact = (bCameraActuator *) bact->data; 00283 if (camact->ob) { 00284 KX_GameObject *tmpgob = converter->FindGameObject(camact->ob); 00285 00286 /* visifac, fac and axis are not copied from the struct... */ 00287 /* that's some internal state... */ 00288 KX_CameraActuator *tmpcamact 00289 = new KX_CameraActuator(gameobj, 00290 tmpgob, 00291 camact->height, 00292 camact->min, 00293 camact->max, 00294 camact->axis=='x', 00295 camact->damping); 00296 baseact = tmpcamact; 00297 } 00298 break; 00299 } 00300 case ACT_MESSAGE: 00301 { 00302 bMessageActuator *msgAct = (bMessageActuator *) bact->data; 00303 00308 STR_String toPropName = (msgAct->toPropName 00309 ? (char*) msgAct->toPropName 00310 : ""); 00311 00315 STR_String subject = (msgAct->subject 00316 ? (char*) msgAct->subject 00317 : ""); 00318 00322 int bodyType = msgAct->bodyType; 00323 00328 STR_String body = (msgAct->body 00329 ? (char*) msgAct->body 00330 : ""); 00331 00332 KX_NetworkMessageActuator *tmpmsgact = 00333 new KX_NetworkMessageActuator( 00334 gameobj, // actuator controlling object 00335 scene->GetNetworkScene(), // needed for replication 00336 toPropName, 00337 subject, 00338 bodyType, 00339 body); 00340 baseact = tmpmsgact; 00341 break; 00342 } 00343 case ACT_MATERIAL: 00344 { 00345 break; 00346 } 00347 case ACT_SOUND: 00348 { 00349 bSoundActuator* soundact = (bSoundActuator*) bact->data; 00350 /* get type, and possibly a start and end frame */ 00351 KX_SoundActuator::KX_SOUNDACT_TYPE 00352 soundActuatorType = KX_SoundActuator::KX_SOUNDACT_NODEF; 00353 00354 switch(soundact->type) { 00355 case ACT_SND_PLAY_STOP_SOUND: 00356 soundActuatorType = KX_SoundActuator::KX_SOUNDACT_PLAYSTOP; 00357 break; 00358 case ACT_SND_PLAY_END_SOUND: 00359 soundActuatorType = KX_SoundActuator::KX_SOUNDACT_PLAYEND; 00360 break; 00361 case ACT_SND_LOOP_STOP_SOUND: 00362 soundActuatorType = KX_SoundActuator::KX_SOUNDACT_LOOPSTOP; 00363 break; 00364 case ACT_SND_LOOP_END_SOUND: 00365 soundActuatorType = KX_SoundActuator::KX_SOUNDACT_LOOPEND; 00366 break; 00367 case ACT_SND_LOOP_BIDIRECTIONAL_SOUND: 00368 soundActuatorType = KX_SoundActuator::KX_SOUNDACT_LOOPBIDIRECTIONAL; 00369 break; 00370 case ACT_SND_LOOP_BIDIRECTIONAL_STOP_SOUND: 00371 soundActuatorType = KX_SoundActuator::KX_SOUNDACT_LOOPBIDIRECTIONAL_STOP; 00372 break; 00373 00374 default: 00375 /* This is an error!!! */ 00376 soundActuatorType = KX_SoundActuator::KX_SOUNDACT_NODEF; 00377 } 00378 00379 if (soundActuatorType != KX_SoundActuator::KX_SOUNDACT_NODEF) 00380 { 00381 bSound* sound = soundact->sound; 00382 bool is3d = soundact->flag & ACT_SND_3D_SOUND ? true : false; 00383 AUD_Sound* snd_sound = NULL; 00384 KX_3DSoundSettings settings; 00385 settings.cone_inner_angle = soundact->sound3D.cone_inner_angle; 00386 settings.cone_outer_angle = soundact->sound3D.cone_outer_angle; 00387 settings.cone_outer_gain = soundact->sound3D.cone_outer_gain; 00388 settings.max_distance = soundact->sound3D.max_distance; 00389 settings.max_gain = soundact->sound3D.max_gain; 00390 settings.min_gain = soundact->sound3D.min_gain; 00391 settings.reference_distance = soundact->sound3D.reference_distance; 00392 settings.rolloff_factor = soundact->sound3D.rolloff_factor; 00393 00394 if(!sound) 00395 { 00396 std::cout << "WARNING: Sound actuator \"" << bact->name << 00397 "\" from object \"" << blenderobject->id.name+2 << 00398 "\" has no sound datablock." << std::endl; 00399 } 00400 else 00401 snd_sound = sound->playback_handle; 00402 KX_SoundActuator* tmpsoundact = 00403 new KX_SoundActuator(gameobj, 00404 snd_sound, 00405 soundact->volume, 00406 (float)(exp((soundact->pitch / 12.0) * M_LN2)), 00407 is3d, 00408 settings, 00409 soundActuatorType); 00410 00411 tmpsoundact->SetName(bact->name); 00412 baseact = tmpsoundact; 00413 } 00414 break; 00415 } 00416 case ACT_PROPERTY: 00417 { 00418 bPropertyActuator* propact = (bPropertyActuator*) bact->data; 00419 SCA_IObject* destinationObj = NULL; 00420 00421 /* 00422 here the destinationobject is searched. problem with multiple scenes: other scenes 00423 have not been converted yet, so the destobj will not be found, so the prop will 00424 not be copied. 00425 possible solutions: 00426 - convert everything when possible and not realtime only when needed. 00427 - let the object-with-property report itself to the act when converted 00428 */ 00429 if (propact->ob) 00430 destinationObj = converter->FindGameObject(propact->ob); 00431 00432 SCA_PropertyActuator* tmppropact = new SCA_PropertyActuator( 00433 gameobj, 00434 destinationObj, 00435 propact->name, 00436 propact->value, 00437 propact->type+1); // + 1 because Ketsji Logic starts 00438 // with 0 for KX_ACT_PROP_NODEF 00439 baseact = tmppropact; 00440 break; 00441 } 00442 case ACT_EDIT_OBJECT: 00443 { 00444 bEditObjectActuator *editobact 00445 = (bEditObjectActuator *) bact->data; 00446 /* There are four different kinds of 'edit object' thingies */ 00447 /* The alternative to this lengthy conversion is packing */ 00448 /* several actuators in one, which is not very nice design.. */ 00449 switch (editobact->type) { 00450 case ACT_EDOB_ADD_OBJECT: 00451 { 00452 00453 // does the 'original' for replication exists, and 00454 // is it in a non-active layer ? 00455 SCA_IObject* originalval = NULL; 00456 if (editobact->ob) 00457 { 00458 if (editobact->ob->lay & activeLayerBitInfo) 00459 { 00460 fprintf(stderr, "Warning, object \"%s\" from AddObject actuator \"%s\" is not in a hidden layer.\n", objectname.Ptr(), uniquename.Ptr()); 00461 } 00462 else { 00463 originalval = converter->FindGameObject(editobact->ob); 00464 } 00465 } 00466 00467 KX_SCA_AddObjectActuator* tmpaddact = 00468 new KX_SCA_AddObjectActuator( 00469 gameobj, 00470 originalval, 00471 editobact->time, 00472 scene, 00473 editobact->linVelocity, 00474 (editobact->localflag & ACT_EDOB_LOCAL_LINV)!=0, 00475 editobact->angVelocity, 00476 (editobact->localflag & ACT_EDOB_LOCAL_ANGV)!=0 00477 ); 00478 00479 //editobact->ob to gameobj 00480 baseact = tmpaddact; 00481 } 00482 break; 00483 case ACT_EDOB_END_OBJECT: 00484 { 00485 KX_SCA_EndObjectActuator* tmpendact 00486 = new KX_SCA_EndObjectActuator(gameobj,scene); 00487 baseact = tmpendact; 00488 } 00489 break; 00490 case ACT_EDOB_REPLACE_MESH: 00491 { 00492 RAS_MeshObject *tmpmesh = NULL; 00493 if (editobact->me) 00494 tmpmesh = BL_ConvertMesh( 00495 editobact->me, 00496 blenderobject, 00497 scene, 00498 converter 00499 ); 00500 00501 KX_SCA_ReplaceMeshActuator* tmpreplaceact 00502 = new KX_SCA_ReplaceMeshActuator( 00503 gameobj, 00504 tmpmesh, 00505 scene, 00506 (editobact->flag & ACT_EDOB_REPLACE_MESH_NOGFX)==0, 00507 (editobact->flag & ACT_EDOB_REPLACE_MESH_PHYS)!=0 00508 00509 ); 00510 00511 baseact = tmpreplaceact; 00512 } 00513 break; 00514 case ACT_EDOB_TRACK_TO: 00515 { 00516 SCA_IObject* originalval = NULL; 00517 if (editobact->ob) 00518 originalval = converter->FindGameObject(editobact->ob); 00519 00520 KX_TrackToActuator* tmptrackact 00521 = new KX_TrackToActuator(gameobj, 00522 originalval, 00523 editobact->time, 00524 editobact->flag, 00525 blenderobject->trackflag, 00526 blenderobject->upflag 00527 ); 00528 baseact = tmptrackact; 00529 break; 00530 } 00531 case ACT_EDOB_DYNAMICS: 00532 { 00533 KX_SCA_DynamicActuator* tmpdynact 00534 = new KX_SCA_DynamicActuator(gameobj, 00535 editobact->dyn_operation, 00536 editobact->mass 00537 ); 00538 baseact = tmpdynact; 00539 } 00540 } 00541 break; 00542 } 00543 case ACT_CONSTRAINT: 00544 { 00545 float min = 0.0, max = 0.0; 00546 char *prop = NULL; 00547 KX_ConstraintActuator::KX_CONSTRAINTTYPE locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_NODEF; 00548 bConstraintActuator *conact 00549 = (bConstraintActuator*) bact->data; 00550 /* convert settings... degrees in the ui become radians */ 00551 /* internally */ 00552 if (conact->type == ACT_CONST_TYPE_ORI) { 00553 min = (float)((MT_2_PI * conact->minloc[0])/360.0); 00554 max = (float)((MT_2_PI * conact->maxloc[0])/360.0); 00555 switch (conact->mode) { 00556 case ACT_CONST_DIRPX: 00557 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_ORIX; 00558 break; 00559 case ACT_CONST_DIRPY: 00560 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_ORIY; 00561 break; 00562 case ACT_CONST_DIRPZ: 00563 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_ORIZ; 00564 break; 00565 } 00566 } else if (conact->type == ACT_CONST_TYPE_DIST) { 00567 switch (conact->mode) { 00568 case ACT_CONST_DIRPX: 00569 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRPX; 00570 min = conact->minloc[0]; 00571 max = conact->maxloc[0]; 00572 break; 00573 case ACT_CONST_DIRPY: 00574 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRPY; 00575 min = conact->minloc[1]; 00576 max = conact->maxloc[1]; 00577 break; 00578 case ACT_CONST_DIRPZ: 00579 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRPZ; 00580 min = conact->minloc[2]; 00581 max = conact->maxloc[2]; 00582 break; 00583 case ACT_CONST_DIRNX: 00584 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRNX; 00585 min = conact->minloc[0]; 00586 max = conact->maxloc[0]; 00587 break; 00588 case ACT_CONST_DIRNY: 00589 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRNY; 00590 min = conact->minloc[1]; 00591 max = conact->maxloc[1]; 00592 break; 00593 case ACT_CONST_DIRNZ: 00594 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRNZ; 00595 min = conact->minloc[2]; 00596 max = conact->maxloc[2]; 00597 break; 00598 } 00599 prop = conact->matprop; 00600 } else if (conact->type == ACT_CONST_TYPE_FH) { 00601 switch (conact->mode) { 00602 case ACT_CONST_DIRPX: 00603 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHPX; 00604 min = conact->minloc[0]; 00605 max = conact->maxloc[0]; 00606 break; 00607 case ACT_CONST_DIRPY: 00608 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHPY; 00609 min = conact->minloc[1]; 00610 max = conact->maxloc[1]; 00611 break; 00612 case ACT_CONST_DIRPZ: 00613 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHPZ; 00614 min = conact->minloc[2]; 00615 max = conact->maxloc[2]; 00616 break; 00617 case ACT_CONST_DIRNX: 00618 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHNX; 00619 min = conact->minloc[0]; 00620 max = conact->maxloc[0]; 00621 break; 00622 case ACT_CONST_DIRNY: 00623 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHNY; 00624 min = conact->minloc[1]; 00625 max = conact->maxloc[1]; 00626 break; 00627 case ACT_CONST_DIRNZ: 00628 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHNZ; 00629 min = conact->minloc[2]; 00630 max = conact->maxloc[2]; 00631 break; 00632 } 00633 prop = conact->matprop; 00634 } else { 00635 switch (conact->flag) { 00636 case ACT_CONST_LOCX: 00637 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_LOCX; 00638 min = conact->minloc[0]; 00639 max = conact->maxloc[0]; 00640 break; 00641 case ACT_CONST_LOCY: 00642 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_LOCY; 00643 min = conact->minloc[1]; 00644 max = conact->maxloc[1]; 00645 break; 00646 case ACT_CONST_LOCZ: 00647 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_LOCZ; 00648 min = conact->minloc[2]; 00649 max = conact->maxloc[2]; 00650 break; 00651 case ACT_CONST_ROTX: 00652 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_ROTX; 00653 min = conact->minrot[0] * (float)MT_RADS_PER_DEG; 00654 max = conact->maxrot[0] * (float)MT_RADS_PER_DEG; 00655 break; 00656 case ACT_CONST_ROTY: 00657 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_ROTY; 00658 min = conact->minrot[1] * (float)MT_RADS_PER_DEG; 00659 max = conact->maxrot[1] * (float)MT_RADS_PER_DEG; 00660 break; 00661 case ACT_CONST_ROTZ: 00662 locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_ROTZ; 00663 min = conact->minrot[2] * (float)MT_RADS_PER_DEG; 00664 max = conact->maxrot[2] * (float)MT_RADS_PER_DEG; 00665 break; 00666 default: 00667 ; /* error */ 00668 } 00669 } 00670 KX_ConstraintActuator *tmpconact 00671 = new KX_ConstraintActuator(gameobj, 00672 conact->damp, 00673 conact->rotdamp, 00674 min, 00675 max, 00676 conact->maxrot, 00677 locrot, 00678 conact->time, 00679 conact->flag, 00680 prop); 00681 baseact = tmpconact; 00682 break; 00683 } 00684 case ACT_GROUP: 00685 { 00686 // deprecated 00687 } 00688 break; 00689 case ACT_SCENE: 00690 { 00691 bSceneActuator *sceneact = (bSceneActuator *) bact->data; 00692 STR_String nextSceneName(""); 00693 00694 KX_SceneActuator* tmpsceneact; 00695 int mode = KX_SceneActuator::KX_SCENE_NODEF; 00696 KX_Camera *cam = NULL; 00697 //KX_Scene* scene = NULL; 00698 switch (sceneact->type) 00699 { 00700 case ACT_SCENE_RESUME: 00701 case ACT_SCENE_SUSPEND: 00702 case ACT_SCENE_ADD_FRONT: 00703 case ACT_SCENE_ADD_BACK: 00704 case ACT_SCENE_REMOVE: 00705 case ACT_SCENE_SET: 00706 { 00707 switch (sceneact->type) 00708 { 00709 case ACT_SCENE_RESUME: 00710 mode = KX_SceneActuator::KX_SCENE_RESUME; 00711 break; 00712 case ACT_SCENE_SUSPEND: 00713 mode = KX_SceneActuator::KX_SCENE_SUSPEND; 00714 break; 00715 case ACT_SCENE_ADD_FRONT: 00716 mode = KX_SceneActuator::KX_SCENE_ADD_FRONT_SCENE; 00717 break; 00718 case ACT_SCENE_ADD_BACK: 00719 mode = KX_SceneActuator::KX_SCENE_ADD_BACK_SCENE; 00720 break; 00721 case ACT_SCENE_REMOVE: 00722 mode = KX_SceneActuator::KX_SCENE_REMOVE_SCENE; 00723 break; 00724 case ACT_SCENE_SET: 00725 default: 00726 mode = KX_SceneActuator::KX_SCENE_SET_SCENE; 00727 break; 00728 }; 00729 00730 if (sceneact->scene) 00731 { 00732 nextSceneName = sceneact->scene->id.name + 2; // this '2' is necessary to remove prefix 'SC' 00733 } 00734 00735 break; 00736 } 00737 case ACT_SCENE_CAMERA: 00738 mode = KX_SceneActuator::KX_SCENE_SET_CAMERA; 00739 if (sceneact->camera) 00740 { 00741 cam = (KX_Camera*) converter->FindGameObject(sceneact->camera); 00742 } 00743 break; 00744 case ACT_SCENE_RESTART: 00745 { 00746 00747 mode = KX_SceneActuator::KX_SCENE_RESTART; 00748 break; 00749 } 00750 default: 00751 ; /* flag error */ 00752 } 00753 tmpsceneact = new KX_SceneActuator(gameobj, 00754 mode, 00755 scene, 00756 ketsjiEngine, 00757 nextSceneName, 00758 cam); 00759 baseact = tmpsceneact; 00760 break; 00761 } 00762 case ACT_GAME: 00763 { 00764 bGameActuator *gameact = (bGameActuator *) bact->data; 00765 KX_GameActuator* tmpgameact; 00766 STR_String filename = maggiename; 00767 STR_String loadinganimationname = ""; 00768 int mode = KX_GameActuator::KX_GAME_NODEF; 00769 switch (gameact->type) 00770 { 00771 case ACT_GAME_LOAD: 00772 { 00773 mode = KX_GameActuator::KX_GAME_LOAD; 00774 filename = gameact->filename; 00775 loadinganimationname = gameact->loadaniname; 00776 break; 00777 } 00778 case ACT_GAME_START: 00779 { 00780 mode = KX_GameActuator::KX_GAME_START; 00781 filename = gameact->filename; 00782 loadinganimationname = gameact->loadaniname; 00783 break; 00784 } 00785 case ACT_GAME_RESTART: 00786 { 00787 mode = KX_GameActuator::KX_GAME_RESTART; 00788 break; 00789 } 00790 case ACT_GAME_QUIT: 00791 { 00792 mode = KX_GameActuator::KX_GAME_QUIT; 00793 break; 00794 } 00795 case ACT_GAME_SAVECFG: 00796 { 00797 mode = KX_GameActuator::KX_GAME_SAVECFG; 00798 break; 00799 } 00800 case ACT_GAME_LOADCFG: 00801 { 00802 mode = KX_GameActuator::KX_GAME_LOADCFG; 00803 break; 00804 } 00805 default: 00806 ; /* flag error */ 00807 } 00808 tmpgameact = new KX_GameActuator(gameobj, 00809 mode, 00810 filename, 00811 loadinganimationname, 00812 scene, 00813 ketsjiEngine); 00814 baseact = tmpgameact; 00815 00816 break; 00817 } 00818 case ACT_RANDOM: 00819 { 00820 bRandomActuator *randAct 00821 = (bRandomActuator *) bact->data; 00822 00823 unsigned long seedArg = randAct->seed; 00824 if (seedArg == 0) 00825 { 00826 seedArg = (int)(ketsjiEngine->GetRealTime()*100000.0); 00827 seedArg ^= (intptr_t)randAct; 00828 } 00829 SCA_RandomActuator::KX_RANDOMACT_MODE modeArg 00830 = SCA_RandomActuator::KX_RANDOMACT_NODEF; 00831 SCA_RandomActuator *tmprandomact; 00832 float paraArg1 = 0.0; 00833 float paraArg2 = 0.0; 00834 00835 switch (randAct->distribution) { 00836 case ACT_RANDOM_BOOL_CONST: 00837 modeArg = SCA_RandomActuator::KX_RANDOMACT_BOOL_CONST; 00838 paraArg1 = (float) randAct->int_arg_1; 00839 break; 00840 case ACT_RANDOM_BOOL_UNIFORM: 00841 modeArg = SCA_RandomActuator::KX_RANDOMACT_BOOL_UNIFORM; 00842 break; 00843 case ACT_RANDOM_BOOL_BERNOUILLI: 00844 paraArg1 = randAct->float_arg_1; 00845 modeArg = SCA_RandomActuator::KX_RANDOMACT_BOOL_BERNOUILLI; 00846 break; 00847 case ACT_RANDOM_INT_CONST: 00848 modeArg = SCA_RandomActuator::KX_RANDOMACT_INT_CONST; 00849 paraArg1 = (float) randAct->int_arg_1; 00850 break; 00851 case ACT_RANDOM_INT_UNIFORM: 00852 paraArg1 = (float) randAct->int_arg_1; 00853 paraArg2 = (float) randAct->int_arg_2; 00854 modeArg = SCA_RandomActuator::KX_RANDOMACT_INT_UNIFORM; 00855 break; 00856 case ACT_RANDOM_INT_POISSON: 00857 paraArg1 = randAct->float_arg_1; 00858 modeArg = SCA_RandomActuator::KX_RANDOMACT_INT_POISSON; 00859 break; 00860 case ACT_RANDOM_FLOAT_CONST: 00861 paraArg1 = randAct->float_arg_1; 00862 modeArg = SCA_RandomActuator::KX_RANDOMACT_FLOAT_CONST; 00863 break; 00864 case ACT_RANDOM_FLOAT_UNIFORM: 00865 paraArg1 = randAct->float_arg_1; 00866 paraArg2 = randAct->float_arg_2; 00867 modeArg = SCA_RandomActuator::KX_RANDOMACT_FLOAT_UNIFORM; 00868 break; 00869 case ACT_RANDOM_FLOAT_NORMAL: 00870 paraArg1 = randAct->float_arg_1; 00871 paraArg2 = randAct->float_arg_2; 00872 modeArg = SCA_RandomActuator::KX_RANDOMACT_FLOAT_NORMAL; 00873 break; 00874 case ACT_RANDOM_FLOAT_NEGATIVE_EXPONENTIAL: 00875 paraArg1 = randAct->float_arg_1; 00876 modeArg = SCA_RandomActuator::KX_RANDOMACT_FLOAT_NEGATIVE_EXPONENTIAL; 00877 break; 00878 default: 00879 ; /* error */ 00880 } 00881 tmprandomact = new SCA_RandomActuator(gameobj, 00882 seedArg, 00883 modeArg, 00884 paraArg1, 00885 paraArg2, 00886 randAct->propname); 00887 baseact = tmprandomact; 00888 } 00889 break; 00890 00891 case ACT_VISIBILITY: 00892 { 00893 bVisibilityActuator *vis_act = (bVisibilityActuator *) bact->data; 00894 KX_VisibilityActuator * tmp_vis_act = NULL; 00895 bool v = ((vis_act->flag & ACT_VISIBILITY_INVISIBLE) != 0); 00896 bool o = ((vis_act->flag & ACT_VISIBILITY_OCCLUSION) != 0); 00897 bool recursive = ((vis_act->flag & ACT_VISIBILITY_RECURSIVE) != 0); 00898 00899 tmp_vis_act = new KX_VisibilityActuator(gameobj, !v, o, recursive); 00900 00901 baseact = tmp_vis_act; 00902 } 00903 break; 00904 00905 case ACT_STATE: 00906 { 00907 bStateActuator *sta_act = (bStateActuator *) bact->data; 00908 KX_StateActuator * tmp_sta_act = NULL; 00909 00910 tmp_sta_act = 00911 new KX_StateActuator(gameobj, sta_act->type, sta_act->mask); 00912 00913 baseact = tmp_sta_act; 00914 } 00915 break; 00916 00917 case ACT_2DFILTER: 00918 { 00919 bTwoDFilterActuator *_2dfilter = (bTwoDFilterActuator*) bact->data; 00920 SCA_2DFilterActuator *tmp = NULL; 00921 00922 RAS_2DFilterManager::RAS_2DFILTER_MODE filtermode; 00923 switch(_2dfilter->type) 00924 { 00925 case ACT_2DFILTER_MOTIONBLUR: 00926 filtermode = RAS_2DFilterManager::RAS_2DFILTER_MOTIONBLUR; 00927 break; 00928 case ACT_2DFILTER_BLUR: 00929 filtermode = RAS_2DFilterManager::RAS_2DFILTER_BLUR; 00930 break; 00931 case ACT_2DFILTER_SHARPEN: 00932 filtermode = RAS_2DFilterManager::RAS_2DFILTER_SHARPEN; 00933 break; 00934 case ACT_2DFILTER_DILATION: 00935 filtermode = RAS_2DFilterManager::RAS_2DFILTER_DILATION; 00936 break; 00937 case ACT_2DFILTER_EROSION: 00938 filtermode = RAS_2DFilterManager::RAS_2DFILTER_EROSION; 00939 break; 00940 case ACT_2DFILTER_LAPLACIAN: 00941 filtermode = RAS_2DFilterManager::RAS_2DFILTER_LAPLACIAN; 00942 break; 00943 case ACT_2DFILTER_SOBEL: 00944 filtermode = RAS_2DFilterManager::RAS_2DFILTER_SOBEL; 00945 break; 00946 case ACT_2DFILTER_PREWITT: 00947 filtermode = RAS_2DFilterManager::RAS_2DFILTER_PREWITT; 00948 break; 00949 case ACT_2DFILTER_GRAYSCALE: 00950 filtermode = RAS_2DFilterManager::RAS_2DFILTER_GRAYSCALE; 00951 break; 00952 case ACT_2DFILTER_SEPIA: 00953 filtermode = RAS_2DFilterManager::RAS_2DFILTER_SEPIA; 00954 break; 00955 case ACT_2DFILTER_INVERT: 00956 filtermode = RAS_2DFilterManager::RAS_2DFILTER_INVERT; 00957 break; 00958 case ACT_2DFILTER_CUSTOMFILTER: 00959 filtermode = RAS_2DFilterManager::RAS_2DFILTER_CUSTOMFILTER; 00960 break; 00961 case ACT_2DFILTER_NOFILTER: 00962 filtermode = RAS_2DFilterManager::RAS_2DFILTER_NOFILTER; 00963 break; 00964 case ACT_2DFILTER_DISABLED: 00965 filtermode = RAS_2DFilterManager::RAS_2DFILTER_DISABLED; 00966 break; 00967 case ACT_2DFILTER_ENABLED: 00968 filtermode = RAS_2DFilterManager::RAS_2DFILTER_ENABLED; 00969 break; 00970 default: 00971 filtermode = RAS_2DFilterManager::RAS_2DFILTER_NOFILTER; 00972 break; 00973 } 00974 00975 tmp = new SCA_2DFilterActuator(gameobj, filtermode, _2dfilter->flag, 00976 _2dfilter->float_arg,_2dfilter->int_arg,ketsjiEngine->GetRasterizer(),scene); 00977 00978 if (_2dfilter->text) 00979 { 00980 char *buf; 00981 // this is some blender specific code 00982 buf = txt_to_buf(_2dfilter->text); 00983 if (buf) 00984 { 00985 tmp->SetShaderText(buf); 00986 MEM_freeN(buf); 00987 } 00988 } 00989 00990 baseact = tmp; 00991 00992 } 00993 break; 00994 case ACT_PARENT: 00995 { 00996 bParentActuator *parAct = (bParentActuator *) bact->data; 00997 int mode = KX_ParentActuator::KX_PARENT_NODEF; 00998 bool addToCompound = true; 00999 bool ghost = true; 01000 KX_GameObject *tmpgob = NULL; 01001 01002 switch(parAct->type) 01003 { 01004 case ACT_PARENT_SET: 01005 mode = KX_ParentActuator::KX_PARENT_SET; 01006 tmpgob = converter->FindGameObject(parAct->ob); 01007 addToCompound = !(parAct->flag & ACT_PARENT_COMPOUND); 01008 ghost = !(parAct->flag & ACT_PARENT_GHOST); 01009 break; 01010 case ACT_PARENT_REMOVE: 01011 mode = KX_ParentActuator::KX_PARENT_REMOVE; 01012 tmpgob = NULL; 01013 break; 01014 } 01015 01016 KX_ParentActuator *tmpparact 01017 = new KX_ParentActuator(gameobj, 01018 mode, 01019 addToCompound, 01020 ghost, 01021 tmpgob); 01022 baseact = tmpparact; 01023 break; 01024 } 01025 01026 case ACT_ARMATURE: 01027 { 01028 bArmatureActuator* armAct = (bArmatureActuator*) bact->data; 01029 KX_GameObject *tmpgob = converter->FindGameObject(armAct->target); 01030 KX_GameObject *subgob = converter->FindGameObject(armAct->subtarget); 01031 BL_ArmatureActuator* tmparmact = new BL_ArmatureActuator(gameobj, armAct->type, armAct->posechannel, armAct->constraint, tmpgob, subgob, armAct->weight); 01032 baseact = tmparmact; 01033 break; 01034 } 01035 default: 01036 ; /* generate some error */ 01037 } 01038 01039 if (baseact) 01040 { 01041 baseact->SetExecutePriority(executePriority++); 01042 uniquename += "#ACT#"; 01043 uniqueint++; 01044 CIntValue* uniqueval = new CIntValue(uniqueint); 01045 uniquename += uniqueval->GetText(); 01046 uniqueval->Release(); 01047 baseact->SetName(bact->name); 01048 //gameobj->SetProperty(uniquename,baseact); 01049 gameobj->AddActuator(baseact); 01050 01051 converter->RegisterGameActuator(baseact, bact); 01052 // done with baseact, release it 01053 baseact->Release(); 01054 } 01055 01056 bact = bact->next; 01057 } 01058 } 01059 01060