source: trunk/test/PhysicObject.h @ 1764

Last change on this file since 1764 was 1764, checked in by touky, 8 years ago

Added Base/Attachment Logic, works with Kinematic & Ghost.

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