Changeset 1607 for trunk/test


Ignore:
Timestamp:
Jul 9, 2012, 1:00:09 AM (8 years ago)
Author:
touky
Message:

Added walls and better context to the physics.

Location:
trunk/test
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/test/BtPhysTest.cpp

    r1605 r1607  
    7575        m_simulation->SetGravity(NewGravity);
    7676
    77         m_ground_object = new PhysicsObject(m_simulation);
    78         Ticker::Ref(m_ground_object);
    79 
    80         for (int x=0; x < 10; x++)
    81         {
    82                 for (int y=0; y < 10; y++)
    83                 {
    84                         PhysicsObject* new_physobj = new PhysicsObject(m_simulation, 10.f, vec3(0.f, 20.f, -20.0f) + vec3(.0f, 4.f * (float)y, 4.f * (float)x));
    85                         m_physobj_list << new_physobj;
    86                         Ticker::Ref(new_physobj);
     77        float offset = 30.f;
     78        vec3 pos_offset = vec3(.0f, 30.f, .0f);
     79        for (int i=0; i < 6; i++)
     80        {
     81                int idx = i/2;
     82                vec3 NewPosition = pos_offset;
     83                NewPosition[idx] += offset;
     84                offset *= -1.f;
     85
     86                quat NewRotation = quat(mat4(1.f));
     87                PhysicsObject* NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation);
     88
     89                if (idx != 1)
     90                {
     91                        vec3 axis = vec3(.0f);
     92                        axis[idx] = 1;
     93                        NewRotation = quat::rotate(90.f, axis);
     94                }
     95
     96                NewPhyobj->SetTransform(NewPosition, NewRotation);
     97                Ticker::Ref(NewPhyobj);
     98                m_ground_list << NewPhyobj;
     99        }
     100
     101        for (int x=0; x < 5; x++)
     102        {
     103                for (int y=0; y < 5; y++)
     104                {
     105                        for (int z=0; z < 4; z++)
     106                        {
     107                                PhysicsObject* new_physobj = new PhysicsObject(m_simulation, 10.f,
     108                                        vec3(-20.f, 40.f, -20.f) +
     109                                        vec3(4.f * (float)x, 4.f * (float)y, 4.f * (float)z));
     110                                m_physobj_list << new_physobj;
     111                                Ticker::Ref(new_physobj);
     112                        }
    87113                }
    88114        }
     
    243269        m_simulation->TickContext(seconds);
    244270
    245         m_camera->SetTarget(vec3(.0f));
    246         m_camera->SetPosition(vec3(-30.0f, 20.0f, .0f));
     271        vec3 barycenter = vec3(.0f);
     272        float factor = .0f;
     273        for (int i = 0; i < m_ground_list.Count(); i++)
     274        {
     275                PhysicsObject* PhysObj = m_ground_list[i];
     276
     277                mat4 GroundMat = PhysObj->GetTransform();
     278                vec3 CenterToGround = GroundMat.v3.xyz - vec3(.0f, 50.f, .0f);
     279                vec3 CenterToCam = m_camera->m_position - vec3(.0f, 50.f, .0f);
     280                if (dot(CenterToCam, CenterToGround) > .0f)
     281                        PhysObj->SetRender(false);
     282                else
     283                        PhysObj->SetRender(true);
     284
     285                barycenter += GroundMat.v3.xyz;
     286                factor += 1.f;
     287        }
     288
     289        barycenter /= factor;
     290
     291        for (int i = 0; i < m_ground_list.Count(); i++)
     292        {
     293                PhysicsObject* PhysObj = m_ground_list[i];
     294
     295                mat4 GroundMat = PhysObj->GetTransform();
     296                mat4 CenterMx = mat4::translate(barycenter);
     297                //GroundMat = inverse(CenterMx) * GroundMat;
     298                //GroundMat = CenterMx * GroundMat;
     299                                        //mat4(quat::rotate(seconds * 10.0f, vec3(0, 1, 0))) * CenterMx;
     300                //PhysObj->SetTransform(GroundMat.v3.xyz, quat(GroundMat));
     301        }
     302
     303        m_camera->SetTarget(barycenter);
     304        m_camera->SetPosition(vec3(-40.0f, 60.0f, -40.0f));
    247305
    248306#if 0
     
    323381{
    324382        Ticker::Unref(m_camera);
    325         Ticker::Unref(m_ground_object);
     383        while (m_ground_list.Count())
     384        {
     385                PhysicsObject* CurPop = m_ground_list.Last();
     386                m_ground_list.Pop();
     387                Ticker::Unref(CurPop);
     388        }
    326389        while (m_physobj_list.Count())
    327390        {
  • trunk/test/BtPhysTest.h

    r1591 r1607  
    2727        lol::phys::Simulation*                          m_simulation;
    2828        Array<PhysicsObject*>                           m_physobj_list;
    29         PhysicsObject*                                          m_ground_object;
     29        Array<PhysicsObject*>                           m_ground_list;
    3030
    3131#if 0
  • trunk/test/PhysicObject.h

    r1605 r1607  
    2222{
    2323public:
    24         PhysicsObject(Simulation* new_sim)
    25                 : m_ready(false)
     24        PhysicsObject(Simulation* new_sim, const vec3 &base_location, const quat &base_rotation)
     25                : m_ready(false), m_should_render(true)
    2626        {
    27                 m_mesh.Compile("[sc#add afcb110 1 110 -.1]");
    28                 vec3 BoxSize = vec3(110.f, 1.f, 110.f);
     27                m_mesh.Compile("[sc#add afcb60 1 60 -.1]");
     28                vec3 BoxSize = vec3(60.f, 1.f, 60.f);
    2929                m_physics.SetShapeToBox(BoxSize);
    3030                m_physics.SetMass(.0f);
     31                m_physics.SetTransform(base_location, base_rotation);
    3132                m_physics.InitBodyToRigid();
    3233                m_physics.AddToSimulation(new_sim);
     
    3435
    3536        PhysicsObject(Simulation* new_sim, float base_mass, const vec3 &base_location)
    36                 : m_ready(false)
     37                : m_ready(false), m_should_render(true)
    3738        {
    3839                Array<char *> MeshRand;
     
    9798
    9899                m_physics.SetMass(base_mass);
    99                 m_physics.SetBaseTransform(base_location);
     100                m_physics.SetTransform(base_location);
    100101                m_physics.InitBodyToRigid();
    101102                m_physics.AddToSimulation(new_sim);
     103        }
     104
     105        void SetTransform(const lol::vec3& base_location, const lol::quat& base_rotation=lol::quat(lol::mat4(1.0f)))
     106        {
     107                m_physics.SetTransform(base_location, base_rotation);
     108        }
     109
     110        lol::mat4 GetTransform()
     111        {
     112                return m_physics.GetTransform();
     113        }
     114
     115        void SetRender(bool should_render)
     116        {
     117                m_should_render = should_render;
    102118        }
    103119
     
    124140                }
    125141
    126                 m_mesh.Render(m_physics.GetTransform());
     142                if (m_should_render)
     143                        m_mesh.Render(m_physics.GetTransform());
    127144        }
    128145
     
    133150
    134151        bool                    m_ready;
     152        bool                    m_should_render;
    135153};
    136154
  • trunk/test/Physics/EasyPhysics.cpp

    r1601 r1607  
    103103//Base Location/Rotation setup
    104104//--
    105 void EasyPhysics::SetBaseTransform(const lol::vec3& base_location, const lol::quat& base_rotation)
     105void EasyPhysics::SetTransform(const lol::vec3& base_location, const lol::quat& base_rotation)
    106106{
    107107        if (m_motion_state)
    108                 m_motion_state->setWorldTransform(btTransform(LOL2BT_QUAT(base_rotation), LOL2BT_VEC3(base_location)));
     108        {
     109                if (m_mass != .0f)
     110                        m_motion_state->setWorldTransform(btTransform(LOL2BT_QUAT(base_rotation), LOL2BT_VEC3(base_location)));
     111                else
     112                {
     113                        m_rigid_body->setWorldTransform(btTransform(LOL2BT_QUAT(base_rotation), LOL2BT_VEC3(base_location)));
     114                        m_motion_state->setWorldTransform(m_rigid_body->getWorldTransform());
     115                }
     116        }
    109117        else
    110118                m_motion_state = new btDefaultMotionState(btTransform(LOL2BT_QUAT(base_rotation), LOL2BT_VEC3(base_location)));
     
    114122//Mass related functions
    115123//--
    116 
    117124//Set Shape functions
    118125void EasyPhysics::SetMass(float mass)
     
    139146        SetLocalInertia(m_mass);
    140147        if (!m_motion_state)
    141                 SetBaseTransform(vec3(.0f));
     148                SetTransform(vec3(.0f));
    142149        btRigidBody::btRigidBodyConstructionInfo NewInfos(m_mass, m_motion_state, m_collision_shape, m_local_inertia);
    143150        m_rigid_body = new btRigidBody(NewInfos);
  • trunk/test/Physics/EasyPhysics.h

    r1601 r1607  
    4343        void SetShapeToCapsule(float radius, float height);
    4444
    45         void SetBaseTransform(const lol::vec3& base_location, const lol::quat& base_rotation=lol::quat(lol::mat4(1.0f)));
     45        void SetTransform(const lol::vec3& base_location, const lol::quat& base_rotation=lol::quat(lol::mat4(1.0f)));
    4646        void SetMass(float mass);
    4747        void InitBodyToRigid();
     
    7373        void SetShapeToCapsule(float radius, float height) { }
    7474
    75         void SetBaseTransform(const lol::vec3& base_location, const lol::quat& base_rotation=lol::quat(lol::mat4(1.0f))) { }
     75        void SetTransform(const lol::vec3& base_location, const lol::quat& base_rotation=lol::quat(lol::mat4(1.0f))) { }
    7676        void SetMass(float mass) { }
    7777        void InitBodyToRigid() { }
Note: See TracChangeset for help on using the changeset viewer.