add missing files after merging
[blender.git] / source / gameengine / Ketsji / KX_PolygonMaterial.cpp
index 3975189a9c2ba0f377b1fce83af6036b2bc690ad..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
 
@@ -188,7 +240,7 @@ PyAttributeDef KX_PolygonMaterial::Attributes[] = {
        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),
+       //KX_PYATTRIBUTE_INT_RW("lightlayer", INT_MIN, INT_MAX, true, KX_PolygonMaterial, m_lightlayer),
 
        KX_PYATTRIBUTE_BOOL_RW("transparent", KX_PolygonMaterial, m_alpha),
        KX_PYATTRIBUTE_BOOL_RW("zsort", KX_PolygonMaterial, m_zsort),
@@ -196,7 +248,7 @@ PyAttributeDef KX_PolygonMaterial::Attributes[] = {
        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),
        
-       KX_PYATTRIBUTE_RW_FUNCTION("diffuse", KX_PolygonMaterial, pyattr_get_texture, pyattr_set_diffuse),
+       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),    
        
        KX_PYATTRIBUTE_RO_FUNCTION("tface",     KX_PolygonMaterial, pyattr_get_tface), /* How the heck is this even useful??? - Campbell */
@@ -207,52 +259,31 @@ PyAttributeDef KX_PolygonMaterial::Attributes[] = {
 };
 
 PyTypeObject KX_PolygonMaterial::Type = {
-       PyObject_HEAD_INIT(NULL)
-               0,
-               "KX_PolygonMaterial",
-               sizeof(KX_PolygonMaterial),
-               0,
-               PyDestructor,
-               0,
-               0,
-               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_PolygonMaterial::Parents[] = {
-       &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,
-       NULL
+       0,0,0,0,0,0,
+       py_base_new
 };
 
-PyObject* KX_PolygonMaterial::py_getattro(PyObject *attr)
-{
-       PyObject* object = py_getattro_self(Attributes, this, attr);
-       if (object != NULL)
-               return object;
-       
-       py_getattro_up(PyObjectPlus);
-}
-
-int KX_PolygonMaterial::py_setattro(PyObject *attr, PyObject *value)
-{
-       int ret = py_setattro_self(Attributes, this, attr, value);
-       if (ret >= 0)
-               return ret;
-
-       return PyObjectPlus::py_setattro(attr, value);
-}
-
 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);
@@ -268,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());
 
@@ -284,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;
        }
        
@@ -297,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);
@@ -314,20 +345,20 @@ KX_PYMETHODDEF_DOC(KX_PolygonMaterial, activate, "activate(rasty, cachingInfo)")
 PyObject* KX_PolygonMaterial::pyattr_get_texture(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 {
        KX_PolygonMaterial* self= static_cast<KX_PolygonMaterial*>(self_v);
-       return PyString_FromString(self->m_texturename.ReadPtr());
+       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 PyString_FromString(self->m_materialname.ReadPtr());
+       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 PyCObject_FromVoidPtr(self->m_tface, NULL);
+       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)
@@ -337,7 +368,7 @@ PyObject* KX_PolygonMaterial::pyattr_get_gl_texture(void *self_v, const KX_PYATT
        if (self->m_tface && self->m_tface->tpage)
                bindcode= self->m_tface->tpage->bindcode;
        
-       return PyInt_FromLong(bindcode);
+       return PyLong_FromSsize_t(bindcode);
 }
 
 
@@ -353,10 +384,10 @@ int KX_PolygonMaterial::pyattr_set_diffuse(void *self_v, const KX_PYATTRIBUTE_DE
        MT_Vector3 vec;
        
        if (!PyVecTo(value, vec))
-               return -1;
+               return PY_SET_ATTR_FAIL;
        
        self->m_diffuse= vec;
-       return 0;
+       return PY_SET_ATTR_SUCCESS;
 }
 
 PyObject* KX_PolygonMaterial::pyattr_get_specular(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
@@ -371,8 +402,10 @@ int KX_PolygonMaterial::pyattr_set_specular(void *self_v, const KX_PYATTRIBUTE_D
        MT_Vector3 vec;
        
        if (!PyVecTo(value, vec))
-               return -1;
+               return PY_SET_ATTR_FAIL;
        
        self->m_specular= vec;
-       return 0;
+       return PY_SET_ATTR_SUCCESS;
 }
+
+#endif // WITH_PYTHON