shapeutils.h

Go to the documentation of this file.

#ifndef ION_GFXUTILS_SHAPEUTILS_H_
#define ION_GFXUTILS_SHAPEUTILS_H_


#include <functional>
#include <istream>  // NOLINT

#include "ion/base/allocator.h"
#include "ion/gfx/bufferobject.h"
#include "ion/gfx/indexbuffer.h"
#include "ion/gfx/shape.h"
#include "ion/math/angle.h"
#include "ion/math/matrix.h"
#include "ion/math/vector.h"

namespace ion {
namespace gfxutils {

struct ShapeSpec {
  enum VertexType {
    kPosition,                 // Position only.
    kPositionTexCoords,        // Position and texture coordinates.
    kPositionNormal,           // Position and normal.
    kPositionTexCoordsNormal,  // Position, texture coordinates, and normal.
  };
  ShapeSpec() : translation(math::Point3f::Zero()),
                scale(1.f),
                rotation(math::Matrix3f::Identity()),
                vertex_type(kPositionTexCoordsNormal),
                usage_mode(gfx::BufferObject::kStaticDraw) {}
  base::AllocatorPtr allocator;  // Used for all allocations (NULL).
  math::Point3f translation;     // Translation (0, 0, 0).
  float scale;                   // Scale factor (1).
  math::Matrix3f rotation;       // Rotation (Identity).
  VertexType vertex_type;        // Type of vertices (kPositionTexCoordsNormal).
  gfx::BufferObject::UsageMode usage_mode;
};




ION_API const gfx::IndexBufferPtr BuildWireframeIndexBuffer(
    const gfx::IndexBufferPtr& tri_index_buffer);




struct ExternalShapeSpec : public ShapeSpec {
  enum Format {
    k3ds,      // Autodesk 3D Studio format.
    kDae,      // Collada Digital Asset Exchange 1.4/1.5 formats.
    kLwo,      // Lightwave Object format.
    kObj,      // Wavefront Object format.
    kOff,      // Geomview file format.
    kUnknown,  // Used as initial value in spec.
  };
  enum IndexSize {
    k16Bit,  // 16-bit indices (unsigned short integer).
    k32Bit,  // 32-bit indices (unsigned integer).
  };
  ExternalShapeSpec()
      : format(kUnknown), center_at_origin(true), index_size(k16Bit) {}
  Format format;
  bool center_at_origin;
  IndexSize index_size;
};

ION_API const gfx::ShapePtr LoadExternalShape(const ExternalShapeSpec& spec,
                                              std::istream& in);  // NOLINT




struct PlanarShapeSpec : public ShapeSpec {
  enum PlaneNormal {
    kPositiveX,  // In YZ-plane, facing +X, width in Z, +S with -Z, +T with +Y.
    kNegativeX,  // In YZ-plane, facing -X, width in Z, +S with +Z, +T with +Y.
    kPositiveY,  // In XZ-plane, facing +Y, width in X, +S with +X, +T with -Z.
    kNegativeY,  // In XZ-plane, facing -Y, width in X, +S with +X, +T with +Z.
    kPositiveZ,  // In XY-plane, facing +Z, width in X, +S with +X, +T with +Y.
    kNegativeZ,  // In XY-plane, facing -Z, width in X, +S with -X, +T with +Y.
  };
  PlanarShapeSpec() : plane_normal(kPositiveZ) {}
  PlaneNormal plane_normal;  // Orientation of plane (kPositiveZ).
};




struct RectangleSpec : public PlanarShapeSpec {
  RectangleSpec() : size(1.f, 1.f) {}
  math::Vector2f size;       // Size of rectangle (1x1).
};

ION_API const gfx::ShapePtr BuildRectangleShape(const RectangleSpec& spec);




struct RegularPolygonSpec : public PlanarShapeSpec {
  RegularPolygonSpec() : sides(3) {}
  int sides;     // The number of sides in the polygon.
};

ION_API const gfx::ShapePtr BuildRegularPolygonShape(
    const RegularPolygonSpec& spec);




struct BoxSpec : public ShapeSpec {
  BoxSpec() : size(1.f, 1.f, 1.f) {}
  math::Vector3f size;       // Size of box (1x1x1).
};

ION_API const gfx::ShapePtr BuildBoxShape(const BoxSpec& spec);




struct EllipsoidSpec : public ShapeSpec {
  EllipsoidSpec()
      : longitude_start(math::Anglef::FromDegrees(0.f)),
        longitude_end(math::Anglef::FromDegrees(360.f)),
        latitude_start(math::Anglef::FromDegrees(-90.f)),
        latitude_end(math::Anglef::FromDegrees(90.f)),
        band_count(10U),
        sector_count(10U),
        size(1.f, 1.f, 1.f) {}

  math::Anglef longitude_start;   // Start longitude angle (0 degrees)
  math::Anglef longitude_end;     // End longitude angle (360 degrees)
  math::Anglef latitude_start;    // Start latitude angle (-90 degrees)
  math::Anglef latitude_end;      // End latitude angle (90 degrees)
  size_t band_count;              // Number of latitudinal bands (10).
  size_t sector_count;            // Number of longitudinal sectors (10).
  math::Vector3f size;            // Size of ellipsoid (1x1x1).
};

ION_API const gfx::ShapePtr BuildEllipsoidShape(const EllipsoidSpec& spec);




struct CylinderSpec : public ShapeSpec {
  CylinderSpec()
      : has_top_cap(true),
        has_bottom_cap(true),
        shaft_band_count(1U),
        cap_band_count(1U),
        sector_count(10U),
        top_radius(.5f),
        bottom_radius(.5f),
        height(1.f) {}
  bool has_top_cap;           // Whether the top cap is present (true).
  bool has_bottom_cap;        // Whether the bottom cap is present (true).
  size_t shaft_band_count;    // Number of bands in the shaft (1).
  size_t cap_band_count;      // Number of bands in each cap (1).
  size_t sector_count;        // Number of longitudinal sectors (10).
  float top_radius;           // Radius of top of cylinder (.5).
  float bottom_radius;        // Radius of bottom of cylinder (.5).
  float height;               // Height of cylinder (1).
};

ION_API const gfx::ShapePtr BuildCylinderShape(const CylinderSpec& spec);

}  // namespace gfxutils
}  // namespace ion

#endif  // ION_GFXUTILS_SHAPEUTILS_H_