nux-1.14.0
GLVertexResourceManager.cpp
00001 /*
00002  * Copyright 2010 Inalogic® Inc.
00003  *
00004  * This program is free software: you can redistribute it and/or modify it
00005  * under the terms of the GNU Lesser General Public License, as
00006  * published by the  Free Software Foundation; either version 2.1 or 3.0
00007  * of the License.
00008  *
00009  * This program is distributed in the hope that it will be useful, but
00010  * WITHOUT ANY WARRANTY; without even the implied warranties of
00011  * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
00012  * PURPOSE.  See the applicable version of the GNU Lesser General Public
00013  * License for more details.
00014  *
00015  * You should have received a copy of both the GNU Lesser General Public
00016  * License along with this program. If not, see <http://www.gnu.org/licenses/>
00017  *
00018  * Authored by: Jay Taoko <jaytaoko@inalogic.com>
00019  *
00020  */
00021 
00022 
00023 #include "GLResource.h"
00024 #include "GLResourceManager.h"
00025 #include "GLDeviceObjects.h"
00026 #include "GpuDevice.h"
00027 #include "GLVertexResourceManager.h"
00028 #include "GraphicsEngine.h"
00029 
00030 namespace nux
00031 {
00032   NUX_IMPLEMENT_OBJECT_TYPE(VertexBuffer);
00033   NUX_IMPLEMENT_OBJECT_TYPE(IndexBuffer);
00034   NUX_IMPLEMENT_OBJECT_TYPE(VertexDeclaration);
00035   NUX_IMPLEMENT_OBJECT_TYPE(MeshBuffer);
00036   
00037   NUX_IMPLEMENT_OBJECT_TYPE(CachedVertexBuffer);
00038   NUX_IMPLEMENT_OBJECT_TYPE(CachedIndexBuffer);
00039   NUX_IMPLEMENT_OBJECT_TYPE(CachedVertexDeclaration);
00040   NUX_IMPLEMENT_OBJECT_TYPE(CachedMeshBuffer);
00041 
00042   VertexBuffer::VertexBuffer()
00043   {
00044     _Stride = 0;
00045   }
00046 
00047   VertexBuffer::~VertexBuffer()
00048   {
00049     _Data.clear();
00050   }
00051 
00052   VertexBuffer::VertexBuffer (int num_element, int size)
00053   {
00054     Allocate (num_element, size);
00055   }
00056 
00058   VertexBuffer::VertexBuffer (const VertexBuffer &Other)
00059   {
00060     _Data = Other._Data;
00061     _Stride = Other._Stride;
00062   }
00063 
00065   VertexBuffer &VertexBuffer::operator = (const VertexBuffer &Other)
00066   {
00067     _Data = Other._Data;
00068     _Stride = Other._Stride;
00069     return *this;
00070   }
00071 
00072   void VertexBuffer::Allocate(int num_element, int size)
00073   {
00074     nuxAssert(num_element > 0);
00075     nuxAssert(size > 0);
00076 
00077     if((size <= 0) || (num_element <= 0))
00078     {
00079       _Data.clear();
00080       _Stride = 0;
00081       return;
00082     }
00083 
00084     // Make sure Size is a multiple of Stride
00085     int sz = size * num_element;
00086     _Stride = size;
00087 
00088     _Data.clear();
00089     _Data.resize(sz);
00090   }
00091 
00092   int VertexBuffer::GetSize() const
00093   {
00094     return _Data.size();
00095   }
00096 
00097   int VertexBuffer::GetStride() const
00098   {
00099     return _Stride;
00100   }
00101 
00102   int VertexBuffer::GetNumElement() const
00103   {
00104     return _Data.size() / _Stride;
00105   }
00106 
00107   const void* VertexBuffer::GetPtrRawData() const
00108   {
00109     if (_Data.size() == 0)
00110       return 0;
00111 
00112     return NUX_STATIC_CAST (const void*, &_Data[0]);
00113   }
00114 
00115   void* VertexBuffer::GetPtrRawData()
00116   {
00117     if (_Data.size() == 0)
00118       return 0;
00119 
00120     return NUX_CONST_CAST(void*, ((NUX_CONST_CAST (const VertexBuffer *, this))->GetPtrRawData()));
00121   }
00122 
00123   IndexBuffer::IndexBuffer()
00124   {
00125     _Stride = 0;
00126   }
00127 
00128   IndexBuffer::~IndexBuffer()
00129   {
00130     _Data.clear();
00131   }
00132 
00133   IndexBuffer::IndexBuffer(int num_element, int size)
00134   {
00135     Allocate(num_element, size);
00136   }
00137 
00139   IndexBuffer::IndexBuffer(const IndexBuffer &Other)
00140   {
00141     _Data = Other._Data;
00142     _Stride = Other._Stride;
00143   }
00144 
00146   IndexBuffer &IndexBuffer::operator = (const IndexBuffer &Other)
00147   {
00148     _Data = Other._Data;
00149     _Stride = Other._Stride;
00150     return *this;
00151   }
00152 
00153   void IndexBuffer::Allocate(int num_index, int size)
00154   {
00155     nuxAssert(num_index > 0);
00156     nuxAssert(size > 0);
00157     nuxAssert((size == 2) || (size == 4));
00158 
00159     if((size <= 0) || (num_index <= 0))
00160     {
00161       _Data.clear();
00162       _Stride = 0;
00163       return;
00164     }
00165 
00166     _num_index = num_index;
00167     // Make sure Size is a multiple of Stride
00168     int sz = _num_index * size;
00169     _Stride = size;
00170 
00171     _Data.clear();
00172     _Data.resize(sz);
00173   }
00174 
00175   int IndexBuffer::GetSize() const
00176   {
00177     return _Data.size();
00178   }
00179 
00180   int IndexBuffer::GetStride() const
00181   {
00182     return _Stride;
00183   }
00184 
00185   int IndexBuffer::GetNumIndex() const
00186   {
00187     return _num_index;
00188   }
00189 
00190   const void* IndexBuffer::GetPtrRawData() const
00191   {
00192     return NUX_STATIC_CAST (const void*, &_Data[0]);
00193   }
00194 
00195   void* IndexBuffer::GetPtrRawData()
00196   {
00197     return NUX_CONST_CAST (void*, ((NUX_CONST_CAST (const IndexBuffer *, this) )->GetPtrRawData()));
00198   }
00199 
00200   VertexDeclaration::VertexDeclaration()
00201   {
00202     _declaration.clear();
00203   }
00204 
00205   VertexDeclaration::~VertexDeclaration()
00206   {
00207     _declaration.clear();
00208   }
00209 
00210   void VertexDeclaration::AddVertexComponent(VERTEXELEMENT Component)
00211   {
00212     _declaration.push_back(Component);
00213   }
00214 
00215 
00216 //   NMeshComponent::NMeshComponent()
00217 //     :   _Type (ATTRIB_DECLTYPE_UNKNOWN)
00218 //     ,   _StreamIndex (-1)
00219 //     ,   _Offset (0)
00220 //   {
00221 //   }
00222 // 
00223 //   NMeshComponent::NMeshComponent (const NMeshComponent &Other)
00224 //     :   _Type (ATTRIB_DECLTYPE_UNKNOWN)
00225 //     ,   _StreamIndex (-1)
00226 //     ,   _Offset (0)
00227 //   {
00228 //     _Type = Other._Type;
00229 //     _Offset = Other._Offset;
00230 //     _StreamIndex = Other._StreamIndex;
00231 //   }
00232 // 
00233 //   NMeshComponent::NMeshComponent (int StreamIndex/*ObjectPtr<VertexBuffer> VtxBuffer*/, int Offset, ATTRIB_DECL_TYPE Type)
00234 //   {
00235 //     nuxAssert (Offset >= 0);
00236 //     _Type = Type;
00237 //     _Offset = Offset;
00238 //     _StreamIndex = StreamIndex;
00239 //   }
00240 // 
00241 //   NMeshComponent::~NMeshComponent()
00242 //   {
00243 //   }
00244 // 
00245 //   NMeshComponent &NMeshComponent::operator = (const NMeshComponent &Other)
00246 //   {
00247 //     _Type = Other._Type;
00248 //     _Offset = Other._Offset;
00249 //     _StreamIndex = Other._StreamIndex;
00250 //     return *this;
00251 //   }
00252 // 
00253 //   int NMeshComponent::GetStreamIndex() const
00254 //   {
00255 //     return _StreamIndex;
00256 //   }
00257 // 
00258 // // int NMeshComponent::GetStride()
00259 // // {
00260 // //     return _VtxBuffer->GetStride();
00261 // // }
00262 // 
00263 //   int NMeshComponent::GetOffset()
00264 //   {
00265 //     return _Offset;
00266 //   }
00267 
00268   CachedVertexBuffer::CachedVertexBuffer (NResourceSet *ResourceManager, VertexBuffer *SourceVtxBuffer)
00269     :   CachedResourceData (ResourceManager)
00270     ,   _Size (0)
00271     ,   _Stride(0)
00272   {
00273     UpdateResource(SourceVtxBuffer);
00274   }
00275 
00276   CachedVertexBuffer::~CachedVertexBuffer()
00277   {
00278     // Not necessary for a smart pointer but do it anyway to be clear;
00279     _vertex_buffer = ObjectPtr<IOpenGLVertexBuffer> (0);
00280   }
00281 
00282   bool CachedVertexBuffer::UpdateResource(ResourceData *Source)
00283   {
00284     if(Source == 0)
00285     {
00286       _Stride = 0;
00287       _vertex_buffer.Release();
00288       return true;
00289     }
00290 
00291     VertexBuffer *SourceVtxBuffer = 0;
00292     nuxAssert(Source->Type().IsDerivedFromType(VertexBuffer::StaticObjectType));
00293 
00294     if(Source->Type().IsDerivedFromType(VertexBuffer::StaticObjectType))
00295     {
00296       SourceVtxBuffer = NUX_STATIC_CAST(VertexBuffer *, Source);
00297     }
00298     else
00299     {
00300       return false;
00301     }
00302 
00303     if((SourceVtxBuffer->GetSize() == 0) || (SourceVtxBuffer->GetStride() == 0))
00304     {
00305       _Stride = 0;
00306       _vertex_buffer.Release();
00307       return true;
00308     }
00309 
00310     if(_Size != SourceVtxBuffer->GetSize())
00311     {
00312       // The current size of the cached buffer is not the same as the requested one.
00313       // Delete the previously allocated buffer and create a new one.
00314       _Size = SourceVtxBuffer->GetSize();
00315       _Stride = SourceVtxBuffer->GetStride();
00316 
00317       //Release the previous vertex buffer if any.
00318       _vertex_buffer.Release();
00319       _vertex_buffer = GetGraphicsDisplay()->GetGpuDevice()->CreateVertexBuffer(_Size, VBO_USAGE_DYNAMIC);
00320       LoadVertexData(SourceVtxBuffer);
00321     }
00322     else
00323     {
00324       // The buffer size has changed. Delete the previously allocated buffer and create a new one.
00325       _Stride = SourceVtxBuffer->GetStride();
00326       LoadVertexData(SourceVtxBuffer);
00327     }
00328 
00329     return true;
00330   }
00331 
00332   void CachedVertexBuffer::LoadVertexData(VertexBuffer *SourceVtxBuffer)
00333   {
00334     if((SourceVtxBuffer == 0) || (SourceVtxBuffer->GetSize() == 0) || (SourceVtxBuffer->GetStride() == 0))
00335     {
00336       return;
00337     }
00338 
00339     t_byte *pData;
00340 
00341     _vertex_buffer->Lock(0, 0, (void **) &pData);
00342     Memcpy(pData, SourceVtxBuffer->GetPtrRawData(), SourceVtxBuffer->GetSize());
00343     _vertex_buffer->Unlock();
00344   }
00345 
00346   int CachedVertexBuffer::GetElementSize() const
00347   {
00348     return _Size;
00349   }
00350 
00351   int CachedVertexBuffer::GetBufferStride() const
00352   {
00353     return _Stride;
00354   }
00355 
00356   CachedIndexBuffer::CachedIndexBuffer (NResourceSet *ResourceManager, IndexBuffer *SourceIdxBuffer)
00357     :   CachedResourceData (ResourceManager)
00358     ,   _Size(0)
00359     ,   _Stride(0)
00360   {
00361     UpdateResource(SourceIdxBuffer);
00362   }
00363 
00364   CachedIndexBuffer::~CachedIndexBuffer()
00365   {
00366     // Not necessary for a smart pointer but do it anyway to be clear;
00367     _index_buffer = ObjectPtr<IOpenGLIndexBuffer> (0);
00368   }
00369 
00370   bool CachedIndexBuffer::UpdateResource (ResourceData *Source)
00371   {
00372     if (Source == 0)
00373     {
00374       _Size = 0;
00375       _Stride = 0;
00376       _index_buffer.Release();
00377       return true;
00378     }
00379 
00380     IndexBuffer *SourceIdxBuffer = 0;
00381     nuxAssert (Source->Type().IsDerivedFromType (IndexBuffer::StaticObjectType) );
00382 
00383     if (Source->Type().IsDerivedFromType (IndexBuffer::StaticObjectType) )
00384     {
00385       SourceIdxBuffer = NUX_STATIC_CAST (IndexBuffer *, Source);
00386     }
00387     else
00388     {
00389       return false;
00390     }
00391 
00392     if ( (SourceIdxBuffer->GetSize() == 0) || (SourceIdxBuffer->GetStride() == 0) )
00393     {
00394       _Size = 0;
00395       _Stride = 0;
00396       _index_buffer.Release();
00397       return true;
00398     }
00399 
00400     if (_Size != SourceIdxBuffer->GetSize() )
00401     {
00402       _Size = SourceIdxBuffer->GetSize();
00403       _Stride = SourceIdxBuffer->GetStride();
00404 
00405       //Release the previous vertex buffer if any.
00406       _index_buffer.Release();
00407       _index_buffer = GetGraphicsDisplay()->GetGpuDevice()->CreateIndexBuffer (_Size, VBO_USAGE_DYNAMIC,
00408                     (SourceIdxBuffer->GetStride() == 2) ? INDEX_FORMAT_USHORT : INDEX_FORMAT_UINT);
00409       LoadIndexData (SourceIdxBuffer);
00410     }
00411     else
00412     {
00413       _Stride = SourceIdxBuffer->GetStride();
00414       LoadIndexData (SourceIdxBuffer);
00415     }
00416 
00417     _num_index = SourceIdxBuffer->GetNumIndex();
00418 
00419     return true;
00420   }
00421 
00422   void CachedIndexBuffer::LoadIndexData (IndexBuffer *SourceIdxBuffer)
00423   {
00424     if ( (SourceIdxBuffer == 0) || (SourceIdxBuffer->GetSize() == 0) || (SourceIdxBuffer->GetStride() == 0) )
00425     {
00426       return;
00427     }
00428 
00429     t_byte *pData;
00430     _index_buffer->Lock (0, 0, (void **) &pData);
00431     Memcpy (pData, SourceIdxBuffer->GetPtrRawData(), SourceIdxBuffer->GetSize() );
00432     _index_buffer->Unlock();
00433   }
00434 
00435   int CachedIndexBuffer::GetElementSize() const
00436   {
00437     return _Size;
00438   }
00439 
00440   int CachedIndexBuffer::GetBufferStride() const
00441   {
00442     return _Stride;
00443   }
00444 
00445   int CachedIndexBuffer::GetNumIndex() const
00446   {
00447     return _num_index;
00448   }
00449 
00450   CachedVertexDeclaration::CachedVertexDeclaration (NResourceSet *ResourceManager, VertexDeclaration *SourceVertexDeclaration)
00451     :   CachedResourceData (ResourceManager)
00452   {
00453     UpdateResource (SourceVertexDeclaration);
00454   }
00455 
00456   CachedVertexDeclaration::~CachedVertexDeclaration()
00457   {
00458     _declaration = ObjectPtr<IOpenGLVertexDeclaration> (0);
00459   }
00460 
00461   bool CachedVertexDeclaration::UpdateResource (ResourceData *Source)
00462   {
00463     if (Source == 0)
00464     {
00465       _declaration = ObjectPtr<IOpenGLVertexDeclaration> (0);
00466       return true;
00467     }
00468 
00469     VertexDeclaration *SourceVertexDeclaration = 0;
00470     nuxAssert (Source->Type().IsDerivedFromType (VertexDeclaration::StaticObjectType) );
00471 
00472     if (Source->Type().IsDerivedFromType (VertexDeclaration::StaticObjectType) )
00473     {
00474       SourceVertexDeclaration = NUX_STATIC_CAST (VertexDeclaration *, Source);
00475     }
00476     else
00477     {
00478       return false;
00479     }
00480 
00481     if (SourceVertexDeclaration == 0)
00482     {
00483       _declaration = ObjectPtr<IOpenGLVertexDeclaration> (0);
00484       return true;
00485     }
00486 
00487     _declaration = GetGraphicsDisplay()->GetGpuDevice()->CreateVertexDeclaration (&SourceVertexDeclaration->_declaration[0]);
00488     return true;
00489   }
00490 
00491   MeshBuffer::MeshBuffer(NUX_FILE_LINE_DECL)
00492   {
00493     _vertex_buffer = 0;
00494     _index_buffer = 0;
00495     _vertex_declaration = 0;
00496   }
00497 
00498   MeshBuffer::~MeshBuffer()
00499   {
00500     if(_vertex_buffer)
00501       _vertex_buffer->UnReference();
00502     if(_index_buffer)
00503       _index_buffer->UnReference();
00504     if(_vertex_declaration)
00505       _vertex_declaration->UnReference();
00506   }
00507 
00508   bool MeshBuffer::Update(const MeshData* mesh_data)
00509   {
00510     int num_element = mesh_data->_num_element;
00511     int element_size = mesh_data->_element_size;
00512 
00513     _mesh_primitive_type = mesh_data->_mesh_primitive_type;
00514 
00515     _vertex_buffer = new VertexBuffer();
00516     _vertex_buffer->Allocate(num_element, element_size);
00517     memcpy(_vertex_buffer->GetPtrRawData(), mesh_data->_vertex_data, num_element * element_size);
00518 
00519     int num_index = mesh_data->_num_index;
00520     int index_size = mesh_data->_index_size;
00521 
00522     _index_buffer = new IndexBuffer();
00523     _index_buffer->Allocate(num_index, index_size);
00524     memcpy(_index_buffer->GetPtrRawData(), mesh_data->_index_data, num_index * index_size);
00525 
00526     _vertex_declaration = new VertexDeclaration();
00527 
00528     VERTEXELEMENT ve_position(0, 0, ATTRIB_CT_FLOAT, 4, 36);
00529 
00530     VERTEXELEMENT ve_normal(0, 16, ATTRIB_CT_FLOAT, 3, 36);
00531 
00532     VERTEXELEMENT ve_texcoord(0, 28, ATTRIB_CT_FLOAT, 2, 36);
00533 
00534     _vertex_declaration->AddVertexComponent(ve_position);
00535     _vertex_declaration->AddVertexComponent(ve_normal);
00536     _vertex_declaration->AddVertexComponent(ve_texcoord);
00537     _vertex_declaration->AddVertexComponent(DECL_END);
00538 
00539     return true;
00540   }
00541 
00542   CachedMeshBuffer::CachedMeshBuffer(NResourceSet* ResourceManager, MeshBuffer* resource)
00543   : CachedResourceData(ResourceManager)
00544   {
00545     UpdateResource(resource);
00546   }
00547 
00548   CachedMeshBuffer::~CachedMeshBuffer()
00549   {
00550   }
00551 
00552   bool CachedMeshBuffer::UpdateResource(ResourceData* source)
00553   {
00554     nuxAssert(source->Type().IsDerivedFromType(MeshBuffer::StaticObjectType));
00555 
00556     MeshBuffer* mesh_buffer = NUX_STATIC_CAST(MeshBuffer*, source);
00557 
00558     _cached_vertex_buffer = GetGraphicsDisplay()->GetGraphicsEngine()->CacheResource(mesh_buffer->_vertex_buffer);
00559     _cached_index_buffer = GetGraphicsDisplay()->GetGraphicsEngine()->CacheResource(mesh_buffer->_index_buffer);
00560     _cached_vertex_declaration = GetGraphicsDisplay()->GetGraphicsEngine()->CacheResource(mesh_buffer->_vertex_declaration);
00561     _cached_vertex_declaration->_declaration->SetVertexBuffer(0, _cached_vertex_buffer->_vertex_buffer);
00562     _cached_vertex_declaration->_declaration->SetVertexBuffer(1, _cached_vertex_buffer->_vertex_buffer);
00563     _cached_vertex_declaration->_declaration->SetVertexBuffer(2, _cached_vertex_buffer->_vertex_buffer);
00564 
00565     _mesh_primitive_type = mesh_buffer->_mesh_primitive_type;
00566 //       
00567     return true;
00568   }
00569 
00570 
00571 //   NMesh::NMesh()
00572 //   {
00573 // 
00574 //   }
00575 // 
00576 //   NMesh::~NMesh()
00577 //   {
00578 // 
00579 //   }
00580 // 
00581 // 
00582 //   NStaticMesh::NStaticMesh (NMeshObject *Object)
00583 //   {
00584 //     if (Object == 0)
00585 //       return;
00586 //   }
00587 // 
00588 //   NStaticMesh::~NStaticMesh()
00589 //   {
00590 //     delete m_pVertexDeclaration;
00591 //     delete m_pIndex;
00592 // 
00593 //     for (int i = 0; i < (int) m_pVertexStreamArray.size(); i++)
00594 //     {
00595 //       delete m_pVertexStreamArray[i];
00596 //     }
00597 //   }
00598 // 
00599 //   int NStaticMesh::GetNumStreams() const
00600 //   {
00601 //     return (int) m_pVertexStreamArray.size();
00602 //   }
00603 // 
00604 //   NGLStaticMesh::NGLStaticMesh (NResourceSet *ResourceManager, NStaticMesh *StaticMesh)
00605 //     :   CachedResourceData (ResourceManager)
00606 //   {
00607 //     int NumStreams = StaticMesh->GetNumStreams();
00608 // 
00609 //     for (int s = 0; s < NumStreams; s++)
00610 //     {
00611 //       m_VertexBufferArray.push_back (GetGraphicsDisplay()->GetGraphicsEngine()->CacheResource (StaticMesh->m_pVertexStreamArray[s]) );
00612 //     }
00613 // 
00614 //     m_Index = ObjectPtr<CachedIndexBuffer> (GetGraphicsDisplay()->GetGraphicsEngine()->CacheResource (StaticMesh->m_pIndex));
00615 //     m_VertexDeclaration = ObjectPtr<CachedVertexDeclaration> (GetGraphicsDisplay()->GetGraphicsEngine()->CacheResource (StaticMesh->m_pVertexDeclaration));
00616 //   }
00617 // 
00618 //   NGLStaticMesh::~NGLStaticMesh()
00619 //   {
00620 // 
00621 //   }
00622 // 
00623 //   bool NGLStaticMesh::UpdateResource (ResourceData *Source)
00624 //   {
00625 //     if (Source == 0)
00626 //     {
00627 //       int NumStreams = m_VertexBufferArray.size();
00628 // 
00629 //       for (int s = 0; s < NumStreams; s++)
00630 //       {
00631 //         m_VertexBufferArray[s]->UpdateResource (0);
00632 //       }
00633 // 
00634 //       m_Index->UpdateResource (0);
00635 //       m_VertexDeclaration->UpdateResource (0);
00636 //       return true;
00637 //     }
00638 // 
00639 //     NStaticMesh *StaticMesh = 0;
00640 //     nuxAssert (Source->Type().IsDerivedFromType (NStaticMesh::StaticObjectType) );
00641 // 
00642 //     if (Source->Type().IsDerivedFromType (NStaticMesh::StaticObjectType) )
00643 //     {
00644 //       StaticMesh = NUX_STATIC_CAST (NStaticMesh *, Source);
00645 //     }
00646 //     else
00647 //     {
00648 //       return false;
00649 //     }
00650 // 
00651 //     int NumStreams = StaticMesh->GetNumStreams();
00652 // 
00653 //     for (int s = 0; s < NumStreams; s++)
00654 //     {
00655 //       GetGraphicsDisplay()->GetGraphicsEngine()->UpdateResource (StaticMesh->m_pVertexStreamArray[s]);
00656 //     }
00657 // 
00658 //     GetGraphicsDisplay()->GetGraphicsEngine()->UpdateResource (StaticMesh->m_pIndex);
00659 //     GetGraphicsDisplay()->GetGraphicsEngine()->UpdateResource (StaticMesh->m_pVertexDeclaration);
00660 //     return true;
00661 //   }
00662 
00663 
00664 // static void sWriteFloat(float** Ptr, float a, float b, float c, float d)
00665 // {
00666 //     *Ptr[0] = a; *Ptr[1] = b; *Ptr[2] = c; *Ptr[3] = d;
00667 //     *Ptr += 4;
00668 // }
00669 
00670 // NStaticMesh::NStaticMesh()
00671 // {
00672 //
00673 // }
00674 //
00675 //
00676 // NCubeVertexBuffer::NCubeVertexBuffer()
00677 // {
00678 //     VERTEXELEMENT decl [] =
00679 //     {
00680 //         {0/*Stream*/, 0/*Offset*/, ATTRIB_CT_FLOAT/*Type*/, 4/*NumComponent*/, ATTRIB_USAGE_DECL_POSITION/*Usage*/, 0/*UsageIndex*/, 0 /*CgParameter*/},
00681 //         DECL_END
00682 //     };
00683 //     INT i = 0;
00684 //     while(decl[i].Stream != 0xFF)
00685 //     {
00686 //         _DeclarationsArray.push_back(decl[i]);
00687 //         i++;
00688 //     }
00689 //
00690 //
00691 //     //          4+------+7
00692 //     //          /|     /|
00693 //     //         / |    / |        y
00694 //     //        / 5+---/--+6       |
00695 //     //      0+------+3 /         |
00696 //     //       | /    | /          *---x
00697 //     //       |/     |/          /
00698 //     //      1+------+2         /
00699 //     //                        z
00700 //
00701 //     float width_    = 1.0f;
00702 //     float height_   = 1.0f;
00703 //     float depth_    = 1.0f;
00704 //     float w_        = 1.0f;
00705 //
00706 //     Vector4 v0, v1, v2;
00707 //     // Front
00708 //     v0 = Vector4(-width_/2.0f, height_/2.0f, depth_/2.0f, w_);       // 0
00709 //     v1 = Vector4(-width_/2.0f, -height_/2.0f, depth_/2.0f, w_);      // 1
00710 //     v2 = Vector4(width_/2.0f, -height_/2.0f, depth_/2.0f, w_);       // 2
00711 //     m_Vertex.push_back(v0); m_Vertex.push_back(v1); m_Vertex.push_back(v2);
00712 //
00713 //     v0 = Vector4(-width_/2.0f, height_/2.0f, depth_/2.0f, w_);       // 0
00714 //     v1 = Vector4(width_/2.0f, -height_/2.0f, depth_/2.0f, w_);       // 2
00715 //     v2 = Vector4(width_/2.0f, height_/2.0f, depth_/2.0f, w_);        // 3
00716 //     m_Vertex.push_back(v0); m_Vertex.push_back(v1); m_Vertex.push_back(v2);
00717 //
00718 //     // Back
00719 //     v0 = Vector4(width_/2.0f, height_/2.0f, -depth_/2.0f, w_);       // 7
00720 //     v1 = Vector4(width_/2.0f, -height_/2.0f, -depth_/2.0f, w_);      // 6
00721 //     v2 = Vector4(-width_/2.0f, -height_/2.0f, -depth_/2.0f, w_);     // 5
00722 //     m_Vertex.push_back(v0); m_Vertex.push_back(v1); m_Vertex.push_back(v2);
00723 //
00724 //     v0 = Vector4(width_/2.0f, height_/2.0f, -depth_/2.0f, w_);       // 7
00725 //     v1 = Vector4(-width_/2.0f, -height_/2.0f, -depth_/2.0f, w_);     // 5
00726 //     v2 = Vector4(-width_/2.0f, height_/2.0f, -depth_/2.0f, w_);      // 4
00727 //     m_Vertex.push_back(v0); m_Vertex.push_back(v1); m_Vertex.push_back(v2);
00728 //
00729 //     // Top
00730 //     v0 = Vector4(-width_/2.0f, height_/2.0f, -depth_/2.0f, w_);      // 4
00731 //     v1 = Vector4(-width_/2.0f, height_/2.0f, depth_/2.0f, w_);       // 0
00732 //     v2 = Vector4(width_/2.0f, height_/2.0f, depth_/2.0f, w_);        // 3
00733 //     m_Vertex.push_back(v0); m_Vertex.push_back(v1); m_Vertex.push_back(v2);
00734 //
00735 //     v0 = Vector4(-width_/2.0f, height_/2.0f, -depth_/2.0f, w_);      // 4
00736 //     v1 = Vector4(width_/2.0f, height_/2.0f, depth_/2.0f, w_);        // 3
00737 //     v2 = Vector4(width_/2.0f, height_/2.0f, -depth_/2.0f, w_);       // 7
00738 //     m_Vertex.push_back(v0); m_Vertex.push_back(v1); m_Vertex.push_back(v2);
00739 //
00740 //     // Bottom
00741 //     v0 = Vector4(width_/2.0f, -height_/2.0f, -depth_/2.0f, w_);      // 6
00742 //     v1 = Vector4(width_/2.0f, -height_/2.0f, depth_/2.0f, w_);       // 2
00743 //     v2 = Vector4(-width_/2.0f, -height_/2.0f, depth_/2.0f, w_);      // 1
00744 //     m_Vertex.push_back(v0); m_Vertex.push_back(v1); m_Vertex.push_back(v2);
00745 //
00746 //     v0 = Vector4(width_/2.0f, -height_/2.0f, -depth_/2.0f, w_);      // 6
00747 //     v1 = Vector4(-width_/2.0f, -height_/2.0f, depth_/2.0f, w_);      // 1
00748 //     v2 = Vector4(-width_/2.0f, -height_/2.0f, -depth_/2.0f, w_);     // 5
00749 //     m_Vertex.push_back(v0); m_Vertex.push_back(v1); m_Vertex.push_back(v2);
00750 //
00751 //     // Left
00752 //     v0 = Vector4(-width_/2.0f, height_/2.0f, -depth_/2.0f, w_);      // 4
00753 //     v1 = Vector4(-width_/2.0f, -height_/2.0f, -depth_/2.0f, w_);     // 5
00754 //     v2 = Vector4(-width_/2.0f, -height_/2.0f, depth_/2.0f, w_);      // 1
00755 //     m_Vertex.push_back(v0); m_Vertex.push_back(v1); m_Vertex.push_back(v2);
00756 //
00757 //     v0 = Vector4(-width_/2.0f, height_/2.0f, -depth_/2.0f, w_);      // 4
00758 //     v1 = Vector4(-width_/2.0f, -height_/2.0f, depth_/2.0f, w_);      // 1
00759 //     v2 = Vector4(-width_/2.0f, height_/2.0f, depth_/2.0f, w_);       // 0
00760 //     m_Vertex.push_back(v0); m_Vertex.push_back(v1); m_Vertex.push_back(v2);
00761 //
00762 //     // Right
00763 //     v0 = Vector4(width_/2.0f, height_/2.0f, depth_/2.0f, w_);        // 3
00764 //     v1 = Vector4(width_/2.0f, -height_/2.0f, depth_/2.0f, w_);       // 2
00765 //     v2 = Vector4(width_/2.0f, -height_/2.0f, -depth_/2.0f, w_);      // 6
00766 //     m_Vertex.push_back(v0); m_Vertex.push_back(v1); m_Vertex.push_back(v2);
00767 //
00768 //     v0 = Vector4(width_/2.0f, height_/2.0f, depth_/2.0f, w_);        // 3
00769 //     v1 = Vector4(width_/2.0f, -height_/2.0f, -depth_/2.0f, w_);      // 6
00770 //     v2 = Vector4(width_/2.0f, height_/2.0f, -depth_/2.0f, w_);       // 7
00771 //     m_Vertex.push_back(v0); m_Vertex.push_back(v1); m_Vertex.push_back(v2);
00772 //
00773 //     m_Size = (INT)m_Vertex.size() * 4 * 4;  // bytes
00774 //     m_Stride = 0;
00775 // }
00776 //
00777 // NCubeVertexBuffer::~NCubeVertexBuffer()
00778 // {
00779 // }
00780 //
00781 // void NCubeVertexBuffer::GetData(void* Buffer)
00782 // {
00783 //     nuxAssert(Buffer);
00784 //
00785 //     float *Ptr = (float*)Buffer;
00786 //
00787 //     INT i = 0;
00788 //     for(i = 0; i < (INT)m_Vertex.size(); i++)
00789 //     {
00790 //         *Ptr++ = m_Vertex[i].x;
00791 //         *Ptr++ = m_Vertex[i].y;
00792 //         *Ptr++ = m_Vertex[i].z;
00793 //         *Ptr++ = m_Vertex[i].w;
00794 //     }
00795 // }
00796 //
00797 // INT NCubeVertexBuffer::GetSize()
00798 // {
00799 //     return m_Size; // bytes
00800 // }
00801 //
00802 // VERTEXELEMENT NCubeVertexBuffer::GetDeclaration(INT i)
00803 // {
00804 //     if(i < (INT)_DeclarationsArray.size())
00805 //     {
00806 //         return _DeclarationsArray[i];
00807 //     }
00808 //     VERTEXELEMENT decl = DECL_END;
00809 //     return decl;
00810 // }
00811 
00812 }
00813 
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends