ResourceCommands.cpp

#include "ResourceCommands.h"
 
#include "Resources/MaterialInstance.h"
 
#include "Components/Core/SceneComponent.h"
#include "Components/Core/MeshComponent.h"
#include "Components/Core/MeshRenderComponent.h"
 
#include "Resources/MaterialManager.h"
#include "Resources/MeshManager.h"
#include "Resources/DefaultMaterial.h"
#include "Resources/Texture.h"
#include "Resources/TextureManager.h"
 
#include "Resources/MaterialInstance.h"
 
#include "Foundation/HashSequence.h"
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
 
#include <iostream>
#include <set>
 
namespace {
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("ResourceCommand");
}
 
void Cogs::Core::SetTexturePropertyCommand::apply()
{
  auto textureKey = material->material->getTextureKey(key);
  auto textureProperty = material->getTextureProperty(textureKey);
 
  previousTexture = textureProperty.texture.handle;
 
  material->setTextureProperty(textureKey, texture);
}
 
void Cogs::Core::SetTexturePropertyCommand::undo()
{
  auto textureKey = material->material->getTextureKey(key);
  material->setTextureProperty(textureKey, previousTexture);
}
 
namespace Cogs::Core
{
  void gatherMaterials(ComponentModel::Entity * entity, std::unordered_map<EntityId, MaterialInstanceHandle> & materials)
  {
    auto component = entity->getComponent<MeshRenderComponent>();
 
    if (component) {
      if (component->material) {
        materials[entity->getId()] = component->material;
      }
    }
 
    auto sceneComponent = entity->getComponent<SceneComponent>();
 
    if (sceneComponent) {
      for (auto & child : sceneComponent->children) {
        gatherMaterials(child.get(), materials);
      }
    }
  }
}
 
void Cogs::Core::RemapMaterialCommand::apply()
{
  gatherMaterials(context->store->getEntityPtr(entityId), materials);
 
  // Keep a mapping of already-remapped materials to avoid creating more instances than
  // necessary.
  std::unordered_map<MaterialInstance *, MaterialInstance *> mapping;
 
  auto material = context->materialManager->getMaterial("StandardMaterial");
 
  for (auto & m : materials) {
    auto entity = context->store->getEntityPtr(m.first);
    auto component = entity->getComponent<MeshRenderComponent>();
 
    auto found = mapping.find(m.second.resolve());
 
    if (found != mapping.end()) {
      component->material = context->materialInstanceManager->generateHandle(found->second);
      continue;
    }
 
    auto newMaterial = context->materialInstanceManager->createMaterialInstance(material);
    newMaterial->setVariant("Textured", false);
 
    auto color = m.second->getVec4Property(DefaultMaterial::DiffuseColor);
    color = glm::pow(color, glm::vec4(glm::vec3(1.0f / 2.2f), 1.0f));
 
    auto diffuseMap = m.second->getTextureProperty(DefaultMaterial::DiffuseMap);
 
    TextureHandle diffuseHandle = m.second->getTextureProperty(DefaultMaterial::DiffuseMap).texture.handle;
    if(diffuseHandle){
      if(!diffuseHandle->getSource().empty()){
        newMaterial->setTextureProperty(material->getTextureKey("albedoMap"), diffuseHandle);
        newMaterial->setVariant("Textured", true);
        newMaterial->setVariant("AlbedoMap", true);
      }
 
      auto name = diffuseHandle->getName();
 
      const char *patterns[] = {
        "ALBEDO",
        "DIFFUSE",
        "GLOSS",
        "NORMAL",
        "SPEC"
      };
 
      std::string albedo, diffuse, gloss, normal, spec;
      for(const char *pattern : patterns){
        std::string::size_type pos;
        if((pos = name.find(pattern)) != StringView::NoPosition){
          std::string first = name.substr(0, pos).to_string();
          std::string last = name.substr(pos+strlen(pattern)).to_string();
          albedo = first+"ALBEDO"+last;
          if(!Cogs::IO::exists(albedo)) albedo = "";
          diffuse = first+"DIFFUSE"+last;
          if(!Cogs::IO::exists(diffuse)) diffuse = "";
          gloss = first+"GLOSS"+last;
          if(!Cogs::IO::exists(gloss)) gloss = "";
          normal = first+"NORMAL"+last;
          if(!Cogs::IO::exists(normal)) normal = "";
          spec = first+"SPEC"+last;
          if(!Cogs::IO::exists(spec)) spec = "";
          break;
        }
      }
      newMaterial->setPermutation("Specular");
      newMaterial->setVariant("Textured", false);
      newMaterial->setVec4Property(material->getVec4Key("albedo"), color);
      newMaterial->setFloatProperty(material->getFloatKey("gloss"), 1.0);
      newMaterial->setVec3Property(material->getVec3Key("specular"), glm::vec3(0.0));
      newMaterial->setFloatProperty(material->getFloatKey("normalMapFactor"), 1.0);
      if(albedo != ""){
        newMaterial->setVariant("Textured", true);
        newMaterial->setVariant("AlbedoMap", true);
        Cogs::Core::TextureHandle mh = context->textureManager->loadTexture(albedo, NoResourceId, TextureLoadFlags::None);
        newMaterial->setTextureProperty(material->getTextureKey("albedoMap"), mh);
      }
      else if(diffuse != ""){
        newMaterial->setVariant("Textured", true);
        newMaterial->setVariant("AlbedoMap", true);
        Cogs::Core::TextureHandle mh = context->textureManager->loadTexture(diffuse, NoResourceId, TextureLoadFlags::None);
        newMaterial->setTextureProperty(material->getTextureKey("albedoMap"), mh);
      }
      if(gloss != ""){
        newMaterial->setVariant("Textured", true);
        newMaterial->setVariant("GlossMap", true);
        Cogs::Core::TextureHandle mh = context->textureManager->loadTexture(gloss, NoResourceId, TextureLoadFlags::LinearColorSpace);
        newMaterial->setTextureProperty(material->getTextureKey("glossMap"), mh);
      }
      if(normal != ""){
        newMaterial->setVariant("Textured", true);
        newMaterial->setVariant("NormalMap", true);
        Cogs::Core::TextureHandle mh = context->textureManager->loadTexture(normal, NoResourceId, TextureLoadFlags::LinearColorSpace);
        newMaterial->setTextureProperty(material->getTextureKey("normalMap"), mh);
      }
      if(spec != ""){
        newMaterial->setVariant("Textured", true);
        newMaterial->setVariant("SpecularMap", true);
        newMaterial->setVec3Property(material->getVec3Key("specular"), glm::vec3(1.0));
        Cogs::Core::TextureHandle mh = context->textureManager->loadTexture(spec, NoResourceId, TextureLoadFlags::None);
        newMaterial->setTextureProperty(material->getTextureKey("specularMap"), mh);
      }
    }
 
    mapping[m.second.resolve()] = newMaterial.resolve();
    component->material = newMaterial;
  }
}
 
void Cogs::Core::RemapMaterialCommand::undo()
{
  for (auto & m : materials) {
    auto entity = context->store->getEntityPtr(m.first);
    auto component = entity->getComponent<MeshRenderComponent>();
    component->material = m.second;
  }
}
namespace Cogs::Core{
static size_t getMaterialHash(MaterialInstance * material)
{
  size_t hashValue = material->getName().hash();
 
  if (material->material->getName() == "DefaultMaterial") {
    hashValue = Cogs::hash(material->getVec4Property(DefaultMaterial::DiffuseColor), hashValue);
    hashValue = Cogs::hash(material->getVec3Property(DefaultMaterial::SpecularColor), hashValue);
    hashValue = Cogs::hash(material->getVec3Property(DefaultMaterial::EmissiveColor), hashValue);
    hashValue = Cogs::hash(material->getFloatProperty(DefaultMaterial::SpecularPower), hashValue);
 
    TextureHandle diffuseHandle = material->getTextureProperty(DefaultMaterial::DiffuseMap).texture.handle;
    if(diffuseHandle) {
      hashValue = Cogs::hash(diffuseHandle->getName(), hashValue);
    }
 
    TextureHandle normalHandle = material->getTextureProperty(DefaultMaterial::NormalMap).texture.handle;
    if(normalHandle) {
      hashValue = Cogs::hash(normalHandle->getName(), hashValue);
    }
 
    TextureHandle specularHandle = material->getTextureProperty(DefaultMaterial::SpecularMap).texture.handle;
    if(specularHandle) {
      hashValue = Cogs::hash(specularHandle->getName(), hashValue);
    }
  }
  else {
    hashValue = Cogs::hash(reinterpret_cast<intptr_t>(material), hashValue);
  }
  return hashValue;
}
}// namespace ...
void Cogs::Core::MergeMaterialCommand::apply()
{
  gatherMaterials(context->store->getEntityPtr(entityId), materials);
 
  std::set<MaterialInstance*> count;
  for (auto & m : materials)
    count.insert(m.second.resolve());
 
  std::unordered_map<size_t, MaterialInstance*> mapping;
 
  for (auto & m : materials) {
    auto entity = context->store->getEntityPtr(m.first);
    auto component = entity->getComponent<MeshRenderComponent>();
 
    size_t hash = getMaterialHash(m.second.resolve());
    if(!mapping.count(hash))
      mapping[hash] = m.second.resolve();
    component->material = MaterialInstanceHandle(mapping[hash]);
  }
  LOG_INFO(logger, "%zu materials merget to %zu materials", count.size(), mapping.size());
}
void Cogs::Core::MergeMaterialCommand::undo()
{
  for (auto & m : materials) {
    auto entity = context->store->getEntityPtr(m.first);
    auto component = entity->getComponent<MeshRenderComponent>();
    component->material = m.second;
  }
}
namespace Cogs::Core{
static void gatherMeshes(ComponentModel::Entity * entity, std::unordered_map<EntityId, MeshHandle> &meshes)
{
  auto component = entity->getComponent<MeshComponent>();
 
  if (component) {
    if (component->meshHandle) {
      meshes[entity->getId()] = component->meshHandle;
    }
  }
 
  auto sceneComponent = entity->getComponent<SceneComponent>();
 
  if (sceneComponent) {
    for (auto & child : sceneComponent->children) {
      gatherMeshes(child.get(), meshes);
    }
  }
}
}// namespace ...
void Cogs::Core::GenNormalsCommand::apply()
{
  gatherMeshes(context->store->getEntityPtr(entityId), meshes);
  for(auto &m : meshes){
    // auto entity = context->store->getEntityPtr(m.first);
    // auto component = entity->getComponent<MeshComponent>();
    // MeshManager::ResourceProxy mesh = context->meshManager->createLocked();
    // mesh->copy(*m.second.resolve());
    // component->meshHandle = mesh.getHandle();
    auto mesh = m.second.resolve();
    generateMeshNormals(mesh);
  }
}
void Cogs::Core::GenNormalsCommand::undo()
{
  LOG_ERROR(logger, "TODO: Undo normal generation.");
  for (auto & m : meshes) {
    auto entity = context->store->getEntityPtr(m.first);
    auto component = entity->getComponent<MeshComponent>();
    component->meshHandle = m.second;
  }
}
void Cogs::Core::GenerateTangentsCommand::apply()
{
  gatherMeshes(context->store->getEntityPtr(entityId), meshes);
  for(auto &m : meshes){
    // auto entity = context->store->getEntityPtr(m.first);
    // auto component = entity->getComponent<MeshComponent>();
    // MeshManager::ResourceProxy mesh = context->meshManager->createLocked();
    // mesh->copy(*m.second.resolve());
    // component->meshHandle = mesh.getHandle();
    auto mesh = m.second.resolve();
    generateMeshTangents(mesh);
  }
}
void Cogs::Core::GenerateTangentsCommand::undo()
{
  LOG_ERROR(logger, "TODO: Undo tangent generation.");
  for (auto & m : meshes) {
    auto entity = context->store->getEntityPtr(m.first);
    auto component = entity->getComponent<MeshComponent>();
    component->meshHandle = m.second;
  }
}