doxygen: prevent GPL license block from being parsed as doxygen comment.
[blender.git] / source / gameengine / Ketsji / KX_PolyProxy.cpp
index ca38117..45f4e68 100644 (file)
@@ -1,4 +1,4 @@
-/**
+/*
  * $Id$
  * ***** BEGIN GPL LICENSE BLOCK *****
  *
@@ -14,7 +14,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  * All rights reserved.
@@ -26,9 +26,7 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
+#ifdef WITH_PYTHON
 
 #include "KX_PolyProxy.h"
 #include "KX_MeshProxy.h"
 #include "KX_PyMath.h"
 
 PyTypeObject KX_PolyProxy::Type = {
-#if (PY_VERSION_HEX >= 0x02060000)
        PyVarObject_HEAD_INIT(NULL, 0)
-#else
-       /* python 2.5 and below */
-       PyObject_HEAD_INIT( NULL )  /* required py macro */
-       0,                          /* ob_size */
-#endif
        "KX_PolyProxy",
        sizeof(PyObjectPlus_Proxy),
        0,
@@ -55,18 +47,15 @@ PyTypeObject KX_PolyProxy::Type = {
        0,
        0,
        py_base_repr,
-       0,0,0,0,0,0,
-       py_base_getattro,
-       py_base_setattro,
        0,0,0,0,0,0,0,0,0,
-       Methods
-};
-
-PyParentObject KX_PolyProxy::Parents[] = {
-       &KX_PolyProxy::Type,
-       &SCA_IObject::Type,
+       Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+       0,0,0,0,0,0,0,
+       Methods,
+       0,
+       0,
        &CValue::Type,
-       NULL
+       0,0,0,0,0,0,
+       py_base_new
 };
 
 PyMethodDef KX_PolyProxy::Methods[] = {
@@ -83,92 +72,19 @@ PyMethodDef KX_PolyProxy::Methods[] = {
 };
 
 PyAttributeDef KX_PolyProxy::Attributes[] = {
-       /* All dummy's so they come up in a dir() */
-       //KX_PYATTRIBUTE_TODO("DummyProps"),
-       KX_PYATTRIBUTE_DUMMY("matname"),
-       KX_PYATTRIBUTE_DUMMY("texture"),
-       KX_PYATTRIBUTE_DUMMY("material"),
-       KX_PYATTRIBUTE_DUMMY("matid"),
-       KX_PYATTRIBUTE_DUMMY("v1"),
-       KX_PYATTRIBUTE_DUMMY("v2"),
-       KX_PYATTRIBUTE_DUMMY("v3"),
-       KX_PYATTRIBUTE_DUMMY("v4"),
-       KX_PYATTRIBUTE_DUMMY("visible"),
-       KX_PYATTRIBUTE_DUMMY("collide"),
+       KX_PYATTRIBUTE_RO_FUNCTION("material_name", KX_PolyProxy, pyattr_get_material_name),
+       KX_PYATTRIBUTE_RO_FUNCTION("texture_name", KX_PolyProxy, pyattr_get_texture_name),
+       KX_PYATTRIBUTE_RO_FUNCTION("material", KX_PolyProxy, pyattr_get_material),
+       KX_PYATTRIBUTE_RO_FUNCTION("material_id", KX_PolyProxy, pyattr_get_material_id),
+       KX_PYATTRIBUTE_RO_FUNCTION("v1", KX_PolyProxy, pyattr_get_v1),
+       KX_PYATTRIBUTE_RO_FUNCTION("v2", KX_PolyProxy, pyattr_get_v2),
+       KX_PYATTRIBUTE_RO_FUNCTION("v3", KX_PolyProxy, pyattr_get_v3),
+       KX_PYATTRIBUTE_RO_FUNCTION("v4", KX_PolyProxy, pyattr_get_v4),
+       KX_PYATTRIBUTE_RO_FUNCTION("visible", KX_PolyProxy, pyattr_get_visible),
+       KX_PYATTRIBUTE_RO_FUNCTION("collide", KX_PolyProxy, pyattr_get_collide),
        { NULL }        //Sentinel
 };
 
-PyObject* KX_PolyProxy::py_getattro(PyObject *attr)
-{
-       char *attr_str= PyString_AsString(attr);
-       if (!strcmp(attr_str, "matname"))
-       {
-               return PyString_FromString(m_polygon->GetMaterial()->GetPolyMaterial()->GetMaterialName());
-       }
-       if (!strcmp(attr_str, "texture"))
-       {
-               return PyString_FromString(m_polygon->GetMaterial()->GetPolyMaterial()->GetTextureName());
-       }
-       if (!strcmp(attr_str, "material"))
-       {
-               RAS_IPolyMaterial *polymat = m_polygon->GetMaterial()->GetPolyMaterial();
-               if(polymat->GetFlag() & RAS_BLENDERMAT)
-               {
-                       KX_BlenderMaterial* mat = static_cast<KX_BlenderMaterial*>(polymat);
-                       return mat->GetProxy();
-               }
-               else
-               {
-                       KX_PolygonMaterial* mat = static_cast<KX_PolygonMaterial*>(polymat);
-                       return mat->GetProxy();
-               }
-       }
-       if (!strcmp(attr_str, "matid"))
-       {
-               // we'll have to scan through the material bucket of the mes and compare with 
-               // the one of the polygon
-               RAS_MaterialBucket* polyBucket = m_polygon->GetMaterial();
-               unsigned int matid;
-               for (matid=0; matid<(unsigned int)m_mesh->NumMaterials(); matid++)
-               {
-                       RAS_MeshMaterial* meshMat = m_mesh->GetMeshMaterial(matid);
-                       if (meshMat->m_bucket == polyBucket)
-                               // found it
-                               break;
-               }
-               return PyInt_FromLong(matid);
-       }
-       if (!strcmp(attr_str, "v1"))
-       {
-               return PyInt_FromLong(m_polygon->GetVertexOffset(0));
-       }
-       if (!strcmp(attr_str, "v2"))
-       {
-               return PyInt_FromLong(m_polygon->GetVertexOffset(1));
-       }
-       if (!strcmp(attr_str, "v3"))
-       {
-               return PyInt_FromLong(m_polygon->GetVertexOffset(2));
-       }
-       if (!strcmp(attr_str, "v4"))
-       {
-               return PyInt_FromLong(((m_polygon->VertexCount()>3)?m_polygon->GetVertexOffset(3):0));
-       }
-       if (!strcmp(attr_str, "visible"))
-       {
-               return PyInt_FromLong(m_polygon->IsVisible());
-       }
-       if (!strcmp(attr_str, "collide"))
-       {
-               return PyInt_FromLong(m_polygon->IsCollider());
-       }
-       py_getattro_up(SCA_IObject);
-}
-
-PyObject* KX_PolyProxy::py_getattro_dict() {
-       py_getattro_dict_up(SCA_IObject);
-}
-
 KX_PolyProxy::KX_PolyProxy(const RAS_MeshObject*mesh, RAS_Polygon* polygon)
 :      m_polygon(polygon),
        m_mesh((RAS_MeshObject*)mesh)
@@ -186,13 +102,81 @@ CValue*           KX_PolyProxy::CalcFinal(VALUE_DATA_TYPE, VALUE_OPERATOR, CValue *) { re
 STR_String     sPolyName="polygone";
 const STR_String &     KX_PolyProxy::GetText() {return sPolyName;};
 double         KX_PolyProxy::GetNumber() { return -1;}
-STR_String     KX_PolyProxy::GetName() { return sPolyName;}
-void           KX_PolyProxy::SetName(STR_String) { };
+STR_String&    KX_PolyProxy::GetName() { return sPolyName;}
+void           KX_PolyProxy::SetName(const char *) { };
 CValue*                KX_PolyProxy::GetReplica() { return NULL;}
 
 // stuff for python integration
 
-KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, getMaterialIndex, 
+PyObject* KX_PolyProxy::pyattr_get_material_name(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_PolyProxy* self= static_cast<KX_PolyProxy*>(self_v);
+       return self->PygetMaterialName();
+}
+
+PyObject* KX_PolyProxy::pyattr_get_texture_name(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_PolyProxy* self= static_cast<KX_PolyProxy*>(self_v);
+       return self->PygetTextureName();
+}
+
+PyObject* KX_PolyProxy::pyattr_get_material(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_PolyProxy* self= static_cast<KX_PolyProxy*>(self_v);
+       return self->PygetMaterial();
+}
+
+PyObject* KX_PolyProxy::pyattr_get_material_id(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_PolyProxy* self= static_cast<KX_PolyProxy*>(self_v);
+       return self->PygetMaterialIndex();
+}
+
+PyObject* KX_PolyProxy::pyattr_get_v1(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_PolyProxy* self= static_cast<KX_PolyProxy*>(self_v);
+
+       return PyLong_FromSsize_t(self->m_polygon->GetVertexOffsetAbs(self->m_mesh, 0));
+}
+
+PyObject* KX_PolyProxy::pyattr_get_v2(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_PolyProxy* self= static_cast<KX_PolyProxy*>(self_v);
+
+       return PyLong_FromSsize_t(self->m_polygon->GetVertexOffsetAbs(self->m_mesh, 1));
+}
+
+PyObject* KX_PolyProxy::pyattr_get_v3(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_PolyProxy* self= static_cast<KX_PolyProxy*>(self_v);
+
+       return PyLong_FromSsize_t(self->m_polygon->GetVertexOffsetAbs(self->m_mesh, 2));
+}
+
+PyObject* KX_PolyProxy::pyattr_get_v4(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_PolyProxy* self= static_cast<KX_PolyProxy*>(self_v);
+
+       if (3 < self->m_polygon->VertexCount())
+       {
+               return PyLong_FromSsize_t(self->m_polygon->GetVertexOffsetAbs(self->m_mesh, 3));
+       }
+       return PyLong_FromSsize_t(0);
+}
+
+PyObject* KX_PolyProxy::pyattr_get_visible(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_PolyProxy* self= static_cast<KX_PolyProxy*>(self_v);
+       return self->PyisVisible();
+}
+
+PyObject* KX_PolyProxy::pyattr_get_collide(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_PolyProxy* self= static_cast<KX_PolyProxy*>(self_v);
+       return self->PyisCollider();
+}
+
+KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, getMaterialIndex,
 "getMaterialIndex() : return the material index of the polygon in the mesh\n")
 {
        RAS_MaterialBucket* polyBucket = m_polygon->GetMaterial();
@@ -204,37 +188,37 @@ KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, getMaterialIndex,
                        // found it
                        break;
        }
-       return PyInt_FromLong(matid);
+       return PyLong_FromSsize_t(matid);
 }
 
 KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, getNumVertex,
 "getNumVertex() : returns the number of vertex of the polygon, 3 or 4\n")
 {
-       return PyInt_FromLong(m_polygon->VertexCount());
+       return PyLong_FromSsize_t(m_polygon->VertexCount());
 }
 
 KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, isVisible,
 "isVisible() : returns whether the polygon is visible or not\n")
 {
-       return PyInt_FromLong(m_polygon->IsVisible());
+       return PyLong_FromSsize_t(m_polygon->IsVisible());
 }
 
 KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, isCollider,
 "isCollider() : returns whether the polygon is receives collision or not\n")
 {
-       return PyInt_FromLong(m_polygon->IsCollider());
+       return PyLong_FromSsize_t(m_polygon->IsCollider());
 }
 
 KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, getMaterialName,
 "getMaterialName() : returns the polygon material name, \"NoMaterial\" if no material\n")
 {
-       return PyString_FromString(m_polygon->GetMaterial()->GetPolyMaterial()->GetMaterialName());
+       return PyUnicode_FromString(m_polygon->GetMaterial()->GetPolyMaterial()->GetMaterialName());
 }
 
 KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, getTextureName,
 "getTexturelName() : returns the polygon texture name, \"NULL\" if no texture\n")
 {
-       return PyString_FromString(m_polygon->GetMaterial()->GetPolyMaterial()->GetTextureName());
+       return PyUnicode_FromString(m_polygon->GetMaterial()->GetPolyMaterial()->GetTextureName());
 }
 
 KX_PYMETHODDEF_DOC(KX_PolyProxy, getVertexIndex,
@@ -255,9 +239,9 @@ KX_PYMETHODDEF_DOC(KX_PolyProxy, getVertexIndex,
        }
        if (index < m_polygon->VertexCount())
        {
-               return PyInt_FromLong(m_polygon->GetVertexOffset(index));
+               return PyLong_FromSsize_t(m_polygon->GetVertexOffsetAbs(m_mesh, index));
        }
-       return PyInt_FromLong(0);
+       return PyLong_FromSsize_t(0);
 }
 
 KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, getMesh,
@@ -282,3 +266,5 @@ KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, getMaterial,
                return mat->GetProxy();
        }
 }
+
+#endif // WITH_PYTHON