m2mpartialmesh.h

Go to the documentation of this file.

#ifndef M2MPARTIALMESH_H
#define M2MPARTIALMESH_H

#include <QVector>
#include <QVector3D>
#include <QSharedPointer>
#include <QMap>

#include "imageandsource.h"
#include "simpletexturedobject.h"
#include "tilematerial.h"

namespace M2M {


class ImageInfo {
public:
    ImageInfo() : mImage(nullptr) {}
    ImageInfo(const ImageInfo &other) = default;
    ImageInfo(SharedImageAndSource img) : mImage(img) {}
    ImageInfo(const TileMaterial *material)
        : mImage(material->texture()) {}

    SharedImageAndSource image() const { return mImage; }

    bool operator ==(const ImageInfo &other) const
    {
        return mImage.data() == other.mImage.data();
    }

    bool operator !=(const ImageInfo &other) const
    {
        return !(*this == other);
    }

private:
    SharedImageAndSource mImage;
};

struct PhongInfo {
    PhongInfo(const TileMaterial *material)
        : ambient(material->ambient())
        , diffuse(material->diffuse())
        , specular(material->specular())
        , shininess(material->shininess()) {}

    float ambient;
    float diffuse;
    float specular;
    float shininess;

    bool operator ==(const PhongInfo &other) const
    {
        return ambient == other.ambient
                && diffuse == other.diffuse
                && specular == other.specular
                && shininess == other.shininess;
    }

    bool operator !=(const PhongInfo &other) const
    {
        return !(*this == other);
    }
};


class Quad
{
public:
    Quad(QVector3D normal,
         ImageInfo texture,
         PhongInfo material,
         QVector3D v1, QVector2D t1,
         QVector3D v2, QVector2D t2,
         QVector3D v3, QVector2D t3,
         QVector3D v4, QVector2D t4);

    QVector3D vertex(int idx) const;
    QVector2D texCoord(int idx) const;

    QVector3D normal() const;

    ImageInfo imageInfo() const;
    PhongInfo phongInfo() const;


    static Quad makeVerticalQuad(QVector3D center,
                                 QVector2D xzDirection,
                                 float width,
                                 float height,
                                 ImageInfo texture,
                                 PhongInfo material,
                                 bool upsideDown = false);


private:
    QVector3D mV1, mV2, mV3, mV4;
    QVector2D mT1, mT2, mT3, mT4;

    QVector3D mNormal;

    ImageInfo mTexture;
    PhongInfo mMaterial;
};


class Trig
{
public:
    Trig(ImageInfo texture,
         PhongInfo material,
         QVector3D v1, QVector2D t1,
         QVector3D v2, QVector2D t2,
         QVector3D v3, QVector2D t3);

    QVector<QVector3D> verts() const { return {mV1, mV2, mV3}; }
    QVector<QVector2D> textureCoords() const { return {mT1, mT2, mT3}; }

    QVector3D normal() const { return mNormal; }

    ImageInfo imageInfo() const { return mTexture; }
    PhongInfo phongInfo() const { return mMaterial; }

private:
    QVector3D mV1, mV2, mV3;
    QVector2D mT1, mT2, mT3;

    ImageInfo mTexture;
    PhongInfo mMaterial;

    QVector3D mNormal;
};


class PreObject
{
public:
    PreObject(ImageInfo img);

    void addQuad(const Quad &q);

    void addTrig(const Trig &t);

    void addPreObject(const PreObject &o);

    QSharedPointer<SimpleTexturedObject> toObject() const;

    ImageInfo imageInfo() const { return mImage; }

private:
    // Face information.
    QVector<QVector3D> mVertexPositions;
    QVector<QVector3D> mTriangleNormals;
    QVector<SimpleTexturedObject::Triangle> mTriangles;

    // Material information.
    QVector<float> mReflAmbient;
    QVector<float> mReflDiffuse;
    QVector<float> mReflSpecular;
    QVector<float> mShininess;

    // Texture information.
    QVector<SimpleTexturedObject::TriangleTexCoords> mTriangleTextureCoordinates;
    SharedImageAndSource mImage;
};

class PartialMeshData
{
public:

    QVector<QSharedPointer<SimpleTexturedObject>> constructObjects();

    void addQuad(const Quad &q);

    void addTrig(const Trig &t);

    void addPartialMesh(const PartialMeshData &p);

    PartialMeshData &operator +=(const PartialMeshData &other)
    {
        addPartialMesh(other);
        return *this;
    }

    PartialMeshData &operator +(const PartialMeshData &other)
    {
        PartialMeshData p = *this;
        return p += other;
    }

private:
    QMap<const QImage *, PreObject> mTexturesToObjects;
};


}

#endif // M2MPARTIALMESH_H