forked from shokunin000/te120
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathbuilddisp.h
1460 lines (1151 loc) · 50.6 KB
/
builddisp.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $Workfile: $
// $Date: $
// $NoKeywords: $
//=============================================================================//
#ifndef BUILDDISP_H
#define BUILDDISP_H
#ifdef _WIN32
#pragma once
#endif
#include "commonmacros.h"
#include "tier0/dbg.h"
#include "bspfile.h"
#include "mathlib/mathlib.h"
#include "mathlib/bumpvects.h"
#include "disp_common.h"
#include "bitvec.h"
#define DISP_ALPHA_PROP_DELTA 382.5f
class CCoreDispInfo;
struct CoreDispBBox_t
{
Vector vMin, vMax;
};
//=========================================================================
//
// Surface Class - interfacing class (fill in with MapFace, dface_t, and
// msurface_t)
//
class CCoreDispSurface
{
public:
enum { QUAD_POINT_COUNT = 4 };
enum { MAX_CORNER_NEIGHBOR_COUNT = 16 };
CCoreDispSurface();
//=========================================================================
//
// initialization
//
void Init( void );
//=========================================================================
//
// parent surface id - index to CMapFace, dface_t, or msurface_t
//
inline void SetHandle( int handle );
inline int GetHandle( void );
//=========================================================================
//
// vertex data - pos, normal, texture, lightmap, alpha, etc...
//
inline void SetPointCount( int count );
inline int GetPointCount( void ) const;
inline void SetPoint( int index, Vector const &pt );
inline void GetPoint( int index, Vector& pt ) const;
inline Vector const& GetPoint( int index ) const;
inline void SetPointNormal( int index, Vector const &normal );
inline void GetPointNormal( int index, Vector &normal );
inline void SetTexCoord( int index, Vector2D const& texCoord );
inline void GetTexCoord( int index, Vector2D& texCoord ) const;
inline void SetLuxelCoord( int bumpIndex, int index, Vector2D const& luxelCoord );
inline void GetLuxelCoord( int bumpIndex, int index, Vector2D& luxelCoord ) const;
inline void SetLuxelCoords( int bumpIndex, Vector2D const coords[4] );
inline void GetLuxelCoords( int bumpIndex, Vector2D coords[4] ) const;
inline void SetLuxelU( int nU ) { m_nLuxelU = nU; }
inline int GetLuxelU( void ) { return m_nLuxelU; }
inline void SetLuxelV( int nV ) { m_nLuxelV = nV; }
inline int GetLuxelV( void ) { return m_nLuxelV; }
bool CalcLuxelCoords( int nLuxels, bool bAdjust, const Vector &vecU, const Vector &vecV );
inline void SetAlpha( int index, float alpha );
inline float GetAlpha( int const index ) const;
//=========================================================================
//
// utils
//
inline void GetNormal( Vector& normal );
inline void SetFlags( int flag );
inline int GetFlags( void );
inline void SetContents( int contents );
inline int GetContents( void );
//=========================================================================
//
// create utils (texture axis not use anymore but here to support older maps)
//
inline void SetSAxis( Vector const &axis );
inline void GetSAxis( Vector &axis );
inline void SetTAxis( Vector const &axis );
inline void GetTAxis( Vector &axis );
inline void SetPointStartIndex( int index );
inline int GetPointStartIndex( void );
inline void SetPointStart( Vector const &pt );
inline void GetPointStart( Vector &pt );
// Used by the tools to set the neighbor data from the BSP file.
void SetNeighborData( const CDispNeighbor edgeNeighbors[4], const CDispCornerNeighbors cornerNeighbors[4] );
void GeneratePointStartIndexFromMappingAxes( Vector const &sAxis, Vector const &tAxis );
int GenerateSurfPointStartIndex( void );
int FindSurfPointStartIndex( void );
void AdjustSurfPointData( void );
// Indexed by CORNER_ defines.
CDispCornerNeighbors* GetCornerNeighbors( int iCorner ) { Assert( iCorner >= 0 && iCorner < ARRAYSIZE( m_CornerNeighbors ) ); return &m_CornerNeighbors[iCorner]; }
const CDispCornerNeighbors* GetCornerNeighbors( int iCorner ) const { Assert( iCorner >= 0 && iCorner < ARRAYSIZE( m_CornerNeighbors ) ); return &m_CornerNeighbors[iCorner]; }
// Indexed by CORNER_ defines.
int GetCornerNeighborCount( int iCorner ) const { return GetCornerNeighbors( iCorner )->m_nNeighbors; }
int GetCornerNeighbor( int iCorner, int iNeighbor ) const { Assert( iNeighbor >= 0 && iNeighbor < GetCornerNeighbors(iCorner)->m_nNeighbors ); return GetCornerNeighbors( iCorner )->m_Neighbors[iNeighbor]; }
CDispNeighbor* GetEdgeNeighbor( int iEdge ) { Assert( iEdge >= 0 && iEdge < ARRAYSIZE( m_EdgeNeighbors ) ); return &m_EdgeNeighbors[iEdge]; }
const CDispNeighbor* GetEdgeNeighbor( int iEdge ) const { Assert( iEdge >= 0 && iEdge < ARRAYSIZE( m_EdgeNeighbors ) ); return &m_EdgeNeighbors[iEdge]; }
protected:
// Utility
bool LongestInU( const Vector &vecU, const Vector &vecV );
int m_Index; // parent face (CMapFace, dface_t, msurface_t) index "handle"
int m_PointCount; // number of points in the face (should be 4!)
Vector m_Points[QUAD_POINT_COUNT]; // points
Vector m_Normals[QUAD_POINT_COUNT]; // normals at points
Vector2D m_TexCoords[QUAD_POINT_COUNT]; // texture coordinates at points
Vector2D m_LuxelCoords[NUM_BUMP_VECTS+1][QUAD_POINT_COUNT]; // lightmap coordinates at points
float m_Alphas[QUAD_POINT_COUNT]; // alpha at points
// Luxels sizes
int m_nLuxelU;
int m_nLuxelV;
// Straight from the BSP file.
CDispNeighbor m_EdgeNeighbors[4];
CDispCornerNeighbors m_CornerNeighbors[4];
int m_Flags; // surface flags - inherited from the "parent" face
int m_Contents; // contents flags - inherited from the "parent" face
Vector sAxis; // used to generate start disp orientation (old method)
Vector tAxis; // used to generate start disp orientation (old method)
int m_PointStartIndex; // index to the starting point -- for saving starting point
Vector m_PointStart; // starting point used to determine the orientation of the displacement map on the surface
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetHandle( int handle )
{
m_Index = handle;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispSurface::GetHandle( void )
{
return m_Index;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetPointCount( int count )
{
// quad only -- currently!
if( count != 4 )
return;
m_PointCount = count;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispSurface::GetPointCount( void ) const
{
return m_PointCount;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetPoint( int index, Vector const &pt )
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
VectorCopy( pt, m_Points[index] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetPoint( int index, Vector &pt ) const
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
VectorCopy( m_Points[index], pt );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline Vector const& CCoreDispSurface::GetPoint( int index ) const
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
return m_Points[index];
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetPointNormal( int index, Vector const &normal )
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
VectorCopy( normal, m_Normals[index] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetPointNormal( int index, Vector& normal )
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
VectorCopy( m_Normals[index], normal );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetTexCoord( int index, Vector2D const& texCoord )
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
Vector2DCopy( texCoord, m_TexCoords[index] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetTexCoord( int index, Vector2D& texCoord ) const
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
Vector2DCopy( m_TexCoords[index], texCoord );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetLuxelCoord( int bumpIndex, int index, Vector2D const& luxelCoord )
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
Assert( bumpIndex >= 0 );
Assert( bumpIndex < NUM_BUMP_VECTS + 1 );
Vector2DCopy( luxelCoord, m_LuxelCoords[bumpIndex][index] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetLuxelCoord( int bumpIndex, int index, Vector2D& luxelCoord ) const
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
Assert( bumpIndex >= 0 );
Assert( bumpIndex < NUM_BUMP_VECTS + 1 );
Vector2DCopy( m_LuxelCoords[bumpIndex][index], luxelCoord );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetLuxelCoords( int bumpIndex, Vector2D const luxelCoords[4] )
{
Assert( bumpIndex >= 0 );
Assert( bumpIndex < NUM_BUMP_VECTS + 1 );
for( int i=0; i < 4; i++ )
Vector2DCopy( luxelCoords[i], m_LuxelCoords[bumpIndex][i] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetLuxelCoords( int bumpIndex, Vector2D luxelCoords[4] ) const
{
Assert( bumpIndex >= 0 );
Assert( bumpIndex < NUM_BUMP_VECTS + 1 );
for( int i=0; i < 4; i++ )
Vector2DCopy( m_LuxelCoords[bumpIndex][i], luxelCoords[i] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetAlpha( int index, float alpha )
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
m_Alphas[index] = alpha;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline float CCoreDispSurface::GetAlpha( int const index ) const
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
return m_Alphas[index];
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetFlags( int flag )
{
m_Flags = flag;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispSurface::GetFlags( void )
{
return m_Flags;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetContents( int contents )
{
m_Contents = contents;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispSurface::GetContents( void )
{
return m_Contents;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetSAxis( Vector const &axis )
{
VectorCopy( axis, sAxis );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetSAxis( Vector& axis )
{
VectorCopy( sAxis, axis );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetTAxis( Vector const &axis )
{
VectorCopy( axis, tAxis );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetTAxis( Vector& axis )
{
VectorCopy( tAxis, axis );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetPointStartIndex( int index )
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
m_PointStartIndex = index;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispSurface::GetPointStartIndex( void )
{
return m_PointStartIndex;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetPointStart( Vector const& pt )
{
VectorCopy( pt, m_PointStart );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetPointStart( Vector& pt )
{
VectorCopy( m_PointStart, pt );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetNormal( Vector& normal )
{
//
// calculate the displacement surface normal
//
Vector tmp[2];
VectorSubtract( m_Points[1], m_Points[0], tmp[0] );
VectorSubtract( m_Points[3], m_Points[0], tmp[1] );
CrossProduct( tmp[1], tmp[0], normal );
VectorNormalize( normal );
}
//=========================================================================
//
// Node Class (for displacement quad-tree)
//
class CCoreDispNode
{
public:
enum { MAX_NEIGHBOR_NODE_COUNT = 4 };
enum { MAX_NEIGHBOR_VERT_COUNT = 8 };
enum { MAX_SURF_AT_NODE_COUNT = 8 };
//=========================================================================
//
// Initialization
//
void Init( void );
//=========================================================================
//
//
//
inline void SetBoundingBox( Vector const& bMin, Vector const& bMax );
inline void GetBoundingBox( Vector& bMin, Vector& bMax );
inline void SetErrorTerm( float errorTerm );
inline float GetErrorTerm( void );
inline void SetNeighborNodeIndex( int dir, int index );
inline int GetNeighborNodeIndex( int dir );
inline void SetCenterVertIndex( int index );
inline int GetCenterVertIndex( void );
inline void SetNeighborVertIndex( int dir, int index );
inline int GetNeighborVertIndex( int dir );
inline void SetTriBoundingBox( int index, Vector const& bMin, Vector const& bMax );
inline void GetTriBoundingBox( int index, Vector& bMin, Vector& bMax );
inline void SetTriPlane( int index, Vector const& normal, float dist );
inline void GetTriPlane( int index, cplane_t *plane );
inline void SetRayBoundingBox( int index, Vector const& bMin, Vector const& bMax );
inline void GetRayBoundingBox( int index, Vector& bMin, Vector& bMax );
//=========================================================================
//
// Node Functions (friend functions)
//
friend int GetNodeLevel( int index );
friend int GetNodeCount( int power );
friend int GetNodeParent( int index );
friend int GetNodeChild( int power, int index, int direction );
friend int GetNodeNeighborNode( int power, int index, int direction, int level );
friend int GetNodeNeighborNodeFromNeighborSurf( int power, int index, int direction, int level, int neighborOrient );
friend int GetNodeMinNodeAtLevel( int level );
friend void GetDispNodeTriVerts( CCoreDispInfo *pDisp, int nodeIndex, int triIndex, float *v1, float *v2, float *v3 );
friend void GetComponentsFromNodeIndex( int index, int *x, int *y );
friend int GetNodeIndexFromComponents( int x, int y );
protected:
Vector m_BBox[2]; // displacement node bounding box (take into account size of children)
float m_ErrorTerm; // LOD error term (the "precision" of the representation of the surface at this node's level)
int m_VertIndex; // the node's vertex index (center vertex of node)
int m_NeighborVertIndices[MAX_NEIGHBOR_VERT_COUNT]; // all other vertex indices in node (maximally creates 8 trianglar surfaces)
Vector m_SurfBBoxes[MAX_SURF_AT_NODE_COUNT][2]; // surface bounding boxes - old method
cplane_t m_SurfPlanes[MAX_SURF_AT_NODE_COUNT]; // surface plane info - old method
Vector m_RayBBoxes[4][2]; // bounding boxes for ray traces
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::SetBoundingBox( Vector const& bMin, Vector const& bMax )
{
VectorCopy( bMin, m_BBox[0] );
VectorCopy( bMax, m_BBox[1] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::GetBoundingBox( Vector& bMin, Vector& bMax )
{
VectorCopy( m_BBox[0], bMin );
VectorCopy( m_BBox[1], bMax );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::SetErrorTerm( float errorTerm )
{
m_ErrorTerm = errorTerm;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline float CCoreDispNode::GetErrorTerm( void )
{
return m_ErrorTerm;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::SetCenterVertIndex( int index )
{
m_VertIndex = index;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispNode::GetCenterVertIndex( void )
{
return m_VertIndex;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::SetNeighborVertIndex( int dir, int index )
{
Assert( dir >= 0 );
Assert( dir < MAX_NEIGHBOR_VERT_COUNT );
m_NeighborVertIndices[dir] = index;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispNode::GetNeighborVertIndex( int dir )
{
Assert( dir >= 0 );
Assert( dir < MAX_NEIGHBOR_VERT_COUNT );
return m_NeighborVertIndices[dir];
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::SetTriBoundingBox( int index, Vector const& bMin, Vector const& bMax )
{
Assert( index >= 0 );
Assert( index < MAX_SURF_AT_NODE_COUNT );
VectorCopy( bMin, m_SurfBBoxes[index][0] );
VectorCopy( bMax, m_SurfBBoxes[index][1] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::GetTriBoundingBox( int index, Vector& bMin, Vector& bMax )
{
Assert( index >= 0 );
Assert( index < MAX_SURF_AT_NODE_COUNT );
VectorCopy( m_SurfBBoxes[index][0], bMin );
VectorCopy( m_SurfBBoxes[index][1], bMax );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::SetTriPlane( int index, Vector const &normal, float dist )
{
Assert( index >= 0 );
Assert( index < MAX_SURF_AT_NODE_COUNT );
VectorCopy( normal, m_SurfPlanes[index].normal );
m_SurfPlanes[index].dist = dist;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::GetTriPlane( int index, cplane_t *plane )
{
Assert( index >= 0 );
Assert( index < MAX_SURF_AT_NODE_COUNT );
VectorCopy( m_SurfPlanes[index].normal, plane->normal );
plane->dist = m_SurfPlanes[index].dist;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::SetRayBoundingBox( int index, Vector const &bMin, Vector const &bMax )
{
Assert( index >= 0 );
Assert( index < 4 );
VectorCopy( bMin, m_RayBBoxes[index][0] );
VectorCopy( bMax, m_RayBBoxes[index][1] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::GetRayBoundingBox( int index, Vector& bMin, Vector& bMax )
{
Assert( index >= 0 );
Assert( index < 4 );
VectorCopy( m_RayBBoxes[index][0], bMin );
VectorCopy( m_RayBBoxes[index][1], bMax );
}
//=============================================================================
//
// CCoreInfoBuilder - the primary data necessay to derive a displacement surface
// used by WorldCraft (CMapFace, CMapDisp), VRAD (dface_t, ddispinto_t),
// and the engine (msurface_t, CDispInfo)
//
struct CoreDispVert_t
{
Vector m_FieldVector; // displacement vector field
float m_FieldDistance; // the distances along the displacement vector normal
Vector m_SubdivNormal;
Vector m_SubdivPos; // used the create curvature of displacements
// generated displacement surface data
Vector m_Vert; // displacement surface vertices
Vector m_FlatVert;
Vector m_Normal; // displacement surface normals
Vector m_TangentS; // use in calculating the tangent space axes
Vector m_TangentT; // use in calculating the tangent space axes
Vector2D m_TexCoord; // displacement surface texture coordinates
Vector2D m_LuxelCoords[NUM_BUMP_VECTS+1]; // displacement surface lightmap coordinates
// additional per-vertex data
float m_Alpha; // displacement alpha values (per displacement vertex)
};
// New, need to use this at the node level
#define COREDISPTRI_TAG_WALKABLE (1<<0)
#define COREDISPTRI_TAG_FORCE_WALKABLE_BIT (1<<1)
#define COREDISPTRI_TAG_FORCE_WALKABLE_VAL (1<<2)
#define COREDISPTRI_TAG_BUILDABLE (1<<3)
#define COREDISPTRI_TAG_FORCE_BUILDABLE_BIT (1<<4)
#define COREDISPTRI_TAG_FORCE_BUILDABLE_VAL (1<<5)
#define COREDISPTRI_TAG_FORCE_REMOVE_BIT (1<<6)
struct CoreDispTri_t
{
unsigned short m_iIndex[3]; // the three indices that make up a triangle
unsigned short m_uiTags; // walkable, buildable, etc.
};
class CCoreDispInfo : public CDispUtilsHelper
{
public:
//
// tree and displacement surface directions
//
enum { WEST = 0,
NORTH = 1,
EAST = 2,
SOUTH = 3,
SOUTHWEST = 4,
SOUTHEAST = 5,
NORTHWEST = 6,
NORTHEAST = 7 };
#if 0
//
// building parameters
//
enum { BUILD_NORMALS = 0x1,
BUILD_TEXCOORDS = 0x2,
BUILD_LIGHTCOORDS = 0x4,
BUILD_LODTREE = 0x8,
BUILD_COLLISION = 0x10,
BUILD_TANGENTSPACE = 0x20 };
#endif
//
// surface info flags
//
enum { SURF_BUMPED = 0x1,
SURF_NOPHYSICS_COLL = 0x2,
SURF_NOHULL_COLL = 0x4,
SURF_NORAY_COLL = 0x8 };
enum { MAX_DISP_POWER = MAX_MAP_DISP_POWER };
enum { MAX_VERT_COUNT = MAX_DISPVERTS };
enum { MAX_NODE_COUNT = 85 };
// Convert from a CDispUtilsHelper.
public:
static CCoreDispInfo* FromDispUtils( CDispUtilsHelper *p ) { return (CCoreDispInfo*)p; }
// CDispUtilsHelper implementation.
public:
virtual CDispNeighbor* GetEdgeNeighbor( int index );
virtual CDispCornerNeighbors* GetCornerNeighbors( int index );
virtual const CPowerInfo* GetPowerInfo() const;
virtual CDispUtilsHelper* GetDispUtilsByIndex( int index );
public:
//=========================================================================
//
// Creation/Destruction
//
CCoreDispInfo();
~CCoreDispInfo();
void InitSurf( int parentIndex, Vector points[4], Vector normals[4],
Vector2D texCoords[4], Vector2D lightCoords[4][4], int contents, int flags,
bool bGenerateSurfPointStart, Vector& startPoint,
bool bHasMappingAxes, Vector& uAxis, Vector& vAxis );
void InitDispInfo( int power, int minTess, float smoothingAngle,
float *alphas, Vector *dispVectorField, float *dispDistances );
// This just unpacks the contents of the verts into arrays and calls InitDispInfo.
void InitDispInfo( int power, int minTess, float smoothingAngle, const CDispVert *pVerts, const CDispTri *pTris );
// bool Create( int creationFlags );
bool Create( void );
bool CreateWithoutLOD( void );
//=========================================================================
//
// Parameter "Wrappers"
//
CCoreDispSurface* GetSurface() { return &m_Surf; }
const CCoreDispSurface* GetSurface() const { return &m_Surf; }
inline CCoreDispNode *GetNode( int index );
inline void SetPower( int power );
inline int GetPower( void ) const;
inline int GetPostSpacing( void );
inline int GetWidth( void );
inline int GetHeight( void );
inline int GetSize( void ) const;
// Use this disp as a CDispUtils.
void SetDispUtilsHelperInfo( CCoreDispInfo **ppListBase, int listSize );
void SetNeighborData( const CDispNeighbor edgeNeighbors[4], const CDispCornerNeighbors cornerNeighbors[4] ) { GetSurface()->SetNeighborData( edgeNeighbors, cornerNeighbors ); }
// Get a corner point. Indexed by the CORNER_ defines.
const CVertIndex& GetCornerPointIndex( int index ) const { return GetPowerInfo()->GetCornerPointIndex( index ); }
const Vector& GetCornerPoint( int index ) const { return GetVert( VertIndexToInt( GetCornerPointIndex( index ) ) ); }
inline void SetVert( int index, Vector const& vert );
inline void GetVert( int index, Vector& vert ) const;
inline const Vector& GetVert( int index ) const;
inline const Vector& GetVert( const CVertIndex &index ) const;
inline void GetFlatVert( int index, Vector& vert ) const;
inline void SetFlatVert( int index, const Vector &vert );
inline void GetNormal( int index, Vector& normal ) const;
inline const Vector& GetNormal( int index ) const;
inline const Vector& GetNormal( const CVertIndex &index ) const;
inline void SetNormal( int index, Vector const& normal );
inline void SetNormal( const CVertIndex &index, Vector const& normal );
inline void GetTangentS( int index, Vector& tangentS ) const;
inline const Vector &GetTangentS( int index ) const;
inline const Vector &GetTangentS( const CVertIndex &index ) const { return GetTangentS(VertIndexToInt(index)); }
inline void GetTangentT( int index, Vector& tangentT ) const;
inline void SetTangentS( int index, Vector const& vTangentS ) { m_pVerts[index].m_TangentS = vTangentS; }
inline void SetTangentT( int index, Vector const& vTangentT ) { m_pVerts[index].m_TangentT = vTangentT; }
inline void SetTexCoord( int index, Vector2D const& texCoord );
inline void GetTexCoord( int index, Vector2D& texCoord ) const;
inline void SetLuxelCoord( int bumpIndex, int index, Vector2D const& luxelCoord );
inline void GetLuxelCoord( int bumpIndex, int index, Vector2D& luxelCoord ) const;
inline void SetAlpha( int index, float alpha );
inline float GetAlpha( int index );
int GetTriCount( void );
void GetTriIndices( int iTri, unsigned short &v1, unsigned short &v2, unsigned short &v3 );
void SetTriIndices( int iTri, unsigned short v1, unsigned short v2, unsigned short v3 );
void GetTriPos( int iTri, Vector &v1, Vector &v2, Vector &v3 );
inline void SetTriTag( int iTri, unsigned short nTag ) { m_pTris[iTri].m_uiTags |= nTag; }
inline void ResetTriTag( int iTri, unsigned short nTag ) { m_pTris[iTri].m_uiTags &= ~nTag; }
inline void ToggleTriTag( int iTri, unsigned short nTag ) { m_pTris[iTri].m_uiTags ^= nTag; }
inline bool IsTriTag( int iTri, unsigned short nTag ) { return ( ( m_pTris[iTri].m_uiTags & nTag ) != 0 ); }
inline unsigned short GetTriTagValue( int iTri ) { return m_pTris[iTri].m_uiTags; }
inline void SetTriTagValue( int iTri, unsigned short nVal ) { m_pTris[iTri].m_uiTags = nVal; }
bool IsTriWalkable( int iTri );
bool IsTriBuildable( int iTri );
bool IsTriRemove( int iTri );
inline void SetElevation( float elevation );
inline float GetElevation( void );
inline void ResetFieldVectors( void );
inline void SetFieldVector( int index, Vector const &v );
inline void GetFieldVector( int index, Vector& v );
inline void ResetFieldDistances( void );
inline void SetFieldDistance( int index, float dist );
inline float GetFieldDistance( int index );
inline void ResetSubdivPositions( void );
inline void SetSubdivPosition( int ndx, Vector const &v );
inline void GetSubdivPosition( int ndx, Vector& v );
inline void ResetSubdivNormals( void );
inline void SetSubdivNormal( int ndx, Vector const &v );
inline void GetSubdivNormal( int ndx, Vector &v );
inline void SetRenderIndexCount( int count );
inline int GetRenderIndexCount( void );
inline void SetRenderIndex( int index, int triIndex );
inline int GetRenderIndex( int index );
inline CoreDispVert_t *GetDispVert( int iVert ) { return &m_pVerts[iVert]; }
inline CoreDispVert_t *GetDispVertList();
inline unsigned short *GetRenderIndexList( void );
inline void SetTouched( bool touched );
inline bool IsTouched( void );
void CalcDispSurfCoords( bool bLightMap, int lightmapID );
void GetPositionOnSurface( float u, float v, Vector &vPos, Vector *pNormal, float *pAlpha );
void DispUVToSurf( Vector2D const &dispUV, Vector &vecPoint, Vector *pNormal, float *pAlpha );
void BaseFacePlaneToDispUV( Vector const &planePt, Vector2D &dispUV );
bool SurfToBaseFacePlane( Vector const &surfPt, Vector &planePt );
const CDispCornerNeighbors* GetCornerNeighbors( int iCorner ) const { return GetSurface()->GetCornerNeighbors( iCorner ); }
const CDispNeighbor* GetEdgeNeighbor( int iEdge ) const { return GetSurface()->GetEdgeNeighbor( iEdge ); }
void SetListIndex( int nIndex ) { m_nListIndex = nIndex; }
int GetListIndex( void ) { return m_nListIndex; }
CBitVec<MAX_DISPVERTS>& GetAllowedVerts() { return m_AllowedVerts; }
const CBitVec<MAX_DISPVERTS>& GetAllowedVerts() const { return m_AllowedVerts; }
void AllowedVerts_Clear( void ) { m_AllowedVerts.SetAll(); }
int AllowedVerts_GetNumDWords() const { return m_AllowedVerts.GetNumDWords(); }
unsigned long AllowedVerts_GetDWord(int i) const { return m_AllowedVerts.GetDWord( i ); }
void AllowedVerts_SetDWord(int i, unsigned long val) { m_AllowedVerts.SetDWord( i, val ); }
void Position_Update( int iVert, Vector vecPos );
//=========================================================================
//
// friend functions
//
friend void SmoothNeighboringDispSurfNormals( CCoreDispInfo **ppCoreDispInfoList, int listSize );
private:
// be changed to match the paint normal next pass)
// LOD/collision node data
CCoreDispNode *m_Nodes; // LOD quad-tree nodes
float m_Elevation; // distance along the subdivision normal (should
// defines the size of the displacement surface
int m_Power; // "size" of the displacement map
// base surface data
CCoreDispSurface m_Surf; // surface containing displacement data
// be changed to match the paint normal next pass)
// Vertex data..
CoreDispVert_t *m_pVerts;
// Triangle data..
CoreDispTri_t *m_pTris;
// render specific data
int m_RenderIndexCount; // number of indices used in rendering
unsigned short *m_RenderIndices; // rendering index list (list of triangles)
int m_RenderCounter; // counter to verify surfaces are renderered/collided with only once per frame
// utility data
bool m_bTouched; // touched flag
CCoreDispInfo *m_pNext; // used for chaining
// The list that this disp is in (used for CDispUtils::IHelper implementation).
CCoreDispInfo **m_ppListBase;
int m_ListSize;
CBitVec<MAX_DISPVERTS> m_AllowedVerts; // Built in VBSP. Defines which verts are allowed to exist based on what the neighbors are.
int m_nListIndex;
//=========================================================================
//
// Creation Functions
//
void GenerateDispSurf( void );
void GenerateDispSurfNormals( void );
void GenerateDispSurfTangentSpaces( void );
bool DoesEdgeExist( int indexRow, int indexCol, int direction, int postSpacing );
void CalcNormalFromEdges( int indexRow, int indexCol, bool bIsEdge[4], Vector& normal );
void CalcDispSurfAlphas( void );
void GenerateLODTree( void );
void CalcVertIndicesAtNodes( int nodeIndex );
int GetNodeVertIndexFromParentIndex( int level, int parentVertIndex, int direction );
void CalcNodeInfo( int nodeIndex, int terminationLevel );
void CalcNeighborVertIndicesAtNode( int nodeIndex, int level );
void CalcNeighborNodeIndicesAtNode( int nodeIndex, int level );
void CalcErrorTermAtNode( int nodeIndex, int level );
float GetMaxErrorFromChildren( int nodeIndex, int level );
void CalcBoundingBoxAtNode( int nodeIndex );
void CalcMinMaxBoundingBoxAtNode( int nodeIndex, Vector& bMin, Vector& bMax );
void CalcTriSurfInfoAtNode( int nodeIndex );
void CalcTriSurfIndices( int nodeIndex, int indices[8][3] );
void CalcTriSurfBoundingBoxes( int nodeIndex, int indices[8][3] );
void CalcRayBoundingBoxes( int nodeIndex, int indices[8][3] );
void CalcTriSurfPlanes( int nodeIndex, int indices[8][3] );
void GenerateCollisionData( void );
void GenerateCollisionSurface( void );
void CreateBoundingBoxes( CoreDispBBox_t *pBBox, int count );
void DispUVToSurf_TriTLToBR( Vector &vecPoint, Vector *pNormal, float *pAlpha, float flU, float flV, const Vector &vecIntersectPoint );
void DispUVToSurf_TriBLToTR( Vector &vecPoint, Vector *pNormal, float *pAlpha, float flU, float flV, const Vector &vecIntersectPoint );
void DispUVToSurf_TriTLToBR_1( const Vector &vecIntersectPoint, int nSnapU, int nNextU, int nSnapV, int nNextV, Vector &vecPoint, Vector *pNormal, float *pAlpha, bool bBackup );
void DispUVToSurf_TriTLToBR_2( const Vector &vecIntersectPoint, int nSnapU, int nNextU, int nSnapV, int nNextV, Vector &vecPoint, Vector *pNormal, float *pAlpha, bool bBackup );
void DispUVToSurf_TriBLToTR_1( const Vector &vecIntersectPoint, int nSnapU, int nNextU, int nSnapV, int nNextV, Vector &vecPoint, Vector *pNormal, float *pAlpha, bool bBackup );
void DispUVToSurf_TriBLToTR_2( const Vector &vecIntersectPoint, int nSnapU, int nNextU, int nSnapV, int nNextV, Vector &vecPoint, Vector *pNormal, float *pAlpha, bool bBackup );
void GetTriangleIndicesForDispBBox( int nIndex, int nTris[2][3] );
void BuildTriTLtoBR( int ndx );
void BuildTriBLtoTR( int ndx );
void InitTris( void );
void CreateTris( void );
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------