serialize.cpp | Explore in Territory

//
// Copyright 2020 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// serialize.cpp:
//   ANGLE GL state serialization.
//

#include "libANGLE/capture/serialize.h"

#include "common/Color.h"
#include "common/MemoryBuffer.h"
#include "common/angleutils.h"
#include "common/gl_enum_utils.h"
#include "common/serializer/JsonSerializer.h"
#include "libANGLE/Buffer.h"
#include "libANGLE/Caps.h"
#include "libANGLE/Context.h"
#include "libANGLE/Framebuffer.h"
#include "libANGLE/Query.h"
#include "libANGLE/RefCountObject.h"
#include "libANGLE/ResourceMap.h"
#include "libANGLE/Sampler.h"
#include "libANGLE/State.h"
#include "libANGLE/TransformFeedback.h"
#include "libANGLE/VertexAttribute.h"
#include "libANGLE/angletypes.h"
#include "libANGLE/renderer/FramebufferImpl.h"
#include "libANGLE/renderer/RenderbufferImpl.h"

#include <vector>

#if !ANGLE_CAPTURE_ENABLED
#    error Frame capture must be enabled to build this file.
#endif  // !ANGLE_CAPTURE_ENABLED

// Note: when diagnosing serialization comparison failures, you can disable the unused function
// compiler warning to allow bisecting the comparison function. One first check is to disable
// Framebuffer Attachment pixel comparison which includes the pixel contents of the default FBO.
// ANGLE_DISABLE_UNUSED_FUNCTION_WARNING

namespace angle
{
namespace
{
template <typename ArgT>
std::string ToString(const ArgT &arg)
{ … }

#define ENUM_TO_STRING …

const char *InitStateToString(gl::InitState state)
{ … }

const char *SrgbOverrideToString(gl::SrgbOverride value)
{ … }

const char *ColorGenericTypeToString(gl::ColorGeneric::Type type)
{ … }

const char *CompileStatusToString(gl::CompileStatus status)
{ … }

#undef ENUM_TO_STRING

class [[nodiscard]] GroupScope
{ … };

void SerializeColorF(JsonSerializer *json, const ColorF &color)
{ … }

void SerializeColorFWithGroup(JsonSerializer *json, const char *groupName, const ColorF &color)
{ … }

void SerializeColorI(JsonSerializer *json, const ColorI &color)
{ … }

void SerializeColorUI(JsonSerializer *json, const ColorUI &color)
{ … }

void SerializeExtents(JsonSerializer *json, const gl::Extents &extents)
{ … }

template <class ObjectType>
void SerializeOffsetBindingPointerVector(
    JsonSerializer *json,
    const char *groupName,
    const std::vector<gl::OffsetBindingPointer<ObjectType>> &offsetBindingPointerVector)
{ … }

template <class ObjectType>
void SerializeBindingPointerVector(
    JsonSerializer *json,
    const std::vector<gl::BindingPointer<ObjectType>> &bindingPointerVector)
{ … }

template <class T>
void SerializeRange(JsonSerializer *json, const gl::Range<T> &range)
{ … }

bool IsValidColorAttachmentBinding(GLenum binding, size_t colorAttachmentsCount)
{ … }

void SerializeFormat(JsonSerializer *json, GLenum glFormat)
{ … }

void SerializeInternalFormat(JsonSerializer *json, const gl::InternalFormat *internalFormat)
{ … }

void SerializeANGLEFormat(JsonSerializer *json, const angle::Format *format)
{ … }

void SerializeGLFormat(JsonSerializer *json, const gl::Format &format)
{ … }

Result ReadPixelsFromAttachment(const gl::Context *context,
                                gl::Framebuffer *framebuffer,
                                const gl::FramebufferAttachment &framebufferAttachment,
                                ScratchBuffer *scratchBuffer,
                                MemoryBuffer **pixels)
{ … }
void SerializeImageIndex(JsonSerializer *json, const gl::ImageIndex &imageIndex)
{ … }

Result SerializeFramebufferAttachment(const gl::Context *context,
                                      JsonSerializer *json,
                                      ScratchBuffer *scratchBuffer,
                                      gl::Framebuffer *framebuffer,
                                      const gl::FramebufferAttachment &framebufferAttachment,
                                      gl::GLESEnum enumGroup)
{ … }

Result SerializeFramebufferState(const gl::Context *context,
                                 JsonSerializer *json,
                                 ScratchBuffer *scratchBuffer,
                                 gl::Framebuffer *framebuffer,
                                 const gl::FramebufferState &framebufferState)
{ … }

Result SerializeFramebuffer(const gl::Context *context,
                            JsonSerializer *json,
                            ScratchBuffer *scratchBuffer,
                            gl::Framebuffer *framebuffer)
{ … }

void SerializeRasterizerState(JsonSerializer *json, const gl::RasterizerState &rasterizerState)
{ … }

void SerializeRectangle(JsonSerializer *json,
                        const std::string &name,
                        const gl::Rectangle &rectangle)
{ … }

void SerializeBlendStateExt(JsonSerializer *json, const gl::BlendStateExt &blendStateExt)
{ … }

void SerializeDepthStencilState(JsonSerializer *json,
                                const gl::DepthStencilState &depthStencilState)
{ … }

void SerializeVertexAttribCurrentValueData(
    JsonSerializer *json,
    const gl::VertexAttribCurrentValueData &vertexAttribCurrentValueData)
{ … }

void SerializePixelPackState(JsonSerializer *json, const gl::PixelPackState &pixelPackState)
{ … }

void SerializePixelUnpackState(JsonSerializer *json, const gl::PixelUnpackState &pixelUnpackState)
{ … }

void SerializeImageUnit(JsonSerializer *json, const gl::ImageUnit &imageUnit, int imageUnitIndex)
{ … }

template <typename ResourceType>
void SerializeResourceID(JsonSerializer *json, const char *name, const ResourceType *resource)
{ … }

void SerializeContextState(JsonSerializer *json, const gl::State &state)
{ … }

void SerializeBufferState(JsonSerializer *json, const gl::BufferState &bufferState)
{ … }

Result SerializeBuffer(const gl::Context *context,
                       JsonSerializer *json,
                       ScratchBuffer *scratchBuffer,
                       gl::Buffer *buffer)
{ … }

void SerializeColorGeneric(JsonSerializer *json,
                           const std::string &name,
                           const ColorGeneric &colorGeneric)
{ … }

void SerializeSamplerState(JsonSerializer *json, const gl::SamplerState &samplerState)
{ … }

void SerializeSampler(JsonSerializer *json, gl::Sampler *sampler)
{ … }

void SerializeSwizzleState(JsonSerializer *json, const gl::SwizzleState &swizzleState)
{ … }

void SerializeRenderbufferState(JsonSerializer *json,
                                const gl::RenderbufferState &renderbufferState)
{ … }

Result SerializeRenderbuffer(const gl::Context *context,
                             JsonSerializer *json,
                             ScratchBuffer *scratchBuffer,
                             gl::Renderbuffer *renderbuffer)
{ … }

void SerializeWorkGroupSize(JsonSerializer *json, const sh::WorkGroupSize &workGroupSize)
{ … }

void SerializeUniformIndexToBufferBinding(JsonSerializer *json,
                                          const gl::ProgramUniformBlockArray<GLuint> &blockToBuffer)
{ … }

void SerializeShaderVariable(JsonSerializer *json, const sh::ShaderVariable &shaderVariable)
{ … }

void SerializeShaderVariablesVector(JsonSerializer *json,
                                    const std::vector<sh::ShaderVariable> &shaderVariables)
{ … }

void SerializeInterfaceBlocksVector(JsonSerializer *json,
                                    const std::vector<sh::InterfaceBlock> &interfaceBlocks)
{ … }

void SerializeCompiledShaderState(JsonSerializer *json, const gl::SharedCompiledShaderState &state)
{ … }

void SerializeShaderState(JsonSerializer *json, const gl::ShaderState &shaderState)
{ … }

void SerializeShader(const gl::Context *context,
                     JsonSerializer *json,
                     GLuint id,
                     gl::Shader *shader)
{ … }

void SerializeVariableLocationsVector(JsonSerializer *json,
                                      const std::string &group_name,
                                      const std::vector<gl::VariableLocation> &variableLocations)
{ … }

void SerializeBlockMemberInfo(JsonSerializer *json, const sh::BlockMemberInfo &blockMemberInfo)
{ … }

void SerializeBufferVariablesVector(JsonSerializer *json,
                                    const std::vector<gl::BufferVariable> &bufferVariables)
{ … }

void SerializeProgramAliasedBindings(JsonSerializer *json,
                                     const gl::ProgramAliasedBindings &programAliasedBindings)
{ … }

void SerializeProgramState(JsonSerializer *json, const gl::ProgramState &programState)
{ … }

void SerializeProgramBindings(JsonSerializer *json, const gl::ProgramBindings &programBindings)
{ … }

template <typename T>
void SerializeUniformData(JsonSerializer *json,
                          const gl::Context *context,
                          const gl::ProgramExecutable &executable,
                          gl::UniformLocation loc,
                          GLenum type,
                          GLint size,
                          void (gl::ProgramExecutable::*getFunc)(const gl::Context *,
                                                                 gl::UniformLocation,
                                                                 T *) const)
{ … }

void SerializeProgram(JsonSerializer *json,
                      const gl::Context *context,
                      GLuint id,
                      gl::Program *program)
{ … }

void SerializeImageDesc(JsonSerializer *json, size_t descIndex, const gl::ImageDesc &imageDesc)
{ … }

void SerializeTextureState(JsonSerializer *json, const gl::TextureState &textureState)
{ … }

Result SerializeTextureData(JsonSerializer *json,
                            const gl::Context *context,
                            gl::Texture *texture,
                            ScratchBuffer *scratchBuffer)
{ … }

Result SerializeTexture(const gl::Context *context,
                        JsonSerializer *json,
                        ScratchBuffer *scratchBuffer,
                        gl::Texture *texture)
{ … }

void SerializeVertexAttributeVector(JsonSerializer *json,
                                    const std::vector<gl::VertexAttribute> &vertexAttributes)
{ … }

void SerializeVertexBindingsVector(JsonSerializer *json,
                                   const std::vector<gl::VertexBinding> &vertexBindings)
{ … }

void SerializeVertexArrayState(JsonSerializer *json, const gl::VertexArrayState &vertexArrayState)
{ … }

void SerializeVertexArray(JsonSerializer *json, gl::VertexArray *vertexArray)
{ … }

}  // namespace

Result SerializeContextToString(const gl::Context *context, std::string *stringOut)
{ … }

}  // namespace angle
chromium/third_party/angle/src/libANGLE/capture/serialize.cpp
