OBJ.hpp

/*
 * Stellarium Scenery3d Plug-in
 *
 * Copyright (C) 2011 Simon Parzer, Peter Neubauer, Georg Zotti, Andrei Borza
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

//-----------------------------------------------------------------------------
// Copyright (c) 2007 dhpoware. All Rights Reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//-----------------------------------------------------------------------------

#ifndef _OBJ_HPP_
#define _OBJ_HPP_

#include <QFile>
#include <QOpenGLBuffer>
#include <QOpenGLVertexArrayObject>

#include "StelTexture.hpp"
#include "VecMath.hpp"
#include "AABB.hpp"

class Heightmap;

class OBJ
{
public:
    enum vertexOrder { XYZ, XZY, YXZ, YZX, ZXY, ZYX };

    struct Material
    {
        enum Illum { I_NONE=-1, I_DIFFUSE=0, I_DIFFUSE_AND_AMBIENT=1, I_SPECULAR=2, I_TRANSLUCENT=9 };
        Illum illum;

        Material() {
            ambient[0] = -1.f;
            ambient[1] = -1.f;
            ambient[2] = -1.f;
            diffuse[0] = 0.8f;
            diffuse[1] = 0.8f;
            diffuse[2] = 0.8f;
            specular[0] = 0.0f;
            specular[1] = 0.0f;
            specular[2] = 0.0f;
            emission[0] = 0.0f;
            emission[1] = 0.0f;
            emission[2] = 0.0f;
            shininess = 8.0f;
            name = "<invalid>";
            alpha = -1.0f;
            alphatest = false;
            backfacecull = true;
            illum = I_NONE;
            hasSpecularity = false;
            hasTransparency = false;
        }

        void finalize();

        QString name;
        QVector3D ambient;
        QVector3D diffuse;
        QVector3D specular;
        QVector3D emission;
        float shininess;
        float alpha;
        bool alphatest;
        bool backfacecull;
        bool hasSpecularity;
        bool hasTransparency;

        QString textureName;
        StelTextureSP texture;
        QString bumpMapName;
        StelTextureSP bump_texture;
        QString heightMapName;
        StelTextureSP height_texture;
        QString emissiveMapName;
        StelTextureSP emissive_texture;
    };


    struct Vertex
    {
        GLfloat position[3];
        GLfloat texCoord[2];
        GLfloat normal[3];
        GLfloat tangent[4];
        GLfloat bitangent[3];

        static const Vertex EmptyVertex;
    };

    struct StelModel
    {
        int startIndex, triangleCount;
        //materials are managed by OBJ
        const Material* pMaterial;
        //AABB is managed by this
        AABB bbox;
        //The centroid location of all vertices of this model
        Vec3f centroid;
    };

    OBJ();
    ~OBJ();

    void clean();
    bool load(const QString& filename, const enum vertexOrder order, bool rebuildNormals = false);
    void transform(QMatrix4x4 mat);
    Material &getMaterial(int i);
    const StelModel& getStelModel(int i) const;

    void finalizeForRendering();

    void transparencyDepthSort(const Vec3f& position);

    int getNumberOfIndices() const;
    int getNumberOfStelModels() const;
    int getNumberOfTriangles() const;
    int getNumberOfVertices() const;
    int getNumberOfMaterials() const;

    const Vertex& getVertex(int i) const;
    const Vertex* getVertexArray() const;
    int getVertexSize() const;

    bool isLoaded() const;
    bool hasPositions() const;
    bool hasTextureCoords() const;
    bool hasNormals() const;
    bool hasTangents() const;
    bool hasStelModels() const;

    //const BoundingBox* getBoundingBox() const;
    const AABB& getBoundingBox();

    void renderAABBs();

    size_t memoryUsage();

    void uploadTexturesGL();
    void uploadBuffersGL();

    void bindGL();
    void unbindGL();

    static void setupGL();
    static inline GLenum getIndexBufferType() { return indexBufferType; }
    static inline size_t getIndexBufferTypeSize() { return indexBufferTypeSize; }

    OBJ& operator=(const OBJ& other);
private:
    struct FaceAttributes
    {
        int materialIndex;
        int objectIndex;
    };

    typedef QVector<FaceAttributes> AttributeVector;
    typedef QVector<Vec3f> VF3Vector;
    typedef QVector<Vec2f> VF2Vector;
    typedef Vec3f VPos;
    typedef QVector<Vec3f> PosVector;
    typedef QMap<QString,int> MatCacheT;
    typedef QMap<int, QVector<int> > VertCacheT;

    void addFaceAttrib(AttributeVector& attributeArray, uint index, int material, int object);
    void addTrianglePos(const PosVector& vertexCoords, VertCacheT &vertexCache, unsigned int index, int v0, int v1, int v2);
    void addTrianglePosNormal(const PosVector &vertexCoords, const VF3Vector& normals, VertCacheT &vertexCache, unsigned int index,
                  int v0, int v1, int v2,
                  int vn0, int vn1, int vn2);
    void addTrianglePosTexCoord(const PosVector &vertexCoords, const VF2Vector &textureCoords, VertCacheT &vertexCache, unsigned int index,
                    int v0, int v1, int v2,
                    int vt0, int vt1, int vt2);
    void addTrianglePosTexCoordNormal(PosVector &vertexCoords, const VF2Vector &textureCoords, const VF3Vector &normals, VertCacheT &vertexCache, unsigned int index,
                      int v0, int v1, int v2,
                      int vt0, int vt1, int vt2,
                      int vn0, int vn1, int vn2);
    int addVertex(VertCacheT &vertexCache, int hash, const Vertex* pVertex);
    void buildStelModels(const AttributeVector &attributeArray);
    void generateNormals();
    void generateTangents();
    void importFirstPass(QFile& pFile, MatCacheT &materialCache);
    void importSecondPass(FILE *pFile, const enum vertexOrder order, const MatCacheT &materialCache);
    bool importMaterials(const QString& filename, MatCacheT& materialCache);
    QString absolutePath(QString path);
    void findBounds();
    void bindBuffersGL();
    void unbindBuffersGL();

    QFile* getFile(const QString& filename);

    QString parseTextureString(const char *buffer) const;

    bool m_loaded;
    bool m_hasPositions;
    bool m_hasTextureCoords;
    bool m_hasNormals;
    bool m_hasTangents;
    bool m_hasStelModels;
    static bool vertexArraysSupported;

    static GLenum indexBufferType;
    static size_t indexBufferTypeSize;
    int m_firstTransparentIndex;

    unsigned int m_numberOfVertexCoords;
    unsigned int m_numberOfTextureCoords;
    unsigned int m_numberOfNormals;
    unsigned int m_numberOfTriangles;
    unsigned int m_numberOfMaterials;
    unsigned int m_numberOfStelModels;

    AABB pBoundingBox;

    QString m_basePath;

    QVector<StelModel> m_stelModels;
    QVector<Material> m_materials;
    QVector<Vertex> m_vertexArray;
    QVector<unsigned int> m_indexArray;

    QOpenGLBuffer m_vertexBuffer;
    QOpenGLBuffer m_indexBuffer;
    QOpenGLVertexArrayObject* m_vertexArrayObject;

    friend class Heightmap;
};

inline OBJ::Material& OBJ::getMaterial(int i) { return m_materials[i]; }

inline const OBJ::StelModel& OBJ::getStelModel(int i) const { return m_stelModels[i]; }

inline int OBJ::getNumberOfIndices() const { return m_numberOfTriangles * 3; }

inline int OBJ::getNumberOfStelModels() const { return m_numberOfStelModels; }

inline int OBJ::getNumberOfTriangles() const { return m_numberOfTriangles; }

inline int OBJ::getNumberOfVertices() const { return static_cast<int>(m_vertexArray.size()); }

inline int OBJ::getNumberOfMaterials() const {return m_numberOfMaterials; }

inline const OBJ::Vertex& OBJ::getVertex(int i) const { return m_vertexArray[i]; }

inline const OBJ::Vertex* OBJ::getVertexArray() const { return &m_vertexArray[0]; }

inline int OBJ::getVertexSize() const { return static_cast<int>(sizeof(Vertex)); }

inline bool OBJ::isLoaded() const{ return m_loaded; }

inline bool OBJ::hasNormals() const{ return m_hasNormals; }

inline bool OBJ::hasPositions() const { return m_hasPositions; }

inline bool OBJ::hasTangents() const { return m_hasTangents; }

inline bool OBJ::hasTextureCoords() const { return m_hasTextureCoords; }

inline bool OBJ::hasStelModels() const { return m_hasStelModels; }

//inline const OBJ::BoundingBox* OBJ::getBoundingBox() const { return pBoundingBox; }
inline const AABB &OBJ::getBoundingBox() {return pBoundingBox; }

inline QString OBJ::absolutePath(QString path) { return m_basePath + path; }

#endif