Shapes.h

//
//  Created by Bradley Austin Davis on 2016/05/26
//  Copyright 2013-2016 High Fidelity, Inc.
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
 
#pragma once
#ifndef hifi_shared_shapes
#define hifi_shared_shapes
 
#include <stdint.h>
 
#include <vector>
#include <array>
 
#include <glm/glm.hpp>
 
namespace geometry {
 
    using Index = uint32_t;
    using Vec = glm::vec3;
    using VertexVector = std::vector<Vec>;
    using TexCoordVector = std::vector<glm::vec2>;
    using IndexVector = std::vector<Index>;
 
    template <size_t N>
    using Face = std::array<Index, N>;
 
    template <size_t N>
    using FaceVector = std::vector<Face<N>>;
 
    template <size_t N>
    struct Solid {
        VertexVector vertices;
        TexCoordVector texCoords;
        FaceVector<N> faces;
 
        template <typename T>
        std::vector<T> getIndices() const {
            size_t count = faces.size() * N;
 
            std::vector<T> indices;
            indices.reserve(count);
            for (const auto& face : faces) {
                for (const auto& index : face) {
                    indices.push_back((T)index);
                }
            }
            return indices;
        }
 
        Solid<N>& fitDimension(float newMaxDimension) {
            float maxDimension = 0;
            for (const auto& vertex : vertices) {
                maxDimension = std::max(maxDimension, std::max(std::max(vertex.x, vertex.y), vertex.z));
            }
            float multiplier = newMaxDimension / maxDimension;
            for (auto& vertex : vertices) {
                vertex *= multiplier;
            }
            return *this;
        }
 
        Vec getFaceNormal(size_t faceIndex) const {
            Vec result;
            const auto& face = faces[faceIndex];
            for (size_t i = 0; i < N; ++i) {
                result += vertices[face[i]];
            }
            result /= N;
            return glm::normalize(result);
        }
    };
 
    template <size_t N>
    size_t triangulatedFaceTriangleCount() {
        return N - 2;
    }
 
    template <size_t N>
    size_t triangulatedFaceIndexCount() {
        return triangulatedFaceTriangleCount<N>() * 3;
    }
 
    Solid<3> tesselate(const Solid<3>& solid, int count);
    const Solid<3>& tetrahedron();
    const Solid<4>& cube();
    const Solid<3>& octahedron();
    const Solid<5>& dodecahedron();
    const Solid<3>& icosahedron();
}
 
#endif