vos/3D/a3dl/polygonmesh.hh

Go to the documentation of this file.

/*
    This file is part of the Virtual Object System of
    the Interreality project (http://interreality.org).

    Copyright (C) 2001, 2002 Peter Amstutz

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA

    Peter Amstutz <tetron@interreality.org>
*/
#ifndef _POLYGONMESH_HH_
#define _POLYGONMESH_HH_

#if defined(_WIN32) && defined(_MSC_VER)
# ifdef A3DL_EXPORTS
#  define A3DL_API __declspec(dllexport)
# else
#  define A3DL_API __declspec(dllimport)
# endif
#else
# define A3DL_API
#endif

#include <vos/corelibs/vos/vos.hh>
#include <vos/metaobjects/property/property.hh>
#include <vector>
#include "object3d.hh"
#include "portal.hh"

namespace A3DL
{
    class A3DL_API PolygonMesh : public virtual Object3D
    {
    public:
        PolygonMesh(MetaObject* superobject);
        ~PolygonMesh();

        struct Vertex
        {
            float x, y, z;
        };

        typedef vector<int> Polygon;

        struct Texel
        {
            float x, y;
        };

        enum TextureType { NoTexture = 0, UVcoord = 1, PolygonPlane = 2, ArbitraryPlane = 3, TexMatrix = 4};
        struct TextureSpace {
            TextureType type;
            bool isPortal;
            unsigned char material;
            union {
                struct {
                    int vert1;
                    float u1, v1;
                    int vert2;
                    float u2, v2;
                    int vert3;
                    float u3, v3;
                } UVcoord;
                struct {
                    float xorg, yorg, zorg;
                    float x, y, z, len;
                } PolygonPlane;
                struct {
                    float xorg, yorg, zorg;
                    float x1, y1, z1, len1;
                    float x2, y2, z2, len2;
                } ArbitraryPlane;
                struct {
                    float m11, m12, m13;
                    float m21, m22, m23;
                    float m31, m32, m33;
                    float x, y, z;
                } Matrix;
            } Rep;
        };


        /** Set a single vertex.
            @param which the index of vertex to set
            @param v the new vertex value
        */
        virtual void setVertex(unsigned int which, Vertex& v);

        /** Set all vertices at once.
            @param v the new vertex array
         */
        virtual void setVertices(const vector<Vertex>& v);

        /** Get all vertices
            @param v the vertices will be filled into this vector
         */
        virtual void getVertices(vector<Vertex>& v);


        /** Change a single polygon.  This is very efficient for
            strictly triangular meshes, less efficient for polygonal
            meshes.
            @param which the index of polygon to set
            @param v the new polygon
        */
        virtual void setPolygon(unsigned int which, Polygon& v);

        /** Set all polygons at once.
            @param v new polygon list
        */
        virtual void setPolygons(const vector<Polygon>& v);

        /** Get all polygons.
            @param v the polygons will be filled into this vector
         */
        virtual void getPolygons(vector<Polygon>& v);


        /** Set the vertex normal vector, used for lighting.
            @param which the index of the vertex this normal applies to
            @param v the normal vector value
        */
        virtual void setNormal(unsigned int which, Vertex& v);

        /** Set all the normals at once.
            @param v array of vertex normals
         */
        virtual void setNormals(const vector<Vertex>& v);

        /** Get the normal vectors.
            @param v the normals will be stored in this vector
        */
        virtual void getNormals(vector<Vertex>& v);


        /** Set all UV coordinates at once.
            @param which the vertex index this UV coordinate applies to
            @param v the UV coordinates for this
        */
        virtual void setTexel(int which, Texel& v);

        /** Set all UV coordinates at once.
            @param v the UV coordinates for each vertex.
        */
        virtual void setTexels(const vector<Texel>& v);

        /** Get all UV coordinates.
            @param v the UV coordinates will be stored in this vector
        */
        virtual void getTexels(vector<Texel>& v);

        /** Set the texture mapping for a specific polygon.
            @param which the polygon index to be changed
            @param t the new texture space to use
        */
        virtual void setTextureSpace(unsigned int which, const TextureSpace& t);

        /** Set the per-polygon texture spaces.
            @param t the texture space to use for each polygon
        */
        virtual void setTextureSpaces(const vector<TextureSpace>& t);

        /** Get the current texture spaces used for polygons.
            @param t the texture spaces will be stored here
         */
        virtual void getTextureSpaces(vector<TextureSpace>& t);

        /** Set whether to treat polygons as double sided or single
            sided.  Direction is determined using the cross product of
            the first two edges, with the vertices listed in clockwise
            order.
            @param ds the flag, true for double sided, false for single sided
        */
        virtual void setDoubleSided(bool ds);

        /** Are these polygons double sided?
            @return true for double sided polygons, false for single
            sided polygons.
        */
        virtual bool getDoubleSided();

        virtual vector<Portal*> getPortals();

        static void unpackTextureSpace(const unsigned char* data, TextureSpace& t);
        static void packTextureSpace(unsigned char* data, const TextureSpace& t);

        virtual const string getType();
        static void registerExtenders();
        static MetaObject* new_PolygonMesh(MetaObject* superobject, const string& type);
    };
}

#endif

---