Initial revision
[blender.git] / source / gameengine / Ketsji / KX_RadarSensor.cpp
1 /**
2  * $Id$
3  * ***** BEGIN GPL/BL DUAL 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. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30  */
31
32 #include "KX_RadarSensor.h"
33
34 #include "KX_GameObject.h"
35 /**
36  *      RadarSensor constructor. Creates a near-sensor derived class, with a cone collision shape.
37  */
38
39 #ifdef PHYSICS_NOT_YET
40
41 KX_RadarSensor::KX_RadarSensor(class SCA_EventManager* eventmgr,
42                 class KX_GameObject* gameobj,
43                         double coneradius,
44                         double coneheight,
45                         int     axis,
46                         double margin,
47                         double resetmargin,
48                         bool bFindMaterial,
49                         const STR_String& touchedpropname,
50                         class KX_Scene* kxscene,
51                         PyTypeObject* T)
52
53                         : KX_NearSensor(
54                                 eventmgr,
55                                 gameobj,
56                                 margin,
57                                 resetmargin,
58                                 bFindMaterial,
59                                 touchedpropname,
60                                 kxscene,
61                                 T),
62                                 m_coneheight(coneheight),
63                                 m_coneradius(coneradius),
64                                 m_axis(axis)
65 {
66         m_client_info.m_type = 3;
67         m_client_info.m_clientobject = gameobj;
68         m_client_info.m_auxilary_info = NULL;
69         sumoObj->setClientObject(&m_client_info);
70 }
71                         
72
73 KX_RadarSensor::~KX_RadarSensor()
74 {
75         
76 }
77
78 /**
79  *      Transforms the collision object. A cone is not correctly centered
80  *      for usage.  */
81 void KX_RadarSensor::SynchronizeTransform()
82 {
83         // Getting the parent location was commented out. Why?
84         MT_Transform trans;
85         trans.setOrigin(((KX_GameObject*)GetParent())->NodeGetWorldPosition());
86         trans.setBasis(((KX_GameObject*)GetParent())->NodeGetWorldOrientation());
87         // What is the default orientation? pointing in the -y direction?
88         // is the geometry correctly converted?
89
90         // a collision cone is oriented
91         // center the cone correctly 
92         // depends on the radar 'axis'
93         switch (m_axis)
94         {
95         case 0: // X Axis
96                 {
97                         MT_Quaternion rotquatje(MT_Vector3(0,0,1),MT_radians(90));
98                         trans.rotate(rotquatje);
99                         trans.translate(MT_Vector3 (0, -m_coneheight/2.0 ,0));
100                         break;
101                 };
102         case 1: // Y Axis
103                 {
104                         MT_Quaternion rotquatje(MT_Vector3(1,0,0),MT_radians(-180));
105                         trans.rotate(rotquatje);
106                         trans.translate(MT_Vector3 (0, -m_coneheight/2.0 ,0));
107                         break;
108                 };
109         case 2: // Z Axis
110                 {
111                         MT_Quaternion rotquatje(MT_Vector3(1,0,0),MT_radians(-90));
112                         trans.rotate(rotquatje);
113                         trans.translate(MT_Vector3 (0, -m_coneheight/2.0 ,0));
114                         break;
115                 };
116         default:
117                 {
118                 }
119         }
120         m_cone_origin = trans.getOrigin();
121         m_cone_target = trans(MT_Point3(0, -m_coneheight/2.0 ,0));
122
123         m_sumoObj->setPosition(trans.getOrigin());
124         m_sumoObj->setOrientation(trans.getRotation());
125         m_sumoObj->calcXform();
126 }
127
128 /* ------------------------------------------------------------------------- */
129 /* Python functions                                                          */
130 /* ------------------------------------------------------------------------- */
131
132 /* Integration hooks ------------------------------------------------------- */
133 PyTypeObject KX_RadarSensor::Type = {
134         PyObject_HEAD_INIT(&PyType_Type)
135         0,
136         "KX_RadarSensor",
137         sizeof(KX_RadarSensor),
138         0,
139         PyDestructor,
140         0,
141         __getattr,
142         __setattr,
143         0, //&MyPyCompare,
144         __repr,
145         0, //&cvalue_as_number,
146         0,
147         0,
148         0,
149         0
150 };
151
152 PyParentObject KX_RadarSensor::Parents[] = {
153         &KX_RadarSensor::Type,
154         &KX_NearSensor::Type,
155         &KX_TouchSensor::Type,
156         &SCA_ISensor::Type,
157         &SCA_ILogicBrick::Type,
158         &CValue::Type,
159         NULL
160 };
161
162 PyMethodDef KX_RadarSensor::Methods[] = {
163         {"getConeOrigin", (PyCFunction) KX_RadarSensor::sPyGetConeOrigin, 
164          METH_VARARGS, GetConeOrigin_doc},
165         {"getConeTarget", (PyCFunction) KX_RadarSensor::sPyGetConeTarget, 
166          METH_VARARGS, GetConeTarget_doc},
167         {"getConeHeight", (PyCFunction) KX_RadarSensor::sPyGetConeHeight, 
168          METH_VARARGS, GetConeHeight_doc},
169         {NULL,NULL,NULL,NULL} //Sentinel
170 };
171
172 PyObject* KX_RadarSensor::_getattr(char* attr) {
173         _getattr_up(KX_TouchSensor);
174 }
175
176 /* getConeOrigin */
177 char KX_RadarSensor::GetConeOrigin_doc[] = 
178 "getConeOrigin()\n"
179 "\tReturns the origin of the cone with which to test. The origin\n"
180 "\tis in the middle of the cone.";
181 PyObject* KX_RadarSensor::PyGetConeOrigin(PyObject* self, 
182                                                                                   PyObject* args, 
183                                                                                   PyObject* kwds) {
184         PyObject *retVal = PyList_New(3);
185         
186         PyList_SetItem(retVal, 0, PyFloat_FromDouble(m_cone_origin[0]));
187         PyList_SetItem(retVal, 1, PyFloat_FromDouble(m_cone_origin[1]));
188         PyList_SetItem(retVal, 2, PyFloat_FromDouble(m_cone_origin[2]));
189         
190         return retVal;
191 }
192
193 /* getConeOrigin */
194 char KX_RadarSensor::GetConeTarget_doc[] = 
195 "getConeTarget()\n"
196 "\tReturns the center of the bottom face of the cone with which to test.\n";
197 PyObject* KX_RadarSensor::PyGetConeTarget(PyObject* self, 
198                                                                                   PyObject* args, 
199                                                                                   PyObject* kwds) {
200         PyObject *retVal = PyList_New(3);
201         
202         PyList_SetItem(retVal, 0, PyFloat_FromDouble(m_cone_target[0]));
203         PyList_SetItem(retVal, 1, PyFloat_FromDouble(m_cone_target[1]));
204         PyList_SetItem(retVal, 2, PyFloat_FromDouble(m_cone_target[2]));
205         
206         return retVal;
207 }
208
209 /* getConeOrigin */
210 char KX_RadarSensor::GetConeHeight_doc[] = 
211 "getConeHeight()\n"
212 "\tReturns the height of the cone with which to test.\n";
213 PyObject* KX_RadarSensor::PyGetConeHeight(PyObject* self, 
214                                                                                   PyObject* args, 
215                                                                                   PyObject* kwds) {
216         return PyFloat_FromDouble(m_coneheight);
217 }
218
219
220 #endif //PHYSICS_NOT_YET