void KX_BlenderSceneConverter::ResetPhysicsObjectsAnimationIpo(bool clearIpo)
{
//TODO this entire function is deprecated, written for 2.4x
//the functionality should be rewritten, currently it does nothing
KX_SceneList *scenes = m_ketsjiEngine->CurrentScenes();
int numScenes = scenes->size();
int i;
for (i = 0; i < numScenes; i++) {
KX_Scene *scene = scenes->at(i);
CListValue *parentList = scene->GetRootParentList();
int numObjects = parentList->GetCount();
int g;
for (g = 0; g < numObjects; g++) {
KX_GameObject *gameObj = (KX_GameObject *)parentList->GetValue(g);
if (gameObj->IsRecordAnimation()) {
Object *blenderObject = gameObj->GetBlenderObject();
if (blenderObject) {
#if 0
//erase existing ipo's
Ipo* ipo = blenderObject->ipo;//findIpoForName(blenderObject->id.name+2);
if (ipo) { //clear the curve data
if (clearIpo) {//rcruiz
IpoCurve *icu1;
int numCurves = 0;
for ( icu1 = (IpoCurve*)ipo->curve.first; icu1; ) {
IpoCurve* tmpicu = icu1;
/*int i;
BezTriple *bezt;
for ( bezt = tmpicu->bezt, i = 0; i < tmpicu->totvert; i++, bezt++) {
printf("(%f,%f,%f),(%f,%f,%f),(%f,%f,%f)\n",bezt->vec[0][0],bezt->vec[0][1],bezt->vec[0][2],bezt->vec[1][0],bezt->vec[1][1],bezt->vec[1][2],bezt->vec[2][0],bezt->vec[2][1],bezt->vec[2][2]);
}*/
icu1 = icu1->next;
numCurves++;
BLI_remlink( &( blenderObject->ipo->curve ), tmpicu );
if ( tmpicu->bezt )
MEM_freeN( tmpicu->bezt );
MEM_freeN( tmpicu );
localDel_ipoCurve( tmpicu );
}
}
}
else {
ipo = NULL; // XXX add_ipo(blenderObject->id.name+2, ID_OB);
blenderObject->ipo = ipo;
}
#endif
}
}
}
}
}
KX_SoftBodyDeformer::KX_SoftBodyDeformer(RAS_MeshObject *pMeshObject, BL_DeformableGameObject *gameobj)
:m_pMeshObject(pMeshObject),
m_gameobj(gameobj),
m_needUpdateAabb(true)
{
KX_Scene *scene = m_gameobj->GetScene();
RAS_BoundingBoxManager *boundingBoxManager = scene->GetBoundingBoxManager();
m_boundingBox = boundingBoxManager->CreateBoundingBox();
// Set AABB default to mesh bounding box AABB.
m_boundingBox->CopyAabb(m_pMeshObject->GetBoundingBox());
}
void KX_NavMeshObject::ProcessReplica()
{
KX_GameObject::ProcessReplica();
m_navMesh = NULL; /* without this, building frees the navmesh we copied from */
BuildNavMesh();
KX_Scene* scene = KX_GetActiveScene();
KX_ObstacleSimulation* obssimulation = scene->GetObstacleSimulation();
if (obssimulation)
obssimulation->AddObstaclesForNavMesh(this);
}
void KX_NavMeshObject::ProcessReplica()
{
KX_GameObject::ProcessReplica();
BuildNavMesh();
KX_Scene* scene = KX_GetActiveScene();
KX_ObstacleSimulation* obssimulation = scene->GetObstacleSimulation();
if (obssimulation)
obssimulation->AddObstaclesForNavMesh(this);
}
void KX_KetsjiEngine::ClearFrame()
{
// clear unless we're drawing overlapping stereo
if(m_rasterizer->InterlacedStereo() &&
m_rasterizer->GetEye() == RAS_IRasterizer::RAS_STEREO_RIGHTEYE)
return;
// clear the viewports with the background color of the first scene
bool doclear = false;
KX_SceneList::iterator sceneit;
RAS_Rect clearvp, area, viewport;
for (sceneit = m_scenes.begin(); sceneit != m_scenes.end(); sceneit++)
{
KX_Scene* scene = *sceneit;
//const RAS_FrameSettings &framesettings = scene->GetFramingType();
list<class KX_Camera*>* cameras = scene->GetCameras();
list<KX_Camera*>::iterator it;
for(it = cameras->begin(); it != cameras->end(); it++)
{
GetSceneViewport(scene, (*it), area, viewport);
if(!doclear) {
clearvp = viewport;
doclear = true;
}
else {
if(viewport.GetLeft() < clearvp.GetLeft())
clearvp.SetLeft(viewport.GetLeft());
if(viewport.GetBottom() < clearvp.GetBottom())
clearvp.SetBottom(viewport.GetBottom());
if(viewport.GetRight() > clearvp.GetRight())
clearvp.SetRight(viewport.GetRight());
if(viewport.GetTop() > clearvp.GetTop())
clearvp.SetTop(viewport.GetTop());
}
}
}
if(doclear) {
KX_Scene* firstscene = *m_scenes.begin();
SetBackGround(firstscene->GetWorldInfo());
m_canvas->SetViewPort(clearvp.GetLeft(), clearvp.GetBottom(),
clearvp.GetRight(), clearvp.GetTop());
m_rasterizer->ClearColorBuffer();
}
}
void KX_BlenderSceneConverter::TestHandlesPhysicsObjectToAnimationIpo()
{
KX_SceneList *scenes = m_ketsjiEngine->CurrentScenes();
int numScenes = scenes->size();
int i;
for (i = 0; i < numScenes; i++) {
KX_Scene *scene = scenes->at(i);
//PHY_IPhysicsEnvironment* physEnv = scene->GetPhysicsEnvironment();
CListValue *parentList = scene->GetRootParentList();
int numObjects = parentList->GetCount();
int g;
for (g = 0; g < numObjects; g++) {
KX_GameObject *gameObj = (KX_GameObject *)parentList->GetValue(g);
if (gameObj->IsRecordAnimation()) {
Object *blenderObject = gameObj->GetBlenderObject();
if (blenderObject && blenderObject->adt) {
bAction *act = verify_adt_action(&blenderObject->id, false);
FCurve *fcu;
if (!act) {
continue;
}
/* for now, not much choice but to run this on all curves... */
for (fcu = (FCurve *)act->curves.first; fcu; fcu = fcu->next) {
/* Note: calling `sort_time_fcurve()` here is not needed, since
* all keys have been added in 'right' order. */
calchandles_fcurve(fcu);
}
#if 0
// XXX animato
Ipo* ipo = blenderObject->ipo;
//create the curves, if not existing
//testhandles_ipocurve checks for NULL
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"LocX"));
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"LocY"));
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"LocZ"));
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"RotX"));
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"RotY"));
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"RotZ"));
#endif
}
}
}
}
}
void KX_BlenderSceneConverter::TestHandlesPhysicsObjectToAnimationIpo()
{
KX_SceneList* scenes = m_ketsjiEngine->CurrentScenes();
int numScenes = scenes->size();
int i;
for (i=0;i<numScenes;i++)
{
KX_Scene* scene = scenes->at(i);
//PHY_IPhysicsEnvironment* physEnv = scene->GetPhysicsEnvironment();
CListValue* parentList = scene->GetRootParentList();
int numObjects = parentList->GetCount();
int g;
for (g=0;g<numObjects;g++)
{
KX_GameObject* gameObj = (KX_GameObject*)parentList->GetValue(g);
if (gameObj->IsDynamic())
{
//KX_IPhysicsController* physCtrl = gameObj->GetPhysicsController();
Object* blenderObject = gameObj->GetBlenderObject();
if (blenderObject && blenderObject->ipo)
{
// XXX animato
#if 0
Ipo* ipo = blenderObject->ipo;
//create the curves, if not existing
//testhandles_ipocurve checks for NULL
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"LocX"));
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"LocY"));
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"LocZ"));
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"RotX"));
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"RotY"));
testhandles_ipocurve(findIpoCurve((IpoCurve *)ipo->curve.first,"RotZ"));
#endif
}
}
}
}
}
void KX_BlenderSceneConverter::resetNoneDynamicObjectToIpo()
{
if (addInitFromFrame) {
KX_SceneList* scenes = m_ketsjiEngine->CurrentScenes();
int numScenes = scenes->size();
if (numScenes>=0) {
KX_Scene* scene = scenes->at(0);
CListValue* parentList = scene->GetRootParentList();
for (int ix=0;ix<parentList->GetCount();ix++) {
KX_GameObject* gameobj = (KX_GameObject*)parentList->GetValue(ix);
if (!gameobj->IsDynamic()) {
Object* blenderobject = gameobj->GetBlenderObject();
if (!blenderobject)
continue;
if (blenderobject->type==OB_ARMATURE)
continue;
float eu[3];
mat4_to_eul(eu,blenderobject->obmat);
MT_Point3 pos = MT_Point3(
blenderobject->obmat[3][0],
blenderobject->obmat[3][1],
blenderobject->obmat[3][2]
);
MT_Vector3 eulxyz = MT_Vector3(
eu[0],
eu[1],
eu[2]
);
MT_Vector3 scale = MT_Vector3(
blenderobject->size[0],
blenderobject->size[1],
blenderobject->size[2]
);
gameobj->NodeSetLocalPosition(pos);
gameobj->NodeSetLocalOrientation(MT_Matrix3x3(eulxyz));
gameobj->NodeSetLocalScale(scale);
gameobj->NodeUpdateGS(0);
}
}
}
}
}
void KX_KetsjiEngine::RenderDebugProperties()
{
STR_String debugtxt;
int xcoord = 10; // mmmm, these constants were taken from blender source
int ycoord = 14; // to 'mimic' behaviour
float tottime = m_logger->GetAverage();
if (tottime < 1e-6f) {
tottime = 1e-6f;
}
// Set viewport to entire canvas
RAS_Rect viewport;
m_canvas->SetViewPort(0, 0, int(m_canvas->GetWidth()), int(m_canvas->GetHeight()));
/* Framerate display */
if (m_show_framerate) {
debugtxt.Format("swap : %.3f (%.3f frames per second)", tottime, 1.0/tottime);
m_rendertools->RenderText2D(RAS_IRenderTools::RAS_TEXT_PADDED,
debugtxt.Ptr(),
xcoord,
ycoord,
m_canvas->GetWidth() /* RdV, TODO ?? */,
m_canvas->GetHeight() /* RdV, TODO ?? */);
ycoord += 14;
}
/* Profile and framerate display */
if (m_show_profile)
{
for (int j = tc_first; j < tc_numCategories; j++)
{
debugtxt.Format(m_profileLabels[j]);
m_rendertools->RenderText2D(RAS_IRenderTools::RAS_TEXT_PADDED,
debugtxt.Ptr(),
xcoord,ycoord,
m_canvas->GetWidth(),
m_canvas->GetHeight());
double time = m_logger->GetAverage((KX_TimeCategory)j);
debugtxt.Format("%.3fms (%2.2f %%)", time*1000.f, time/tottime * 100.f);
m_rendertools->RenderText2D(RAS_IRenderTools::RAS_TEXT_PADDED,
debugtxt.Ptr(),
xcoord + 60 ,ycoord,
m_canvas->GetWidth(),
m_canvas->GetHeight());
ycoord += 14;
}
}
/* Property display*/
if (m_show_debug_properties && m_propertiesPresent)
{
KX_SceneList::iterator sceneit;
for (sceneit = m_scenes.begin();sceneit != m_scenes.end() ; sceneit++)
{
KX_Scene* scene = *sceneit;
/* the 'normal' debug props */
vector<SCA_DebugProp*>& debugproplist = scene->GetDebugProperties();
for (vector<SCA_DebugProp*>::iterator it = debugproplist.begin();
!(it==debugproplist.end());it++)
{
CValue* propobj = (*it)->m_obj;
STR_String objname = propobj->GetName();
STR_String propname = (*it)->m_name;
if (propname == "__state__")
{
// reserve name for object state
KX_GameObject* gameobj = static_cast<KX_GameObject*>(propobj);
unsigned int state = gameobj->GetState();
debugtxt = objname + "." + propname + " = ";
bool first = true;
for (int statenum=1;state;state >>= 1, statenum++)
{
if (state & 1)
{
if (!first)
{
debugtxt += ",";
}
debugtxt += STR_String(statenum);
first = false;
}
}
m_rendertools->RenderText2D(RAS_IRenderTools::RAS_TEXT_PADDED,
debugtxt.Ptr(),
xcoord,
ycoord,
m_canvas->GetWidth(),
m_canvas->GetHeight());
ycoord += 14;
}
else
{
CValue* propval = propobj->GetProperty(propname);
if (propval)
{
STR_String text = propval->GetText();
debugtxt = objname + "." + propname + " = " + text;
m_rendertools->RenderText2D(RAS_IRenderTools::RAS_TEXT_PADDED,
debugtxt.Ptr(),
xcoord,
ycoord,
m_canvas->GetWidth(),
m_canvas->GetHeight());
ycoord += 14;
}
}
}
void RAS_OpenGLRasterizer::applyTransform(double* oglmatrix,int objectdrawmode )
{
/* FIXME:
blender: intern/moto/include/MT_Vector3.inl:42: MT_Vector3 operator/(const
MT_Vector3&, double): Assertion `!MT_fuzzyZero(s)' failed.
Program received signal SIGABRT, Aborted.
[Switching to Thread 16384 (LWP 1519)]
0x40477571 in kill () from /lib/libc.so.6
(gdb) bt
#7 0x08334368 in MT_Vector3::normalized() const ()
#8 0x0833e6ec in RAS_OpenGLRasterizer::applyTransform(RAS_IRasterizer*, double*, int) ()
*/
if (objectdrawmode & RAS_IPolyMaterial::BILLBOARD_SCREENALIGNED ||
objectdrawmode & RAS_IPolyMaterial::BILLBOARD_AXISALIGNED)
{
// rotate the billboard/halo
//page 360/361 3D Game Engine Design, David Eberly for a discussion
// on screen aligned and axis aligned billboards
// assumed is that the preprocessor transformed all billboard polygons
// so that their normal points into the positive x direction (1.0, 0.0, 0.0)
// when new parenting for objects is done, this rotation
// will be moved into the object
MT_Point3 objpos (oglmatrix[12],oglmatrix[13],oglmatrix[14]);
MT_Point3 campos = GetCameraPosition();
MT_Vector3 dir = (campos - objpos).safe_normalized();
MT_Vector3 up(0,0,1.0);
KX_GameObject* gameobj = (KX_GameObject*)m_clientobject;
// get scaling of halo object
MT_Vector3 size = gameobj->GetSGNode()->GetWorldScaling();
bool screenaligned = (objectdrawmode & RAS_IPolyMaterial::BILLBOARD_SCREENALIGNED)!=0;//false; //either screen or axisaligned
if (screenaligned)
{
up = (up - up.dot(dir) * dir).safe_normalized();
} else
{
dir = (dir - up.dot(dir)*up).safe_normalized();
}
MT_Vector3 left = dir.normalized();
dir = (up.cross(left)).normalized();
// we have calculated the row vectors, now we keep
// local scaling into account:
left *= size[0];
dir *= size[1];
up *= size[2];
double maat[16] = {left[0], left[1], left[2], 0,
dir[0], dir[1], dir[2], 0,
up[0], up[1], up[2], 0,
0, 0, 0, 1};
glTranslated(objpos[0],objpos[1],objpos[2]);
glMultMatrixd(maat);
}
else {
if (objectdrawmode & RAS_IPolyMaterial::SHADOW)
{
// shadow must be cast to the ground, physics system needed here!
MT_Point3 frompoint(oglmatrix[12],oglmatrix[13],oglmatrix[14]);
KX_GameObject *gameobj = (KX_GameObject*)m_clientobject;
MT_Vector3 direction = MT_Vector3(0,0,-1);
direction.normalize();
direction *= 100000;
MT_Point3 topoint = frompoint + direction;
KX_Scene* kxscene = (KX_Scene*) m_auxilaryClientInfo;
PHY_IPhysicsEnvironment* physics_environment = kxscene->GetPhysicsEnvironment();
PHY_IPhysicsController* physics_controller = gameobj->GetPhysicsController();
KX_GameObject *parent = gameobj->GetParent();
if (!physics_controller && parent)
physics_controller = parent->GetPhysicsController();
if (parent)
parent->Release();
KX_RayCast::Callback<RAS_OpenGLRasterizer> callback(this, physics_controller, oglmatrix);
if (!KX_RayCast::RayTest(physics_environment, frompoint, topoint, callback))
{
// couldn't find something to cast the shadow on...
glMultMatrixd(oglmatrix);
}
else
{ // we found the "ground", but the cast matrix doesn't take
// scaling in consideration, so we must apply the object scale
MT_Vector3 size = gameobj->GetSGNode()->GetLocalScale();
glScalef(size[0], size[1], size[2]);
}
} else
{
// 'normal' object
glMultMatrixd(oglmatrix);
}
}
}
///this generates ipo curves for position, rotation, allowing to use game physics in animation
void KX_BlenderSceneConverter::WritePhysicsObjectToAnimationIpo(int frameNumber)
{
KX_SceneList* scenes = m_ketsjiEngine->CurrentScenes();
int numScenes = scenes->size();
int i;
for (i=0;i<numScenes;i++)
{
KX_Scene* scene = scenes->at(i);
//PHY_IPhysicsEnvironment* physEnv = scene->GetPhysicsEnvironment();
CListValue* parentList = scene->GetObjectList();
int numObjects = parentList->GetCount();
int g;
for (g=0;g<numObjects;g++)
{
KX_GameObject* gameObj = (KX_GameObject*)parentList->GetValue(g);
Object* blenderObject = gameObj->GetBlenderObject();
if (blenderObject && blenderObject->parent==NULL && gameObj->IsDynamic())
{
//KX_IPhysicsController* physCtrl = gameObj->GetPhysicsController();
if (blenderObject->adt==NULL)
BKE_id_add_animdata(&blenderObject->id);
if (blenderObject->adt)
{
const MT_Point3& position = gameObj->NodeGetWorldPosition();
//const MT_Vector3& scale = gameObj->NodeGetWorldScaling();
const MT_Matrix3x3& orn = gameObj->NodeGetWorldOrientation();
position.getValue(blenderObject->loc);
float tmat[3][3];
for (int r=0;r<3;r++)
for (int c=0;c<3;c++)
tmat[r][c] = (float)orn[c][r];
mat3_to_compatible_eul(blenderObject->rot, blenderObject->rot, tmat);
insert_keyframe(NULL, &blenderObject->id, NULL, NULL, "location", -1, (float)frameNumber, INSERTKEY_FAST);
insert_keyframe(NULL, &blenderObject->id, NULL, NULL, "rotation_euler", -1, (float)frameNumber, INSERTKEY_FAST);
#if 0
const MT_Point3& position = gameObj->NodeGetWorldPosition();
//const MT_Vector3& scale = gameObj->NodeGetWorldScaling();
const MT_Matrix3x3& orn = gameObj->NodeGetWorldOrientation();
float eulerAngles[3];
float eulerAnglesOld[3] = {0.0f, 0.0f, 0.0f};
float tmat[3][3];
// XXX animato
Ipo* ipo = blenderObject->ipo;
//create the curves, if not existing, set linear if new
IpoCurve *icu_lx = findIpoCurve((IpoCurve *)ipo->curve.first,"LocX");
if (!icu_lx) {
icu_lx = verify_ipocurve(&blenderObject->id, ipo->blocktype, NULL, NULL, NULL, OB_LOC_X, 1);
if (icu_lx) icu_lx->ipo = IPO_LIN;
}
IpoCurve *icu_ly = findIpoCurve((IpoCurve *)ipo->curve.first,"LocY");
if (!icu_ly) {
icu_ly = verify_ipocurve(&blenderObject->id, ipo->blocktype, NULL, NULL, NULL, OB_LOC_Y, 1);
if (icu_ly) icu_ly->ipo = IPO_LIN;
}
IpoCurve *icu_lz = findIpoCurve((IpoCurve *)ipo->curve.first,"LocZ");
if (!icu_lz) {
icu_lz = verify_ipocurve(&blenderObject->id, ipo->blocktype, NULL, NULL, NULL, OB_LOC_Z, 1);
if (icu_lz) icu_lz->ipo = IPO_LIN;
}
IpoCurve *icu_rx = findIpoCurve((IpoCurve *)ipo->curve.first,"RotX");
if (!icu_rx) {
icu_rx = verify_ipocurve(&blenderObject->id, ipo->blocktype, NULL, NULL, NULL, OB_ROT_X, 1);
if (icu_rx) icu_rx->ipo = IPO_LIN;
}
IpoCurve *icu_ry = findIpoCurve((IpoCurve *)ipo->curve.first,"RotY");
if (!icu_ry) {
icu_ry = verify_ipocurve(&blenderObject->id, ipo->blocktype, NULL, NULL, NULL, OB_ROT_Y, 1);
if (icu_ry) icu_ry->ipo = IPO_LIN;
}
IpoCurve *icu_rz = findIpoCurve((IpoCurve *)ipo->curve.first,"RotZ");
if (!icu_rz) {
icu_rz = verify_ipocurve(&blenderObject->id, ipo->blocktype, NULL, NULL, NULL, OB_ROT_Z, 1);
if (icu_rz) icu_rz->ipo = IPO_LIN;
}
if (icu_rx) eulerAnglesOld[0]= eval_icu( icu_rx, frameNumber - 1 ) / ((180 / 3.14159265f) / 10);
if (icu_ry) eulerAnglesOld[1]= eval_icu( icu_ry, frameNumber - 1 ) / ((180 / 3.14159265f) / 10);
if (icu_rz) eulerAnglesOld[2]= eval_icu( icu_rz, frameNumber - 1 ) / ((180 / 3.14159265f) / 10);
// orn.getValue((float *)tmat); // uses the wrong ordering, cant use this
for (int r=0;r<3;r++)
for (int c=0;c<3;c++)
tmat[r][c] = orn[c][r];
// mat3_to_eul( eulerAngles,tmat); // better to use Mat3ToCompatibleEul
mat3_to_compatible_eul( eulerAngles, eulerAnglesOld,tmat);
//eval_icu
for (int x = 0; x < 3; x++)
eulerAngles[x] *= (float) ((180 / 3.14159265f) / 10.0);
//fill the curves with data
if (icu_lx) insert_vert_icu(icu_lx, frameNumber, position.x(), 1);
if (icu_ly) insert_vert_icu(icu_ly, frameNumber, position.y(), 1);
if (icu_lz) insert_vert_icu(icu_lz, frameNumber, position.z(), 1);
if (icu_rx) insert_vert_icu(icu_rx, frameNumber, eulerAngles[0], 1);
if (icu_ry) insert_vert_icu(icu_ry, frameNumber, eulerAngles[1], 1);
if (icu_rz) insert_vert_icu(icu_rz, frameNumber, eulerAngles[2], 1);
// Handles are corrected at the end, testhandles_ipocurve isn't needed yet
#endif
}
}
}
}
}
void KX_BlenderSceneConverter::ResetPhysicsObjectsAnimationIpo(bool clearIpo)
{
KX_SceneList* scenes = m_ketsjiEngine->CurrentScenes();
int numScenes = scenes->size();
int i;
for (i=0;i<numScenes;i++)
{
KX_Scene* scene = scenes->at(i);
//PHY_IPhysicsEnvironment* physEnv = scene->GetPhysicsEnvironment();
CListValue* parentList = scene->GetRootParentList();
int numObjects = parentList->GetCount();
int g;
for (g=0;g<numObjects;g++)
{
KX_GameObject* gameObj = (KX_GameObject*)parentList->GetValue(g);
if (gameObj->IsDynamic())
{
//KX_IPhysicsController* physCtrl = gameObj->GetPhysicsController();
Object* blenderObject = gameObj->GetBlenderObject();
if (blenderObject)
{
#if 0
//erase existing ipo's
Ipo* ipo = blenderObject->ipo;//findIpoForName(blenderObject->id.name+2);
if (ipo)
{ //clear the curve data
if (clearIpo) {//rcruiz
IpoCurve *icu1;
int numCurves = 0;
for ( icu1 = (IpoCurve*)ipo->curve.first; icu1; ) {
IpoCurve* tmpicu = icu1;
/*int i;
BezTriple *bezt;
for ( bezt = tmpicu->bezt, i = 0; i < tmpicu->totvert; i++, bezt++) {
printf("(%f,%f,%f),(%f,%f,%f),(%f,%f,%f)\n",bezt->vec[0][0],bezt->vec[0][1],bezt->vec[0][2],bezt->vec[1][0],bezt->vec[1][1],bezt->vec[1][2],bezt->vec[2][0],bezt->vec[2][1],bezt->vec[2][2]);
}*/
icu1 = icu1->next;
numCurves++;
BLI_remlink( &( blenderObject->ipo->curve ), tmpicu );
if ( tmpicu->bezt )
MEM_freeN( tmpicu->bezt );
MEM_freeN( tmpicu );
localDel_ipoCurve( tmpicu );
}
}
} else
{ ipo = NULL; // XXX add_ipo(blenderObject->id.name+2, ID_OB);
blenderObject->ipo = ipo;
}
#endif
}
}
}
}
}
int main(int argc, char** argv)
{
int i;
int argc_py_clamped= argc; /* use this so python args can be added after ' - ' */
bool error = false;
SYS_SystemHandle syshandle = SYS_GetSystem();
bool fullScreen = false;
bool fullScreenParFound = false;
bool windowParFound = false;
#ifdef WIN32
bool closeConsole = true;
#endif
RAS_IRasterizer::StereoMode stereomode = RAS_IRasterizer::RAS_STEREO_NOSTEREO;
bool stereoWindow = false;
bool stereoParFound = false;
int stereoFlag = STEREO_NOSTEREO;
int domeFov = -1;
int domeTilt = -200;
int domeMode = 0;
char* domeWarp = NULL;
Text *domeText = NULL;
int windowLeft = 100;
int windowTop = 100;
int windowWidth = 640;
int windowHeight = 480;
GHOST_TUns32 fullScreenWidth = 0;
GHOST_TUns32 fullScreenHeight= 0;
int fullScreenBpp = 32;
int fullScreenFrequency = 60;
GHOST_TEmbedderWindowID parentWindow = 0;
bool isBlenderPlayer = false; //true when lauching from blender or command line. false for bundled player
int validArguments=0;
bool samplesParFound = false;
GHOST_TUns16 aasamples = 0;
#ifdef __linux__
#ifdef __alpha__
signal (SIGFPE, SIG_IGN);
#endif /* __alpha__ */
#endif /* __linux__ */
#ifdef WITH_SDL_DYNLOAD
sdlewInit();
#endif
BKE_appdir_program_path_init(argv[0]);
BKE_tempdir_init(NULL);
// We don't use threads directly in the BGE, but we need to call this so things like
// freeing up GPU_Textures works correctly.
BLI_threadapi_init();
RNA_init();
init_nodesystem();
initglobals();
// We load our own G.main, so free the one that initglobals() gives us
BKE_main_free(G.main);
G.main = NULL;
MEM_CacheLimiter_set_disabled(true);
IMB_init();
BKE_images_init();
BKE_modifier_init();
DAG_init();
#ifdef WITH_FFMPEG
IMB_ffmpeg_init();
#endif
// Setup builtin font for BLF (mostly copied from creator.c, wm_init_exit.c and interface_style.c)
BLF_init(11, U.dpi);
BLT_lang_init();
BLT_lang_set("");
BLF_load_mem("default", (unsigned char*)datatoc_bfont_ttf, datatoc_bfont_ttf_size);
if (blf_mono_font == -1)
blf_mono_font = BLF_load_mem_unique("monospace", (unsigned char*)datatoc_bmonofont_ttf, datatoc_bmonofont_ttf_size);
// Parse command line options
#if defined(DEBUG)
printf("argv[0] = '%s'\n", argv[0]);
#endif
#ifdef WIN32
if (scr_saver_init(argc, argv))
{
switch (scr_saver_mode)
{
case SCREEN_SAVER_MODE_CONFIGURATION:
MessageBox(scr_saver_hwnd, "This screen saver has no options that you can set", "Screen Saver", MB_OK);
break;
case SCREEN_SAVER_MODE_PASSWORD:
/* This is W95 only, which we currently do not support.
* Fall-back to normal screen saver behavior in that case... */
case SCREEN_SAVER_MODE_SAVER:
fullScreen = true;
fullScreenParFound = true;
break;
case SCREEN_SAVER_MODE_PREVIEW:
/* This will actually be handled somewhere below... */
break;
}
}
#endif
// XXX add the ability to change this values to the command line parsing.
U.mixbufsize = 2048;
U.audiodevice = 2;
U.audiorate = 44100;
U.audioformat = 0x24;
U.audiochannels = 2;
// XXX this one too
U.anisotropic_filter = 2;
// enable fast mipmap generation
U.use_gpu_mipmap = 1;
BKE_sound_init_once();
// Initialize a default material for meshes without materials.
init_def_material();
BKE_library_callback_free_window_manager_set(wm_free);
/* if running blenderplayer the last argument can't be parsed since it has to be the filename. else it is bundled */
isBlenderPlayer = !BLO_is_a_runtime(argv[0]);
if (isBlenderPlayer)
validArguments = argc - 1;
else
validArguments = argc;
/* Parsing command line arguments (can be set from WM_OT_blenderplayer_start) */
#if defined(DEBUG)
printf("Parsing command line arguments...\n");
printf("Num of arguments is: %i\n", validArguments-1); //-1 because i starts at 1
#endif
for (i = 1; (i < validArguments) && !error
#ifdef WIN32
&& scr_saver_mode == SCREEN_SAVER_MODE_NONE
#endif
;)
{
#if defined(DEBUG)
printf("argv[%d] = '%s'\n", i, argv[i]);
#endif
if (argv[i][0] == '-')
{
/* ignore all args after " - ", allow python to have own args */
if (argv[i][1]=='\0') {
argc_py_clamped= i;
break;
}
switch (argv[i][1])
{
case 'g': //game engine options (show_framerate, fixedtime, etc)
{
i++;
if (i <= validArguments)
{
char* paramname = argv[i];
// Check for single value versus assignment
if (i+1 <= validArguments && (*(argv[i+1]) == '='))
{
i++;
if (i + 1 <= validArguments)
{
i++;
// Assignment
SYS_WriteCommandLineInt(syshandle, paramname, atoi(argv[i]));
SYS_WriteCommandLineFloat(syshandle, paramname, atof(argv[i]));
SYS_WriteCommandLineString(syshandle, paramname, argv[i]);
#if defined(DEBUG)
printf("%s = '%s'\n", paramname, argv[i]);
#endif
i++;
}
else
{
error = true;
printf("error: argument assignment %s without value.\n", paramname);
}
}
else
{
// SYS_WriteCommandLineInt(syshandle, argv[i++], 1);
}
}
break;
}
case 'd': //debug on
{
i++;
G.debug |= G_DEBUG;
MEM_set_memory_debug();
#ifndef NDEBUG
BLI_mempool_set_memory_debug();
#endif
break;
}
case 'f': //fullscreen mode
{
i++;
fullScreen = true;
fullScreenParFound = true;
if ((i + 2) <= validArguments && argv[i][0] != '-' && argv[i+1][0] != '-')
{
fullScreenWidth = atoi(argv[i++]);
fullScreenHeight = atoi(argv[i++]);
if ((i + 1) <= validArguments && argv[i][0] != '-')
{
fullScreenBpp = atoi(argv[i++]);
if ((i + 1) <= validArguments && argv[i][0] != '-')
fullScreenFrequency = atoi(argv[i++]);
}
}
else if ((i + 1) <= validArguments && argv[i][0] != '-' && argv[i+1][0] != '-')
{
error = true;
printf("error: to define fullscreen width or height, both options must be used.\n");
}
break;
}
case 'w': //display in a window
{
i++;
fullScreen = false;
windowParFound = true;
// Parse window position and size options
if ((i + 2) <= validArguments && argv[i][0] != '-' && argv[i+1][0] != '-')
{
windowWidth = atoi(argv[i++]);
windowHeight = atoi(argv[i++]);
if ((i + 2) <= validArguments && argv[i][0] != '-' && argv[i+1][0] != '-')
{
windowLeft = atoi(argv[i++]);
windowTop = atoi(argv[i++]);
}
else if ((i + 1) <= validArguments && argv[i][0] != '-' && argv[i+1][0] != '-')
{
error = true;
printf("error: to define the window left or right coordinates, both options must be used.\n");
}
}
else if ((i + 1) <= validArguments && argv[i][0] != '-' && argv[i+1][0] != '-')
{
error = true;
printf("error: to define the window's width or height, both options must be used.\n");
}
break;
}
case 'h': //display help
{
usage(argv[0], isBlenderPlayer);
return 0;
break;
}
case 'i': //parent window ID
{
i++;
if ( (i + 1) <= validArguments )
parentWindow = atoi(argv[i++]);
else {
error = true;
printf("error: too few options for parent window argument.\n");
}
#if defined(DEBUG)
printf("XWindows ID = %d\n", parentWindow);
#endif // defined(DEBUG)
break;
}
case 'm': //maximum anti-aliasing (eg. 2,4,8,16)
{
i++;
samplesParFound = true;
if ((i+1) <= validArguments )
aasamples = atoi(argv[i++]);
else
{
error = true;
printf("error: No argument supplied for -m");
}
break;
}
case 'c': //keep console (windows only)
{
i++;
#ifdef WIN32
closeConsole = false;
#endif
break;
}
case 's': //stereo mode
{
i++;
if ((i + 1) <= validArguments)
{
stereoParFound = true;
stereoFlag = STEREO_ENABLED;
if (!strcmp(argv[i], "nostereo")) // may not be redundant if the file has different setting
{
stereomode = RAS_IRasterizer::RAS_STEREO_NOSTEREO;
stereoFlag = STEREO_NOSTEREO;
}
// only the hardware pageflip method needs a stereo window
else if (!strcmp(argv[i], "hwpageflip")) {
stereomode = RAS_IRasterizer::RAS_STEREO_QUADBUFFERED;
stereoWindow = true;
}
else if (!strcmp(argv[i], "syncdoubling"))
stereomode = RAS_IRasterizer::RAS_STEREO_ABOVEBELOW;
else if (!strcmp(argv[i], "3dtvtopbottom"))
stereomode = RAS_IRasterizer::RAS_STEREO_3DTVTOPBOTTOM;
else if (!strcmp(argv[i], "anaglyph"))
stereomode = RAS_IRasterizer::RAS_STEREO_ANAGLYPH;
else if (!strcmp(argv[i], "sidebyside"))
stereomode = RAS_IRasterizer::RAS_STEREO_SIDEBYSIDE;
else if (!strcmp(argv[i], "interlace"))
stereomode = RAS_IRasterizer::RAS_STEREO_INTERLACED;
else if (!strcmp(argv[i], "vinterlace"))
stereomode = RAS_IRasterizer::RAS_STEREO_VINTERLACE;
#if 0
// // future stuff
// else if (!strcmp(argv[i], "stencil")
// stereomode = RAS_STEREO_STENCIL;
#endif
else
{
error = true;
printf("error: stereomode '%s' unrecognized.\n", argv[i]);
}
i++;
}
else
{
error = true;
printf("error: too few options for stereo argument.\n");
}
break;
}
case 'D': //dome mode
{
stereoFlag = STEREO_DOME;
stereomode = RAS_IRasterizer::RAS_STEREO_DOME;
i++;
if ((i + 1) <= validArguments)
{
if (!strcmp(argv[i], "angle")) {
i++;
domeFov = atoi(argv[i++]);
}
if (!strcmp(argv[i], "tilt")) {
i++;
domeTilt = atoi(argv[i++]);
}
if (!strcmp(argv[i], "warpdata")) {
i++;
domeWarp = argv[i++];
}
if (!strcmp(argv[i], "mode")) {
i++;
if (!strcmp(argv[i], "fisheye"))
domeMode = DOME_FISHEYE;
else if (!strcmp(argv[i], "truncatedfront"))
domeMode = DOME_TRUNCATED_FRONT;
else if (!strcmp(argv[i], "truncatedrear"))
domeMode = DOME_TRUNCATED_REAR;
else if (!strcmp(argv[i], "cubemap"))
domeMode = DOME_ENVMAP;
else if (!strcmp(argv[i], "sphericalpanoramic"))
domeMode = DOME_PANORAM_SPH;
else
printf("error: %s is not a valid dome mode.\n", argv[i]);
}
i++;
}
break;
}
default: //not recognized
{
printf("Unknown argument: %s\n", argv[i++]);
break;
}
}
}
else
{
i++;
}
}
if ((windowWidth < kMinWindowWidth) || (windowHeight < kMinWindowHeight))
{
error = true;
printf("error: window size too small.\n");
}
if (error )
{
usage(argv[0], isBlenderPlayer);
return 0;
}
#ifdef WIN32
if (scr_saver_mode != SCREEN_SAVER_MODE_CONFIGURATION)
#endif
{
// Create the system
if (GHOST_ISystem::createSystem() == GHOST_kSuccess) {
GHOST_ISystem* system = GHOST_ISystem::getSystem();
assertd(system);
if (!fullScreenWidth || !fullScreenHeight)
system->getMainDisplayDimensions(fullScreenWidth, fullScreenHeight);
// process first batch of events. If the user
// drops a file on top off the blenderplayer icon, we
// receive an event with the filename
system->processEvents(0);
// this bracket is needed for app (see below) to get out
// of scope before GHOST_ISystem::disposeSystem() is called.
{
int exitcode = KX_EXIT_REQUEST_NO_REQUEST;
STR_String exitstring = "";
GPG_Application app(system);
bool firstTimeRunning = true;
char filename[FILE_MAX];
char pathname[FILE_MAX];
char *titlename;
get_filename(argc_py_clamped, argv, filename);
if (filename[0])
BLI_path_cwd(filename, sizeof(filename));
// fill the GlobalSettings with the first scene files
// those may change during the game and persist after using Game Actuator
GlobalSettings gs;
do {
// Read the Blender file
BlendFileData *bfd;
// if we got an exitcode 3 (KX_EXIT_REQUEST_START_OTHER_GAME) load a different file
if (exitcode == KX_EXIT_REQUEST_START_OTHER_GAME)
{
char basedpath[FILE_MAX];
// base the actuator filename relative to the last file
BLI_strncpy(basedpath, exitstring.Ptr(), sizeof(basedpath));
BLI_path_abs(basedpath, pathname);
bfd = load_game_data(basedpath);
if (!bfd) {
// just add "//" in front of it
char temppath[FILE_MAX] = "//";
BLI_strncpy(temppath + 2, basedpath, FILE_MAX - 2);
BLI_path_abs(temppath, pathname);
bfd = load_game_data(temppath);
}
}
else {
bfd = load_game_data(BKE_appdir_program_path(), filename[0]? filename: NULL);
}
#if defined(DEBUG)
printf("Game data loaded from %s\n", filename);
#endif
if (!bfd) {
usage(argv[0], isBlenderPlayer);
error = true;
exitcode = KX_EXIT_REQUEST_QUIT_GAME;
}
else {
/* Setting options according to the blend file if not overriden in the command line */
#ifdef WIN32
#if !defined(DEBUG)
if (closeConsole) {
system->toggleConsole(0); // Close a console window
}
#endif // !defined(DEBUG)
#endif // WIN32
Main *maggie = bfd->main;
Scene *scene = bfd->curscene;
G.main = maggie;
if (firstTimeRunning) {
G.fileflags = bfd->fileflags;
gs.matmode= scene->gm.matmode;
gs.glslflag= scene->gm.flag;
}
//Seg Fault; icon.c gIcons == 0
BKE_icons_init(1);
titlename = maggie->name;
// Check whether the game should be displayed full-screen
if ((!fullScreenParFound) && (!windowParFound)) {
// Only use file settings when command line did not override
if ((scene->gm.playerflag & GAME_PLAYER_FULLSCREEN)) {
//printf("fullscreen option found in Blender file\n");
fullScreen = true;
fullScreenWidth= scene->gm.xplay;
fullScreenHeight= scene->gm.yplay;
fullScreenFrequency= scene->gm.freqplay;
fullScreenBpp = scene->gm.depth;
}
else
{
fullScreen = false;
windowWidth = scene->gm.xplay;
windowHeight = scene->gm.yplay;
}
}
// Check whether the game should be displayed in stereo (dome included)
if (!stereoParFound) {
// Only use file settings when command line did not override
if (scene->gm.stereoflag == STEREO_ENABLED) {
stereomode = (RAS_IRasterizer::StereoMode) scene->gm.stereomode;
if (stereomode == RAS_IRasterizer::RAS_STEREO_QUADBUFFERED)
stereoWindow = true;
}
}
else {
scene->gm.stereoflag = STEREO_ENABLED;
}
if (!samplesParFound)
aasamples = scene->gm.aasamples;
// Dome specific settings
if (stereoFlag == STEREO_DOME) {
stereomode = RAS_IRasterizer::RAS_STEREO_DOME;
scene->gm.stereoflag = STEREO_DOME;
if (domeFov > 89)
scene->gm.dome.angle = domeFov;
if (domeTilt > -180)
scene->gm.dome.tilt = domeTilt;
if (domeMode > 0)
scene->gm.dome.mode = domeMode;
if (domeWarp) {
//XXX to do: convert relative to absolute path
domeText= BKE_text_load(G.main, domeWarp, "");
if (!domeText)
printf("error: invalid warpdata text file - %s\n", domeWarp);
else
scene->gm.dome.warptext = domeText;
}
}
// GPG_Application app (system, maggie, startscenename);
app.SetGameEngineData(maggie, scene, &gs, argc, argv); /* this argc cant be argc_py_clamped, since python uses it */
BLI_strncpy(pathname, maggie->name, sizeof(pathname));
if (G.main != maggie) {
BLI_strncpy(G.main->name, maggie->name, sizeof(G.main->name));
}
#ifdef WITH_PYTHON
setGamePythonPath(G.main->name);
#endif
if (firstTimeRunning) {
firstTimeRunning = false;
if (fullScreen) {
#ifdef WIN32
if (scr_saver_mode == SCREEN_SAVER_MODE_SAVER)
{
app.startScreenSaverFullScreen(fullScreenWidth, fullScreenHeight, fullScreenBpp, fullScreenFrequency,
stereoWindow, stereomode, aasamples);
}
else
#endif
{
app.startFullScreen(fullScreenWidth, fullScreenHeight, fullScreenBpp, fullScreenFrequency,
stereoWindow, stereomode, aasamples, (scene->gm.playerflag & GAME_PLAYER_DESKTOP_RESOLUTION));
}
}
else
{
#ifdef __APPLE__
// on Mac's we'll show the executable name instead of the 'game.blend' name
char tempname[1024], *appstring;
::strcpy(tempname, titlename);
appstring = strstr(tempname, ".app/");
if (appstring) {
appstring[2] = 0;
titlename = &tempname[0];
}
#endif
// Strip the path so that we have the name of the game file
STR_String path = titlename;
#ifndef WIN32
vector<STR_String> parts = path.Explode('/');
#else // WIN32
vector<STR_String> parts = path.Explode('\\');
#endif // WIN32
STR_String title;
if (parts.size()) {
title = parts[parts.size()-1];
parts = title.Explode('.');
if (parts.size() > 1)
{
title = parts[0];
}
}
else {
title = "blenderplayer";
}
#ifdef WIN32
if (scr_saver_mode == SCREEN_SAVER_MODE_PREVIEW)
{
app.startScreenSaverPreview(scr_saver_hwnd, stereoWindow, stereomode, aasamples);
}
else
#endif
{
if (parentWindow != 0)
app.startEmbeddedWindow(title, parentWindow, stereoWindow, stereomode, aasamples);
else
app.startWindow(title, windowLeft, windowTop, windowWidth, windowHeight,
stereoWindow, stereomode, aasamples);
if (SYS_GetCommandLineInt(syshandle, "nomipmap", 0)) {
GPU_set_mipmap(0);
}
GPU_set_anisotropic(U.anisotropic_filter);
GPU_set_gpu_mipmapping(U.use_gpu_mipmap);
}
}
}
else {
app.StartGameEngine(stereomode);
exitcode = KX_EXIT_REQUEST_NO_REQUEST;
}
// Add the application as event consumer
system->addEventConsumer(&app);
// Enter main loop
bool run = true;
char *python_main = NULL;
pynextframestate.state = NULL;
pynextframestate.func = NULL;
#ifdef WITH_PYTHON
python_main = KX_GetPythonMain(scene);
#endif // WITH_PYTHON
if (python_main) {
char *python_code = KX_GetPythonCode(maggie, python_main);
if (python_code) {
#ifdef WITH_PYTHON
// Set python environement variable.
KX_Scene *startscene = app.GetStartScene();
KX_SetActiveScene(startscene);
PHY_SetActiveEnvironment(startscene->GetPhysicsEnvironment());
gpg_nextframestate.system = system;
gpg_nextframestate.app = &app;
gpg_nextframestate.gs = &gs;
pynextframestate.state = &gpg_nextframestate;
pynextframestate.func = &GPG_PyNextFrame;
printf("Yielding control to Python script '%s'...\n", python_main);
PyRun_SimpleString(python_code);
printf("Exit Python script '%s'\n", python_main);
#endif // WITH_PYTHON
MEM_freeN(python_code);
}
else {
fprintf(stderr, "ERROR: cannot yield control to Python: no Python text data block named '%s'\n", python_main);
}
}
else {
while (run) {
run = GPG_NextFrame(system, &app, exitcode, exitstring, &gs);
}
}
app.StopGameEngine();
/* 'app' is freed automatic when out of scope.
* removal is needed else the system will free an already freed value */
system->removeEventConsumer(&app);
BLO_blendfiledata_free(bfd);
/* G.main == bfd->main, it gets referenced in free_nodesystem so we can't have a dangling pointer */
G.main = NULL;
if (python_main) MEM_freeN(python_main);
}
} while (exitcode == KX_EXIT_REQUEST_RESTART_GAME || exitcode == KX_EXIT_REQUEST_START_OTHER_GAME);
}
// Seg Fault; icon.c gIcons == 0
BKE_icons_free();
// Dispose the system
GHOST_ISystem::disposeSystem();
}
else {
error = true;
printf("error: couldn't create a system.\n");
}
}
/* refer to WM_exit_ext() and free_blender(),
* these are not called in the player but we need to match some of there behavior here,
* if the order of function calls or blenders state isn't matching that of blender proper,
* we may get troubles later on */
free_nodesystem();
// Cleanup
RNA_exit();
BLF_exit();
#ifdef WITH_INTERNATIONAL
BLF_free_unifont();
BLF_free_unifont_mono();
BLT_lang_free();
#endif
IMB_exit();
BKE_images_exit();
DAG_exit();
IMB_moviecache_destruct();
SYS_DeleteSystem(syshandle);
int totblock= MEM_get_memory_blocks_in_use();
if (totblock!=0) {
printf("Error Totblock: %d\n",totblock);
MEM_set_error_callback(mem_error_cb);
MEM_printmemlist();
}
BKE_tempdir_session_purge();
return error ? -1 : 0;
}
bool KX_KetsjiEngine::NextFrame()
{
double timestep = 1.0/m_ticrate;
double framestep = timestep;
// static hidden::Clock sClock;
m_logger->StartLog(tc_services, m_kxsystem->GetTimeInSeconds(),true);
//float dt = sClock.getTimeMicroseconds() * 0.000001f;
//sClock.reset();
if (m_bFixedTime)
m_clockTime += timestep;
else
{
// m_clockTime += dt;
m_clockTime = m_kxsystem->GetTimeInSeconds();
}
double deltatime = m_clockTime - m_frameTime;
if (deltatime<0.f)
{
printf("problem with clock\n");
deltatime = 0.f;
m_clockTime = 0.f;
m_frameTime = 0.f;
}
// Compute the number of logic frames to do each update (fixed tic bricks)
int frames =int(deltatime*m_ticrate+1e-6);
// if (frames>1)
// printf("****************************************");
// printf("dt = %f, deltatime = %f, frames = %d\n",dt, deltatime,frames);
// if (!frames)
// PIL_sleep_ms(1);
KX_SceneList::iterator sceneit;
if (frames>m_maxPhysicsFrame)
{
// printf("framedOut: %d\n",frames);
m_frameTime+=(frames-m_maxPhysicsFrame)*timestep;
frames = m_maxPhysicsFrame;
}
bool doRender = frames>0;
if (frames > m_maxLogicFrame)
{
framestep = (frames*timestep)/m_maxLogicFrame;
frames = m_maxLogicFrame;
}
while (frames)
{
m_frameTime += framestep;
for (sceneit = m_scenes.begin();sceneit != m_scenes.end(); ++sceneit)
// for each scene, call the proceed functions
{
KX_Scene* scene = *sceneit;
/* Suspension holds the physics and logic processing for an
* entire scene. Objects can be suspended individually, and
* the settings for that preceed the logic and physics
* update. */
m_logger->StartLog(tc_logic, m_kxsystem->GetTimeInSeconds(), true);
m_sceneconverter->resetNoneDynamicObjectToIpo();//this is for none dynamic objects with ipo
scene->UpdateObjectActivity();
if (!scene->IsSuspended())
{
// if the scene was suspended recalcutlate the delta tu "curtime"
m_suspendedtime = scene->getSuspendedTime();
if (scene->getSuspendedTime()!=0.0)
scene->setSuspendedDelta(scene->getSuspendedDelta()+m_clockTime-scene->getSuspendedTime());
m_suspendeddelta = scene->getSuspendedDelta();
m_logger->StartLog(tc_network, m_kxsystem->GetTimeInSeconds(), true);
SG_SetActiveStage(SG_STAGE_NETWORK);
scene->GetNetworkScene()->proceed(m_frameTime);
//m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
//SG_SetActiveStage(SG_STAGE_NETWORK_UPDATE);
//scene->UpdateParents(m_frameTime);
m_logger->StartLog(tc_physics, m_kxsystem->GetTimeInSeconds(), true);
SG_SetActiveStage(SG_STAGE_PHYSICS1);
// set Python hooks for each scene
#ifndef DISABLE_PYTHON
PHY_SetActiveEnvironment(scene->GetPhysicsEnvironment());
#endif
KX_SetActiveScene(scene);
scene->GetPhysicsEnvironment()->endFrame();
// Update scenegraph after physics step. This maps physics calculations
// into node positions.
//m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
//SG_SetActiveStage(SG_STAGE_PHYSICS1_UPDATE);
//scene->UpdateParents(m_frameTime);
// Process sensors, and controllers
m_logger->StartLog(tc_logic, m_kxsystem->GetTimeInSeconds(), true);
SG_SetActiveStage(SG_STAGE_CONTROLLER);
scene->LogicBeginFrame(m_frameTime);
// Scenegraph needs to be updated again, because Logic Controllers
// can affect the local matrices.
m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
SG_SetActiveStage(SG_STAGE_CONTROLLER_UPDATE);
scene->UpdateParents(m_frameTime);
// Process actuators
// Do some cleanup work for this logic frame
m_logger->StartLog(tc_logic, m_kxsystem->GetTimeInSeconds(), true);
SG_SetActiveStage(SG_STAGE_ACTUATOR);
scene->LogicUpdateFrame(m_frameTime, true);
scene->LogicEndFrame();
// Actuators can affect the scenegraph
m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
SG_SetActiveStage(SG_STAGE_ACTUATOR_UPDATE);
scene->UpdateParents(m_frameTime);
m_logger->StartLog(tc_physics, m_kxsystem->GetTimeInSeconds(), true);
SG_SetActiveStage(SG_STAGE_PHYSICS2);
scene->GetPhysicsEnvironment()->beginFrame();
// Perform physics calculations on the scene. This can involve
// many iterations of the physics solver.
scene->GetPhysicsEnvironment()->proceedDeltaTime(m_frameTime,timestep,framestep);//m_deltatimerealDeltaTime);
m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
SG_SetActiveStage(SG_STAGE_PHYSICS2_UPDATE);
scene->UpdateParents(m_frameTime);
if (m_game2ipo)
{
m_sceneconverter->WritePhysicsObjectToAnimationIpo(++m_currentFrame);
}
scene->setSuspendedTime(0.0);
} // suspended
else
if(scene->getSuspendedTime()==0.0)
scene->setSuspendedTime(m_clockTime);
DoSound(scene);
m_logger->StartLog(tc_services, m_kxsystem->GetTimeInSeconds(), true);
}
// update system devices
m_logger->StartLog(tc_logic, m_kxsystem->GetTimeInSeconds(), true);
if (m_keyboarddevice)
m_keyboarddevice->NextFrame();
if (m_mousedevice)
m_mousedevice->NextFrame();
if (m_networkdevice)
m_networkdevice->NextFrame();
// scene management
ProcessScheduledScenes();
frames--;
}
bool bUseAsyncLogicBricks= false;//true;
if (bUseAsyncLogicBricks)
{
// Logic update sub frame: this will let some logic bricks run at the
// full frame rate.
for (sceneit = m_scenes.begin();sceneit != m_scenes.end(); ++sceneit)
// for each scene, call the proceed functions
{
KX_Scene* scene = *sceneit;
if (!scene->IsSuspended())
{
// if the scene was suspended recalcutlate the delta tu "curtime"
m_suspendedtime = scene->getSuspendedTime();
if (scene->getSuspendedTime()!=0.0)
scene->setSuspendedDelta(scene->getSuspendedDelta()+m_clockTime-scene->getSuspendedTime());
m_suspendeddelta = scene->getSuspendedDelta();
// set Python hooks for each scene
#ifndef DISABLE_PYTHON
PHY_SetActiveEnvironment(scene->GetPhysicsEnvironment());
#endif
KX_SetActiveScene(scene);
m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
SG_SetActiveStage(SG_STAGE_PHYSICS1);
scene->UpdateParents(m_clockTime);
// Perform physics calculations on the scene. This can involve
// many iterations of the physics solver.
m_logger->StartLog(tc_physics, m_kxsystem->GetTimeInSeconds(), true);
scene->GetPhysicsEnvironment()->proceedDeltaTime(m_clockTime,timestep,timestep);
// Update scenegraph after physics step. This maps physics calculations
// into node positions.
m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
SG_SetActiveStage(SG_STAGE_PHYSICS2);
scene->UpdateParents(m_clockTime);
// Do some cleanup work for this logic frame
m_logger->StartLog(tc_logic, m_kxsystem->GetTimeInSeconds(), true);
scene->LogicUpdateFrame(m_clockTime, false);
// Actuators can affect the scenegraph
m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
SG_SetActiveStage(SG_STAGE_ACTUATOR);
scene->UpdateParents(m_clockTime);
scene->setSuspendedTime(0.0);
} // suspended
else
if(scene->getSuspendedTime()==0.0)
scene->setSuspendedTime(m_clockTime);
DoSound(scene);
m_logger->StartLog(tc_services, m_kxsystem->GetTimeInSeconds(), true);
}
}
m_previousClockTime = m_clockTime;
// Start logging time spend outside main loop
m_logger->StartLog(tc_outside, m_kxsystem->GetTimeInSeconds(), true);
return doRender;
}
void KX_KetsjiEngine::RenderDome()
{
GLuint viewport[4]={0};
glGetIntegerv(GL_VIEWPORT,(GLint *)viewport);
m_dome->SetViewPort(viewport);
KX_Scene* firstscene = *m_scenes.begin();
const RAS_FrameSettings &framesettings = firstscene->GetFramingType();
m_logger->StartLog(tc_rasterizer, m_kxsystem->GetTimeInSeconds(), true);
// hiding mouse cursor each frame
// (came back when going out of focus and then back in again)
if (m_hideCursor)
m_canvas->SetMouseState(RAS_ICanvas::MOUSE_INVISIBLE);
// clear the entire game screen with the border color
// only once per frame
m_canvas->BeginDraw();
// BeginFrame() sets the actual drawing area. You can use a part of the window
if (!BeginFrame())
return;
KX_SceneList::iterator sceneit;
int n_renders=m_dome->GetNumberRenders();// usually 4 or 6
for (int i=0;i<n_renders;i++){
m_canvas->ClearBuffer(RAS_ICanvas::COLOR_BUFFER|RAS_ICanvas::DEPTH_BUFFER);
for (sceneit = m_scenes.begin();sceneit != m_scenes.end(); sceneit++)
// for each scene, call the proceed functions
{
KX_Scene* scene = *sceneit;
KX_Camera* cam = scene->GetActiveCamera();
m_rendertools->BeginFrame(m_rasterizer);
// pass the scene's worldsettings to the rasterizer
SetWorldSettings(scene->GetWorldInfo());
// shadow buffers
if (i == 0){
RenderShadowBuffers(scene);
}
// Avoid drawing the scene with the active camera twice when it's viewport is enabled
if(cam && !cam->GetViewport())
{
if (scene->IsClearingZBuffer())
m_rasterizer->ClearDepthBuffer();
m_rendertools->SetAuxilaryClientInfo(scene);
// do the rendering
m_dome->RenderDomeFrame(scene,cam, i);
}
list<class KX_Camera*>* cameras = scene->GetCameras();
// Draw the scene once for each camera with an enabled viewport
list<KX_Camera*>::iterator it = cameras->begin();
while(it != cameras->end())
{
if((*it)->GetViewport())
{
if (scene->IsClearingZBuffer())
m_rasterizer->ClearDepthBuffer();
m_rendertools->SetAuxilaryClientInfo(scene);
// do the rendering
m_dome->RenderDomeFrame(scene, (*it),i);
}
it++;
}
}
m_dome->BindImages(i);
}
m_canvas->EndFrame();//XXX do we really need that?
m_canvas->SetViewPort(0, 0, m_canvas->GetWidth(), m_canvas->GetHeight());
if (m_overrideFrameColor) //XXX why do we want
{
// Do not use the framing bar color set in the Blender scenes
m_canvas->ClearColor(
m_overrideFrameColorR,
m_overrideFrameColorG,
m_overrideFrameColorB,
1.0
);
}
else
{
// Use the framing bar color set in the Blender scenes
m_canvas->ClearColor(
framesettings.BarRed(),
framesettings.BarGreen(),
framesettings.BarBlue(),
1.0
);
}
m_dome->Draw();
// run the 2dfilters and motion blur once for all the scenes
PostRenderFrame();
EndFrame();
}
bool BL_Action::Play(const char* name,
float start,
float end,
short priority,
float blendin,
short play_mode,
float layer_weight,
short ipo_flags,
float playback_speed)
{
// Only start playing a new action if we're done, or if
// the new action has a higher priority
if (!IsDone() && priority > m_priority)
return false;
m_priority = priority;
bAction* prev_action = m_action;
KX_Scene* kxscene = m_obj->GetScene();
// First try to load the action
m_action = (bAction*)kxscene->GetLogicManager()->GetActionByName(name);
if (!m_action)
{
printf("Failed to load action: %s\n", name);
m_done = true;
return false;
}
// If we have the same settings, don't play again
// This is to resolve potential issues with pulses on sensors such as the ones
// reported in bug #29412. The fix is here so it works for both logic bricks and Python.
// However, this may eventually lead to issues where a user wants to override an already
// playing action with the same action and settings. If this becomes an issue,
// then this fix may have to be re-evaluated.
if (!IsDone() && m_action == prev_action && m_startframe == start && m_endframe == end
&& m_priority == priority && m_speed == playback_speed)
return false;
// First get rid of any old controllers
ClearControllerList();
// Create an SG_Controller
SG_Controller *sg_contr = BL_CreateIPO(m_action, m_obj, kxscene->GetSceneConverter());
m_sg_contr_list.push_back(sg_contr);
m_obj->GetSGNode()->AddSGController(sg_contr);
sg_contr->SetObject(m_obj->GetSGNode());
// Try obcolor
sg_contr = BL_CreateObColorIPO(m_action, m_obj, kxscene->GetSceneConverter());
if (sg_contr) {
m_sg_contr_list.push_back(sg_contr);
m_obj->GetSGNode()->AddSGController(sg_contr);
sg_contr->SetObject(m_obj->GetSGNode());
}
// Now try materials
if (m_obj->GetBlenderObject()->totcol==1) {
Material *mat = give_current_material(m_obj->GetBlenderObject(), 1);
if (mat) {
sg_contr = BL_CreateMaterialIpo(m_action, mat, 0, m_obj, kxscene->GetSceneConverter());
if (sg_contr) {
m_sg_contr_list.push_back(sg_contr);
m_obj->GetSGNode()->AddSGController(sg_contr);
sg_contr->SetObject(m_obj->GetSGNode());
}
}
} else {
Material *mat;
STR_HashedString matname;
for (int matidx = 1; matidx <= m_obj->GetBlenderObject()->totcol; ++matidx) {
mat = give_current_material(m_obj->GetBlenderObject(), matidx);
if (mat) {
matname = mat->id.name;
sg_contr = BL_CreateMaterialIpo(m_action, mat, matname.hash(), m_obj, kxscene->GetSceneConverter());
if (sg_contr) {
m_sg_contr_list.push_back(sg_contr);
m_obj->GetSGNode()->AddSGController(sg_contr);
sg_contr->SetObject(m_obj->GetSGNode());
}
}
}
}
// Extra controllers
if (m_obj->GetGameObjectType() == SCA_IObject::OBJ_LIGHT)
{
sg_contr = BL_CreateLampIPO(m_action, m_obj, kxscene->GetSceneConverter());
m_sg_contr_list.push_back(sg_contr);
m_obj->GetSGNode()->AddSGController(sg_contr);
sg_contr->SetObject(m_obj->GetSGNode());
}
else if (m_obj->GetGameObjectType() == SCA_IObject::OBJ_CAMERA)
{
sg_contr = BL_CreateCameraIPO(m_action, m_obj, kxscene->GetSceneConverter());
m_sg_contr_list.push_back(sg_contr);
m_obj->GetSGNode()->AddSGController(sg_contr);
sg_contr->SetObject(m_obj->GetSGNode());
}
m_ipo_flags = ipo_flags;
InitIPO();
// Setup blendin shapes/poses
if (m_obj->GetGameObjectType() == SCA_IObject::OBJ_ARMATURE)
{
BL_ArmatureObject *obj = (BL_ArmatureObject*)m_obj;
obj->GetMRDPose(&m_blendinpose);
}
else
{
BL_DeformableGameObject *obj = (BL_DeformableGameObject*)m_obj;
BL_ShapeDeformer *shape_deformer = dynamic_cast<BL_ShapeDeformer*>(obj->GetDeformer());
if (shape_deformer && shape_deformer->GetKey())
{
obj->GetShape(m_blendinshape);
// Now that we have the previous blend shape saved, we can clear out the key to avoid any
// further interference.
KeyBlock *kb;
for (kb=(KeyBlock *)shape_deformer->GetKey()->block.first; kb; kb=(KeyBlock *)kb->next)
kb->curval = 0.f;
}
}
// Now that we have an action, we have something we can play
m_starttime = -1.f; // We get the start time on our first update
m_startframe = m_localtime = start;
m_endframe = end;
m_blendin = blendin;
m_playmode = play_mode;
m_endtime = 0.f;
m_blendframe = 0.f;
m_blendstart = 0.f;
m_speed = playback_speed;
m_layer_weight = layer_weight;
m_done = false;
return true;
}
bool BL_Action::Play(const std::string& name,
float start,
float end,
short priority,
float blendin,
short play_mode,
float layer_weight,
short ipo_flags,
float playback_speed,
short blend_mode)
{
// Only start playing a new action if we're done, or if
// the new action has a higher priority
if (!IsDone() && priority > m_priority)
return false;
m_priority = priority;
bAction* prev_action = m_action;
KX_Scene* kxscene = m_obj->GetScene();
// First try to load the action
m_action = (bAction*)kxscene->GetLogicManager()->GetActionByName(name);
if (!m_action)
{
CM_Error("failed to load action: " << name);
m_done = true;
return false;
}
// If we have the same settings, don't play again
// This is to resolve potential issues with pulses on sensors such as the ones
// reported in bug #29412. The fix is here so it works for both logic bricks and Python.
// However, this may eventually lead to issues where a user wants to override an already
// playing action with the same action and settings. If this becomes an issue,
// then this fix may have to be re-evaluated.
if (!IsDone() && m_action == prev_action && m_startframe == start && m_endframe == end
&& m_priority == priority && m_speed == playback_speed)
return false;
// Keep a copy of the action for threading purposes
if (m_tmpaction) {
BKE_libblock_free(G.main, m_tmpaction);
m_tmpaction = NULL;
}
m_tmpaction = BKE_action_copy(G.main, m_action);
// First get rid of any old controllers
ClearControllerList();
// Create an SG_Controller
SG_Controller *sg_contr = BL_CreateIPO(m_action, m_obj, kxscene->GetSceneConverter());
m_sg_contr_list.push_back(sg_contr);
m_obj->GetSGNode()->AddSGController(sg_contr);
sg_contr->SetObject(m_obj->GetSGNode());
// World
sg_contr = BL_CreateWorldIPO(m_action, kxscene->GetBlenderScene()->world, kxscene->GetSceneConverter());
if (sg_contr) {
m_sg_contr_list.push_back(sg_contr);
m_obj->GetSGNode()->AddSGController(sg_contr);
sg_contr->SetObject(m_obj->GetSGNode());
}
// Try obcolor
sg_contr = BL_CreateObColorIPO(m_action, m_obj, kxscene->GetSceneConverter());
if (sg_contr) {
m_sg_contr_list.push_back(sg_contr);
m_obj->GetSGNode()->AddSGController(sg_contr);
sg_contr->SetObject(m_obj->GetSGNode());
}
// Now try materials
for (int matidx = 1; matidx <= m_obj->GetBlenderObject()->totcol; ++matidx) {
Material *mat = give_current_material(m_obj->GetBlenderObject(), matidx);
if (!mat) {
continue;
}
KX_BlenderSceneConverter *converter = kxscene->GetSceneConverter();
RAS_IPolyMaterial *polymat = converter->FindCachedPolyMaterial(kxscene, mat);
if (!polymat) {
continue;
}
sg_contr = BL_CreateMaterialIpo(m_action, mat, polymat, m_obj, converter);
if (sg_contr) {
m_sg_contr_list.push_back(sg_contr);
m_obj->GetSGNode()->AddSGController(sg_contr);
sg_contr->SetObject(m_obj->GetSGNode());
}
}
// Extra controllers
if (m_obj->GetGameObjectType() == SCA_IObject::OBJ_LIGHT)
{
sg_contr = BL_CreateLampIPO(m_action, m_obj, kxscene->GetSceneConverter());
m_sg_contr_list.push_back(sg_contr);
m_obj->GetSGNode()->AddSGController(sg_contr);
sg_contr->SetObject(m_obj->GetSGNode());
}
else if (m_obj->GetGameObjectType() == SCA_IObject::OBJ_CAMERA)
{
sg_contr = BL_CreateCameraIPO(m_action, m_obj, kxscene->GetSceneConverter());
m_sg_contr_list.push_back(sg_contr);
m_obj->GetSGNode()->AddSGController(sg_contr);
sg_contr->SetObject(m_obj->GetSGNode());
}
m_ipo_flags = ipo_flags;
InitIPO();
// Setup blendin shapes/poses
if (m_obj->GetGameObjectType() == SCA_IObject::OBJ_ARMATURE)
{
BL_ArmatureObject *obj = (BL_ArmatureObject*)m_obj;
obj->GetPose(&m_blendinpose);
}
else
{
BL_DeformableGameObject *obj = (BL_DeformableGameObject*)m_obj;
BL_ShapeDeformer *shape_deformer = dynamic_cast<BL_ShapeDeformer*>(obj->GetDeformer());
if (shape_deformer && shape_deformer->GetKey())
{
obj->GetShape(m_blendinshape);
// Now that we have the previous blend shape saved, we can clear out the key to avoid any
// further interference.
KeyBlock *kb;
for (kb=(KeyBlock *)shape_deformer->GetKey()->block.first; kb; kb=(KeyBlock *)kb->next)
kb->curval = 0.f;
}
}
// Now that we have an action, we have something we can play
m_starttime = KX_GetActiveEngine()->GetFrameTime() - kxscene->getSuspendedDelta();
m_startframe = m_localframe = start;
m_endframe = end;
m_blendin = blendin;
m_playmode = play_mode;
m_blendmode = blend_mode;
m_blendframe = 0.f;
m_blendstart = 0.f;
m_speed = playback_speed;
m_layer_weight = layer_weight;
m_done = false;
m_appliedToObject = false;
m_prevUpdate = -1.0f;
return true;
}
bool GPG_Application::startEngine(void)
{
if (m_engineRunning) {
return false;
}
// Temporary hack to disable banner display for NaN approved content.
/*
m_canvas->SetBannerDisplayEnabled(true);
Camera* cam;
cam = (Camera*)scene->camera->data;
if (cam) {
if (((cam->flag) & 48)==48) {
m_canvas->SetBannerDisplayEnabled(false);
}
}
else {
showError(CString("Camera data invalid."));
return false;
}
*/
// create a scene converter, create and convert the stratingscene
m_sceneconverter = new KX_BlenderSceneConverter(m_maggie, m_ketsjiengine);
if (m_sceneconverter)
{
STR_String startscenename = m_startSceneName.Ptr();
m_ketsjiengine->SetSceneConverter(m_sceneconverter);
// if (always_use_expand_framing)
// sceneconverter->SetAlwaysUseExpandFraming(true);
if (m_blendermat)
m_sceneconverter->SetMaterials(true);
if (m_blenderglslmat && (m_globalSettings->matmode == GAME_MAT_GLSL))
m_sceneconverter->SetGLSLMaterials(true);
if (m_startScene->gm.flag & GAME_NO_MATERIAL_CACHING)
m_sceneconverter->SetCacheMaterials(false);
KX_Scene* startscene = new KX_Scene(m_keyboard,
m_mouse,
m_networkdevice,
startscenename,
m_startScene,
m_canvas);
#ifdef WITH_PYTHON
// some python things
PyObject *gameLogic, *gameLogic_keys;
setupGamePython(m_ketsjiengine, startscene, m_maggie, NULL, &gameLogic, &gameLogic_keys, m_argc, m_argv);
#endif // WITH_PYTHON
//initialize Dome Settings
if (m_startScene->gm.stereoflag == STEREO_DOME)
m_ketsjiengine->InitDome(m_startScene->gm.dome.res, m_startScene->gm.dome.mode, m_startScene->gm.dome.angle, m_startScene->gm.dome.resbuf, m_startScene->gm.dome.tilt, m_startScene->gm.dome.warptext);
// initialize 3D Audio Settings
AUD_I3DDevice* dev = AUD_get3DDevice();
if (dev)
{
dev->setSpeedOfSound(m_startScene->audio.speed_of_sound);
dev->setDopplerFactor(m_startScene->audio.doppler_factor);
dev->setDistanceModel(AUD_DistanceModel(m_startScene->audio.distance_model));
}
#ifdef WITH_PYTHON
// Set the GameLogic.globalDict from marshal'd data, so we can
// load new blend files and keep data in GameLogic.globalDict
loadGamePythonConfig(m_pyGlobalDictString, m_pyGlobalDictString_Length);
#endif
m_sceneconverter->ConvertScene(
startscene,
m_rasterizer,
m_canvas);
m_ketsjiengine->AddScene(startscene);
// Create a timer that is used to kick the engine
if (!m_frameTimer) {
m_frameTimer = m_system->installTimer(0, kTimerFreq, frameTimerProc, m_mainWindow);
}
m_rasterizer->Init();
m_ketsjiengine->StartEngine(true);
m_engineRunning = true;
// Set the animation playback rate for ipo's and actions
// the framerate below should patch with FPS macro defined in blendef.h
// Could be in StartEngine set the framerate, we need the scene to do this
Scene *scene= startscene->GetBlenderScene(); // needed for macro
m_ketsjiengine->SetAnimFrameRate(FPS);
}
if (!m_engineRunning)
{
stopEngine();
}
return m_engineRunning;
}
/* Note m_map_*** are all ok and don't need to be freed
* most are temp and NewRemoveObject frees m_map_gameobject_to_blender */
bool KX_BlenderSceneConverter::FreeBlendFile(struct Main *maggie)
{
int maggie_index= -1;
int i=0;
if (maggie==NULL)
return false;
/* tag all false except the one we remove */
for (vector<Main*>::iterator it=m_DynamicMaggie.begin(); !(it==m_DynamicMaggie.end()); it++) {
Main *main= *it;
if (main != maggie) {
tag_main(main, 0);
}
else {
maggie_index= i;
}
i++;
}
/* should never happen but just to be safe */
if (maggie_index == -1)
return false;
m_DynamicMaggie.erase(m_DynamicMaggie.begin() + maggie_index);
tag_main(maggie, 1);
/* free all tagged objects */
KX_SceneList* scenes = m_ketsjiEngine->CurrentScenes();
int numScenes = scenes->size();
for (int scene_idx=0;scene_idx<numScenes;scene_idx++)
{
KX_Scene* scene = scenes->at(scene_idx);
if (IS_TAGGED(scene->GetBlenderScene())) {
RemoveScene(scene); // XXX - not tested yet
scene_idx--;
numScenes--;
}
else {
/* in case the mesh might be refered to later */
{
CTR_Map<STR_HashedString,void*> &mapStringToMeshes = scene->GetLogicManager()->GetMeshMap();
for (int i=0; i<mapStringToMeshes.size(); i++)
{
RAS_MeshObject *meshobj= (RAS_MeshObject *) *mapStringToMeshes.at(i);
if (meshobj && IS_TAGGED(meshobj->GetMesh()))
{
STR_HashedString mn = meshobj->GetName();
mapStringToMeshes.remove(mn);
m_map_mesh_to_gamemesh.remove(CHashedPtr(meshobj->GetMesh()));
i--;
}
}
}
/* Now unregister actions */
{
CTR_Map<STR_HashedString,void*> &mapStringToActions = scene->GetLogicManager()->GetActionMap();
for (int i=0; i<mapStringToActions.size(); i++)
{
ID *action= (ID*) *mapStringToActions.at(i);
if (IS_TAGGED(action))
{
STR_HashedString an = action->name+2;
mapStringToActions.remove(an);
i--;
}
}
}
//scene->FreeTagged(); /* removed tagged objects and meshes*/
CListValue *obj_lists[] = {scene->GetObjectList(), scene->GetInactiveList(), NULL};
for (int ob_ls_idx=0; obj_lists[ob_ls_idx]; ob_ls_idx++)
{
CListValue *obs= obj_lists[ob_ls_idx];
RAS_MeshObject* mesh;
for (int ob_idx = 0; ob_idx < obs->GetCount(); ob_idx++)
{
KX_GameObject* gameobj = (KX_GameObject*)obs->GetValue(ob_idx);
if (IS_TAGGED(gameobj->GetBlenderObject())) {
int size_before = obs->GetCount();
/* Eventually calls RemoveNodeDestructObject
* frees m_map_gameobject_to_blender from UnregisterGameObject */
scene->RemoveObject(gameobj);
if (size_before != obs->GetCount())
ob_idx--;
else {
printf("ERROR COULD NOT REMOVE \"%s\"\n", gameobj->GetName().ReadPtr());
}
}
else {
/* free the mesh, we could be referecing a linked one! */
int mesh_index= gameobj->GetMeshCount();
while(mesh_index--) {
mesh= gameobj->GetMesh(mesh_index);
if (IS_TAGGED(mesh->GetMesh())) {
gameobj->RemoveMeshes(); /* XXX - slack, should only remove meshes that are library items but mostly objects only have 1 mesh */
break;
}
}
/* make sure action actuators are not referencing tagged actions */
for (unsigned int act_idx=0; act_idx<gameobj->GetActuators().size(); act_idx++)
{
if (gameobj->GetActuators()[act_idx]->IsType(SCA_IActuator::KX_ACT_ACTION))
{
BL_ActionActuator *act = (BL_ActionActuator*)gameobj->GetActuators()[act_idx];
if (IS_TAGGED(act->GetAction()))
act->SetAction(NULL);
}
}
}
}
}
}
}
int size;
// delete the entities of this scene
/* TODO - */
#if 0
vector<pair<KX_Scene*,KX_WorldInfo*> >::iterator worldit;
size = m_worldinfos.size();
for (i=0, worldit=m_worldinfos.begin(); i<size; ) {
if ((*worldit).second) {
delete (*worldit).second;
*worldit = m_worldinfos.back();
m_worldinfos.pop_back();
size--;
} else {
i++;
worldit++;
}
}
#endif
/* Worlds don't reference original blender data so we need to make a set from them */
typedef std::set<KX_WorldInfo*> KX_WorldInfoSet;
KX_WorldInfoSet worldset;
for (int scene_idx=0;scene_idx<numScenes;scene_idx++)
{
KX_Scene* scene = scenes->at(scene_idx);
if (scene->GetWorldInfo())
worldset.insert( scene->GetWorldInfo() );
}
vector<pair<KX_Scene*,KX_WorldInfo*> >::iterator worldit;
size = m_worldinfos.size();
for (i=0, worldit=m_worldinfos.begin(); i<size; ) {
if ((*worldit).second && (worldset.count((*worldit).second)) == 0) {
delete (*worldit).second;
*worldit = m_worldinfos.back();
m_worldinfos.pop_back();
size--;
} else {
i++;
worldit++;
}
}
worldset.clear();
/* done freeing the worlds */
vector<pair<KX_Scene*,RAS_IPolyMaterial*> >::iterator polymit;
size = m_polymaterials.size();
for (i=0, polymit=m_polymaterials.begin(); i<size; ) {
RAS_IPolyMaterial *mat= (*polymit).second;
Material *bmat= NULL;
/* Why do we need to check for RAS_BLENDERMAT if both are cast to a (PyObject*)? - Campbell */
if (mat->GetFlag() & RAS_BLENDERMAT) {
KX_BlenderMaterial *bl_mat = static_cast<KX_BlenderMaterial*>(mat);
bmat= bl_mat->GetBlenderMaterial();
} else {
KX_PolygonMaterial *kx_mat = static_cast<KX_PolygonMaterial*>(mat);
bmat= kx_mat->GetBlenderMaterial();
}
if (IS_TAGGED(bmat)) {
/* only remove from bucket */
((*polymit).first)->GetBucketManager()->RemoveMaterial(mat);
}
i++;
polymit++;
}
for (i=0, polymit=m_polymaterials.begin(); i<size; ) {
RAS_IPolyMaterial *mat= (*polymit).second;
Material *bmat= NULL;
/* Why do we need to check for RAS_BLENDERMAT if both are cast to a (PyObject*)? - Campbell */
if (mat->GetFlag() & RAS_BLENDERMAT) {
KX_BlenderMaterial *bl_mat = static_cast<KX_BlenderMaterial*>(mat);
bmat= bl_mat->GetBlenderMaterial();
} else {
KX_PolygonMaterial *kx_mat = static_cast<KX_PolygonMaterial*>(mat);
bmat= kx_mat->GetBlenderMaterial();
}
if (bmat) {
//printf("FOUND MAT '%s' !!! ", ((ID*)bmat)->name+2);
}
else {
//printf("LOST MAT !!!");
}
if (IS_TAGGED(bmat)) {
delete (*polymit).second;
*polymit = m_polymaterials.back();
m_polymaterials.pop_back();
size--;
//printf("tagged !\n");
} else {
i++;
polymit++;
//printf("(un)tagged !\n");
}
}
vector<pair<KX_Scene*,BL_Material*> >::iterator matit;
size = m_materials.size();
for (i=0, matit=m_materials.begin(); i<size; ) {
BL_Material *mat= (*matit).second;
if (IS_TAGGED(mat->material)) {
delete (*matit).second;
*matit = m_materials.back();
m_materials.pop_back();
size--;
} else {
i++;
matit++;
}
}
vector<pair<KX_Scene*,RAS_MeshObject*> >::iterator meshit;
size = m_meshobjects.size();
for (i=0, meshit=m_meshobjects.begin(); i<size; ) {
RAS_MeshObject *me= (*meshit).second;
if (IS_TAGGED(me->GetMesh())) {
delete (*meshit).second;
*meshit = m_meshobjects.back();
m_meshobjects.pop_back();
size--;
} else {
i++;
meshit++;
}
}
free_main(maggie);
return true;
}
void KX_KetsjiEngine::Render()
{
if(m_usedome){
RenderDome();
return;
}
KX_Scene* firstscene = *m_scenes.begin();
const RAS_FrameSettings &framesettings = firstscene->GetFramingType();
m_logger->StartLog(tc_rasterizer, m_kxsystem->GetTimeInSeconds(), true);
SG_SetActiveStage(SG_STAGE_RENDER);
// hiding mouse cursor each frame
// (came back when going out of focus and then back in again)
if (m_hideCursor)
m_canvas->SetMouseState(RAS_ICanvas::MOUSE_INVISIBLE);
// clear the entire game screen with the border color
// only once per frame
m_canvas->BeginDraw();
if (m_drawingmode == RAS_IRasterizer::KX_TEXTURED) {
m_canvas->SetViewPort(0, 0, m_canvas->GetWidth(), m_canvas->GetHeight());
if (m_overrideFrameColor)
{
// Do not use the framing bar color set in the Blender scenes
m_canvas->ClearColor(
m_overrideFrameColorR,
m_overrideFrameColorG,
m_overrideFrameColorB,
1.0
);
}
else
{
// Use the framing bar color set in the Blender scenes
m_canvas->ClearColor(
framesettings.BarRed(),
framesettings.BarGreen(),
framesettings.BarBlue(),
1.0
);
}
// clear the -whole- viewport
m_canvas->ClearBuffer(RAS_ICanvas::COLOR_BUFFER|RAS_ICanvas::DEPTH_BUFFER);
}
m_rasterizer->SetEye(RAS_IRasterizer::RAS_STEREO_LEFTEYE);
// BeginFrame() sets the actual drawing area. You can use a part of the window
if (!BeginFrame())
return;
KX_SceneList::iterator sceneit;
for (sceneit = m_scenes.begin();sceneit != m_scenes.end(); sceneit++)
// for each scene, call the proceed functions
{
KX_Scene* scene = *sceneit;
KX_Camera* cam = scene->GetActiveCamera();
// pass the scene's worldsettings to the rasterizer
SetWorldSettings(scene->GetWorldInfo());
// this is now done incrementatlly in KX_Scene::CalculateVisibleMeshes
//scene->UpdateMeshTransformations();
// shadow buffers
RenderShadowBuffers(scene);
// Avoid drawing the scene with the active camera twice when it's viewport is enabled
if(cam && !cam->GetViewport())
{
if (scene->IsClearingZBuffer())
m_rasterizer->ClearDepthBuffer();
m_rendertools->SetAuxilaryClientInfo(scene);
// do the rendering
RenderFrame(scene, cam);
}
list<class KX_Camera*>* cameras = scene->GetCameras();
// Draw the scene once for each camera with an enabled viewport
list<KX_Camera*>::iterator it = cameras->begin();
while(it != cameras->end())
{
if((*it)->GetViewport())
{
if (scene->IsClearingZBuffer())
m_rasterizer->ClearDepthBuffer();
m_rendertools->SetAuxilaryClientInfo(scene);
// do the rendering
RenderFrame(scene, (*it));
}
it++;
}
}
// only one place that checks for stereo
if(m_rasterizer->Stereo())
{
m_rasterizer->SetEye(RAS_IRasterizer::RAS_STEREO_RIGHTEYE);
if (!BeginFrame())
return;
for (sceneit = m_scenes.begin();sceneit != m_scenes.end(); sceneit++)
// for each scene, call the proceed functions
{
KX_Scene* scene = *sceneit;
KX_Camera* cam = scene->GetActiveCamera();
// pass the scene's worldsettings to the rasterizer
SetWorldSettings(scene->GetWorldInfo());
if (scene->IsClearingZBuffer())
m_rasterizer->ClearDepthBuffer();
//pass the scene, for picking and raycasting (shadows)
m_rendertools->SetAuxilaryClientInfo(scene);
// do the rendering
//RenderFrame(scene);
RenderFrame(scene, cam);
list<class KX_Camera*>* cameras = scene->GetCameras();
// Draw the scene once for each camera with an enabled viewport
list<KX_Camera*>::iterator it = cameras->begin();
while(it != cameras->end())
{
if((*it)->GetViewport())
{
if (scene->IsClearingZBuffer())
m_rasterizer->ClearDepthBuffer();
m_rendertools->SetAuxilaryClientInfo(scene);
// do the rendering
RenderFrame(scene, (*it));
}
it++;
}
}
} // if(m_rasterizer->Stereo())
EndFrame();
}
/* Note m_map_*** are all ok and don't need to be freed
* most are temp and NewRemoveObject frees m_map_gameobject_to_blender */
bool KX_BlenderSceneConverter::FreeBlendFile(Main *maggie)
{
int maggie_index = -1;
int i = 0;
if (maggie == NULL)
return false;
// If the given library is currently in loading, we do nothing.
if (m_status_map.count(maggie->name)) {
BLI_mutex_lock(&m_threadinfo->m_mutex);
const bool finished = m_status_map[maggie->name]->IsFinished();
BLI_mutex_unlock(&m_threadinfo->m_mutex);
if (!finished) {
printf("Library (%s) is currently being loaded asynchronously, and cannot be freed until this process is done\n", maggie->name);
return false;
}
}
/* tag all false except the one we remove */
for (vector<Main *>::iterator it = m_DynamicMaggie.begin(); !(it == m_DynamicMaggie.end()); it++) {
Main *main = *it;
if (main != maggie) {
BKE_main_id_tag_all(main, LIB_TAG_DOIT, false);
}
else {
maggie_index = i;
}
i++;
}
/* should never happen but just to be safe */
if (maggie_index == -1)
return false;
m_DynamicMaggie.erase(m_DynamicMaggie.begin() + maggie_index);
BKE_main_id_tag_all(maggie, LIB_TAG_DOIT, true);
/* free all tagged objects */
KX_SceneList *scenes = m_ketsjiEngine->CurrentScenes();
int numScenes = scenes->size();
for (int scene_idx = 0; scene_idx < numScenes; scene_idx++) {
KX_Scene *scene = scenes->at(scene_idx);
if (IS_TAGGED(scene->GetBlenderScene())) {
m_ketsjiEngine->RemoveScene(scene->GetName());
m_mat_cache.erase(scene);
m_polymat_cache.erase(scene);
scene_idx--;
numScenes--;
}
else {
/* in case the mesh might be refered to later */
{
CTR_Map<STR_HashedString, void *> &mapStringToMeshes = scene->GetLogicManager()->GetMeshMap();
for (int i = 0; i < mapStringToMeshes.size(); i++) {
RAS_MeshObject *meshobj = (RAS_MeshObject *) *mapStringToMeshes.at(i);
if (meshobj && IS_TAGGED(meshobj->GetMesh())) {
STR_HashedString mn = meshobj->GetName();
mapStringToMeshes.remove(mn);
m_map_mesh_to_gamemesh.remove(CHashedPtr(meshobj->GetMesh()));
i--;
}
}
}
/* Now unregister actions */
{
CTR_Map<STR_HashedString, void *> &mapStringToActions = scene->GetLogicManager()->GetActionMap();
for (int i = 0; i < mapStringToActions.size(); i++) {
ID *action = (ID*) *mapStringToActions.at(i);
if (IS_TAGGED(action)) {
STR_HashedString an = action->name + 2;
mapStringToActions.remove(an);
m_map_blender_to_gameAdtList.remove(CHashedPtr(action));
i--;
}
}
}
//scene->FreeTagged(); /* removed tagged objects and meshes*/
CListValue *obj_lists[] = {scene->GetObjectList(), scene->GetInactiveList(), NULL};
for (int ob_ls_idx = 0; obj_lists[ob_ls_idx]; ob_ls_idx++) {
CListValue *obs = obj_lists[ob_ls_idx];
RAS_MeshObject *mesh;
for (int ob_idx = 0; ob_idx < obs->GetCount(); ob_idx++) {
KX_GameObject *gameobj = (KX_GameObject*)obs->GetValue(ob_idx);
if (IS_TAGGED(gameobj->GetBlenderObject())) {
int size_before = obs->GetCount();
/* Eventually calls RemoveNodeDestructObject
* frees m_map_gameobject_to_blender from UnregisterGameObject */
scene->RemoveObject(gameobj);
if (size_before != obs->GetCount())
ob_idx--;
else {
printf("ERROR COULD NOT REMOVE \"%s\"\n", gameobj->GetName().ReadPtr());
}
}
else {
gameobj->RemoveTaggedActions();
/* free the mesh, we could be referecing a linked one! */
int mesh_index = gameobj->GetMeshCount();
while (mesh_index--) {
mesh = gameobj->GetMesh(mesh_index);
if (IS_TAGGED(mesh->GetMesh())) {
gameobj->RemoveMeshes(); /* XXX - slack, should only remove meshes that are library items but mostly objects only have 1 mesh */
break;
}
else {
/* also free the mesh if it's using a tagged material */
int mat_index = mesh->NumMaterials();
while (mat_index--) {
if (IS_TAGGED(mesh->GetMeshMaterial(mat_index)->m_bucket->GetPolyMaterial()->GetBlenderMaterial())) {
gameobj->RemoveMeshes(); /* XXX - slack, same as above */
break;
}
}
}
}
/* make sure action actuators are not referencing tagged actions */
for (unsigned int act_idx = 0; act_idx < gameobj->GetActuators().size(); act_idx++) {
if (gameobj->GetActuators()[act_idx]->IsType(SCA_IActuator::KX_ACT_ACTION)) {
BL_ActionActuator *act = (BL_ActionActuator *)gameobj->GetActuators()[act_idx];
if (IS_TAGGED(act->GetAction()))
act->SetAction(NULL);
}
}
}
}
}
}
}
int size;
// delete the entities of this scene
/* TODO - */
#if 0
vector<pair<KX_Scene*,KX_WorldInfo*> >::iterator worldit;
size = m_worldinfos.size();
for (i=0, worldit=m_worldinfos.begin(); i<size; ) {
if ((*worldit).second) {
delete (*worldit).second;
*worldit = m_worldinfos.back();
m_worldinfos.pop_back();
size--;
} else {
i++;
worldit++;
}
}
#endif
/* Worlds don't reference original blender data so we need to make a set from them */
typedef std::set<KX_WorldInfo *> KX_WorldInfoSet;
KX_WorldInfoSet worldset;
for (int scene_idx = 0; scene_idx < numScenes; scene_idx++) {
KX_Scene *scene = scenes->at(scene_idx);
if (scene->GetWorldInfo())
worldset.insert(scene->GetWorldInfo());
}
vector<pair<KX_Scene *, KX_WorldInfo *> >::iterator worldit;
size = m_worldinfos.size();
for (i = 0, worldit = m_worldinfos.begin(); i < size;) {
if (worldit->second && (worldset.count(worldit->second)) == 0) {
delete worldit->second;
*worldit = m_worldinfos.back();
m_worldinfos.pop_back();
size--;
}
else {
i++;
worldit++;
}
}
worldset.clear();
/* done freeing the worlds */
vector<pair<KX_Scene *, RAS_IPolyMaterial *> >::iterator polymit;
size = m_polymaterials.size();
for (i = 0, polymit = m_polymaterials.begin(); i < size; ) {
RAS_IPolyMaterial *mat = polymit->second;
Material *bmat = NULL;
KX_BlenderMaterial *bl_mat = static_cast<KX_BlenderMaterial *>(mat);
bmat = bl_mat->GetBlenderMaterial();
if (IS_TAGGED(bmat)) {
/* only remove from bucket */
polymit->first->GetBucketManager()->RemoveMaterial(mat);
}
i++;
polymit++;
}
for (i = 0, polymit = m_polymaterials.begin(); i < size; ) {
RAS_IPolyMaterial *mat = polymit->second;
Material *bmat = NULL;
KX_BlenderMaterial *bl_mat = static_cast<KX_BlenderMaterial*>(mat);
bmat = bl_mat->GetBlenderMaterial();
if (IS_TAGGED(bmat)) {
// Remove the poly material coresponding to this Blender Material.
m_polymat_cache[polymit->first].erase(bmat);
delete polymit->second;
*polymit = m_polymaterials.back();
m_polymaterials.pop_back();
size--;
} else {
i++;
polymit++;
}
}
vector<pair<KX_Scene *, BL_Material *> >::iterator matit;
size = m_materials.size();
for (i = 0, matit = m_materials.begin(); i < size; ) {
BL_Material *mat = matit->second;
if (IS_TAGGED(mat->material)) {
// Remove the bl material coresponding to this Blender Material.
m_mat_cache[matit->first].erase(mat->material);
delete matit->second;
*matit = m_materials.back();
m_materials.pop_back();
size--;
}
else {
i++;
matit++;
}
}
vector<pair<KX_Scene *, RAS_MeshObject *> >::iterator meshit;
RAS_BucketManager::BucketList::iterator bit;
list<RAS_MeshSlot>::iterator msit;
RAS_BucketManager::BucketList buckets;
size = m_meshobjects.size();
for (i = 0, meshit = m_meshobjects.begin(); i < size;) {
RAS_MeshObject *me = meshit->second;
if (IS_TAGGED(me->GetMesh())) {
// Before deleting the mesh object, make sure the rasterizer is
// no longer referencing it.
buckets = meshit->first->GetBucketManager()->GetSolidBuckets();
for (bit = buckets.begin(); bit != buckets.end(); bit++) {
msit = (*bit)->msBegin();
while (msit != (*bit)->msEnd()) {
if (msit->m_mesh == meshit->second)
(*bit)->RemoveMesh(&(*msit++));
else
msit++;
}
}
// And now the alpha buckets
buckets = meshit->first->GetBucketManager()->GetAlphaBuckets();
for (bit = buckets.begin(); bit != buckets.end(); bit++) {
msit = (*bit)->msBegin();
while (msit != (*bit)->msEnd()) {
if (msit->m_mesh == meshit->second)
(*bit)->RemoveMesh(&(*msit++));
else
msit++;
}
}
// Now it should be safe to delete
delete meshit->second;
*meshit = m_meshobjects.back();
m_meshobjects.pop_back();
size--;
}
else {
i++;
meshit++;
}
}
#ifdef WITH_PYTHON
/* make sure this maggie is removed from the import list if it's there
* (this operation is safe if it isn't in the list) */
removeImportMain(maggie);
#endif
delete m_status_map[maggie->name];
m_status_map.erase(maggie->name);
BKE_main_free(maggie);
return true;
}
