mesh.h

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#ifndef _SCENEPIC_MESH_H_
#define _SCENEPIC_MESH_H_
 
#include "camera.h"
#include "color.h"
#include "json_value.h"
#include "matrix.h"
#include "mesh_info.h"
 
#include <array>
#include <cstdint>
#include <string>
#include <vector>
 
namespace scenepic
{
  class Mesh
  {
  public:
    Mesh(
      const Color& shared_color = Color::None(),
      const std::string& texture_id = "");
 
    std::uint32_t count_vertices() const;
 
    Vector center_of_mass() const;
 
    void reverse_triangle_order();
 
    void apply_transform(const Transform& transform);
 
    void apply_rotation(const Transform& transform);
 
    Mesh get_transformed(const Transform& transform);
 
    Mesh get_rotated(const Transform& transform);
 
    void append_mesh(const Mesh& mesh);
 
    void add_triangle(
      const Color& color = Color::None(),
      const Vector& pos0 = Vector(0, 0, 0),
      const Vector& pos1 = Vector(1, 0, 0),
      const Vector& pos2 = Vector(0, 1, 0),
      const Vector& normal = VectorNone(),
      bool fill_triangles = true,
      bool add_wireframe = false,
      const UV& uv_0 = UV(0, 0),
      const UV& uv_1 = UV(1, 0),
      const UV& uv_2 = UV(0, 1));
 
    void add_quad(
      const Color& color = Color::None(),
      const Vector& pos0 = Vector(0, -0.5f, -0.5f),
      const Vector& pos1 = Vector(0, +0.5f, -0.5f),
      const Vector& pos2 = Vector(0, +0.5f, +0.5f),
      const Vector& pos3 = Vector(0, -0.5f, +0.5f),
      const Vector& normal = VectorNone(),
      bool fill_triangles = true,
      bool add_wireframe = false,
      const Transform& transform = Transform::Identity(),
      const UV& uv_0 = UV(0, 0),
      const UV& uv_1 = UV(1, 0),
      const UV& uv_2 = UV(1, 1),
      const UV& uv_3 = UV(0, 1));
 
    void add_image(
      const Vector& origin = Vector(-0.5f, -0.5f, 0),
      const Vector& x_axis = Vector(1, 0, 0),
      const Vector& y_axis = Vector(0, 1, 0),
      const Vector& normal = VectorNone(),
      const UV& uv_0 = UV(0, 0),
      const UV& uv_1 = UV(1, 0),
      const UV& uv_2 = UV(1, 1),
      const UV& uv_3 = UV(0, 1),
      bool double_sided = true,
      const Transform& transform = Transform::Identity());
 
    void add_cube(
      const Color& color = Color::None(),
      const Transform& transform = Transform::Identity(),
      bool fill_triangles = true,
      bool add_wireframe = false);
 
    void add_thickline(
      const Color& color = Color::None(),
      const Vector& start_point = Vector(-0.5, 0, 0),
      const Vector& end_point = Vector(0.5, 0, 0),
      float start_thickness = 0.1f,
      float end_thickness = 0.1f,
      const Transform& transform = Transform::Identity(),
      bool fill_triangles = true,
      bool add_wireframe = false);
 
    void add_cone(
      const Color& color = Color::None(),
      const Transform& transform = Transform::Identity(),
      float truncation_height = 1,
      std::uint32_t lat_count = 10,
      std::uint32_t long_count = 10,
      bool fill_triangles = true,
      bool add_wireframe = false);
 
    void add_coordinate_axes(
      float length = 1.0f,
      float thickness = 0.1f,
      const Transform& transform = Transform::Identity());
 
    void add_camera_frustum(
      const Color& color = Color::None(),
      float fov_y_degrees = 45.0f,
      float aspect_ratio = 16.0f / 9.0f,
      float depth = 1.0f,
      float thickness = 0.02f,
      const Transform& transform = Transform::Identity());
 
    void add_camera_frustum(
      const Camera& camera,
      const Color& color = Color::None(),
      float thickness = 0.02f,
      float depth = 1.0f);
 
    void add_camera_image(const Camera& camera, float depth = 1.0f);
 
    void add_disc(
      const Color& color = Color::None(),
      const Transform& transform = Transform::Identity(),
      std::uint32_t segment_count = 10,
      bool fill_triangles = true,
      bool add_wireframe = false);
 
    void add_cylinder(
      const Color& color = Color::None(),
      const Transform& transform = Transform::Identity(),
      std::uint32_t segment_count = 10,
      bool fill_triangles = true,
      bool add_wireframe = false);
 
    void add_sphere(
      const Color& color = Color::None(),
      const Transform& transform = Transform::Identity(),
      bool fill_triangles = true,
      bool add_wireframe = false);
 
    void add_icosphere(
      const Color& color = Color::None(),
      const Transform& transform = Transform::Identity(),
      std::uint32_t steps = 0,
      bool fill_triangles = true,
      bool add_wireframe = false);
 
    void add_uv_sphere(
      const Color& color = Color::None(),
      const Transform& transform = Transform::Identity(),
      std::uint32_t lat_count = 10,
      std::uint32_t long_count = 10,
      bool fill_triangles = true,
      bool add_wireframe = false);
 
    void add_mesh_without_normals(
      const ConstVectorBufferRef& vertices,
      const ConstTriangleBufferRef& triangles,
      const ConstColorBufferRef& colors = ColorBufferNone(),
      const ConstUVBufferRef& uvs = UVBufferNone(),
      const Transform& transform = Transform::Identity(),
      bool reverse_triangle_order = false,
      bool fill_triangles = true,
      bool add_wireframe = false);
 
    static VectorBuffer compute_normals(
      const ConstVectorBufferRef& vertices,
      const ConstTriangleBufferRef& triangles,
      bool reverse_triangle_order = false);
 
    void add_mesh_with_normals(
      const ConstVectorBufferRef& vertices,
      const ConstVectorBufferRef& normals,
      const ConstTriangleBufferRef& triangles,
      const ConstColorBufferRef& colors = ColorBufferNone(),
      const ConstUVBufferRef& uvs = UVBufferNone(),
      const Transform& transform = Transform::Identity(),
      bool reverse_triangle_order = false,
      bool fill_triangles = true,
      bool add_wireframe = false);
 
    void add_mesh(
      const std::shared_ptr<MeshInfo>& mesh_info,
      const Transform& transform = Transform::Identity(),
      bool reverse_triangle_order = false,
      bool fill_triangles = true,
      bool add_wireframe = false);
 
    void add_lines(
      const ConstVertexBufferRef& start_points,
      const ConstVertexBufferRef& end_points,
      const Color& color = Color::None(),
      const Transform& transform = Transform::Identity());
 
    void enable_instancing(
      const ConstVectorBufferRef& positions,
      const ConstQuaternionBufferRef& rotations = QuaternionBufferNone(),
      const ConstColorBufferRef& colors = ColorBufferNone());
 
    std::string to_string() const;
 
    JsonValue to_json() const;
 
    const Color& shared_color() const;
 
    Mesh& shared_color(const Color& shared_color);
 
    const std::string& texture_id() const;
 
    Mesh& texture_id(const std::string& texture_id);
 
    const std::string& mesh_id() const;
 
    const std::string& layer_id() const;
 
    Mesh& layer_id(const std::string& layer_id);
 
    bool double_sided() const;
 
    Mesh& double_sided(bool double_sided);
 
    bool camera_space() const;
 
    Mesh& camera_space(bool camera_space);
 
    bool nn_texture() const;
 
    Mesh& nn_texture(bool nn_texture);
 
    bool use_texture_alpha() const;
 
    Mesh& use_texture_alpha(bool use_texture_alpha);
 
    bool is_billboard() const;
 
    Mesh& is_billboard(bool is_billboard);
 
    bool is_label() const;
 
    Mesh& is_label(bool is_label);
 
    const ConstTriangleBufferRef triangles() const;
 
    VertexBlock vertex_positions();
 
    const ConstVertexBlock vertex_positions() const;
 
    Mesh& vertex_positions(const VertexBlock& vertices);
 
    VertexBlock vertex_normals();
 
    Mesh& vertex_normals(const VertexBlock& normals);
 
    const ConstVertexBlock vertex_normals() const;
 
    VertexBlock vertex_colors();
 
    Mesh& vertex_colors(const VertexBlock& colors);
 
    const ConstVertexBlock vertex_colors() const;
 
    VertexBlock vertex_uvs();
 
    Mesh& vertex_uvs(const VertexBlock& uvs);
 
    const ConstVertexBlock vertex_uvs() const;
 
    VertexBufferRef vertex_buffer();
 
    InstanceBufferRef instance_buffer();
 
  private:
    friend class Scene;
 
    Mesh(const std::string& mesh_id);
 
    bool is_instanced() const;
    void check_instances();
    void check_color(const Color& color);
    std::uint32_t
    append_vertex(const Vector& pos, const Vector& normal, const Color& color);
    std::uint32_t
    append_vertex(const Vector& pos, const Vector& normal, UV texture_uv);
    std::uint32_t append_vertex(const Vector& pos, const Vector& normal);
    void append_triangle(
      std::uint32_t index0, std::uint32_t index1, std::uint32_t index2);
    void append_line(std::uint32_t index0, std::uint32_t index1);
    JsonValue definition_to_json() const;
 
    VertexBuffer m_vertices;
    TriangleBuffer m_triangles;
    LineBuffer m_lines;
    Color m_shared_color;
    std::string m_texture_id;
    std::string m_mesh_id;
    std::string m_layer_id;
    bool m_double_sided;
    bool m_camera_space;
    bool m_nn_texture;
    bool m_use_texture_alpha;
    bool m_is_billboard;
    bool m_is_label;
 
    InstanceBuffer m_instance_buffer;
    bool m_instance_buffer_has_rotations;
    bool m_instance_buffer_has_colors;
  };
} // namespace scenepic
 
#endif