- when C++ uses guardedalloc SYS_DeleteSystem was called after MEM_printmemlist(), making it look like there was a leak.
using namespace std;
+#ifdef WITH_CXX_GUARDEDALLOC
+#include "MEM_guardedalloc.h"
+#endif
class STR_String;
char *pData; // -> STR_String data
int Len; // Data length
int Max; // Space in data buffer
+
+
+#ifdef WITH_CXX_GUARDEDALLOC
+public:
+ void *operator new( unsigned int num_bytes) { return MEM_mallocN(num_bytes, "CXX:STR_String"); }
+ void operator delete( void *mem ) { MEM_freeN(mem); }
+#endif
};
inline STR_String operator+(rcSTR_String lhs, rcSTR_String rhs) { return STR_String(lhs.ReadPtr(), lhs.Length(), rhs.ReadPtr(), rhs.Length()); }
CTX_free(C);
+ SYS_DeleteSystem(SYS_GetSystem());
+
if(MEM_get_memory_blocks_in_use()!=0) {
printf("Error Totblock: %d\n", MEM_get_memory_blocks_in_use());
MEM_printmemlist();
}
#endif
-
- SYS_DeleteSystem(SYS_GetSystem());
-
exit(G.afbreek==1);
}
: KX_GameObject(sgReplicationInfo,callbacks),
m_objArma(armature),
- m_scene(scene), // maybe remove later. needed for where_is_pose
m_framePose(NULL),
+ m_scene(scene), // maybe remove later. needed for where_is_pose
m_lastframe(0.0),
m_activeAct(NULL),
m_activePriority(999),
{
if (!m_shapeDrivers.empty() && PoseUpdated()) {
vector<IpoCurve*>::iterator it;
- void *poin;
- int type;
+// void *poin;
+// int type;
// the shape drivers use the bone matrix as input. Must
// update the matrix now
}
}
-KX_IScalarInterpolator *BL_InterpolatorList::GetScalarInterpolator(char *rna_path, int array_index) {
+KX_IScalarInterpolator *BL_InterpolatorList::GetScalarInterpolator(const char *rna_path, int array_index) {
for(BL_InterpolatorList::iterator i = begin(); (i != end()) ; i++ )
{
FCurve *fcu= (static_cast<BL_ScalarInterpolator *>(*i))->GetFCurve();
BL_InterpolatorList(struct AnimData *adt);
~BL_InterpolatorList();
- KX_IScalarInterpolator *GetScalarInterpolator(char *rna_path, int array_index);
+ KX_IScalarInterpolator *GetScalarInterpolator(const char *rna_path, int array_index);
#ifdef WITH_CXX_GUARDEDALLOC
Object* blenderObject = gameObj->GetBlenderObject();
if (blenderObject && blenderObject->ipo)
{
+#if 0
const MT_Point3& position = gameObj->NodeGetWorldPosition();
//const MT_Vector3& scale = gameObj->NodeGetWorldScaling();
const MT_Matrix3x3& orn = gameObj->NodeGetWorldOrientation();
float tmat[3][3];
// XXX animato
-#if 0
Ipo* ipo = blenderObject->ipo;
//create the curves, if not existing, set linear if new
KX_ObColorIpoSGController* ipocontr_obcol=NULL;
for(int i=0; i<4; i++) {
- if (interp = adtList->GetScalarInterpolator("color", i)) {
+ if ((interp = adtList->GetScalarInterpolator("color", i))) {
if (!ipocontr_obcol) {
ipocontr_obcol = new KX_ObColorIpoSGController();
gameobj->GetSGNode()->AddSGController(ipocontr_obcol);
#include "PyObjectPlus.h"
-STR_String KX_CameraActuator::X_AXIS_STRING = "x";
-STR_String KX_CameraActuator::Y_AXIS_STRING = "y";
-
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
return NULL;
}
-bool KX_CameraActuator::string2axischoice(const char *axisString)
-{
- bool res = true;
-
- res = !(axisString == Y_AXIS_STRING);
-
- return res;
-}
-
/* ------------------------------------------------------------------------- */
/* Python functions */
/* ------------------------------------------------------------------------- */
double* fl = GetOpenGLMatrixPtr()->getPointer();
SG_QList::iterator<RAS_MeshSlot> mit(m_meshSlots);
- RAS_MeshSlot* ms;
+// RAS_MeshSlot* ms;
for(mit.begin(); !mit.end(); ++mit)
{
(*mit)->m_OpenGLMatrix = fl;
PyObject* KX_GameObject::pyattr_get_worldPosition(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
{
- KX_GameObject* self= static_cast<KX_GameObject*>(self_v);
#ifdef USE_MATHUTILS
return newVectorObject_cb((PyObject *)self_v, 3, mathutils_kxgameob_vector_cb_index, MATHUTILS_VEC_CB_POS_GLOBAL);
#else
+ KX_GameObject* self= static_cast<KX_GameObject*>(self_v);
return PyObjectFrom(self->NodeGetWorldPosition());
#endif
}
PyObject* KX_GameObject::pyattr_get_localPosition(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
{
- KX_GameObject* self= static_cast<KX_GameObject*>(self_v);
#ifdef USE_MATHUTILS
return newVectorObject_cb((PyObject *)self_v, 3, mathutils_kxgameob_vector_cb_index, MATHUTILS_VEC_CB_POS_LOCAL);
#else
+ KX_GameObject* self= static_cast<KX_GameObject*>(self_v);
return PyObjectFrom(self->NodeGetLocalPosition());
#endif
}
PyObject* KX_GameObject::pyattr_get_localInertia(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
{
- KX_GameObject* self= static_cast<KX_GameObject*>(self_v);
#ifdef USE_MATHUTILS
return newVectorObject_cb((PyObject *)self_v, 3, mathutils_kxgameob_vector_cb_index, MATHUTILS_VEC_CB_INERTIA_LOCAL);
#else
+ KX_GameObject* self= static_cast<KX_GameObject*>(self_v);
if (self->GetPhysicsController())
return PyObjectFrom(self->GetPhysicsController()->GetLocalInertia());
return Py_BuildValue("fff", 0.0f, 0.0f, 0.0f);
PyObject* KX_GameObject::pyattr_get_worldScaling(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
{
- KX_GameObject* self= static_cast<KX_GameObject*>(self_v);
#ifdef USE_MATHUTILS
return newVectorObject_cb((PyObject *)self_v, 3, mathutils_kxgameob_vector_cb_index, MATHUTILS_VEC_CB_SCALE_GLOBAL);
#else
+ KX_GameObject* self= static_cast<KX_GameObject*>(self_v);
return PyObjectFrom(self->NodeGetWorldScaling());
#endif
}
PyObject* KX_GameObject::pyattr_get_localScaling(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
{
- KX_GameObject* self= static_cast<KX_GameObject*>(self_v);
#ifdef USE_MATHUTILS
return newVectorObject_cb((PyObject *)self_v, 3, mathutils_kxgameob_vector_cb_index, MATHUTILS_VEC_CB_SCALE_LOCAL);
#else
+ KX_GameObject* self= static_cast<KX_GameObject*>(self_v);
return PyObjectFrom(self->NodeGetLocalScaling());
#endif
}
/* Type strings */
/* ------------------------------------------------------------------------- */
-STR_String KX_IpoActuator::S_KX_ACT_IPO_PLAY_STRING = "Play";
-STR_String KX_IpoActuator::S_KX_ACT_IPO_PINGPONG_STRING = "PingPong";
-STR_String KX_IpoActuator::S_KX_ACT_IPO_FLIPPER_STRING = "Flipper";
-STR_String KX_IpoActuator::S_KX_ACT_IPO_LOOPSTOP_STRING = "LoopStop";
-STR_String KX_IpoActuator::S_KX_ACT_IPO_LOOPEND_STRING = "LoopEnd";
-STR_String KX_IpoActuator::S_KX_ACT_IPO_KEY2KEY_STRING = "Key2key";
-STR_String KX_IpoActuator::S_KX_ACT_IPO_FROM_PROP_STRING = "FromProp";
+const char *KX_IpoActuator::S_KX_ACT_IPO_PLAY_STRING = "Play";
+const char *KX_IpoActuator::S_KX_ACT_IPO_PINGPONG_STRING = "PingPong";
+const char *KX_IpoActuator::S_KX_ACT_IPO_FLIPPER_STRING = "Flipper";
+const char *KX_IpoActuator::S_KX_ACT_IPO_LOOPSTOP_STRING = "LoopStop";
+const char *KX_IpoActuator::S_KX_ACT_IPO_LOOPEND_STRING = "LoopEnd";
+const char *KX_IpoActuator::S_KX_ACT_IPO_KEY2KEY_STRING = "Key2key";
+const char *KX_IpoActuator::S_KX_ACT_IPO_FROM_PROP_STRING = "FromProp";
/* ------------------------------------------------------------------------- */
/* Native functions */
int KX_IpoActuator::string2mode(char* modename) {
IpoActType res = KX_ACT_IPO_NODEF;
- if (modename == S_KX_ACT_IPO_PLAY_STRING) {
+ if (strcmp(modename, S_KX_ACT_IPO_PLAY_STRING)==0) {
res = KX_ACT_IPO_PLAY;
- } else if (modename == S_KX_ACT_IPO_PINGPONG_STRING) {
+ } else if (strcmp(modename, S_KX_ACT_IPO_PINGPONG_STRING)==0) {
res = KX_ACT_IPO_PINGPONG;
- } else if (modename == S_KX_ACT_IPO_FLIPPER_STRING) {
+ } else if (strcmp(modename, S_KX_ACT_IPO_FLIPPER_STRING)==0) {
res = KX_ACT_IPO_FLIPPER;
- } else if (modename == S_KX_ACT_IPO_LOOPSTOP_STRING) {
+ } else if (strcmp(modename, S_KX_ACT_IPO_LOOPSTOP_STRING)==0) {
res = KX_ACT_IPO_LOOPSTOP;
- } else if (modename == S_KX_ACT_IPO_LOOPEND_STRING) {
+ } else if (strcmp(modename, S_KX_ACT_IPO_LOOPEND_STRING)==0) {
res = KX_ACT_IPO_LOOPEND;
- } else if (modename == S_KX_ACT_IPO_KEY2KEY_STRING) {
+ } else if (strcmp(modename, S_KX_ACT_IPO_KEY2KEY_STRING)==0) {
res = KX_ACT_IPO_KEY2KEY;
- } else if (modename == S_KX_ACT_IPO_FROM_PROP_STRING) {
+ } else if (strcmp(modename, S_KX_ACT_IPO_FROM_PROP_STRING)==0) {
res = KX_ACT_IPO_FROM_PROP;
}
KX_ACT_IPO_MAX
};
- static STR_String S_KX_ACT_IPO_PLAY_STRING;
- static STR_String S_KX_ACT_IPO_PINGPONG_STRING;
- static STR_String S_KX_ACT_IPO_FLIPPER_STRING;
- static STR_String S_KX_ACT_IPO_LOOPSTOP_STRING;
- static STR_String S_KX_ACT_IPO_LOOPEND_STRING;
- static STR_String S_KX_ACT_IPO_KEY2KEY_STRING;
- static STR_String S_KX_ACT_IPO_FROM_PROP_STRING;
+ static const char *S_KX_ACT_IPO_PLAY_STRING;
+ static const char *S_KX_ACT_IPO_PINGPONG_STRING;
+ static const char *S_KX_ACT_IPO_FLIPPER_STRING;
+ static const char *S_KX_ACT_IPO_LOOPSTOP_STRING;
+ static const char *S_KX_ACT_IPO_LOOPEND_STRING;
+ static const char *S_KX_ACT_IPO_KEY2KEY_STRING;
+ static const char *S_KX_ACT_IPO_FROM_PROP_STRING;
int string2mode(char* modename);
// List of methods defined in the module
static PyObject* ErrorObject;
-STR_String gPyGetRandomFloat_doc="getRandomFloat returns a random floating point value in the range [0..1)";
+static const char *gPyGetRandomFloat_doc="getRandomFloat returns a random floating point value in the range [0..1]";
static PyObject* gPyGetRandomFloat(PyObject*)
{
return list;
}
-static STR_String gPyGetCurrentScene_doc =
+static const char *gPyGetCurrentScene_doc =
"getCurrentScene()\n"
"Gets a reference to the current scene.\n";
static PyObject* gPyGetCurrentScene(PyObject* self)
return gp_KetsjiScene->GetProxy();
}
-static STR_String gPyGetSceneList_doc =
+static const char *gPyGetSceneList_doc =
"getSceneList()\n"
"Return a list of converted scenes.\n";
static PyObject* gPyGetSceneList(PyObject* self)
{"sendMessage", (PyCFunction)gPySendMessage, METH_VARARGS, (const char *)gPySendMessage_doc},
{"getCurrentController",
(PyCFunction) SCA_PythonController::sPyGetCurrentController,
- METH_NOARGS, (const char *)SCA_PythonController::sPyGetCurrentController__doc__},
+ METH_NOARGS, SCA_PythonController::sPyGetCurrentController__doc__},
{"getCurrentScene", (PyCFunction) gPyGetCurrentScene,
- METH_NOARGS, (const char *)gPyGetCurrentScene_doc.Ptr()},
+ METH_NOARGS, gPyGetCurrentScene_doc},
{"getSceneList", (PyCFunction) gPyGetSceneList,
- METH_NOARGS, (const char *)gPyGetSceneList_doc.Ptr()},
+ METH_NOARGS, (const char *)gPyGetSceneList_doc},
{"addActiveActuator",(PyCFunction) SCA_PythonController::sPyAddActiveActuator,
METH_VARARGS, (const char *)SCA_PythonController::sPyAddActiveActuator__doc__},
{"getRandomFloat",(PyCFunction) gPyGetRandomFloat,
- METH_NOARGS, (const char *)gPyGetRandomFloat_doc.Ptr()},
+ METH_NOARGS, (const char *)gPyGetRandomFloat_doc},
{"setGravity",(PyCFunction) gPySetGravity, METH_O, (const char *)"set Gravitation"},
{"getSpectrum",(PyCFunction) gPyGetSpectrum, METH_NOARGS, (const char *)"get audio spectrum"},
{"stopDSP",(PyCFunction) gPyStopDSP, METH_VARARGS, (const char *)"stop using the audio dsp (for performance reasons)"},
memset(attr_getset, 0, sizeof(PyGetSetDef));
}
} else {
-
- PyObject *item;
-
PyType_Ready(tp);
PyDict_SetItemString(dict, tp->tp_name, reinterpret_cast<PyObject *>(tp));
}
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
/* TODO, richcmp */
- NULL, /* ( cmpfunc ) KX_PythonSeq_compare, /* cmpfunc tp_compare; */
+ NULL, /* ( cmpfunc ) KX_PythonSeq_compare, // cmpfunc tp_compare; */
( reprfunc ) KX_PythonSeq_repr, /* reprfunc tp_repr; */
/* Method suites for standard classes */
// mesh reference (mesh to replace)
RAS_MeshObject* m_mesh;
SCA_IScene* m_scene;
- bool m_use_phys;
bool m_use_gfx;
+ bool m_use_phys;
public:
KX_SCA_ReplaceMeshActuator(
}
for(mf= mface, i=0; i < numpolys; mf++, i++) {
- unsigned int *fv = &mf->v1;
-
if(mf->v4) {
fv_pt= quad_verts;
*poly_index_pt++ = *poly_index_pt++ = index[i];
RAS_IPolyMaterial::RAS_IPolyMaterial()
: m_texturename("__Dummy_Texture_Name__"),
m_materialname("__Dummy_Material_Name__"),
- m_materialindex(0),
m_tile(0),
m_tilexrep(0),
m_tileyrep(0),
m_transp(0),
m_alpha(false),
m_zsort(false),
+ m_materialindex(0),
m_polymatid(0),
m_flag(0),
m_multimode(0)
bool zsort)
: m_texturename(texname),
m_materialname(matname),
- m_materialindex(materialindex),
m_tile(tile),
m_tilexrep(tilexrep),
m_tileyrep(tileyrep),
m_transp(transp),
m_alpha(alpha),
m_zsort(zsort),
+ m_materialindex(materialindex),
m_polymatid(m_newpolymatid++),
m_flag(0),
m_multimode(0)
// get size of current source
short * curSize = (*it)->getSize();
// if size is available and is not empty
- if (curSize[0] != 0 && curSize[1] != 0)
+ if (curSize[0] != 0 && curSize[1] != 0) {
// if reference size is not set
- if (refSize == NULL)
+ if (refSize == NULL) {
// set current size as reference
refSize = curSize;
// otherwise check with current size
- else if (curSize[0] != refSize[0] || curSize[1] != refSize[1])
+ } else if (curSize[0] != refSize[0] || curSize[1] != refSize[1]) {
// if they don't match, report it
return false;
+ }
+ }
}
// all sizes match
return true;