vertices_builder.h

Go to the documentation of this file.

// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#ifndef FLUTTER_IMPELLER_SCENE_IMPORTER_VERTICES_BUILDER_H_
#define FLUTTER_IMPELLER_SCENE_IMPORTER_VERTICES_BUILDER_H_
 
#include <cstddef>
#include <map>
 
#include "impeller/geometry/matrix.h"
#include "impeller/scene/importer/scene_flatbuffers.h"
 
namespace impeller {
namespace scene {
namespace importer {
 
//------------------------------------------------------------------------------
/// VerticesBuilder
///
 
class VerticesBuilder {
 public:
  static std::unique_ptr<VerticesBuilder> MakeUnskinned();
 
  static std::unique_ptr<VerticesBuilder> MakeSkinned();
 
  enum class ComponentType {
    kSignedByte = 5120,
    kUnsignedByte,
    kSignedShort,
    kUnsignedShort,
    kSignedInt,
    kUnsignedInt,
    kFloat,
  };
 
  enum class AttributeType {
    kPosition,
    kNormal,
    kTangent,
    kTextureCoords,
    kColor,
    kJoints,
    kWeights,
  };
 
  using ComponentConverter = std::function<
      Scalar(const void* source, size_t byte_offset, bool normalized)>;
  struct ComponentProperties {
    size_t size_bytes = 0;
    ComponentConverter convert_proc;
  };
 
  struct AttributeProperties;
  using AttributeWriter =
      std::function<void(Scalar* destination,
                         const void* source,
                         const ComponentProperties& component_props,
                         const AttributeProperties& attribute_props)>;
  struct AttributeProperties {
    size_t offset_bytes = 0;
    size_t size_bytes = 0;
    size_t component_count = 0;
    AttributeWriter write_proc;
  };
 
  VerticesBuilder();
 
  virtual ~VerticesBuilder();
 
  virtual void WriteFBVertices(fb::MeshPrimitiveT& primitive) const = 0;
 
  virtual void SetAttributeFromBuffer(AttributeType attribute,
                                      ComponentType component_type,
                                      const void* buffer_start,
                                      size_t attribute_stride_bytes,
                                      size_t attribute_count) = 0;
 
 protected:
  static void WriteAttribute(void* destination,
                             size_t destination_stride_bytes,
                             AttributeType attribute,
                             ComponentType component_type,
                             const void* source,
                             size_t attribute_stride_bytes,
                             size_t attribute_count);
 
 private:
  static std::map<VerticesBuilder::AttributeType,
                  VerticesBuilder::AttributeProperties>
      kAttributeTypes;
 
  VerticesBuilder(const VerticesBuilder&) = delete;
 
  VerticesBuilder& operator=(const VerticesBuilder&) = delete;
};
 
//------------------------------------------------------------------------------
/// UnskinnedVerticesBuilder
///
 
class UnskinnedVerticesBuilder final : public VerticesBuilder {
 public:
  struct Vertex {
    Vector3 position;
    Vector3 normal;
    Vector4 tangent;
    Vector2 texture_coords;
    Color color = Color::White();
  };
 
  UnskinnedVerticesBuilder();
 
  virtual ~UnskinnedVerticesBuilder() override;
 
  // |VerticesBuilder|
  void WriteFBVertices(fb::MeshPrimitiveT& primitive) const override;
 
  // |VerticesBuilder|
  void SetAttributeFromBuffer(AttributeType attribute,
                              ComponentType component_type,
                              const void* buffer_start,
                              size_t attribute_stride_bytes,
                              size_t attribute_count) override;
 
 private:
  std::vector<Vertex> vertices_;
 
  UnskinnedVerticesBuilder(const UnskinnedVerticesBuilder&) = delete;
 
  UnskinnedVerticesBuilder& operator=(const UnskinnedVerticesBuilder&) = delete;
};
 
//------------------------------------------------------------------------------
/// SkinnedVerticesBuilder
///
 
class SkinnedVerticesBuilder final : public VerticesBuilder {
 public:
  struct Vertex {
    UnskinnedVerticesBuilder::Vertex vertex;
    Vector4 joints;
    Vector4 weights;
  };
 
  SkinnedVerticesBuilder();
 
  virtual ~SkinnedVerticesBuilder() override;
 
  // |VerticesBuilder|
  void WriteFBVertices(fb::MeshPrimitiveT& primitive) const override;
 
  // |VerticesBuilder|
  void SetAttributeFromBuffer(AttributeType attribute,
                              ComponentType component_type,
                              const void* buffer_start,
                              size_t attribute_stride_bytes,
                              size_t attribute_count) override;
 
 private:
  std::vector<Vertex> vertices_;
 
  SkinnedVerticesBuilder(const SkinnedVerticesBuilder&) = delete;
 
  SkinnedVerticesBuilder& operator=(const SkinnedVerticesBuilder&) = delete;
};
 
}  // namespace importer
}  // namespace scene
}  // namespace impeller
 
#endif  // FLUTTER_IMPELLER_SCENE_IMPORTER_VERTICES_BUILDER_H_