// This file allows multiple includes.

#if !defined(RT_VERTEX_POSITION) || !defined(RT_VERTEX_NORMAL) || !defined(RT_VERTEX_TEXTURE1) || !defined(RT_VERTEX_TEXTURE2) || !defined(RT_VERTEX_TEXTURE3) || !defined(RT_VERTEX_TEXTURE4) || !defined(RT_FACE_NORMAL) || !defined(RT_MATERIAL) || !defined(RT_MATERIAL)
#error not all required macros are defined in RTMesh.hxx invocation.
#endif

// Just to allow warning-less compilation of some pathological cases
// (which shoudn't be used anyway).
#pragma warning(push)
#ifdef __INTEL_COMPILER
#pragma warning(disable: 504)  // initial value of reference to non-const must be an lvalue
#pragma warning(disable: 473)  // returning reference to local temporary
#endif
#ifdef _MSC_VER
#pragma warning(disable: 4172) // returning address of local variable or temporary
#endif

// Just to make the coding simpler...
#if RTMESH_COMPONENT(RT_VERTEX_POSITION)
#define STORE_VERTEX_POSITION(s) s
#else
#define STORE_VERTEX_POSITION(s)
#endif
#if RTMESH_COMPONENT(RT_VERTEX_NORMAL)
#define STORE_VERTEX_NORMAL(s) s
#else
#define STORE_VERTEX_NORMAL(s)
#endif
#if RTMESH_COMPONENT(RT_VERTEX_TEXTURE1)
#define STORE_VERTEX_TEXTURE1(s) s
#else
#define STORE_VERTEX_TEXTURE1(s)
#endif
#if RTMESH_COMPONENT(RT_VERTEX_TEXTURE2)
#define STORE_VERTEX_TEXTURE2(s) s
#else
#define STORE_VERTEX_TEXTURE2(s)
#endif
#if RTMESH_COMPONENT(RT_VERTEX_TEXTURE2)
#define STORE_VERTEX_TEXTURE2(s) s
#else
#define STORE_VERTEX_TEXTURE2(s)
#endif
#if RTMESH_COMPONENT(RT_VERTEX_TEXTURE4)
#define STORE_VERTEX_TEXTURE4(s) s
#else
#define STORE_VERTEX_TEXTURE4(s)
#endif
#if RTMESH_COMPONENT(RT_FACE_NORMAL)
#define STORE_FACE_NORMAL(s) s
#else
#define STORE_FACE_NORMAL(s)
#endif
#if RTMESH_COMPONENT(RT_MATERIAL)
#define STORE_MATERIAL(s) s
#else
#define STORE_MATERIAL(s)
#endif

// Size for the additional vertex/traingle members 
// (beyond RT_* semanthics), defaulted to 0.
#ifndef RT_VERTEX_DATA
#define RT_VERTEX_DATA 0
#endif
#ifndef RT_FACE_DATA
#define RT_FACE_DATA 0
#endif

// Data types for indices and data 
// (defaulted to int and float if not defined in the includer).
#ifndef IndexType
#define IndexType int
#endif
#ifndef FloatType
#define FloatType float
#endif

namespace RTTL {

    /// \class RTTriangleMesh
    /// Vertices (for indexed meshes), primitives (triangles),
    /// texture coordinates, materials, and geometric normals.
    /// Some of the entries might never be used.
    ///
    /// We will define here a partially specialized instantiation of RTTriangleMesh
    /// (with template parameter equal to RT_MESH_DESCRIPTOR).
    /// Non-specialized instantiations of RTTriangleMesh are prohibited by law.
    template<>
    class RTTriangleMesh<RT_MESH_DESCRIPTOR> {
    public:

        // 2 possibilities:
        typedef RTVec_t<3, FloatType> vec3f;
        // typedef RTVec_t<3, FloatType, RTAlignedData_t<3, FloatType> > vec3f;

        typedef RTVec_t<2, FloatType> vec2f;
        typedef RTVec_t<3, IndexType> vec3i;

        // Vertices do not exist in 'fat triangle' layout.
        #if RTMESH_COMPONENT(RT_VERTEX_POSITION)
        #if defined(STL_MESH_VECTORS)
        typedef RTVec_t<VERTEX_SIZE, FloatType,  0> VertexAsVector;
        #else
        typedef RTVec_t<VERTEX_SIZE, FloatType, 16> VertexAsVector;
        _ALIGN(16) // will not work with stl::vector (at least for current stl implementations).
        #endif
        class Vertex {
        public:
        
            /// Empty default ctor (still need it). There will be other ctors down below.
            Vertex() {}
        
            /// static typing -- it might be necessary to change it to dynamic at certain stage
            /// though it will be unfortunate...
            static const int m_type = RT_VERTEX_TYPE;
            static _INLINE int type() { return m_type; }

            /// Return # of floats in Vertex.
            static _INLINE int size() { return VERTEX_SIZE; }
        
            /// Linearization: overloaded operator* facilitates arithmetic ops over vertices.
            const VertexAsVector& operator*() const { return *(VertexAsVector*)this; }
            VertexAsVector&       operator*()       { return *(VertexAsVector*)this; }
            Vertex(const VertexAsVector& vd) {
                *(VertexAsVector*)this = vd;
            }
            explicit Vertex(const FloatType* v, int n = VERTEX_SIZE) {
                // Only if it is really really needed...
                memcpy((FloatType*)this, v, sizeof(FloatType) * n);
            }
            const VertexAsVector& operator=(const VertexAsVector& vd) {
                return *(VertexAsVector*)this = vd;
            }

            // These are public members though should rarely be accessed directly
            // (better use RTTriangleMesh access member functions).

            #if   RT_VERTEX_POSITION == RT_INDEXED
            vec3f m_vertex_position;
            #endif
            #if RT_VERTEX_NORMAL   == RT_VERTEXDATA
            vec3f m_vertex_normal;
            #endif
            #if RT_VERTEX_TEXTURE1 == RT_VERTEXDATA
            vec2f m_vertex_texture1;
            #endif
            #if RT_VERTEX_TEXTURE2 == RT_VERTEXDATA
            vec2f m_vertex_texture2;
            #endif
            #if RT_VERTEX_TEXTURE3 == RT_VERTEXDATA
            vec2f m_vertex_texture3;
            #endif
            #if RT_VERTEX_TEXTURE4 == RT_VERTEXDATA
            vec2f m_vertex_texture4;
            #endif
            // Application-specific data
            #if RT_VERTEX_DATA > 0
            FloatType m_vertex_data[RT_VERTEX_DATA];
            #endif
        };
        #endif
        
        class Triangle {
        public:

            // These are public members though should rarely be accessed directly
            // (better use RTTriangleMesh access member functions).

            // Per vertex data
            #if   RT_VERTEX_POSITION == RT_INDEXED
            vec3i m_vertex_position_index;
            #elif RT_VERTEX_POSITION == RT_EMBEDDED
            vec3f m_vertex_position[3];
            #endif
            #if   RT_VERTEX_NORMAL   == RT_INDEXED
            vec3i m_vertex_normal_index;
            #elif RT_VERTEX_NORMAL   == RT_EMBEDDED
            vec3f m_vertex_normal[3];
            #endif
            #if   RT_VERTEX_TEXTURE1 == RT_INDEXED
            vec3i m_vertex_texture1_index;
            #elif RT_VERTEX_TEXTURE1 == RT_EMBEDDED
            vec2f m_vertex_texture1[3];
            #endif
            #if   RT_VERTEX_TEXTURE2 == RT_INDEXED
            vec3i m_vertex_texture2_index;
            #elif RT_VERTEX_TEXTURE2 == RT_EMBEDDED
            vec2f m_vertex_texture2[3];
            #endif
            #if   RT_VERTEX_TEXTURE2 == RT_INDEXED
            vec3i m_vertex_texture3_index;
            #elif RT_VERTEX_TEXTURE3 == RT_EMBEDDED
            vec2f m_vertex_texture3[3];
            #endif
            #if   RT_VERTEX_TEXTURE4 == RT_INDEXED
            vec3i m_vertex_texture4_index;
            #elif RT_VERTEX_TEXTURE4 == RT_EMBEDDED
            vec2f m_vertex_texture4[3];
            #endif
        
            // Per triangle data
            #if   RT_FACE_NORMAL     == RT_INDEXED
            IndexType m_face_normal_index;
            #elif RT_FACE_NORMAL     == RT_EMBEDDED
            vec3f m_face_normal;
            #endif
            #if   RT_MATERIAL        == RT_INDEXED
            IndexType m_material_index;
            #elif RT_MATERIAL        == RT_EMBEDDED
            RTMaterial m_material;
            #endif
            // Application-specific data
            #if RT_FACE_DATA > 0
            FloatType m_data[RT_FACE_DATA];
            #endif
        };

        // RTTriangleMesh() {}
        // ~RTTriangleMesh() {}

        long long descriptor() const { return RT_MESH_DESCRIPTOR; }

        _INLINE void clear() {
            // reserve(0) forces delete.
            m_triangle.reserve(0);
            STORE_VERTEX_POSITION(m_vertex.reserve(0));
            STORE_VERTEX_NORMAL  (m_vertex_normal.reserve(0));
            STORE_VERTEX_TEXTURE1(m_vertex_texture1.reserve(0));
            STORE_VERTEX_TEXTURE2(m_vertex_texture2.reserve(0));
            STORE_VERTEX_TEXTURE2(m_vertex_texture3.reserve(0));
            STORE_VERTEX_TEXTURE4(m_vertex_texture4.reserve(0));
            STORE_FACE_NORMAL    (m_face_normal.reserve(0));
            STORE_MATERIAL       (m_material.reserve(0));
        }

        /// Better not to use these 2 functions directly.
        Triangle&       triangle(int ti)       { return m_triangle[ti]; }
        const Triangle& triangle(int ti) const { return m_triangle[ti]; }

        template<typename T>
        _INLINE T* vertexData(int ti, int vi) {
            #if   RT_VERTEX_DATA > 0
            #if   RT_VERTEX_POSITION == RT_INDEXED
            int i = m_triangle[ti].m_vertex_position_index[vi];
            return (T*)m_vertex[i].m_vertex_data;
            #elif RT_VERTEX_POSITION == RT_COMMON
            int i = 3*ti+vi;
            return (T*)m_vertex[i].m_vertex_data;
            #else
            FATAL("vertexData");
            #endif
            #else
            return 0;
            #endif
        }
        template<typename T>
        _INLINE T* vertexData(int vi) {
            #if RT_FACE_DATA > 0
            return (T*)m_vertex[vi].m_vertex_data;
            #else
            return 0;
            #endif
        }
        template<typename T>
        _INLINE T* triangleData(int ti) {
            #if RT_FACE_DATA > 0
            return (T*)m_triangle[ti].m_data;
            #else
            return 0;
            #endif
        }

        // const access functions are implemented through casting to non-const ones,
        // which may not be up to the highest standards, but saves space.

        _INLINE const vec3f& vertexPosition(int ti, int vi) const { return (const vec3f&)((RTTriangleMesh*)this)->vertexPosition(ti, vi); }
        _INLINE vec3f& vertexPosition(int ti, int vi) {
            #if   RT_VERTEX_POSITION == RT_EMBEDDED
            return m_triangle[ti].m_vertex_position[vi];
            #elif RT_VERTEX_POSITION == RT_INDEXED
            int i = m_triangle[ti].m_vertex_position_index[vi];
            return m_vertex[i].m_vertex_position;
            #elif RT_VERTEX_POSITION == RT_COMMON
            return m_vertex[3*ti+vi].m_vertex_position;
            #endif
        }

        _INLINE const vec3f& vertexNormal(int ti, int vi) const { return (const vec3f&)((RTTriangleMesh*)this)->vertexNormal(ti, vi); }
        _INLINE vec3f& vertexNormal(int ti, int vi) {
            #if   RT_VERTEX_NORMAL   == RT_EMBEDDED
            return m_triangle[ti].m_vertex_normal[vi];
            #elif RT_VERTEX_NORMAL   == RT_INDEXED
            int i = m_triangle[ti].m_vertex_normal_index[vi];
            return m_vertex_normal[i];
            #elif RT_VERTEX_NORMAL   == RT_COMMON
            return m_vertex_normal[3*ti+vi];
            #elif RT_VERTEX_NORMAL   == RT_VERTEXDATA
            int i = m_triangle[ti].m_vertex_position_index[vi];
            return m_vertex[i].m_vertex_normal;
            #endif
        }

        _INLINE const vec3f& faceNormal(int ti) const { return (const vec3f&)((RTTriangleMesh*)this)->faceNormal(ti); }
        _INLINE vec3f& faceNormal(int ti) {
            #if   RT_FACE_NORMAL   == RT_EMBEDDED
            return m_triangle[ti].m_face_normal;
            #elif RT_FACE_NORMAL   == RT_INDEXED
            int i = m_triangle[ti].m_face_normal_index;
            return m_face_normal[i];
            #elif RT_FACE_NORMAL   == RT_COMMON
            return m_face_normal[ti];
            #elif RT_FACE_NORMAL   == RT_NOTSET
            const vec3f& v0 = vertexPosition(ti, 0);
            const vec3f& v1 = vertexPosition(ti, 1);
            const vec3f& v2 = vertexPosition(ti, 2);
            return (v0 - v1) ^ (v0 - v2);
            #endif
        }

        /// Per-triangle material.
        _INLINE const RTMaterial& material(int ti) const { return (const RTMaterial&)((RTTriangleMesh*)this)->material(ti); }
        _INLINE RTMaterial& material(int ti) {
            #if   RT_MATERIAL == RT_EMBEDDED
            return m_triangle[ti].m_material;
            #elif RT_MATERIAL == RT_INDEXED
            int i = m_triangle[ti].m_material_index;
            return m_material[i];
            #elif RT_MATERIAL == RT_COMMON
            return m_material[ti];
            #endif
        }

        /// There isn't anything better than replication...
        _INLINE const vec2f& texture1(int ti, int vi) const { return (const vec2f&)((RTTriangleMesh*)this)->texture1(ti, vi); }
        _INLINE vec2f& texture1(int ti, int vi) {
            #if   RT_VERTEX_TEXTURE1   == RT_EMBEDDED
            return m_triangle[ti].m_vertex_texture1[vi];
            #elif RT_VERTEX_TEXTURE1   == RT_INDEXED
            int i = m_triangle[ti].m_vertex_texture1_index[vi];
            return m_vertex_texture1[i];
            #elif RT_VERTEX_TEXTURE1   == RT_COMMON
            return m_vertex_texture1[3*ti+vi];
            #elif RT_VERTEX_TEXTURE1   == RT_VERTEXDATA
            int i = m_triangle[ti].m_vertex_position_index[vi];
            return m_vertex[i].m_vertex_texture1;
            #elif RT_VERTEX_TEXTURE1   == RT_NOTSET
            return vec2f(-1, -1);
            #endif
        }
        _INLINE const vec2f& texture2(int ti, int vi) const { return (const vec2f&)((RTTriangleMesh*)this)->texture2(ti, vi); }
        _INLINE vec2f& texture2(int ti, int vi) {
            #if   RT_VERTEX_TEXTURE2   == RT_EMBEDDED
            return m_triangle[ti].m_vertex_texture2[vi];
            #elif RT_VERTEX_TEXTURE2   == RT_INDEXED
            int i = m_triangle[ti].m_vertex_texture2_index[vi];
            return m_vertex_texture2[i];
            #elif RT_VERTEX_TEXTURE2   == RT_COMMON
            return m_vertex_texture2[3*ti+vi];
            #elif RT_VERTEX_TEXTURE2   == RT_VERTEXDATA
            int i = m_triangle[ti].m_vertex_position_index[vi];
            return m_vertex[i].m_vertex_texture2;
            #else
            return vec2f(-1, -1);
            #endif
        }
        _INLINE const vec2f& texture3(int ti, int vi) const { return (const vec2f&)((RTTriangleMesh*)this)->texture3(ti, vi); }
        _INLINE vec2f& texture3(int ti, int vi) {
            #if   RT_VERTEX_TEXTURE3   == RT_EMBEDDED
            return m_triangle[ti].m_vertex_texture3[vi];
            #elif RT_VERTEX_TEXTURE3   == RT_INDEXED
            int i = m_triangle[ti].m_vertex_texture3_index[vi];
            return m_vertex_texture3[i];
            #elif RT_VERTEX_TEXTURE3   == RT_COMMON
            return m_vertex_texture3[3*ti+vi];
            #elif RT_VERTEX_TEXTURE3   == RT_VERTEXDATA
            int i = m_triangle[ti].m_vertex_position_index[vi];
            return m_vertex[i].m_vertex_texture3;
            #else
            return vec2f(-1, -1);
            #endif
        }
        _INLINE const vec2f& texture4(int ti, int vi) const { return (const vec2f&)((RTTriangleMesh*)this)->texture4(ti, vi); }
        _INLINE vec2f& texture4(int ti, int vi) {
            #if   RT_VERTEX_TEXTURE4   == RT_EMBEDDED
            return m_triangle[ti].m_vertex_texture4[vi];
            #elif RT_VERTEX_TEXTURE4   == RT_INDEXED
            int i = m_triangle[ti].m_vertex_texture4_index[vi];
            return m_vertex_texture4[i];
            #elif RT_VERTEX_TEXTURE4   == RT_COMMON
            return m_vertex_texture4[3*ti+vi];
            #elif RT_VERTEX_TEXTURE4   == RT_VERTEXDATA
            int i = m_triangle[ti].m_vertex_position_index[vi];
            return m_vertex[i].m_vertex_texture4;
            #else
            return vec2f(-1, -1);
            #endif
        }

        _INLINE int numberOfTriangles() { return m_triangle.size(); }

        STORE_VERTEX_POSITION(_INLINE int numberOfVertices()            { return m_vertex.size(); })
        STORE_VERTEX_NORMAL  (_INLINE int numberOfVertexNormals()       { return m_vertex_normal.size(); })
        STORE_VERTEX_TEXTURE1(_INLINE int numberOfTextureCoordinates1() { return m_vertex_texture1.size(); })
        STORE_VERTEX_TEXTURE2(_INLINE int numberOfTextureCoordinates2() { return m_vertex_texture2.size(); })
        STORE_VERTEX_TEXTURE2(_INLINE int numberOfTextureCoordinates3() { return m_vertex_texture3.size(); })
        STORE_VERTEX_TEXTURE4(_INLINE int numberOfTextureCoordinates4() { return m_vertex_texture4.size(); })

        STORE_FACE_NORMAL    (_INLINE int numberOfFaceNormals()         { return m_face_normal.size(); })
        STORE_MATERIAL       (_INLINE int numberOfMaterials()           { return m_material.size(); })

        /// Reservations are not necessary, but advised :)
        _INLINE void setNumberOfTriangles(int n) { m_triangle.reserve(n); }

        STORE_VERTEX_POSITION(_INLINE void setNumberOfVertices(int n)            { m_vertex.reserve(n); })
        STORE_VERTEX_NORMAL  (_INLINE void setNumberOfVertexNormals(int n)       { m_vertex_normal.reserve(n); })
        STORE_VERTEX_TEXTURE1(_INLINE void setNumberOfTextureCoordinates1(int n) { m_vertex_texture1.reserve(n); })
        STORE_VERTEX_TEXTURE2(_INLINE void setNumberOfTextureCoordinates2(int n) { m_vertex_texture2.reserve(n); })
        STORE_VERTEX_TEXTURE2(_INLINE void setNumberOfTextureCoordinates3(int n) { m_vertex_texture3.reserve(n); })
        STORE_VERTEX_TEXTURE4(_INLINE void setNumberOfTextureCoordinates4(int n) { m_vertex_texture4.reserve(n); })

        STORE_FACE_NORMAL    (_INLINE void setNumberOfFaceNormals(int n)         { m_face_normal.reserve(n); })
        STORE_MATERIAL       (_INLINE void setNumberOfMaterials(int n)           { m_material.reserve(n); })

        // Multiple flavors of addSomething functions.

        int addVertexPosition(const vec3f& v0, int vi = -1) {
            #if RT_VERTEX_POSITION == RT_EMBEDDED 
            FATAL("addVertexPosition");
            #else
            if (vi == -1) vi = m_vertex.add();
            m_vertex[vi].m_vertex_position = v0;
            #endif
            return vi;
        }

        int addVertexNormal(const vec3f& v0, int vi = -1) {
            #if RT_VERTEX_NORMAL == RT_EMBEDDED 
            FATAL("addVertexNormal");
            #elif RT_VERTEX_NORMAL == RT_COMMON || RT_VERTEX_NORMAL == RT_INDEXED
            if (vi == -1) vi = m_vertex_normal.add();
            m_vertex_normal[vi] = v0;
            #elif RT_VERTEX_NORMAL == RT_VERTEXDATA
            if (vi == -1) vi = m_vertex.add();
            m_vertex[vi].m_vertex_normal = v0;
            #endif
            return vi;
        }

        int addVertexTexture1(const vec2f& v0, int vi = -1) {
            #if   RT_VERTEX_TEXTURE1 == RT_EMBEDDED 
            FATAL("addVertexTexture1");
            #elif RT_VERTEX_TEXTURE1 == RT_COMMON || RT_VERTEX_TEXTURE1 == RT_INDEXED
            if (vi == -1) vi = m_vertex_texture1.add();
            m_vertex_texture1[vi] = v0;
            #elif RT_VERTEX_TEXTURE1 == RT_VERTEXDATA
            if (vi == -1) vi = m_vertex.add();
            m_vertex[vi].m_vertex_texture1 = v0;
            #endif
            return vi;
        }
        int addVertexTexture2(const vec2f& v0, int vi = -1) {
            #if   RT_VERTEX_TEXTURE2 == RT_EMBEDDED 
            FATAL("addVertexTexture2");
            #elif RT_VERTEX_TEXTURE2 == RT_COMMON || RT_VERTEX_TEXTURE2 == RT_INDEXED
            if (vi == -1) vi = m_vertex_texture2.add();
            m_vertex_texture2[vi] = v0;
            #elif RT_VERTEX_TEXTURE2 == RT_VERTEXDATA
            if (vi == -1) vi = m_vertex.add();
            m_vertex[vi].m_vertex_texture2 = v0;
            #endif
            return vi;
        }
        int addVertexTexture3(const vec2f& v0, int vi = -1) {
            #if   RT_VERTEX_TEXTURE3 == RT_EMBEDDED 
            FATAL("addVertexTexture3");
            #elif RT_VERTEX_TEXTURE3 == RT_COMMON || RT_VERTEX_TEXTURE3 == RT_INDEXED
            if (vi == -1) vi = m_vertex_texture3.add();
            m_vertex_texture3[vi] = v0;
            #elif RT_VERTEX_TEXTURE3 == RT_VERTEXDATA
            if (vi == -1) vi = m_vertex.add();
            m_vertex[vi].m_vertex_texture3 = v0;
            #endif
            return vi;
        }
        int addVertexTexture4(const vec2f& v0, int vi = -1) {
            #if   RT_VERTEX_TEXTURE4 == RT_EMBEDDED 
            FATAL("addVertexTexture4");
            #elif RT_VERTEX_TEXTURE4 == RT_COMMON || RT_VERTEX_TEXTURE4 == RT_INDEXED
            if (vi == -1) vi = m_vertex_texture4.add();
            m_vertex_texture4[vi] = v0;
            #elif RT_VERTEX_TEXTURE4 == RT_VERTEXDATA
            if (vi == -1) vi = m_vertex.add();
            m_vertex[vi].m_vertex_texture4 = v0;
            #endif
            return vi;
        }

        /// Some possible combinations are implemented here;
        /// all other data could be added by obtianing index with addTriangle()
        /// and then using data access functions for specific layouts.
        /// Indices:
        /// ti -- triangle index
        /// vi -- vertex position index
        /// ni -- vertex normal index
        /// mi -- material index
        /// fi -- face normal index

        _INLINE int addTriangle() {
            // Return index of the next triangle.
            return m_triangle.add();
        }
        _INLINE int addTriangle(int i0, int i1, int i2) {
            return addTriangle(RTVec3i(i0, i1, i2));
        }
        _INLINE int addTriangle(const RTVec3i& vi) {
            int ti = addTriangle();
            #if RT_VERTEX_POSITION == RT_INDEXED
            m_triangle[ti].m_vertex_position_index = vi;
            #endif
            return ti;
        }
        _INLINE int addTriangle(const RTVec3i& vi, int mi) {
            int ti = addTriangle(vi);
            #if RT_MATERIAL == RT_INDEXED
            m_triangle[ti].m_material_index = mi;
            #endif
            return ti;
        }
        _INLINE int addTriangle(const RTVec3i& vi, const RTVec3i& ni) {
            int ti = addTriangle(vi);
            #if RT_VERTEX_NORMAL == RT_INDEXED
            m_triangle[ti].m_vertex_normal_index = vi;
            #endif
            return ti;
        }
        _INLINE int addTriangle(const RTVec3i& vi, const RTVec3i& ni, int mi) {
            int ti = addTriangle(vi, ni);
            #if RT_VERTEX_NORMAL == RT_INDEXED
            m_triangle[ti].m_vertex_normal_index = vi;
            #endif
            return ti;
        }
        _INLINE int addTriangleNormal(int ti = -1) {
            if (ti == -1) {
                // Use the last triangle if ti is not defined.
                ti = m_triangle.size() - 1;
            }
            // Compute it on the fly and store in apropriate place.
            const vec3f& v0 = vertexPosition(ti, 0);
            const vec3f& v1 = vertexPosition(ti, 1);
            const vec3f& v2 = vertexPosition(ti, 2);
            vec3f n = (v0 - v1) ^ (v0 - v2);
            // n.normalize(); // do we care?
            return addTriangleNormal(ti, n);
        }
        _INLINE int addTriangleNormal(int ti, const vec3f& n) {
            // Store it in apropriate place.
            #if   RT_FACE_NORMAL     == RT_INDEXED
            m_triangle[ti].m_face_normal_index = m_face_normal.add(n);
            #elif RT_FACE_NORMAL     == RT_EMBEDDED
            m_triangle[ti].m_face_normal = n;
            #endif
            return ti;
        }
        _INLINE int addTriangleNormal(int ti, int fi) {
            // Store it in apropriate place.
            #if   RT_FACE_NORMAL     == RT_INDEXED
            m_triangle[ti].m_face_normal_index = fi;
            #elif RT_FACE_NORMAL     == RT_EMBEDDED
            FATAL("addTriangleNormal");
            #endif
            return ti;
        }


    protected:
        // Mesh components (defined by RT_* macro definitions in the caller, like RTmesh.hxx).
        // Not using plural noons since all these entries are arrays.

        /// Triangles
        RTArray_t<Triangle>   m_triangle;

        /// Vertices (indexed in m_triangle).
        #if   RTMESH_COMPONENT(RT_VERTEX_POSITION)
        RTArray_t<Vertex>     m_vertex;
        #endif

        /// Extra vertex data (indexed in m_triangle or implicitly).
        /// If it is not here, than it is inside m_vertex or RT_NOTSET).
        #if   RTMESH_COMPONENT(RT_VERTEX_NORMAL)
        RTArray_t<vec3f>      m_vertex_normal;
        #endif
        #if   RTMESH_COMPONENT(RT_VERTEX_TEXTURE1)
        RTArray_t<vec2f, -1>  m_vertex_texture1;
        #endif
        #if   RTMESH_COMPONENT(RT_VERTEX_TEXTURE2)
        RTArray_t<vec2f, -1>  m_vertex_texture2;
        #endif
        #if   RTMESH_COMPONENT(RT_VERTEX_TEXTURE2)
        RTArray_t<vec2f, -1>  m_vertex_texture3;
        #endif
        #if   RTMESH_COMPONENT(RT_VERTEX_TEXTURE4)
        RTArray_t<vec2f, -1>  m_vertex_texture4;
        #endif

        /// Extra vertex data (indexed in m_triangle or implicitly).
        /// If it is not here, than it is inside m_vertex or RT_NOTSET).
        #if   RTMESH_COMPONENT(RT_FACE_NORMAL)
        RTArray_t<vec3f>      m_face_normal;
        #endif
        #if   RTMESH_COMPONENT(RT_MATERIAL)
        RTArray_t<RTMaterial, -1> m_material;
        #endif
    };

    /// Streaming.
    #if   RTMESH_COMPONENT(RT_VERTEX_POSITION)
    _INLINE ostream& operator<<(ostream& out, const RTTriangleMesh<RT_MESH_DESCRIPTOR>::Vertex& v) {
        FloatType* data = (FloatType*)&v;

        bool not_defined = false;
        int i;
        for (i = 0; i < v.size(); i++) not_defined |= NOTINITIALIZED(data[i]);
        if (not_defined) {
            out << "[not defined]";
            goto done;
        }

        out << "[" << data[0];
        for (i = 1; i < v.size(); i++) {
            not_defined |= NOTINITIALIZED(data[i]);
            out << "," << (i!=3 && i!=6? " ":"\t");
            out << data[i];
        }
        out << "]";

    done:
        return out;
    }
    #endif

    _INLINE ostream& operator<<(ostream& out, const RTTriangleMesh<RT_MESH_DESCRIPTOR>::Triangle& t) {
        // There is a limited output functionality for a triangle without underlying mesh,
        // mostly for debugging.

        // Per vertex data
        #if   RT_VERTEX_POSITION == RT_INDEXED
        out << "m_vertex_position_index\t= ";
        if (NOTINITIALIZED(t.m_vertex_position_index))
            out << "not defined\n";
        else
            out << t.m_vertex_position_index << endl;
        #elif RT_VERTEX_POSITION == RT_EMBEDDED
        out << "m_vertex_position\t = [";
        if (NOTINITIALIZED(t.m_vertex_position[0]) || NOTINITIALIZED(t.m_vertex_position[1]) || NOTINITIALIZED(t.m_vertex_position[2]))
            out << "not defined\n";
        else
            out << t.m_vertex_position[0] << ", " << t.m_vertex_position[1] << ", " << t.m_vertex_position[2] << "]" << endl;
        #endif
        #if   RT_VERTEX_NORMAL   == RT_INDEXED
        out << "m_vertex_normal_index\t = ";
        if (NOTINITIALIZED(t.m_vertex_normal_index))
            out << "not defined\n";
        else
            out << t.m_vertex_normal_index << endl;
        #elif RT_VERTEX_NORMAL   == RT_EMBEDDED
        out << "m_vertex_normal\t = [";
        if (NOTINITIALIZED(t.m_vertex_normal[0]) || NOTINITIALIZED(t.m_vertex_normal[1]) || NOTINITIALIZED(t.m_vertex_normal[2]))
            out << "not defined]\n";
        else
            out << t.m_vertex_normal[0] << ", " << t.m_vertex_normal[1] << ", " << t.m_vertex_normal[2] << "]" << endl;
        #endif
        #if   RT_VERTEX_TEXTURE1 == RT_INDEXED
        out << "m_vertex_texture1_index\t = ";
        if (NOTINITIALIZED(t.m_vertex_texture1_index))
            out << "not defined\n";
        else
            out << t.m_vertex_texture1_index << endl;
        #elif RT_VERTEX_TEXTURE1 == RT_EMBEDDED
        out << "m_vertex_texture1\t = [";
        if (NOTINITIALIZED(t.m_vertex_texture1[0]) || NOTINITIALIZED(t.m_vertex_texture1[1]))
            out << "not defined]\n";
        else
            out << t.m_vertex_texture1[0] << ", " << t.m_vertex_texture1[1] << "]" << endl;
        #endif
        #if   RT_VERTEX_TEXTURE2 == RT_INDEXED
        out << "m_vertex_texture2_index\t = ";
        if (NOTINITIALIZED(t.m_vertex_texture2_index))
            out << "not defined\n";
        else
            out << t.m_vertex_texture2_index << endl;
        #elif RT_VERTEX_TEXTURE2 == RT_EMBEDDED
        out << "m_vertex_texture2\t = [";
        if (NOTINITIALIZED(t.m_vertex_texture2[0]) || NOTINITIALIZED(t.m_vertex_texture2[1]))
            out << "not defined]\n";
        else
            out << t.m_vertex_texture2[0] << ", " << t.m_vertex_texture2[1] << ", " << t.m_vertex_texture2[2] << "]" << endl;
        #endif
        #if   RT_VERTEX_TEXTURE2 == RT_INDEXED
        out << "m_vertex_texture3_index\t = ";
        if (NOTINITIALIZED(t.m_vertex_texture1[0]) || NOTINITIALIZED(t.m_vertex_texture1[1]))
        if (NOTINITIALIZED(t.m_vertex_texture3_index))
            out << "not defined\n";
        else
            out << t.m_vertex_texture3_index << endl;
        #elif RT_VERTEX_TEXTURE3 == RT_EMBEDDED
        out << "m_vertex_texture3\t = [";
        if (NOTINITIALIZED(t.m_vertex_texture3[0]) || NOTINITIALIZED(t.m_vertex_texture3[1]))
            out << "not defined]\n";
        else
            out << t.m_vertex_texture3[0] << ", " << t.m_vertex_texture3[1] << ", " << t.m_vertex_texture3[2] << "]" << endl;
        #endif
        #if   RT_VERTEX_TEXTURE4 == RT_INDEXED
        out << "m_vertex_texture4_index\t = ";
        if (NOTINITIALIZED(t.m_vertex_texture4_index))
            out << "not defined\n";
        else
            out << t.m_vertex_texture4_index << endl;
        #elif RT_VERTEX_TEXTURE4 == RT_EMBEDDED
        out << "m_vertex_texture4\t = [";
        if (NOTINITIALIZED(t.m_vertex_texture4[0]) || NOTINITIALIZED(t.m_vertex_texture4[1]))
            out << "not defined]\n";
        else
            out << t.m_vertex_texture4[0] << ", " << t.m_vertex_texture4[1] << ", " << t.m_vertex_texture4[2] << "]" << endl;
        #endif
        
        // Per triangle data
        #if   RT_FACE_NORMAL     == RT_INDEXED
        out << "m_face_normal_index\t = ";
        if (NOTINITIALIZED(t.m_face_normal_index))
            out << "not defined\n";
        else
            out << t.m_face_normal_index << endl;
        #elif RT_FACE_NORMAL     == RT_EMBEDDED
        out << "m_face_normal\t = ";
        if (NOTINITIALIZED(t.m_face_normal.x) || NOTINITIALIZED(t.m_face_normal.y) || NOTINITIALIZED(t.m_face_normal.z))
            out << "[not defined]\n";
        else
            out << t.m_face_normal << endl;
        #endif
        #if   RT_MATERIAL        == RT_INDEXED
        out << "m_material_index\t = ";
        if (NOTINITIALIZED(t.m_material_index))
            out << "not defined\n";
        else
            out << t.m_material_index << endl;
        #elif RT_MATERIAL        == RT_EMBEDDED
        out << "m_material\t = ";
        if (NOTINITIALIZED(t.m_material))
            out << "not defined\n";
        else
            out << t.m_material << endl;
        #endif

        #if RT_FACE_DATA > 0
        out << "extra data\t = [";
        if (NOTINITIALIZED(t.m_data[0])) {
            out << "not defined]\n";
        } else {
            out << t.m_data[0];
            for (int i = 1; i < RT_FACE_DATA; i++) {
                out << ", " << t.m_data[i];
            }
            out << "]" << endl;
        }
        #endif

        return out;
    }

// Undefined these definitions to allow a new invocation of this file.
#undef RT_VERTEX_POSITION
#undef RT_VERTEX_NORMAL
#undef RT_VERTEX_TEXTURE1
#undef RT_VERTEX_TEXTURE2
#undef RT_VERTEX_TEXTURE3
#undef RT_VERTEX_TEXTURE4
#undef RT_FACE_NORMAL
#undef RT_MATERIAL

#undef STORE_VERTEX_POSITION
#undef STORE_VERTEX_NORMAL
#undef STORE_VERTEX_TEXTURE1
#undef STORE_VERTEX_TEXTURE2
#undef STORE_VERTEX_TEXTURE2
#undef STORE_VERTEX_TEXTURE4
#undef STORE_FACE_NORMAL
#undef STORE_MATERIAL

#undef RT_VERTEX_DATA
#undef RT_FACE_DATA

#undef IndexType
#undef FloatType

#pragma warning(pop)

};