source/gameengine/Ketsji/KX_PolyProxy.cpp

   1 /**
   2  * $Id$
   3  * ***** BEGIN GPL LICENSE BLOCK *****
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software Foundation,
  17  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18  *
  19  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  20  * All rights reserved.
  21  *
  22  * The Original Code is: all of this file.
  23  *
  24  * Contributor(s): none yet.
  25  *
  26  * ***** END GPL LICENSE BLOCK *****
  27  */
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include <config.h>
  31 #endif
  32
  33 #include "KX_PolyProxy.h"
  34 #include "KX_MeshProxy.h"
  35 #include "RAS_MeshObject.h"
  36 #include "KX_BlenderMaterial.h"
  37 #include "KX_PolygonMaterial.h"
  38
  39 #include "KX_PyMath.h"
  40
  41 PyTypeObject KX_PolyProxy::Type = {
  42         PyObject_HEAD_INIT(NULL)
  43         0,
  44         "KX_PolyProxy",
  45         sizeof(PyObjectPlus_Proxy),
  46         0,
  47         py_base_dealloc,
  48         0,
  49         0,
  50         0,
  51         0,
  52         py_base_repr,
  53         0,0,0,0,0,0,
  54         py_base_getattro,
  55         py_base_setattro,
  56         0,0,0,0,0,0,0,0,0,
  57         Methods
  58 };
  59
  60 PyParentObject KX_PolyProxy::Parents[] = {
  61         &KX_PolyProxy::Type,
  62         &SCA_IObject::Type,
  63         &CValue::Type,
  64         NULL
  65 };
  66
  67 PyMethodDef KX_PolyProxy::Methods[] = {
  68         KX_PYMETHODTABLE_NOARGS(KX_PolyProxy,getMaterialIndex),
  69         KX_PYMETHODTABLE_NOARGS(KX_PolyProxy,getNumVertex),
  70         KX_PYMETHODTABLE_NOARGS(KX_PolyProxy,isVisible),
  71         KX_PYMETHODTABLE_NOARGS(KX_PolyProxy,isCollider),
  72         KX_PYMETHODTABLE_NOARGS(KX_PolyProxy,getMaterialName),
  73         KX_PYMETHODTABLE_NOARGS(KX_PolyProxy,getTextureName),
  74         KX_PYMETHODTABLE(KX_PolyProxy,getVertexIndex),
  75         KX_PYMETHODTABLE_NOARGS(KX_PolyProxy,getMesh),
  76         KX_PYMETHODTABLE_NOARGS(KX_PolyProxy,getMaterial),
  77         {NULL,NULL} //Sentinel
  78 };
  79
  80 PyAttributeDef KX_PolyProxy::Attributes[] = {
  81         /* All dummy's so they come up in a dir() */
  82         //KX_PYATTRIBUTE_TODO("DummyProps"),
  83         KX_PYATTRIBUTE_DUMMY("matname"),
  84         KX_PYATTRIBUTE_DUMMY("texture"),
  85         KX_PYATTRIBUTE_DUMMY("material"),
  86         KX_PYATTRIBUTE_DUMMY("matid"),
  87         KX_PYATTRIBUTE_DUMMY("v1"),
  88         KX_PYATTRIBUTE_DUMMY("v2"),
  89         KX_PYATTRIBUTE_DUMMY("v3"),
  90         KX_PYATTRIBUTE_DUMMY("v4"),
  91         KX_PYATTRIBUTE_DUMMY("visible"),
  92         KX_PYATTRIBUTE_DUMMY("collide"),
  93         { NULL }        //Sentinel
  94 };
  95
  96 PyObject* KX_PolyProxy::py_getattro(PyObject *attr)
  97 {
  98         char *attr_str= PyString_AsString(attr);
  99         if (!strcmp(attr_str, "matname"))
 100         {
 101                 return PyString_FromString(m_polygon->GetMaterial()->GetPolyMaterial()->GetMaterialName());
 102         }
 103         if (!strcmp(attr_str, "texture"))
 104         {
 105                 return PyString_FromString(m_polygon->GetMaterial()->GetPolyMaterial()->GetTextureName());
 106         }
 107         if (!strcmp(attr_str, "material"))
 108         {
 109                 RAS_IPolyMaterial *polymat = m_polygon->GetMaterial()->GetPolyMaterial();
 110                 if(polymat->GetFlag() & RAS_BLENDERMAT)
 111                 {
 112                         KX_BlenderMaterial* mat = static_cast<KX_BlenderMaterial*>(polymat);
 113                         return mat->GetProxy();
 114                 }
 115                 else
 116                 {
 117                         KX_PolygonMaterial* mat = static_cast<KX_PolygonMaterial*>(polymat);
 118                         return mat->GetProxy();
 119                 }
 120         }
 121         if (!strcmp(attr_str, "matid"))
 122         {
 123                 // we'll have to scan through the material bucket of the mes and compare with
 124                 // the one of the polygon
 125                 RAS_MaterialBucket* polyBucket = m_polygon->GetMaterial();
 126                 unsigned int matid;
 127                 for (matid=0; matid<(unsigned int)m_mesh->NumMaterials(); matid++)
 128                 {
 129                         RAS_MeshMaterial* meshMat = m_mesh->GetMeshMaterial(matid);
 130                         if (meshMat->m_bucket == polyBucket)
 131                                 // found it
 132                                 break;
 133                 }
 134                 return PyInt_FromLong(matid);
 135         }
 136         if (!strcmp(attr_str, "v1"))
 137         {
 138                 return PyInt_FromLong(m_polygon->GetVertexOffset(0));
 139         }
 140         if (!strcmp(attr_str, "v2"))
 141         {
 142                 return PyInt_FromLong(m_polygon->GetVertexOffset(1));
 143         }
 144         if (!strcmp(attr_str, "v3"))
 145         {
 146                 return PyInt_FromLong(m_polygon->GetVertexOffset(2));
 147         }
 148         if (!strcmp(attr_str, "v4"))
 149         {
 150                 return PyInt_FromLong(((m_polygon->VertexCount()>3)?m_polygon->GetVertexOffset(3):0));
 151         }
 152         if (!strcmp(attr_str, "visible"))
 153         {
 154                 return PyInt_FromLong(m_polygon->IsVisible());
 155         }
 156         if (!strcmp(attr_str, "collide"))
 157         {
 158                 return PyInt_FromLong(m_polygon->IsCollider());
 159         }
 160         py_getattro_up(SCA_IObject);
 161 }
 162
 163 PyObject* KX_PolyProxy::py_getattro_dict() {
 164         py_getattro_dict_up(SCA_IObject);
 165 }
 166
 167 KX_PolyProxy::KX_PolyProxy(const RAS_MeshObject*mesh, RAS_Polygon* polygon)
 168 :       m_polygon(polygon),
 169         m_mesh((RAS_MeshObject*)mesh)
 170 {
 171 }
 172
 173 KX_PolyProxy::~KX_PolyProxy()
 174 {
 175 }
 176
 177
 178 // stuff for cvalue related things
 179 CValue*         KX_PolyProxy::Calc(VALUE_OPERATOR, CValue *) { return NULL;}
 180 CValue*         KX_PolyProxy::CalcFinal(VALUE_DATA_TYPE, VALUE_OPERATOR, CValue *) { return NULL;}
 181 STR_String      sPolyName="polygone";
 182 const STR_String &      KX_PolyProxy::GetText() {return sPolyName;};
 183 double          KX_PolyProxy::GetNumber() { return -1;}
 184 STR_String      KX_PolyProxy::GetName() { return sPolyName;}
 185 void            KX_PolyProxy::SetName(STR_String) { };
 186 CValue*         KX_PolyProxy::GetReplica() { return NULL;}
 187
 188 // stuff for python integration
 189
 190 KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, getMaterialIndex,
 191 "getMaterialIndex() : return the material index of the polygon in the mesh\n")
 192 {
 193         RAS_MaterialBucket* polyBucket = m_polygon->GetMaterial();
 194         unsigned int matid;
 195         for (matid=0; matid<(unsigned int)m_mesh->NumMaterials(); matid++)
 196         {
 197                 RAS_MeshMaterial* meshMat = m_mesh->GetMeshMaterial(matid);
 198                 if (meshMat->m_bucket == polyBucket)
 199                         // found it
 200                         break;
 201         }
 202         return PyInt_FromLong(matid);
 203 }
 204
 205 KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, getNumVertex,
 206 "getNumVertex() : returns the number of vertex of the polygon, 3 or 4\n")
 207 {
 208         return PyInt_FromLong(m_polygon->VertexCount());
 209 }
 210
 211 KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, isVisible,
 212 "isVisible() : returns whether the polygon is visible or not\n")
 213 {
 214         return PyInt_FromLong(m_polygon->IsVisible());
 215 }
 216
 217 KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, isCollider,
 218 "isCollider() : returns whether the polygon is receives collision or not\n")
 219 {
 220         return PyInt_FromLong(m_polygon->IsCollider());
 221 }
 222
 223 KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, getMaterialName,
 224 "getMaterialName() : returns the polygon material name, \"NoMaterial\" if no material\n")
 225 {
 226         return PyString_FromString(m_polygon->GetMaterial()->GetPolyMaterial()->GetMaterialName());
 227 }
 228
 229 KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, getTextureName,
 230 "getTexturelName() : returns the polygon texture name, \"NULL\" if no texture\n")
 231 {
 232         return PyString_FromString(m_polygon->GetMaterial()->GetPolyMaterial()->GetTextureName());
 233 }
 234
 235 KX_PYMETHODDEF_DOC(KX_PolyProxy, getVertexIndex,
 236 "getVertexIndex(vertex) : returns the mesh vertex index of a polygon vertex\n"
 237 "vertex: index of the vertex in the polygon: 0->3\n"
 238 "return value can be used to retrieve the vertex details through mesh proxy\n"
 239 "Note: getVertexIndex(3) on a triangle polygon returns 0\n")
 240 {
 241         int index;
 242         if (!PyArg_ParseTuple(args,"i:getVertexIndex",&index))
 243         {
 244                 return NULL;
 245         }
 246         if (index < 0 || index > 3)
 247         {
 248                 PyErr_SetString(PyExc_AttributeError, "poly.getVertexIndex(int): KX_PolyProxy, expected an index between 0-3");
 249                 return NULL;
 250         }
 251         if (index < m_polygon->VertexCount())
 252         {
 253                 return PyInt_FromLong(m_polygon->GetVertexOffset(index));
 254         }
 255         return PyInt_FromLong(0);
 256 }
 257
 258 KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, getMesh,
 259 "getMesh() : returns a mesh proxy\n")
 260 {
 261         KX_MeshProxy* meshproxy = new KX_MeshProxy((RAS_MeshObject*)m_mesh);
 262         return meshproxy->NewProxy(true);
 263 }
 264
 265 KX_PYMETHODDEF_DOC_NOARGS(KX_PolyProxy, getMaterial,
 266 "getMaterial() : returns a material\n")
 267 {
 268         RAS_IPolyMaterial *polymat = m_polygon->GetMaterial()->GetPolyMaterial();
 269         if(polymat->GetFlag() & RAS_BLENDERMAT)
 270         {
 271                 KX_BlenderMaterial* mat = static_cast<KX_BlenderMaterial*>(polymat);
 272                 return mat->GetProxy();
 273         }
 274         else
 275         {
 276                 KX_PolygonMaterial* mat = static_cast<KX_PolygonMaterial*>(polymat);
 277                 return mat->GetProxy();
 278         }
 279 }