impeller::scene::importer Namespace Reference

Namespaces
namespace	testing

Classes
class	SkinnedVerticesBuilder
struct	Switches
class	UnskinnedVerticesBuilder
class	VerticesBuilder

Enumerations
enum class	SourceType { kUnknown , kGLTF }

Functions
Matrix	ToMatrix (const std::vector< double > &m)
Matrix	ToMatrix (const fb::Matrix &m)
Vector2	ToVector2 (const fb::Vec2 &v)
Vector3	ToVector3 (const fb::Vec3 &v)
Vector4	ToVector4 (const fb::Vec4 &v)
Color	ToColor (const fb::Color &c)
fb::Matrix	ToFBMatrix (const Matrix &m)
std::unique_ptr< fb::Matrix >	ToFBMatrixUniquePtr (const Matrix &m)
fb::Vec2	ToFBVec2 (const Vector2 v)
fb::Vec3	ToFBVec3 (const Vector3 v)
fb::Vec4	ToFBVec4 (const Vector4 v)
fb::Color	ToFBColor (const Color c)
std::unique_ptr< fb::Color >	ToFBColor (const std::vector< double > &c)
bool	ParseGLTF (const fml::Mapping &source_mapping, fb::SceneT &out_scene)
static bool	WithinRange (int index, size_t size)
static bool	MeshPrimitiveIsSkinned (const tinygltf::Primitive &primitive)
static void	ProcessMaterial (const tinygltf::Model &gltf, const tinygltf::Material &in_material, fb::MaterialT &out_material)
static bool	ProcessMeshPrimitive (const tinygltf::Model &gltf, const tinygltf::Primitive &primitive, fb::MeshPrimitiveT &mesh_primitive)
static void	ProcessNode (const tinygltf::Model &gltf, const tinygltf::Node &in_node, fb::NodeT &out_node)
static void	ProcessTexture (const tinygltf::Model &gltf, const tinygltf::Texture &in_texture, fb::TextureT &out_texture)
static void	ProcessAnimation (const tinygltf::Model &gltf, const tinygltf::Animation &in_animation, fb::AnimationT &out_animation)
static bool	SetPermissiveAccess (const std::filesystem::path &p)
bool	Main (const fml::CommandLine &command_line)
static SourceType	SourceTypeFromCommandLine (const fml::CommandLine &command_line)
template<typename SourceType >
static Scalar	ToScalar (const void *source, size_t index, bool normalized)
	Reads a numeric component from source and returns a 32bit float. If normalized is true, signed SourceTypes convert to a range of -1 to 1, and unsigned SourceTypes convert to a range of 0 to 1.
static void	PassthroughAttributeWriter (Scalar *destination, const void *source, const VerticesBuilder::ComponentProperties &component, const VerticesBuilder::AttributeProperties &attribute)
	A ComponentWriter which simply converts all of an attribute's components to normalized scalar form.
static void	JointsAttributeWriter (Scalar *destination, const void *source, const VerticesBuilder::ComponentProperties &component, const VerticesBuilder::AttributeProperties &attribute)
	A ComponentWriter which converts four vertex indices to scalars.

Variables
static const std::map< std::string, VerticesBuilder::AttributeType >	kAttributes
static const std::map< std::string, SourceType >	kKnownSourceTypes
static std::map< VerticesBuilder::ComponentType, VerticesBuilder::ComponentProperties >	kComponentTypes

Enumeration Type Documentation

SourceType

enum class impeller::scene::importer::SourceType

strong

Enumerator
kUnknown
kGLTF

Definition at line 12 of file types.h.

                      {
  kUnknown,
  kGLTF,
};

Function Documentation

JointsAttributeWriter()

static void impeller::scene::importer::JointsAttributeWriter ( Scalar *  destination, const void *  source, const VerticesBuilder::ComponentProperties &  component, const VerticesBuilder::AttributeProperties &  attribute  )

static

A ComponentWriter which converts four vertex indices to scalars.

Definition at line 70 of file vertices_builder.cc.

                                                         {
  FML_DCHECK(attribute.component_count == 4);
  for (int i = 0; i < 4; i++) {
    *(destination + i) = component.convert_proc(source, i, false);
  }
}

Main()

bool impeller::scene::importer::Main

(

const fml::CommandLine &

command_line

)

Definition at line 41 of file scenec_main.cc.

                                              {
  fml::InstallCrashHandler();
  if (command_line.HasOption("help")) {
    Switches::PrintHelp(std::cout);
    return true;
  }
 
  Switches switches(command_line);
  if (!switches.AreValid(std::cerr)) {
    std::cerr << "Invalid flags specified." << std::endl;
    Switches::PrintHelp(std::cerr);
    return false;
  }
 
  auto source_file_mapping =
      fml::FileMapping::CreateReadOnly(switches.source_file_name);
  if (!source_file_mapping) {
    std::cerr << "Could not open input file." << std::endl;
    return false;
  }
 
  fb::SceneT scene;
  bool success = false;
  switch (switches.input_type) {
    case SourceType::kGLTF:
      success = ParseGLTF(*source_file_mapping, scene);
      break;
    case SourceType::kUnknown:
      std::cerr << "Unknown input type." << std::endl;
      return false;
  }
  if (!success) {
    std::cerr << "Failed to parse input file." << std::endl;
    return false;
  }
 
  flatbuffers::FlatBufferBuilder builder;
  builder.Finish(fb::Scene::Pack(builder, &scene), fb::SceneIdentifier());
 
  auto output_file_name = std::filesystem::absolute(
      std::filesystem::current_path() / switches.output_file_name);
  fml::NonOwnedMapping mapping(builder.GetCurrentBufferPointer(),
                               builder.GetSize());
  if (!fml::WriteAtomically(*switches.working_directory,
                            compiler::Utf8FromPath(output_file_name).c_str(),
                            mapping)) {
    std::cerr << "Could not write file to " << switches.output_file_name
              << std::endl;
    return false;
  }
 
  // Tools that consume the geometry data expect the access mode to be 0644.
  if (!SetPermissiveAccess(output_file_name)) {
    return false;
  }
 
  return true;
}

MeshPrimitiveIsSkinned()

static bool impeller::scene::importer::MeshPrimitiveIsSkinned ( const tinygltf::Primitive &  primitive )

static

Definition at line 39 of file importer_gltf.cc.

                                                                       {
  return primitive.attributes.find("JOINTS_0") != primitive.attributes.end() &&
         primitive.attributes.find("WEIGHTS_0") != primitive.attributes.end();
}

ParseGLTF()

bool impeller::scene::importer::ParseGLTF	(	const fml::Mapping &	source_mapping,
		fb::SceneT &	out_scene
	)

Definition at line 450 of file importer_gltf.cc.

                                                                      {
  tinygltf::Model gltf;
 
  {
    tinygltf::TinyGLTF loader;
    std::string error;
    std::string warning;
    bool success = loader.LoadBinaryFromMemory(&gltf, &error, &warning,
                                               source_mapping.GetMapping(),
                                               source_mapping.GetSize());
    if (!warning.empty()) {
      std::cerr << "Warning while loading GLTF: " << warning << std::endl;
    }
    if (!error.empty()) {
      std::cerr << "Error while loading GLTF: " << error << std::endl;
    }
    if (!success) {
      return false;
    }
  }
 
  const tinygltf::Scene& scene = gltf.scenes[gltf.defaultScene];
  out_scene.children = scene.nodes;
 
  out_scene.transform =
      ToFBMatrixUniquePtr(Matrix::MakeScale(Vector3(1, 1, -1)));
 
  for (size_t texture_i = 0; texture_i < gltf.textures.size(); texture_i++) {
    auto texture = std::make_unique<fb::TextureT>();
    ProcessTexture(gltf, gltf.textures[texture_i], *texture);
    out_scene.textures.push_back(std::move(texture));
  }
 
  for (size_t node_i = 0; node_i < gltf.nodes.size(); node_i++) {
    auto node = std::make_unique<fb::NodeT>();
    ProcessNode(gltf, gltf.nodes[node_i], *node);
    out_scene.nodes.push_back(std::move(node));
  }
 
  for (size_t animation_i = 0; animation_i < gltf.animations.size();
       animation_i++) {
    auto animation = std::make_unique<fb::AnimationT>();
    ProcessAnimation(gltf, gltf.animations[animation_i], *animation);
    out_scene.animations.push_back(std::move(animation));
  }
 
  return true;
}

PassthroughAttributeWriter()

static void impeller::scene::importer::PassthroughAttributeWriter ( Scalar *  destination, const void *  source, const VerticesBuilder::ComponentProperties &  component, const VerticesBuilder::AttributeProperties &  attribute  )

static

A ComponentWriter which simply converts all of an attribute's components to normalized scalar form.

Definition at line 55 of file vertices_builder.cc.

                                                         {
  FML_DCHECK(attribute.size_bytes ==
             attribute.component_count * sizeof(Scalar));
  for (size_t component_i = 0; component_i < attribute.component_count;
       component_i++) {
    *(destination + component_i) =
        component.convert_proc(source, component_i, true);
  }
}

ProcessAnimation()

static void impeller::scene::importer::ProcessAnimation ( const tinygltf::Model &  gltf, const tinygltf::Animation &  in_animation, fb::AnimationT &  out_animation  )

static

Keyframe times.

Keyframe values.

Definition at line 316 of file importer_gltf.cc.

                                                          {
  out_animation.name = in_animation.name;
 
  // std::vector<impeller::fb::ChannelT> channels;
  std::vector<impeller::fb::ChannelT> translation_channels;
  std::vector<impeller::fb::ChannelT> rotation_channels;
  std::vector<impeller::fb::ChannelT> scale_channels;
  for (auto& in_channel : in_animation.channels) {
    auto out_channel = fb::ChannelT();
 
    out_channel.node = in_channel.target_node;
    auto& sampler = in_animation.samplers[in_channel.sampler];
 
    /// Keyframe times.
    auto& times_accessor = gltf.accessors[sampler.input];
    if (times_accessor.count <= 0) {
      continue;  // Nothing to record.
    }
    {
      auto& times_bufferview = gltf.bufferViews[times_accessor.bufferView];
      auto& times_buffer = gltf.buffers[times_bufferview.buffer];
      if (times_accessor.componentType != TINYGLTF_COMPONENT_TYPE_FLOAT) {
        std::cerr << "Unexpected component type \""
                  << times_accessor.componentType
                  << "\" for animation channel times accessor. Skipping."
                  << std::endl;
        continue;
      }
      if (times_accessor.type != TINYGLTF_TYPE_SCALAR) {
        std::cerr << "Unexpected type \"" << times_accessor.type
                  << "\" for animation channel times accessor. Skipping."
                  << std::endl;
        continue;
      }
      for (size_t time_i = 0; time_i < times_accessor.count; time_i++) {
        const float* time_p = reinterpret_cast<const float*>(
            times_buffer.data.data() + times_bufferview.byteOffset +
            times_accessor.ByteStride(times_bufferview) * time_i);
        out_channel.timeline.push_back(*time_p);
      }
    }
 
    /// Keyframe values.
    auto& values_accessor = gltf.accessors[sampler.output];
    if (values_accessor.count != times_accessor.count) {
      std::cerr << "Mismatch between time and value accessors for animation "
                   "channel. Skipping."
                << std::endl;
      continue;
    }
    {
      auto& values_bufferview = gltf.bufferViews[values_accessor.bufferView];
      auto& values_buffer = gltf.buffers[values_bufferview.buffer];
      if (values_accessor.componentType != TINYGLTF_COMPONENT_TYPE_FLOAT) {
        std::cerr << "Unexpected component type \""
                  << values_accessor.componentType
                  << "\" for animation channel values accessor. Skipping."
                  << std::endl;
        continue;
      }
      if (in_channel.target_path == "translation") {
        if (values_accessor.type != TINYGLTF_TYPE_VEC3) {
          std::cerr << "Unexpected type \"" << values_accessor.type
                    << "\" for animation channel \"translation\" accessor. "
                       "Skipping."
                    << std::endl;
          continue;
        }
        fb::TranslationKeyframesT keyframes;
        for (size_t value_i = 0; value_i < values_accessor.count; value_i++) {
          const float* value_p = reinterpret_cast<const float*>(
              values_buffer.data.data() + values_bufferview.byteOffset +
              values_accessor.ByteStride(values_bufferview) * value_i);
          keyframes.values.push_back(
              fb::Vec3(value_p[0], value_p[1], value_p[2]));
        }
        out_channel.keyframes.Set(std::move(keyframes));
        translation_channels.push_back(std::move(out_channel));
      } else if (in_channel.target_path == "rotation") {
        if (values_accessor.type != TINYGLTF_TYPE_VEC4) {
          std::cerr << "Unexpected type \"" << values_accessor.type
                    << "\" for animation channel \"rotation\" accessor. "
                       "Skipping."
                    << std::endl;
          continue;
        }
        fb::RotationKeyframesT keyframes;
        for (size_t value_i = 0; value_i < values_accessor.count; value_i++) {
          const float* value_p = reinterpret_cast<const float*>(
              values_buffer.data.data() + values_bufferview.byteOffset +
              values_accessor.ByteStride(values_bufferview) * value_i);
          keyframes.values.push_back(
              fb::Vec4(value_p[0], value_p[1], value_p[2], value_p[3]));
        }
        out_channel.keyframes.Set(std::move(keyframes));
        rotation_channels.push_back(std::move(out_channel));
      } else if (in_channel.target_path == "scale") {
        if (values_accessor.type != TINYGLTF_TYPE_VEC3) {
          std::cerr << "Unexpected type \"" << values_accessor.type
                    << "\" for animation channel \"scale\" accessor. "
                       "Skipping."
                    << std::endl;
          continue;
        }
        fb::ScaleKeyframesT keyframes;
        for (size_t value_i = 0; value_i < values_accessor.count; value_i++) {
          const float* value_p = reinterpret_cast<const float*>(
              values_buffer.data.data() + values_bufferview.byteOffset +
              values_accessor.ByteStride(values_bufferview) * value_i);
          keyframes.values.push_back(
              fb::Vec3(value_p[0], value_p[1], value_p[2]));
        }
        out_channel.keyframes.Set(std::move(keyframes));
        scale_channels.push_back(std::move(out_channel));
      } else {
        std::cerr << "Unsupported animation channel target path \""
                  << in_channel.target_path << "\". Skipping." << std::endl;
        continue;
      }
    }
  }
 
  std::vector<std::unique_ptr<impeller::fb::ChannelT>> channels;
  for (const auto& channel_list :
       {translation_channels, rotation_channels, scale_channels}) {
    for (const auto& channel : channel_list) {
      channels.push_back(std::make_unique<fb::ChannelT>(channel));
    }
  }
  out_animation.channels = std::move(channels);
}

ProcessMaterial()

static void impeller::scene::importer::ProcessMaterial ( const tinygltf::Model &  gltf, const tinygltf::Material &  in_material, fb::MaterialT &  out_material  )

static

Definition at line 44 of file importer_gltf.cc.

                                                       {
  out_material.type = fb::MaterialType::kUnlit;
  out_material.base_color_factor =
      ToFBColor(in_material.pbrMetallicRoughness.baseColorFactor);
  bool base_color_texture_valid =
      in_material.pbrMetallicRoughness.baseColorTexture.texCoord == 0 &&
      in_material.pbrMetallicRoughness.baseColorTexture.index >= 0 &&
      in_material.pbrMetallicRoughness.baseColorTexture.index <
          static_cast<int32_t>(gltf.textures.size());
  out_material.base_color_texture =
      base_color_texture_valid
          // This is safe because every GLTF input texture is mapped to a
          // `Scene->texture`.
          ? in_material.pbrMetallicRoughness.baseColorTexture.index
          : -1;
}

ProcessMeshPrimitive()

static bool impeller::scene::importer::ProcessMeshPrimitive ( const tinygltf::Model &  gltf, const tinygltf::Primitive &  primitive, fb::MeshPrimitiveT &  mesh_primitive  )

static

Vertices.

Indices.

Material.

Definition at line 63 of file importer_gltf.cc.

                                                                   {
  //---------------------------------------------------------------------------
  /// Vertices.
  ///
 
  {
    bool is_skinned = MeshPrimitiveIsSkinned(primitive);
    std::unique_ptr<VerticesBuilder> builder =
        is_skinned ? VerticesBuilder::MakeSkinned()
                   : VerticesBuilder::MakeUnskinned();
 
    for (const auto& attribute : primitive.attributes) {
      auto attribute_type = kAttributes.find(attribute.first);
      if (attribute_type == kAttributes.end()) {
        std::cerr << "Vertex attribute \"" << attribute.first
                  << "\" not supported." << std::endl;
        continue;
      }
      if (!is_skinned &&
          (attribute_type->second == VerticesBuilder::AttributeType::kJoints ||
           attribute_type->second ==
               VerticesBuilder::AttributeType::kWeights)) {
        // If the primitive doesn't have enough information to be skinned, skip
        // skinning-related attributes.
        continue;
      }
 
      const auto accessor = gltf.accessors[attribute.second];
      const auto view = gltf.bufferViews[accessor.bufferView];
 
      const auto buffer = gltf.buffers[view.buffer];
      const unsigned char* source_start = &buffer.data[view.byteOffset];
 
      VerticesBuilder::ComponentType type;
      switch (accessor.componentType) {
        case TINYGLTF_COMPONENT_TYPE_BYTE:
          type = VerticesBuilder::ComponentType::kSignedByte;
          break;
        case TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE:
          type = VerticesBuilder::ComponentType::kUnsignedByte;
          break;
        case TINYGLTF_COMPONENT_TYPE_SHORT:
          type = VerticesBuilder::ComponentType::kSignedShort;
          break;
        case TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT:
          type = VerticesBuilder::ComponentType::kUnsignedShort;
          break;
        case TINYGLTF_COMPONENT_TYPE_INT:
          type = VerticesBuilder::ComponentType::kSignedInt;
          break;
        case TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT:
          type = VerticesBuilder::ComponentType::kUnsignedInt;
          break;
        case TINYGLTF_COMPONENT_TYPE_FLOAT:
          type = VerticesBuilder::ComponentType::kFloat;
          break;
        default:
          std::cerr << "Skipping attribute \"" << attribute.first
                    << "\" due to invalid component type." << std::endl;
          continue;
      }
 
      builder->SetAttributeFromBuffer(
          attribute_type->second,     // attribute
          type,                       // component_type
          source_start,               // buffer_start
          accessor.ByteStride(view),  // stride_bytes
          accessor.count);            // count
    }
 
    builder->WriteFBVertices(mesh_primitive);
  }
 
  //---------------------------------------------------------------------------
  /// Indices.
  ///
 
  {
    if (!WithinRange(primitive.indices, gltf.accessors.size())) {
      std::cerr << "Mesh primitive has no index buffer. Skipping." << std::endl;
      return false;
    }
 
    auto index_accessor = gltf.accessors[primitive.indices];
    auto index_view = gltf.bufferViews[index_accessor.bufferView];
 
    auto indices = std::make_unique<fb::IndicesT>();
 
    switch (index_accessor.componentType) {
      case TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT:
        indices->type = fb::IndexType::k16Bit;
        break;
      case TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT:
        indices->type = fb::IndexType::k32Bit;
        break;
      default:
        std::cerr << "Mesh primitive has unsupported index type "
                  << index_accessor.componentType << ". Skipping.";
        return false;
    }
    indices->count = index_accessor.count;
    indices->data.resize(index_view.byteLength);
    const auto* index_buffer =
        &gltf.buffers[index_view.buffer].data[index_view.byteOffset];
    std::memcpy(indices->data.data(), index_buffer, indices->data.size());
 
    mesh_primitive.indices = std::move(indices);
  }
 
  //---------------------------------------------------------------------------
  /// Material.
  ///
 
  {
    auto material = std::make_unique<fb::MaterialT>();
    if (primitive.material >= 0 &&
        primitive.material < static_cast<int>(gltf.materials.size())) {
      ProcessMaterial(gltf, gltf.materials[primitive.material], *material);
    } else {
      material->type = fb::MaterialType::kUnlit;
    }
    mesh_primitive.material = std::move(material);
  }
 
  return true;
}

ProcessNode()

static void impeller::scene::importer::ProcessNode ( const tinygltf::Model &  gltf, const tinygltf::Node &  in_node, fb::NodeT &  out_node  )

static

Transform.

Static meshes.

Skin.

Definition at line 192 of file importer_gltf.cc.

                                           {
  out_node.name = in_node.name;
  out_node.children = in_node.children;
 
  //---------------------------------------------------------------------------
  /// Transform.
  ///
 
  Matrix transform;
  if (in_node.scale.size() == 3) {
    transform =
        transform * Matrix::MakeScale({static_cast<Scalar>(in_node.scale[0]),
                                       static_cast<Scalar>(in_node.scale[1]),
                                       static_cast<Scalar>(in_node.scale[2])});
  }
  if (in_node.rotation.size() == 4) {
    transform = transform * Matrix::MakeRotation(Quaternion(
                                in_node.rotation[0], in_node.rotation[1],
                                in_node.rotation[2], in_node.rotation[3]));
  }
  if (in_node.translation.size() == 3) {
    transform = transform * Matrix::MakeTranslation(
                                {static_cast<Scalar>(in_node.translation[0]),
                                 static_cast<Scalar>(in_node.translation[1]),
                                 static_cast<Scalar>(in_node.translation[2])});
  }
  if (in_node.matrix.size() == 16) {
    if (!transform.IsIdentity()) {
      std::cerr << "The `matrix` attribute of node (name: " << in_node.name
                << ") is set in addition to one or more of the "
                   "`translation/rotation/scale` attributes. Using only the "
                   "`matrix` "
                   "attribute.";
    }
    transform = ToMatrix(in_node.matrix);
  }
  out_node.transform = ToFBMatrixUniquePtr(transform);
 
  //---------------------------------------------------------------------------
  /// Static meshes.
  ///
 
  if (WithinRange(in_node.mesh, gltf.meshes.size())) {
    auto& mesh = gltf.meshes[in_node.mesh];
    for (const auto& primitive : mesh.primitives) {
      auto mesh_primitive = std::make_unique<fb::MeshPrimitiveT>();
      if (!ProcessMeshPrimitive(gltf, primitive, *mesh_primitive)) {
        continue;
      }
      out_node.mesh_primitives.push_back(std::move(mesh_primitive));
    }
  }
 
  //---------------------------------------------------------------------------
  /// Skin.
  ///
 
  if (WithinRange(in_node.skin, gltf.skins.size())) {
    auto& skin = gltf.skins[in_node.skin];
 
    auto ipskin = std::make_unique<fb::SkinT>();
    ipskin->joints = skin.joints;
    {
      std::vector<fb::Matrix> matrices;
      auto& matrix_accessor = gltf.accessors[skin.inverseBindMatrices];
      auto& matrix_view = gltf.bufferViews[matrix_accessor.bufferView];
      auto& matrix_buffer = gltf.buffers[matrix_view.buffer];
      for (size_t matrix_i = 0; matrix_i < matrix_accessor.count; matrix_i++) {
        auto* s = reinterpret_cast<const float*>(
            matrix_buffer.data.data() + matrix_view.byteOffset +
            matrix_accessor.ByteStride(matrix_view) * matrix_i);
        Matrix m(s[0], s[1], s[2], s[3],    //
                 s[4], s[5], s[6], s[7],    //
                 s[8], s[9], s[10], s[11],  //
                 s[12], s[13], s[14], s[15]);
        matrices.push_back(ToFBMatrix(m));
      }
      ipskin->inverse_bind_matrices = std::move(matrices);
    }
    ipskin->skeleton = skin.skeleton;
    out_node.skin = std::move(ipskin);
  }
}

ProcessTexture()

static void impeller::scene::importer::ProcessTexture ( const tinygltf::Model &  gltf, const tinygltf::Texture &  in_texture, fb::TextureT &  out_texture  )

static

Definition at line 278 of file importer_gltf.cc.

                                                    {
  if (!WithinRange(in_texture.source, gltf.images.size())) {
    return;
  }
  auto& image = gltf.images[in_texture.source];
 
  auto embedded = std::make_unique<fb::EmbeddedImageT>();
  embedded->bytes = image.image;
  size_t bytes_per_component = 0;
  switch (image.pixel_type) {
    case TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE:
      embedded->component_type = fb::ComponentType::k8Bit;
      bytes_per_component = 1;
      break;
    case TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT:
      embedded->component_type = fb::ComponentType::k16Bit;
      bytes_per_component = 2;
      break;
    default:
      std::cerr << "Texture component type " << image.pixel_type
                << " not supported." << std::endl;
      return;
  }
  if (image.image.size() !=
      bytes_per_component * image.component * image.width * image.height) {
    std::cerr << "Decompressed texture had unexpected buffer size. Skipping."
              << std::endl;
    return;
  }
  embedded->component_count = image.component;
  embedded->width = image.width;
  embedded->height = image.height;
  out_texture.embedded_image = std::move(embedded);
  out_texture.uri = image.uri;
}

SetPermissiveAccess()

static bool impeller::scene::importer::SetPermissiveAccess ( const std::filesystem::path &  p )

static

Definition at line 27 of file scenec_main.cc.

                                                            {
  auto permissions =
      std::filesystem::perms::owner_read | std::filesystem::perms::owner_write |
      std::filesystem::perms::group_read | std::filesystem::perms::others_read;
  std::error_code error;
  std::filesystem::permissions(p, permissions, error);
  if (error) {
    std::cerr << "Failed to set access on file '" << p
              << "': " << error.message() << std::endl;
    return false;
  }
  return true;
}

SourceTypeFromCommandLine()

static SourceType impeller::scene::importer::SourceTypeFromCommandLine ( const fml::CommandLine &  command_line )

static

Definition at line 43 of file switches.cc.

                                        {
  auto source_type_option =
      command_line.GetOptionValueWithDefault("input-type", "gltf");
  auto source_type_search = kKnownSourceTypes.find(source_type_option);
  if (source_type_search == kKnownSourceTypes.end()) {
    return SourceType::kUnknown;
  }
  return source_type_search->second;
}

ToColor()

Color impeller::scene::importer::ToColor

(

const fb::Color &

c

)

Definition at line 46 of file conversions.cc.

                                {
  return Color(c.r(), c.g(), c.b(), c.a());
}

ToFBColor() [1/2]

fb::Color impeller::scene::importer::ToFBColor

(

const Color

c

)

Definition at line 82 of file conversions.cc.

                                 {
  return fb::Color(c.red, c.green, c.blue, c.alpha);
}

ToFBColor() [2/2]

std::unique_ptr< fb::Color > impeller::scene::importer::ToFBColor

(

const std::vector< double > &

c

)

Definition at line 86 of file conversions.cc.

                                                             {
  auto* color = new fb::Color(c.size() > 0 ? c[0] : 1,  //
                              c.size() > 1 ? c[1] : 1,  //
                              c.size() > 2 ? c[2] : 1,  //
                              c.size() > 3 ? c[3] : 1);
  return std::unique_ptr<fb::Color>(color);
}

ToFBMatrix()

fb::Matrix impeller::scene::importer::ToFBMatrix

(

const Matrix &

m

)

Impeller -> Flatbuffers

Definition at line 54 of file conversions.cc.

                                     {
  auto array = std::array<Scalar, 16>{m.m[0],  m.m[1],  m.m[2],  m.m[3],   //
                                      m.m[4],  m.m[5],  m.m[6],  m.m[7],   //
                                      m.m[8],  m.m[9],  m.m[10], m.m[11],  //
                                      m.m[12], m.m[13], m.m[14], m.m[15]};
  return fb::Matrix(array);
}

ToFBMatrixUniquePtr()

std::unique_ptr< fb::Matrix > impeller::scene::importer::ToFBMatrixUniquePtr

(

const Matrix &

m

)

Definition at line 62 of file conversions.cc.

                                                             {
  auto array = std::array<Scalar, 16>{m.m[0],  m.m[1],  m.m[2],  m.m[3],   //
                                      m.m[4],  m.m[5],  m.m[6],  m.m[7],   //
                                      m.m[8],  m.m[9],  m.m[10], m.m[11],  //
                                      m.m[12], m.m[13], m.m[14], m.m[15]};
  return std::make_unique<fb::Matrix>(array);
}

ToFBVec2()

fb::Vec2 impeller::scene::importer::ToFBVec2

(

const Vector2

v

)

Definition at line 70 of file conversions.cc.

                                 {
  return fb::Vec2(v.x, v.y);
}

ToFBVec3()

fb::Vec3 impeller::scene::importer::ToFBVec3

(

const Vector3

v

)

Definition at line 74 of file conversions.cc.

                                 {
  return fb::Vec3(v.x, v.y, v.z);
}

ToFBVec4()

fb::Vec4 impeller::scene::importer::ToFBVec4

(

const Vector4

v

)

Definition at line 78 of file conversions.cc.

                                 {
  return fb::Vec4(v.x, v.y, v.z, v.w);
}

ToMatrix() [1/2]

Matrix impeller::scene::importer::ToMatrix

(

const fb::Matrix &

m

)

Flatbuffers -> Impeller

Definition at line 26 of file conversions.cc.

                                   {
  auto& a = *m.m();
  return Matrix(a[0], a[1], a[2], a[3],    //
                a[4], a[5], a[6], a[7],    //
                a[8], a[9], a[10], a[11],  //
                a[12], a[13], a[14], a[15]);
}

ToMatrix() [2/2]

Matrix impeller::scene::importer::ToMatrix

(

const std::vector< double > &

m

)

Definition at line 15 of file conversions.cc.

                                            {
  return Matrix(m[0], m[1], m[2], m[3],    //
                m[4], m[5], m[6], m[7],    //
                m[8], m[9], m[10], m[11],  //
                m[12], m[13], m[14], m[15]);
}

ToScalar()

template<typename SourceType >

static Scalar impeller::scene::importer::ToScalar ( const void *  source, size_t  index, bool  normalized  )

static

Reads a numeric component from source and returns a 32bit float. If normalized is true, signed SourceTypes convert to a range of -1 to 1, and unsigned SourceTypes convert to a range of 0 to 1.

Definition at line 41 of file vertices_builder.cc.

                                                                          {
  const SourceType* s = reinterpret_cast<const SourceType*>(source) + index;
  Scalar result = static_cast<Scalar>(*s);
  if (normalized) {
    constexpr SourceType divisor = std::is_integral_v<SourceType>
                                       ? std::numeric_limits<SourceType>::max()
                                       : 1;
    result = static_cast<Scalar>(*s) / static_cast<Scalar>(divisor);
  }
  return result;
}

ToVector2()

Vector2 impeller::scene::importer::ToVector2

(

const fb::Vec2 &

v

)

Definition at line 34 of file conversions.cc.

                                   {
  return Vector2(v.x(), v.y());
}

ToVector3()

Vector3 impeller::scene::importer::ToVector3

(

const fb::Vec3 &

v

)

Definition at line 38 of file conversions.cc.

                                   {
  return Vector3(v.x(), v.y(), v.z());
}

ToVector4()

Vector4 impeller::scene::importer::ToVector4

(

const fb::Vec4 &

v

)

Definition at line 42 of file conversions.cc.

                                   {
  return Vector4(v.x(), v.y(), v.z(), v.w());
}

WithinRange()

static bool impeller::scene::importer::WithinRange ( int  index, size_t  size  )

static

Definition at line 35 of file importer_gltf.cc.

                                                {
  return index >= 0 && static_cast<size_t>(index) < size;
}

Variable Documentation

kAttributes

const std::map<std::string, VerticesBuilder::AttributeType> impeller::scene::importer::kAttributes

static

Initial value:

=
    {{"POSITION", VerticesBuilder::AttributeType::kPosition},
     {"NORMAL", VerticesBuilder::AttributeType::kNormal},
     {"TANGENT", VerticesBuilder::AttributeType::kTangent},
     {"TEXCOORD_0", VerticesBuilder::AttributeType::kTextureCoords},
     {"COLOR_0", VerticesBuilder::AttributeType::kColor},
     {"JOINTS_0", VerticesBuilder::AttributeType::kJoints},
     {"WEIGHTS_0", VerticesBuilder::AttributeType::kWeights}}

Definition at line 26 of file importer_gltf.cc.

    {{"POSITION", VerticesBuilder::AttributeType::kPosition},
     {"NORMAL", VerticesBuilder::AttributeType::kNormal},
     {"TANGENT", VerticesBuilder::AttributeType::kTangent},
     {"TEXCOORD_0", VerticesBuilder::AttributeType::kTextureCoords},
     {"COLOR_0", VerticesBuilder::AttributeType::kColor},
     {"JOINTS_0", VerticesBuilder::AttributeType::kJoints},
     {"WEIGHTS_0", VerticesBuilder::AttributeType::kWeights}};

kComponentTypes

std::map<VerticesBuilder::ComponentType, VerticesBuilder::ComponentProperties> impeller::scene::importer::kComponentTypes

static

Initial value:

= {
        {VerticesBuilder::ComponentType::kSignedByte,
         {.size_bytes = sizeof(int8_t), .convert_proc = ToScalar<int8_t>}},
        {VerticesBuilder::ComponentType::kUnsignedByte,
         {.size_bytes = sizeof(int8_t), .convert_proc = ToScalar<uint8_t>}},
        {VerticesBuilder::ComponentType::kSignedShort,
         {.size_bytes = sizeof(int16_t), .convert_proc = ToScalar<int16_t>}},
        {VerticesBuilder::ComponentType::kUnsignedShort,
         {.size_bytes = sizeof(int16_t), .convert_proc = ToScalar<uint16_t>}},
        {VerticesBuilder::ComponentType::kSignedInt,
         {.size_bytes = sizeof(int32_t), .convert_proc = ToScalar<int32_t>}},
        {VerticesBuilder::ComponentType::kUnsignedInt,
         {.size_bytes = sizeof(int32_t), .convert_proc = ToScalar<uint32_t>}},
        {VerticesBuilder::ComponentType::kFloat,
         {.size_bytes = sizeof(float), .convert_proc = ToScalar<float>}},
}

Definition at line 123 of file vertices_builder.cc.

                      {
        {VerticesBuilder::ComponentType::kSignedByte,
         {.size_bytes = sizeof(int8_t), .convert_proc = ToScalar<int8_t>}},
        {VerticesBuilder::ComponentType::kUnsignedByte,
         {.size_bytes = sizeof(int8_t), .convert_proc = ToScalar<uint8_t>}},
        {VerticesBuilder::ComponentType::kSignedShort,
         {.size_bytes = sizeof(int16_t), .convert_proc = ToScalar<int16_t>}},
        {VerticesBuilder::ComponentType::kUnsignedShort,
         {.size_bytes = sizeof(int16_t), .convert_proc = ToScalar<uint16_t>}},
        {VerticesBuilder::ComponentType::kSignedInt,
         {.size_bytes = sizeof(int32_t), .convert_proc = ToScalar<int32_t>}},
        {VerticesBuilder::ComponentType::kUnsignedInt,
         {.size_bytes = sizeof(int32_t), .convert_proc = ToScalar<uint32_t>}},
        {VerticesBuilder::ComponentType::kFloat,
         {.size_bytes = sizeof(float), .convert_proc = ToScalar<float>}},
};

kKnownSourceTypes

const std::map<std::string, SourceType> impeller::scene::importer::kKnownSourceTypes

static

Initial value:

= {
    {"gltf", SourceType::kGLTF},
}

Definition at line 20 of file switches.cc.

                                                               {
    {"gltf", SourceType::kGLTF},
};