nux-1.16.0
|
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