screen.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_SHAPES_SCREEN_1107121519_HPP
#define OGLPLUS_SHAPES_SCREEN_1107121519_HPP

#include <oglplus/shapes/draw.hpp>
#include <oglplus/math/vector.hpp>
#include <oglplus/math/sphere.hpp>
#include <oglplus/face_mode.hpp>

#include <oglplus/shapes/vert_attr_info.hpp>

#include <oglplus/math/sphere.hpp>

#include <cassert>
#include <cmath>

namespace oglplus {
namespace shapes {

class Screen
 : public DrawingInstructionWriter
 , public DrawMode
{
public:
    FaceOrientation FaceWinding(void) const
    {
        return FaceOrientation::CW;
    }

    template <typename T>
    GLuint Normals(std::vector<T>& dest) const
    {
        unsigned k = 0;
        dest.resize(12);

        for(unsigned i=0; i!=4; ++i)
        {
            dest[k++] = T(0);
            dest[k++] = T(0);
            dest[k++] = T(1);
        }
        assert(k == dest.size());
        // 3 values per vertex
        return 3;
    }

    template <typename T>
    GLuint Tangents(std::vector<T>& dest) const
    {
        unsigned k = 0;
        dest.resize(12);

        for(unsigned i=0; i!=4; ++i)
        {
            dest[k++] = T(1);
            dest[k++] = T(0);
            dest[k++] = T(0);
        }
        assert(k == dest.size());
        // 3 values per vertex
        return 3;
    }

    template <typename T>
    GLuint Bitangents(std::vector<T>& dest) const
    {
        unsigned k = 0;
        dest.resize(12);

        for(unsigned i=0; i!=4; ++i)
        {
            dest[k++] = T(0);
            dest[k++] = T(1);
            dest[k++] = T(0);
        }
        assert(k == dest.size());
        // 3 values per vertex
        return 3;
    }

    template <typename T>
    GLuint Positions(std::vector<T>& dest) const
    {
        unsigned k = 0;
        dest.resize(8);

        dest[k++] = T(-1);
        dest[k++] = T(-1);

        dest[k++] = T(-1);
        dest[k++] = T(+1);

        dest[k++] = T(+1);
        dest[k++] = T(-1);

        dest[k++] = T(+1);
        dest[k++] = T(+1);

        assert(k == dest.size());
        // 2 values per vertex
        return 2;
    }

    template <typename T>
    GLuint TexCoordinates(std::vector<T>& dest) const
    {
        unsigned k = 0;
        dest.resize(8);

        dest[k++] = T(0);
        dest[k++] = T(0);

        dest[k++] = T(0);
        dest[k++] = T(1);

        dest[k++] = T(1);
        dest[k++] = T(0);

        dest[k++] = T(1);
        dest[k++] = T(1);

        assert(k == dest.size());
        // 2 values per vertex
        return 2;
    }

#if OGLPLUS_DOCUMENTATION_ONLY

    typedef VertexAttribsInfo<Screen> VertexAttribs;
#else
    typedef VertexAttribsInfo<
        Screen,
        std::tuple<
            VertexPositionsTag,
            VertexNormalsTag,
            VertexTangentsTag,
            VertexBitangentsTag,
            VertexTexCoordinatesTag
        >
    > VertexAttribs;
#endif

    template <typename T>
    void BoundingSphere(oglplus::Sphere<T>& bounding_sphere) const
    {
        bounding_sphere = oglplus::Sphere<T>(T(0), T(0), T(0), T(1));
    }

    typedef std::vector<GLuint> IndexArray;

    IndexArray Indices(Default = Default()) const
    {
        return IndexArray();
    }

    DrawingInstructions Instructions(Default = Default()) const
    {
        auto instructions = this->MakeInstructions();

        DrawOperation operation;
        operation.method = DrawOperation::Method::DrawArrays;
        operation.mode = PrimitiveType::TriangleStrip;
        operation.first = GLuint(0);
        operation.count = 4;
        operation.restart_index = DrawOperation::NoRestartIndex();
        operation.phase = 0;
        this->AddInstruction(instructions, operation);

        return instructions;
    }
};

} // shapes
} // oglplus

#endif // include guard