OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
104 Commits
81 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: 745d8c675f
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '745d8c675f'
${ noResults }
CWE-ou-minkata/Sources/Plasma/FeatureLib/pfPython/pySDLGlue.cpp

297 lines
12 KiB
Raw Blame History

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#include "pySDL.h"
#include "plSDL/plSDL.h"
#include "pyEnum.h"
#include "pyKey.h"
#include <python.h>
void pySDL::AddPlasmaConstantsClasses(PyObject *m)
{
PYTHON_ENUM_START(PtSDLReadWriteOptions);
PYTHON_ENUM_ELEMENT(PtSDLReadWriteOptions, kDirtyOnly, plSDL::kDirtyOnly);
PYTHON_ENUM_ELEMENT(PtSDLReadWriteOptions, kSkipNotificationInfo, plSDL::kSkipNotificationInfo);
PYTHON_ENUM_ELEMENT(PtSDLReadWriteOptions, kBroadcast, plSDL::kBroadcast);
//PYTHON_ENUM_ELEMENT(PtSDLReadWriteOptions, kWriteTimeStamps, plSDL::kWriteTimeStamps);
PYTHON_ENUM_ELEMENT(PtSDLReadWriteOptions, kTimeStampOnRead, plSDL::kTimeStampOnRead);
//PYTHON_ENUM_ELEMENT(PtSDLReadWriteOptions, kTimeStampDirtyOnRead, plSDL::kTimeStampDirtyOnRead);
PYTHON_ENUM_END(m, PtSDLReadWriteOptions);
PYTHON_ENUM_START(PtSDLVarType);
PYTHON_ENUM_ELEMENT(PtSDLVarType, kNone, plVarDescriptor::kNone);
PYTHON_ENUM_ELEMENT(PtSDLVarType, kInt, plVarDescriptor::kInt);
PYTHON_ENUM_ELEMENT(PtSDLVarType, kFloat, plVarDescriptor::kFloat);
PYTHON_ENUM_ELEMENT(PtSDLVarType, kBool, plVarDescriptor::kBool);
PYTHON_ENUM_ELEMENT(PtSDLVarType, kString32, plVarDescriptor::kString32);
PYTHON_ENUM_ELEMENT(PtSDLVarType, kKey, plVarDescriptor::kKey);
PYTHON_ENUM_ELEMENT(PtSDLVarType, kStateDescriptor, plVarDescriptor::kStateDescriptor);
PYTHON_ENUM_ELEMENT(PtSDLVarType, kCreatable, plVarDescriptor::kCreatable);
PYTHON_ENUM_ELEMENT(PtSDLVarType, kDouble, plVarDescriptor::kDouble);
PYTHON_ENUM_ELEMENT(PtSDLVarType, kTime, plVarDescriptor::kTime);
PYTHON_ENUM_ELEMENT(PtSDLVarType, kVector3, plVarDescriptor::kVector3);
PYTHON_ENUM_ELEMENT(PtSDLVarType, kPoint3, plVarDescriptor::kPoint3);
PYTHON_ENUM_ELEMENT(PtSDLVarType, kRGB, plVarDescriptor::kRGB);
PYTHON_ENUM_ELEMENT(PtSDLVarType, kRGBA, plVarDescriptor::kRGBA);
PYTHON_ENUM_ELEMENT(PtSDLVarType, kQuaternion, plVarDescriptor::kQuaternion);
PYTHON_ENUM_ELEMENT(PtSDLVarType, kByte, plVarDescriptor::kByte);
PYTHON_ENUM_ELEMENT(PtSDLVarType, kShort, plVarDescriptor::kShort);
PYTHON_ENUM_END(m, PtSDLVarType);
}
// glue functions
PYTHON_CLASS_DEFINITION(ptSDLStateDataRecord, pySDLStateDataRecord);
PYTHON_DEFAULT_NEW_DEFINITION(ptSDLStateDataRecord, pySDLStateDataRecord)
PYTHON_DEFAULT_DEALLOC_DEFINITION(ptSDLStateDataRecord)
PYTHON_INIT_DEFINITION(ptSDLStateDataRecord, args, keywords)
{
PYTHON_RETURN_INIT_OK;
}
PYTHON_METHOD_DEFINITION(ptSDLStateDataRecord, findVar, args)
{
char* name;
if (!PyArg_ParseTuple(args, "s", &name))
{
PyErr_SetString(PyExc_TypeError, "findVar expects a string");
PYTHON_RETURN_ERROR;
}
return self->fThis->FindVar(name);
}
PYTHON_METHOD_DEFINITION_NOARGS(ptSDLStateDataRecord, getName)
{
return PyString_FromString(self->fThis->GetName());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptSDLStateDataRecord, getVarList)
{
std::vector<std::string> vars = self->fThis->GetVarList();
PyObject* varList = PyList_New(vars.size());
for (int i = 0; i < vars.size(); i++)
PyList_SetItem(varList, i, PyString_FromString(vars[i].c_str()));
return varList;
}
PYTHON_METHOD_DEFINITION(ptSDLStateDataRecord, setFromDefaults, args)
{
char timeStampNow;
if (!PyArg_ParseTuple(args, "b", &timeStampNow))
{
PyErr_SetString(PyExc_TypeError, "setFromDefaults expects a boolean");
PYTHON_RETURN_ERROR;
}
self->fThis->SetFromDefaults(timeStampNow != 0);
PYTHON_RETURN_NONE;
}
PYTHON_START_METHODS_TABLE(ptSDLStateDataRecord)
PYTHON_METHOD(ptSDLStateDataRecord, findVar, "Params: name\nFinds and returns the specified ptSimpleStateVariable"),
PYTHON_METHOD_NOARGS(ptSDLStateDataRecord, getName, "Returns our record's name"),
PYTHON_METHOD_NOARGS(ptSDLStateDataRecord, getVarList, "Returns the names of the vars we hold as a list of strings"),
PYTHON_METHOD(ptSDLStateDataRecord, setFromDefaults, "Params: timeStampNow\nSets all our vars to their defaults"),
PYTHON_END_METHODS_TABLE;
// Type structure definition
PLASMA_DEFAULT_TYPE(ptSDLStateDataRecord, "Basic SDL state data record class");
// required functions for PyObject interoperability
PYTHON_CLASS_NEW_IMPL(ptSDLStateDataRecord, pySDLStateDataRecord)
PyObject *pySDLStateDataRecord::New(plStateDataRecord* rec)
{
ptSDLStateDataRecord* newObj = (ptSDLStateDataRecord*)ptSDLStateDataRecord_type.tp_new(&ptSDLStateDataRecord_type, NULL, NULL);
newObj->fThis->fRec = rec;
return (PyObject*)newObj;
}
PYTHON_CLASS_CHECK_IMPL(ptSDLStateDataRecord, pySDLStateDataRecord)
PYTHON_CLASS_CONVERT_FROM_IMPL(ptSDLStateDataRecord, pySDLStateDataRecord)
///////////////////////////////////////////////////////////////////////////
//
// AddPlasmaClasses - the python module definitions
//
void pySDLStateDataRecord::AddPlasmaClasses(PyObject *m)
{
PYTHON_CLASS_IMPORT_START(m);
PYTHON_CLASS_IMPORT(m, ptSDLStateDataRecord);
PYTHON_CLASS_IMPORT_END(m);
}
// glue functions
PYTHON_CLASS_DEFINITION(ptSimpleStateVariable, pySimpleStateVariable);
PYTHON_DEFAULT_NEW_DEFINITION(ptSimpleStateVariable, pySimpleStateVariable)
PYTHON_DEFAULT_DEALLOC_DEFINITION(ptSimpleStateVariable)
PYTHON_INIT_DEFINITION(ptSimpleStateVariable, args, keywords)
{
PYTHON_RETURN_INIT_OK;
}
// two little macros to make things a little easier
#define STATEVAR_SET(funcName, cFuncName, typeName, cTypeName, pythonTypeChar) \
PYTHON_METHOD_DEFINITION(ptSimpleStateVariable, funcName, args) \
{ \
cTypeName val; \
int idx = 0; \
if (!PyArg_ParseTuple(args, #pythonTypeChar "|i", &val, &idx)) \
{ \
PyErr_SetString(PyExc_TypeError, #funcName " expects a " #typeName " and an optional int"); \
PYTHON_RETURN_ERROR; \
} \
PYTHON_RETURN_BOOL(self->fThis->cFuncName(val, idx)); \
}
#define STATEVAR_GET(funcName, cFuncName, pythonReturnFunc) \
PYTHON_METHOD_DEFINITION(ptSimpleStateVariable, funcName, args) \
{ \
int idx = 0; \
if (!PyArg_ParseTuple(args, "|i", &idx)) \
{ \
PyErr_SetString(PyExc_TypeError, #funcName " expects an optional int"); \
PYTHON_RETURN_ERROR; \
} \
return pythonReturnFunc(self->fThis->cFuncName(idx)); \
}
STATEVAR_SET(setByte, SetByte, byte, char, b)
STATEVAR_SET(setShort, SetShort, short, short, h)
STATEVAR_SET(setFloat, SetFloat, float, float, f)
STATEVAR_SET(setDouble, SetDouble, double, double, d)
STATEVAR_SET(setInt, SetInt, int, int, i)
STATEVAR_SET(setString, SetString, string, char*, s)
// setBool is special cause of the way python represents booleans
PYTHON_METHOD_DEFINITION(ptSimpleStateVariable, setBool, args)
{
char val;
int idx = 0;
if (!PyArg_ParseTuple(args, "b|i", &val, &idx))
{
PyErr_SetString(PyExc_TypeError, "setBool expects a boolean and an optional int");
PYTHON_RETURN_ERROR;
}
PYTHON_RETURN_BOOL(self->fThis->SetBool(val != 0, idx));
}
STATEVAR_GET(getByte, GetByte, PyInt_FromLong)
STATEVAR_GET(getShort, GetShort, PyInt_FromLong)
STATEVAR_GET(getInt, GetInt, PyInt_FromLong)
STATEVAR_GET(getFloat, GetFloat, PyFloat_FromDouble)
STATEVAR_GET(getDouble, GetDouble, PyFloat_FromDouble)
STATEVAR_GET(getString, GetString, PyString_FromString)
STATEVAR_GET(getKey, GetKey, pyKey::New)
// getBool is special cause of the way python represents booleans
PYTHON_METHOD_DEFINITION(ptSimpleStateVariable, getBool, args)
{
int idx = 0;
if (!PyArg_ParseTuple(args, "|i", &idx))
{
PyErr_SetString(PyExc_TypeError, "getBool expects an optional int");
PYTHON_RETURN_ERROR;
}
PYTHON_RETURN_BOOL(self->fThis->GetBool(idx));
}
PYTHON_METHOD_DEFINITION_NOARGS(ptSimpleStateVariable, getType)
{
return PyInt_FromLong(self->fThis->GetType());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptSimpleStateVariable, getDisplayOptions)
{
return PyString_FromString(self->fThis->GetDisplayOptions());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptSimpleStateVariable, getDefault)
{
return PyString_FromString(self->fThis->GetDefault());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptSimpleStateVariable, isAlwaysNew)
{
PYTHON_RETURN_BOOL(self->fThis->IsAlwaysNew());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptSimpleStateVariable, isInternal)
{
PYTHON_RETURN_BOOL(self->fThis->IsInternal());
}
PYTHON_START_METHODS_TABLE(ptSimpleStateVariable)
PYTHON_METHOD(ptSimpleStateVariable, setByte, "Params: val,idx=0\nSets a byte variable's value"),
PYTHON_METHOD(ptSimpleStateVariable, setShort, "Params: val,idx=0\nSets a short variable's value"),
PYTHON_METHOD(ptSimpleStateVariable, setFloat, "Params: val,idx=0\nSets a float variable's value"),
PYTHON_METHOD(ptSimpleStateVariable, setDouble, "Params: val,idx=0\nSets a double variable's value"),
PYTHON_METHOD(ptSimpleStateVariable, setInt, "Params: val,idx=0\nSets an int variable's value"),
PYTHON_METHOD(ptSimpleStateVariable, setString, "Params: val,idx=0\nSets a string variable's value"),
PYTHON_METHOD(ptSimpleStateVariable, setBool, "Params: val,idx=0\nSets a boolean variable's value"),
PYTHON_METHOD(ptSimpleStateVariable, getByte, "Params: idx=0\nReturns a byte variable's value"),
PYTHON_METHOD(ptSimpleStateVariable, getShort, "Params: idx=0\nReturns a short variable's value"),
PYTHON_METHOD(ptSimpleStateVariable, getInt, "Params: idx=0\nReturns an int variable's value"),
PYTHON_METHOD(ptSimpleStateVariable, getFloat, "Params: idx=0\nReturns a float variable's value"),
PYTHON_METHOD(ptSimpleStateVariable, getDouble, "Params: idx=0\nReturns a double variable's value"),
PYTHON_METHOD(ptSimpleStateVariable, getString, "Params: idx=0\nReturns a string variable's value"),
PYTHON_METHOD(ptSimpleStateVariable, getKey, "Params: idx=0\nReturns a plKey variable's value"),
PYTHON_METHOD(ptSimpleStateVariable, getBool, "Params: idx=0\nReturns a boolean variable's value"),
PYTHON_METHOD_NOARGS(ptSimpleStateVariable, getType, "Returns the variable's type"),
PYTHON_METHOD_NOARGS(ptSimpleStateVariable, getDisplayOptions, "Returns the variable's display options"),
PYTHON_METHOD_NOARGS(ptSimpleStateVariable, getDefault, "Returns the variable's default"),
PYTHON_METHOD_NOARGS(ptSimpleStateVariable, isAlwaysNew, "Is this variable always new?"),
PYTHON_METHOD_NOARGS(ptSimpleStateVariable, isInternal, "Is this an internal variable?"),
PYTHON_END_METHODS_TABLE;
// Type structure definition
PLASMA_DEFAULT_TYPE(ptSimpleStateVariable, "Basic SDL state data record class");
// required functions for PyObject interoperability
PYTHON_CLASS_NEW_IMPL(ptSimpleStateVariable, pySimpleStateVariable)
PyObject *pySimpleStateVariable::New(plSimpleStateVariable* var)
{
ptSimpleStateVariable* newObj = (ptSimpleStateVariable*)ptSimpleStateVariable_type.tp_new(&ptSimpleStateVariable_type, NULL, NULL);
newObj->fThis->fVar = var;
return (PyObject*)newObj;
}
PYTHON_CLASS_CHECK_IMPL(ptSimpleStateVariable, pySimpleStateVariable)
PYTHON_CLASS_CONVERT_FROM_IMPL(ptSimpleStateVariable, pySimpleStateVariable)
///////////////////////////////////////////////////////////////////////////
//
// AddPlasmaClasses - the python module definitions
//
void pySimpleStateVariable::AddPlasmaClasses(PyObject *m)
{
PYTHON_CLASS_IMPORT_START(m);
PYTHON_CLASS_IMPORT(m, ptSimpleStateVariable);
PYTHON_CLASS_IMPORT_END(m);
}