Richard Boegli's CnC_Generals_Zero_Hour Fork WIP
This is documentation of Richard Boegil's Zero Hour Fork
 
Loading...
Searching...
No Matches
dx8vertexbuffer.cpp
Go to the documentation of this file.
1/*
2** Command & Conquer Generals Zero Hour(tm)
3** Copyright 2025 Electronic Arts Inc.
4**
5** This program is free software: you can redistribute it and/or modify
6** it under the terms of the GNU General Public License as published by
7** the Free Software Foundation, either version 3 of the License, or
8** (at your option) any later version.
9**
10** This program is distributed in the hope that it will be useful,
11** but WITHOUT ANY WARRANTY; without even the implied warranty of
12** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13** GNU General Public License for more details.
14**
15** You should have received a copy of the GNU General Public License
16** along with this program. If not, see <http://www.gnu.org/licenses/>.
17*/
18
19/***********************************************************************************************
20 *** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
21 ***********************************************************************************************
22 * *
23 * Project Name : ww3d *
24 * *
25 * $Archive:: /Commando/Code/ww3d2/dx8vertexbuffer.cpp $*
26 * *
27 * Original Author:: Jani Penttinen *
28 * *
29 * $Author:: Kenny Mitchell *
30 * *
31 * $Modtime:: 06/26/02 5:06p $*
32 * *
33 * $Revision:: 39 $*
34 * *
35 * 06/26/02 KM VB Vertex format size update for shaders *
36 *---------------------------------------------------------------------------------------------*
37 * Functions: *
38 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
39
40//#define VERTEX_BUFFER_LOG
41
42#include "dx8vertexbuffer.h"
43#include "dx8wrapper.h"
44#include "dx8fvf.h"
45#include "dx8caps.h"
46#include "thread.h"
47#include "wwmemlog.h"
48#include <D3dx8core.h>
49
50#define DEFAULT_VB_SIZE 5000
51
52static bool _DynamicSortingVertexArrayInUse=false;
53//static VertexFormatXYZNDUV2* _DynamicSortingVertexArray=NULL;
54static SortingVertexBufferClass* _DynamicSortingVertexArray=NULL;
55static unsigned short _DynamicSortingVertexArraySize=0;
56static unsigned short _DynamicSortingVertexArrayOffset=0;
57
58static bool _DynamicDX8VertexBufferInUse=false;
59static DX8VertexBufferClass* _DynamicDX8VertexBuffer=NULL;
60static unsigned short _DynamicDX8VertexBufferSize=DEFAULT_VB_SIZE;
61static unsigned short _DynamicDX8VertexBufferOffset=0;
62
63static const FVFInfoClass _DynamicFVFInfo(dynamic_fvf_type);
64
65static int _DX8VertexBufferCount=0;
66
67static int _VertexBufferCount;
68static int _VertexBufferTotalVertices;
69static int _VertexBufferTotalSize;
70
71// ----------------------------------------------------------------------------
72//
73//
74//
75// ----------------------------------------------------------------------------
76
77VertexBufferClass::VertexBufferClass(unsigned type_, unsigned FVF, unsigned short vertex_count_, unsigned vertex_size)
78 :
79 VertexCount(vertex_count_),
80 type(type_),
81 engine_refs(0)
82{
83 WWMEMLOG(MEM_RENDERER);
84 WWASSERT(VertexCount);
85 WWASSERT(type==BUFFER_TYPE_DX8 || type==BUFFER_TYPE_SORTING);
86 WWASSERT((FVF!=0 && vertex_size==0) || (FVF==0 && vertex_size!=0));
87 fvf_info=W3DNEW FVFInfoClass(FVF,vertex_size);
88
89 _VertexBufferCount++;
90 _VertexBufferTotalVertices+=VertexCount;
91 _VertexBufferTotalSize+=VertexCount*fvf_info->Get_FVF_Size();
92#ifdef VERTEX_BUFFER_LOG
93 WWDEBUG_SAY(("New VB, %d vertices, size %d bytes\n",VertexCount,VertexCount*fvf_info->Get_FVF_Size()));
94 WWDEBUG_SAY(("Total VB count: %d, total %d vertices, total size %d bytes\n",
95 _VertexBufferCount,
96 _VertexBufferTotalVertices,
97 _VertexBufferTotalSize));
98#endif
99}
100
101// ----------------------------------------------------------------------------
102
103VertexBufferClass::~VertexBufferClass()
104{
105 _VertexBufferCount--;
106 _VertexBufferTotalVertices-=VertexCount;
107 _VertexBufferTotalSize-=VertexCount*fvf_info->Get_FVF_Size();
108
109#ifdef VERTEX_BUFFER_LOG
110 WWDEBUG_SAY(("Delete VB, %d vertices, size %d bytes\n",VertexCount,VertexCount*fvf_info->Get_FVF_Size()));
111 WWDEBUG_SAY(("Total VB count: %d, total %d vertices, total size %d bytes\n",
112 _VertexBufferCount,
113 _VertexBufferTotalVertices,
114 _VertexBufferTotalSize));
115#endif
116 delete fvf_info;
117}
118
119unsigned VertexBufferClass::Get_Total_Buffer_Count()
120{
121 return _VertexBufferCount;
122}
123
124unsigned VertexBufferClass::Get_Total_Allocated_Vertices()
125{
126 return _VertexBufferTotalVertices;
127}
128
129unsigned VertexBufferClass::Get_Total_Allocated_Memory()
130{
131 return _VertexBufferTotalSize;
132}
133
134
135// ----------------------------------------------------------------------------
136
137void VertexBufferClass::Add_Engine_Ref() const
138{
139 engine_refs++;
140}
141
142// ----------------------------------------------------------------------------
143
149
150// ----------------------------------------------------------------------------
151//
152//
153//
154// ----------------------------------------------------------------------------
155
156VertexBufferClass::WriteLockClass::WriteLockClass(VertexBufferClass* VertexBuffer, int flags)
157 :
158 VertexBufferLockClass(VertexBuffer)
159{
160 DX8_THREAD_ASSERT();
161 WWASSERT(VertexBuffer);
162 WWASSERT(!VertexBuffer->Engine_Refs());
163 VertexBuffer->Add_Ref();
164 switch (VertexBuffer->Type()) {
165 case BUFFER_TYPE_DX8:
166#ifdef VERTEX_BUFFER_LOG
167 {
168 StringClass fvf_name;
169 VertexBuffer->FVF_Info().Get_FVF_Name(fvf_name);
170 WWDEBUG_SAY(("VertexBuffer->Lock(start_index: 0, index_range: 0(%d), fvf_size: %d, fvf: %s)\n",
171 VertexBuffer->Get_Vertex_Count(),
172 VertexBuffer->FVF_Info().Get_FVF_Size(),
173 fvf_name));
174 }
175#endif
176 DX8_Assert();
177 DX8_ErrorCode(static_cast<DX8VertexBufferClass*>(VertexBuffer)->Get_DX8_Vertex_Buffer()->Lock(
178 0,
179 0,
180 (unsigned char**)&Vertices,
181 flags)); //flags
182 break;
183 case BUFFER_TYPE_SORTING:
184 Vertices=static_cast<SortingVertexBufferClass*>(VertexBuffer)->VertexBuffer;
185 break;
186 default:
187 WWASSERT(0);
188 break;
189 }
190}
191
192// ----------------------------------------------------------------------------
193
194VertexBufferClass::WriteLockClass::~WriteLockClass()
195{
196 DX8_THREAD_ASSERT();
197 switch (VertexBuffer->Type()) {
198 case BUFFER_TYPE_DX8:
199#ifdef VERTEX_BUFFER_LOG
200 WWDEBUG_SAY(("VertexBuffer->Unlock()\n"));
201#endif
202 DX8_Assert();
203 DX8_ErrorCode(static_cast<DX8VertexBufferClass*>(VertexBuffer)->Get_DX8_Vertex_Buffer()->Unlock());
204 break;
205 case BUFFER_TYPE_SORTING:
206 break;
207 default:
208 WWASSERT(0);
209 break;
210 }
211 VertexBuffer->Release_Ref();
212}
213
214// ----------------------------------------------------------------------------
215//
216//
217//
218// ----------------------------------------------------------------------------
219
220VertexBufferClass::AppendLockClass::AppendLockClass(VertexBufferClass* VertexBuffer,unsigned start_index, unsigned index_range)
221 :
222 VertexBufferLockClass(VertexBuffer)
223{
224 DX8_THREAD_ASSERT();
225 WWASSERT(VertexBuffer);
226 WWASSERT(!VertexBuffer->Engine_Refs());
227 WWASSERT(start_index+index_range<=VertexBuffer->Get_Vertex_Count());
228 VertexBuffer->Add_Ref();
229 switch (VertexBuffer->Type()) {
230 case BUFFER_TYPE_DX8:
231#ifdef VERTEX_BUFFER_LOG
232 {
233 StringClass fvf_name;
234 VertexBuffer->FVF_Info().Get_FVF_Name(fvf_name);
235 WWDEBUG_SAY(("VertexBuffer->Lock(start_index: %d, index_range: %d, fvf_size: %d, fvf: %s)\n",
236 start_index,
237 index_range,
238 VertexBuffer->FVF_Info().Get_FVF_Size(),
239 fvf_name));
240 }
241#endif
242 DX8_Assert();
243 DX8_ErrorCode(static_cast<DX8VertexBufferClass*>(VertexBuffer)->Get_DX8_Vertex_Buffer()->Lock(
244 start_index*VertexBuffer->FVF_Info().Get_FVF_Size(),
245 index_range*VertexBuffer->FVF_Info().Get_FVF_Size(),
246 (unsigned char**)&Vertices,
247 0)); // Default (no) flags
248 break;
249 case BUFFER_TYPE_SORTING:
250 Vertices=static_cast<SortingVertexBufferClass*>(VertexBuffer)->VertexBuffer+start_index;
251 break;
252 default:
253 WWASSERT(0);
254 break;
255 }
256}
257
258// ----------------------------------------------------------------------------
259
260VertexBufferClass::AppendLockClass::~AppendLockClass()
261{
262 DX8_THREAD_ASSERT();
263 switch (VertexBuffer->Type()) {
264 case BUFFER_TYPE_DX8:
265 DX8_Assert();
266#ifdef VERTEX_BUFFER_LOG
267 WWDEBUG_SAY(("VertexBuffer->Unlock()\n"));
268#endif
269 DX8_ErrorCode(static_cast<DX8VertexBufferClass*>(VertexBuffer)->Get_DX8_Vertex_Buffer()->Unlock());
270 break;
271 case BUFFER_TYPE_SORTING:
272 break;
273 default:
274 WWASSERT(0);
275 break;
276 }
277 VertexBuffer->Release_Ref();
278}
279
280// ----------------------------------------------------------------------------
281//
282//
283//
284// ----------------------------------------------------------------------------
285
293
294// ----------------------------------------------------------------------------
295
296SortingVertexBufferClass::~SortingVertexBufferClass()
297{
298 delete[] VertexBuffer;
299}
300
301
302// ----------------------------------------------------------------------------
303//
304//
305//
306// ----------------------------------------------------------------------------
307
308// bool dynamic=false,bool softwarevp=false);
309
310DX8VertexBufferClass::DX8VertexBufferClass(unsigned FVF, unsigned short vertex_count_, UsageType usage, unsigned vertex_size)
311 :
312 VertexBufferClass(BUFFER_TYPE_DX8, FVF, vertex_count_, vertex_size),
313 VertexBuffer(NULL)
314{
315 Create_Vertex_Buffer(usage);
316}
317
318// ----------------------------------------------------------------------------
319
320DX8VertexBufferClass::DX8VertexBufferClass(
321 const Vector3* vertices,
322 const Vector3* normals,
323 const Vector2* tex_coords,
324 unsigned short VertexCount,
325 UsageType usage)
326 :
327 VertexBufferClass(BUFFER_TYPE_DX8, D3DFVF_XYZ|D3DFVF_TEX1|D3DFVF_NORMAL, VertexCount),
328 VertexBuffer(NULL)
329{
330 WWASSERT(vertices);
331 WWASSERT(normals);
332 WWASSERT(tex_coords);
333
334 Create_Vertex_Buffer(usage);
335 Copy(vertices,normals,tex_coords,0,VertexCount);
336}
337
338// ----------------------------------------------------------------------------
339
340DX8VertexBufferClass::DX8VertexBufferClass(
341 const Vector3* vertices,
342 const Vector3* normals,
343 const Vector4* diffuse,
344 const Vector2* tex_coords,
345 unsigned short VertexCount,
346 UsageType usage)
347 :
348 VertexBufferClass(BUFFER_TYPE_DX8, D3DFVF_XYZ|D3DFVF_TEX1|D3DFVF_NORMAL|D3DFVF_DIFFUSE, VertexCount),
349 VertexBuffer(NULL)
350{
351 WWASSERT(vertices);
352 WWASSERT(normals);
353 WWASSERT(tex_coords);
354 WWASSERT(diffuse);
355
356 Create_Vertex_Buffer(usage);
357 Copy(vertices,normals,tex_coords,diffuse,0,VertexCount);
358}
359
360// ----------------------------------------------------------------------------
361
362DX8VertexBufferClass::DX8VertexBufferClass(
363 const Vector3* vertices,
364 const Vector4* diffuse,
365 const Vector2* tex_coords,
366 unsigned short VertexCount,
367 UsageType usage)
368 :
369 VertexBufferClass(BUFFER_TYPE_DX8, D3DFVF_XYZ|D3DFVF_TEX1|D3DFVF_DIFFUSE, VertexCount),
370 VertexBuffer(NULL)
371{
372 WWASSERT(vertices);
373 WWASSERT(tex_coords);
374 WWASSERT(diffuse);
375
376 Create_Vertex_Buffer(usage);
377 Copy(vertices,tex_coords,diffuse,0,VertexCount);
378}
379
380// ----------------------------------------------------------------------------
381
382DX8VertexBufferClass::DX8VertexBufferClass(
383 const Vector3* vertices,
384 const Vector2* tex_coords,
385 unsigned short VertexCount,
386 UsageType usage)
387 :
388 VertexBufferClass(BUFFER_TYPE_DX8, D3DFVF_XYZ|D3DFVF_TEX1, VertexCount),
389 VertexBuffer(NULL)
390{
391 WWASSERT(vertices);
392 WWASSERT(tex_coords);
393
394 Create_Vertex_Buffer(usage);
395 Copy(vertices,tex_coords,0,VertexCount);
396}
397
398// ----------------------------------------------------------------------------
399
400DX8VertexBufferClass::~DX8VertexBufferClass()
401{
402#ifdef VERTEX_BUFFER_LOG
403 WWDEBUG_SAY(("VertexBuffer->Release()\n"));
404 _DX8VertexBufferCount--;
405 WWDEBUG_SAY(("Current vertex buffer count: %d\n",_DX8VertexBufferCount));
406#endif
407 VertexBuffer->Release();
408}
409
410// ----------------------------------------------------------------------------
411//
412//
413//
414// ----------------------------------------------------------------------------
415
416void DX8VertexBufferClass::Create_Vertex_Buffer(UsageType usage)
417{
418 DX8_THREAD_ASSERT();
419 WWASSERT(!VertexBuffer);
420
421#ifdef VERTEX_BUFFER_LOG
422 StringClass fvf_name;
423 FVF_Info().Get_FVF_Name(fvf_name);
424 WWDEBUG_SAY(("CreateVertexBuffer(fvfsize=%d, vertex_count=%d, D3DUSAGE_WRITEONLY|%s|%s, fvf: %s, %s)\n",
425 FVF_Info().Get_FVF_Size(),
426 VertexCount,
427 (usage&USAGE_DYNAMIC) ? "D3DUSAGE_DYNAMIC" : "-",
428 (usage&USAGE_SOFTWAREPROCESSING) ? "D3DUSAGE_SOFTWAREPROCESSING" : "-",
429 fvf_name,
430 (usage&USAGE_DYNAMIC) ? "D3DPOOL_DEFAULT" : "D3DPOOL_MANAGED"));
431 _DX8VertexBufferCount++;
432 WWDEBUG_SAY(("Current vertex buffer count: %d\n",_DX8VertexBufferCount));
433#endif
434
435 unsigned usage_flags=
436 D3DUSAGE_WRITEONLY|
437 ((usage&USAGE_DYNAMIC) ? D3DUSAGE_DYNAMIC : 0)|
438 ((usage&USAGE_NPATCHES) ? D3DUSAGE_NPATCHES : 0)|
439 ((usage&USAGE_SOFTWAREPROCESSING) ? D3DUSAGE_SOFTWAREPROCESSING : 0);
440 if (!DX8Wrapper::Get_Current_Caps()->Support_TnL()) {
441 usage_flags|=D3DUSAGE_SOFTWAREPROCESSING;
442 }
443
444 // New Code
445 if (!DX8Wrapper::Get_Current_Caps()->Support_TnL()) {
446 usage_flags|=D3DUSAGE_SOFTWAREPROCESSING;
447 }
448
449 HRESULT ret=DX8Wrapper::_Get_D3D_Device8()->CreateVertexBuffer(
450 FVF_Info().Get_FVF_Size()*VertexCount,
451 usage_flags,
452 FVF_Info().Get_FVF(),
453 (usage&USAGE_DYNAMIC) ? D3DPOOL_DEFAULT : D3DPOOL_MANAGED,
454 &VertexBuffer);
455 if (SUCCEEDED(ret)) {
456 return;
457 }
458
459 WWDEBUG_SAY(("Vertex buffer creation failed, trying to release assets...\n"));
460
461 // Vertex buffer creation failed, so try releasing least used textures and flushing the mesh cache.
462
463 // Free all textures that haven't been used in the last 5 seconds
464 TextureClass::Invalidate_Old_Unused_Textures(5000);
465
466 // Invalidate the mesh cache
467 WW3D::_Invalidate_Mesh_Cache();
468
469 //@todo: Find some way to invalidate the textures too
470 ret = DX8Wrapper::_Get_D3D_Device8()->ResourceManagerDiscardBytes(0);
471
472 // Try again...
473 ret=DX8Wrapper::_Get_D3D_Device8()->CreateVertexBuffer(
474 FVF_Info().Get_FVF_Size()*VertexCount,
475 usage_flags,
476 FVF_Info().Get_FVF(),
477 (usage&USAGE_DYNAMIC) ? D3DPOOL_DEFAULT : D3DPOOL_MANAGED,
478 &VertexBuffer);
479
480 if (SUCCEEDED(ret)) {
481 WWDEBUG_SAY(("...Vertex buffer creation succesful\n"));
482 }
483
484 // If it still fails it is fatal
485 DX8_ErrorCode(ret);
486
487 /* Old Code
488 DX8CALL(CreateVertexBuffer(
489 FVF_Info().Get_FVF_Size()*VertexCount,
490 usage_flags,
491 FVF_Info().Get_FVF(),
492 (usage&USAGE_DYNAMIC) ? D3DPOOL_DEFAULT : D3DPOOL_MANAGED,
493 &VertexBuffer));
494 */
495}
496
497// ----------------------------------------------------------------------------
498
499void DX8VertexBufferClass::Copy(const Vector3* loc, const Vector3* norm, const Vector2* uv, unsigned first_vertex,unsigned count)
500{
501 WWASSERT(loc);
502 WWASSERT(norm);
503 WWASSERT(uv);
504 WWASSERT(count<=VertexCount);
505 WWASSERT(FVF_Info().Get_FVF()==DX8_FVF_XYZNUV1);
506
507 if (first_vertex) {
508 VertexBufferClass::AppendLockClass l(this,first_vertex,count);
509 VertexFormatXYZNUV1* verts=(VertexFormatXYZNUV1*)l.Get_Vertex_Array();
510 for (unsigned v=0;v<count;++v) {
511 verts[v].x=(*loc)[0];
512 verts[v].y=(*loc)[1];
513 verts[v].z=(*loc++)[2];
514 verts[v].nx=(*norm)[0];
515 verts[v].ny=(*norm)[1];
516 verts[v].nz=(*norm++)[2];
517 verts[v].u1=(*uv)[0];
518 verts[v].v1=(*uv++)[1];
519 }
520 }
521 else {
522 VertexBufferClass::WriteLockClass l(this);
523 VertexFormatXYZNUV1* verts=(VertexFormatXYZNUV1*)l.Get_Vertex_Array();
524 for (unsigned v=0;v<count;++v) {
525 verts[v].x=(*loc)[0];
526 verts[v].y=(*loc)[1];
527 verts[v].z=(*loc++)[2];
528 verts[v].nx=(*norm)[0];
529 verts[v].ny=(*norm)[1];
530 verts[v].nz=(*norm++)[2];
531 verts[v].u1=(*uv)[0];
532 verts[v].v1=(*uv++)[1];
533 }
534 }
535}
536
537// ----------------------------------------------------------------------------
538
539void DX8VertexBufferClass::Copy(const Vector3* loc, unsigned first_vertex, unsigned count)
540{
541 WWASSERT(loc);
542 WWASSERT(count<=VertexCount);
543 WWASSERT(FVF_Info().Get_FVF()==DX8_FVF_XYZ);
544
545 if (first_vertex) {
546 VertexBufferClass::AppendLockClass l(this,first_vertex,count);
547 VertexFormatXYZ* verts=(VertexFormatXYZ*)l.Get_Vertex_Array();
548 for (unsigned v=0;v<count;++v) {
549 verts[v].x=(*loc)[0];
550 verts[v].y=(*loc)[1];
551 verts[v].z=(*loc++)[2];
552 }
553 }
554 else {
555 VertexBufferClass::WriteLockClass l(this);
556 VertexFormatXYZ* verts=(VertexFormatXYZ*)l.Get_Vertex_Array();
557 for (unsigned v=0;v<count;++v) {
558 verts[v].x=(*loc)[0];
559 verts[v].y=(*loc)[1];
560 verts[v].z=(*loc++)[2];
561 }
562 }
563
564}
565
566// ----------------------------------------------------------------------------
567
568void DX8VertexBufferClass::Copy(const Vector3* loc, const Vector2* uv, unsigned first_vertex, unsigned count)
569{
570 WWASSERT(loc);
571 WWASSERT(uv);
572 WWASSERT(count<=VertexCount);
573 WWASSERT(FVF_Info().Get_FVF()==DX8_FVF_XYZUV1);
574
575 if (first_vertex) {
576 VertexBufferClass::AppendLockClass l(this,first_vertex,count);
577 VertexFormatXYZUV1* verts=(VertexFormatXYZUV1*)l.Get_Vertex_Array();
578 for (unsigned v=0;v<count;++v) {
579 verts[v].x=(*loc)[0];
580 verts[v].y=(*loc)[1];
581 verts[v].z=(*loc++)[2];
582 verts[v].u1=(*uv)[0];
583 verts[v].v1=(*uv++)[1];
584 }
585 }
586 else {
587 VertexBufferClass::WriteLockClass l(this);
588 VertexFormatXYZUV1* verts=(VertexFormatXYZUV1*)l.Get_Vertex_Array();
589 for (unsigned v=0;v<count;++v) {
590 verts[v].x=(*loc)[0];
591 verts[v].y=(*loc)[1];
592 verts[v].z=(*loc++)[2];
593 verts[v].u1=(*uv)[0];
594 verts[v].v1=(*uv++)[1];
595 }
596 }
597}
598
599// ----------------------------------------------------------------------------
600
601void DX8VertexBufferClass::Copy(const Vector3* loc, const Vector3* norm, unsigned first_vertex, unsigned count)
602{
603 WWASSERT(loc);
604 WWASSERT(norm);
605 WWASSERT(count<=VertexCount);
606 WWASSERT(FVF_Info().Get_FVF()==DX8_FVF_XYZN);
607
608 if (first_vertex) {
609 VertexBufferClass::AppendLockClass l(this,first_vertex,count);
610 VertexFormatXYZN* verts=(VertexFormatXYZN*)l.Get_Vertex_Array();
611 for (unsigned v=0;v<count;++v) {
612 verts[v].x=(*loc)[0];
613 verts[v].y=(*loc)[1];
614 verts[v].z=(*loc++)[2];
615 verts[v].nx=(*norm)[0];
616 verts[v].ny=(*norm)[1];
617 verts[v].nz=(*norm++)[2];
618 }
619 }
620 else {
621 VertexBufferClass::WriteLockClass l(this);
622 VertexFormatXYZN* verts=(VertexFormatXYZN*)l.Get_Vertex_Array();
623 for (unsigned v=0;v<count;++v) {
624 verts[v].x=(*loc)[0];
625 verts[v].y=(*loc)[1];
626 verts[v].z=(*loc++)[2];
627 verts[v].nx=(*norm)[0];
628 verts[v].ny=(*norm)[1];
629 verts[v].nz=(*norm++)[2];
630 }
631 }
632}
633
634// ----------------------------------------------------------------------------
635
636void DX8VertexBufferClass::Copy(const Vector3* loc, const Vector3* norm, const Vector2* uv, const Vector4* diffuse, unsigned first_vertex, unsigned count)
637{
638 WWASSERT(loc);
639 WWASSERT(norm);
640 WWASSERT(uv);
641 WWASSERT(diffuse);
642 WWASSERT(count<=VertexCount);
643 WWASSERT(FVF_Info().Get_FVF()==DX8_FVF_XYZNDUV1);
644
645 if (first_vertex) {
646 VertexBufferClass::AppendLockClass l(this,first_vertex,count);
647 VertexFormatXYZNDUV1* verts=(VertexFormatXYZNDUV1*)l.Get_Vertex_Array();
648 for (unsigned v=0;v<count;++v) {
649 verts[v].x=(*loc)[0];
650 verts[v].y=(*loc)[1];
651 verts[v].z=(*loc++)[2];
652 verts[v].nx=(*norm)[0];
653 verts[v].ny=(*norm)[1];
654 verts[v].nz=(*norm++)[2];
655 verts[v].u1=(*uv)[0];
656 verts[v].v1=(*uv++)[1];
657 verts[v].diffuse=DX8Wrapper::Convert_Color(diffuse[v]);
658 }
659 }
660 else {
661 VertexBufferClass::WriteLockClass l(this);
662 VertexFormatXYZNDUV1* verts=(VertexFormatXYZNDUV1*)l.Get_Vertex_Array();
663 for (unsigned v=0;v<count;++v) {
664 verts[v].x=(*loc)[0];
665 verts[v].y=(*loc)[1];
666 verts[v].z=(*loc++)[2];
667 verts[v].nx=(*norm)[0];
668 verts[v].ny=(*norm)[1];
669 verts[v].nz=(*norm++)[2];
670 verts[v].u1=(*uv)[0];
671 verts[v].v1=(*uv++)[1];
672 verts[v].diffuse=DX8Wrapper::Convert_Color(diffuse[v]);
673 }
674 }
675}
676
677// ----------------------------------------------------------------------------
678
679void DX8VertexBufferClass::Copy(const Vector3* loc, const Vector2* uv, const Vector4* diffuse, unsigned first_vertex, unsigned count)
680{
681 WWASSERT(loc);
682 WWASSERT(uv);
683 WWASSERT(diffuse);
684 WWASSERT(count<=VertexCount);
685 WWASSERT(FVF_Info().Get_FVF()==DX8_FVF_XYZDUV1);
686
687 if (first_vertex) {
688 VertexBufferClass::AppendLockClass l(this,first_vertex,count);
689 VertexFormatXYZDUV1* verts=(VertexFormatXYZDUV1*)l.Get_Vertex_Array();
690 for (unsigned v=0;v<count;++v) {
691 verts[v].x=(*loc)[0];
692 verts[v].y=(*loc)[1];
693 verts[v].z=(*loc++)[2];
694 verts[v].u1=(*uv)[0];
695 verts[v].v1=(*uv++)[1];
696 verts[v].diffuse=DX8Wrapper::Convert_Color(diffuse[v]);
697 }
698 }
699 else {
700 VertexBufferClass::WriteLockClass l(this);
701 VertexFormatXYZDUV1* verts=(VertexFormatXYZDUV1*)l.Get_Vertex_Array();
702 for (unsigned v=0;v<count;++v) {
703 verts[v].x=(*loc)[0];
704 verts[v].y=(*loc)[1];
705 verts[v].z=(*loc++)[2];
706 verts[v].u1=(*uv)[0];
707 verts[v].v1=(*uv++)[1];
708 verts[v].diffuse=DX8Wrapper::Convert_Color(diffuse[v]);
709 }
710 }
711}
712
713// ----------------------------------------------------------------------------
714//
715//
716//
717// ----------------------------------------------------------------------------
718
719DynamicVBAccessClass::DynamicVBAccessClass(unsigned t,unsigned fvf,unsigned short vertex_count_)
720 :
721 Type(t),
722 FVFInfo(_DynamicFVFInfo),
723 VertexCount(vertex_count_),
724 VertexBuffer(0)
725{
726 WWASSERT(fvf==dynamic_fvf_type);
727 WWASSERT(Type==BUFFER_TYPE_DYNAMIC_DX8 || Type==BUFFER_TYPE_DYNAMIC_SORTING);
728
729 if (Type==BUFFER_TYPE_DYNAMIC_DX8) {
730 Allocate_DX8_Dynamic_Buffer();
731 }
732 else {
733 Allocate_Sorting_Dynamic_Buffer();
734 }
735}
736
737DynamicVBAccessClass::~DynamicVBAccessClass()
738{
739 if (Type==BUFFER_TYPE_DYNAMIC_DX8) {
740 _DynamicDX8VertexBufferInUse=false;
741 _DynamicDX8VertexBufferOffset+=(unsigned) VertexCount;
742 }
743 else {
744 _DynamicSortingVertexArrayInUse=false;
745 _DynamicSortingVertexArrayOffset+=VertexCount;
746 }
747
748 REF_PTR_RELEASE (VertexBuffer);
749}
750
751// ----------------------------------------------------------------------------
752
753void DynamicVBAccessClass::_Deinit()
754{
755 WWASSERT ((_DynamicDX8VertexBuffer == NULL) || (_DynamicDX8VertexBuffer->Num_Refs() == 1));
756 REF_PTR_RELEASE(_DynamicDX8VertexBuffer);
757 _DynamicDX8VertexBufferInUse=false;
758 _DynamicDX8VertexBufferSize=DEFAULT_VB_SIZE;
759 _DynamicDX8VertexBufferOffset=0;
760
761 WWASSERT ((_DynamicSortingVertexArray == NULL) || (_DynamicSortingVertexArray->Num_Refs() == 1));
762 REF_PTR_RELEASE(_DynamicSortingVertexArray);
763 WWASSERT(!_DynamicSortingVertexArrayInUse);
764 _DynamicSortingVertexArrayInUse=false;
765 _DynamicSortingVertexArraySize=0;
766 _DynamicSortingVertexArrayOffset=0;
767}
768
769void DynamicVBAccessClass::Allocate_DX8_Dynamic_Buffer()
770{
771 WWMEMLOG(MEM_RENDERER);
772 WWASSERT(!_DynamicDX8VertexBufferInUse);
773 _DynamicDX8VertexBufferInUse=true;
774
775 // If requesting more vertices than dynamic vertex buffer can fit, delete the vb
776 // and adjust the size to the new count.
777 if (VertexCount>_DynamicDX8VertexBufferSize) {
778 REF_PTR_RELEASE(_DynamicDX8VertexBuffer);
779 _DynamicDX8VertexBufferSize=VertexCount;
780 if (_DynamicDX8VertexBufferSize<DEFAULT_VB_SIZE) _DynamicDX8VertexBufferSize=DEFAULT_VB_SIZE;
781 }
782
783 // Create a new vb if one doesn't exist currently
784 if (!_DynamicDX8VertexBuffer) {
785 unsigned usage=DX8VertexBufferClass::USAGE_DYNAMIC;
786 if (DX8Wrapper::Get_Current_Caps()->Support_NPatches()) {
787 usage|=DX8VertexBufferClass::USAGE_NPATCHES;
788 }
789
790 _DynamicDX8VertexBuffer=NEW_REF(DX8VertexBufferClass,(
791 dynamic_fvf_type,
792 _DynamicDX8VertexBufferSize,
793 (DX8VertexBufferClass::UsageType)usage));
794 _DynamicDX8VertexBufferOffset=0;
795 }
796
797 // Any room at the end of the buffer?
798 if (((unsigned)VertexCount+_DynamicDX8VertexBufferOffset)>_DynamicDX8VertexBufferSize) {
799 _DynamicDX8VertexBufferOffset=0;
800 }
801
802 REF_PTR_SET(VertexBuffer,_DynamicDX8VertexBuffer);
803 VertexBufferOffset=_DynamicDX8VertexBufferOffset;
804}
805
806void DynamicVBAccessClass::Allocate_Sorting_Dynamic_Buffer()
807{
808 WWMEMLOG(MEM_RENDERER);
809 WWASSERT(!_DynamicSortingVertexArrayInUse);
810 _DynamicSortingVertexArrayInUse=true;
811
812 unsigned new_vertex_count=_DynamicSortingVertexArrayOffset+VertexCount;
813 WWASSERT(new_vertex_count<65536);
814 if (new_vertex_count>_DynamicSortingVertexArraySize) {
815 REF_PTR_RELEASE(_DynamicSortingVertexArray);
816 _DynamicSortingVertexArraySize=new_vertex_count;
817 if (_DynamicSortingVertexArraySize<DEFAULT_VB_SIZE) _DynamicSortingVertexArraySize=DEFAULT_VB_SIZE;
818 }
819
820 if (!_DynamicSortingVertexArray) {
821 _DynamicSortingVertexArray=NEW_REF(SortingVertexBufferClass,(_DynamicSortingVertexArraySize));
822 _DynamicSortingVertexArrayOffset=0;
823 }
824
825 REF_PTR_SET(VertexBuffer,_DynamicSortingVertexArray);
826 VertexBufferOffset=_DynamicSortingVertexArrayOffset;
827}
828
829// ----------------------------------------------------------------------------
830static int dx8_lock;
831DynamicVBAccessClass::WriteLockClass::WriteLockClass(DynamicVBAccessClass* dynamic_vb_access_)
832 :
833 DynamicVBAccess(dynamic_vb_access_)
834{
835 DX8_THREAD_ASSERT();
836 switch (DynamicVBAccess->Get_Type()) {
837 case BUFFER_TYPE_DYNAMIC_DX8:
838#ifdef VERTEX_BUFFER_LOG
839/* {
840 WWASSERT(!dx8_lock);
841 dx8_lock++;
842 StringClass fvf_name;
843 DynamicVBAccess->VertexBuffer->FVF_Info().Get_FVF_Name(fvf_name);
844 WWDEBUG_SAY(("DynamicVertexBuffer->Lock(start_index: %d, index_range: %d, fvf_size: %d, fvf: %s)\n",
845 DynamicVBAccess->VertexBufferOffset,
846 DynamicVBAccess->Get_Vertex_Count(),
847 DynamicVBAccess->VertexBuffer->FVF_Info().Get_FVF_Size(),
848 fvf_name));
849 }
850*/
851#endif
852 WWASSERT(_DynamicDX8VertexBuffer);
853// WWASSERT(!_DynamicDX8VertexBuffer->Engine_Refs());
854
855 DX8_Assert();
856 // Lock with discard contents if the buffer offset is zero
857 DX8_ErrorCode(static_cast<DX8VertexBufferClass*>(DynamicVBAccess->VertexBuffer)->Get_DX8_Vertex_Buffer()->Lock(
858 DynamicVBAccess->VertexBufferOffset*_DynamicDX8VertexBuffer->FVF_Info().Get_FVF_Size(),
859 DynamicVBAccess->Get_Vertex_Count()*DynamicVBAccess->VertexBuffer->FVF_Info().Get_FVF_Size(),
860 (unsigned char**)&Vertices,
861 D3DLOCK_NOSYSLOCK | (!DynamicVBAccess->VertexBufferOffset ? D3DLOCK_DISCARD : D3DLOCK_NOOVERWRITE)));
862 break;
863 case BUFFER_TYPE_DYNAMIC_SORTING:
864 Vertices=static_cast<SortingVertexBufferClass*>(DynamicVBAccess->VertexBuffer)->VertexBuffer;
865 Vertices+=DynamicVBAccess->VertexBufferOffset;
866// vertices=_DynamicSortingVertexArray+_DynamicSortingVertexArrayOffset;
867 break;
868 default:
869 WWASSERT(0);
870 break;
871 }
872}
873
874// ----------------------------------------------------------------------------
875
876DynamicVBAccessClass::WriteLockClass::~WriteLockClass()
877{
878 DX8_THREAD_ASSERT();
879 switch (DynamicVBAccess->Get_Type()) {
880 case BUFFER_TYPE_DYNAMIC_DX8:
881#ifdef VERTEX_BUFFER_LOG
882/* dx8_lock--;
883 WWASSERT(!dx8_lock);
884 WWDEBUG_SAY(("DynamicVertexBuffer->Unlock()\n"));
885*/
886#endif
887 DX8_Assert();
888 DX8_ErrorCode(static_cast<DX8VertexBufferClass*>(DynamicVBAccess->VertexBuffer)->Get_DX8_Vertex_Buffer()->Unlock());
889 break;
890 case BUFFER_TYPE_DYNAMIC_SORTING:
891 break;
892 default:
893 WWASSERT(0);
894 break;
895 }
896}
897
898// ----------------------------------------------------------------------------
899
900void DynamicVBAccessClass::_Reset(bool frame_changed)
901{
902 _DynamicSortingVertexArrayOffset=0;
903 if (frame_changed) _DynamicDX8VertexBufferOffset=0;
904}
905
906unsigned short DynamicVBAccessClass::Get_Default_Vertex_Count(void)
907{
908 return _DynamicDX8VertexBufferSize;
909}
910
NULL
#define NULL
Definition BaseType.h:92
WWASSERT
#define WWASSERT
Definition aabtreebuilder.cpp:68
W3DNEWARRAY
#define W3DNEWARRAY
Definition always.h:110
W3DNEW
#define W3DNEW
Definition always.h:109
DX8VertexBufferClass::DX8VertexBufferClass
DX8VertexBufferClass(unsigned FVF, unsigned short VertexCount, UsageType usage=USAGE_DEFAULT, unsigned vertex_size=0)
Definition dx8vertexbuffer.cpp:310
DX8VertexBufferClass::Create_Vertex_Buffer
void Create_Vertex_Buffer(UsageType usage)
Definition dx8vertexbuffer.cpp:416
DX8VertexBufferClass::VertexBuffer
IDirect3DVertexBuffer8 * VertexBuffer
Definition dx8vertexbuffer.h:236
DX8VertexBufferClass::Get_DX8_Vertex_Buffer
IDirect3DVertexBuffer8 * Get_DX8_Vertex_Buffer()
Definition dx8vertexbuffer.h:226
DX8VertexBufferClass::Copy
void Copy(const Vector3 *loc, unsigned first_vertex, unsigned count)
Definition dx8vertexbuffer.cpp:539
DX8Wrapper::_Get_D3D_Device8
static IDirect3DDevice8 * _Get_D3D_Device8()
Definition dx8wrapper.h:530
DX8Wrapper::Get_Current_Caps
static const DX8Caps * Get_Current_Caps()
Definition dx8wrapper.h:536
DX8Wrapper::Convert_Color
static Vector4 Convert_Color(unsigned color)
Definition dx8wrapper.h:958
DynamicVBAccessClass::WriteLockClass::WriteLockClass
WriteLockClass(DynamicVBAccessClass *vb_access)
Definition dx8vertexbuffer.cpp:831
DynamicVBAccessClass::Get_Default_Vertex_Count
static unsigned short Get_Default_Vertex_Count(void)
current size of dynamic vertex buffer
Definition dx8vertexbuffer.cpp:906
DynamicVBAccessClass::_Reset
static void _Reset(bool frame_changed)
Definition dx8vertexbuffer.cpp:900
DynamicVBAccessClass::DynamicVBAccessClass
DynamicVBAccessClass(unsigned type, unsigned fvf, unsigned short vertex_count)
Definition dx8vertexbuffer.cpp:719
FVFInfoClass::Get_FVF_Name
void Get_FVF_Name(StringClass &fvfname) const
Definition dx8fvf.cpp:85
SortingVertexBufferClass::SortingVertexBufferClass
SortingVertexBufferClass(unsigned short VertexCount)
Definition dx8vertexbuffer.cpp:286
TextureBaseClass::Invalidate_Old_Unused_Textures
static void Invalidate_Old_Unused_Textures(unsigned inactive_time_override)
Invalidate old unused textures.
Definition texture.cpp:142
VertexBufferClass::AppendLockClass::AppendLockClass
AppendLockClass(VertexBufferClass *vertex_buffer, unsigned start_index, unsigned index_range)
Definition dx8vertexbuffer.cpp:220
VertexBufferClass::WriteLockClass::WriteLockClass
WriteLockClass(VertexBufferClass *vertex_buffer, int flags=0)
Definition dx8vertexbuffer.cpp:156
VertexBufferClass::VertexCount
unsigned short VertexCount
Definition dx8vertexbuffer.h:120
VertexBufferClass::Get_Vertex_Count
unsigned short Get_Vertex_Count() const
Definition dx8vertexbuffer.h:93
VertexBufferClass::Get_Total_Allocated_Vertices
static unsigned Get_Total_Allocated_Vertices()
Definition dx8vertexbuffer.cpp:124
VertexBufferClass::fvf_info
FVFInfoClass * fvf_info
Definition dx8vertexbuffer.h:122
VertexBufferClass::VertexBufferClass
VertexBufferClass(unsigned type, unsigned FVF, unsigned short VertexCount, unsigned vertex_size=0)
Definition dx8vertexbuffer.cpp:77
VertexBufferClass::Release_Engine_Ref
void Release_Engine_Ref() const
Definition dx8vertexbuffer.cpp:144
VertexBufferClass::Get_Total_Allocated_Memory
static unsigned Get_Total_Allocated_Memory()
Definition dx8vertexbuffer.cpp:129
VertexBufferClass::Get_Total_Buffer_Count
static unsigned Get_Total_Buffer_Count()
Definition dx8vertexbuffer.cpp:119
VertexBufferClass::Add_Engine_Ref
void Add_Engine_Ref() const
Definition dx8vertexbuffer.cpp:137
VertexBufferClass::FVF_Info
const FVFInfoClass & FVF_Info() const
Definition dx8vertexbuffer.h:92
VertexBufferLockClass::VertexBuffer
VertexBufferClass * VertexBuffer
Definition dx8vertexbuffer.h:69
VertexBufferLockClass::VertexBufferLockClass
VertexBufferLockClass(VertexBufferClass *vertex_buffer_)
Definition dx8vertexbuffer.h:73
WW3D::_Invalidate_Mesh_Cache
static void _Invalidate_Mesh_Cache()
Definition ww3d.cpp:749
DX8_FVF_XYZUV1
@ DX8_FVF_XYZUV1
Definition dx8fvf.h:67
DX8_FVF_XYZNUV1
@ DX8_FVF_XYZNUV1
Definition dx8fvf.h:61
DX8_FVF_XYZNDUV1
@ DX8_FVF_XYZNDUV1
Definition dx8fvf.h:63
DX8_FVF_XYZ
@ DX8_FVF_XYZ
Definition dx8fvf.h:59
DX8_FVF_XYZDUV1
@ DX8_FVF_XYZDUV1
Definition dx8fvf.h:65
DX8_FVF_XYZN
@ DX8_FVF_XYZN
Definition dx8fvf.h:60
DEFAULT_VB_SIZE
#define DEFAULT_VB_SIZE
Definition dx8vertexbuffer.cpp:50
dynamic_fvf_type
const unsigned dynamic_fvf_type
Definition dx8vertexbuffer.h:52
DX8_Assert
void DX8_Assert()
Definition dx8wrapper.cpp:1676
BUFFER_TYPE_DYNAMIC_DX8
@ BUFFER_TYPE_DYNAMIC_DX8
Definition dx8wrapper.h:90
BUFFER_TYPE_DX8
@ BUFFER_TYPE_DX8
Definition dx8wrapper.h:88
BUFFER_TYPE_SORTING
@ BUFFER_TYPE_SORTING
Definition dx8wrapper.h:89
BUFFER_TYPE_DYNAMIC_SORTING
@ BUFFER_TYPE_DYNAMIC_SORTING
Definition dx8wrapper.h:91
DX8_THREAD_ASSERT
#define DX8_THREAD_ASSERT()
Definition dx8wrapper.h:140
DX8_ErrorCode
WWINLINE void DX8_ErrorCode(unsigned res)
Definition dx8wrapper.h:125
REF_PTR_RELEASE
#define REF_PTR_RELEASE(x)
Definition refcount.h:80
REF_PTR_SET
#define REF_PTR_SET(dst, src)
Definition refcount.h:79
NEW_REF
#define NEW_REF(C, P)
Definition refcount.h:62
VertexFormatXYZDUV1::diffuse
unsigned diffuse
Definition dx8fvf.h:157
WWDEBUG_SAY
#define WWDEBUG_SAY(x)
Definition wwdebug.h:114
MEM_RENDERER
@ MEM_RENDERER
Definition wwmemlog.h:72
WWMEMLOG
#define WWMEMLOG(category)
Definition wwmemlog.h:183