blender/source/gameengine/Expressions/Value.cpp

664 lines
14 KiB
C++
Raw Normal View History

/** \file gameengine/Expressions/Value.cpp
* \ingroup expressions
*/
2002-10-12 11:37:38 +00:00
// Value.cpp: implementation of the CValue class.
// developed at Eindhoven University of Technology, 1997
// by the OOPS team
//////////////////////////////////////////////////////////////////////
/*
* Copyright (c) 1996-2000 Erwin Coumans <coockie@acm.org>
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Erwin Coumans makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*/
#include "Value.h"
#include "BoolValue.h"
2002-10-12 11:37:38 +00:00
#include "FloatValue.h"
#include "IntValue.h"
#include "VectorValue.h"
#include "VoidValue.h"
#include "StringValue.h"
#include "ErrorValue.h"
#include "ListValue.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
double CValue::m_sZeroVec[3] = {0.0,0.0,0.0};
#ifdef WITH_PYTHON
2002-10-12 11:37:38 +00:00
PyTypeObject CValue::Type = {
PyVarObject_HEAD_INIT(NULL, 0)
2002-10-12 11:37:38 +00:00
"CValue",
sizeof(PyObjectPlus_Proxy),
2002-10-12 11:37:38 +00:00
0,
py_base_dealloc,
2002-10-12 11:37:38 +00:00
0,
0,
0,
0,
py_base_repr,
0,
0,0,0,0,0,
NULL,
NULL,
0,
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
0,0,0,0,0,0,0,
Methods,
0,
0,
&PyObjectPlus::Type,
0,0,0,0,0,0,
py_base_new
2002-10-12 11:37:38 +00:00
};
PyMethodDef CValue::Methods[] = {
{NULL,NULL} //Sentinel
};
#endif // WITH_PYTHON
2002-10-12 11:37:38 +00:00
/*#define CVALUE_DEBUG*/
#ifdef CVALUE_DEBUG
int gRefCount;
struct SmartCValueRef
{
CValue *m_ref;
int m_count;
SmartCValueRef(CValue *ref)
{
m_ref = ref;
m_count = gRefCount++;
}
};
2002-10-12 11:37:38 +00:00
#include <vector>
std::vector<SmartCValueRef> gRefList;
#endif
#ifdef _DEBUG
//int gRefCountValue;
#endif
2002-10-12 11:37:38 +00:00
CValue::CValue()
: PyObjectPlus(),
2002-10-12 11:37:38 +00:00
m_pNamedPropertyArray(NULL),
m_refcount(1)
2002-10-12 11:37:38 +00:00
/*
pre: false
effect: constucts a CValue
*/
{
//debug(gRefCountValue++) // debugging
#ifdef _DEBUG
//gRefCountValue++;
#ifdef CVALUE_DEBUG
gRefList.push_back(SmartCValueRef(this));
#endif
#endif
2002-10-12 11:37:38 +00:00
}
CValue::~CValue()
/*
pre:
effect: deletes the object
*/
{
ClearProperties();
assertd (m_refcount==0);
#ifdef CVALUE_DEBUG
std::vector<SmartCValueRef>::iterator it;
for (it=gRefList.begin(); it!=gRefList.end(); it++)
{
if (it->m_ref == this)
{
*it = gRefList.back();
gRefList.pop_back();
break;
}
}
#endif
2002-10-12 11:37:38 +00:00
}
/* UNUSED */
#if 0
2002-10-12 11:37:38 +00:00
#define VALUE_SUB(val1, val2) (val1)->Calc(VALUE_SUB_OPERATOR, val2)
#define VALUE_MUL(val1, val2) (val1)->Calc(VALUE_MUL_OPERATOR, val2)
#define VALUE_DIV(val1, val2) (val1)->Calc(VALUE_DIV_OPERATOR, val2)
#define VALUE_NEG(val1) (val1)->Calc(VALUE_NEG_OPERATOR, val1)
#define VALUE_POS(val1) (val1)->Calc(VALUE_POS_OPERATOR, val1)
#endif
2002-10-12 11:37:38 +00:00
STR_String CValue::op2str(VALUE_OPERATOR op)
2002-10-12 11:37:38 +00:00
{
//pre:
//ret: the stringrepresentation of operator op
STR_String opmsg;
switch (op) {
case VALUE_MOD_OPERATOR:
opmsg = " % ";
break;
2002-10-12 11:37:38 +00:00
case VALUE_ADD_OPERATOR:
opmsg = " + ";
break;
case VALUE_SUB_OPERATOR:
opmsg = " - ";
break;
case VALUE_MUL_OPERATOR:
opmsg = " * ";
break;
case VALUE_DIV_OPERATOR:
opmsg = " / ";
break;
case VALUE_NEG_OPERATOR:
opmsg = " -";
break;
case VALUE_POS_OPERATOR:
opmsg = " +";
break;
case VALUE_AND_OPERATOR:
opmsg = " & ";
break;
case VALUE_OR_OPERATOR:
opmsg = " | ";
break;
case VALUE_EQL_OPERATOR:
opmsg = " = ";
break;
case VALUE_NEQ_OPERATOR:
opmsg = " != ";
break;
case VALUE_NOT_OPERATOR:
opmsg = " !";
break;
default:
opmsg="Error in Errorhandling routine.";
// AfxMessageBox("Invalid operator");
break;
}
return opmsg;
}
//---------------------------------------------------------------------------------------------------------------------
// Property Management
//---------------------------------------------------------------------------------------------------------------------
//
// Set property <ioProperty>, overwrites and releases a previous property with the same name if needed
//
void CValue::SetProperty(const STR_String & name,CValue* ioProperty)
{
if (ioProperty==NULL)
{ // Check if somebody is setting an empty property
2002-10-12 11:37:38 +00:00
trace("Warning:trying to set empty property!");
return;
}
if (m_pNamedPropertyArray)
{ // Try to replace property (if so -> exit as soon as we replaced it)
CValue* oldval = (*m_pNamedPropertyArray)[name];
if (oldval)
oldval->Release();
}
else { // Make sure we have a property array
m_pNamedPropertyArray = new std::map<STR_String,CValue *>;
2002-10-12 11:37:38 +00:00
}
// Add property at end of array
(*m_pNamedPropertyArray)[name] = ioProperty->AddRef();//->Add(ioProperty);
2002-10-12 11:37:38 +00:00
}
void CValue::SetProperty(const char* name,CValue* ioProperty)
{
if (ioProperty==NULL)
{ // Check if somebody is setting an empty property
trace("Warning:trying to set empty property!");
return;
}
2002-10-12 11:37:38 +00:00
if (m_pNamedPropertyArray)
{ // Try to replace property (if so -> exit as soon as we replaced it)
CValue* oldval = (*m_pNamedPropertyArray)[name];
if (oldval)
oldval->Release();
}
else { // Make sure we have a property array
m_pNamedPropertyArray = new std::map<STR_String,CValue *>;
}
// Add property at end of array
(*m_pNamedPropertyArray)[name] = ioProperty->AddRef();//->Add(ioProperty);
}
2002-10-12 11:37:38 +00:00
//
// Get pointer to a property with name <inName>, returns NULL if there is no property named <inName>
//
CValue* CValue::GetProperty(const STR_String & inName)
{
if (m_pNamedPropertyArray) {
std::map<STR_String,CValue*>::iterator it = m_pNamedPropertyArray->find(inName);
if (it != m_pNamedPropertyArray->end())
return (*it).second;
2002-10-12 11:37:38 +00:00
}
return NULL;
2002-10-12 11:37:38 +00:00
}
CValue* CValue::GetProperty(const char *inName)
{
if (m_pNamedPropertyArray) {
std::map<STR_String,CValue*>::iterator it = m_pNamedPropertyArray->find(inName);
if (it != m_pNamedPropertyArray->end())
return (*it).second;
}
return NULL;
}
2002-10-12 11:37:38 +00:00
//
// Get text description of property with name <inName>, returns an empty string if there is no property named <inName>
//
const STR_String& CValue::GetPropertyText(const STR_String & inName)
2002-10-12 11:37:38 +00:00
{
BGE performance, 4th round: logic This commit extends the technique of dynamic linked list to the logic system to eliminate as much as possible temporaries, map lookup or full scan. The logic engine is now free of memory allocation, which is an important stability factor. The overhead of the logic system is reduced by a factor between 3 and 6 depending on the logic setup. This is the speed-up you can expect on a logic setup using simple bricks. Heavy bricks like python controllers and ray sensors will still take about the same time to execute so the speed up will be less important. The core of the logic engine has been much reworked but the functionality is still the same except for one thing: the priority system on the execution of controllers. The exact same remark applies to actuators but I'll explain for controllers only: Previously, it was possible, with the "executePriority" attribute to set a controller to run before any other controllers in the game. Other than that, the sequential execution of controllers, as defined in Blender was guaranteed by default. With the new system, the sequential execution of controllers is still guaranteed but only within the controllers of one object. the user can no longer set a controller to run before any other controllers in the game. The "executePriority" attribute controls the execution of controllers within one object. The priority is a small number starting from 0 for the first controller and incrementing for each controller. If this missing feature is a must, a special method can be implemented to set a controller to run before all other controllers. Other improvements: - Systematic use of reference in parameter passing to avoid unnecessary data copy - Use pre increment in iterator instead of post increment to avoid temporary allocation - Use const char* instead of STR_String whenever possible to avoid temporary allocation - Fix reference counting bugs (memory leak) - Fix a crash in certain cases of state switching and object deletion - Minor speed up in property sensor - Removal of objects during the game is a lot faster
2009-05-10 20:53:58 +00:00
const static STR_String sEmpty("");
2002-10-12 11:37:38 +00:00
CValue *property = GetProperty(inName);
if (property)
return property->GetText();
else
BGE performance, 4th round: logic This commit extends the technique of dynamic linked list to the logic system to eliminate as much as possible temporaries, map lookup or full scan. The logic engine is now free of memory allocation, which is an important stability factor. The overhead of the logic system is reduced by a factor between 3 and 6 depending on the logic setup. This is the speed-up you can expect on a logic setup using simple bricks. Heavy bricks like python controllers and ray sensors will still take about the same time to execute so the speed up will be less important. The core of the logic engine has been much reworked but the functionality is still the same except for one thing: the priority system on the execution of controllers. The exact same remark applies to actuators but I'll explain for controllers only: Previously, it was possible, with the "executePriority" attribute to set a controller to run before any other controllers in the game. Other than that, the sequential execution of controllers, as defined in Blender was guaranteed by default. With the new system, the sequential execution of controllers is still guaranteed but only within the controllers of one object. the user can no longer set a controller to run before any other controllers in the game. The "executePriority" attribute controls the execution of controllers within one object. The priority is a small number starting from 0 for the first controller and incrementing for each controller. If this missing feature is a must, a special method can be implemented to set a controller to run before all other controllers. Other improvements: - Systematic use of reference in parameter passing to avoid unnecessary data copy - Use pre increment in iterator instead of post increment to avoid temporary allocation - Use const char* instead of STR_String whenever possible to avoid temporary allocation - Fix reference counting bugs (memory leak) - Fix a crash in certain cases of state switching and object deletion - Minor speed up in property sensor - Removal of objects during the game is a lot faster
2009-05-10 20:53:58 +00:00
return sEmpty;
2002-10-12 11:37:38 +00:00
}
float CValue::GetPropertyNumber(const STR_String& inName,float defnumber)
{
CValue *property = GetProperty(inName);
if (property)
return property->GetNumber();
2002-10-12 11:37:38 +00:00
else
return defnumber;
}
//
// Remove the property named <inName>, returns true if the property was succesfully removed, false if property was not found or could not be removed
//
bool CValue::RemoveProperty(const char *inName)
2002-10-12 11:37:38 +00:00
{
// Check if there are properties at all which can be removed
if (m_pNamedPropertyArray)
{
std::map<STR_String,CValue*>::iterator it = m_pNamedPropertyArray->find(inName);
if (it != m_pNamedPropertyArray->end())
{
((*it).second)->Release();
m_pNamedPropertyArray->erase(it);
return true;
}
}
2002-10-12 11:37:38 +00:00
return false;
}
//
// Get Property Names
//
vector<STR_String> CValue::GetPropertyNames()
{
vector<STR_String> result;
if (!m_pNamedPropertyArray) return result;
result.reserve(m_pNamedPropertyArray->size());
std::map<STR_String,CValue*>::iterator it;
for (it= m_pNamedPropertyArray->begin(); (it != m_pNamedPropertyArray->end()); it++)
{
result.push_back((*it).first);
}
return result;
}
2002-10-12 11:37:38 +00:00
//
// Clear all properties
//
void CValue::ClearProperties()
2012-09-16 04:58:18 +00:00
{
2002-10-12 11:37:38 +00:00
// Check if we have any properties
if (m_pNamedPropertyArray == NULL)
return;
// Remove all properties
std::map<STR_String,CValue*>::iterator it;
for (it= m_pNamedPropertyArray->begin();(it != m_pNamedPropertyArray->end()); it++)
2002-10-12 11:37:38 +00:00
{
CValue* tmpval = (*it).second;
//STR_String name = (*it).first;
2002-10-12 11:37:38 +00:00
tmpval->Release();
}
// Delete property array
delete m_pNamedPropertyArray;
m_pNamedPropertyArray=NULL;
}
//
// Set all properties' modified flag to <inModified>
//
void CValue::SetPropertiesModified(bool inModified)
{
if (!m_pNamedPropertyArray) return;
std::map<STR_String,CValue*>::iterator it;
for (it= m_pNamedPropertyArray->begin();(it != m_pNamedPropertyArray->end()); it++)
((*it).second)->SetModified(inModified);
2002-10-12 11:37:38 +00:00
}
//
// Check if any of the properties in this value have been modified
//
bool CValue::IsAnyPropertyModified()
{
if (!m_pNamedPropertyArray) return false;
std::map<STR_String,CValue*>::iterator it;
for (it= m_pNamedPropertyArray->begin();(it != m_pNamedPropertyArray->end()); it++)
if (((*it).second)->IsModified())
2002-10-12 11:37:38 +00:00
return true;
2002-10-12 11:37:38 +00:00
return false;
}
//
// Get property number <inIndex>
//
CValue* CValue::GetProperty(int inIndex)
{
int count=0;
CValue* result = NULL;
if (m_pNamedPropertyArray)
{
std::map<STR_String,CValue*>::iterator it;
for (it= m_pNamedPropertyArray->begin(); (it != m_pNamedPropertyArray->end()); it++)
2002-10-12 11:37:38 +00:00
{
2012-07-01 09:54:44 +00:00
if (count++ == inIndex)
2002-10-12 11:37:38 +00:00
{
result = (*it).second;
break;
}
}
}
return result;
}
//
// Get the amount of properties assiocated with this value
//
int CValue::GetPropertyCount()
{
if (m_pNamedPropertyArray)
return m_pNamedPropertyArray->size();
else
return 0;
}
double* CValue::GetVector3(bool bGetTransformedVec)
{
2012-03-01 12:20:18 +00:00
assertd(false); // don't get vector from me
2002-10-12 11:37:38 +00:00
return m_sZeroVec;//::sZero;
}
/*---------------------------------------------------------------------------------------------------------------------
Reference Counting
---------------------------------------------------------------------------------------------------------------------*/
//
// Release a reference to this value (when reference count reaches 0, the value is removed from the heap)
//
//
// Disable reference counting for this value
//
void CValue::DisableRefCount()
{
assertd(m_refcount == 1);
m_refcount--;
//debug(gRefCountValue--);
#ifdef _DEBUG
//gRefCountValue--;
#endif
2002-10-12 11:37:38 +00:00
m_ValFlags.RefCountDisabled=true;
}
void CValue::ProcessReplica() /* was AddDataToReplica in 2.48 */
2002-10-12 11:37:38 +00:00
{
m_refcount = 1;
2002-10-12 11:37:38 +00:00
#ifdef _DEBUG
//gRefCountValue++;
#endif
PyObjectPlus::ProcessReplica();
2002-10-12 11:37:38 +00:00
m_ValFlags.RefCountDisabled = false;
2002-10-12 11:37:38 +00:00
/* copy all props */
if (m_pNamedPropertyArray)
{
std::map<STR_String,CValue*> *pOldArray = m_pNamedPropertyArray;
m_pNamedPropertyArray=NULL;
std::map<STR_String,CValue*>::iterator it;
for (it= pOldArray->begin(); (it != pOldArray->end()); it++)
{
CValue *val = (*it).second->GetReplica();
SetProperty((*it).first,val);
val->Release();
}
}
}
2002-10-12 11:37:38 +00:00
CValue* CValue::FindIdentifier(const STR_String& identifiername)
{
CValue* result = NULL;
int pos = 0;
// if a dot exists, explode the name into pieces to get the subcontext
if ((pos=identifiername.Find('.'))>=0)
{
const STR_String rightstring = identifiername.Right(identifiername.Length() -1 - pos);
const STR_String leftstring = identifiername.Left(pos);
CValue* tempresult = GetProperty(leftstring);
if (tempresult)
{
result=tempresult->FindIdentifier(rightstring);
}
} else
{
result = GetProperty(identifiername);
if (result)
return result->AddRef();
}
if (!result)
{
// warning here !!!
result = new CErrorValue(identifiername+" not found");
2002-10-12 11:37:38 +00:00
}
return result;
}
#ifdef WITH_PYTHON
2002-10-12 11:37:38 +00:00
PyAttributeDef CValue::Attributes[] = {
KX_PYATTRIBUTE_RO_FUNCTION("name", CValue, pyattr_get_name),
{ NULL } //Sentinel
};
PyObject *CValue::pyattr_get_name(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
2011-12-30 07:55:15 +00:00
{
CValue * self = static_cast<CValue *> (self_v);
return PyUnicode_From_STR_String(self->GetName());
}
/**
* There are 2 reasons this could return NULL
* - unsupported type.
* - error converting (overflow).
*
* \param do_type_exception Use to skip raising an exception for unknown types.
*/
CValue *CValue::ConvertPythonToValue(PyObject *pyobj, const bool do_type_exception, const char *error_prefix)
2002-10-12 11:37:38 +00:00
{
CValue *vallie;
/* refcounting is broking here! - this crashes anyway, just store a python list for KX_GameObject */
#if 0
if (PyList_Check(pyobj))
2002-10-12 11:37:38 +00:00
{
CListValue* listval = new CListValue();
bool error = false;
Py_ssize_t i;
Py_ssize_t numitems = PyList_GET_SIZE(pyobj);
2002-10-12 11:37:38 +00:00
for (i=0;i<numitems;i++)
{
2012-09-16 04:58:18 +00:00
PyObject *listitem = PyList_GetItem(pyobj,i); /* borrowed ref */
CValue* listitemval = ConvertPythonToValue(listitem, error_prefix);
2002-10-12 11:37:38 +00:00
if (listitemval)
{
listval->Add(listitemval);
} else
{
error = true;
}
}
if (!error)
{
// jippie! could be converted
vallie = listval;
} else
{
// list could not be converted... bad luck
listval->Release();
}
} else
#endif
/* note: Boolean check should go before Int check [#34677] */
if (PyBool_Check(pyobj))
{
vallie = new CBoolValue( (bool)PyLong_AsLongLong(pyobj) );
} else
if (PyFloat_Check(pyobj))
2002-10-12 11:37:38 +00:00
{
const double tval = PyFloat_AsDouble(pyobj);
if (tval > (double)FLT_MAX || tval < (double)-FLT_MAX) {
PyErr_Format(PyExc_OverflowError, "%soverflow converting from float, out of internal range", error_prefix);
vallie = NULL;
}
else {
vallie = new CFloatValue((float)tval);
}
2002-10-12 11:37:38 +00:00
} else
if (PyLong_Check(pyobj))
{
vallie = new CIntValue( (cInt)PyLong_AsLongLong(pyobj) );
2002-10-12 11:37:38 +00:00
} else
if (PyUnicode_Check(pyobj))
2002-10-12 11:37:38 +00:00
{
vallie = new CStringValue(_PyUnicode_AsString(pyobj),"");
2002-10-12 11:37:38 +00:00
} else
2012-03-18 07:38:51 +00:00
if (PyObject_TypeCheck(pyobj, &CValue::Type)) /* Note, don't let these get assigned to GameObject props, must check elsewhere */
2002-10-12 11:37:38 +00:00
{
vallie = (static_cast<CValue *>(BGE_PROXY_REF(pyobj)))->AddRef();
}
else {
if (do_type_exception) {
/* return an error value from the caller */
PyErr_Format(PyExc_TypeError, "%scould convert python value to a game engine property", error_prefix);
}
vallie = NULL;
2002-10-12 11:37:38 +00:00
}
return vallie;
}
2012-09-16 04:58:18 +00:00
PyObject *CValue::ConvertKeysToPython(void)
{
if (m_pNamedPropertyArray)
{
PyObject *pylist= PyList_New(m_pNamedPropertyArray->size());
Py_ssize_t i= 0;
std::map<STR_String,CValue*>::iterator it;
for (it= m_pNamedPropertyArray->begin(); (it != m_pNamedPropertyArray->end()); it++)
{
PyList_SET_ITEM(pylist, i++, PyUnicode_From_STR_String((*it).first));
}
return pylist;
}
else {
return PyList_New(0);
}
}
#endif // WITH_PYTHON
2002-10-12 11:37:38 +00:00
///////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
/* These implementations were moved out of the header */
void CValue::SetOwnerExpression(class CExpression* expr)
{
/* intentionally empty */
}
void CValue::SetColorOperator(VALUE_OPERATOR op)
{
/* intentionally empty */
}
void CValue::SetValue(CValue* newval)
{
// no one should get here
2012-09-16 04:58:18 +00:00
assertd(newval->GetNumber() == 10121969);
2002-10-12 11:37:38 +00:00
}