source: trunk/test/PhysicObject.h @ 1749

Last change on this file since 1749 was 1747, checked in by touky, 9 years ago

BtPhysTest : Splitted Physics files

File size: 7.2 KB
Line 
1//
2// Orbital
3//
4// Copyright: (c) 2009-2012 Cédric Lecacheur <jordx@free.fr>
5//            (c) 2009-2012 Benjamin Huet <huet.benjamin@gmail.com>
6//            (c) 2012 Sam Hocevar <sam@hocevar.net>
7//
8
9/* FIXME: this file is pure crap; it's only a test. */
10
11#if !defined __PHYSICOBJECT_H__
12#define __PHYSICOBJECT_H__
13
14#include "core.h"
15#include "easymesh/easymesh.h"
16#include "Physics/Include/EasyPhysics.h"
17#include "Physics/Include/EasyCharacterController.h"
18#include "Physics/Include/EasyConstraint.h"
19
20using namespace lol;
21using namespace lol::phys;
22
23class PhysicsObject : public WorldEntity
24{
25public:
26        PhysicsObject(Simulation* new_sim, const vec3 &base_location, const quat &base_rotation)
27                : m_ready(false), m_should_render(true), m_is_character(false)
28        {
29                m_mesh.Compile("[sc#ddd afcb60 1 60 -.1]");
30                vec3 BoxSize = vec3(60.f, 1.f, 60.f);
31                m_physics.SetCollisionChannel(0, 0xFF);
32                m_physics.SetShapeToBox(BoxSize);
33                m_physics.SetMass(.0f);
34                m_physics.SetTransform(base_location, base_rotation);
35                m_physics.InitBodyToRigid(true);
36                m_physics.AddToSimulation(new_sim);
37        }
38
39        PhysicsObject(Simulation* new_sim, const vec3 &base_location, const quat &base_rotation, int dummy)
40                : m_ready(false), m_should_render(true), m_is_character(false)
41        {
42                if (dummy == 1) //for Rope purpose
43                {
44                        m_mesh.Compile("[sc#ddd afcb20 1 20 -.1]");
45                        vec3 BoxSize = vec3(20.f, 1.f, 20.f);
46                        m_physics.SetCollisionChannel(0, 0xFF);
47                        m_physics.SetShapeToBox(BoxSize);
48                        m_physics.SetMass(.0f);
49                        m_physics.SetTransform(base_location, base_rotation);
50                        m_physics.InitBodyToRigid(true);
51                        m_physics.AddToSimulation(new_sim);
52                }
53                else if (dummy == 2) //for character purpose
54                {
55                        m_is_character = true;
56                        //m_mesh.Compile("[sc#f00 afcb10 10 10 -.1]");
57                        m_mesh.Compile(
58                                "[sc#000 scb#000"
59                                //"[sc#aaa scb#aaa"
60                                "[ad8 2 0 rx180 ty-1]"
61                                "[asph8 .5 .5 .5 ty1]"
62                                "[ac32 2 .5 .5 0 0]"
63                                "[asph6 .1 .1 .1 ty.9 tx.5 tz.15]"
64                                "[asph6 .1 .1 .1 ty.9 tx.5 tz-.15]"
65                                "[asph8 .05 .5 .05 ty.6 tz.5]"
66                                "[asph8 .05 .5 .05 ty.6 tz-.5]"
67                                "]"
68                                "[sc#fd0 scb#fd0"
69                                "[ac8 .4 .1 0 0 0 ty.25 rz-90 ty.7 tx.5]"
70                                "]"
71                                "["
72                                "[sc#fff scb#fff"
73                                "[ad8 2 0 rx180 ty-1]"
74                                "[asph8 .5 .5 .5 ty1]"
75                                "[ac32 1.9 .5 .5 0 0]"
76                                "]"
77                                " ty-.1 tx.05]"
78                                );
79                        vec3 BoxSize = vec3(.5f, 2.f, .5f);
80                        m_character.SetCollisionChannel(0, 0xFF);
81                        m_character.SetShapeToCapsule(BoxSize.x, BoxSize.y);
82                        m_character.SetMass(.0f);
83                        m_character.SetTransform(base_location, base_rotation);
84                        m_character.InitBodyToGhost();
85                        m_character.AddToSimulation(new_sim);
86                }
87        }
88
89        PhysicsObject(Simulation* new_sim, float base_mass, const vec3 &base_location, int RandValue = -1)
90                : m_ready(false), m_should_render(true), m_is_character(false)
91        {
92                Array<char const *> MeshRand;
93
94                MeshRand << "[sc#add afcb2 2 2 -.1]";
95                MeshRand << "[sc#dad afcb2 2 2 -.1]";
96                MeshRand << "[sc#dda afcb2 2 2 -.1]";
97                MeshRand << "[sc#daa afcb2 2 2 -.1]";
98                MeshRand << "[sc#ada afcb2 2 2 -.1]";
99                MeshRand << "[sc#aad afcb2 2 2 -.1]";
100
101                int SphereLimit = MeshRand.Count();
102
103                MeshRand << "[sc#add asph1 2 2 2]";
104                MeshRand << "[sc#dad asph1 2 2 2]";
105                MeshRand << "[sc#dda asph1 2 2 2]";
106                MeshRand << "[sc#daa asph1 2 2 2]";
107                MeshRand << "[sc#ada asph1 2 2 2]";
108                MeshRand << "[sc#aad asph1 2 2 2]";
109
110                int ConeLimit = MeshRand.Count();
111
112                MeshRand << "[sc#add scb#add ad1 2 0 rx180 ty-1 ac4 2 2 0 0 0]";
113                MeshRand << "[sc#dad scb#dad ad1 2 0 rx180 ty-1 ac4 2 2 0 0 0]";
114                MeshRand << "[sc#dda scb#dda ad1 2 0 rx180 ty-1 ac4 2 2 0 0 0]";
115                MeshRand << "[sc#daa scb#daa ad1 2 0 rx180 ty-1 ac4 2 2 0 0 0]";
116                MeshRand << "[sc#ada scb#ada ad1 2 0 rx180 ty-1 ac4 2 2 0 0 0]";
117                MeshRand << "[sc#aad scb#aad ad1 2 0 rx180 ty-1 ac4 2 2 0 0 0]";
118
119                int CylLimit = MeshRand.Count();
120
121                MeshRand << "[sc#add scb#add ad1 2 0 rx180 ty-1 my ac4 2 2 2 0 0]";
122                MeshRand << "[sc#dad scb#dad ad1 2 0 rx180 ty-1 my ac4 2 2 2 0 0]";
123                MeshRand << "[sc#dda scb#dda ad1 2 0 rx180 ty-1 my ac4 2 2 2 0 0]";
124                MeshRand << "[sc#daa scb#daa ad1 2 0 rx180 ty-1 my ac4 2 2 2 0 0]";
125                MeshRand << "[sc#ada scb#ada ad1 2 0 rx180 ty-1 my ac4 2 2 2 0 0]";
126                MeshRand << "[sc#aad scb#aad ad1 2 0 rx180 ty-1 my ac4 2 2 2 0 0]";
127
128                int CapsLimit = MeshRand.Count();
129
130                MeshRand << "[sc#add scb#add acap1 2 1]";
131                MeshRand << "[sc#dad scb#dad acap1 2 1]";
132                MeshRand << "[sc#dda scb#dda acap1 2 1]";
133                MeshRand << "[sc#daa scb#daa acap1 2 1]";
134                MeshRand << "[sc#ada scb#ada acap1 2 1]";
135                MeshRand << "[sc#aad scb#aad acap1 2 1]";
136
137                switch (RandValue)
138                {
139                        case 0:
140                        {
141                                RandValue = (int)(lol::RandF() * (SphereLimit - 1));
142                                break;
143                        }
144                        case 1:
145                        {
146                                RandValue = SphereLimit + (int)(lol::RandF() * ((ConeLimit - SphereLimit) - 1));
147                                break;
148                        }
149                        case 2:
150                        {
151                                RandValue = ConeLimit + (int)(lol::RandF() * ((CylLimit - ConeLimit) - 1));
152                                break;
153                        }
154                        case 3:
155                        {
156                                RandValue = CylLimit + (int)(lol::RandF() * ((CapsLimit - CylLimit) - 1));
157                                break;
158                        }
159                        case 4:
160                        {
161                                RandValue = CapsLimit + (int)(lol::RandF() * ((MeshRand.Count() - CapsLimit) - 1));
162                                break;
163                        }
164                        default:
165                        {
166                                RandValue = (int)(lol::RandF() * (MeshRand.Count() - 1));
167                        }
168                }
169
170                m_mesh.Compile(MeshRand[RandValue]);
171                vec3 BoxSize = vec3(2.0f);
172                int ColGroup = 1;
173                if (RandValue < SphereLimit)
174                {
175                        m_physics.SetShapeToBox(BoxSize);
176                        ColGroup += 0;
177                }
178                else if (RandValue < ConeLimit)
179                {
180                        m_physics.SetShapeToSphere(BoxSize.x * 2.f);
181                        ColGroup += 1;
182                }
183                else if (RandValue < CylLimit)
184                {
185                        m_physics.SetShapeToCone(BoxSize.x, BoxSize.y);
186                        ColGroup += 2;
187                }
188                else if (RandValue < CapsLimit)
189                {
190                        m_physics.SetShapeToCylinder(BoxSize);
191                        ColGroup += 3;
192                }
193                else
194                {
195                        m_physics.SetShapeToCapsule(BoxSize.x, BoxSize.y);
196                        ColGroup += 4;
197                }
198
199                m_physics.SetCollisionChannel(0, 0xFF);
200                //m_physics.SetCollisionChannel(ColGroup, (1<<ColGroup)|(1));
201                m_physics.SetMass(base_mass);
202                m_physics.SetTransform(base_location);
203                m_physics.InitBodyToRigid();
204                m_physics.AddToSimulation(new_sim);
205        }
206
207        void SetTransform(const lol::vec3& base_location, const lol::quat& base_rotation=lol::quat(lol::mat4(1.0f)))
208        {
209                if (m_is_character)
210                        m_character.SetTransform(base_location, base_rotation);
211                else
212                        m_physics.SetTransform(base_location, base_rotation);
213        }
214
215        lol::mat4 GetTransform()
216        {
217                if (m_is_character)
218                        return m_character.GetTransform();
219                else
220                        return m_physics.GetTransform();
221        }
222
223        void SetRender(bool should_render)
224        {
225                m_should_render = should_render;
226        }
227
228        EasyMesh *GetMesh() { return &m_mesh; }
229        EasyPhysic *GetPhysic() { return &m_physics; }
230        EasyPhysic *GetCharacter() { return &m_character; }
231
232        ~PhysicsObject()
233        {
234        }
235
236        char const *GetName() { return "<PhysicsObject>"; }
237
238protected:
239        virtual void TickGame(float seconds)
240        {
241                WorldEntity::TickGame(seconds);
242        }
243
244        virtual void TickDraw(float seconds)
245        {
246                WorldEntity::TickDraw(seconds);
247
248                if (!m_ready)
249                {
250                        m_mesh.MeshConvert();
251                        m_ready = true;
252                }
253
254                if (m_should_render)
255                {
256                        if (m_is_character)
257                                m_mesh.Render(m_character.GetTransform());
258                        else
259                                m_mesh.Render(m_physics.GetTransform());
260                }
261        }
262
263private:
264        //Base datas
265        EasyMesh                                m_mesh;
266        EasyPhysic                              m_physics;
267        EasyCharacterController m_character;
268
269        bool                    m_ready;
270        bool                    m_should_render;
271        bool                    m_is_character;
272};
273
274#endif /* __PHYSICOBJECT_H__ */
275
Note: See TracBrowser for help on using the repository browser.