Blender Py API: Implemented missing KX_PYATTRIBUTE_TODOs and -DUMMYs.
authorJoerg Mueller <nexyon@gmail.com>
Wed, 11 Aug 2010 10:36:16 +0000 (10:36 +0000)
committerJoerg Mueller <nexyon@gmail.com>
Wed, 11 Aug 2010 10:36:16 +0000 (10:36 +0000)
12 files changed:
source/gameengine/Expressions/PyObjectPlus.h
source/gameengine/GameLogic/SCA_ISensor.cpp
source/gameengine/GameLogic/SCA_ISensor.h
source/gameengine/GameLogic/SCA_JoystickSensor.cpp
source/gameengine/Ketsji/KX_BlenderMaterial.cpp
source/gameengine/Ketsji/KX_BlenderMaterial.h
source/gameengine/Ketsji/KX_ConstraintWrapper.cpp
source/gameengine/Ketsji/KX_ConstraintWrapper.h
source/gameengine/Ketsji/KX_PolyProxy.cpp
source/gameengine/Ketsji/KX_PolyProxy.h
source/gameengine/Ketsji/KX_VertexProxy.cpp
source/gameengine/Ketsji/KX_VertexProxy.h

index 7afa85c..625549a 100644 (file)
@@ -319,9 +319,6 @@ typedef struct KX_PYATTRIBUTE_DEF {
        } m_typeCheck;
 } PyAttributeDef;
 
-#define KX_PYATTRIBUTE_DUMMY(name) \
-       { name, KX_PYATTRIBUTE_TYPE_DUMMY, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, false, 0, 0, 1, NULL, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL, NULL} }
-
 #define KX_PYATTRIBUTE_BOOL_RW(name,object,field) \
        { name, KX_PYATTRIBUTE_TYPE_BOOL, KX_PYATTRIBUTE_RW, 0, 1, 0.f, 0.f, false, false, offsetof(object,field), 0, 1, NULL, NULL, NULL, {&((object *)0)->field, NULL, NULL, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_BOOL_RW_CHECK(name,object,field,function) \
index bff0232..fada698 100644 (file)
@@ -357,9 +357,8 @@ PyAttributeDef SCA_ISensor::Attributes[] = {
        KX_PYATTRIBUTE_RO_FUNCTION("triggered", SCA_ISensor, pyattr_get_triggered),
        KX_PYATTRIBUTE_RO_FUNCTION("positive", SCA_ISensor, pyattr_get_positive),
        KX_PYATTRIBUTE_RO_FUNCTION("status", SCA_ISensor, pyattr_get_status),
-       //KX_PYATTRIBUTE_TODO("links"),
-       //KX_PYATTRIBUTE_TODO("posTicks"),
-       //KX_PYATTRIBUTE_TODO("negTicks"),
+       KX_PYATTRIBUTE_RO_FUNCTION("pos_ticks", SCA_ISensor, pyattr_get_posTicks),
+       KX_PYATTRIBUTE_RO_FUNCTION("neg_ticks", SCA_ISensor, pyattr_get_negTicks),
        { NULL }        //Sentinel
 };
 
@@ -401,6 +400,18 @@ PyObject* SCA_ISensor::pyattr_get_status(void *self_v, const KX_PYATTRIBUTE_DEF
        return PyLong_FromSsize_t(status);
 }
 
+PyObject* SCA_ISensor::pyattr_get_posTicks(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       SCA_ISensor* self= static_cast<SCA_ISensor*>(self_v);
+       return PyLong_FromLong(self->GetPosTicks());
+}
+
+PyObject* SCA_ISensor::pyattr_get_negTicks(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       SCA_ISensor* self= static_cast<SCA_ISensor*>(self_v);
+       return PyLong_FromLong(self->GetNegTicks());
+}
+
 int SCA_ISensor::pyattr_check_level(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 {
        SCA_ISensor* self= static_cast<SCA_ISensor*>(self_v);
index 42d06d8..2d3a3ef 100644 (file)
@@ -167,6 +167,18 @@ public:
                return m_prev_state;
        }
 
+       /** get the number of ticks since the last positive pulse */
+       int GetPosTicks()
+       {
+               return m_pos_ticks;
+       }
+
+       /** get the number of ticks since the last negative pulse */
+       int GetNegTicks()
+       {
+               return m_neg_ticks;
+       }
+
        /** Resume sensing. */
        void Resume();
 
@@ -185,6 +197,9 @@ public:
        static PyObject*        pyattr_get_triggered(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static PyObject*        pyattr_get_positive(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static PyObject*        pyattr_get_status(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject*        pyattr_get_posTicks(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject*        pyattr_get_negTicks(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+
        static int          pyattr_check_level(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        static int          pyattr_check_tap(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
        
index 5ab42ae..29a6a73 100644 (file)
@@ -290,7 +290,6 @@ PyAttributeDef SCA_JoystickSensor::Attributes[] = {
        KX_PYATTRIBUTE_RO_FUNCTION("numButtons",        SCA_JoystickSensor, pyattr_get_num_buttons),
        KX_PYATTRIBUTE_RO_FUNCTION("numHats",           SCA_JoystickSensor, pyattr_get_num_hats),
        KX_PYATTRIBUTE_RO_FUNCTION("connected",         SCA_JoystickSensor, pyattr_get_connected),
-       //KX_PYATTRIBUTE_TODO("events"),
        { NULL }        //Sentinel
 };
 
index 2ef7e55..f5f52a3 100644 (file)
@@ -794,9 +794,9 @@ PyMethodDef KX_BlenderMaterial::Methods[] =
 };
 
 PyAttributeDef KX_BlenderMaterial::Attributes[] = {
-       //KX_PYATTRIBUTE_TODO("shader"),
-       //KX_PYATTRIBUTE_TODO("materialIndex"),
-       //KX_PYATTRIBUTE_TODO("blending"),
+       KX_PYATTRIBUTE_RO_FUNCTION("shader", KX_BlenderMaterial, pyattr_get_shader),
+       KX_PYATTRIBUTE_RO_FUNCTION("material_index", KX_BlenderMaterial, pyattr_get_materialIndex),
+       KX_PYATTRIBUTE_RW_FUNCTION("blending", KX_BlenderMaterial, pyattr_get_blending, pyattr_set_blending),
        { NULL }        //Sentinel
 };
 
@@ -822,6 +822,37 @@ PyTypeObject KX_BlenderMaterial::Type = {
        py_base_new
 };
 
+PyObject* KX_BlenderMaterial::pyattr_get_shader(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_BlenderMaterial* self= static_cast<KX_BlenderMaterial*>(self_v);
+       return self->PygetShader(NULL, NULL);
+}
+
+PyObject* KX_BlenderMaterial::pyattr_get_materialIndex(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_BlenderMaterial* self= static_cast<KX_BlenderMaterial*>(self_v);
+       return PyLong_FromSsize_t(self->GetMaterialIndex());
+}
+
+PyObject* KX_BlenderMaterial::pyattr_get_blending(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_BlenderMaterial* self= static_cast<KX_BlenderMaterial*>(self_v);
+       unsigned int* bfunc = self->getBlendFunc();
+       return Py_BuildValue("(ll)", (long int)bfunc[0], (long int)bfunc[1]);
+}
+
+int KX_BlenderMaterial::pyattr_set_blending(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_BlenderMaterial* self= static_cast<KX_BlenderMaterial*>(self_v);
+       PyObject* obj = self->PysetBlending(value, NULL);
+       if(obj)
+       {
+               Py_DECREF(obj);
+               return 0;
+       }
+       return -1;
+}
+
 KX_PYMETHODDEF_DOC( KX_BlenderMaterial, getShader , "getShader()")
 {
        if( !GLEW_ARB_fragment_shader) {
index 5bf62ff..239e334 100644 (file)
@@ -79,6 +79,9 @@ public:
        Image * getImage (unsigned int idx) { 
                return (idx < MAXTEX && mMaterial) ? mMaterial->img[idx] : NULL; 
        }
+       unsigned int* getBlendFunc() {
+               return mBlendFunc;
+       }
        // for ipos
        void UpdateIPO(
                MT_Vector4 rgba, MT_Vector3 specrgb,
@@ -99,6 +102,11 @@ public:
        // --------------------------------
        virtual PyObject* py_repr(void) { return PyUnicode_FromString(mMaterial->matname.ReadPtr()); }
 
+       static PyObject* pyattr_get_shader(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_materialIndex(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_blending(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static int       pyattr_set_blending(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+
        KX_PYMETHOD_DOC( KX_BlenderMaterial, getShader );
        KX_PYMETHOD_DOC( KX_BlenderMaterial, getMaterialIndex );
        KX_PYMETHOD_DOC( KX_BlenderMaterial, getTexture );
index 8af6e63..b1baa5f 100644 (file)
@@ -110,8 +110,14 @@ PyMethodDef KX_ConstraintWrapper::Methods[] = {
 };
 
 PyAttributeDef KX_ConstraintWrapper::Attributes[] = {
-       //KX_PYATTRIBUTE_TODO("constraintId"),
+       KX_PYATTRIBUTE_RO_FUNCTION("constraint_id", KX_ConstraintWrapper, pyattr_get_constraintId),
        { NULL }        //Sentinel
 };
 
+PyObject* KX_ConstraintWrapper::pyattr_get_constraintId(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_ConstraintWrapper* self= static_cast<KX_ConstraintWrapper*>(self_v);
+       return self->PyGetConstraintId();
+}
+
 #endif // DISABLE_PYTHON
index 530ecf1..db9543c 100644 (file)
@@ -44,6 +44,8 @@ public:
        KX_PYMETHOD_NOARGS(KX_ConstraintWrapper,GetConstraintId);
        KX_PYMETHOD(KX_ConstraintWrapper,SetParam);
        KX_PYMETHOD(KX_ConstraintWrapper,GetParam);
+
+       static PyObject* pyattr_get_constraintId(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
 #endif
 
 private:
index 837c79c..9395e57 100644 (file)
@@ -72,90 +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
 };
 
-#if 0
-PyObject* KX_PolyProxy::py_getattro(PyObject *attr)
-{
-       char *attr_str= _PyUnicode_AsString(attr);
-       if (!strcmp(attr_str, "matname"))
-       {
-               return PyUnicode_FromString(m_polygon->GetMaterial()->GetPolyMaterial()->GetMaterialName());
-       }
-       if (!strcmp(attr_str, "texture"))
-       {
-               return PyUnicode_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 PyLong_FromSsize_t(matid);
-       }
-       if (!strcmp(attr_str, "v1"))
-       {
-               return PyLong_FromSsize_t(m_polygon->GetVertexOffsetAbs(m_mesh, 0));
-       }
-       if (!strcmp(attr_str, "v2"))
-       {
-               return PyLong_FromSsize_t(m_polygon->GetVertexOffsetAbs(m_mesh, 1));
-       }
-       if (!strcmp(attr_str, "v3"))
-       {
-               return PyLong_FromSsize_t(m_polygon->GetVertexOffsetAbs(m_mesh, 2));
-       }
-       if (!strcmp(attr_str, "v4"))
-       {
-               return PyLong_FromSsize_t(((m_polygon->VertexCount()>3)?m_polygon->GetVertexOffsetAbs(m_mesh, 3):0));
-       }
-       if (!strcmp(attr_str, "visible"))
-       {
-               return PyLong_FromSsize_t(m_polygon->IsVisible());
-       }
-       if (!strcmp(attr_str, "collide"))
-       {
-               return PyLong_FromSsize_t(m_polygon->IsCollider());
-       }
-       // py_getattro_up(CValue); // XXX -- todo, make all these attributes
-}
-#endif
-
 KX_PolyProxy::KX_PolyProxy(const RAS_MeshObject*mesh, RAS_Polygon* polygon)
 :      m_polygon(polygon),
        m_mesh((RAS_MeshObject*)mesh)
@@ -179,7 +108,75 @@ 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();
index 97d89b3..3e66963 100644 (file)
@@ -54,6 +54,16 @@ public:
 
 
 // stuff for python integration
+       static PyObject* pyattr_get_material_name(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_texture_name(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_material(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_material_id(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_v1(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_v2(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_v3(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_v4(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_visible(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_collide(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
 
        KX_PYMETHOD_DOC_NOARGS(KX_PolyProxy,getMaterialIndex)
        KX_PYMETHOD_DOC_NOARGS(KX_PolyProxy,getNumVertex)
index 652bf5e..09630ad 100644 (file)
@@ -73,247 +73,359 @@ PyMethodDef KX_VertexProxy::Methods[] = {
 };
 
 PyAttributeDef KX_VertexProxy::Attributes[] = {
-       //KX_PYATTRIBUTE_TODO("DummyProps"),
+       KX_PYATTRIBUTE_RW_FUNCTION("x", KX_VertexProxy, pyattr_get_x, pyattr_set_x),
+       KX_PYATTRIBUTE_RW_FUNCTION("y", KX_VertexProxy, pyattr_get_y, pyattr_set_y),
+       KX_PYATTRIBUTE_RW_FUNCTION("z", KX_VertexProxy, pyattr_get_z, pyattr_set_z),
 
-       KX_PYATTRIBUTE_DUMMY("x"),
-       KX_PYATTRIBUTE_DUMMY("y"),
-       KX_PYATTRIBUTE_DUMMY("z"),
+       KX_PYATTRIBUTE_RW_FUNCTION("r", KX_VertexProxy, pyattr_get_r, pyattr_set_r),
+       KX_PYATTRIBUTE_RW_FUNCTION("g", KX_VertexProxy, pyattr_get_g, pyattr_set_g),
+       KX_PYATTRIBUTE_RW_FUNCTION("b", KX_VertexProxy, pyattr_get_b, pyattr_set_b),
+       KX_PYATTRIBUTE_RW_FUNCTION("a", KX_VertexProxy, pyattr_get_a, pyattr_set_a),
 
-       KX_PYATTRIBUTE_DUMMY("r"),
-       KX_PYATTRIBUTE_DUMMY("g"),
-       KX_PYATTRIBUTE_DUMMY("b"),
-       KX_PYATTRIBUTE_DUMMY("a"),
+       KX_PYATTRIBUTE_RW_FUNCTION("u", KX_VertexProxy, pyattr_get_u, pyattr_set_u),
+       KX_PYATTRIBUTE_RW_FUNCTION("v", KX_VertexProxy, pyattr_get_v, pyattr_set_v),
 
-       KX_PYATTRIBUTE_DUMMY("u"),
-       KX_PYATTRIBUTE_DUMMY("v"),
+       KX_PYATTRIBUTE_RW_FUNCTION("u2", KX_VertexProxy, pyattr_get_u2, pyattr_set_u2),
+       KX_PYATTRIBUTE_RW_FUNCTION("v2", KX_VertexProxy, pyattr_get_v2, pyattr_set_v2),
 
-       KX_PYATTRIBUTE_DUMMY("u2"),
-       KX_PYATTRIBUTE_DUMMY("v2"),
+       KX_PYATTRIBUTE_RW_FUNCTION("XYZ", KX_VertexProxy, pyattr_get_XYZ, pyattr_set_XYZ),
+       KX_PYATTRIBUTE_RW_FUNCTION("UV", KX_VertexProxy, pyattr_get_UV, pyattr_set_UV),
 
-       KX_PYATTRIBUTE_DUMMY("XYZ"),
-       KX_PYATTRIBUTE_DUMMY("UV"),
-
-       KX_PYATTRIBUTE_DUMMY("color"),
-       KX_PYATTRIBUTE_DUMMY("colour"),
-
-       KX_PYATTRIBUTE_DUMMY("normal"),
+       KX_PYATTRIBUTE_RW_FUNCTION("color", KX_VertexProxy, pyattr_get_color, pyattr_set_color),
+       KX_PYATTRIBUTE_RW_FUNCTION("normal", KX_VertexProxy, pyattr_get_normal, pyattr_set_normal),
 
        { NULL }        //Sentinel
 };
 
-#if 0
-PyObject*
-KX_VertexProxy::py_getattro(PyObject *attr)
-{
-  char *attr_str= _PyUnicode_AsString(attr);
-  if (attr_str[1]=='\0') { // Group single letters
-    // pos
-    if (attr_str[0]=='x')
-       return PyFloat_FromDouble(m_vertex->getXYZ()[0]);
-    if (attr_str[0]=='y')
-       return PyFloat_FromDouble(m_vertex->getXYZ()[1]);
-    if (attr_str[0]=='z')
-       return PyFloat_FromDouble(m_vertex->getXYZ()[2]);
-
-    // Col
-    if (attr_str[0]=='r')
-       return PyFloat_FromDouble(m_vertex->getRGBA()[0]/255.0);
-    if (attr_str[0]=='g')
-       return PyFloat_FromDouble(m_vertex->getRGBA()[1]/255.0);
-    if (attr_str[0]=='b')
-       return PyFloat_FromDouble(m_vertex->getRGBA()[2]/255.0);
-    if (attr_str[0]=='a')
-       return PyFloat_FromDouble(m_vertex->getRGBA()[3]/255.0);
-
-    // UV
-    if (attr_str[0]=='u')
-       return PyFloat_FromDouble(m_vertex->getUV1()[0]);
-    if (attr_str[0]=='v')
-       return PyFloat_FromDouble(m_vertex->getUV1()[1]);
-  }
-
-
-  if (!strcmp(attr_str, "XYZ"))
-       return PyObjectFrom(MT_Vector3(m_vertex->getXYZ()));
-
-  if (!strcmp(attr_str, "UV"))
-       return PyObjectFrom(MT_Point2(m_vertex->getUV1()));
-
-  if (!strcmp(attr_str, "color") || !strcmp(attr_str, "colour"))
-  {
-       const unsigned char *colp = m_vertex->getRGBA();
-       MT_Vector4 color(colp[0], colp[1], colp[2], colp[3]);
-       color /= 255.0;
-       return PyObjectFrom(color);
-  }
+PyObject* KX_VertexProxy::pyattr_get_x(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       return PyFloat_FromDouble(self->m_vertex->getXYZ()[0]);
+}
 
-  if (!strcmp(attr_str, "normal"))
-  {
-       return PyObjectFrom(MT_Vector3(m_vertex->getNormal()));
-  }
+PyObject* KX_VertexProxy::pyattr_get_y(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       return PyFloat_FromDouble(self->m_vertex->getXYZ()[1]);
+}
 
-  py_getattro_up(CValue);
+PyObject* KX_VertexProxy::pyattr_get_z(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       return PyFloat_FromDouble(self->m_vertex->getXYZ()[2]);
 }
-#endif
 
+PyObject* KX_VertexProxy::pyattr_get_r(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       return PyFloat_FromDouble(self->m_vertex->getRGBA()[0]/255.0);
+}
 
-#if 0
-int    KX_VertexProxy::py_setattro(PyObject *attr, PyObject *pyvalue)
+PyObject* KX_VertexProxy::pyattr_get_g(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 {
-  char *attr_str= _PyUnicode_AsString(attr);
-  if (PySequence_Check(pyvalue))
-  {
-       if (!strcmp(attr_str, "XYZ"))
-       {
-               MT_Point3 vec;
-               if (PyVecTo(pyvalue, vec))
-               {
-                       m_vertex->SetXYZ(vec);
-                       m_mesh->SetMeshModified(true);
-                       return PY_SET_ATTR_SUCCESS;
-               }
-               return PY_SET_ATTR_FAIL;
-       }
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       return PyFloat_FromDouble(self->m_vertex->getRGBA()[1]/255.0);
+}
 
-       if (!strcmp(attr_str, "UV"))
-       {
-               MT_Point2 vec;
-               if (PyVecTo(pyvalue, vec))
-               {
-                       m_vertex->SetUV(vec);
-                       m_mesh->SetMeshModified(true);
-                       return PY_SET_ATTR_SUCCESS;
-               }
-               return PY_SET_ATTR_FAIL;
-       }
+PyObject* KX_VertexProxy::pyattr_get_b(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       return PyFloat_FromDouble(self->m_vertex->getRGBA()[2]/255.0);
+}
 
-       if (!strcmp(attr_str, "color") || !strcmp(attr_str, "colour"))
-       {
-               MT_Vector4 vec;
-               if (PyVecTo(pyvalue, vec))
-               {
-                       m_vertex->SetRGBA(vec);
-                       m_mesh->SetMeshModified(true);
-                       return PY_SET_ATTR_SUCCESS;
-               }
-               return PY_SET_ATTR_FAIL;
-       }
+PyObject* KX_VertexProxy::pyattr_get_a(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       return PyFloat_FromDouble(self->m_vertex->getRGBA()[3]/255.0);
+}
 
-       if (!strcmp(attr_str, "normal"))
-       {
-               MT_Vector3 vec;
-               if (PyVecTo(pyvalue, vec))
-               {
-                       m_vertex->SetNormal(vec);
-                       m_mesh->SetMeshModified(true);
-                       return PY_SET_ATTR_SUCCESS;
-               }
-               return PY_SET_ATTR_FAIL;
-       }
-  }
-
-  if (PyFloat_Check(pyvalue))
-  {
-       float val = PyFloat_AsDouble(pyvalue);
-       // pos
-       MT_Point3 pos(m_vertex->getXYZ());
-       if (!strcmp(attr_str, "x"))
+PyObject* KX_VertexProxy::pyattr_get_u(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       return PyFloat_FromDouble(self->m_vertex->getUV1()[0]);
+}
+
+PyObject* KX_VertexProxy::pyattr_get_v(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       return PyFloat_FromDouble(self->m_vertex->getUV1()[1]);
+}
+
+PyObject* KX_VertexProxy::pyattr_get_u2(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       return PyFloat_FromDouble(self->m_vertex->getUV2()[0]);
+}
+
+PyObject* KX_VertexProxy::pyattr_get_v2(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       return PyFloat_FromDouble(self->m_vertex->getUV2()[1]);
+}
+
+PyObject* KX_VertexProxy::pyattr_get_XYZ(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       return PyObjectFrom(MT_Vector3(self->m_vertex->getXYZ()));
+}
+
+PyObject* KX_VertexProxy::pyattr_get_UV(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       return PyObjectFrom(MT_Point2(self->m_vertex->getUV1()));
+}
+
+PyObject* KX_VertexProxy::pyattr_get_color(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       const unsigned char *colp = self->m_vertex->getRGBA();
+       MT_Vector4 color(colp[0], colp[1], colp[2], colp[3]);
+       color /= 255.0;
+       return PyObjectFrom(color);
+}
+
+PyObject* KX_VertexProxy::pyattr_get_normal(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       return PyObjectFrom(MT_Vector3(self->m_vertex->getNormal()));
+}
+
+int KX_VertexProxy::pyattr_set_x(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       if (PyFloat_Check(value))
        {
+               float val = PyFloat_AsDouble(value);
+               MT_Point3 pos(self->m_vertex->getXYZ());
                pos.x() = val;
-               m_vertex->SetXYZ(pos);
-               m_mesh->SetMeshModified(true);
+               self->m_vertex->SetXYZ(pos);
+               self->m_mesh->SetMeshModified(true);
                return PY_SET_ATTR_SUCCESS;
        }
+       return PY_SET_ATTR_FAIL;
+}
 
-       if (!strcmp(attr_str, "y"))
+int KX_VertexProxy::pyattr_set_y(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       if (PyFloat_Check(value))
        {
+               float val = PyFloat_AsDouble(value);
+               MT_Point3 pos(self->m_vertex->getXYZ());
                pos.y() = val;
-               m_vertex->SetXYZ(pos);
-               m_mesh->SetMeshModified(true);
+               self->m_vertex->SetXYZ(pos);
+               self->m_mesh->SetMeshModified(true);
                return PY_SET_ATTR_SUCCESS;
        }
+       return PY_SET_ATTR_FAIL;
+}
 
-       if (!strcmp(attr_str, "z"))
+int KX_VertexProxy::pyattr_set_z(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       if (PyFloat_Check(value))
        {
+               float val = PyFloat_AsDouble(value);
+               MT_Point3 pos(self->m_vertex->getXYZ());
                pos.z() = val;
-               m_vertex->SetXYZ(pos);
-               m_mesh->SetMeshModified(true);
+               self->m_vertex->SetXYZ(pos);
+               self->m_mesh->SetMeshModified(true);
                return PY_SET_ATTR_SUCCESS;
        }
+       return PY_SET_ATTR_FAIL;
+}
 
-       // uv
-       MT_Point2 uv = m_vertex->getUV1();
-       if (!strcmp(attr_str, "u"))
+int KX_VertexProxy::pyattr_set_u(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       if (PyFloat_Check(value))
        {
+               float val = PyFloat_AsDouble(value);
+               MT_Point2 uv = self->m_vertex->getUV1();
                uv[0] = val;
-               m_vertex->SetUV(uv);
-               m_mesh->SetMeshModified(true);
+               self->m_vertex->SetUV(uv);
+               self->m_mesh->SetMeshModified(true);
                return PY_SET_ATTR_SUCCESS;
        }
+       return PY_SET_ATTR_FAIL;
+}
 
-       if (!strcmp(attr_str, "v"))
+int KX_VertexProxy::pyattr_set_v(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       if (PyFloat_Check(value))
        {
+               float val = PyFloat_AsDouble(value);
+               MT_Point2 uv = self->m_vertex->getUV1();
                uv[1] = val;
-               m_vertex->SetUV(uv);
-               m_mesh->SetMeshModified(true);
+               self->m_vertex->SetUV(uv);
+               self->m_mesh->SetMeshModified(true);
                return PY_SET_ATTR_SUCCESS;
        }
+       return PY_SET_ATTR_FAIL;
+}
 
-       // uv
-       MT_Point2 uv2 = m_vertex->getUV2();
-       if (!strcmp(attr_str, "u2"))
+int KX_VertexProxy::pyattr_set_u2(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       if (PyFloat_Check(value))
        {
+               float val = PyFloat_AsDouble(value);
+               MT_Point2 uv = self->m_vertex->getUV2();
                uv[0] = val;
-               m_vertex->SetUV2(uv);
-               m_mesh->SetMeshModified(true);
-               return 0;
+               self->m_vertex->SetUV2(uv);
+               self->m_mesh->SetMeshModified(true);
+               return PY_SET_ATTR_SUCCESS;
        }
+       return PY_SET_ATTR_FAIL;
+}
 
-       if (!strcmp(attr_str, "v2"))
+int KX_VertexProxy::pyattr_set_v2(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       if (PyFloat_Check(value))
        {
+               float val = PyFloat_AsDouble(value);
+               MT_Point2 uv = self->m_vertex->getUV2();
                uv[1] = val;
-               m_vertex->SetUV2(uv);
-               m_mesh->SetMeshModified(true);
+               self->m_vertex->SetUV2(uv);
+               self->m_mesh->SetMeshModified(true);
                return PY_SET_ATTR_SUCCESS;
        }
+       return PY_SET_ATTR_FAIL;
+}
 
-       // col
-       unsigned int icol = *((const unsigned int *)m_vertex->getRGBA());
-       unsigned char *cp = (unsigned char*) &icol;
-       val *= 255.0;
-       if (!strcmp(attr_str, "r"))
+int KX_VertexProxy::pyattr_set_r(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       if (PyFloat_Check(value))
        {
+               float val = PyFloat_AsDouble(value);
+               unsigned int icol = *((const unsigned int *)self->m_vertex->getRGBA());
+               unsigned char *cp = (unsigned char*) &icol;
+               val *= 255.0;
                cp[0] = (unsigned char) val;
-               m_vertex->SetRGBA(icol);
-               m_mesh->SetMeshModified(true);
+               self->m_vertex->SetRGBA(icol);
+               self->m_mesh->SetMeshModified(true);
                return PY_SET_ATTR_SUCCESS;
        }
-       if (!strcmp(attr_str, "g"))
+       return PY_SET_ATTR_FAIL;
+}
+
+int KX_VertexProxy::pyattr_set_g(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       if (PyFloat_Check(value))
        {
+               float val = PyFloat_AsDouble(value);
+               unsigned int icol = *((const unsigned int *)self->m_vertex->getRGBA());
+               unsigned char *cp = (unsigned char*) &icol;
+               val *= 255.0;
                cp[1] = (unsigned char) val;
-               m_vertex->SetRGBA(icol);
-               m_mesh->SetMeshModified(true);
+               self->m_vertex->SetRGBA(icol);
+               self->m_mesh->SetMeshModified(true);
                return PY_SET_ATTR_SUCCESS;
        }
-       if (!strcmp(attr_str, "b"))
+       return PY_SET_ATTR_FAIL;
+}
+
+int KX_VertexProxy::pyattr_set_b(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       if (PyFloat_Check(value))
        {
+               float val = PyFloat_AsDouble(value);
+               unsigned int icol = *((const unsigned int *)self->m_vertex->getRGBA());
+               unsigned char *cp = (unsigned char*) &icol;
+               val *= 255.0;
                cp[2] = (unsigned char) val;
-               m_vertex->SetRGBA(icol);
-               m_mesh->SetMeshModified(true);
+               self->m_vertex->SetRGBA(icol);
+               self->m_mesh->SetMeshModified(true);
                return PY_SET_ATTR_SUCCESS;
        }
-       if (!strcmp(attr_str, "a"))
+       return PY_SET_ATTR_FAIL;
+}
+
+int KX_VertexProxy::pyattr_set_a(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       if (PyFloat_Check(value))
        {
+               float val = PyFloat_AsDouble(value);
+               unsigned int icol = *((const unsigned int *)self->m_vertex->getRGBA());
+               unsigned char *cp = (unsigned char*) &icol;
+               val *= 255.0;
                cp[3] = (unsigned char) val;
-               m_vertex->SetRGBA(icol);
-               m_mesh->SetMeshModified(true);
+               self->m_vertex->SetRGBA(icol);
+               self->m_mesh->SetMeshModified(true);
                return PY_SET_ATTR_SUCCESS;
        }
-  }
+       return PY_SET_ATTR_FAIL;
+}
 
-  return CValue::py_setattro(attr, pyvalue);
+int KX_VertexProxy::pyattr_set_XYZ(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       if (PySequence_Check(value))
+       {
+               MT_Point3 vec;
+               if (PyVecTo(value, vec))
+               {
+                       self->m_vertex->SetXYZ(vec);
+                       self->m_mesh->SetMeshModified(true);
+                       return PY_SET_ATTR_SUCCESS;
+               }
+       }
+       return PY_SET_ATTR_FAIL;
+}
+
+int KX_VertexProxy::pyattr_set_UV(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       if (PySequence_Check(value))
+       {
+               MT_Point2 vec;
+               if (PyVecTo(value, vec))
+               {
+                       self->m_vertex->SetUV(vec);
+                       self->m_mesh->SetMeshModified(true);
+                       return PY_SET_ATTR_SUCCESS;
+               }
+       }
+       return PY_SET_ATTR_FAIL;
+}
+
+int KX_VertexProxy::pyattr_set_color(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       if (PySequence_Check(value))
+       {
+               MT_Vector4 vec;
+               if (PyVecTo(value, vec))
+               {
+                       self->m_vertex->SetRGBA(vec);
+                       self->m_mesh->SetMeshModified(true);
+                       return PY_SET_ATTR_SUCCESS;
+               }
+       }
+       return PY_SET_ATTR_FAIL;
+}
+
+int KX_VertexProxy::pyattr_set_normal(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_VertexProxy* self= static_cast<KX_VertexProxy*>(self_v);
+       if (PySequence_Check(value))
+       {
+               MT_Vector3 vec;
+               if (PyVecTo(value, vec))
+               {
+                       self->m_vertex->SetNormal(vec);
+                       self->m_mesh->SetMeshModified(true);
+                       return PY_SET_ATTR_SUCCESS;
+               }
+       }
+       return PY_SET_ATTR_FAIL;
 }
-#endif
 
 KX_VertexProxy::KX_VertexProxy(KX_MeshProxy*mesh, RAS_TexVert* vertex)
 :      m_vertex(vertex),
index 08fe0e7..b39d3ec 100644 (file)
@@ -56,6 +56,37 @@ public:
 
 // stuff for python integration
 
+       static PyObject* pyattr_get_x(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_y(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_z(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_r(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_g(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_b(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_a(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_u(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_v(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_u2(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_v2(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_XYZ(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_UV(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_color(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static PyObject* pyattr_get_normal(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+       static int pyattr_set_x(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+       static int pyattr_set_y(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+       static int pyattr_set_z(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+       static int pyattr_set_u(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+       static int pyattr_set_v(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+       static int pyattr_set_u2(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+       static int pyattr_set_v2(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+       static int pyattr_set_r(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+       static int pyattr_set_g(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+       static int pyattr_set_b(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+       static int pyattr_set_a(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+       static int pyattr_set_XYZ(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+       static int pyattr_set_UV(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+       static int pyattr_set_color(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+       static int pyattr_set_normal(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+
        KX_PYMETHOD_NOARGS(KX_VertexProxy,GetXYZ);
        KX_PYMETHOD_O(KX_VertexProxy,SetXYZ);
        KX_PYMETHOD_NOARGS(KX_VertexProxy,GetUV);