doxygen: prevent GPL license block from being parsed as doxygen comment.
[blender.git] / source / gameengine / Ketsji / KX_PolyProxy.cpp
index b4bdd77..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 = {
-       PyObject_HEAD_INIT(&PyType_Type)
-       0,
+       PyVarObject_HEAD_INIT(NULL, 0)
        "KX_PolyProxy",
-       sizeof(KX_PolyProxy),
+       sizeof(PyObjectPlus_Proxy),
        0,
-       PyDestructor,
+       py_base_dealloc,
        0,
-       __getattr,
-       __setattr,
-       0, //&MyPyCompare,
-       __repr,
-       0, //&cvalue_as_number,
        0,
        0,
        0,
-       0
-};
-
-PyParentObject KX_PolyProxy::Parents[] = {
-       &KX_PolyProxy::Type,
-       &SCA_IObject::Type,
+       py_base_repr,
+       0,0,0,0,0,0,0,0,0,
+       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[] = {
@@ -78,77 +72,19 @@ PyMethodDef KX_PolyProxy::Methods[] = {
 };
 
 PyAttributeDef KX_PolyProxy::Attributes[] = {
+       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::_getattr(const char *attr)
-{
-       if (!strcmp(attr, "matname"))
-       {
-               return PyString_FromString(m_polygon->GetMaterial()->GetPolyMaterial()->GetMaterialName());
-       }
-       if (!strcmp(attr, "texture"))
-       {
-               return PyString_FromString(m_polygon->GetMaterial()->GetPolyMaterial()->GetTextureName());
-       }
-       if (!strcmp(attr, "material"))
-       {
-               RAS_IPolyMaterial *polymat = m_polygon->GetMaterial()->GetPolyMaterial();
-               if(polymat->GetFlag() & RAS_BLENDERMAT)
-               {
-                       KX_BlenderMaterial* mat = static_cast<KX_BlenderMaterial*>(polymat);
-                       Py_INCREF(mat);
-                       return mat;
-               }
-               else
-               {
-                       KX_PolygonMaterial* mat = static_cast<KX_PolygonMaterial*>(polymat);
-                       Py_INCREF(mat);
-                       return mat;
-               }
-       }
-       if (!strcmp(attr, "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<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, "v1"))
-       {
-               return PyInt_FromLong(m_polygon->GetVertexOffset(0));
-       }
-       if (!strcmp(attr, "v2"))
-       {
-               return PyInt_FromLong(m_polygon->GetVertexOffset(1));
-       }
-       if (!strcmp(attr, "v3"))
-       {
-               return PyInt_FromLong(m_polygon->GetVertexOffset(2));
-       }
-       if (!strcmp(attr, "v4"))
-       {
-               return PyInt_FromLong(((m_polygon->VertexCount()>3)?m_polygon->GetVertexOffset(3):0));
-       }
-       if (!strcmp(attr, "visible"))
-       {
-               return PyInt_FromLong(m_polygon->IsVisible());
-       }
-       if (!strcmp(attr, "collide"))
-       {
-               return PyInt_FromLong(m_polygon->IsCollider());
-       }
-       _getattr_up(SCA_IObject);
-}
-
 KX_PolyProxy::KX_PolyProxy(const RAS_MeshObject*mesh, RAS_Polygon* polygon)
 :      m_polygon(polygon),
        m_mesh((RAS_MeshObject*)mesh)
@@ -165,58 +101,124 @@ CValue*          KX_PolyProxy::Calc(VALUE_OPERATOR, CValue *) { return NULL;}
 CValue*                KX_PolyProxy::CalcFinal(VALUE_DATA_TYPE, VALUE_OPERATOR, CValue *) { return NULL;}      
 STR_String     sPolyName="polygone";
 const STR_String &     KX_PolyProxy::GetText() {return sPolyName;};
-float          KX_PolyProxy::GetNumber() { return -1;}
-STR_String     KX_PolyProxy::GetName() { return sPolyName;}
-void           KX_PolyProxy::SetName(STR_String) { };
+double         KX_PolyProxy::GetNumber() { return -1;}
+STR_String&    KX_PolyProxy::GetName() { return sPolyName;}
+void           KX_PolyProxy::SetName(const char *) { };
 CValue*                KX_PolyProxy::GetReplica() { return NULL;}
-void           KX_PolyProxy::ReplicaSetName(STR_String) {};
-
 
 // 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();
        unsigned int matid;
-       for (matid=0; matid<m_mesh->NumMaterials(); 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);
+       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,
@@ -226,27 +228,27 @@ KX_PYMETHODDEF_DOC(KX_PolyProxy, getVertexIndex,
 "Note: getVertexIndex(3) on a triangle polygon returns 0\n")
 {
        int index;
-       if (!PyArg_ParseTuple(args,"i",&index))
+       if (!PyArg_ParseTuple(args,"i:getVertexIndex",&index))
        {
                return NULL;
        }
        if (index < 0 || index > 3)
        {
-               PyErr_SetString(PyExc_AttributeError, "Valid range for index is 0-3");
+               PyErr_SetString(PyExc_AttributeError, "poly.getVertexIndex(int): KX_PolyProxy, expected an index between 0-3");
                return NULL;
        }
        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,
 "getMesh() : returns a mesh proxy\n")
 {
        KX_MeshProxy* meshproxy = new KX_MeshProxy((RAS_MeshObject*)m_mesh);
-       return meshproxy;
+       return meshproxy->NewProxy(true);
 }
 
 KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, getMaterial,
@@ -256,13 +258,13 @@ KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, getMaterial,
        if(polymat->GetFlag() & RAS_BLENDERMAT)
        {
                KX_BlenderMaterial* mat = static_cast<KX_BlenderMaterial*>(polymat);
-               Py_INCREF(mat);
-               return mat;
+               return mat->GetProxy();
        }
        else
        {
                KX_PolygonMaterial* mat = static_cast<KX_PolygonMaterial*>(polymat);
-               Py_INCREF(mat);
-               return mat;
+               return mat->GetProxy();
        }
 }
+
+#endif // WITH_PYTHON