Fix MSYS2 issues
[xonotic/netradiant.git] / libs / render.h
1 /*
2    Copyright (C) 2001-2006, William Joseph.
3    All Rights Reserved.
4
5    This file is part of GtkRadiant.
6
7    GtkRadiant is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    GtkRadiant is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with GtkRadiant; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20  */
21
22 #if !defined( INCLUDED_RENDER_H )
23 #define INCLUDED_RENDER_H
24
25 /// \file
26 /// \brief High-level constructs for efficient OpenGL rendering.
27
28 #include "irender.h"
29 #include "igl.h"
30
31 #include "container/array.h"
32 #include "math/vector.h"
33 #include "math/pi.h"
34
35 #include <vector>
36
37 typedef unsigned int RenderIndex;
38 const GLenum RenderIndexTypeID = GL_UNSIGNED_INT;
39
40 /// \brief A resizable buffer of indices.
41 class IndexBuffer
42 {
43 typedef std::vector<RenderIndex> Indices;
44 Indices m_data;
45 public:
46 typedef Indices::iterator iterator;
47 typedef Indices::const_iterator const_iterator;
48
49 iterator begin(){
50         return m_data.begin();
51 }
52 const_iterator begin() const {
53         return m_data.begin();
54 }
55 iterator end(){
56         return m_data.end();
57 }
58 const_iterator end() const {
59         return m_data.end();
60 }
61
62 bool empty() const {
63         return m_data.empty();
64 }
65 std::size_t size() const {
66         return m_data.size();
67 }
68 const RenderIndex* data() const {
69         return &( *m_data.begin() );
70 }
71 RenderIndex& operator[]( std::size_t index ){
72         return m_data[index];
73 }
74 const RenderIndex& operator[]( std::size_t index ) const {
75         return m_data[index];
76 }
77 void clear(){
78         m_data.clear();
79 }
80 void reserve( std::size_t max_indices ){
81         m_data.reserve( max_indices );
82 }
83 void insert( RenderIndex index ){
84         m_data.push_back( index );
85 }
86 void swap( IndexBuffer& other ){
87         std::swap( m_data, m_data );
88 }
89 };
90
91 namespace std
92 {
93 /// \brief Swaps the values of \p self and \p other.
94 /// Overloads std::swap.
95 inline void swap( IndexBuffer& self, IndexBuffer& other ){
96         self.swap( other );
97 }
98 }
99
100 /// \brief A resizable buffer of vertices.
101 /// \param Vertex The vertex data type.
102 template<typename Vertex>
103 class VertexBuffer
104 {
105 typedef typename std::vector<Vertex> Vertices;
106 Vertices m_data;
107 public:
108 typedef typename Vertices::iterator iterator;
109 typedef typename Vertices::const_iterator const_iterator;
110
111 iterator begin(){
112         return m_data.begin();
113 }
114 iterator end(){
115         return m_data.end();
116 }
117 const_iterator begin() const {
118         return m_data.begin();
119 }
120 const_iterator end() const {
121         return m_data.end();
122 }
123
124 bool empty() const {
125         return m_data.empty();
126 }
127 RenderIndex size() const {
128         return RenderIndex( m_data.size() );
129 }
130 const Vertex* data() const {
131         return &( *m_data.begin() );
132 }
133 Vertex& operator[]( std::size_t index ){
134         return m_data[index];
135 }
136 const Vertex& operator[]( std::size_t index ) const {
137         return m_data[index];
138 }
139
140 void clear(){
141         m_data.clear();
142 }
143 void reserve( std::size_t max_vertices ){
144         m_data.reserve( max_vertices );
145 }
146 void push_back( const Vertex& vertex ){
147         m_data.push_back( vertex );
148 }
149 };
150
151 /// \brief A wrapper around a VertexBuffer which inserts only vertices which have not already been inserted.
152 /// \param Vertex The vertex data type. Must support operator<, operator== and operator!=.
153 /// For best performance, quantise vertices before inserting them.
154 template<typename Vertex>
155 class UniqueVertexBuffer
156 {
157 typedef VertexBuffer<Vertex> Vertices;
158 Vertices& m_data;
159
160 struct bnode
161 {
162         bnode()
163                 : m_left( 0 ), m_right( 0 ){
164         }
165         RenderIndex m_left;
166         RenderIndex m_right;
167 };
168
169 std::vector<bnode> m_btree;
170 RenderIndex m_prev0;
171 RenderIndex m_prev1;
172 RenderIndex m_prev2;
173
174 const RenderIndex find_or_insert( const Vertex& vertex ){
175         RenderIndex index = 0;
176
177         while ( 1 )
178         {
179                 if ( vertex < m_data[index] ) {
180                         bnode& node = m_btree[index];
181                         if ( node.m_left != 0 ) {
182                                 index = node.m_left;
183                                 continue;
184                         }
185                         else
186                         {
187                                 node.m_left = RenderIndex( m_btree.size() );
188                                 m_btree.push_back( bnode() );
189                                 m_data.push_back( vertex );
190                                 return RenderIndex( m_btree.size() - 1 );
191                         }
192                 }
193                 if ( m_data[index] < vertex ) {
194                         bnode& node = m_btree[index];
195                         if ( node.m_right != 0 ) {
196                                 index = node.m_right;
197                                 continue;
198                         }
199                         else
200                         {
201                                 node.m_right = RenderIndex( m_btree.size() );
202                                 m_btree.push_back( bnode() );
203                                 m_data.push_back( vertex );
204                                 return RenderIndex( m_btree.size() - 1 );
205                         }
206                 }
207
208                 return index;
209         }
210 }
211 public:
212 UniqueVertexBuffer( Vertices& data )
213         : m_data( data ), m_prev0( 0 ), m_prev1( 0 ), m_prev2( 0 ){
214 }
215
216 typedef typename Vertices::const_iterator iterator;
217
218 iterator begin() const {
219         return m_data.begin();
220 }
221 iterator end() const {
222         return m_data.end();
223 }
224
225 std::size_t size() const {
226         return m_data.size();
227 }
228 const Vertex* data() const {
229         return &( *m_data.begin() );
230 }
231 Vertex& operator[]( std::size_t index ){
232         return m_data[index];
233 }
234 const Vertex& operator[]( std::size_t index ) const {
235         return m_data[index];
236 }
237
238 void clear(){
239         m_prev0 = 0;
240         m_prev1 = 0;
241         m_prev2 = 0;
242         m_data.clear();
243         m_btree.clear();
244 }
245 void reserve( std::size_t max_vertices ){
246         m_data.reserve( max_vertices );
247         m_btree.reserve( max_vertices );
248 }
249 /// \brief Returns the index of the element equal to \p vertex.
250 RenderIndex insert( const Vertex& vertex ){
251         if ( m_data.empty() ) {
252                 m_data.push_back( vertex );
253                 m_btree.push_back( bnode() );
254                 return 0;
255         }
256
257         if ( m_data[m_prev0] == vertex ) {
258                 return m_prev0;
259         }
260         if ( m_prev1 != m_prev0 && m_data[m_prev1] == vertex ) {
261                 return m_prev1;
262         }
263         if ( m_prev2 != m_prev0 && m_prev2 != m_prev1 && m_data[m_prev2] == vertex ) {
264                 return m_prev2;
265         }
266
267         m_prev2 = m_prev1;
268         m_prev1 = m_prev0;
269         m_prev0 = find_or_insert( vertex );
270
271         return m_prev0;
272 }
273 };
274
275
276 /// \brief A 4-byte colour.
277 struct Colour4b
278 {
279         unsigned char r, g, b, a;
280
281         Colour4b(){
282         }
283
284         Colour4b( unsigned char _r, unsigned char _g, unsigned char _b, unsigned char _a )
285                 : r( _r ), g( _g ), b( _b ), a( _a ){
286         }
287 };
288
289 const Colour4b colour_vertex( 0, 255, 0, 255 );
290 const Colour4b colour_selected( 0, 0, 255, 255 );
291
292 inline bool operator<( const Colour4b& self, const Colour4b& other ){
293         if ( self.r != other.r ) {
294                 return self.r < other.r;
295         }
296         if ( self.g != other.g ) {
297                 return self.g < other.g;
298         }
299         if ( self.b != other.b ) {
300                 return self.b < other.b;
301         }
302         if ( self.a != other.a ) {
303                 return self.a < other.a;
304         }
305         return false;
306 }
307
308 inline bool operator==( const Colour4b& self, const Colour4b& other ){
309         return self.r == other.r && self.g == other.g && self.b == other.b && self.a == other.a;
310 }
311
312 inline bool operator!=( const Colour4b& self, const Colour4b& other ){
313         return !operator==( self, other );
314 }
315
316 /// \brief A 3-float vertex.
317 struct Vertex3f : public Vector3
318 {
319         Vertex3f(){
320         }
321
322         Vertex3f( float _x, float _y, float _z )
323                 : Vector3( _x, _y, _z ){
324         }
325 };
326
327 inline bool operator<( const Vertex3f& self, const Vertex3f& other ){
328         if ( self.x() != other.x() ) {
329                 return self.x() < other.x();
330         }
331         if ( self.y() != other.y() ) {
332                 return self.y() < other.y();
333         }
334         if ( self.z() != other.z() ) {
335                 return self.z() < other.z();
336         }
337         return false;
338 }
339
340 inline bool operator==( const Vertex3f& self, const Vertex3f& other ){
341         return self.x() == other.x() && self.y() == other.y() && self.z() == other.z();
342 }
343
344 inline bool operator!=( const Vertex3f& self, const Vertex3f& other ){
345         return !operator==( self, other );
346 }
347
348
349 inline Vertex3f vertex3f_from_array( const float* array ){
350         return Vertex3f( array[0], array[1], array[2] );
351 }
352
353 inline float* vertex3f_to_array( Vertex3f& vertex ){
354         return reinterpret_cast<float*>( &vertex );
355 }
356
357 inline const float* vertex3f_to_array( const Vertex3f& vertex ){
358         return reinterpret_cast<const float*>( &vertex );
359 }
360
361 const Vertex3f vertex3f_identity( 0, 0, 0 );
362
363 inline Vertex3f vertex3f_for_vector3( const Vector3& vector3 ){
364         return Vertex3f( vector3.x(), vector3.y(), vector3.z() );
365 }
366
367 inline const Vector3& vertex3f_to_vector3( const Vertex3f& vertex ){
368         return vertex;
369 }
370
371 inline Vector3& vertex3f_to_vector3( Vertex3f& vertex ){
372         return vertex;
373 }
374
375
376 /// \brief A 3-float normal.
377 struct Normal3f : public Vector3
378 {
379         Normal3f(){
380         }
381
382         Normal3f( float _x, float _y, float _z )
383                 : Vector3( _x, _y, _z ){
384         }
385 };
386
387 inline bool operator<( const Normal3f& self, const Normal3f& other ){
388         if ( self.x() != other.x() ) {
389                 return self.x() < other.x();
390         }
391         if ( self.y() != other.y() ) {
392                 return self.y() < other.y();
393         }
394         if ( self.z() != other.z() ) {
395                 return self.z() < other.z();
396         }
397         return false;
398 }
399
400 inline bool operator==( const Normal3f& self, const Normal3f& other ){
401         return self.x() == other.x() && self.y() == other.y() && self.z() == other.z();
402 }
403
404 inline bool operator!=( const Normal3f& self, const Normal3f& other ){
405         return !operator==( self, other );
406 }
407
408
409 inline Normal3f normal3f_from_array( const float* array ){
410         return Normal3f( array[0], array[1], array[2] );
411 }
412
413 inline float* normal3f_to_array( Normal3f& normal ){
414         return reinterpret_cast<float*>( &normal );
415 }
416
417 inline const float* normal3f_to_array( const Normal3f& normal ){
418         return reinterpret_cast<const float*>( &normal );
419 }
420
421 inline Normal3f normal3f_for_vector3( const Vector3& vector3 ){
422         return Normal3f( vector3.x(), vector3.y(), vector3.z() );
423 }
424
425 inline const Vector3& normal3f_to_vector3( const Normal3f& normal ){
426         return normal;
427 }
428
429 inline Vector3& normal3f_to_vector3( Normal3f& normal ){
430         return normal;
431 }
432
433
434 /// \brief A 2-float texture-coordinate set.
435 struct TexCoord2f : public Vector2
436 {
437         TexCoord2f(){
438         }
439
440         TexCoord2f( float _s, float _t )
441                 : Vector2( _s, _t ){
442         }
443
444         float& s(){
445                 return x();
446         }
447         const float& s() const {
448                 return x();
449         }
450         float& t(){
451                 return y();
452         }
453         const float& t() const {
454                 return y();
455         }
456 };
457
458 inline bool operator<( const TexCoord2f& self, const TexCoord2f& other ){
459         if ( self.s() != other.s() ) {
460                 return self.s() < other.s();
461         }
462         if ( self.t() != other.t() ) {
463                 return self.t() < other.t();
464         }
465         return false;
466 }
467
468 inline bool operator==( const TexCoord2f& self, const TexCoord2f& other ){
469         return self.s() == other.s() && self.t() == other.t();
470 }
471
472 inline bool operator!=( const TexCoord2f& self, const TexCoord2f& other ){
473         return !operator==( self, other );
474 }
475
476
477 inline float* texcoord2f_to_array( TexCoord2f& texcoord ){
478         return reinterpret_cast<float*>( &texcoord );
479 }
480
481 inline const float* texcoord2f_to_array( const TexCoord2f& texcoord ){
482         return reinterpret_cast<const float*>( &texcoord );
483 }
484
485 inline const TexCoord2f& texcoord2f_from_array( const float* array ){
486         return *reinterpret_cast<const TexCoord2f*>( array );
487 }
488
489 inline TexCoord2f texcoord2f_for_vector2( const Vector2& vector2 ){
490         return TexCoord2f( vector2.x(), vector2.y() );
491 }
492
493 inline const Vector2& texcoord2f_to_vector2( const TexCoord2f& vertex ){
494         return vertex;
495 }
496
497 inline Vector2& texcoord2f_to_vector2( TexCoord2f& vertex ){
498         return vertex;
499 }
500
501 /// \brief Returns \p normal rescaled to be unit-length.
502 inline Normal3f normal3f_normalised( const Normal3f& normal ){
503         return normal3f_for_vector3( vector3_normalised( normal3f_to_vector3( normal ) ) );
504 }
505
506 enum UnitSphereOctant
507 {
508         UNITSPHEREOCTANT_000 = 0 << 0 | 0 << 1 | 0 << 2,
509         UNITSPHEREOCTANT_001 = 0 << 0 | 0 << 1 | 1 << 2,
510         UNITSPHEREOCTANT_010 = 0 << 0 | 1 << 1 | 0 << 2,
511         UNITSPHEREOCTANT_011 = 0 << 0 | 1 << 1 | 1 << 2,
512         UNITSPHEREOCTANT_100 = 1 << 0 | 0 << 1 | 0 << 2,
513         UNITSPHEREOCTANT_101 = 1 << 0 | 0 << 1 | 1 << 2,
514         UNITSPHEREOCTANT_110 = 1 << 0 | 1 << 1 | 0 << 2,
515         UNITSPHEREOCTANT_111 = 1 << 0 | 1 << 1 | 1 << 2,
516 };
517
518 /// \brief Returns the octant for \p normal indicating the sign of the region of unit-sphere space it lies within.
519 inline UnitSphereOctant normal3f_classify_octant( const Normal3f& normal ){
520         return static_cast<UnitSphereOctant>(
521                            ( ( normal.x() > 0 ) << 0 ) | ( ( normal.y() > 0 ) << 1 ) | ( ( normal.z() > 0 ) << 2 )
522                            );
523 }
524
525 /// \brief Returns \p normal with its components signs made positive based on \p octant.
526 inline Normal3f normal3f_fold_octant( const Normal3f& normal, UnitSphereOctant octant ){
527         switch ( octant )
528         {
529         case UNITSPHEREOCTANT_000:
530                 return Normal3f( -normal.x(), -normal.y(), -normal.z() );
531         case UNITSPHEREOCTANT_001:
532                 return Normal3f( normal.x(), -normal.y(), -normal.z() );
533         case UNITSPHEREOCTANT_010:
534                 return Normal3f( -normal.x(), normal.y(), -normal.z() );
535         case UNITSPHEREOCTANT_011:
536                 return Normal3f( normal.x(), normal.y(), -normal.z() );
537         case UNITSPHEREOCTANT_100:
538                 return Normal3f( -normal.x(), -normal.y(), normal.z() );
539         case UNITSPHEREOCTANT_101:
540                 return Normal3f( normal.x(), -normal.y(), normal.z() );
541         case UNITSPHEREOCTANT_110:
542                 return Normal3f( -normal.x(), normal.y(), normal.z() );
543         case UNITSPHEREOCTANT_111:
544                 return Normal3f( normal.x(), normal.y(), normal.z() );
545         }
546         return Normal3f();
547 }
548
549 /// \brief Reverses the effect of normal3f_fold_octant() on \p normal with \p octant.
550 /// \p normal must have been obtained with normal3f_fold_octant().
551 /// \p octant must have been obtained with normal3f_classify_octant().
552 inline Normal3f normal3f_unfold_octant( const Normal3f& normal, UnitSphereOctant octant ){
553         return normal3f_fold_octant( normal, octant );
554 }
555
556 enum UnitSphereSextant
557 {
558         UNITSPHERESEXTANT_XYZ = 0,
559         UNITSPHERESEXTANT_XZY = 1,
560         UNITSPHERESEXTANT_YXZ = 2,
561         UNITSPHERESEXTANT_YZX = 3,
562         UNITSPHERESEXTANT_ZXY = 4,
563         UNITSPHERESEXTANT_ZYX = 5,
564 };
565
566 /// \brief Returns the sextant for \p normal indicating how to sort its components so that x > y > z.
567 /// All components of \p normal must be positive.
568 /// \p normal must be normalised.
569 inline UnitSphereSextant normal3f_classify_sextant( const Normal3f& normal ){
570         return
571                 normal.x() >= normal.y()
572                 ? normal.x() >= normal.z()
573                 ? normal.y() >= normal.z()
574                 ? UNITSPHERESEXTANT_XYZ
575                 : UNITSPHERESEXTANT_XZY
576                 : UNITSPHERESEXTANT_ZXY
577                 : normal.y() >= normal.z()
578                 ? normal.x() >= normal.z()
579                 ? UNITSPHERESEXTANT_YXZ
580                 : UNITSPHERESEXTANT_YZX
581                 : UNITSPHERESEXTANT_ZYX;
582 }
583
584 /// \brief Returns \p normal with its components sorted so that x > y > z based on \p sextant.
585 /// All components of \p normal must be positive.
586 /// \p normal must be normalised.
587 inline Normal3f normal3f_fold_sextant( const Normal3f& normal, UnitSphereSextant sextant ){
588         switch ( sextant )
589         {
590         case UNITSPHERESEXTANT_XYZ:
591                 return Normal3f( normal.x(), normal.y(), normal.z() );
592         case UNITSPHERESEXTANT_XZY:
593                 return Normal3f( normal.x(), normal.z(), normal.y() );
594         case UNITSPHERESEXTANT_YXZ:
595                 return Normal3f( normal.y(), normal.x(), normal.z() );
596         case UNITSPHERESEXTANT_YZX:
597                 return Normal3f( normal.y(), normal.z(), normal.x() );
598         case UNITSPHERESEXTANT_ZXY:
599                 return Normal3f( normal.z(), normal.x(), normal.y() );
600         case UNITSPHERESEXTANT_ZYX:
601                 return Normal3f( normal.z(), normal.y(), normal.x() );
602         }
603         return Normal3f();
604 }
605
606 /// \brief Reverses the effect of normal3f_fold_sextant() on \p normal with \p sextant.
607 /// \p normal must have been obtained with normal3f_fold_sextant().
608 /// \p sextant must have been obtained with normal3f_classify_sextant().
609 inline Normal3f normal3f_unfold_sextant( const Normal3f& normal, UnitSphereSextant sextant ){
610         return normal3f_fold_sextant( normal, sextant );
611 }
612
613 const std::size_t c_quantise_normal = 1 << 6;
614
615 /// \brief All the components of \p folded must be positive and sorted so that x > y > z.
616 inline Normal3f normal3f_folded_quantised( const Normal3f& folded ){
617         // compress
618         double scale = static_cast<float>( c_quantise_normal ) / ( folded.x() + folded.y() + folded.z() );
619         unsigned int zbits = static_cast<unsigned int>( folded.z() * scale );
620         unsigned int ybits = static_cast<unsigned int>( folded.y() * scale );
621
622         // decompress
623         return normal3f_normalised( Normal3f(
624                                                                         static_cast<float>( c_quantise_normal - zbits - ybits ),
625                                                                         static_cast<float>( ybits ),
626                                                                         static_cast<float>( zbits )
627                                                                         ) );
628 }
629
630 /// \brief Returns \p normal quantised by compressing and then decompressing its representation.
631 inline Normal3f normal3f_quantised_custom( const Normal3f& normal ){
632         UnitSphereOctant octant = normal3f_classify_octant( normal );
633         Normal3f folded = normal3f_fold_octant( normal, octant );
634         UnitSphereSextant sextant = normal3f_classify_sextant( folded );
635         folded = normal3f_fold_sextant( folded, sextant );
636         return normal3f_unfold_octant( normal3f_unfold_sextant( normal3f_folded_quantised( folded ), sextant ), octant );
637 }
638
639
640
641 struct spherical_t
642 {
643         double longditude, latitude;
644
645         spherical_t( double _longditude, double _latitude )
646                 : longditude( _longditude ), latitude( _latitude ){
647         }
648 };
649
650 /*
651    {
652    theta = 2pi * U;
653    phi = acos((2 * V) - 1);
654
655    U = theta / 2pi;
656    V = (cos(phi) + 1) / 2;
657    }
658
659    longitude = atan(y / x);
660    latitude = acos(z);
661  */
662 struct uniformspherical_t
663 {
664         double U, V;
665
666         uniformspherical_t( double U_, double V_ )
667                 : U( U_ ), V( V_ ){
668         }
669 };
670
671
672 inline spherical_t spherical_from_normal3f( const Normal3f& normal ){
673         return spherical_t( normal.x() == 0 ? c_pi / 2 : normal.x() > 0 ? atan( normal.y() / normal.x() ) : atan( normal.y() / normal.x() ) + c_pi, acos( normal.z() ) );
674 }
675
676 inline Normal3f normal3f_from_spherical( const spherical_t& spherical ){
677         return Normal3f(
678                            static_cast<float>( cos( spherical.longditude ) * sin( spherical.latitude ) ),
679                            static_cast<float>( sin( spherical.longditude ) * sin( spherical.latitude ) ),
680                            static_cast<float>( cos( spherical.latitude ) )
681                            );
682 }
683
684 inline uniformspherical_t uniformspherical_from_spherical( const spherical_t& spherical ){
685         return uniformspherical_t( spherical.longditude * c_inv_2pi, ( cos( spherical.latitude ) + 1 ) * 0.5 );
686 }
687
688 inline spherical_t spherical_from_uniformspherical( const uniformspherical_t& uniformspherical ){
689         return spherical_t( c_2pi * uniformspherical.U, acos( ( 2 * uniformspherical.V ) - 1 ) );
690 }
691
692 inline uniformspherical_t uniformspherical_from_normal3f( const Normal3f& normal ){
693         return uniformspherical_from_spherical( spherical_from_normal3f( normal ) );
694         //return uniformspherical_t(atan2(normal.y / normal.x) * c_inv_2pi, (normal.z + 1) * 0.5);
695 }
696
697 inline Normal3f normal3f_from_uniformspherical( const uniformspherical_t& uniformspherical ){
698         return normal3f_from_spherical( spherical_from_uniformspherical( uniformspherical ) );
699 }
700
701 /// \brief Returns a single-precision \p component quantised to \p precision.
702 inline float float_quantise( float component, float precision ){
703         return float_snapped( component, precision );
704 }
705
706 /// \brief Returns a double-precision \p component quantised to \p precision.
707 inline double double_quantise( double component, double precision ){
708         return float_snapped( component, precision );
709 }
710
711 inline spherical_t spherical_quantised( const spherical_t& spherical, float snap ){
712         return spherical_t( double_quantise( spherical.longditude, snap ), double_quantise( spherical.latitude, snap ) );
713 }
714
715 inline uniformspherical_t uniformspherical_quantised( const uniformspherical_t& uniformspherical, float snap ){
716         return uniformspherical_t( double_quantise( uniformspherical.U, snap ), double_quantise( uniformspherical.V, snap ) );
717 }
718
719 /// \brief Returns a \p vertex quantised to \p precision.
720 inline Vertex3f vertex3f_quantised( const Vertex3f& vertex, float precision ){
721         return Vertex3f( float_quantise( vertex.x(), precision ), float_quantise( vertex.y(), precision ), float_quantise( vertex.z(), precision ) );
722 }
723
724 /// \brief Returns a \p normal quantised to a fixed precision.
725 inline Normal3f normal3f_quantised( const Normal3f& normal ){
726         return normal3f_quantised_custom( normal );
727         //return normal3f_from_spherical(spherical_quantised(spherical_from_normal3f(normal), snap));
728         //return normal3f_from_uniformspherical(uniformspherical_quantised(uniformspherical_from_normal3f(normal), snap));
729         //  float_quantise(normal.x, snap), float_quantise(normal.y, snap), float_quantise(normal.y, snap));
730 }
731
732 /// \brief Returns a \p texcoord quantised to \p precision.
733 inline TexCoord2f texcoord2f_quantised( const TexCoord2f& texcoord, float precision ){
734         return TexCoord2f( float_quantise( texcoord.s(), precision ), float_quantise( texcoord.t(), precision ) );
735 }
736
737 /// \brief Standard vertex type for lines and points.
738 struct PointVertex
739 {
740         Colour4b colour;
741         Vertex3f vertex;
742
743         PointVertex(){
744         }
745         PointVertex( Vertex3f _vertex )
746                 : colour( Colour4b( 255, 255, 255, 255 ) ), vertex( _vertex ){
747         }
748         PointVertex( Vertex3f _vertex, Colour4b _colour )
749                 : colour( _colour ), vertex( _vertex ){
750         }
751 };
752
753 inline bool operator<( const PointVertex& self, const PointVertex& other ){
754         if ( self.vertex != other.vertex ) {
755                 return self.vertex < other.vertex;
756         }
757         if ( self.colour != other.colour ) {
758                 return self.colour < other.colour;
759         }
760         return false;
761 }
762
763 inline bool operator==( const PointVertex& self, const PointVertex& other ){
764         return self.colour == other.colour && self.vertex == other.vertex;
765 }
766
767 inline bool operator!=( const PointVertex& self, const PointVertex& other ){
768         return !operator==( self, other );
769 }
770
771 /// \brief Standard vertex type for lit/textured meshes.
772 struct ArbitraryMeshVertex
773 {
774         TexCoord2f texcoord;
775         Normal3f normal;
776         Vertex3f vertex;
777         Normal3f tangent;
778         Normal3f bitangent;
779
780         ArbitraryMeshVertex() : tangent( 0, 0, 0 ), bitangent( 0, 0, 0 ){
781         }
782         ArbitraryMeshVertex( Vertex3f _vertex, Normal3f _normal, TexCoord2f _texcoord )
783                 : texcoord( _texcoord ), normal( _normal ), vertex( _vertex ), tangent( 0, 0, 0 ), bitangent( 0, 0, 0 ){
784         }
785 };
786
787 inline bool operator<( const ArbitraryMeshVertex& self, const ArbitraryMeshVertex& other ){
788         if ( self.texcoord != other.texcoord ) {
789                 return self.texcoord < other.texcoord;
790         }
791         if ( self.normal != other.normal ) {
792                 return self.normal < other.normal;
793         }
794         if ( self.vertex != other.vertex ) {
795                 return self.vertex < other.vertex;
796         }
797         return false;
798 }
799
800 inline bool operator==( const ArbitraryMeshVertex& self, const ArbitraryMeshVertex& other ){
801         return self.texcoord == other.texcoord && self.normal == other.normal && self.vertex == other.vertex;
802 }
803
804 inline bool operator!=( const ArbitraryMeshVertex& self, const ArbitraryMeshVertex& other ){
805         return !operator==( self, other );
806 }
807
808 const float c_quantise_vertex = 1.f / static_cast<float>( 1 << 3 );
809
810 /// \brief Returns \p v with vertex quantised to a fixed precision.
811 inline PointVertex pointvertex_quantised( const PointVertex& v ){
812         return PointVertex( vertex3f_quantised( v.vertex, c_quantise_vertex ), v.colour );
813 }
814
815 const float c_quantise_texcoord = 1.f / static_cast<float>( 1 << 8 );
816
817 /// \brief Returns \p v with vertex, normal and texcoord quantised to a fixed precision.
818 inline ArbitraryMeshVertex arbitrarymeshvertex_quantised( const ArbitraryMeshVertex& v ){
819         return ArbitraryMeshVertex( vertex3f_quantised( v.vertex, c_quantise_vertex ), normal3f_quantised( v.normal ), texcoord2f_quantised( v.texcoord, c_quantise_texcoord ) );
820 }
821
822
823 /// \brief Sets up the OpenGL colour and vertex arrays for \p array.
824 inline void pointvertex_gl_array( const PointVertex* array ){
825         glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof( PointVertex ), &array->colour );
826         glVertexPointer( 3, GL_FLOAT, sizeof( PointVertex ), &array->vertex );
827 }
828
829 class RenderablePointArray : public OpenGLRenderable
830 {
831 const Array<PointVertex>& m_array;
832 const GLenum m_mode;
833 public:
834 RenderablePointArray( const Array<PointVertex>& array, GLenum mode )
835         : m_array( array ), m_mode( mode ){
836 }
837 void render( RenderStateFlags state ) const {
838 #define NV_DRIVER_BUG 1
839 #if NV_DRIVER_BUG
840         glColorPointer( 4, GL_UNSIGNED_BYTE, 0, 0 );
841         glVertexPointer( 3, GL_FLOAT, 0, 0 );
842         glDrawArrays( GL_TRIANGLE_FAN, 0, 0 );
843 #endif
844         pointvertex_gl_array( m_array.data() );
845         glDrawArrays( m_mode, 0, GLsizei( m_array.size() ) );
846 }
847 };
848
849 class RenderablePointVector : public OpenGLRenderable
850 {
851 std::vector<PointVertex> m_vector;
852 const GLenum m_mode;
853 public:
854 RenderablePointVector( GLenum mode )
855         : m_mode( mode ){
856 }
857
858 void render( RenderStateFlags state ) const {
859         pointvertex_gl_array( &m_vector.front() );
860         glDrawArrays( m_mode, 0, GLsizei( m_vector.size() ) );
861 }
862
863 std::size_t size() const {
864         return m_vector.size();
865 }
866 bool empty() const {
867         return m_vector.empty();
868 }
869 void clear(){
870         m_vector.clear();
871 }
872 void reserve( std::size_t size ){
873         m_vector.reserve( size );
874 }
875 void push_back( const PointVertex& point ){
876         m_vector.push_back( point );
877 }
878 };
879
880
881 class RenderableVertexBuffer : public OpenGLRenderable
882 {
883 const GLenum m_mode;
884 const VertexBuffer<PointVertex>& m_vertices;
885 public:
886 RenderableVertexBuffer( GLenum mode, const VertexBuffer<PointVertex>& vertices )
887         : m_mode( mode ), m_vertices( vertices ){
888 }
889
890 void render( RenderStateFlags state ) const {
891         pointvertex_gl_array( m_vertices.data() );
892         glDrawArrays( m_mode, 0, m_vertices.size() );
893 }
894 };
895
896 class RenderableIndexBuffer : public OpenGLRenderable
897 {
898 const GLenum m_mode;
899 const IndexBuffer& m_indices;
900 const VertexBuffer<PointVertex>& m_vertices;
901 public:
902 RenderableIndexBuffer( GLenum mode, const IndexBuffer& indices, const VertexBuffer<PointVertex>& vertices )
903         : m_mode( mode ), m_indices( indices ), m_vertices( vertices ){
904 }
905
906 void render( RenderStateFlags state ) const {
907 #if 1
908         pointvertex_gl_array( m_vertices.data() );
909         glDrawElements( m_mode, GLsizei( m_indices.size() ), RenderIndexTypeID, m_indices.data() );
910 #else
911         glBegin( m_mode );
912         if ( state & RENDER_COLOURARRAY != 0 ) {
913                 for ( std::size_t i = 0; i < m_indices.size(); ++i )
914                 {
915                         glColor4ubv( &m_vertices[m_indices[i]].colour.r );
916                         glVertex3fv( &m_vertices[m_indices[i]].vertex.x );
917                 }
918         }
919         else
920         {
921                 for ( std::size_t i = 0; i < m_indices.size(); ++i )
922                 {
923                         glVertex3fv( &m_vertices[m_indices[i]].vertex.x );
924                 }
925         }
926         glEnd();
927 #endif
928 }
929 };
930
931
932 class RemapXYZ
933 {
934 public:
935 static void set( Vertex3f& vertex, float x, float y, float z ){
936         vertex.x() = x;
937         vertex.y() = y;
938         vertex.z() = z;
939 }
940 };
941
942 class RemapYZX
943 {
944 public:
945 static void set( Vertex3f& vertex, float x, float y, float z ){
946         vertex.x() = z;
947         vertex.y() = x;
948         vertex.z() = y;
949 }
950 };
951
952 class RemapZXY
953 {
954 public:
955 static void set( Vertex3f& vertex, float x, float y, float z ){
956         vertex.x() = y;
957         vertex.y() = z;
958         vertex.z() = x;
959 }
960 };
961
962 template<typename remap_policy>
963 inline void draw_circle( const std::size_t segments, const float radius, PointVertex* vertices, remap_policy remap ){
964         const double increment = c_pi / double(segments << 2);
965
966         std::size_t count = 0;
967         float x = radius;
968         float y = 0;
969         while ( count < segments )
970         {
971                 PointVertex* i = vertices + count;
972                 PointVertex* j = vertices + ( ( segments << 1 ) - ( count + 1 ) );
973
974                 PointVertex* k = i + ( segments << 1 );
975                 PointVertex* l = j + ( segments << 1 );
976
977                 PointVertex* m = i + ( segments << 2 );
978                 PointVertex* n = j + ( segments << 2 );
979                 PointVertex* o = k + ( segments << 2 );
980                 PointVertex* p = l + ( segments << 2 );
981
982                 remap_policy::set( i->vertex, x,-y, 0 );
983                 remap_policy::set( k->vertex,-y,-x, 0 );
984                 remap_policy::set( m->vertex,-x, y, 0 );
985                 remap_policy::set( o->vertex, y, x, 0 );
986
987                 ++count;
988
989                 {
990                         const double theta = increment * count;
991                         x = static_cast<float>( radius * cos( theta ) );
992                         y = static_cast<float>( radius * sin( theta ) );
993                 }
994
995                 remap_policy::set( j->vertex, y,-x, 0 );
996                 remap_policy::set( l->vertex,-x,-y, 0 );
997                 remap_policy::set( n->vertex,-y, x, 0 );
998                 remap_policy::set( p->vertex, x, y, 0 );
999         }
1000 }
1001
1002 #if 0
1003 class PointVertexArrayIterator
1004 {
1005 PointVertex* m_point;
1006 public:
1007 PointVertexArrayIterator( PointVertex* point )
1008         : m_point( point ){
1009 }
1010 PointVertexArrayIterator& operator++(){
1011         ++m_point;
1012         return *this;
1013 }
1014 PointVertexArrayIterator operator++( int ){
1015         PointVertexArrayIterator tmp( *this );
1016         ++m_point;
1017         return tmp;
1018 }
1019 Vertex3f& operator*(){
1020         return m_point.vertex;
1021 }
1022 Vertex3f* operator->(){
1023         return &( operator*() );
1024 }
1025 }
1026
1027 template<typename remap_policy, typename iterator_type
1028                  inline void draw_circle( const std::size_t segments, const float radius, iterator_type start, remap_policy remap ){
1029                          const float increment = c_pi / (double)( segments << 2 );
1030
1031                          std::size_t count = 0;
1032                          iterator_type pxpy( start );
1033                          iterator_type pypx( pxpy + ( segments << 1 ) );
1034                          iterator_type pynx( pxpy + ( segments << 1 ) );
1035                          iterator_type nxpy( pypx + ( segments << 1 ) );
1036                          iterator_type nxny( pypx + ( segments << 1 ) );
1037                          iterator_type nynx( nxpy + ( segments << 1 ) );
1038                          iterator_type nypx( nxpy + ( segments << 1 ) );
1039                          iterator_type pxny( start );
1040                          while ( count < segments )
1041                          {
1042                                  const float theta = increment * count;
1043                                  const float x = radius * cos( theta );
1044                                  const float y = radius * sin( theta );
1045
1046                                  remap_policy::set( ( *pxpy ), x, y, 0 );
1047                                  remap_policy::set( ( *pxny ), x,-y, 0 );
1048                                  remap_policy::set( ( *nxpy ),-x, y, 0 );
1049                                  remap_policy::set( ( *nxny ),-x,-y, 0 );
1050
1051                                  remap_policy::set( ( *pypx ), y, x, 0 );
1052                                  remap_policy::set( ( *pynx ), y,-x, 0 );
1053                                  remap_policy::set( ( *nypx ),-y, x, 0 );
1054                                  remap_policy::set( ( *nynx ),-y,-x, 0 );
1055                          }
1056                  }
1057
1058                  template<typename remap_policy, typename iterator_type
1059                                   inline void draw_semicircle( const std::size_t segments, const float radius, iterator_type start, remap_policy remap )
1060                                   {
1061                                           const float increment = c_pi / (double)( segments << 2 );
1062
1063                                           std::size_t count = 0;
1064                                           iterator_type pxpy( start );
1065                                           iterator_type pypx( pxpy + ( segments << 1 ) );
1066                                           iterator_type pynx( pxpy + ( segments << 1 ) );
1067                                           iterator_type nxpy( pypx + ( segments << 1 ) );
1068                                           iterator_type nxny( pypx + ( segments << 1 ) );
1069                                           iterator_type nynx( nxpy + ( segments << 1 ) );
1070                                           iterator_type nypx( nxpy + ( segments << 1 ) );
1071                                           iterator_type pxny( start );
1072                                           while ( count < segments )
1073                                           {
1074                                                   const float theta = increment * count;
1075                                                   const float x = radius * cos( theta );
1076                                                   const float y = radius * sin( theta );
1077
1078                                                   remap_policy::set( ( *pxpy ), x, y, 0 );
1079                                                   remap_policy::set( ( *pxny ), x,-y, 0 );
1080                                                   remap_policy::set( ( *nxpy ),-x, y, 0 );
1081                                                   remap_policy::set( ( *nxny ),-x,-y, 0 );
1082
1083                           //remap_policy::set((*pypx), y, x, 0);
1084                           //remap_policy::set((*pynx), y,-x, 0);
1085                           //remap_policy::set((*nypx),-y, x, 0);
1086                           //remap_policy::set((*nynx),-y,-x, 0);
1087                                           }
1088                                   }
1089
1090
1091 #endif
1092
1093 inline void draw_quad( const float radius, PointVertex* quad ){
1094         ( *quad ++ ).vertex = Vertex3f( -radius, radius, 0 );
1095         ( *quad ++ ).vertex = Vertex3f( radius, radius, 0 );
1096         ( *quad ++ ).vertex = Vertex3f( radius, -radius, 0 );
1097         ( *quad ++ ).vertex = Vertex3f( -radius, -radius, 0 );
1098 }
1099
1100 inline void draw_cube( const float radius, PointVertex* cube ){
1101         ( *cube ++ ).vertex = Vertex3f( -radius, -radius, -radius );
1102         ( *cube ++ ).vertex = Vertex3f( radius, -radius, -radius );
1103         ( *cube ++ ).vertex = Vertex3f( -radius, radius, -radius );
1104         ( *cube ++ ).vertex = Vertex3f( radius, radius, -radius );
1105         ( *cube ++ ).vertex = Vertex3f( -radius, -radius, radius );
1106         ( *cube ++ ).vertex = Vertex3f( radius, -radius, radius );
1107         ( *cube ++ ).vertex = Vertex3f( -radius, radius, radius );
1108         ( *cube ++ ).vertex = Vertex3f( radius, radius, radius );
1109 }
1110
1111
1112 /// \brief Calculates the tangent vectors for a triangle \p a, \p b, \p c and stores the tangent in \p s and the bitangent in \p t.
1113 inline void ArbitraryMeshTriangle_calcTangents( const ArbitraryMeshVertex& a, const ArbitraryMeshVertex& b, const ArbitraryMeshVertex& c, Vector3& s, Vector3& t ){
1114         s = Vector3( 0, 0, 0 );
1115         t = Vector3( 0, 0, 0 );
1116         {
1117                 Vector3 cross(
1118                         vector3_cross(
1119                                 vector3_subtracted(
1120                                         Vector3( b.vertex.x(), b.texcoord.s(), b.texcoord.t() ),
1121                                         Vector3( a.vertex.x(), a.texcoord.s(), a.texcoord.t() )
1122                                         ),
1123                                 vector3_subtracted(
1124                                         Vector3( c.vertex.x(), c.texcoord.s(), c.texcoord.t() ),
1125                                         Vector3( a.vertex.x(), a.texcoord.s(), a.texcoord.t() )
1126                                         )
1127                                 )
1128                         );
1129
1130                 if ( fabs( cross.x() ) > 0.000001f ) {
1131                         s.x() = -cross.y() / cross.x();
1132                 }
1133
1134                 if ( fabs( cross.x() ) > 0.000001f ) {
1135                         t.x() = -cross.z() / cross.x();
1136                 }
1137         }
1138
1139         {
1140                 Vector3 cross(
1141                         vector3_cross(
1142                                 vector3_subtracted(
1143                                         Vector3( b.vertex.y(), b.texcoord.s(), b.texcoord.t() ),
1144                                         Vector3( a.vertex.y(), a.texcoord.s(), a.texcoord.t() )
1145                                         ),
1146                                 vector3_subtracted(
1147                                         Vector3( c.vertex.y(), c.texcoord.s(), c.texcoord.t() ),
1148                                         Vector3( a.vertex.y(), a.texcoord.s(), a.texcoord.t() )
1149                                         )
1150                                 )
1151                         );
1152
1153                 if ( fabs( cross.x() ) > 0.000001f ) {
1154                         s.y() = -cross.y() / cross.x();
1155                 }
1156
1157                 if ( fabs( cross.x() ) > 0.000001f ) {
1158                         t.y() = -cross.z() / cross.x();
1159                 }
1160         }
1161
1162         {
1163                 Vector3 cross(
1164                         vector3_cross(
1165                                 vector3_subtracted(
1166                                         Vector3( b.vertex.z(), b.texcoord.s(), b.texcoord.t() ),
1167                                         Vector3( a.vertex.z(), a.texcoord.s(), a.texcoord.t() )
1168                                         ),
1169                                 vector3_subtracted(
1170                                         Vector3( c.vertex.z(), c.texcoord.s(), c.texcoord.t() ),
1171                                         Vector3( a.vertex.z(), a.texcoord.s(), a.texcoord.t() )
1172                                         )
1173                                 )
1174                         );
1175
1176                 if ( fabs( cross.x() ) > 0.000001f ) {
1177                         s.z() = -cross.y() / cross.x();
1178                 }
1179
1180                 if ( fabs( cross.x() ) > 0.000001f ) {
1181                         t.z() = -cross.z() / cross.x();
1182                 }
1183         }
1184 }
1185
1186 inline void ArbitraryMeshTriangle_sumTangents( ArbitraryMeshVertex& a, ArbitraryMeshVertex& b, ArbitraryMeshVertex& c ){
1187         Vector3 s, t;
1188
1189         ArbitraryMeshTriangle_calcTangents( a, b, c, s, t );
1190
1191         reinterpret_cast<Vector3&>( a.tangent ) += s;
1192         reinterpret_cast<Vector3&>( b.tangent ) += s;
1193         reinterpret_cast<Vector3&>( c.tangent ) += s;
1194
1195         reinterpret_cast<Vector3&>( a.bitangent ) += t;
1196         reinterpret_cast<Vector3&>( b.bitangent ) += t;
1197         reinterpret_cast<Vector3&>( c.bitangent ) += t;
1198 }
1199
1200
1201 #endif