StelGeometryBuilder.hpp

/*
 * Stellarium
 * Copyright (C) 2012 Ferdinand Majerech
 *
 * 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 _STELGEOMETRYBUILDER_HPP_
#define _STELGEOMETRYBUILDER_HPP_


#include "GenericVertexTypes.hpp"
#include "StelIndexBuffer.hpp"
#include "StelLight.hpp"
#include "StelProjector.hpp"
#include "StelVertexBuffer.hpp"
#include "VecMath.hpp"


struct SphereParams
{
    SphereParams(const float radius)
        : radius_(radius)
        , oneMinusOblateness_(1.0f)
        , slices_(20)
        , stacks_(20)
        , orientInside_(false)
        , flipTexture_(false)
    {
    }

    SphereParams& oneMinusOblateness(const float rhs)
    {
        oneMinusOblateness_ = rhs;
        return *this;
    }

    SphereParams& resolution(const int slices, const int stacks)
    {
        slices_ = slices;
        stacks_ = stacks;
        return *this;
    }

    SphereParams& orientInside()
    {
        orientInside_ = true;
        return *this;
    }

    SphereParams& flipTexture()
    {
        flipTexture_ = true;
        return *this;
    }

    float radius_;
    float oneMinusOblateness_;
    int slices_;
    int stacks_;
    bool orientInside_;
    bool flipTexture_;
};


class StelGeometrySphere
{
friend class StelGeometryBuilder;
private:
    enum SphereType
    {
        SphereType_Fisheye,
        SphereType_Unlit,
        SphereType_Lit
    };

public:
    ~StelGeometrySphere()
    {
        if(NULL != unlitVertices)
        {
            Q_ASSERT_X(NULL == litVertices, Q_FUNC_INFO,
                       "Both lit and unlit vertex buffers are used");
            delete unlitVertices;
            unlitVertices = NULL;
        }
        if(NULL != litVertices)
        {
            Q_ASSERT_X(NULL == unlitVertices, Q_FUNC_INFO,
                       "Both lit and unlit vertex buffers are used");
            delete litVertices;
            litVertices = NULL;
        }   
        for(int row = 0; row < rowIndices.size(); ++row)
        {
            delete rowIndices[row];
        }
        rowIndices.clear();
    }

    void draw(class StelRenderer* renderer, StelProjectorP projector);

    void setRadius(const float radius)
    {
        Q_ASSERT_X(radius > 0.0f, Q_FUNC_INFO, "Sphere radius must be greater than zero");
        this->radius = radius;
        updated = true;
    }

    void setOneMinusOblateness(const float oneMinusOblateness)
    {
        Q_ASSERT_X(oneMinusOblateness >= 0.0f && oneMinusOblateness <= 1.0f, Q_FUNC_INFO,
                   "Sphere oneMinusOblateness parameter must be at least zero and at most one");
        this->oneMinusOblateness = oneMinusOblateness;
        updated = true;
    }

    void setResolution(const int slices, const int stacks)
    {
        // The maximums here must match MAX_STACKS and MAX_SLICES in the cpp file.
        Q_ASSERT_X(stacks >= 3 && stacks < 4096, Q_FUNC_INFO,
                   "There must be at least 3 stacks in a sphere, and at most 4096.");
        Q_ASSERT_X(slices >= 3 && slices < 4096, Q_FUNC_INFO,
                   "There must be at least 3 slices in a sphere, and at most 4096.");
        this->stacks = stacks;
        this->slices = slices;
        updated = true;
    }

    void setOrientInside(const bool orientInside)
    {
        this->orientInside = orientInside;
        updated = true;
    }

    void setFlipTexture(const bool flipTexture)
    {
        this->flipTexture = flipTexture;
        updated = true;
    }

    void setLight(const StelLight& light)
    {
        Q_ASSERT_X(type == SphereType_Lit, Q_FUNC_INFO,
                   "Trying to set light for an unlit sphere");
        if(this->light == light){return;}
        this->light = light;
        updated     = true;
    }

private:
    const SphereType type;

    bool updated;

    float radius;
    float oneMinusOblateness;
    int stacks;
    int slices;
    bool orientInside;
    bool flipTexture;

    const float fisheyeTextureFov;

    StelLight light;

    StelVertexBuffer<VertexP3T2>* unlitVertices;
    StelVertexBuffer<VertexP3T2C4>* litVertices;

    QVector<StelIndexBuffer*> rowIndices;

    StelGeometrySphere(const SphereType type, const float textureFov = -100.0f, 
                       const StelLight& light = StelLight())
        : type(type)
        , updated(true)
        , radius(0.0f)
        , oneMinusOblateness(0.0f)
        , stacks(0)
        , slices(0)
        , orientInside(false)
        , flipTexture(false)
        , fisheyeTextureFov(textureFov)
        , light(light)
        , unlitVertices(NULL)
        , litVertices(NULL)
    {
        if(type == SphereType_Fisheye)
        {
            Q_ASSERT_X(textureFov > 0.0f, Q_FUNC_INFO,
                       "Fisheye sphere texture FOV must be greater than zero");
        }
    }

    void regenerate(class StelRenderer* renderer, StelProjectorP projector);
};


struct RingParams
{
    RingParams(const float innerRadius, const float outerRadius)
        : innerRadius_(innerRadius)
        , outerRadius_(outerRadius)
        , loops_(20)
        , slices_(20)
        , flipFaces_(false)
    {
    }

    RingParams& resolution(const int slices, const int loops)
    {
        slices_ = slices;
        loops_ = loops;
        return *this;
    }

    RingParams& flipFaces()
    {
        flipFaces_ = true;
        return *this;
    }

    float innerRadius_; 
    float outerRadius_;
    int loops_;
    int slices_;
    bool flipFaces_;
};


class StelGeometryRing
{
friend class StelGeometryBuilder;
private:
    enum RingType
    {
        RingType_Textured,
        RingType_Plain2D
    };

public:
    ~StelGeometryRing()
    {
        if(NULL != texturedVertices)
        {
            Q_ASSERT_X(NULL == plain2DVertices, Q_FUNC_INFO,
                       "Both textured and 2D vertex buffers are used");
            delete texturedVertices;
            texturedVertices = NULL;
        }
        if(NULL != plain2DVertices)
        {
            Q_ASSERT_X(NULL == texturedVertices, Q_FUNC_INFO,
                       "Both textured and 2D vertex buffers are used");
            delete plain2DVertices;
            plain2DVertices = NULL;
        }
        for(int loop = 0; loop < loopIndices.size(); ++loop)
        {
            delete loopIndices[loop];
        }
        loopIndices.clear();
    }

    void draw(class StelRenderer* renderer, StelProjectorP projector = StelProjectorP());
    
    void setInnerOuterRadius(const float inner, const float outer)
    {
        Q_ASSERT_X(inner > 0.0f, Q_FUNC_INFO, "Inner ring radius must be greater than zero");

        // No need to regenerate
        if(inner == this->innerRadius && outer == this->outerRadius) {return;}

        this->innerRadius = inner;
        this->outerRadius = outer;
        updated = true;
    }

    void setResolution(const int slices, const int loops)
    {
        Q_ASSERT_X(loops >= 1, Q_FUNC_INFO, "There must be at least 1 loop in a ring");
        // Must correspond with MAX_SLICES in the .cpp file.
        Q_ASSERT_X(slices >= 3 && slices <= 4096, Q_FUNC_INFO,
                   "There must be at least 3 and at most 4096 slices in a ring.");

        // No need to regenerate
        if(slices == this->slices && loops == this->loops) {return;}

        this->loops = loops;
        this->slices = slices;
        updated = true;
    }

    void setFlipFaces(const bool flipFaces)
    {
        // No need to regenerate
        if(flipFaces == this->flipFaces) {return;}
        this->flipFaces = flipFaces;
        updated = true;
    }

    void setOffset(const Vec3f offset)
    {
        // No need to regenerate
        if(offset == this->offset) {return;}
        this->offset = offset;
        updated = true;
    }

private:
    const RingType type; 

    bool updated;

    float innerRadius; 
    float outerRadius;
    int loops;
    int slices;
    bool flipFaces;
    Vec3f offset;

    StelVertexBuffer<VertexP3T2>* texturedVertices;
    StelVertexBuffer<VertexP2>* plain2DVertices;

    QVector<StelIndexBuffer*> loopIndices;

    StelGeometryRing(const RingType type)
        : type(type)
        , updated(true)
        , innerRadius(0.0f)
        , outerRadius(0.0f)
        , loops(0)
        , slices(0)
        , flipFaces(0)
        , offset(0.0f, 0.0f, 0.0f)
        , texturedVertices(NULL)
        , plain2DVertices(NULL)
    {
    }

    void regenerate(class StelRenderer* renderer);
};


class StelGeometryBuilder
{
public:

    void buildCircle(StelVertexBuffer<VertexP2>* vertexBuffer, 
                     const float x, const float y, const float radius, 
                     const int segments = 128)
    {
        Q_ASSERT_X(radius > 0.0f, Q_FUNC_INFO, "Circle must have a radius greater than zero");
        Q_ASSERT_X(segments > 3, Q_FUNC_INFO, "Circle must have at least 3 segments");
        Q_ASSERT_X(vertexBuffer->length() == 0, Q_FUNC_INFO,
                   "Need an empty vertex buffer to build a circle");
        Q_ASSERT_X(vertexBuffer->primitiveType() == PrimitiveType_LineStrip, Q_FUNC_INFO,
                   "Need a line loop vertex buffer to build a circle");

        const Vec2f center(x,y);
        const float phi = 2.0f * M_PI / segments;
        const float cp = std::cos(phi);
        const float sp = std::sin(phi);
        float dx = radius;
        float dy = 0;

        vertexBuffer->unlock();

        for (int i = 0; i < segments; i++)
        {
            vertexBuffer->addVertex(VertexP2(x + dx, y + dy));
            const float dxNew = dx * cp - dy * sp;
            dy = dx * sp + dy * cp;
            dx = dxNew;
        }
        vertexBuffer->addVertex(VertexP2(x + radius, y));
        vertexBuffer->lock();
    }

    void buildCylinder(StelVertexBuffer<VertexP3T2>* const vertexBuffer, 
                       const float radius, const float height, const int slices,
                       const bool orientInside = false)
    {
        // No need for indices - w/o top/bottom a cylinder is just a single tristrip
        // with no duplicate vertices except start/end

        Q_ASSERT_X(vertexBuffer->length() == 0, Q_FUNC_INFO, 
                   "Need an empty vertex buffer to start building a cylinder");
        Q_ASSERT_X(vertexBuffer->primitiveType() == PrimitiveType_TriangleStrip, 
                    Q_FUNC_INFO, "Need a triangle strip vertex buffer to build a cylinder");
        Q_ASSERT_X(slices >= 3, Q_FUNC_INFO, 
                   "can't build a cylinder with less than 3 slices");

        vertexBuffer->unlock();
        float texCoord = orientInside ? 1.0f : 0.0f;
        float angle    = 0.0f;

        // Needed to generate vertices with opposite winding if orientInside == true.
        const float sign          = orientInside ? -1.0f : 1.0f;
        const float deltaTexCoord = 1.0f / slices;
        const float deltaAngle    = 2.0f * M_PI / slices;

        for (int i = 0; i <= slices; ++i)
        {
            const float x = std::sin(angle) * radius;
            const float y = std::cos(angle) * radius;

            vertexBuffer->addVertex(VertexP3T2(Vec3f(x, y, 0.0f),   Vec2f(texCoord, 0.0f)));
            vertexBuffer->addVertex(VertexP3T2(Vec3f(x, y, height), Vec2f(texCoord, 1.0f)));

            // If oriented outside, we go from 0 at 0deg to 1 at 360deg
            // If oriented inside, we go from 1 at 360 deg to 0 at 0deg
            texCoord += sign * deltaTexCoord;
            angle    += sign * deltaAngle;
        }
        vertexBuffer->lock();
    }

    void buildFanDisk(StelVertexBuffer<VertexP3T2>* const vertexBuffer,
                      StelIndexBuffer* const indexBuffer, const float radius,
                      const int innerFanSlices, const int level);

    StelGeometrySphere* buildSphereFisheye(const SphereParams& params, const float textureFov)
    {
        StelGeometrySphere* result = 
            new StelGeometrySphere(StelGeometrySphere::SphereType_Fisheye, textureFov);
        result->setRadius(params.radius_);
        result->setOneMinusOblateness(params.oneMinusOblateness_);
        result->setResolution(params.slices_, params.stacks_);
        result->setOrientInside(params.orientInside_);
        result->setFlipTexture(params.flipTexture_);
        return result;
    }

    StelGeometrySphere* buildSphereUnlit(const SphereParams& params)
    {
        StelGeometrySphere* result = 
            new StelGeometrySphere(StelGeometrySphere::SphereType_Unlit);
        result->setRadius(params.radius_);
        result->setOneMinusOblateness(params.oneMinusOblateness_);
        result->setResolution(params.slices_, params.stacks_);
        result->setOrientInside(params.orientInside_);
        result->setFlipTexture(params.flipTexture_);
        return result;
    }

    StelGeometrySphere* buildSphereLit(const SphereParams& params, const StelLight& light)
    {
        StelGeometrySphere* result = 
            new StelGeometrySphere(StelGeometrySphere::SphereType_Lit, -100.0f, light);
        result->setRadius(params.radius_);
        result->setOneMinusOblateness(params.oneMinusOblateness_);
        result->setResolution(params.slices_, params.stacks_);
        result->setOrientInside(params.orientInside_);
        result->setFlipTexture(params.flipTexture_);
        return result;
    }

    StelGeometryRing* buildRingTextured
        (const RingParams& params, const Vec3f offset = Vec3f(0.0f, 0.0f, 0.0f))
    {
        StelGeometryRing* result = new StelGeometryRing(StelGeometryRing::RingType_Textured);
        result->setInnerOuterRadius(params.innerRadius_, params.outerRadius_);
        result->setResolution(params.slices_, params.loops_);
        result->setFlipFaces(params.flipFaces_);
        result->setOffset(offset);
        return result;
    }

    StelGeometryRing* buildRing2D
        (const RingParams& params, const Vec2f offset = Vec2f(0.0f, 0.0f))
    {
        StelGeometryRing* result = new StelGeometryRing(StelGeometryRing::RingType_Plain2D);
        result->setInnerOuterRadius(params.innerRadius_, params.outerRadius_);
        result->setResolution(params.slices_, params.loops_);
        result->setFlipFaces(params.flipFaces_);
        result->setOffset(Vec3f(offset[0], offset[1], 0.0f));
        return result;
    }
};
#endif // _STELGEOMETRYBUILDER_HPP_