StelOBJ.hpp

/*
 * Stellarium
 * Copyright (C) 2012 Andrei Borza
 * Copyright (C) 2016 Florian Schaukowitsch
 *
 * 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., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
 */

#ifndef _STELOBJ_HPP_
#define _STELOBJ_HPP_

#include "GeomMath.hpp"

#include <qopengl.h>
#include <QLoggingCategory>
#include <QString>
#include <QIODevice>
#include <QVector>
#include <QHash>

Q_DECLARE_LOGGING_CATEGORY(stelOBJ)

class StelOBJ
{
public:
    enum VertexOrder
    {
        XYZ, XZY, YXZ, YZX, ZXY, ZYX
    };

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

        bool operator==(const Vertex& b) const { return !memcmp(this,&b,sizeof(Vertex)); }
    };

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

        Material()
            : illum(I_NONE),
              Ka(-1.0f,-1.0f,-1.0f),Kd(-1.0f,-1.0f,-1.0f),Ks(-1.0f,-1.0f,-1.0f),Ke(-1.0f,-1.0f,-1.0f),
              Ns(8.0f), d(-1.0f)
        {

        }

        QString name;

        QVector3D Ka;
        QVector3D Kd;
        QVector3D Ks;
        QVector3D Ke;
        float Ns;
        float d;

        QString map_Ka;
        QString map_Kd;
        QString map_Ks;
        QString map_Ke;
        QString map_bump;
        QString map_height;


        typedef QMap<QString,QStringList> ParamsMap;
        ParamsMap additionalParams;

        static QVector<Material> loadFromFile(const QString& filename);
    protected:
        static bool parseBool(const QStringList& params, bool &out);
        static bool parseFloat(const QStringList &params, float &out);
        static bool parseVec2d(const QStringList &params, Vec2d &out);
    };


    struct MaterialGroup{
        MaterialGroup()
            : startIndex(0),
              indexCount(0),
              objectIndex(-1),
              materialIndex(-1),
              centroid(0.)
        {
        }

        int startIndex;
        int indexCount;

        int objectIndex;
        int materialIndex;

        Vec3f centroid;
        AABBox boundingbox;
    };

    typedef QVector<MaterialGroup> MaterialGroupList;

    struct Object
    {
        Object()
            : isDefaultObject(false),
              centroid(0.)
        {
        }

        bool isDefaultObject;

        QString name;

        Vec3f centroid;
        AABBox boundingbox;

        MaterialGroupList groups;
    private:
        void postprocess(const StelOBJ& obj, Vec3d& centroid);
        friend class StelOBJ;
    };

    typedef QVector<Vec3f> V3Vec;
    typedef QVector<Vec2f> V2Vec;
    typedef QVector<Vertex> VertexList;
    typedef QVector<unsigned int> IndexList;
    typedef QVector<unsigned short> ShortIndexList;
    typedef QVector<Material> MaterialList;
    typedef QMap<QString, int> MaterialMap;
    typedef QVector<Object> ObjectList;
    typedef QMap<QString, int> ObjectMap;

    StelOBJ();
    virtual ~StelOBJ();

    void clear();

    inline unsigned int getFaceCount() const { return m_indices.size() / 3; }

    inline const VertexList& getVertexList() const { return m_vertices; }
    inline const IndexList& getIndexList() const { return m_indices; }
    inline const MaterialList& getMaterialList() const { return m_materials; }
    inline const ObjectList& getObjectList() const { return m_objects; }
    inline const ObjectMap& getObjectMap() const { return m_objectMap; }
    inline const AABBox& getAABBox() const { return m_bbox; }
    inline const Vec3f& getCentroid() const { return m_centroid; }

    bool load(const QString& filename, const VertexOrder vertexOrder = VertexOrder::XYZ);
    bool load(QIODevice& device, const QString& basePath, const VertexOrder vertexOrder = VertexOrder::XYZ);

    bool isLoaded() const { return m_isLoaded; }

    void rebuildNormals();

    inline bool canUseShortIndices() const { return m_vertices.size() < std::numeric_limits<unsigned short>::max(); }

    ShortIndexList getShortIndexList() const;

    void scale(double factor);

    void transform(const QMatrix4x4& mat, bool onlyPosition = false);

    void splitVertexData(V3Vec* position,
                 V2Vec* texCoord = Q_NULLPTR,
                 V3Vec* normal = Q_NULLPTR,
                 V3Vec* tangent = Q_NULLPTR,
                 V3Vec* bitangent = Q_NULLPTR) const;

    void clearVertexData();
private:
    typedef QVector<QStringRef> ParseParams;
    typedef QHash<Vertex, int> VertexCache;

    struct CurrentParserState
    {
        int currentMaterialIdx;
        MaterialGroup* currentMaterialGroup;
        Object* currentObject;
    };

    bool m_isLoaded;
    //all vertex data is contained in this list
    VertexList m_vertices;
    //all index data is contained in this list
    IndexList m_indices;
    //all material data is contained in this list
    MaterialList m_materials;
    MaterialMap m_materialMap;
    ObjectList m_objects;
    ObjectMap m_objectMap;

    //global bounding box
    AABBox m_bbox;
    //global centroid
    Vec3f m_centroid;

    inline Object* getCurrentObject(CurrentParserState& state);
    inline MaterialGroup* getCurrentMaterialGroup(CurrentParserState& state);
    inline int getCurrentMaterialIndex(CurrentParserState& state);
    inline static bool parseBool(const ParseParams& params, bool& out, int paramsStart=1);
    inline static bool parseInt(const ParseParams& params, int& out, int paramsStart=1);
    inline static bool parseString(const ParseParams &params, QString &out, int paramsStart=1);
    inline static QString getRestOfString(const QString &strip, const QString& line);
    inline static bool parseFloat(const ParseParams& params, float& out, int paramsStart=1);
    template<typename T>
    inline static bool parseVec3(const ParseParams& params, T& out, int paramsStart=1);
    template<typename T>
    inline static bool parseVec2(const ParseParams& params, T& out, int paramsStart=1);
    inline bool parseFace(const ParseParams& params, const V3Vec& posList, const V3Vec& normList, const V2Vec& texList,
                  CurrentParserState &state, VertexCache& vertCache);

    inline void addObject(const QString& name, CurrentParserState& state);

    void generateNormals();

    void generateTangents();

    void generateAABB();

    void performPostProcessing(bool genNormals);
};

inline uint qHash(const StelOBJ::Vertex& key, uint seed)
{
#if (QT_VERSION >= QT_VERSION_CHECK(5,4,0))
    //hash the whole vertex raw memory directly
    return qHashBits(&key, sizeof(StelOBJ::Vertex), seed);
#else
    //no qHashBits, hash just the position and first uv coord
    uint h1 = qHash(reinterpret_cast<const quint64*>(key.position)[0], seed);
    uint h2 = qHash(reinterpret_cast<const quint64*>(key.position)[1], seed);

    return ((h1 << 16) | (h1 >> 16)) ^ h2 ^ seed;
#endif
}

#endif // _STELOBJ_HPP_