e15847fe6c616acb67fe33fd7418fcb23160c2a4
[blender.git] / source / gameengine / Ketsji / KX_MeshProxy.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_MeshProxy.h"
34 #include "RAS_IPolygonMaterial.h"
35 #include "RAS_MeshObject.h"
36
37 #include "KX_VertexProxy.h"
38 #include "KX_PolyProxy.h"
39
40 #include "KX_PolygonMaterial.h"
41 #include "KX_BlenderMaterial.h"
42
43 #include "KX_PyMath.h"
44 #include "KX_ConvertPhysicsObject.h"
45
46 #include "PyObjectPlus.h" 
47
48 PyTypeObject KX_MeshProxy::Type = {
49         PyVarObject_HEAD_INIT(NULL, 0)
50         "KX_MeshProxy",
51         sizeof(PyObjectPlus_Proxy),
52         0,
53         py_base_dealloc,
54         0,
55         0,
56         0,
57         0,
58         py_base_repr,
59         0,0,0,0,0,0,0,0,0,
60         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
61         0,0,0,0,0,0,0,
62         Methods,
63         0,
64         0,
65         &CValue::Type,
66         0,0,0,0,0,0,
67         py_base_new
68 };
69
70 PyMethodDef KX_MeshProxy::Methods[] = {
71 // Deprecated ----->
72 {"getNumMaterials", (PyCFunction)KX_MeshProxy::sPyGetNumMaterials,METH_VARARGS},
73 {"getNumPolygons", (PyCFunction)KX_MeshProxy::sPyGetNumPolygons,METH_NOARGS},
74 // <-----
75
76 {"getMaterialName", (PyCFunction)KX_MeshProxy::sPyGetMaterialName,METH_VARARGS},
77 {"getTextureName", (PyCFunction)KX_MeshProxy::sPyGetTextureName,METH_VARARGS},
78 {"getVertexArrayLength", (PyCFunction)KX_MeshProxy::sPyGetVertexArrayLength,METH_VARARGS},
79 {"getVertex", (PyCFunction)KX_MeshProxy::sPyGetVertex,METH_VARARGS},
80 {"getPolygon", (PyCFunction)KX_MeshProxy::sPyGetPolygon,METH_VARARGS},
81 //{"getIndexArrayLength", (PyCFunction)KX_MeshProxy::sPyGetIndexArrayLength,METH_VARARGS},
82
83   {NULL,NULL} //Sentinel
84 };
85
86 PyAttributeDef KX_MeshProxy::Attributes[] = {
87         KX_PYATTRIBUTE_RO_FUNCTION("materials",         KX_MeshProxy, pyattr_get_materials),
88         KX_PYATTRIBUTE_RO_FUNCTION("numPolygons",       KX_MeshProxy, pyattr_get_numPolygons),
89         KX_PYATTRIBUTE_RO_FUNCTION("numMaterials",      KX_MeshProxy, pyattr_get_numMaterials),
90
91         { NULL }        //Sentinel
92 };
93
94 void KX_MeshProxy::SetMeshModified(bool v)
95 {
96         m_meshobj->SetMeshModified(v);
97 }
98
99 KX_MeshProxy::KX_MeshProxy(RAS_MeshObject* mesh)
100         : CValue(), m_meshobj(mesh)
101 {
102 }
103
104 KX_MeshProxy::~KX_MeshProxy()
105 {
106 }
107
108
109
110 // stuff for cvalue related things
111 CValue*         KX_MeshProxy::Calc(VALUE_OPERATOR op, CValue *val) { return NULL;}
112 CValue*         KX_MeshProxy::CalcFinal(VALUE_DATA_TYPE dtype, VALUE_OPERATOR op, CValue *val) { return NULL;}  
113
114 const STR_String &      KX_MeshProxy::GetText() {return m_meshobj->GetName();};
115 double          KX_MeshProxy::GetNumber() { return -1;}
116 STR_String&     KX_MeshProxy::GetName() { return m_meshobj->GetName();}
117 void            KX_MeshProxy::SetName(const char *name) { };
118 CValue*         KX_MeshProxy::GetReplica() { return NULL;}
119
120
121 // stuff for python integration
122         
123 PyObject* KX_MeshProxy::PyGetNumMaterials(PyObject* args, PyObject* kwds)
124 {
125         int num = m_meshobj->NumMaterials();
126         ShowDeprecationWarning("getNumMaterials()", "the numMaterials property");
127         return PyLong_FromSsize_t(num);
128 }
129
130 PyObject* KX_MeshProxy::PyGetNumPolygons()
131 {
132         int num = m_meshobj->NumPolygons();
133         ShowDeprecationWarning("getNumPolygons()", "the numPolygons property");
134         return PyLong_FromSsize_t(num);
135 }
136
137 PyObject* KX_MeshProxy::PyGetMaterialName(PyObject* args, PyObject* kwds)
138 {
139     int matid= 1;
140         STR_String matname;
141
142         if (PyArg_ParseTuple(args,"i:getMaterialName",&matid))
143         {
144                 matname = m_meshobj->GetMaterialName(matid);
145         }
146         else {
147                 return NULL;
148         }
149
150         return PyUnicode_FromString(matname.Ptr());
151                 
152 }
153         
154
155 PyObject* KX_MeshProxy::PyGetTextureName(PyObject* args, PyObject* kwds)
156 {
157     int matid= 1;
158         STR_String matname;
159
160         if (PyArg_ParseTuple(args,"i:getTextureName",&matid))
161         {
162                 matname = m_meshobj->GetTextureName(matid);
163         }
164         else {
165                 return NULL;
166         }
167
168         return PyUnicode_FromString(matname.Ptr());
169                 
170 }
171
172 PyObject* KX_MeshProxy::PyGetVertexArrayLength(PyObject* args, PyObject* kwds)
173 {
174     int matid= 0;
175         int length = 0;
176
177         
178         if (!PyArg_ParseTuple(args,"i:getVertexArrayLength",&matid))
179                 return NULL;
180         
181
182         RAS_MeshMaterial *mmat = m_meshobj->GetMeshMaterial(matid); /* can be NULL*/
183         
184         if (mmat)
185         {
186                 RAS_IPolyMaterial* mat = mmat->m_bucket->GetPolyMaterial();
187                 if (mat)
188                         length = m_meshobj->NumVertices(mat);
189         }
190         
191         return PyLong_FromSsize_t(length);
192 }
193
194
195 PyObject* KX_MeshProxy::PyGetVertex(PyObject* args, PyObject* kwds)
196 {
197     int vertexindex;
198         int matindex;
199
200         if (!PyArg_ParseTuple(args,"ii:getVertex",&matindex,&vertexindex))
201                 return NULL;
202         
203         RAS_TexVert* vertex = m_meshobj->GetVertex(matindex,vertexindex);
204         
205         if(vertex==NULL) {
206                 PyErr_SetString(PyExc_ValueError, "mesh.getVertex(mat_idx, vert_idx): KX_MeshProxy, could not get a vertex at the given indicies");
207                 return NULL;
208         }
209         
210         return (new KX_VertexProxy(this, vertex))->NewProxy(true);
211 }
212
213 PyObject* KX_MeshProxy::PyGetPolygon(PyObject* args, PyObject* kwds)
214 {
215     int polyindex= 1;
216         PyObject* polyob = NULL;
217
218         if (!PyArg_ParseTuple(args,"i:getPolygon",&polyindex))
219                 return NULL;
220         
221         if (polyindex<0 || polyindex >= m_meshobj->NumPolygons())
222         {
223                 PyErr_SetString(PyExc_AttributeError, "mesh.getPolygon(int): KX_MeshProxy, invalid polygon index");
224                 return NULL;
225         }
226                 
227
228         RAS_Polygon* polygon = m_meshobj->GetPolygon(polyindex);
229         if (polygon)
230         {
231                 polyob = (new KX_PolyProxy(m_meshobj, polygon))->NewProxy(true);
232         }
233         else {
234                 PyErr_SetString(PyExc_AttributeError, "mesh.getPolygon(int): KX_MeshProxy, polygon is NULL, unknown reason");
235         }
236         return polyob;
237 }
238
239 PyObject* KX_MeshProxy::pyattr_get_materials(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
240 {
241         KX_MeshProxy* self= static_cast<KX_MeshProxy*>(self_v);
242         
243         int tot= self->m_meshobj->NumMaterials();
244         int i;
245         
246         PyObject *materials = PyList_New( tot );
247         
248         list<RAS_MeshMaterial>::iterator mit= self->m_meshobj->GetFirstMaterial();
249         
250         
251         for(i=0; i<tot; mit++, i++) {
252                 RAS_IPolyMaterial *polymat = mit->m_bucket->GetPolyMaterial();   
253                 
254                 /* Why do we need to check for RAS_BLENDERMAT if both are cast to a (PyObject*)? - Campbell */
255                 if(polymat->GetFlag() & RAS_BLENDERMAT)          
256                 {        
257                         KX_BlenderMaterial *mat = static_cast<KX_BlenderMaterial*>(polymat);     
258                         PyList_SET_ITEM(materials, i, mat->GetProxy());
259                 }
260                 else {  
261                         KX_PolygonMaterial *mat = static_cast<KX_PolygonMaterial*>(polymat);
262                         PyList_SET_ITEM(materials, i, mat->GetProxy());
263                 }
264         }       
265         return materials;
266 }
267
268 PyObject * KX_MeshProxy::pyattr_get_numMaterials(void * selfv, const KX_PYATTRIBUTE_DEF * attrdef) {
269         KX_MeshProxy * self = static_cast<KX_MeshProxy *> (selfv);
270         return PyLong_FromSsize_t(self->m_meshobj->NumMaterials());
271 }
272
273 PyObject * KX_MeshProxy::pyattr_get_numPolygons(void * selfv, const KX_PYATTRIBUTE_DEF * attrdef) {
274         KX_MeshProxy * self = static_cast<KX_MeshProxy *> (selfv);
275         return PyLong_FromSsize_t(self->m_meshobj->NumPolygons());
276 }
277
278 /* a close copy of ConvertPythonToGameObject but for meshes */
279 bool ConvertPythonToMesh(PyObject * value, RAS_MeshObject **object, bool py_none_ok, const char *error_prefix)
280 {
281         if (value==NULL) {
282                 PyErr_Format(PyExc_TypeError, "%s, python pointer NULL, should never happen", error_prefix);
283                 *object = NULL;
284                 return false;
285         }
286                 
287         if (value==Py_None) {
288                 *object = NULL;
289                 
290                 if (py_none_ok) {
291                         return true;
292                 } else {
293                         PyErr_Format(PyExc_TypeError, "%s, expected KX_MeshProxy or a KX_MeshProxy name, None is invalid", error_prefix);
294                         return false;
295                 }
296         }
297         
298         if (PyUnicode_Check(value)) {
299                 *object = (RAS_MeshObject*)SCA_ILogicBrick::m_sCurrentLogicManager->GetMeshByName(STR_String( _PyUnicode_AsString(value) ));
300                 
301                 if (*object) {
302                         return true;
303                 } else {
304                         PyErr_Format(PyExc_ValueError, "%s, requested name \"%s\" did not match any KX_MeshProxy in this scene", error_prefix, _PyUnicode_AsString(value));
305                         return false;
306                 }
307         }
308         
309         if (PyObject_TypeCheck(value, &KX_MeshProxy::Type)) {
310                 KX_MeshProxy *kx_mesh = static_cast<KX_MeshProxy*>BGE_PROXY_REF(value);
311                 
312                 /* sets the error */
313                 if (kx_mesh==NULL) {
314                         PyErr_Format(PyExc_SystemError, "%s, " BGE_PROXY_ERROR_MSG, error_prefix);
315                         return false;
316                 }               
317                 
318                 *object = kx_mesh->GetMesh();
319                 return true;
320         }
321         
322         *object = NULL;
323         
324         if (py_none_ok) {
325                 PyErr_Format(PyExc_TypeError, "%s, expect a KX_MeshProxy, a string or None", error_prefix);
326         } else {
327                 PyErr_Format(PyExc_TypeError, "%s, expect a KX_MeshProxy or a string", error_prefix);
328         }
329         
330         return false;
331 }