Changeset 2425


Ignore:
Timestamp:
Feb 17, 2013, 6:03:35 PM (7 years ago)
Author:
touky
Message:

easymesh : "struct m_gpu" no longer exists and has been replaced by more simpler classes. VertexDecl&Buffer are now not created several times when using the same source datas.

Location:
trunk/src
Files:
3 edited

Legend:

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

    r2416 r2425  
    7474
    7575//-----------------------------------------------------------------------------
    76 void EasyMesh::MeshConvert(Shader* provided_shader)
    77 {
    78     for (int i = 0; i < DebugRenderMode::Max; i++)
    79     {
    80         if (i == DebugRenderMode::Default)
    81         {
    82             if(provided_shader == NULL)
    83                 m_gpu.shader << Shader::Create(LOLFX_RESOURCE_NAME(shiny));
    84             else
    85                 m_gpu.shader << provided_shader;
    86         }
    87         else if (i == DebugRenderMode::Wireframe)
    88                 m_gpu.shader << Shader::Create(LOLFX_RESOURCE_NAME(shinydebugwireframe));
    89         else if (i == DebugRenderMode::Lighting)
    90                 m_gpu.shader << Shader::Create(LOLFX_RESOURCE_NAME(shinydebuglighting));
    91         else if (i == DebugRenderMode::Normal)
    92                 m_gpu.shader << Shader::Create(LOLFX_RESOURCE_NAME(shinydebugnormal));
    93         else if (i == DebugRenderMode::UV)
    94                 m_gpu.shader << Shader::Create(LOLFX_RESOURCE_NAME(shinydebugUV));
    95 
    96         m_gpu.modelview << m_gpu.shader.Last()->GetUniformLocation("in_ModelView");
    97         m_gpu.invmodelview << m_gpu.shader.Last()->GetUniformLocation("in_Inv_ModelView");
    98         m_gpu.view << m_gpu.shader.Last()->GetUniformLocation("in_View");
    99         m_gpu.invview << m_gpu.shader.Last()->GetUniformLocation("in_Inv_View");
    100         m_gpu.proj << m_gpu.shader.Last()->GetUniformLocation("in_Proj");
    101         m_gpu.normalmat << m_gpu.shader.Last()->GetUniformLocation("in_NormalMat");
    102         m_gpu.damage << m_gpu.shader.Last()->GetUniformLocation("in_Damage");
    103         m_gpu.lights << m_gpu.shader.Last()->GetUniformLocation("u_Lights");
    104         m_gpu.coord << m_gpu.shader.Last()->GetAttribLocation("in_Vertex",
    105                                              VertexUsage::Position, 0);
    106         m_gpu.norm << m_gpu.shader.Last()->GetAttribLocation("in_Normal",
    107                                              VertexUsage::Normal, 0);
    108         m_gpu.color << m_gpu.shader.Last()->GetAttribLocation("in_Color",
    109                                              VertexUsage::Color, 0);
    110 #if VERTEX_USEAGE == VU_BONES
    111         //TODO : -- BONE SUPPORT --
    112 #elif VERTEX_USEAGE == VU_TEX_UV
    113         //UV SUPPORT --
    114         m_gpu.tex_coord << m_gpu.shader.Last()->GetAttribLocation("in_TexCoord",
    115                                               VertexUsage::TexCoord, 0);
    116 #endif
    117     }
    118 
    119 #if VERTEX_USEAGE == VU_BONES
    120         //TODO : -- BONE SUPPORT --
    121 #elif VERTEX_USEAGE == VU_TEX_UV
    122     //UV SUPPORT --
    123     m_gpu.vdecl = new VertexDeclaration(
    124         VertexStream<vec3,vec3,u8vec4,vec2>(VertexUsage::Position,
    125                                             VertexUsage::Normal,
    126                                             VertexUsage::Color,
    127                                             VertexUsage::TexCoord));
    128 
    129     Array<vec3,vec3,u8vec4,vec2> vertexlist;
    130     for (int i = 0; i < m_vert.Count(); i++)
    131         vertexlist.Push(m_vert[i].m1,
    132                         m_vert[i].m2,
    133                         (u8vec4)(m_vert[i].m3 * 255.f),
    134                         m_vert[i].m4);
    135 #else
    136     //-- VANILLA --
    137     m_gpu.vdecl = new VertexDeclaration(
    138         VertexStream<vec3,vec3,u8vec4>(VertexUsage::Position,
    139                                         VertexUsage::Normal,
    140                                         VertexUsage::Color));
    141 
    142     Array<vec3,vec3,u8vec4> vertexlist;
    143     for (int i = 0; i < m_vert.Count(); i++)
    144         vertexlist.Push(m_vert[i].m1,
    145                         m_vert[i].m2,
    146                         (u8vec4)(m_vert[i].m3 * 255.f));
    147 #endif
    148 
    149     Array<uint16_t> indexlist;
    150     for (int i = 0; i < m_indices.Count(); i += 3)
    151     {
    152         indexlist << m_indices[i + 0];
    153         indexlist << m_indices[i + 1];
    154         indexlist << m_indices[i + 2];
    155     }
    156 
    157     m_gpu.vbo = new VertexBuffer(vertexlist.Bytes());
    158     void *mesh = m_gpu.vbo->Lock(0, 0);
    159     memcpy(mesh, &vertexlist[0], vertexlist.Bytes());
    160     m_gpu.vbo->Unlock();
    161 
    162     m_gpu.ibo = new IndexBuffer(indexlist.Bytes());
    163     void *indices = m_gpu.ibo->Lock(0, 0);
    164     memcpy(indices, &indexlist[0], indexlist.Bytes());
    165     m_gpu.ibo->Unlock();
    166 
    167     m_gpu.vertexcount = vertexlist.Count();
    168     m_gpu.indexcount = indexlist.Count();
    169 }
    170 
    171 //-----------------------------------------------------------------------------
    172 void EasyMesh::Render(mat4 const &model, float damage)
    173 {
    174     DebugRenderMode d = Video::GetDebugRenderMode();
    175 
     76GpuShaderData::GpuShaderData()
     77{
     78    m_render_mode = DebugRenderMode::Default;
     79}
     80   
     81//-----------------------------------------------------------------------------
     82GpuShaderData::GpuShaderData(uint16_t vert_decl_flags, Shader* shader, DebugRenderMode render_mode)
     83{
     84    m_render_mode = render_mode;
     85    m_shader = shader;
     86    m_vert_decl_flags = vert_decl_flags;
     87}
     88
     89//-----------------------------------------------------------------------------
     90GpuShaderData::~GpuShaderData()
     91{
     92    m_shader_uniform.Empty();
     93    m_shader_attrib.Empty();
     94}
     95
     96//-----------------------------------------------------------------------------
     97void GpuShaderData::AddUniform(const lol::String &new_uniform)
     98{
     99    m_shader_uniform.Push(new_uniform, m_shader->GetUniformLocation(new_uniform.C()));
     100}
     101
     102//-----------------------------------------------------------------------------
     103void GpuShaderData::AddAttribute(const lol::String &new_attribute, VertexUsage usage, int index)
     104{
     105    m_shader_attrib.Push(new_attribute, m_shader->GetAttribLocation(new_attribute.C(), usage, index));
     106}
     107
     108//-----------------------------------------------------------------------------
     109ShaderUniform const *GpuShaderData::GetUniform(const lol::String &uniform)
     110{
     111    for (int i = 0; i < m_shader_uniform.Count(); ++i)
     112        if (m_shader_uniform[i].m1 == uniform)
     113            return &m_shader_uniform[i].m2;
     114    return NULL;
     115}
     116
     117//-----------------------------------------------------------------------------
     118ShaderAttrib const *GpuShaderData::GetAttribute(const lol::String &attribute)
     119{
     120    for (int i = 0; i < m_shader_attrib.Count(); ++i)
     121        if (m_shader_attrib[i].m1 == attribute)
     122            return &m_shader_attrib[i].m2;
     123    return NULL;
     124}
     125
     126//-----------------------------------------------------------------------------
     127DefaultShaderData::DefaultShaderData(DebugRenderMode render_mode)
     128{
     129    bool with_UV = false;
     130    m_render_mode = render_mode;
     131    m_vert_decl_flags = (VertexUsage::Position << 1) |
     132                        (VertexUsage::Normal << 1)   |
     133                        (VertexUsage::Color << 1);
     134
     135    if (render_mode == DebugRenderMode::Default)
     136        m_shader = Shader::Create(LOLFX_RESOURCE_NAME(shiny));
     137    else if (render_mode == DebugRenderMode::Wireframe)
     138        m_shader = Shader::Create(LOLFX_RESOURCE_NAME(shinydebugwireframe));
     139    else if (render_mode == DebugRenderMode::Lighting)
     140        m_shader = Shader::Create(LOLFX_RESOURCE_NAME(shinydebuglighting));
     141    else if (render_mode == DebugRenderMode::Normal)
     142        m_shader = Shader::Create(LOLFX_RESOURCE_NAME(shinydebugnormal));
     143    else if (render_mode == DebugRenderMode::UV)
     144    {
     145        m_shader = Shader::Create(LOLFX_RESOURCE_NAME(shinydebugUV));
     146        m_vert_decl_flags |= (VertexUsage::TexCoord << 1);
     147        with_UV = true;
     148    }
     149    SetupDefaultData(with_UV);
     150}
     151
     152//-----------------------------------------------------------------------------
     153DefaultShaderData::DefaultShaderData(uint16_t vert_decl_flags, Shader* shader, bool with_UV)
     154    : GpuShaderData(vert_decl_flags, shader, DebugRenderMode::Default)
     155{
     156    SetupDefaultData(with_UV);
     157}
     158
     159//-----------------------------------------------------------------------------
     160void DefaultShaderData::SetupDefaultData(bool with_UV)
     161{
     162    AddUniform("in_ModelView");
     163    AddUniform("in_Inv_ModelView");
     164    AddUniform("in_View");
     165    AddUniform("in_Inv_View");
     166    AddUniform("in_Proj");
     167    AddUniform("in_NormalMat");
     168    AddUniform("in_Damage");
     169    AddUniform("u_Lights");
     170    AddAttribute("in_Vertex", VertexUsage::Position, 0);
     171    AddAttribute("in_Normal", VertexUsage::Normal, 0);
     172    AddAttribute("in_Color",  VertexUsage::Color, 0);
     173    if (with_UV)
     174        AddAttribute("in_TexCoord", VertexUsage::TexCoord, 0);
     175}
     176
     177//-----------------------------------------------------------------------------
     178void DefaultShaderData::SetupShaderDatas(mat4 const &model)
     179{
    176180    mat4 modelview = Scene::GetDefault()->GetViewMatrix() * model;
    177181    mat3 normalmat = transpose(inverse(mat3(modelview)));
    178182
    179     m_gpu.shader[d]->Bind();
    180 
    181183    /* FIXME: this should be hidden in the shader */
    182184    /* FIXME: the 4th component of the position can be used for other things */
     185    /* FIXME: GetUniform("blabla") is costly */
    183186    Array<Light *> const lights = Scene::GetDefault()->GetLights();
    184187    Array<vec4> light_data;
     
    187190    while (light_data.Count() < 8)
    188191        light_data << vec4(0.f) << vec4(0.f);
    189     m_gpu.shader[d]->SetUniform(m_gpu.lights[d], light_data);
    190 
    191     m_gpu.shader[d]->SetUniform(m_gpu.modelview[d], modelview);
    192     m_gpu.shader[d]->SetUniform(m_gpu.invmodelview[d], inverse(modelview));
    193     m_gpu.shader[d]->SetUniform(m_gpu.view[d], Scene::GetDefault()->GetViewMatrix());
    194     m_gpu.shader[d]->SetUniform(m_gpu.invview[d], inverse(Scene::GetDefault()->GetViewMatrix()));
    195     m_gpu.shader[d]->SetUniform(m_gpu.proj[d], Scene::GetDefault()->GetProjMatrix());
    196     m_gpu.shader[d]->SetUniform(m_gpu.normalmat[d], normalmat);
    197     m_gpu.shader[d]->SetUniform(m_gpu.damage[d], damage);
    198     m_gpu.vdecl->Bind();
    199 #if VERTEX_USEAGE == VU_BONES
    200     //TODO : -- BONE SUPPORT --
    201 #elif VERTEX_USEAGE == VU_TEX_UV
    202     //UV SUPPORT --
    203     m_gpu.vdecl->SetStream(m_gpu.vbo, m_gpu.coord[d], m_gpu.norm[d], m_gpu.color[d], m_gpu.tex_coord[d]);
    204 #else
    205     //-- VANILLA --
    206     m_gpu.vdecl->SetStream(m_gpu.vbo, m_gpu.coord[d], m_gpu.norm[d], m_gpu.color[d]);
    207 #endif
    208     m_gpu.ibo->Bind();
    209     m_gpu.vdecl->DrawIndexedElements(MeshPrimitive::Triangles,
    210                                      0, 0, m_gpu.vertexcount,
    211                                      0, m_gpu.indexcount);
    212     m_gpu.ibo->Unbind();
    213     m_gpu.vdecl->Unbind();
     192    m_shader->SetUniform(*GetUniform("u_Lights"), light_data);
     193
     194    m_shader->SetUniform(*GetUniform("in_ModelView"), modelview);
     195    m_shader->SetUniform(*GetUniform("in_Inv_ModelView"), inverse(modelview));
     196    m_shader->SetUniform(*GetUniform("in_View"), Scene::GetDefault()->GetViewMatrix());
     197    m_shader->SetUniform(*GetUniform("in_Inv_View"), inverse(Scene::GetDefault()->GetViewMatrix()));
     198    m_shader->SetUniform(*GetUniform("in_Proj"), Scene::GetDefault()->GetProjMatrix());
     199    m_shader->SetUniform(*GetUniform("in_NormalMat"), normalmat);
     200    m_shader->SetUniform(*GetUniform("in_Damage"), 0);
     201}
     202
     203//-----------------------------------------------------------------------------
     204GpuEasyMeshData::GpuEasyMeshData()
     205{
     206    m_vertexcount = 0;
     207    m_indexcount = 0;
     208    m_ibo = NULL;
     209}
     210
     211//-----------------------------------------------------------------------------
     212GpuEasyMeshData::~GpuEasyMeshData()
     213{
     214    m_gpudatas.Empty();
     215    m_vdatas.Empty();
     216    if (m_ibo)
     217        delete(m_ibo);
     218}
     219
     220//-----------------------------------------------------------------------------
     221void GpuEasyMeshData::AddGpuData(GpuShaderData* gpudata, EasyMesh* src_mesh)
     222{
     223    SetupVertexData(gpudata->m_vert_decl_flags, src_mesh);
     224
     225    if (!m_ibo)
     226    {
     227        Array<uint16_t> indexlist;
     228        for (int i = 0; i < src_mesh->m_indices.Count(); i += 3)
     229        {
     230            indexlist << src_mesh->m_indices[i + 0];
     231            indexlist << src_mesh->m_indices[i + 1];
     232            indexlist << src_mesh->m_indices[i + 2];
     233        }
     234
     235        m_ibo = new IndexBuffer(indexlist.Bytes());
     236        void *indices = m_ibo->Lock(0, 0);
     237        memcpy(indices, &indexlist[0], indexlist.Bytes());
     238        m_ibo->Unlock();
     239
     240        m_indexcount = indexlist.Count();
     241    }
     242
     243    if (m_gpudatas.Count() != DebugRenderMode::Max)
     244    {
     245        m_gpudatas.Reserve(DebugRenderMode::Max);
     246        for (int i = 0; i < DebugRenderMode::Max; i++)
     247            m_gpudatas << NULL;
     248    }
     249    m_gpudatas[gpudata->m_render_mode] = gpudata;
     250}
     251
     252//-----------------------------------------------------------------------------
     253void GpuEasyMeshData::SetupVertexData(uint16_t vdecl_flags, EasyMesh* src_mesh)
     254{
     255    for (int i = 0; i < m_vdatas.Count(); ++i)
     256        if (m_vdatas[i].m1 == vdecl_flags)
     257            return;
     258
     259    VertexDeclaration* new_vdecl = NULL;
     260    VertexBuffer* new_vbo = NULL;
     261    void *vbo_data = NULL;
     262    int vbo_bytes = 0;
     263
     264#define COPY_VBO \
     265    new_vbo = new VertexBuffer(vbo_bytes); \
     266    void *mesh = new_vbo->Lock(0, 0); \
     267    memcpy(mesh, vbo_data, vbo_bytes); \
     268    new_vbo->Unlock();
     269
     270    if (vdecl_flags ==  ((VertexUsage::Position<<1) |
     271                         (VertexUsage::Normal<<1)   |
     272                         (VertexUsage::Color<<1)    |
     273                         (VertexUsage::TexCoord<<1)))
     274    {
     275        new_vdecl = new VertexDeclaration(
     276                         VertexStream<vec3,vec3,u8vec4,vec2>(
     277                          VertexUsage::Position,
     278                          VertexUsage::Normal,
     279                          VertexUsage::Color,
     280                          VertexUsage::TexCoord));
     281
     282        Array<vec3, vec3, u8vec4, vec2> vertexlist;
     283        for (int i = 0; i < src_mesh->m_vert.Count(); i++)
     284            vertexlist.Push(src_mesh->m_vert[i].m1,
     285                            src_mesh->m_vert[i].m2,
     286                            (u8vec4)(src_mesh->m_vert[i].m3 * 255.f),
     287                            src_mesh->m_vert[i].m4);
     288
     289        vbo_data = &vertexlist[0];
     290        vbo_bytes = vertexlist.Bytes();
     291        m_vertexcount = vertexlist.Count();
     292
     293        COPY_VBO;
     294    }
     295    else if (vdecl_flags ==  ((VertexUsage::Position<<1) |
     296                              (VertexUsage::Normal<<1)   |
     297                              (VertexUsage::Color<<1)))
     298    {
     299        new_vdecl = new VertexDeclaration(
     300                         VertexStream<vec3,vec3,u8vec4>(
     301                          VertexUsage::Position,
     302                          VertexUsage::Normal,
     303                          VertexUsage::Color));
     304
     305        Array<vec3,vec3,u8vec4> vertexlist;
     306        for (int i = 0; i < src_mesh->m_vert.Count(); i++)
     307            vertexlist.Push(src_mesh->m_vert[i].m1,
     308                            src_mesh->m_vert[i].m2,
     309                            (u8vec4)(src_mesh->m_vert[i].m3 * 255.f));
     310
     311        vbo_data = &vertexlist[0];
     312        vbo_bytes = vertexlist.Bytes();
     313        m_vertexcount = vertexlist.Count();
     314
     315        COPY_VBO;
     316    }
     317
     318    m_vdatas.Push(vdecl_flags, new_vdecl, new_vbo);
     319}
     320
     321//-----------------------------------------------------------------------------
     322void GpuEasyMeshData::RenderMeshData(mat4 const &model)
     323{
     324    DebugRenderMode d = Video::GetDebugRenderMode();
     325    GpuShaderData& gpu_sd = *(m_gpudatas[d]);
     326
     327    int vdecl_idx = 0;
     328    for (; vdecl_idx < m_vdatas.Count(); ++vdecl_idx)
     329        if (m_vdatas[vdecl_idx].m1 == gpu_sd.m_vert_decl_flags)
     330            break;
     331
     332    if (vdecl_idx >= m_vdatas.Count())
     333        return;
     334
     335    uint16_t vflags = m_vdatas[vdecl_idx].m1;
     336    VertexDeclaration* vdecl = m_vdatas[vdecl_idx].m2;
     337    VertexBuffer* vbo = m_vdatas[vdecl_idx].m3;
     338
     339    gpu_sd.m_shader->Bind();
     340    gpu_sd.SetupShaderDatas(model);
     341
     342    vdecl->Bind();
     343
     344    if (vflags == ((VertexUsage::Position<<1) | (VertexUsage::Normal<<1) |
     345                   (VertexUsage::Color<<1)    | (VertexUsage::TexCoord<<1)))
     346    {
     347        vdecl->SetStream(vbo, *gpu_sd.GetAttribute(lol::String("in_Vertex")),
     348                              *gpu_sd.GetAttribute(lol::String("in_Normal")),
     349                              *gpu_sd.GetAttribute(lol::String("in_Color")),
     350                              *gpu_sd.GetAttribute(lol::String("in_TexCoord")));
     351    }
     352    else if (vflags == ((VertexUsage::Position<<1) | (VertexUsage::Normal<<1) |
     353                        (VertexUsage::Color<<1)))
     354    {
     355        vdecl->SetStream(vbo, *gpu_sd.GetAttribute(lol::String("in_Vertex")),
     356                              *gpu_sd.GetAttribute(lol::String("in_Normal")),
     357                              *gpu_sd.GetAttribute(lol::String("in_Color")));
     358    }
     359
     360    m_ibo->Bind();
     361    vdecl->DrawIndexedElements(MeshPrimitive::Triangles, 0, 0, m_vertexcount, 0, m_indexcount);
     362    m_ibo->Unbind();
     363    vdecl->Unbind();
     364}
     365
     366//-----------------------------------------------------------------------------
     367void EasyMesh::MeshConvert(GpuShaderData* new_gpu_sdata)
     368{
     369    if (new_gpu_sdata)
     370    {
     371        m_gpu_data.AddGpuData(new_gpu_sdata, this);
     372        for (int i = DebugRenderMode::Default + 1; i < DebugRenderMode::Max; i++)
     373            m_gpu_data.AddGpuData(new DefaultShaderData(DebugRenderMode(i)), this);
     374    }
     375}
     376
     377//-----------------------------------------------------------------------------
     378void EasyMesh::MeshConvert(Shader* provided_shader)
     379{
     380    if (provided_shader)
     381    {
     382        GpuShaderData *new_gpu_sdata = new DefaultShaderData(((VertexUsage::Position<<1) |
     383                                                              (VertexUsage::Normal<<1) |
     384                                                              (VertexUsage::Color<<1)),
     385                                                              provided_shader,
     386                                                              false);
     387        m_gpu_data.AddGpuData(new_gpu_sdata, this);
     388    }
     389    else
     390        m_gpu_data.AddGpuData(new DefaultShaderData(DebugRenderMode::Default), this);
     391    for (int i = DebugRenderMode::Default + 1; i < DebugRenderMode::Max; i++)
     392        m_gpu_data.AddGpuData(new DefaultShaderData(DebugRenderMode(i)), this);
     393}
     394
     395//-----------------------------------------------------------------------------
     396void EasyMesh::Render(mat4 const &model, float damage)
     397{
     398    m_gpu_data.RenderMeshData(model);
    214399}
    215400
  • trunk/src/easymesh/easymesh.h

    r2418 r2425  
    2020#define VU_VANILLA 0
    2121
    22 #define VERTEX_USEAGE VU_VANILLA
     22#define VERTEX_USEAGE VU_TEX_UV
    2323
    2424#if !defined __EASYMESH_EASYMESH_H__
     
    2727namespace lol
    2828{
     29
     30//-----------------------------------------------------------------------------
     31//Base class to declare shader datas
     32class GpuShaderData
     33{
     34    friend class GpuEasyMeshData;
     35
     36protected:
     37    GpuShaderData();
     38public:
     39    //--
     40    GpuShaderData(uint16_t vert_decl_flags, Shader* shader, DebugRenderMode render_mode);
     41    ~GpuShaderData();
     42    //--
     43    void AddUniform(const lol::String &new_uniform);
     44    void AddAttribute(const lol::String &new_attribute, VertexUsage usage, int index);
     45    ShaderUniform const *GetUniform(const lol::String &uniform);
     46    ShaderAttrib const *GetAttribute(const lol::String &attribute);
     47    //--
     48    virtual void SetupShaderDatas(mat4 const &model) { }
     49
     50protected:
     51    uint16_t                            m_vert_decl_flags;
     52    Shader*                             m_shader;
     53    DebugRenderMode                     m_render_mode;
     54    Array<lol::String, ShaderUniform>   m_shader_uniform;
     55    Array<lol::String, ShaderAttrib>    m_shader_attrib;
     56};
     57
     58class DefaultShaderData : public GpuShaderData
     59{
     60public:
     61    //---
     62    DefaultShaderData(DebugRenderMode render_mode);
     63    DefaultShaderData(uint16_t vert_decl_flags, Shader* shader, bool with_UV);
     64    //---
     65    void SetupDefaultData(bool with_UV);
     66    virtual void SetupShaderDatas(mat4 const &model);
     67};
     68
     69class GpuEasyMeshData
     70{
     71public:
     72    //---
     73    GpuEasyMeshData();
     74    ~GpuEasyMeshData();
     75    //---
     76    void AddGpuData(GpuShaderData* gpudata, class EasyMesh* src_mesh);
     77    void RenderMeshData(mat4 const &model);
     78
     79private:
     80    void SetupVertexData(uint16_t vdecl_flags, EasyMesh* src_mesh);
     81
     82    Array<GpuShaderData*>               m_gpudatas;
     83    //uint16_t are the vdecl/vbo flags to avoid copy same vdecl several times.
     84    Array<uint16_t, VertexDeclaration*,
     85                    VertexBuffer*>      m_vdatas;
     86    int                                 m_vertexcount;
     87    //We only need only one ibo for the whole mesh
     88    IndexBuffer *                       m_ibo;
     89    int                                 m_indexcount;
     90};
    2991
    3092/* A safe enum for MeshCSG operations. */
     
    117179
    118180    bool Compile(char const *command);
     181    void MeshConvert(GpuShaderData* new_gpu_sdata);
    119182    void MeshConvert(Shader* ProvidedShader = NULL);
    120183    void Render(mat4 const &model, float damage = 0.f);
     
    445508    vec2 m_texcoord_scale;
    446509
    447     /* FIXME: put this in a separate class so that we can copy meshes. */
    448     struct
    449     {
    450         /* FIXME: very naughty way of handling debug render modes */
    451         Array<Shader *>shader;
    452 #if VERTEX_USEAGE == VU_BONES
    453         //TODO : -- BONE SUPPORT --
    454         Array<ShaderAttrib> coord, norm, color, bone_id, bone_weight;
    455 #elif VERTEX_USEAGE == VU_TEX_UV
    456         //-- UV SUPPORT --
    457         Array<ShaderAttrib> coord, norm, color, tex_coord;
    458 #else
    459         //-- VANILLA --
    460         Array<ShaderAttrib> coord, norm, color;
    461 #endif
    462         Array<ShaderUniform> modelview, invmodelview, view, invview, proj, normalmat, damage, lights;
    463 
    464         VertexDeclaration *vdecl;
    465         VertexBuffer *vbo;
    466         IndexBuffer *ibo;
    467         int vertexcount, indexcount;
    468     }
    469     m_gpu;
     510    friend class GpuEasyMeshData;
     511    GpuEasyMeshData m_gpu_data;
    470512};
    471513
  • trunk/src/video.h

    r2370 r2425  
    5757    m_value;
    5858
     59    inline DebugRenderMode() : m_value(Default) {}
    5960    inline DebugRenderMode(Value v) : m_value(v) {}
     61    inline DebugRenderMode(int v) : m_value((Value)v) {}
    6062    inline operator Value() { return m_value; }
    6163};
Note: See TracChangeset for help on using the changeset viewer.