RenderTexture.cpp

#include "RenderTexture.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/ITextures.h"
#include "Rendering/IContext.h"
#include "Rendering/IRenderTargets.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/BitTwiddling/PowerOfTwo.h"
 
#include "Resources/Texture.h"
 
#include "Context.h"
#include "Renderer.h"
#include "RenderTarget.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderTexture");
 
  // Count the number of leading zeros.
  uint32_t lzcnt(uint32_t x)
  {
    if (x == 0u) return (32u);
    uint32_t n = 1u;
    if ((x >> 16) == 0) { n += 16u; x = x << 16; }
    if ((x >> 24) == 0) { n +=  8u; x = x <<  8; }
    if ((x >> 28) == 0) { n +=  4u; x = x <<  4; }
    if ((x >> 30) == 0) { n +=  2u; x = x <<  2; }
    return n - (x >> 31);
  }
 
}
 
Cogs::Core::RenderTexture::RenderTexture()
{
  type = RenderResourceType::RenderTexture;
}
 
Cogs::Core::ActivationResult Cogs::Core::RenderTexture::update(Texture * texture, IGraphicsDevice * device, RenderResources * renderResources)
{
  setResource(texture);
 
  if (isOwned()) return ActivationResult::Success;
 
  ITextures* textures = device->getTextures();
  const bool isRenderTarget = (texture->description.flags & TextureFlags::RenderTarget) != 0;
  const bool isDepthTarget = (texture->description.flags & TextureFlags::DepthBuffer) != 0;
  const bool dimensionsChanged = texture->description.width != description.width ||
    texture->description.target != description.target ||
    texture->description.height != description.height ||
    texture->description.depth != description.depth ||
    texture->description.format != description.format ||
    texture->description.layers != description.layers ||
    texture->description.levels != description.levels ||
    texture->description.faces != description.faces ||
    texture->description.samples != description.samples ||
    !HandleIsValid(textureHandle);
 
  if (!dimensionsChanged) {
    if (!isRenderTarget && !isDepthTarget) {
      if (!texture->storage.data.empty()) {
        if (device->getType() == Cogs::GraphicsDeviceType::OpenGL20 ||
            device->getType() == Cogs::GraphicsDeviceType::OpenGLES30)  // UploadTextureData is not implemented for all device types.
        {
          TextureExtent extent{
            .width = description.width,
            .height = description.height,
            .depth = description.depth,
          };
          TextureData textureData(texture->storage.getData(), extent, description.layers, description.faces, description.levels, description.format);
          textures->uploadTextureData(textureHandle, textureData);
        }
        else {
          device->getImmediateContext()->updateSubTexture(textureHandle, 0, texture->storage.getData());
 
          if (texture->description.flags & TextureFlags::GenerateMipMaps) {
            textures->generateMipmaps(textureHandle);
          }
        }
      }
    }
  } else {
    release(device, renderResources);
 
    if (texture->externalHandle) {
      texture->description.flags |= TextureFlags::ExternalTexture;
      TextureData textureData;
      textureData.initExternal(texture->externalHandle);
      textureHandle = textures->loadTexture(texture->description, &textureData);
      textures->annotate(textureHandle, getName());
    }
    else if (texture->ownsExternalTexture.value) {
      LOG_TRACE(logger, "Clearing render texture handle");
      textureHandle = Cogs::TextureHandle();  // External texture that shouldn't be used anymore.
      setFailed();
      return ActivationResult::Failure;
    }
    else {
      textureHandle = textures->loadTexture(texture->description, (isRenderTarget || isDepthTarget || !texture->storage.data.size()) ? nullptr : &texture->storage);
      textures->annotate(textureHandle, getName());
    }
 
    description = texture->description;
  }
  texture->clearData();
 
  if (!HandleIsValid(textureHandle)) {
    LOG_ERROR(logger, "Failed to create texture.");
 
    setFailed();
 
    return ActivationResult::Failure;
  }
 
  incrementGeneration();
  setActive();
 
  return ActivationResult::Success;
}
 
void Cogs::Core::RenderTexture::release(IGraphicsDevice * device, RenderResources * resources)
{
  if (renderTarget) {
    resources->releaseResource(renderTarget);
    renderTarget = nullptr;
  }
  if (resolveTarget) {
    resources->releaseResource(resolveTarget);
    resolveTarget = nullptr;
  }
 
  if (depthTexture) {
    resources->releaseResource(depthTexture);
    depthTexture = nullptr;
  }
 
  auto textures = device->getTextures();
 
  for (auto & view : views) {
    textures->releaseTextureView(view.second);
  }
  views.clear();
 
  if (HandleIsValid(textureHandle)) {
    textures->releaseTexture(textureHandle);
    textureHandle = Cogs::TextureHandle::NoHandle;
  }
}
 
void Cogs::Core::RenderTexture::release(Renderer * renderer)
{
  release(renderer->getDevice(), &renderer->getRenderResources());
  setReleased();
}
 
void Cogs::Core::RenderTexture::update(Renderer * renderer)
{
  auto device = renderer->getDevice();
  auto textures = device->getTextures();
 
  // By default we size textures to the back buffer size.
  auto targetSize = renderer->getSize();
 
  if (isOverride()) return;
 
  float scale = 1.0f;
  uint32_t targetWidth = (uint32_t)(scale * (float)targetSize.x);
  uint32_t targetHeight = (uint32_t)(scale * (float)targetSize.y);
  uint32_t targetSamples = static_cast<uint32_t>(samples);
 
  if (sizeSource) {
    if (sizeSource->getType() == RenderResourceType::RenderTexture) {
      targetWidth = static_cast<RenderTexture *>(sizeSource)->description.width;
      targetHeight = static_cast<RenderTexture *>(sizeSource)->description.height;
    }
    else {
      targetWidth = static_cast<RenderTarget *>(sizeSource)->width;
      targetHeight = static_cast<RenderTarget *>(sizeSource)->height;
    }
  }
  else{
    int iw = static_cast<int>(width);
    int ih = static_cast<int>(height);
    if((description.width != (uint32_t)std::max(iw, 2)) && iw < 2){
      LOG_WARNING(logger, "Render texture, width %d < 2. (Clamping to 2).", iw);
    }
    if((description.height != (uint32_t)std::max(ih, 2)) && ih < 2){
      LOG_WARNING(logger, "Render texture, height %d < 2. (Clamping to 2).", ih);
    }
    targetWidth = std::max(iw, 2);
    targetHeight = std::max(ih, 2);
  }
 
  // Maximum number of mipmap levels, power of two of largest size, rounded down.
  uint32_t maxSize = static_cast<uint32_t>(std::max(targetWidth, targetHeight));
  uint32_t maxLevels = 31 - std::min(31u, lzcnt(maxSize));
  assert((maxSize == 0) || ((1u << maxLevels) <= maxSize));
  assert(maxSize <= (1u << (maxLevels + 1)));
  uint32_t targetLevels = std::min(maxLevels, static_cast<uint32_t>(levels.getValue() == 0 ? 1 : levels.getValue()));
 
  // Only 1 or 6 are acceptable values.
  uint32_t targetFaces = 1;
  if (faces == 6) targetFaces = 6;
 
  uint32_t targetLayers = static_cast<uint32_t>(layers.getValue() == 0 ? 1 : layers.getValue());
 
  if (!targetWidth || !targetHeight) return;
 
  if (targetWidth == description.width &&
      targetHeight == description.height &&
      targetLevels == description.levels &&
      targetFaces == description.faces &&
      targetLayers == description.layers &&
      targetSamples == description.samples) return;
 
  release(renderer);
 
  description.width = targetWidth;
  description.height = targetHeight;
  description.levels = targetLevels;
  description.faces = targetFaces;
  description.layers = targetLayers;
  description.samples = targetSamples;
  if (description.target == ResourceDimensions::Texture2D && description.samples > 1) {
    description.target = ResourceDimensions::Texture2DMS;
  }
  if (description.target == ResourceDimensions::Texture2DMS && description.samples == 1) {
    description.target = ResourceDimensions::Texture2D;
  }
 
  textureHandle = textures->loadTexture(description, nullptr);
 
  textures->annotate(textureHandle, getName());
 
  incrementGeneration();
}