Changeset 2879 for trunk


Ignore:
Timestamp:
Sep 9, 2013, 12:30:11 AM (6 years ago)
Author:
touky
Message:

btPhysTest : Added a new test mode called "CAT_MODE". Try it out at your own risks.

Location:
trunk
Files:
1 deleted
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/easymesh/easymesh.cpp

    r2816 r2879  
    354354        COPY_VBO;
    355355    }
     356    else if (has_position && has_color && has_texcoord && has_texcoordExt && flagnb == 4)
     357    {
     358        new_vdecl = new VertexDeclaration(VertexStream<vec3,vec4,vec4>(VertexUsage::Position, VertexUsage::Color, VertexUsage::TexCoord));
     359
     360        Array<vec3, vec4, vec4> vertexlist;
     361        for (int i = 0; i < src_mesh->m_vert.Count(); i++)
     362            vertexlist.Push(src_mesh->m_vert[i].m_coord, src_mesh->m_vert[i].m_color, src_mesh->m_vert[i].m_texcoord);
     363
     364        vbo_data = &vertexlist[0];
     365        vbo_bytes = vertexlist.Bytes();
     366        m_vertexcount = vertexlist.Count();
     367
     368        COPY_VBO;
     369    }
     370    else
     371        ASSERT(!saveflags, "Vertex Declaration combination is not implemented for %s, feel free to do so.",
     372           VertexUsage::GetNameList(vflags).C());
    356373
    357374    m_vdatas.Push(vflags, new_vdecl, new_vbo);
  • trunk/src/lolcore.vcxproj

    r2841 r2879  
    9999  <ItemDefinitionGroup>
    100100    <ClCompile>
    101       <PreprocessorDefinitions>_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     101      <PreprocessorDefinitions>_LIB;%(PreprocessorDefinitions);LOL_INPUT_V2</PreprocessorDefinitions>
    102102    </ClCompile>
    103103  </ItemDefinitionGroup>
  • trunk/test/btphystest.cpp

    r2838 r2879  
    2121#include "physics/lolphysics.h"
    2222#include "physics/easyphysics.h"
     23
     24#define CAT_MODE        0
     25#define OBJ_SIZE        2.f
    2326#include "physicobject.h"
     27
    2428#include "btphystest.h"
    2529
     
    2832#define CUBE_HALF_EXTENTS .5f
    2933#define EXTRA_HEIGHT 1.f
     34#define BASE_TIME 2.f
     35#define ZERO_TIME (BASE_TIME + rand(-BASE_TIME * .4f, BASE_TIME * .4f))
     36#define ZERO_SPEED 3.5f
     37#define JUMP_HEIGHT 30.f
     38#define JUMP_STRAFE .5f
    3039
    3140int gNumObjects = 64;
    3241
     42#if CAT_MODE
     43#define USE_WALL        1
     44#define USE_BODIES      1
     45#else
    3346#define USE_WALL        1
    3447#define USE_PLATFORM    1
     
    3649#define USE_BODIES      1
    3750#define USE_ROTATION    0
    38 #define USE_CHARACTER   1
    39 #define USE_STAIRS      1
     51#define USE_CHARACTER   0
     52#define USE_STAIRS      0
     53#endif
     54
     55LOLFX_RESOURCE_DECLARE(front_camera_sprite);
    4056
    4157BtPhysTest::BtPhysTest(bool editor)
    4258{
    4359    m_loop_value = .0f;
     60
     61    g_renderer->SetAlphaFunc(AlphaFunc::Greater, 0.0);
     62
     63#if CAT_MODE
     64    /* cat datas setup */
     65    m_cat_texture = Tiler::Register("data/CatsSheet.png", ivec2(0), ivec2(0,1));
     66#endif //CAT_MODE
    4467
    4568    /* Register an input controller for the keyboard */
     
    5679    /* Create a camera that matches the settings of XNA BtPhysTest */
    5780    m_camera = new Camera();
     81#if CAT_MODE
     82    m_camera->SetView(vec3(70.f, 50.f, 0.f),
     83                      vec3(0.f, 0.f, 0.f),
     84                      vec3(0, 1, 0));
     85    m_camera->SetProjection(mat4::perspective(60.f, 1280.f, 960.f, .1f, 1000.f));
     86#else
    5887    m_camera->SetView(vec3(50.f, 50.f, 0.f),
    5988                      vec3(0.f, 0.f, 0.f),
    6089                      vec3(0, 1, 0));
    6190    m_camera->SetProjection(mat4::perspective(45.f, 1280.f, 960.f, .1f, 1000.f));
     91#endif
    6292    g_scene->PushCamera(m_camera);
    6393
     
    87117    float offset = 29.5f;
    88118    vec3 pos_offset = vec3(.0f, 30.f, .0f);
    89     if (USE_STAIRS)
     119#if USE_STAIRS
    90120    {
    91121        vec3 new_offset = vec3(1.0f, .125f, .0f);
     
    119149        }
    120150    }
    121 
    122     if (USE_WALL)
     151#endif //USE_STAIRS
     152
     153#if USE_WALL
    123154    {
    124155        for (int i=0; i < 6; i++)
     
    146177        }
    147178    }
     179#endif //USE_WALL
    148180
    149181    PhysicsObject* BasePhyobj = NULL;
    150     if (USE_PLATFORM)
     182#if USE_PLATFORM
    151183    {
    152184        quat NewRotation = quat::fromeuler_xyz(0.f, 0.f, 0.f);
     
    189221        //Ticker::Ref(NewPhyobj);
    190222    }
    191 
    192     if (USE_CHARACTER)
     223#endif //USE_PLATFORM
     224
     225#if USE_CHARACTER
    193226    {
    194227        quat NewRotation = quat::fromeuler_xyz(0.f, 0.f, 0.f);
     
    202235        //NewPhyobj->GetCharacter()->AttachTo(BasePhyobj->GetPhysic(), true, true);
    203236    }
    204 
    205     if (USE_BODIES)
     237#endif //USE_CHARACTER
     238
     239#if USE_BODIES
    206240    {
    207241        for (int x=0; x < 6; x++)
    208242        {
    209             for (int y=0; y < 6; y++)
     243            for (int y=0; y < 2; y++)
    210244            {
    211245                for (int z=0; z < 5; z++)
     
    214248                        vec3(-20.f, 15.f, -20.f) +
    215249                        vec3(8.f * (float)x, 8.f * (float)y, 8.f * (float)z));
    216                     m_physobj_list << new_physobj;
     250                    m_physobj_list.Push(new_physobj, ZERO_TIME);
    217251                    Ticker::Ref(new_physobj);
    218252                }
     
    220254        }
    221255    }
    222 
    223     if (USE_ROPE)
     256#endif //USE_BODIES
     257
     258#if USE_ROPE
    224259    {
    225260        Array<PhysicsObject*> RopeElements;
     
    230265                vec3(0.f, 0.f, 2.f * (float)i), 1);
    231266            RopeElements << new_physobj;
    232             m_physobj_list << new_physobj;
     267            m_physobj_list.Push(new_physobj, ZERO_TIME);
    233268            Ticker::Ref(new_physobj);
    234269            if (RopeElements.Count() > 1)
     
    247282        }
    248283    }
     284#endif //USE_ROPE
    249285}
    250286
     
    263299    vec3 PhysObjBarycenter = vec3(.0f);
    264300    float factor = .0f;
    265 
    266     if (USE_WALL)
     301#if CAT_MODE
     302#if USE_BODIES
     303    vec3 cam_center(0.f);
     304    float cam_factor = .0f;
     305    vec2 screen_min_max[2] = { vec2(FLT_MAX), vec2(-FLT_MAX) };
     306    vec3 cam_min_max[2] = { vec3(FLT_MAX), vec3(-FLT_MAX) };
     307    mat4 world_cam = g_scene->GetCamera()->GetView();
     308    mat4 cam_screen = g_scene->GetCamera()->GetProjection();
     309
     310    for (int i = 0; i < m_physobj_list.Count(); i++)
     311    {
     312        PhysicsObject* PhysObj = m_physobj_list[i].m1;
     313        float &Timer = m_physobj_list[i].m2;
     314
     315        vec3 obj_loc = PhysObj->GetPhysic()->GetTransform().v3.xyz;
     316
     317        cam_center += obj_loc;
     318        cam_factor += 1.f;
     319
     320        mat4 LocalPos = mat4::translate(obj_loc);
     321        vec3 vpos;
     322
     323        LocalPos = world_cam * LocalPos;
     324        vpos = LocalPos.v3.xyz;
     325        cam_min_max[0] = min(vpos.xyz, cam_min_max[0]);
     326        cam_min_max[1] = max(vpos.xyz, cam_min_max[1]);
     327
     328        LocalPos = cam_screen * LocalPos;
     329        vpos = (LocalPos.v3 / LocalPos.v3.w).xyz;
     330        screen_min_max[0] = min(vpos.xy, screen_min_max[0]);
     331        screen_min_max[1] = max(vpos.xy, screen_min_max[1]);
     332
     333        //if (length(PhysObj->GetPhysic()->GetLinearVelocity()) < ZERO_SPEED)
     334        if (lol::abs(PhysObj->GetPhysic()->GetLinearVelocity().y) < ZERO_SPEED)
     335            Timer -= seconds;
     336
     337        if (Timer < .0f)
     338        {
     339            PhysObj->GetPhysic()->AddImpulse(JUMP_HEIGHT *
     340                                             vec3(JUMP_STRAFE, 1.f, JUMP_STRAFE) *
     341                                             vec3(rand(-1.f, 1.f), 1.0f, rand(-1.f, 1.f)) *
     342                                             PhysObj->GetPhysic()->GetMass());
     343            Timer = ZERO_TIME;
     344        }
     345    }
     346
     347    vec3 min_max_diff = (cam_min_max[1] - cam_min_max[0]);
     348    float screen_size = max(max(lol::abs(min_max_diff.x), lol::abs(min_max_diff.y)),
     349                        max(    lol::abs(min_max_diff.x), lol::abs(min_max_diff.y)));
     350    float fov_ratio = max(max(lol::abs(screen_min_max[0].x), lol::abs(screen_min_max[0].y)),
     351                          max(lol::abs(screen_min_max[1].x), lol::abs(screen_min_max[1].y)));
     352
     353    //m_camera->SetProjection(mat4::perspective(30.f * fov_ratio * 1.1f, 1280.f, 960.f, .1f, 1000.f));
     354    m_camera->SetView((mat4::rotate(10.f * seconds, vec3(.0f, 1.f, .0f)) * vec4(m_camera->GetPosition(), 1.0f)).xyz,
     355                      //vec3(70.f, 30.f, 0.f),
     356                      cam_center / cam_factor, vec3(0, 1, 0));
     357#endif //USE_BODIES
     358#endif //CAT_MODE
     359
     360#if USE_WALL
    267361    {
    268362        for (int i = 0; i < m_ground_list.Count(); i++)
     
    292386        }
    293387    }
    294 
    295     if (USE_ROTATION)
     388#endif //USE_WALL
     389
     390#if USE_ROTATION
    296391    {
    297392        for (int i = 0; i < m_ground_list.Count(); i++)
     
    308403        }
    309404    }
    310 
    311     if (USE_PLATFORM)
     405#endif //USE_ROTATION
     406
     407#if USE_PLATFORM
    312408    {
    313409        for (int i = 0; i < m_platform_list.Count(); i++)
     
    330426        }
    331427    }
    332 
    333     if (USE_CHARACTER)
     428#endif //USE_PLATFORM
     429
     430#if USE_CHARACTER
    334431    {
    335432        for (int i = 0; i < m_character_list.Count(); i++)
     
    359456        }
    360457    }
    361 
    362     if (USE_CHARACTER)
     458#endif //USE_CHARACTER
     459
     460#if USE_CHARACTER
    363461    {
    364462        PhysObjBarycenter = vec3(.0f);
     
    382480#endif
    383481    }
    384     else
     482#else
    385483    {
    386484        PhysObjBarycenter = vec3(.0f);
    387485        for (int i = 0; i < m_physobj_list.Count(); i++)
    388486        {
    389             PhysicsObject* PhysObj = m_physobj_list[i];
     487            PhysicsObject* PhysObj = m_physobj_list[i].m1;
    390488            mat4 GroundMat = PhysObj->GetTransform();
    391489
     
    401499#endif
    402500    }
    403 
     501#endif //USE_CHARACTER
    404502}
    405503
     
    410508    if (!m_ready)
    411509    {
     510#if CAT_MODE
     511        /* cat datas setup */
     512        m_cat_shader = Shader::Create(LOLFX_RESOURCE_NAME(front_camera_sprite));
     513#if USE_BODIES
     514        for (int i = 0; i < m_physobj_list.Count(); i++)
     515        {
     516            PhysicsObject* PhysObj = m_physobj_list[i].m1;
     517            m_cat_sdata = new CatShaderData(((1 << VertexUsage::Position) |
     518                                                (1 << VertexUsage::Color) |
     519                                                (1 << VertexUsage::TexCoord) |
     520                                                (1 << VertexUsage::TexCoordExt)),
     521                                                m_cat_shader);
     522            m_cat_sdata->m_shader_texture = m_cat_texture->GetTexture();
     523            PhysObj->SetCustomShaderData(m_cat_sdata);
     524        }
     525#endif //USE_BODIES
     526
     527
     528#endif //CAT_MODE
     529
    412530        /* FIXME: this object never cleans up */
    413531        m_ready = true;
     
    423541    Ticker::Unref(m_light1);
    424542    Ticker::Unref(m_light2);
     543
     544#if CAT_MODE
     545    /* cat datas setup */
     546    delete(m_cat_sdata);
     547    Shader::Destroy(m_cat_shader);
     548    Tiler::Deregister(m_cat_texture);
     549#endif //CAT_MODE
    425550
    426551    while (m_constraint_list.Count())
     
    461586    while (m_physobj_list.Count())
    462587    {
    463         PhysicsObject* CurPop = m_physobj_list.Last();
     588        PhysicsObject* CurPop = m_physobj_list.Last().m1;
    464589        m_physobj_list.Pop();
    465590        CurPop->GetPhysic()->RemoveFromSimulation(m_simulation);
     
    470595}
    471596
     597//-----------------------------------------------------------------------------
     598// CShaderData
     599//-----------------------------------------------------------------------------
     600CatShaderData::CatShaderData(uint32_t vert_decl_flags, Shader* shader)
     601    : GpuShaderData(vert_decl_flags, shader, DebugRenderMode::Default)
     602{
     603    SetupDefaultData();
     604}
     605
     606//-----------------------------------------------------------------------------
     607void CatShaderData::SetupDefaultData()
     608{
     609    AddUniform("in_model_view");
     610    AddUniform("in_normal_mat");
     611    AddUniform("in_proj");
     612    AddUniform("in_texture");
     613}
     614
     615//-----------------------------------------------------------------------------
     616void CatShaderData::SetupShaderDatas(mat4 const &model)
     617{
     618    mat4 proj = g_scene->GetCamera()->GetProjection();
     619    mat4 view = g_scene->GetCamera()->GetView();
     620
     621    mat4 modelview = view * model;
     622    mat3 normalmat = transpose(inverse(mat3(view)));
     623
     624    m_shader->SetUniform(*GetUniform("in_model_view"), modelview);
     625    m_shader->SetUniform(*GetUniform("in_normal_mat"), normalmat);
     626    m_shader->SetUniform(*GetUniform("in_proj"), proj);
     627}
     628
    472629int main(int argc, char **argv)
    473630{
    474631    System::Init(argc, argv);
    475632
    476     Application app("BtPhysTest", ivec2(1280, 720), 60.0f);
     633    Application app("BtPhysTest", ivec2(1280, 960), 60.0f);
    477634
    478635    new BtPhysTest(argc > 1);
  • trunk/test/btphystest.h

    r2838 r2879  
    88#if !defined __BTPHYSTEST_H__
    99#define __BTPHYSTEST_H__
     10
     11class CatShaderData : public GpuShaderData
     12{
     13    friend class CRenderer;
     14
     15public:
     16    //---
     17    CatShaderData(uint32_t vert_decl_flags, Shader* shader);
     18    //---
     19    void SetupDefaultData();
     20    virtual void SetupShaderDatas(mat4 const &model);
     21    //--
     22    virtual lol::String GetInVertexName()   { return lol::String("in_vertex");   }
     23    virtual lol::String GetInNormalName()   { return lol::String("in_normal");   }
     24    virtual lol::String GetInColorName()    { return lol::String("in_color");    }
     25    virtual lol::String GetInTexCoordName() { return lol::String("in_texcoord"); }
     26
     27    ShaderTexture   m_shader_texture;
     28};
    1029
    1130class BtPhysTest : public WorldEntity
     
    3554    };
    3655
    37     Camera*                     m_camera;
    38     Controller *                m_controller;
    39     Light *                     m_light1;
    40     Light *                     m_light2;
    41     bool                        m_ready;
     56    TileSet*                        m_cat_texture;
     57    Shader*                         m_cat_shader;
     58    CatShaderData*                  m_cat_sdata;
     59    Camera*                         m_camera;
     60    Controller *                    m_controller;
     61    Light *                         m_light1;
     62    Light *                         m_light2;
     63    bool                            m_ready;
    4264
    43     lol::phys::Simulation*      m_simulation;
    44     Array<EasyConstraint*>      m_constraint_list;
    45     Array<PhysicsObject*>       m_physobj_list;
    46     Array<PhysicsObject*>       m_ground_list;
    47     Array<PhysicsObject*>       m_platform_list;
    48     Array<PhysicsObject*>       m_character_list;
    49     Array<PhysicsObject*>       m_stairs_list;
     65    lol::phys::Simulation*          m_simulation;
     66    Array<EasyConstraint*>          m_constraint_list;
     67    Array<PhysicsObject*, float>    m_physobj_list;
     68    Array<PhysicsObject*>           m_ground_list;
     69    Array<PhysicsObject*>           m_platform_list;
     70    Array<PhysicsObject*>           m_character_list;
     71    Array<PhysicsObject*>           m_stairs_list;
    5072
    51     float                       m_loop_value;
     73    float                           m_loop_value;
    5274};
    5375
  • trunk/test/btphystest.vcxproj

    r2788 r2879  
    7676    </None>
    7777  </ItemGroup>
     78  <ItemGroup>
     79    <LolFxCompile Include="front_camera_sprite.lolfx" />
     80  </ItemGroup>
    7881  <PropertyGroup Label="Globals">
    7982    <ProjectGuid>{ee203b88-44cf-4859-9d42-7a1f43fecb52}</ProjectGuid>
  • trunk/test/btphystest.vcxproj.filters

    r2465 r2879  
    4949    <None Include="Makefile.am" />
    5050  </ItemGroup>
     51  <ItemGroup>
     52    <LolFxCompile Include="front_camera_sprite.lolfx" />
     53  </ItemGroup>
    5154</Project>
  • trunk/test/physicobject.h

    r2816 r2879  
    2121using namespace lol::phys;
    2222
     23#if CAT_MODE
     24#define USE_SPHERE          1
     25#else
     26#define USE_BOX             1
     27#define USE_SPHERE          1
     28#define USE_CONE            1
     29#define USE_CYLINDER        1
     30#define USE_CAPSULE         1
     31#endif
     32
    2333class PhysicsObject : public WorldEntity
    2434{
    2535public:
    2636    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     {
     37        : m_ready(false), m_should_render(true), m_is_character(false), m_custom_shader(0)
     38    {
     39#if CAT_MODE
     40        m_is_phys = false;
     41#endif //CAT_MODE
    2942        m_physics = new EasyPhysic(this);
    3043
     
    4053
    4154    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     {
     55        : m_ready(false), m_should_render(true), m_is_character(false), m_custom_shader(0)
     56    {
     57#if CAT_MODE
     58        m_is_phys = false;
     59#endif //CAT_MODE
    4460        if (dummy == 1) //for platform purpose
    4561        {
     
    107123
    108124    PhysicsObject(Simulation* new_sim, float base_mass, const vec3 &base_location, int RandValue = -1)
    109         : m_ready(false), m_should_render(true), m_is_character(false)
     125        : m_ready(false), m_should_render(true), m_is_character(false), m_custom_shader(0)
    110126    {
    111127        Array<char const *> MeshRand;
    112 
     128        Array<int> MeshLimit;
     129        Array<int> MeshType;
     130
     131#if CAT_MODE
     132        m_is_phys = true;
     133#endif //CAT_MODE
     134
     135        MeshLimit << 0;
     136
     137#if USE_BOX
    113138        MeshRand << "[sc#add afcb1.7 1.7 1.7 0.4][sc#000 tsw afcb1.9 1.9 1.9 0.4 sx-1 sy-1 sz-1]";
    114139        MeshRand << "[sc#dad afcb1.7 1.7 1.7 0.4][sc#000 tsw afcb1.9 1.9 1.9 0.4 sx-1 sy-1 sz-1]";
     
    118143        MeshRand << "[sc#aad afcb1.7 1.7 1.7 0.4][sc#000 tsw afcb1.9 1.9 1.9 0.4 sx-1 sy-1 sz-1]";
    119144
    120         int SphereLimit = MeshRand.Count();
    121 
     145        MeshLimit << MeshRand.Count();
     146        MeshType << 0;
     147#endif //USE_BOX
     148
     149
     150#if USE_SPHERE
     151#if CAT_MODE
     152        int nb_sprite = 4;
     153        //SPRITE
     154        vec2 start_point = vec2((float)rand(nb_sprite), (float)rand(nb_sprite)) / vec2((float)nb_sprite);
     155        vec2 size = vec2(1.f) / vec2((float)nb_sprite);
     156        m_mesh.BD()->SetTexCoordCustomBuild(MeshType::Quad, MeshFaceType::QuadDefault,
     157                                            start_point, start_point + size);
     158        m_mesh.BD()->SetTexCoordCustomBuild2(MeshType::Quad, MeshFaceType::QuadDefault,
     159                                             vec2(-4.f), vec2(4.f));
     160        MeshRand << "[sc#ffff aq 0 0]";
     161        MeshRand << "[sc#ffff aq 0 0]";
     162        MeshRand << "[sc#ffff aq 0 0]";
     163        MeshRand << "[sc#fbbf aq 0 0]";
     164        MeshRand << "[sc#bbff aq 0 0]";
     165        MeshRand << "[sc#bfbf aq 0 0]";
     166#else
    122167        MeshRand << "[sc#add asph1 2]";
    123168        MeshRand << "[sc#dad asph1 2]";
     
    126171        MeshRand << "[sc#ada asph1 2]";
    127172        MeshRand << "[sc#aad asph1 2]";
    128 
    129         int ConeLimit = MeshRand.Count();
    130 
     173#endif
     174
     175        MeshLimit << MeshRand.Count();
     176        MeshType << 1;
     177#endif //USE_SPHERE
     178
     179#if USE_CONE
    131180        MeshRand << "[sc#add scb#add ad8 2 0 rx180 ty-1 ac8 2 2 0 0 0]";
    132181        MeshRand << "[sc#dad scb#dad ad8 2 0 rx180 ty-1 ac8 2 2 0 0 0]";
     
    136185        MeshRand << "[sc#aad scb#aad ad8 2 0 rx180 ty-1 ac8 2 2 0 0 0]";
    137186
    138         int CylLimit = MeshRand.Count();
    139 
     187        MeshLimit << MeshRand.Count();
     188        MeshType << 2;
     189#endif //USE_CONE
     190
     191#if USE_CYLINDER
    140192        MeshRand << "[sc#add scb#add ad8 2 0 rx180 ty-1 my ac8 2 2 2 0 0]";
    141193        MeshRand << "[sc#dad scb#dad ad8 2 0 rx180 ty-1 my ac8 2 2 2 0 0]";
     
    145197        MeshRand << "[sc#aad scb#aad ad8 2 0 rx180 ty-1 my ac8 2 2 2 0 0]";
    146198
    147         int CapsLimit = MeshRand.Count();
    148 
     199        MeshLimit << MeshRand.Count();
     200        MeshType << 3;
     201#endif //USE_CYLINDER
     202
     203#if USE_CAPSULE
    149204        MeshRand << "[sc#add scb#add acap1 2 1]";
    150205        MeshRand << "[sc#dad scb#dad acap1 2 1]";
     
    154209        MeshRand << "[sc#aad scb#aad acap1 2 1]";
    155210
    156         switch (RandValue)
     211        MeshLimit << MeshRand.Count();
     212        MeshType << 4;
     213#endif //USE_CAPSULE
     214
     215        int RandLimit = RandValue;
     216        if (MeshLimit.Count() <= RandValue || RandValue < 0)
     217            RandLimit = rand(MeshLimit.Count() - 1);
     218        RandValue = rand(MeshLimit[RandLimit], MeshLimit[RandLimit + 1]);
     219
     220        m_physics = new EasyPhysic(this);
     221
     222        m_mesh.Compile(MeshRand[RandValue]);
     223        m_mesh.Scale(vec3(OBJ_SIZE));
     224        vec3 BoxSize = vec3(2.0f) * OBJ_SIZE;
     225        int ColGroup = 1;
     226
     227        switch (MeshType[RandLimit])
    157228        {
    158229            case 0:
    159230            {
    160                 RandValue = rand(SphereLimit);
     231                m_physics->SetShapeToBox(BoxSize);
     232                ColGroup += 0;
    161233                break;
    162234            }
    163235            case 1:
    164236            {
    165                 RandValue = rand(SphereLimit, ConeLimit);
     237                m_physics->SetShapeToSphere(BoxSize.x);
     238                ColGroup += 1;
    166239                break;
    167240            }
    168241            case 2:
    169242            {
    170                 RandValue = rand(ConeLimit, CylLimit);
     243                m_physics->SetShapeToCone(BoxSize.x, BoxSize.y);
     244                ColGroup += 2;
    171245                break;
    172246            }
    173247            case 3:
    174248            {
    175                 RandValue = rand(CylLimit, CapsLimit);
     249                m_physics->SetShapeToCylinder(BoxSize);
     250                ColGroup += 3;
    176251                break;
    177252            }
    178253            case 4:
    179254            {
    180                 RandValue = rand(CapsLimit, MeshRand.Count());
     255                m_physics->SetShapeToCapsule(BoxSize.x, BoxSize.y);
     256                ColGroup += 4;
    181257                break;
    182258            }
    183259            default:
    184260            {
    185                 RandValue = rand(MeshRand.Count());
    186             }
    187         }
    188 
    189         m_physics = new EasyPhysic(this);
    190 
    191         m_mesh.Compile(MeshRand[RandValue]);
    192         vec3 BoxSize = vec3(2.0f);
    193         int ColGroup = 1;
    194         if (RandValue < SphereLimit)
    195         {
    196             m_physics->SetShapeToBox(BoxSize);
    197             ColGroup += 0;
    198         }
    199         else if (RandValue < ConeLimit)
    200         {
    201             m_physics->SetShapeToSphere(BoxSize.x * 2.f);
    202             ColGroup += 1;
    203         }
    204         else if (RandValue < CylLimit)
    205         {
    206             m_physics->SetShapeToCone(BoxSize.x, BoxSize.y);
    207             ColGroup += 2;
    208         }
    209         else if (RandValue < CapsLimit)
    210         {
    211             m_physics->SetShapeToCylinder(BoxSize);
    212             ColGroup += 3;
    213         }
    214         else
    215         {
    216             m_physics->SetShapeToCapsule(BoxSize.x, BoxSize.y);
    217             ColGroup += 4;
    218         }
    219 
     261            }
     262        }
     263
     264        m_physics->SetHitRestitution(1.0f);
    220265        m_physics->SetCollisionChannel(0, 0xFF);
    221266        //m_physics->SetCollisionChannel(ColGroup, (1 << ColGroup)|(1));
     
    247292    }
    248293
     294    void SetCustomShaderData(GpuShaderData* custom_shader)
     295    {
     296        m_custom_shader = custom_shader;
     297    }
     298
    249299    EasyMesh *GetMesh() { return &m_mesh; }
    250300    EasyPhysic *GetPhysic() { return m_physics; }
     
    267317        WorldEntity::TickDraw(seconds);
    268318
    269         if (!m_ready)
    270         {
    271             m_mesh.MeshConvert();
    272             m_ready = true;
    273         }
    274 
    275         if (m_should_render)
    276         {
    277             if (m_is_character)
    278                 m_mesh.Render(m_character->GetTransform());
    279             else
    280                 m_mesh.Render(m_physics->GetTransform());
     319#if CAT_MODE
     320        if (!m_is_phys || m_custom_shader)
     321#endif //CAT_MODE
     322        {
     323            if (!m_ready)
     324            {
     325                if (m_custom_shader)
     326                    m_mesh.MeshConvert(m_custom_shader);
     327                else
     328                    m_mesh.MeshConvert();
     329                m_ready = true;
     330            }
     331            else if (m_should_render)
     332            {
     333                if (m_is_character)
     334                    m_mesh.Render(m_character->GetTransform());
     335                else
     336                    m_mesh.Render(m_physics->GetTransform());
     337            }
    281338        }
    282339    }
     
    285342    //Base datas
    286343    EasyMesh                    m_mesh;
    287     EasyPhysic*                    m_physics;
     344    EasyPhysic*                 m_physics;
    288345    EasyCharacterController*    m_character;
     346    GpuShaderData*              m_custom_shader;
    289347
    290348    bool                        m_ready;
    291349    bool                        m_should_render;
    292350    bool                        m_is_character;
     351#if CAT_MODE
     352    bool                        m_is_phys;
     353#endif //CAT_MODE
    293354};
    294355
  • trunk/test/physics/easyphysics.cpp

    r2816 r2879  
    3939    m_motion_state(NULL),
    4040    m_mass(.0f),
     41    m_hit_restitution(.0f),
    4142    m_collision_group(1),
    4243    m_collision_mask(1),
     
    175176//Mass related functions
    176177//--
    177 //Set Shape functions
     178//Set Mass functions
    178179void EasyPhysic::SetMass(float mass)
    179180{
     
    183184    {
    184185        SetLocalInertia(m_mass);
    185         m_rigid_body->setMassProps(mass, m_local_inertia);
    186     }
    187 }
    188 
    189 //-------------------------------------------------------------------------
    190 //Final conversion pass functons : Body related
     186        m_rigid_body->setMassProps(m_mass, m_local_inertia);
     187    }
     188}
     189
     190//-------------------------------------------------------------------------
     191//Hit restitution functions
     192//--
     193//Set Hit Restitution functions
     194void EasyPhysic::SetHitRestitution(float hit_restitution)
     195{
     196    m_hit_restitution = hit_restitution;
     197
     198    if (m_rigid_body)
     199    {
     200        m_rigid_body->setRestitution(m_hit_restitution);
     201    }
     202}
     203
     204//-------------------------------------------------------------------------
     205//Final conversion pass functions : Body related
    191206//--
    192207
     
    201216
    202217    btRigidBody::btRigidBodyConstructionInfo NewInfos(m_mass, m_motion_state, m_collision_shape, m_local_inertia);
     218    NewInfos.m_restitution = m_hit_restitution;
    203219    m_rigid_body = new btRigidBody(NewInfos);
    204220    m_collision_object = m_rigid_body;
     
    330346}
    331347
     348//-------------------------------------------------------------------------
     349//Force/Impulse functions
     350//--
     351void EasyPhysic::AddImpulse(const lol::vec3& impulse)
     352{
     353    if (m_rigid_body)
     354        m_rigid_body->applyCentralImpulse(LOL2BT_VEC3(impulse));
     355}
     356
     357void EasyPhysic::AddImpulse(const lol::vec3& impulse, const lol::vec3& rel_pos)
     358{
     359    if (m_rigid_body)
     360        m_rigid_body->applyImpulse(LOL2BT_VEC3(impulse), LOL2BTU_VEC3(rel_pos));
     361}
     362
     363void EasyPhysic::AddImpulseTorque(const lol::vec3& torque)
     364{
     365    if (m_rigid_body)
     366        m_rigid_body->applyTorqueImpulse(LOL2BT_VEC3(torque));
     367}
     368
     369//--
     370void EasyPhysic::AddForce(const lol::vec3& force)
     371{
     372    if (m_rigid_body)
     373        m_rigid_body->applyCentralForce(LOL2BT_VEC3(force));
     374}
     375
     376void EasyPhysic::AddForce(const lol::vec3& force, const lol::vec3& rel_pos)
     377{
     378    if (m_rigid_body)
     379        m_rigid_body->applyForce(LOL2BT_VEC3(force), LOL2BTU_VEC3(rel_pos));
     380}
     381
     382void EasyPhysic::AddForceTorque(const lol::vec3& torque)
     383{
     384    if (m_rigid_body)
     385        m_rigid_body->applyTorque(LOL2BT_VEC3(torque));
     386}
     387
     388//-------------------------------------------------------------------------
     389//Movements getter
     390//--
     391lol::vec3 EasyPhysic::GetLinearVelocity() const
     392{
     393    if (m_rigid_body)
     394        return BT2LOL_VEC3(m_rigid_body->getLinearVelocity());
     395    return lol::vec3(.0f);
     396}
     397
     398lol::vec3 EasyPhysic::GetLinearForce() const
     399{
     400    if (m_rigid_body)
     401        return BT2LOL_VEC3(m_rigid_body->getTotalForce());
     402    return lol::vec3(.0f);
     403}
     404
     405lol::vec3 EasyPhysic::GetAngularVelocity() const
     406{
     407    if (m_rigid_body)
     408        return BT2LOL_VEC3(m_rigid_body->getAngularVelocity());
     409    return lol::vec3(.0f);
     410}
     411
     412lol::vec3 EasyPhysic::GetAngularForce() const
     413{
     414    if (m_rigid_body)
     415        return BT2LOL_VEC3(m_rigid_body->getTotalTorque());
     416    return lol::vec3(.0f);
     417}
     418
    332419//Set Local Inertia
    333420void EasyPhysic::SetLocalInertia(float mass)
  • trunk/test/physics/easyphysics.h

    r2816 r2879  
    5656public:
    5757    virtual void SetMass(float mass);
     58    virtual float GetMass() { return m_mass; }
     59    virtual void SetHitRestitution(float hit_restitution);
    5860    virtual void InitBodyToRigid(bool ZeroMassIsKinematic=false);
    5961    virtual void InitBodyToGhost();
     
    6163    virtual void RemoveFromSimulation(class Simulation* current_simulation);
    6264
     65    //Force/Impulse functions
     66        virtual void AddImpulse(const lol::vec3& impulse);
     67    virtual void AddImpulse(const lol::vec3& impulse, const lol::vec3& rel_pos);
     68        virtual void AddImpulseTorque(const lol::vec3& torque);
     69        virtual void AddForce(const lol::vec3& force);
     70        virtual void AddForce(const lol::vec3& force, const lol::vec3& rel_pos);
     71    virtual void AddForceTorque(const lol::vec3& torque);
     72
     73    //Movements getter
     74        lol::vec3 GetLinearVelocity() const;
     75        lol::vec3 GetLinearForce() const;
     76        lol::vec3 GetAngularVelocity() const;
     77        lol::vec3 GetAngularForce() const;
     78
    6379protected:
    6480    virtual void SetLocalInertia(float mass);
     
    6783    virtual btGhostObject* GetGhostObjectInstance();
    6884
    69     btCollisionObject*                            m_collision_object;
    70 
    71     btGhostObject*                                m_ghost_object;
     85    btCollisionObject*                          m_collision_object;
     86
     87    btGhostObject*                              m_ghost_object;
    7288
    7389    btRigidBody*                                m_rigid_body;
    74     btVector3                                    m_local_inertia;
    75 
    76     btCollisionShape*                            m_collision_shape;
    77     btConvexShape*                                m_convex_shape;
    78     btMotionState*                                m_motion_state;
     90    btVector3                                   m_local_inertia;
     91
     92    btCollisionShape*                           m_collision_shape;
     93    btConvexShape*                              m_convex_shape;
     94    btMotionState*                              m_motion_state;
    7995
    8096#else  // NO PHYSIC IMPLEMENTATION
     
    96112public:
    97113    virtual void SetMass(float mass) { }
     114    virtual float GetMass() { return .0f; }
     115    virtual void SetHitRestitution(float hit_restitution) { }
    98116    virtual void InitBodyToRigid() { }
    99117    virtual void InitBodyToGhost() { }
    100118    virtual void AddToSimulation(class Simulation* current_simulation) { }
    101119    virtual void RemoveFromSimulation(class Simulation* current_simulation) { }
     120
     121    //Force/Impulse functions
     122        virtual void AddImpulse(const lol::vec3& impulse) { }
     123    virtual void AddImpulse(const lol::vec3& impulse, const lol::vec3& rel_pos) { }
     124        virtual void AddImpulseTorque(const lol::vec3& torque) { }
     125        virtual void AddForce(const lol::vec3& force) { }
     126        virtual void AddForce(const lol::vec3& force, const lol::vec3& rel_pos) { }
     127    virtual void AddForceTorque(const lol::vec3& torque) { }
     128
     129    //Movements getter
     130    lol::vec3 GetLinearVelocity()    const { return lol::vec3(.0f); }
     131        lol::vec3 GetLinearForce()       const { return lol::vec3(.0f); }
     132        lol::vec3 GetAngularVelocity()   const { return lol::vec3(.0f); }
     133        lol::vec3 GetAngularForce()      const { return lol::vec3(.0f); }
    102134
    103135    virtual void InitBodyToGhost() { }
     
    149181
    150182protected:
    151     lol::mat4                                    m_local_to_world;
    152     float                                        m_mass;
    153     int                                            m_collision_group;
    154     int                                            m_collision_mask;
    155     WorldEntity*                                m_owner_entity;
    156     Simulation*                                    m_owner_simulation;
     183    lol::mat4                                       m_local_to_world;
     184    float                                           m_mass;
     185    float                                           m_hit_restitution;
     186    int                                             m_collision_group;
     187    int                                             m_collision_mask;
     188    WorldEntity*                                    m_owner_entity;
     189    Simulation*                                     m_owner_simulation;
    157190
    158191    //Base/Attachment logic
    159     Array<EasyPhysic*>                            m_based_physic_list;    //List of objects based on this : this object moves, its based object MoveStep with it.
    160     EasyPhysic*                                    m_base_physic;            //Base for this object : The base moves, the object moves with it.
    161     bool                                        m_base_lock_location;    //when this is TRUE, location moves with rotation change.
    162     bool                                        m_base_lock_rotation;    //when this is TRUE, rotation moves with rotation change.
     192    Array<EasyPhysic*>                              m_based_physic_list;     //List of objects based on this : this object moves, its based object MoveStep with it.
     193    EasyPhysic*                                     m_base_physic;           //Base for this object : The base moves, the object moves with it.
     194    bool                                            m_base_lock_location;    //when this is TRUE, location moves with rotation change.
     195    bool                                            m_base_lock_rotation;    //when this is TRUE, rotation moves with rotation change.
    163196
    164197    //Touch logic
    165     Array<EasyPhysic*>                            m_touching_physic;        //Maintained by ghost objects
     198    Array<EasyPhysic*>                              m_touching_physic;        //Maintained by ghost objects
    166199};
    167200
Note: See TracChangeset for help on using the changeset viewer.