RenderResources.cpp

#include "RenderResources.h"
#include "Renderer.h"
#include "Context.h"
 
#include "MemoryContext.h"
 
#include "Resources/Mesh.h"
#include "Resources/Texture.h"
 
#include "RenderTexture.h"
#include "RenderTarget.h"
#include "RenderMesh.h"
#include "RenderEffect.h"
#include "RenderMaterial.h"
#include "RenderMaterialInstance.h"
#include "RenderList.h"
#include "RenderBuffer.h"
 
#include "Foundation/Collections/Pool.h"
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/Threads.h"
 
#include "Rendering/ITextures.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderResources");
}
 
using namespace Cogs;
using namespace Cogs::Core;
 
namespace Cogs
{
  namespace Core
  {
    struct RenderResourceStorage
    {
      RenderResourceStorage(Memory::Allocator * allocator) :
        renderMeshes(1024, 1024, allocator, MemBlockType::RenderResourceStorage),
        renderTextures(1024, 1024, allocator, MemBlockType::RenderResourceStorage),
        renderEffects(1024, 1024, allocator, MemBlockType::RenderResourceStorage),
        renderMaterials(128, 128, allocator, MemBlockType::RenderResourceStorage),
        renderMaterialInstances(1024, 1024, allocator, MemBlockType::RenderResourceStorage),
        renderTargets(128, 128, allocator, MemBlockType::RenderResourceStorage),
        renderLists(128, 128, allocator, MemBlockType::RenderResourceStorage),
        renderBuffers(128, 128, allocator, MemBlockType::RenderResourceStorage)
      {}
 
      Mutex renderMeshMutex;
      Collections::Pool<RenderMesh> renderMeshes;
      Collections::Pool<RenderTexture> renderTextures;
      Collections::Pool<RenderEffect> renderEffects;
      Collections::Pool<RenderMaterial> renderMaterials;
      Collections::Pool<RenderMaterialInstance> renderMaterialInstances;
      Collections::Pool<RenderTarget> renderTargets;
      Collections::Pool<RenderList> renderLists;
      Collections::Pool<RenderBuffer> renderBuffers;
    };
  }
}
 
Cogs::Core::RenderResources::RenderResources(Context * context) :
  storage(std::make_unique<RenderResourceStorage>(context->memory->resourceAllocator))
{
 
}
 
Cogs::Core::RenderResources::~RenderResources()
{
}
 
std::string Cogs::Core::RenderResources::getReport() const
{
  if(storage) {
    size_t meshes, textures, effects, materials, materialinstances, targets, lists, buffers;
    {
      LockGuard guard(storage->renderMeshMutex);
      meshes = storage->renderMeshes.size();
      textures = storage->renderTextures.size();
      effects = storage->renderEffects.size();
      materials = storage->renderMaterials.size();
      materialinstances = storage->renderMaterialInstances.size();
      targets = storage->renderTargets.size();
      lists = storage->renderLists.size();
      buffers = storage->renderBuffers.size();
    }
    char buf[1024];
    auto rv = std::snprintf(buf, sizeof(buf), "msh=%zu, tex=%zu, eff=%zu mat=%3zu, mit=%zu, trg=%3zu, lst=%zu, buf=%zu",
                            meshes, textures, effects, materials, materialinstances, targets, lists, buffers);
    if (0 <= rv && static_cast<size_t>(rv) < sizeof(buf)) {
      return std::string(buf);
    }
  }
  return std::string();
}
 
 
void Cogs::Core::RenderResources::initialize(Context * context, Renderer * renderer)
{
  this->context = context;
  this->renderer = renderer;
  device = renderer->getDevice();
  renderStates = &renderer->getRenderStates();
}
 
void Cogs::Core::RenderResources::cleanup(Context * /*context*/)
{
  //TODO: Perform shutdown validation.
}
 
RenderTarget * Cogs::Core::RenderResources::createRenderTarget()
{
  auto renderTarget = storage->renderTargets.create();
  renderTarget->type = RenderResourceType::RenderTarget;
  return renderTarget;
}
 
RenderTexture * Cogs::Core::RenderResources::createRenderTexture()
{
  auto renderTexture = storage->renderTextures.create();
  renderTexture->type = RenderResourceType::RenderTexture;
  return renderTexture;
}
 
RenderList * Cogs::Core::RenderResources::createRenderList()
{
  auto renderList = storage->renderLists.create();
  renderList->type = RenderResourceType::RenderList;
  return renderList;
}
 
RenderBuffer * Cogs::Core::RenderResources::createRenderBuffer()
{
  auto renderBuffer = storage->renderBuffers.create();
  renderBuffer->type = RenderResourceType::RenderBuffer;
  return renderBuffer;
}
 
Cogs::Core::RenderMesh * Cogs::Core::RenderResources::createRenderMesh()
{
  LockGuard lock(storage->renderMeshMutex);
 
  auto renderMesh = storage->renderMeshes.create();
  renderMesh->type = RenderResourceType::Unknown;
  return renderMesh;
}
 
void Cogs::Core::RenderResources::destroyRenderMesh(RenderMesh * renderMesh)
{
  LockGuard lock(storage->renderMeshMutex);
 
  storage->renderMeshes.destroy(renderMesh);
}
 
uint32_t Cogs::Core::RenderResources::getRenderHandle(RenderMesh * renderMesh)
{
  return storage->renderMeshes.getHandle(renderMesh);
}
 
RenderMesh * Cogs::Core::RenderResources::getRenderMesh(uint32_t handle)
{
  LockGuard lock(storage->renderMeshMutex);
 
  return storage->renderMeshes[handle];
}
 
void Cogs::Core::RenderResources::updateResource(RenderResource * resource)
{
  switch (resource->type)
  {
  case RenderResourceType::RenderTarget:
    static_cast<RenderTarget *>(resource)->update(renderer);
    break;
  case RenderResourceType::RenderTexture:
    static_cast<RenderTexture *>(resource)->update(renderer);
    break;
  case RenderResourceType::RenderBuffer:
    static_cast<RenderBuffer *>(resource)->update(renderer);
    break;
  default:
    break;
  }
}
 
void Cogs::Core::RenderResources::releaseResource(RenderResource * resource)
{
  switch (resource->type)
  {
  case RenderResourceType::RenderTarget:
    static_cast<RenderTarget *>(resource)->release(renderer);
    break;
  case RenderResourceType::RenderTexture:
    static_cast<RenderTexture *>(resource)->release(renderer);
    break;
  case RenderResourceType::RenderBuffer:
    static_cast<RenderBuffer *>(resource)->release(renderer);
    break;
  default:
    break;
  }
}
 
void Cogs::Core::RenderResources::destroyResource(RenderResource * resource)
{
  switch (resource->type)
  {
  case RenderResourceType::RenderTarget:
    storage->renderTargets.destroy(static_cast<RenderTarget *>(resource));
    break;
  case RenderResourceType::RenderTexture:
    storage->renderTextures.destroy(reinterpret_cast<RenderTexture *>(resource));
    break;
  case RenderResourceType::RenderBuffer:
    storage->renderBuffers.destroy(reinterpret_cast<RenderBuffer *>(resource));
    break;
  case RenderResourceType::RenderList:
    storage->renderLists.destroy(reinterpret_cast<RenderList *>(resource));
    break;
  default:
    break;
  }
}
 
RenderEffect * Cogs::Core::RenderResources::getRenderEffect(const EffectHandle & effect)
{
  auto effectResource = effect.resolve();
 
  if (!effectResource || !effectResource->hasAttachedResource()) return nullptr;
 
  return (RenderEffect *)effectResource->getAttachedResource();
}
 
RenderMaterial * Cogs::Core::RenderResources::getRenderMaterial(const Material * material)
{
  if (!material || !material->hasAttachedResource()) return nullptr;
 
  return (RenderMaterial *)material->getAttachedResource();
}
 
RenderMaterialInstance * Cogs::Core::RenderResources::getRenderMaterialInstance(const MaterialInstance * materialInstance)
{
  if (!materialInstance || !materialInstance->hasAttachedResource()) return nullptr;
 
  return (RenderMaterialInstance *)materialInstance->getAttachedResource();
}
 
RenderMaterial * Cogs::Core::RenderResources::getRenderMaterial(const MaterialHandle & material)
{
  return getRenderMaterial(material.resolve());
}
 
RenderMaterialInstance * Cogs::Core::RenderResources::getRenderMaterialInstance(const MaterialInstanceHandle & materialInstance)
{
  return getRenderMaterialInstance(materialInstance.resolve());
}
 
RenderTexture * Cogs::Core::RenderResources::getRenderTexture(const TextureHandle & texture)
{
  auto textureResource = texture.resolve();
 
  if (!textureResource || !textureResource->hasAttachedResource()) return nullptr;
 
  return (RenderTexture *)textureResource->getAttachedResource();
}
 
RenderMesh * Cogs::Core::RenderResources::getRenderMesh(const MeshHandle & mesh)
{
  LockGuard lock(storage->renderMeshMutex);
 
  auto meshResource = mesh.resolve();
 
  if (!meshResource || !meshResource->hasAttachedResource()) return nullptr;
 
  return (RenderMesh *)meshResource->getAttachedResource();
}
 
namespace Cogs::Core
{
  template<typename Handle, typename Resource>
  Resource * createGpuResource(const Handle & handle, Collections::Pool<Resource> & resources, RenderResources * /*renderResources*/)
  {
    auto resource = handle.resolve();
 
    if (!resource->hasAttachedResource()) {
      auto renderResource = resources.create();
      resource->attachResource(renderResource);
      renderResource->setResource(resource);
      renderResource->setName(resource->getName());
    }
 
    return static_cast<Resource *>(resource->getAttachedResource());
  }
}
 
ActivationResult Cogs::Core::RenderResources::updateResource(const MeshHandle & meshHandle)
{
  LockGuard lock(storage->renderMeshMutex);
  auto gpuResource = createGpuResource<MeshHandle, RenderMesh>(meshHandle, storage->renderMeshes, this);
  return gpuResource->update(meshHandle.resolve(), device, this);
}
 
ActivationResult Cogs::Core::RenderResources::updateResource(const TextureHandle & textureHandle)
{
  auto gpuResource = createGpuResource<TextureHandle, RenderTexture>(textureHandle, storage->renderTextures, this);
  return gpuResource->update(textureHandle.resolve(), device, this);
}
 
ActivationResult Cogs::Core::RenderResources::updateResource(const EffectHandle & effectHandle)
{
  auto gpuResource = createGpuResource<EffectHandle, RenderEffect>(effectHandle, storage->renderEffects, this);
  return gpuResource->update(effectHandle.resolve(), device, this);
}
 
Cogs::Core::ActivationResult Cogs::Core::RenderResources::updateResource(const MaterialHandle & materialHandle)
{
  auto gpuResource = createGpuResource<MaterialHandle, RenderMaterial>(materialHandle, storage->renderMaterials, this);
  return gpuResource->update(materialHandle.resolve(), device, this, renderStates);
}
 
Cogs::Core::ActivationResult Cogs::Core::RenderResources::updateResource(const MaterialInstanceHandle & materialInstanceHandle)
{
  auto gpuResource = createGpuResource<MaterialInstanceHandle, RenderMaterialInstance>(materialInstanceHandle, storage->renderMaterialInstances, this);
  return gpuResource->update(materialInstanceHandle.resolve(), device, this, renderStates);
}
 
namespace Cogs::Core
{
  template<typename RenderResourceType>
  RenderResource * releaseGpuResource(ResourceBase * resource, Renderer * renderer)
  {
    auto renderResource = (RenderResourceType *)resource->getAttachedResource();
    if (renderResource) {
      renderResource->release(renderer);
      resource->attachResource(nullptr);
      resource->unsetFlag(ResourceFlags::Resident);
    }
    return renderResource;
  }
}
 
void Cogs::Core::RenderResources::releaseResource(Texture * texture)
{
  if (auto renderResource = releaseGpuResource<RenderTexture>(texture, renderer)) {
    storage->renderTextures.destroy((RenderTexture *)renderResource);
  }
  if (!texture->isProxy() && texture->ownsExternalTexture.value) {
    if (texture->externalHandle) {
      device->getTextures()->releaseNativeTexture(texture->externalHandle);
      texture->externalHandle = 0;
    }
  }
}
 
void Cogs::Core::RenderResources::releaseResource(Mesh * mesh)
{
  LockGuard lock(storage->renderMeshMutex);
 
  if (auto renderResource = releaseGpuResource<RenderMesh>(mesh, renderer)) {
    storage->renderMeshes.destroy((RenderMesh *)renderResource);
  }
}
 
void Cogs::Core::RenderResources::releaseResource(Material * material)
{
  if (auto renderResource = releaseGpuResource<RenderMaterial>(material, renderer)) {
    storage->renderMaterials.destroy((RenderMaterial *)renderResource);
  }
}
 
void Cogs::Core::RenderResources::releaseResource(MaterialInstance * materialInstance)
{
  if (auto renderResource = releaseGpuResource<RenderMaterialInstance>(materialInstance, renderer)) {
    storage->renderMaterialInstances.destroy((RenderMaterialInstance *)renderResource);
  }
}
 
void Cogs::Core::RenderResources::releaseResource(Effect * effect)
{
  if (auto renderResource = releaseGpuResource<RenderEffect>(effect, renderer)) {
    storage->renderEffects.destroy((RenderEffect *)renderResource);
  }
}