add missing files after merging
[blender.git] / source / gameengine / Ketsji / KX_PolygonMaterial.cpp
index 52c5b013e657a5b16b6cd3cdf6379354f6a5fe02..9d0597051ad1f0dca8c8613fb395cea8e500556f 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.
  *
  * ***** END GPL LICENSE BLOCK *****
  */
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
+
+/** \file gameengine/Ketsji/KX_PolygonMaterial.cpp
+ *  \ingroup ketsji
+ */
+
+
+#include <stddef.h>
 
 #include "KX_PolygonMaterial.h"
 
 
 #include "KX_PyMath.h"
 
-KX_PolygonMaterial::KX_PolygonMaterial(const STR_String &texname,
-                                                                                          Material *material,
-                                                                                          int tile,
-                                                                                          int tilexrep,
-                                                                                          int tileyrep,
-                                                                                          int mode,
-                                                                                          int transp,
-                                                                                          bool alpha,
-                                                                                          bool zsort,
-                                                                                          int lightlayer,
-                                                                                          struct MTFace* tface,
-                                                                                          unsigned int* mcol,
-                                                                                          PyTypeObject *T)
-               : PyObjectPlus(T),
-                 RAS_IPolyMaterial(texname,
-                                                       STR_String(material?material->id.name:""),
+#define KX_POLYGONMATERIAL_CAPSULE_ID "KX_POLYGONMATERIAL_PTR"
+
+KX_PolygonMaterial::KX_PolygonMaterial()
+               : PyObjectPlus(),
+                 RAS_IPolyMaterial(),
+
+       m_tface(NULL),
+       m_mcol(NULL),
+       m_material(NULL),
+#ifdef WITH_PYTHON
+       m_pymaterial(NULL),
+#endif
+       m_pass(0)
+{
+}
+
+void KX_PolygonMaterial::Initialize(
+               const STR_String &texname,
+               Material* ma,
+               int materialindex,
+               int tile,
+               int tilexrep,
+               int tileyrep,
+               int mode,
+               int transp,
+               bool alpha,
+               bool zsort,
+               int lightlayer,
+               struct MTFace* tface,
+               unsigned int* mcol)
+{
+       RAS_IPolyMaterial::Initialize(
+                                                       texname,
+                                                       ma?ma->id.name:"",
+                                                       materialindex,
                                                        tile,
                                                        tilexrep,
                                                        tileyrep,
                                                        mode,
                                                        transp,
                                                        alpha,
-                                                       zsort,
-                                                       lightlayer),
-               m_tface(tface),
-               m_mcol(mcol),
-               m_material(material),
-               m_pymaterial(0),
-               m_pass(0)
-{
+                                                       zsort);
+       m_tface = tface;
+       m_mcol = mcol;
+       m_material = ma;
+#ifdef WITH_PYTHON
+       m_pymaterial = 0;
+#endif
+       m_pass = 0;
 }
 
 KX_PolygonMaterial::~KX_PolygonMaterial()
 {
+#ifdef WITH_PYTHON
        if (m_pymaterial)
        {
                Py_DECREF(m_pymaterial);
        }
+#endif // WITH_PYTHON
+}
+
+Image *KX_PolygonMaterial::GetBlenderImage() const
+{
+       return (m_tface) ? m_tface->tpage : NULL;
 }
 
 bool KX_PolygonMaterial::Activate(RAS_IRasterizer* rasty, TCachingInfo& cachingInfo) const 
 {
        bool dopass = false;
+
+#ifdef WITH_PYTHON
        if (m_pymaterial)
        {
-               PyObject *pyRasty = PyCObject_FromVoidPtr((void*)rasty, NULL);  /* new reference */
-               PyObject *pyCachingInfo = PyCObject_FromVoidPtr((void*) &cachingInfo, NULL); /* new reference */
-               
-               PyObject *ret = PyObject_CallMethod(m_pymaterial, "activate", "(NNO)", pyRasty, pyCachingInfo, (PyObject*) this);
+               PyObject *pyRasty = PyCapsule_New((void*)rasty, KX_POLYGONMATERIAL_CAPSULE_ID, NULL);   /* new reference */
+               PyObject *pyCachingInfo = PyCapsule_New((void*) &cachingInfo, KX_POLYGONMATERIAL_CAPSULE_ID, NULL); /* new reference */
+               PyObject *ret = PyObject_CallMethod(m_pymaterial, (char *)"activate", (char *)"(NNO)", pyRasty, pyCachingInfo, (PyObject*) this->m_proxy);
                if (ret)
                {
-                       bool value = PyInt_AsLong(ret);
+                       bool value = PyLong_AsSsize_t(ret);
                        Py_DECREF(ret);
                        dopass = value;
                }
                else
                {
                        PyErr_Print();
+                       PyErr_Clear();
+                       PySys_SetObject( (char *)"last_traceback", NULL);
                }
        }
        else
+#endif // WITH_PYTHON
        {
                switch (m_pass++)
                {
@@ -134,18 +168,18 @@ void KX_PolygonMaterial::DefaultActivate(RAS_IRasterizer* rasty, TCachingInfo& c
        if (GetCachingInfo() != cachingInfo)
        {
                if (!cachingInfo)
-                       GPU_set_tpage(NULL);
+                       GPU_set_tpage(NULL, 0);
 
                cachingInfo = GetCachingInfo();
 
-               if ((m_drawingmode & 4)&& (rasty->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED))
+               if ((m_drawingmode & RAS_IRasterizer::KX_TEX)&& (rasty->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED))
                {
                        Image *ima = (Image*)m_tface->tpage;
                        GPU_update_image_time(ima, rasty->GetTime());
-                       GPU_set_tpage(m_tface);
+                       GPU_set_tpage(m_tface, 1);
                }
                else
-                       GPU_set_tpage(NULL);
+                       GPU_set_tpage(NULL, 0);
                
                if(m_drawingmode & RAS_IRasterizer::KX_TWOSIDE)
                        rasty->SetCullFace(false);
@@ -157,15 +191,33 @@ void KX_PolygonMaterial::DefaultActivate(RAS_IRasterizer* rasty, TCachingInfo& c
                        rasty->SetLines(true);
                else
                        rasty->SetLines(false);
+               rasty->SetSpecularity(m_specular[0],m_specular[1],m_specular[2],m_specularity);
+               rasty->SetShinyness(m_shininess);
+               rasty->SetDiffuse(m_diffuse[0], m_diffuse[1],m_diffuse[2], 1.0);
+               if (m_material)
+                       rasty->SetPolygonOffset(-m_material->zoffs, 0.0);
        }
 
-       rasty->SetSpecularity(m_specular[0],m_specular[1],m_specular[2],m_specularity);
-       rasty->SetShinyness(m_shininess);
-       rasty->SetDiffuse(m_diffuse[0], m_diffuse[1],m_diffuse[2], 1.0);
-       if (m_material)
-               rasty->SetPolygonOffset(-m_material->zoffs, 0.0);
+       //rasty->SetSpecularity(m_specular[0],m_specular[1],m_specular[2],m_specularity);
+       //rasty->SetShinyness(m_shininess);
+       //rasty->SetDiffuse(m_diffuse[0], m_diffuse[1],m_diffuse[2], 1.0);
+       //if (m_material)
+       //      rasty->SetPolygonOffset(-m_material->zoffs, 0.0);
+}
+
+void KX_PolygonMaterial::GetMaterialRGBAColor(unsigned char *rgba) const
+{
+       if (m_material) {
+               *rgba++ = (unsigned char) (m_material->r*255.0);
+               *rgba++ = (unsigned char) (m_material->g*255.0);
+               *rgba++ = (unsigned char) (m_material->b*255.0);
+               *rgba++ = (unsigned char) (m_material->alpha*255.0);
+       } else
+               RAS_IPolyMaterial::GetMaterialRGBAColor(rgba);
 }
 
+#ifdef WITH_PYTHON
+
 //----------------------------------------------------------------------------
 //Python
 
@@ -180,179 +232,58 @@ PyMethodDef KX_PolygonMaterial::Methods[] = {
        {NULL,NULL} //Sentinel
 };
 
+PyAttributeDef KX_PolygonMaterial::Attributes[] = {
+       KX_PYATTRIBUTE_RO_FUNCTION("texture",   KX_PolygonMaterial, pyattr_get_texture),
+       KX_PYATTRIBUTE_RO_FUNCTION("material",  KX_PolygonMaterial, pyattr_get_material), /* should probably be .name ? */
+       
+       KX_PYATTRIBUTE_INT_RW("tile", INT_MIN, INT_MAX, true, KX_PolygonMaterial, m_tile),
+       KX_PYATTRIBUTE_INT_RW("tilexrep", INT_MIN, INT_MAX, true, KX_PolygonMaterial, m_tilexrep),
+       KX_PYATTRIBUTE_INT_RW("tileyrep", INT_MIN, INT_MAX, true, KX_PolygonMaterial, m_tileyrep),
+       KX_PYATTRIBUTE_INT_RW("drawingmode", INT_MIN, INT_MAX, true, KX_PolygonMaterial, m_drawingmode),        
+       //KX_PYATTRIBUTE_INT_RW("lightlayer", INT_MIN, INT_MAX, true, KX_PolygonMaterial, m_lightlayer),
 
-PyTypeObject KX_PolygonMaterial::Type = {
-       PyObject_HEAD_INIT(&PyType_Type)
-               0,
-               "KX_PolygonMaterial",
-               sizeof(KX_PolygonMaterial),
-               0,
-               PyDestructor,
-               0,
-               __getattr,
-               __setattr,
-               0, //&MyPyCompare,
-               __repr,
-               0 //&cvalue_as_number,
-};
-
-PyParentObject KX_PolygonMaterial::Parents[] = {
-       &PyObjectPlus::Type,
-       &KX_PolygonMaterial::Type,
-       NULL
-};
-
-PyObject* KX_PolygonMaterial::_getattr(const char *attr)
-{
-       if (!strcmp(attr, "texture"))
-               return PyString_FromString(m_texturename.ReadPtr());
-       if (!strcmp(attr, "material"))
-               return PyString_FromString(m_materialname.ReadPtr());
-               
-       if (!strcmp(attr, "tface"))
-               return PyCObject_FromVoidPtr(m_tface, NULL);
-               
-       if (!strcmp(attr, "gl_texture"))
-       {
-               Image *ima = m_tface->tpage;
-               int bind = 0;
-               if (ima)
-                       bind = ima->bindcode;
-               
-               return PyInt_FromLong(bind);
-       }
+       KX_PYATTRIBUTE_BOOL_RW("transparent", KX_PolygonMaterial, m_alpha),
+       KX_PYATTRIBUTE_BOOL_RW("zsort", KX_PolygonMaterial, m_zsort),
        
-       if (!strcmp(attr, "tile"))
-               return PyInt_FromLong(m_tile);
-       if (!strcmp(attr, "tilexrep"))
-               return PyInt_FromLong(m_tilexrep);
-       if (!strcmp(attr, "tileyrep"))
-               return PyInt_FromLong(m_tileyrep);
+       KX_PYATTRIBUTE_FLOAT_RW("shininess", 0.0f, 1000.0f, KX_PolygonMaterial, m_shininess),
+       KX_PYATTRIBUTE_FLOAT_RW("specularity", 0.0f, 1000.0f, KX_PolygonMaterial, m_specularity),
        
-       if (!strcmp(attr, "drawingmode"))
-               return PyInt_FromLong(m_drawingmode);
-       if (!strcmp(attr, "transparent"))
-               return PyInt_FromLong(m_alpha);
-       if (!strcmp(attr, "zsort"))
-               return PyInt_FromLong(m_zsort);
-       if (!strcmp(attr, "lightlayer"))
-               return PyInt_FromLong(m_lightlayer);
-       if (!strcmp(attr, "triangle"))
-               // deprecated, triangle/quads shouldn't have been a material property
-               return 0;
-               
-       if (!strcmp(attr, "diffuse"))
-               return PyObjectFrom(m_diffuse);
-       if (!strcmp(attr, "shininess"))
-               return PyFloat_FromDouble(m_shininess);
-       if (!strcmp(attr, "specular"))
-               return PyObjectFrom(m_specular);
-       if (!strcmp(attr, "specularity"))
-               return PyFloat_FromDouble(m_specularity);
+       KX_PYATTRIBUTE_RW_FUNCTION("diffuse", KX_PolygonMaterial, pyattr_get_diffuse, pyattr_set_diffuse),
+       KX_PYATTRIBUTE_RW_FUNCTION("specular",KX_PolygonMaterial, pyattr_get_specular, pyattr_set_specular),    
        
-       _getattr_up(PyObjectPlus);
-}
-
-int KX_PolygonMaterial::_setattr(const char *attr, PyObject *pyvalue)
-{
-       if (PyFloat_Check(pyvalue))
-       {
-               float value = PyFloat_AsDouble(pyvalue);
-               if (!strcmp(attr, "shininess"))
-               {
-                       m_shininess = value;
-                       return 0;
-               }
-               
-               if (!strcmp(attr, "specularity"))
-               {
-                       m_specularity = value;
-                       return 0;
-               }
-       }
+       KX_PYATTRIBUTE_RO_FUNCTION("tface",     KX_PolygonMaterial, pyattr_get_tface), /* How the heck is this even useful??? - Campbell */
+       KX_PYATTRIBUTE_RO_FUNCTION("gl_texture", KX_PolygonMaterial, pyattr_get_gl_texture), /* could be called 'bindcode' */
        
-       if (PyInt_Check(pyvalue))
-       {
-               int value = PyInt_AsLong(pyvalue);
-               if (!strcmp(attr, "tile"))
-               {
-                       m_tile = value;
-                       return 0;
-               }
-               
-               if (!strcmp(attr, "tilexrep"))
-               {
-                       m_tilexrep = value;
-                       return 0;
-               }
-               
-               if (!strcmp(attr, "tileyrep"))
-               {
-                       m_tileyrep = value;
-                       return 0;
-               }
-               
-               if (!strcmp(attr, "drawingmode"))
-               {
-                       m_drawingmode = value;
-                       return 0;
-               }
-               
-               if (!strcmp(attr, "transparent"))
-               {
-                       m_alpha = value;
-                       return 0;
-               }
-               
-               if (!strcmp(attr, "zsort"))
-               {
-                       m_zsort = value;
-                       return 0;
-               }
-               
-               if (!strcmp(attr, "lightlayer"))
-               {
-                       m_lightlayer = value;
-                       return 0;
-               }
-               
-               // This probably won't work...
-               if (!strcmp(attr, "triangle"))
-               {
-                       // deprecated, triangle/quads shouldn't have been a material property
-                       return 0;
-               }
-       }
-       
-       if (PySequence_Check(pyvalue))
-       {
-               if (PySequence_Size(pyvalue) == 3)
-               {
-                       MT_Vector3 value;
-                       if (PyVecTo(pyvalue, value))
-                       {
-                               if (!strcmp(attr, "diffuse"))
-                               {
-                                       m_diffuse = value;
-                                       return 0;
-                               }
-                               
-                               if (!strcmp(attr, "specular"))
-                               {
-                                       m_specular = value;
-                                       return 0;
-                               }
-                       }
-               }
-       }
+       /* triangle used to be an attribute, removed for 2.49, nobody should be using it */
+       { NULL }        //Sentinel
+};
 
-       return PyObjectPlus::_setattr(attr, pyvalue);
-}
+PyTypeObject KX_PolygonMaterial::Type = {
+       PyVarObject_HEAD_INIT(NULL, 0)
+       "KX_PolygonMaterial",
+       sizeof(PyObjectPlus_Proxy),
+       0,
+       py_base_dealloc,
+       0,
+       0,
+       0,
+       0,
+       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,
+       &PyObjectPlus::Type,
+       0,0,0,0,0,0,
+       py_base_new
+};
 
 KX_PYMETHODDEF_DOC(KX_PolygonMaterial, setCustomMaterial, "setCustomMaterial(material)")
 {
        PyObject *material;
-       if (PyArg_ParseTuple(args, "O", &material))
+       if (PyArg_ParseTuple(args, "O:setCustomMaterial", &material))
        {
                if (m_pymaterial) {
                        Py_DECREF(m_pymaterial);
@@ -368,10 +299,10 @@ KX_PYMETHODDEF_DOC(KX_PolygonMaterial, setCustomMaterial, "setCustomMaterial(mat
 KX_PYMETHODDEF_DOC(KX_PolygonMaterial, updateTexture, "updateTexture(tface, rasty)")
 {
        PyObject *pyrasty, *pytface;
-       if (PyArg_ParseTuple(args, "O!O!", &PyCObject_Type, &pytface, &PyCObject_Type, &pyrasty))
+       if (PyArg_ParseTuple(args, "O!O!:updateTexture", &PyCapsule_Type, &pytface, &PyCapsule_Type, &pyrasty))
        {
-               MTFace *tface = (MTFace*) PyCObject_AsVoidPtr(pytface);
-               RAS_IRasterizer *rasty = (RAS_IRasterizer*) PyCObject_AsVoidPtr(pyrasty);
+               MTFace *tface = (MTFace*) PyCapsule_GetPointer(pytface, KX_POLYGONMATERIAL_CAPSULE_ID);
+               RAS_IRasterizer *rasty = (RAS_IRasterizer*) PyCapsule_GetPointer(pyrasty, KX_POLYGONMATERIAL_CAPSULE_ID);
                Image *ima = (Image*)tface->tpage;
                GPU_update_image_time(ima, rasty->GetTime());
 
@@ -384,10 +315,10 @@ KX_PYMETHODDEF_DOC(KX_PolygonMaterial, updateTexture, "updateTexture(tface, rast
 KX_PYMETHODDEF_DOC(KX_PolygonMaterial, setTexture, "setTexture(tface)")
 {
        PyObject *pytface;
-       if (PyArg_ParseTuple(args, "O!", &PyCObject_Type, &pytface))
+       if (PyArg_ParseTuple(args, "O!:setTexture", &PyCapsule_Type, &pytface))
        {
-               MTFace *tface = (MTFace*) PyCObject_AsVoidPtr(pytface);
-               GPU_set_tpage(tface);
+               MTFace *tface = (MTFace*) PyCapsule_GetPointer(pytface, KX_POLYGONMATERIAL_CAPSULE_ID);
+               GPU_set_tpage(tface, 1);
                Py_RETURN_NONE;
        }
        
@@ -397,10 +328,10 @@ KX_PYMETHODDEF_DOC(KX_PolygonMaterial, setTexture, "setTexture(tface)")
 KX_PYMETHODDEF_DOC(KX_PolygonMaterial, activate, "activate(rasty, cachingInfo)")
 {
        PyObject *pyrasty, *pyCachingInfo;
-       if (PyArg_ParseTuple(args, "O!O!", &PyCObject_Type, &pyrasty, &PyCObject_Type, &pyCachingInfo))
+       if (PyArg_ParseTuple(args, "O!O!:activate", &PyCapsule_Type, &pyrasty, &PyCapsule_Type, &pyCachingInfo))
        {
-               RAS_IRasterizer *rasty = static_cast<RAS_IRasterizer*>(PyCObject_AsVoidPtr(pyrasty));
-               TCachingInfo *cachingInfo = static_cast<TCachingInfo*>(PyCObject_AsVoidPtr(pyCachingInfo));
+               RAS_IRasterizer *rasty = static_cast<RAS_IRasterizer*>(PyCapsule_GetPointer(pyrasty, KX_POLYGONMATERIAL_CAPSULE_ID));
+               TCachingInfo *cachingInfo = static_cast<TCachingInfo*>(PyCapsule_GetPointer(pyCachingInfo, KX_POLYGONMATERIAL_CAPSULE_ID));
                if (rasty && cachingInfo)
                {
                        DefaultActivate(rasty, *cachingInfo);
@@ -410,3 +341,71 @@ KX_PYMETHODDEF_DOC(KX_PolygonMaterial, activate, "activate(rasty, cachingInfo)")
        
        return NULL;
 }
+
+PyObject* KX_PolygonMaterial::pyattr_get_texture(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_PolygonMaterial* self= static_cast<KX_PolygonMaterial*>(self_v);
+       return PyUnicode_FromString(self->m_texturename.ReadPtr());
+}
+
+PyObject* KX_PolygonMaterial::pyattr_get_material(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_PolygonMaterial* self= static_cast<KX_PolygonMaterial*>(self_v);
+       return PyUnicode_FromString(self->m_materialname.ReadPtr());
+}
+
+/* this does not seem useful */
+PyObject* KX_PolygonMaterial::pyattr_get_tface(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_PolygonMaterial* self= static_cast<KX_PolygonMaterial*>(self_v);
+       return PyCapsule_New(self->m_tface, KX_POLYGONMATERIAL_CAPSULE_ID, NULL);
+}
+
+PyObject* KX_PolygonMaterial::pyattr_get_gl_texture(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_PolygonMaterial* self= static_cast<KX_PolygonMaterial*>(self_v);
+       int bindcode= 0;
+       if (self->m_tface && self->m_tface->tpage)
+               bindcode= self->m_tface->tpage->bindcode;
+       
+       return PyLong_FromSsize_t(bindcode);
+}
+
+
+PyObject* KX_PolygonMaterial::pyattr_get_diffuse(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_PolygonMaterial* self= static_cast<KX_PolygonMaterial*>(self_v);
+       return PyObjectFrom(self->m_diffuse);
+}
+
+int KX_PolygonMaterial::pyattr_set_diffuse(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_PolygonMaterial* self= static_cast<KX_PolygonMaterial*>(self_v);
+       MT_Vector3 vec;
+       
+       if (!PyVecTo(value, vec))
+               return PY_SET_ATTR_FAIL;
+       
+       self->m_diffuse= vec;
+       return PY_SET_ATTR_SUCCESS;
+}
+
+PyObject* KX_PolygonMaterial::pyattr_get_specular(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_PolygonMaterial* self= static_cast<KX_PolygonMaterial*>(self_v);
+       return PyObjectFrom(self->m_specular);
+}
+
+int KX_PolygonMaterial::pyattr_set_specular(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+       KX_PolygonMaterial* self= static_cast<KX_PolygonMaterial*>(self_v);
+       MT_Vector3 vec;
+       
+       if (!PyVecTo(value, vec))
+               return PY_SET_ATTR_FAIL;
+       
+       self->m_specular= vec;
+       return PY_SET_ATTR_SUCCESS;
+}
+
+#endif // WITH_PYTHON