formats.cc

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.
 
#include "impeller/core/formats.h"
 
#include <format>
#include <sstream>
 
#include "impeller/base/validation.h"
#include "impeller/core/texture.h"
 
namespace impeller {
 
constexpr bool StoreActionNeedsResolveTexture(StoreAction action) {
  switch (action) {
    case StoreAction::kDontCare:
    case StoreAction::kStore:
      return false;
    case StoreAction::kMultisampleResolve:
    case StoreAction::kStoreAndMultisampleResolve:
      return true;
  }
}
 
bool Attachment::IsValid() const {
  if (!texture || !texture->IsValid()) {
    VALIDATION_LOG << "Attachment has no texture.";
    return false;
  }
 
  const TextureDescriptor& desc = texture->GetTextureDescriptor();
  if (mip_level >= desc.mip_count) {
    VALIDATION_LOG << "Attachment mip_level " << mip_level
                   << " is out of range; the texture has " << desc.mip_count
                   << " mip levels.";
    return false;
  }
  const uint32_t slice_count = desc.type == TextureType::kTextureCube ? 6u : 1u;
  if (slice >= slice_count) {
    VALIDATION_LOG << "Attachment slice " << slice
                   << " is out of range for the texture type.";
    return false;
  }
 
  if (StoreActionNeedsResolveTexture(store_action)) {
    if (!resolve_texture || !resolve_texture->IsValid()) {
      VALIDATION_LOG << "Store action needs resolve but no valid resolve "
                        "texture specified.";
      return false;
    }
  }
 
  if (resolve_texture) {
    if (store_action != StoreAction::kMultisampleResolve &&
        store_action != StoreAction::kStoreAndMultisampleResolve) {
      VALIDATION_LOG << "A resolve texture was specified, but the store action "
                        "doesn't include multisample resolve.";
      return false;
    }
 
    if (texture->GetTextureDescriptor().storage_mode ==
            StorageMode::kDeviceTransient &&
        store_action == StoreAction::kStoreAndMultisampleResolve) {
      VALIDATION_LOG
          << "The multisample texture cannot be transient when "
             "specifying the StoreAndMultisampleResolve StoreAction.";
    }
  }
 
  auto storage_mode = resolve_texture
                          ? resolve_texture->GetTextureDescriptor().storage_mode
                          : texture->GetTextureDescriptor().storage_mode;
 
  if (storage_mode == StorageMode::kDeviceTransient) {
    if (load_action == LoadAction::kLoad) {
      VALIDATION_LOG << "The LoadAction cannot be Load when attaching a device "
                        "transient " +
                            std::string(resolve_texture ? "resolve texture."
                                                        : "texture.");
      return false;
    }
    if (store_action != StoreAction::kDontCare) {
      VALIDATION_LOG << "The StoreAction must be DontCare when attaching a "
                        "device transient " +
                            std::string(resolve_texture ? "resolve texture."
                                                        : "texture.");
      return false;
    }
  }
 
  return true;
}
 
std::string TextureUsageMaskToString(TextureUsageMask mask) {
  std::vector<TextureUsage> usages;
  if (mask & TextureUsage::kShaderRead) {
    usages.push_back(TextureUsage::kShaderRead);
  }
  if (mask & TextureUsage::kShaderWrite) {
    usages.push_back(TextureUsage::kShaderWrite);
  }
  if (mask & TextureUsage::kRenderTarget) {
    usages.push_back(TextureUsage::kRenderTarget);
  }
  std::stringstream stream;
  stream << "{ ";
  for (size_t i = 0; i < usages.size(); i++) {
    stream << TextureUsageToString(usages[i]);
    if (i != usages.size() - 1u) {
      stream << ", ";
    }
  }
  stream << " }";
  return stream.str();
}
 
std::string AttachmentToString(const Attachment& attachment) {
  std::stringstream stream;
  if (attachment.texture) {
    stream << "Texture=("
           << TextureDescriptorToString(
                  attachment.texture->GetTextureDescriptor())
           << "),";
  }
  if (attachment.resolve_texture) {
    stream << "ResolveTexture=("
           << TextureDescriptorToString(
                  attachment.resolve_texture->GetTextureDescriptor())
           << "),";
  }
  stream << "LoadAction=" << LoadActionToString(attachment.load_action) << ",";
  stream << "StoreAction=" << StoreActionToString(attachment.store_action);
  return stream.str();
}
 
std::string ColorAttachmentToString(const ColorAttachment& color) {
  std::stringstream stream;
  stream << AttachmentToString(color) << ",";
  stream << "ClearColor=" << color.clear_color;
  return stream.str();
}
 
std::string DepthAttachmentToString(const DepthAttachment& depth) {
  std::stringstream stream;
  stream << AttachmentToString(depth) << ",";
  stream << std::format("ClearDepth={:.2f}", depth.clear_depth);
  return stream.str();
}
 
std::string StencilAttachmentToString(const StencilAttachment& stencil) {
  std::stringstream stream;
  stream << AttachmentToString(stencil) << ",";
  stream << std::format("ClearStencil={}", stencil.clear_stencil);
  return stream.str();
}
 
}  // namespace impeller