diff options
Diffstat (limited to 'gfx/angle/checkout/src/libANGLE/capture')
18 files changed, 19921 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/libANGLE/capture/FrameCapture.h b/gfx/angle/checkout/src/libANGLE/capture/FrameCapture.h new file mode 100644 index 0000000000..a9b0348b6a --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/FrameCapture.h @@ -0,0 +1,1208 @@ +// +// Copyright 2019 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. +// +// FrameCapture.h: +// ANGLE Frame capture interface. +// + +#ifndef LIBANGLE_FRAME_CAPTURE_H_ +#define LIBANGLE_FRAME_CAPTURE_H_ + +#include "common/PackedEnums.h" +#include "common/system_utils.h" +#include "libANGLE/Context.h" +#include "libANGLE/angletypes.h" +#include "libANGLE/capture/frame_capture_utils_autogen.h" +#include "libANGLE/entry_points_utils.h" + +namespace gl +{ +enum class BigGLEnum; +enum class GLESEnum; +} // namespace gl + +namespace angle +{ + +using ParamData = std::vector<std::vector<uint8_t>>; +struct ParamCapture : angle::NonCopyable +{ + ParamCapture(); + ParamCapture(const char *nameIn, ParamType typeIn); + ~ParamCapture(); + + ParamCapture(ParamCapture &&other); + ParamCapture &operator=(ParamCapture &&other); + + std::string name; + ParamType type; + ParamValue value; + gl::GLESEnum enumGroup; // only used for param type GLenum, GLboolean and GLbitfield + gl::BigGLEnum bigGLEnum; // only used for param type GLenum, GLboolean and GLbitfield + ParamData data; + int dataNElements = 0; + int arrayClientPointerIndex = -1; + size_t readBufferSizeBytes = 0; +}; + +class ParamBuffer final : angle::NonCopyable +{ + public: + ParamBuffer(); + ~ParamBuffer(); + + ParamBuffer(ParamBuffer &&other); + ParamBuffer &operator=(ParamBuffer &&other); + + template <typename T> + void addValueParam(const char *paramName, ParamType paramType, T paramValue); + template <typename T> + void setValueParamAtIndex(const char *paramName, ParamType paramType, T paramValue, int index); + template <typename T> + void addEnumParam(const char *paramName, + gl::GLESEnum enumGroup, + ParamType paramType, + T paramValue); + template <typename T> + void addEnumParam(const char *paramName, + gl::BigGLEnum enumGroup, + ParamType paramType, + T paramValue); + + ParamCapture &getParam(const char *paramName, ParamType paramType, int index); + const ParamCapture &getParam(const char *paramName, ParamType paramType, int index) const; + ParamCapture &getParamFlexName(const char *paramName1, + const char *paramName2, + ParamType paramType, + int index); + const ParamCapture &getParamFlexName(const char *paramName1, + const char *paramName2, + ParamType paramType, + int index) const; + const ParamCapture &getReturnValue() const { return mReturnValueCapture; } + + void addParam(ParamCapture &¶m); + void addReturnValue(ParamCapture &&returnValue); + bool hasClientArrayData() const { return mClientArrayDataParam != -1; } + ParamCapture &getClientArrayPointerParameter(); + size_t getReadBufferSize() const { return mReadBufferSize; } + + const std::vector<ParamCapture> &getParamCaptures() const { return mParamCaptures; } + + // These helpers allow us to track the ID of the buffer that was active when + // MapBufferRange was called. We'll use it during replay to track the + // buffer's contents, as they can be modified by the host. + void setMappedBufferID(gl::BufferID bufferID) { mMappedBufferID = bufferID; } + gl::BufferID getMappedBufferID() const { return mMappedBufferID; } + + private: + std::vector<ParamCapture> mParamCaptures; + ParamCapture mReturnValueCapture; + int mClientArrayDataParam = -1; + size_t mReadBufferSize = 0; + gl::BufferID mMappedBufferID; +}; + +struct CallCapture +{ + CallCapture(EntryPoint entryPointIn, ParamBuffer &¶msIn); + CallCapture(const std::string &customFunctionNameIn, ParamBuffer &¶msIn); + ~CallCapture(); + + CallCapture(CallCapture &&other); + CallCapture &operator=(CallCapture &&other); + + const char *name() const; + + EntryPoint entryPoint; + std::string customFunctionName; + ParamBuffer params; + bool isActive = true; +}; + +class ReplayContext +{ + public: + ReplayContext(size_t readBufferSizebytes, const gl::AttribArray<size_t> &clientArraysSizebytes); + ~ReplayContext(); + + template <typename T> + T getReadBufferPointer(const ParamCapture ¶m) + { + ASSERT(param.readBufferSizeBytes > 0); + ASSERT(mReadBuffer.size() >= param.readBufferSizeBytes); + return reinterpret_cast<T>(mReadBuffer.data()); + } + template <typename T> + T getAsConstPointer(const ParamCapture ¶m) + { + if (param.arrayClientPointerIndex != -1) + { + return reinterpret_cast<T>(mClientArraysBuffer[param.arrayClientPointerIndex].data()); + } + + if (!param.data.empty()) + { + ASSERT(param.data.size() == 1); + return reinterpret_cast<T>(param.data[0].data()); + } + + return nullptr; + } + + template <typename T> + T getAsPointerConstPointer(const ParamCapture ¶m) + { + static_assert(sizeof(typename std::remove_pointer<T>::type) == sizeof(uint8_t *), + "pointer size not match!"); + + ASSERT(!param.data.empty()); + mPointersBuffer.clear(); + mPointersBuffer.reserve(param.data.size()); + for (const std::vector<uint8_t> &data : param.data) + { + mPointersBuffer.emplace_back(data.data()); + } + return reinterpret_cast<T>(mPointersBuffer.data()); + } + + gl::AttribArray<std::vector<uint8_t>> &getClientArraysBuffer() { return mClientArraysBuffer; } + + private: + std::vector<uint8_t> mReadBuffer; + std::vector<const uint8_t *> mPointersBuffer; + gl::AttribArray<std::vector<uint8_t>> mClientArraysBuffer; +}; + +// Helper to use unique IDs for each local data variable. +class DataCounters final : angle::NonCopyable +{ + public: + DataCounters(); + ~DataCounters(); + + int getAndIncrement(EntryPoint entryPoint, const std::string ¶mName); + + private: + // <CallName, ParamName> + using Counter = std::pair<EntryPoint, std::string>; + std::map<Counter, int> mData; +}; + +constexpr int kStringsNotFound = -1; +class StringCounters final : angle::NonCopyable +{ + public: + StringCounters(); + ~StringCounters(); + + int getStringCounter(const std::vector<std::string> &str); + void setStringCounter(const std::vector<std::string> &str, int &counter); + + private: + std::map<std::vector<std::string>, int> mStringCounterMap; +}; + +class DataTracker final : angle::NonCopyable +{ + public: + DataTracker(); + ~DataTracker(); + + DataCounters &getCounters() { return mCounters; } + StringCounters &getStringCounters() { return mStringCounters; } + + private: + DataCounters mCounters; + StringCounters mStringCounters; +}; + +class ReplayWriter final : angle::NonCopyable +{ + public: + ReplayWriter(); + ~ReplayWriter(); + + void setSourceFileSizeThreshold(size_t sourceFileSizeThreshold); + void setFilenamePattern(const std::string &pattern); + void setCaptureLabel(const std::string &label); + void setSourcePrologue(const std::string &prologue); + void setHeaderPrologue(const std::string &prologue); + + void addPublicFunction(const std::string &functionProto, + const std::stringstream &headerStream, + const std::stringstream &bodyStream); + void addPrivateFunction(const std::string &functionProto, + const std::stringstream &headerStream, + const std::stringstream &bodyStream); + std::string getInlineVariableName(EntryPoint entryPoint, const std::string ¶mName); + + std::string getInlineStringSetVariableName(EntryPoint entryPoint, + const std::string ¶mName, + const std::vector<std::string> &strings, + bool *isNewEntryOut); + + void saveFrame(); + void saveFrameIfFull(); + void saveIndexFilesAndHeader(); + void saveSetupFile(); + + std::vector<std::string> getAndResetWrittenFiles(); + + private: + static std::string GetVarName(EntryPoint entryPoint, const std::string ¶mName, int counter); + + void saveHeader(); + void writeReplaySource(const std::string &filename); + void addWrittenFile(const std::string &filename); + size_t getStoredReplaySourceSize() const; + + size_t mSourceFileSizeThreshold; + size_t mFrameIndex; + + DataTracker mDataTracker; + std::string mFilenamePattern; + std::string mCaptureLabel; + std::string mSourcePrologue; + std::string mHeaderPrologue; + + std::vector<std::string> mReplayHeaders; + std::vector<std::string> mGlobalVariableDeclarations; + + std::vector<std::string> mPublicFunctionPrototypes; + std::vector<std::string> mPublicFunctions; + + std::vector<std::string> mPrivateFunctionPrototypes; + std::vector<std::string> mPrivateFunctions; + + std::vector<std::string> mWrittenFiles; +}; + +using BufferCalls = std::map<GLuint, std::vector<CallCapture>>; + +// true means mapped, false means unmapped +using BufferMapStatusMap = std::map<GLuint, bool>; + +using FenceSyncSet = std::set<GLsync>; +using FenceSyncCalls = std::map<GLsync, std::vector<CallCapture>>; + +// For default uniforms, we need to track which ones are dirty, and the series of calls to reset. +// Each program has unique default uniforms, and each uniform has one or more locations in the +// default buffer. For reset efficiency, we track only the uniforms dirty by location, per program. + +// A set of all default uniforms (per program) that were modified during the run +using DefaultUniformLocationsSet = std::set<gl::UniformLocation>; +using DefaultUniformLocationsPerProgramMap = + std::map<gl::ShaderProgramID, DefaultUniformLocationsSet>; + +// A map of programs which maps to locations and their reset calls +using DefaultUniformCallsPerLocationMap = std::map<gl::UniformLocation, std::vector<CallCapture>>; +using DefaultUniformCallsPerProgramMap = + std::map<gl::ShaderProgramID, DefaultUniformCallsPerLocationMap>; + +using DefaultUniformBaseLocationMap = + std::map<std::pair<gl::ShaderProgramID, gl::UniformLocation>, gl::UniformLocation>; + +using ResourceSet = std::set<GLuint>; +using ResourceCalls = std::map<GLuint, std::vector<CallCapture>>; + +class TrackedResource final : angle::NonCopyable +{ + public: + TrackedResource(); + ~TrackedResource(); + + const ResourceSet &getStartingResources() const { return mStartingResources; } + ResourceSet &getStartingResources() { return mStartingResources; } + const ResourceSet &getNewResources() const { return mNewResources; } + ResourceSet &getNewResources() { return mNewResources; } + const ResourceSet &getResourcesToRegen() const { return mResourcesToRegen; } + ResourceSet &getResourcesToRegen() { return mResourcesToRegen; } + const ResourceSet &getResourcesToRestore() const { return mResourcesToRestore; } + ResourceSet &getResourcesToRestore() { return mResourcesToRestore; } + + void setGennedResource(GLuint id); + void setDeletedResource(GLuint id); + void setModifiedResource(GLuint id); + bool resourceIsGenerated(GLuint id); + + ResourceCalls &getResourceRegenCalls() { return mResourceRegenCalls; } + ResourceCalls &getResourceRestoreCalls() { return mResourceRestoreCalls; } + + private: + // Resource regen calls will gen a resource + ResourceCalls mResourceRegenCalls; + // Resource restore calls will restore the contents of a resource + ResourceCalls mResourceRestoreCalls; + + // Resources created during startup + ResourceSet mStartingResources; + + // Resources created during the run that need to be deleted + ResourceSet mNewResources; + // Resources deleted during the run that need to be recreated + ResourceSet mResourcesToRegen; + // Resources modified during the run that need to be restored + ResourceSet mResourcesToRestore; +}; + +using TrackedResourceArray = + std::array<TrackedResource, static_cast<uint32_t>(ResourceIDType::EnumCount)>; + +// Helper to track resource changes during the capture +class ResourceTracker final : angle::NonCopyable +{ + public: + ResourceTracker(); + ~ResourceTracker(); + + BufferCalls &getBufferMapCalls() { return mBufferMapCalls; } + BufferCalls &getBufferUnmapCalls() { return mBufferUnmapCalls; } + + std::vector<CallCapture> &getBufferBindingCalls() { return mBufferBindingCalls; } + + void setBufferMapped(gl::ContextID contextID, GLuint id); + void setBufferUnmapped(gl::ContextID contextID, GLuint id); + + bool getStartingBuffersMappedCurrent(GLuint id) const; + bool getStartingBuffersMappedInitial(GLuint id) const; + + void setStartingBufferMapped(GLuint id, bool mapped) + { + // Track the current state (which will change throughout the trace) + mStartingBuffersMappedCurrent[id] = mapped; + + // And the initial state, to compare during frame loop reset + mStartingBuffersMappedInitial[id] = mapped; + } + + void onShaderProgramAccess(gl::ShaderProgramID shaderProgramID); + uint32_t getMaxShaderPrograms() const { return mMaxShaderPrograms; } + + FenceSyncSet &getStartingFenceSyncs() { return mStartingFenceSyncs; } + FenceSyncCalls &getFenceSyncRegenCalls() { return mFenceSyncRegenCalls; } + FenceSyncSet &getFenceSyncsToRegen() { return mFenceSyncsToRegen; } + void setDeletedFenceSync(GLsync sync); + + DefaultUniformLocationsPerProgramMap &getDefaultUniformsToReset() + { + return mDefaultUniformsToReset; + } + DefaultUniformCallsPerLocationMap &getDefaultUniformResetCalls(gl::ShaderProgramID id) + { + return mDefaultUniformResetCalls[id]; + } + void setModifiedDefaultUniform(gl::ShaderProgramID programID, gl::UniformLocation location); + void setDefaultUniformBaseLocation(gl::ShaderProgramID programID, + gl::UniformLocation location, + gl::UniformLocation baseLocation); + gl::UniformLocation getDefaultUniformBaseLocation(gl::ShaderProgramID programID, + gl::UniformLocation location) + { + ASSERT(mDefaultUniformBaseLocations.find({programID, location}) != + mDefaultUniformBaseLocations.end()); + return mDefaultUniformBaseLocations[{programID, location}]; + } + + TrackedResource &getTrackedResource(gl::ContextID contextID, ResourceIDType type); + + void getContextIDs(std::set<gl::ContextID> &idsOut); + + std::map<void *, egl::AttributeMap> &getImageToAttribTable() { return mMatchImageToAttribs; } + + std::map<GLuint, void *> &getTextureIDToImageTable() { return mMatchTextureIDToImage; } + + private: + // Buffer map calls will map a buffer with correct offset, length, and access flags + BufferCalls mBufferMapCalls; + // Buffer unmap calls will bind and unmap a given buffer + BufferCalls mBufferUnmapCalls; + + // Buffer binding calls to restore bindings recorded during MEC + std::vector<CallCapture> mBufferBindingCalls; + + // Whether a given buffer was mapped at the start of the trace + BufferMapStatusMap mStartingBuffersMappedInitial; + // The status of buffer mapping throughout the trace, modified with each Map/Unmap call + BufferMapStatusMap mStartingBuffersMappedCurrent; + + // Maximum accessed shader program ID. + uint32_t mMaxShaderPrograms = 0; + + // Fence sync objects created during MEC setup + FenceSyncSet mStartingFenceSyncs; + // Fence sync regen calls will create a fence sync objects + FenceSyncCalls mFenceSyncRegenCalls; + // Fence syncs to regen are a list of starting fence sync objects that were deleted and need to + // be regen'ed. + FenceSyncSet mFenceSyncsToRegen; + + // Default uniforms that were modified during the run + DefaultUniformLocationsPerProgramMap mDefaultUniformsToReset; + // Calls per default uniform to return to original state + DefaultUniformCallsPerProgramMap mDefaultUniformResetCalls; + + // Base location of arrayed uniforms + DefaultUniformBaseLocationMap mDefaultUniformBaseLocations; + + // Tracked resources per context + TrackedResourceArray mTrackedResourcesShared; + std::map<gl::ContextID, TrackedResourceArray> mTrackedResourcesPerContext; + + std::map<void *, egl::AttributeMap> mMatchImageToAttribs; + std::map<GLuint, void *> mMatchTextureIDToImage; +}; + +// Used by the CPP replay to filter out unnecessary code. +using HasResourceTypeMap = angle::PackedEnumBitSet<ResourceIDType>; + +// Map of ResourceType to IDs and range of setup calls +using ResourceIDToSetupCallsMap = + PackedEnumMap<ResourceIDType, std::map<GLuint, gl::Range<size_t>>>; + +// Map of buffer ID to offset and size used when mapped +using BufferDataMap = std::map<gl::BufferID, std::pair<GLintptr, GLsizeiptr>>; + +// A dictionary of sources indexed by shader type. +using ProgramSources = gl::ShaderMap<std::string>; + +// Maps from IDs to sources. +using ShaderSourceMap = std::map<gl::ShaderProgramID, std::string>; +using ProgramSourceMap = std::map<gl::ShaderProgramID, ProgramSources>; + +// Map from textureID to level and data +using TextureLevels = std::map<GLint, std::vector<uint8_t>>; +using TextureLevelDataMap = std::map<gl::TextureID, TextureLevels>; + +struct SurfaceParams +{ + gl::Extents extents; + egl::ColorSpace colorSpace; +}; + +// Map from ContextID to SurfaceParams +using SurfaceParamsMap = std::map<gl::ContextID, SurfaceParams>; + +using CallVector = std::vector<std::vector<CallCapture> *>; + +// A map from API entry point to calls +using CallResetMap = std::map<angle::EntryPoint, std::vector<CallCapture>>; + +// StateResetHelper provides a simple way to track whether an entry point has been called during the +// trace, along with the reset calls to get it back to starting state. This is useful for things +// that are one dimensional, like context bindings or context state. +class StateResetHelper final : angle::NonCopyable +{ + public: + StateResetHelper(); + ~StateResetHelper(); + + const std::set<angle::EntryPoint> &getDirtyEntryPoints() const { return mDirtyEntryPoints; } + void setEntryPointDirty(EntryPoint entryPoint) { mDirtyEntryPoints.insert(entryPoint); } + + CallResetMap &getResetCalls() { return mResetCalls; } + const CallResetMap &getResetCalls() const { return mResetCalls; } + + void setDefaultResetCalls(const gl::Context *context, angle::EntryPoint); + + private: + // Dirty state per entry point + std::set<angle::EntryPoint> mDirtyEntryPoints; + + // Reset calls per API entry point + CallResetMap mResetCalls; +}; + +class FrameCapture final : angle::NonCopyable +{ + public: + FrameCapture(); + ~FrameCapture(); + + std::vector<CallCapture> &getSetupCalls() { return mSetupCalls; } + void clearSetupCalls() { mSetupCalls.clear(); } + + StateResetHelper &getStateResetHelper() { return mStateResetHelper; } + + void reset(); + + private: + std::vector<CallCapture> mSetupCalls; + + StateResetHelper mStateResetHelper; +}; + +// Page range inside a coherent buffer +struct PageRange +{ + PageRange(size_t start, size_t end); + ~PageRange(); + + // Relative start page + size_t start; + + // First page after the relative end + size_t end; +}; + +// Memory address range defined by start and size +struct AddressRange +{ + AddressRange(); + AddressRange(uintptr_t start, size_t size); + ~AddressRange(); + + uintptr_t end(); + + uintptr_t start; + size_t size; +}; + +// Used to handle protection of buffers that overlap in pages. +enum class PageSharingType +{ + NoneShared, + FirstShared, + LastShared, + FirstAndLastShared +}; + +class CoherentBuffer +{ + public: + CoherentBuffer(uintptr_t start, size_t size, size_t pageSize); + ~CoherentBuffer(); + + // Sets the a range in the buffer clean and protects a selected range + void protectPageRange(const PageRange &pageRange); + + // Sets a page dirty state and sets it's protection + void setDirty(size_t relativePage, bool dirty); + + // Removes protection + void removeProtection(PageSharingType sharingType); + + bool contains(size_t page, size_t *relativePage); + bool isDirty(); + + // Returns dirty page ranges + std::vector<PageRange> getDirtyPageRanges(); + + // Calculates address range from page range + AddressRange getDirtyAddressRange(const PageRange &dirtyPageRange); + AddressRange getRange(); + + private: + // Actual buffer start and size + AddressRange mRange; + + // Start and size of page aligned protected area + AddressRange mProtectionRange; + + // Start and end of protection in relative pages, calculated from mProtectionRange. + size_t mProtectionStartPage; + size_t mProtectionEndPage; + + size_t mPageCount; + size_t mPageSize; + + // Clean pages are protected + std::vector<bool> mDirtyPages; +}; + +class CoherentBufferTracker final : angle::NonCopyable +{ + public: + CoherentBufferTracker(); + ~CoherentBufferTracker(); + + bool isDirty(gl::BufferID id); + void addBuffer(gl::BufferID id, uintptr_t start, size_t size); + void removeBuffer(gl::BufferID id); + void disable(); + void enable(); + void onEndFrame(); + + private: + // Detect overlapping pages when removing protection + PageSharingType doesBufferSharePage(gl::BufferID id); + + // Returns a map to found buffers and the corresponding pages for a given address. + // For addresses that are in a page shared by 2 buffers, 2 results are returned. + HashMap<std::shared_ptr<CoherentBuffer>, size_t> getBufferPagesForAddress(uintptr_t address); + PageFaultHandlerRangeType handleWrite(uintptr_t address); + bool haveBuffer(gl::BufferID id); + + public: + std::mutex mMutex; + HashMap<GLuint, std::shared_ptr<CoherentBuffer>> mBuffers; + + private: + bool mEnabled = false; + std::unique_ptr<PageFaultHandler> mPageFaultHandler; + size_t mPageSize; +}; + +// Shared class for any items that need to be tracked by FrameCapture across shared contexts +class FrameCaptureShared final : angle::NonCopyable +{ + public: + FrameCaptureShared(); + ~FrameCaptureShared(); + + void captureCall(const gl::Context *context, CallCapture &&call, bool isCallValid); + void checkForCaptureTrigger(); + void onEndFrame(const gl::Context *context); + void onDestroyContext(const gl::Context *context); + void onMakeCurrent(const gl::Context *context, const egl::Surface *drawSurface); + bool enabled() const { return mEnabled; } + + bool isCapturing() const; + void replay(gl::Context *context); + uint32_t getFrameCount() const; + + // Returns a frame index starting from "1" as the first frame. + uint32_t getReplayFrameIndex() const; + + void trackBufferMapping(const gl::Context *context, + CallCapture *call, + gl::BufferID id, + gl::Buffer *buffer, + GLintptr offset, + GLsizeiptr length, + bool writable, + bool coherent); + + void trackTextureUpdate(const gl::Context *context, const CallCapture &call); + void trackDefaultUniformUpdate(const gl::Context *context, const CallCapture &call); + void trackVertexArrayUpdate(const gl::Context *context, const CallCapture &call); + + const std::string &getShaderSource(gl::ShaderProgramID id) const; + void setShaderSource(gl::ShaderProgramID id, std::string sources); + + const ProgramSources &getProgramSources(gl::ShaderProgramID id) const; + void setProgramSources(gl::ShaderProgramID id, ProgramSources sources); + + // Load data from a previously stored texture level + const std::vector<uint8_t> &retrieveCachedTextureLevel(gl::TextureID id, + gl::TextureTarget target, + GLint level); + + // Create new texture level data and copy the source into it + void copyCachedTextureLevel(const gl::Context *context, + gl::TextureID srcID, + GLint srcLevel, + gl::TextureID dstID, + GLint dstLevel, + const CallCapture &call); + + // Create the location that should be used to cache texture level data + std::vector<uint8_t> &getCachedTextureLevelData(gl::Texture *texture, + gl::TextureTarget target, + GLint level, + EntryPoint entryPoint); + + // Capture coherent buffer storages + void captureCoherentBufferSnapshot(const gl::Context *context, gl::BufferID bufferID); + + // Remove any cached texture levels on deletion + void deleteCachedTextureLevelData(gl::TextureID id); + + void eraseBufferDataMapEntry(const gl::BufferID bufferId) + { + const auto &bufferDataInfo = mBufferDataMap.find(bufferId); + if (bufferDataInfo != mBufferDataMap.end()) + { + mBufferDataMap.erase(bufferDataInfo); + } + } + + bool hasBufferData(gl::BufferID bufferID) + { + const auto &bufferDataInfo = mBufferDataMap.find(bufferID); + if (bufferDataInfo != mBufferDataMap.end()) + { + return true; + } + return false; + } + + std::pair<GLintptr, GLsizeiptr> getBufferDataOffsetAndLength(gl::BufferID bufferID) + { + const auto &bufferDataInfo = mBufferDataMap.find(bufferID); + ASSERT(bufferDataInfo != mBufferDataMap.end()); + return bufferDataInfo->second; + } + + void setCaptureActive() { mCaptureActive = true; } + void setCaptureInactive() { mCaptureActive = false; } + bool isCaptureActive() { return mCaptureActive; } + bool usesMidExecutionCapture() { return mCaptureStartFrame > 1; } + + gl::ContextID getWindowSurfaceContextID() const { return mWindowSurfaceContextID; } + + void markResourceSetupCallsInactive(std::vector<CallCapture> *setupCalls, + ResourceIDType type, + GLuint id, + gl::Range<size_t> range); + + void updateReadBufferSize(size_t readBufferSize) + { + mReadBufferSize = std::max(mReadBufferSize, readBufferSize); + } + + template <typename ResourceType> + void handleGennedResource(const gl::Context *context, ResourceType resourceID) + { + if (isCaptureActive()) + { + ResourceIDType idType = GetResourceIDTypeFromType<ResourceType>::IDType; + TrackedResource &tracker = mResourceTracker.getTrackedResource(context->id(), idType); + tracker.setGennedResource(resourceID.value); + } + } + + template <typename ResourceType> + bool resourceIsGenerated(const gl::Context *context, ResourceType resourceID) + { + ResourceIDType idType = GetResourceIDTypeFromType<ResourceType>::IDType; + TrackedResource &tracker = mResourceTracker.getTrackedResource(context->id(), idType); + return tracker.resourceIsGenerated(resourceID.value); + } + + template <typename ResourceType> + void handleDeletedResource(const gl::Context *context, ResourceType resourceID) + { + if (isCaptureActive()) + { + ResourceIDType idType = GetResourceIDTypeFromType<ResourceType>::IDType; + TrackedResource &tracker = mResourceTracker.getTrackedResource(context->id(), idType); + tracker.setDeletedResource(resourceID.value); + } + } + + private: + void writeJSON(const gl::Context *context); + void writeCppReplayIndexFiles(const gl::Context *context, bool writeResetContextCall); + void writeMainContextCppReplay(const gl::Context *context, + const std::vector<CallCapture> &setupCalls, + StateResetHelper &StateResetHelper); + + void captureClientArraySnapshot(const gl::Context *context, + size_t vertexCount, + size_t instanceCount); + void captureMappedBufferSnapshot(const gl::Context *context, const CallCapture &call); + + void copyCompressedTextureData(const gl::Context *context, const CallCapture &call); + void captureCompressedTextureData(const gl::Context *context, const CallCapture &call); + + void reset(); + void maybeOverrideEntryPoint(const gl::Context *context, + CallCapture &call, + std::vector<CallCapture> &newCalls); + void maybeCapturePreCallUpdates(const gl::Context *context, + CallCapture &call, + std::vector<CallCapture> *shareGroupSetupCalls, + ResourceIDToSetupCallsMap *resourceIDToSetupCalls); + template <typename ParamValueType> + void maybeGenResourceOnBind(const gl::Context *context, CallCapture &call); + void maybeCapturePostCallUpdates(const gl::Context *context); + void maybeCaptureDrawArraysClientData(const gl::Context *context, + CallCapture &call, + size_t instanceCount); + void maybeCaptureDrawElementsClientData(const gl::Context *context, + CallCapture &call, + size_t instanceCount); + void maybeCaptureCoherentBuffers(const gl::Context *context); + void updateCopyImageSubData(CallCapture &call); + void overrideProgramBinary(const gl::Context *context, + CallCapture &call, + std::vector<CallCapture> &outCalls); + void updateResourceCountsFromParamCapture(const ParamCapture ¶m, ResourceIDType idType); + void updateResourceCountsFromCallCapture(const CallCapture &call); + + void runMidExecutionCapture(const gl::Context *context); + + void scanSetupCalls(const gl::Context *context, std::vector<CallCapture> &setupCalls); + + static void ReplayCall(gl::Context *context, + ReplayContext *replayContext, + const CallCapture &call); + + std::vector<CallCapture> mFrameCalls; + gl::ContextID mLastContextId; + + // We save one large buffer of binary data for the whole CPP replay. + // This simplifies a lot of file management. + std::vector<uint8_t> mBinaryData; + + bool mEnabled; + bool mSerializeStateEnabled; + std::string mOutDirectory; + std::string mCaptureLabel; + bool mCompression; + gl::AttribArray<int> mClientVertexArrayMap; + uint32_t mFrameIndex; + uint32_t mCaptureStartFrame; + uint32_t mCaptureEndFrame; + bool mIsFirstFrame = true; + bool mWroteIndexFile = false; + SurfaceParamsMap mDrawSurfaceParams; + gl::AttribArray<size_t> mClientArraySizes; + size_t mReadBufferSize; + HasResourceTypeMap mHasResourceType; + ResourceIDToSetupCallsMap mResourceIDToSetupCalls; + BufferDataMap mBufferDataMap; + bool mValidateSerializedState = false; + std::string mValidationExpression; + bool mTrimEnabled = true; + PackedEnumMap<ResourceIDType, uint32_t> mMaxAccessedResourceIDs; + CoherentBufferTracker mCoherentBufferTracker; + + ResourceTracker mResourceTracker; + ReplayWriter mReplayWriter; + + // If you don't know which frame you want to start capturing at, use the capture trigger. + // Initialize it to the number of frames you want to capture, and then clear the value to 0 when + // you reach the content you want to capture. Currently only available on Android. + uint32_t mCaptureTrigger; + + bool mCaptureActive; + std::vector<uint32_t> mActiveFrameIndices; + + // Cache most recently compiled and linked sources. + ShaderSourceMap mCachedShaderSource; + ProgramSourceMap mCachedProgramSources; + + gl::ContextID mWindowSurfaceContextID; + + std::vector<CallCapture> mShareGroupSetupCalls; +}; + +template <typename CaptureFuncT, typename... ArgsT> +void CaptureCallToFrameCapture(CaptureFuncT captureFunc, + bool isCallValid, + gl::Context *context, + ArgsT... captureParams) +{ + FrameCaptureShared *frameCaptureShared = context->getShareGroup()->getFrameCaptureShared(); + if (!frameCaptureShared->isCapturing()) + { + return; + } + + CallCapture call = captureFunc(context->getState(), isCallValid, captureParams...); + + frameCaptureShared->captureCall(context, std::move(call), isCallValid); +} + +template <typename T> +void ParamBuffer::addValueParam(const char *paramName, ParamType paramType, T paramValue) +{ + ParamCapture capture(paramName, paramType); + InitParamValue(paramType, paramValue, &capture.value); + mParamCaptures.emplace_back(std::move(capture)); +} + +template <typename T> +void ParamBuffer::setValueParamAtIndex(const char *paramName, + ParamType paramType, + T paramValue, + int index) +{ + ASSERT(mParamCaptures.size() > static_cast<size_t>(index)); + + ParamCapture capture(paramName, paramType); + InitParamValue(paramType, paramValue, &capture.value); + mParamCaptures[index] = std::move(capture); +} + +template <typename T> +void ParamBuffer::addEnumParam(const char *paramName, + gl::GLESEnum enumGroup, + ParamType paramType, + T paramValue) +{ + ParamCapture capture(paramName, paramType); + InitParamValue(paramType, paramValue, &capture.value); + capture.enumGroup = enumGroup; + mParamCaptures.emplace_back(std::move(capture)); +} + +template <typename T> +void ParamBuffer::addEnumParam(const char *paramName, + gl::BigGLEnum enumGroup, + ParamType paramType, + T paramValue) +{ + ParamCapture capture(paramName, paramType); + InitParamValue(paramType, paramValue, &capture.value); + capture.bigGLEnum = enumGroup; + mParamCaptures.emplace_back(std::move(capture)); +} + +// Pointer capture helpers. +void CaptureMemory(const void *source, size_t size, ParamCapture *paramCapture); +void CaptureString(const GLchar *str, ParamCapture *paramCapture); +void CaptureStringLimit(const GLchar *str, uint32_t limit, ParamCapture *paramCapture); +void CaptureVertexPointerGLES1(const gl::State &glState, + gl::ClientVertexArrayType type, + const void *pointer, + ParamCapture *paramCapture); + +gl::Program *GetProgramForCapture(const gl::State &glState, gl::ShaderProgramID handle); + +// For GetIntegerv, GetFloatv, etc. +void CaptureGetParameter(const gl::State &glState, + GLenum pname, + size_t typeSize, + ParamCapture *paramCapture); + +void CaptureGetActiveUniformBlockivParameters(const gl::State &glState, + gl::ShaderProgramID handle, + gl::UniformBlockIndex uniformBlockIndex, + GLenum pname, + ParamCapture *paramCapture); + +template <typename T> +void CaptureClearBufferValue(GLenum buffer, const T *value, ParamCapture *paramCapture) +{ + // Per the spec, color buffers have a vec4, the rest a single value + uint32_t valueSize = (buffer == GL_COLOR) ? 4 : 1; + CaptureMemory(value, valueSize * sizeof(T), paramCapture); +} + +void CaptureGenHandlesImpl(GLsizei n, GLuint *handles, ParamCapture *paramCapture); + +template <typename T> +void CaptureGenHandles(GLsizei n, T *handles, ParamCapture *paramCapture) +{ + paramCapture->dataNElements = n; + CaptureGenHandlesImpl(n, reinterpret_cast<GLuint *>(handles), paramCapture); +} + +template <typename T> +void CaptureArray(T *elements, GLsizei n, ParamCapture *paramCapture) +{ + paramCapture->dataNElements = n; + CaptureMemory(elements, n * sizeof(T), paramCapture); +} + +void CaptureShaderStrings(GLsizei count, + const GLchar *const *strings, + const GLint *length, + ParamCapture *paramCapture); + +template <ParamType ParamT, typename T> +void WriteParamValueReplay(std::ostream &os, const CallCapture &call, T value); + +template <> +void WriteParamValueReplay<ParamType::TGLboolean>(std::ostream &os, + const CallCapture &call, + GLboolean value); + +template <> +void WriteParamValueReplay<ParamType::TGLbooleanPointer>(std::ostream &os, + const CallCapture &call, + GLboolean *value); + +template <> +void WriteParamValueReplay<ParamType::TvoidConstPointer>(std::ostream &os, + const CallCapture &call, + const void *value); + +template <> +void WriteParamValueReplay<ParamType::TvoidPointer>(std::ostream &os, + const CallCapture &call, + void *value); + +template <> +void WriteParamValueReplay<ParamType::TGLfloatConstPointer>(std::ostream &os, + const CallCapture &call, + const GLfloat *value); + +template <> +void WriteParamValueReplay<ParamType::TGLintConstPointer>(std::ostream &os, + const CallCapture &call, + const GLint *value); + +template <> +void WriteParamValueReplay<ParamType::TGLsizeiPointer>(std::ostream &os, + const CallCapture &call, + GLsizei *value); + +template <> +void WriteParamValueReplay<ParamType::TGLuintConstPointer>(std::ostream &os, + const CallCapture &call, + const GLuint *value); + +template <> +void WriteParamValueReplay<ParamType::TGLDEBUGPROCKHR>(std::ostream &os, + const CallCapture &call, + GLDEBUGPROCKHR value); + +template <> +void WriteParamValueReplay<ParamType::TGLDEBUGPROC>(std::ostream &os, + const CallCapture &call, + GLDEBUGPROC value); + +template <> +void WriteParamValueReplay<ParamType::TBufferID>(std::ostream &os, + const CallCapture &call, + gl::BufferID value); + +template <> +void WriteParamValueReplay<ParamType::TFenceNVID>(std::ostream &os, + const CallCapture &call, + gl::FenceNVID value); + +template <> +void WriteParamValueReplay<ParamType::TFramebufferID>(std::ostream &os, + const CallCapture &call, + gl::FramebufferID value); + +template <> +void WriteParamValueReplay<ParamType::TMemoryObjectID>(std::ostream &os, + const CallCapture &call, + gl::MemoryObjectID value); + +template <> +void WriteParamValueReplay<ParamType::TProgramPipelineID>(std::ostream &os, + const CallCapture &call, + gl::ProgramPipelineID value); + +template <> +void WriteParamValueReplay<ParamType::TQueryID>(std::ostream &os, + const CallCapture &call, + gl::QueryID value); + +template <> +void WriteParamValueReplay<ParamType::TRenderbufferID>(std::ostream &os, + const CallCapture &call, + gl::RenderbufferID value); + +template <> +void WriteParamValueReplay<ParamType::TSamplerID>(std::ostream &os, + const CallCapture &call, + gl::SamplerID value); + +template <> +void WriteParamValueReplay<ParamType::TSemaphoreID>(std::ostream &os, + const CallCapture &call, + gl::SemaphoreID value); + +template <> +void WriteParamValueReplay<ParamType::TShaderProgramID>(std::ostream &os, + const CallCapture &call, + gl::ShaderProgramID value); + +template <> +void WriteParamValueReplay<ParamType::TTextureID>(std::ostream &os, + const CallCapture &call, + gl::TextureID value); + +template <> +void WriteParamValueReplay<ParamType::TTransformFeedbackID>(std::ostream &os, + const CallCapture &call, + gl::TransformFeedbackID value); + +template <> +void WriteParamValueReplay<ParamType::TVertexArrayID>(std::ostream &os, + const CallCapture &call, + gl::VertexArrayID value); + +template <> +void WriteParamValueReplay<ParamType::TUniformLocation>(std::ostream &os, + const CallCapture &call, + gl::UniformLocation value); + +template <> +void WriteParamValueReplay<ParamType::TUniformBlockIndex>(std::ostream &os, + const CallCapture &call, + gl::UniformBlockIndex value); + +template <> +void WriteParamValueReplay<ParamType::TGLsync>(std::ostream &os, + const CallCapture &call, + GLsync value); + +template <> +void WriteParamValueReplay<ParamType::TGLeglImageOES>(std::ostream &os, + const CallCapture &call, + GLeglImageOES value); + +template <> +void WriteParamValueReplay<ParamType::TGLubyte>(std::ostream &os, + const CallCapture &call, + GLubyte value); + +template <> +void WriteParamValueReplay<ParamType::TEGLContext>(std::ostream &os, + const CallCapture &call, + EGLContext value); + +template <> +void WriteParamValueReplay<ParamType::TEGLDisplay>(std::ostream &os, + const CallCapture &call, + EGLContext value); + +template <> +void WriteParamValueReplay<ParamType::TEGLSurface>(std::ostream &os, + const CallCapture &call, + EGLContext value); + +template <> +void WriteParamValueReplay<ParamType::TEGLDEBUGPROCKHR>(std::ostream &os, + const CallCapture &call, + EGLDEBUGPROCKHR value); + +template <> +void WriteParamValueReplay<ParamType::TEGLGetBlobFuncANDROID>(std::ostream &os, + const CallCapture &call, + EGLGetBlobFuncANDROID value); + +template <> +void WriteParamValueReplay<ParamType::TEGLSetBlobFuncANDROID>(std::ostream &os, + const CallCapture &call, + EGLSetBlobFuncANDROID value); +template <> +void WriteParamValueReplay<ParamType::TEGLClientBuffer>(std::ostream &os, + const CallCapture &call, + EGLClientBuffer value); + +template <> +void WriteParamValueReplay<ParamType::TEGLConfig>(std::ostream &os, + const CallCapture &call, + EGLConfig value); + +template <> +void WriteParamValueReplay<ParamType::TEGLSurface>(std::ostream &os, + const CallCapture &call, + EGLSurface value); + +// General fallback for any unspecific type. +template <ParamType ParamT, typename T> +void WriteParamValueReplay(std::ostream &os, const CallCapture &call, T value) +{ + os << value; +} +} // namespace angle + +template <typename T> +void CaptureTextureAndSamplerParameter_params(GLenum pname, + const T *param, + angle::ParamCapture *paramCapture) +{ + if (pname == GL_TEXTURE_BORDER_COLOR || pname == GL_TEXTURE_CROP_RECT_OES) + { + CaptureMemory(param, sizeof(T) * 4, paramCapture); + } + else + { + CaptureMemory(param, sizeof(T), paramCapture); + } +} + +#endif // LIBANGLE_FRAME_CAPTURE_H_ diff --git a/gfx/angle/checkout/src/libANGLE/capture/FrameCapture_mock.cpp b/gfx/angle/checkout/src/libANGLE/capture/FrameCapture_mock.cpp new file mode 100644 index 0000000000..dc9e44c5bb --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/FrameCapture_mock.cpp @@ -0,0 +1,55 @@ +// +// Copyright 2019 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. +// +// FrameCapture_mock.cpp: +// ANGLE mock Frame capture implementation. +// + +#include "libANGLE/capture/FrameCapture.h" + +#if ANGLE_CAPTURE_ENABLED +# error Frame capture must be disabled to include this file. +#endif // ANGLE_CAPTURE_ENABLED + +namespace angle +{ +CallCapture::~CallCapture() {} +ParamBuffer::~ParamBuffer() {} +ParamCapture::~ParamCapture() {} +ResourceTracker::ResourceTracker() {} +ResourceTracker::~ResourceTracker() {} +TrackedResource::TrackedResource() {} +TrackedResource::~TrackedResource() {} +StateResetHelper::StateResetHelper() {} +StateResetHelper::~StateResetHelper() {} +DataTracker::DataTracker() {} +DataTracker::~DataTracker() {} +DataCounters::DataCounters() {} +DataCounters::~DataCounters() {} +StringCounters::StringCounters() {} +StringCounters::~StringCounters() {} +ReplayWriter::ReplayWriter() {} +ReplayWriter::~ReplayWriter() {} + +FrameCapture::FrameCapture() {} +FrameCapture::~FrameCapture() {} + +FrameCaptureShared::FrameCaptureShared() : mEnabled(false) {} +FrameCaptureShared::~FrameCaptureShared() {} +void FrameCaptureShared::onEndFrame(const gl::Context *context) {} +void FrameCaptureShared::onMakeCurrent(const gl::Context *context, const egl::Surface *drawSurface) +{} +void FrameCaptureShared::onDestroyContext(const gl::Context *context) {} +void FrameCaptureShared::replay(gl::Context *context) {} +const ProgramSources &FrameCaptureShared::getProgramSources(gl::ShaderProgramID id) const +{ + const auto &foundSources = mCachedProgramSources.find(id); + return foundSources->second; +} +void FrameCaptureShared::setProgramSources(gl::ShaderProgramID id, ProgramSources sources) {} + +CoherentBufferTracker::CoherentBufferTracker() {} +CoherentBufferTracker::~CoherentBufferTracker() {} +} // namespace angle diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_egl.h b/gfx/angle/checkout/src/libANGLE/capture/capture_egl.h new file mode 100644 index 0000000000..f23bc1a2ce --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/capture_egl.h @@ -0,0 +1,69 @@ +// +// Copyright 2022 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. +// +// capture_egl.h: +// EGL capture functions +// + +#ifndef LIBANGLE_CAPTURE_EGL_H_ +#define LIBANGLE_CAPTURE_EGL_H_ + +#include "libANGLE/Context.h" +#include "libANGLE/Thread.h" +#include "libANGLE/capture/FrameCapture.h" + +namespace gl +{ +enum class GLenumGroup; +} + +namespace egl +{ + +template <typename CaptureFuncT, typename... ArgsT> +void CaptureCallToCaptureEGL(CaptureFuncT captureFunc, egl::Thread *thread, ArgsT... captureParams) +{ + gl::Context *context = thread->getContext(); + if (!context) + { + return; + } + + angle::FrameCaptureShared *frameCaptureShared = + context->getShareGroup()->getFrameCaptureShared(); + if (!frameCaptureShared->isCapturing()) + { + return; + } + + angle::CallCapture call = captureFunc(captureParams...); + + frameCaptureShared->captureCall(context, std::move(call), true); +} + +angle::CallCapture CaptureCreateNativeClientBufferANDROID(const egl::AttributeMap &attribMap, + EGLClientBuffer eglClientBuffer); +angle::CallCapture CaptureEGLCreateImage(const gl::Context *context, + EGLenum target, + EGLClientBuffer buffer, + const egl::AttributeMap &attributes, + egl::Image *image); +angle::CallCapture CaptureEGLDestroyImage(egl::Display *display, egl::Image *image); + +angle::CallCapture CaptureEGLCreatePbufferSurface(const AttributeMap &attrib_list, + egl::Surface *surface); + +angle::CallCapture CaptureEGLDestroySurface(Display *display, Surface *surface); + +angle::CallCapture CaptureEGLBindTexImage(egl::Surface *surface, EGLint buffer); + +angle::CallCapture CaptureEGLReleaseTexImage(egl::Surface *surface, EGLint buffer); + +angle::CallCapture CaptureEGLMakeCurrent(Surface *drawSurface, + Surface *readSurface, + gl::Context *context); +} // namespace egl + +#endif // LIBANGLE_FRAME_CAPTURE_H_ diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gl_1_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gl_1_autogen.h new file mode 100644 index 0000000000..7e4eea7af1 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gl_1_autogen.h @@ -0,0 +1,2072 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml. +// +// 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. +// +// capture_gl_1_autogen.h: +// Capture functions for the OpenGL ES Desktop GL 1.x entry points. + +#ifndef LIBANGLE_CAPTURE_GL_1_AUTOGEN_H_ +#define LIBANGLE_CAPTURE_GL_1_AUTOGEN_H_ + +#include "common/PackedEnums.h" +#include "libANGLE/capture/FrameCapture.h" + +namespace gl +{ + +// Method Captures + +// GL 1.0 +angle::CallCapture CaptureAccum(const State &glState, bool isCallValid, GLenum op, GLfloat value); +angle::CallCapture CaptureBegin(const State &glState, bool isCallValid, GLenum mode); +angle::CallCapture CaptureBitmap(const State &glState, + bool isCallValid, + GLsizei width, + GLsizei height, + GLfloat xorig, + GLfloat yorig, + GLfloat xmove, + GLfloat ymove, + const GLubyte *bitmap); +angle::CallCapture CaptureCallList(const State &glState, bool isCallValid, GLuint list); +angle::CallCapture CaptureCallLists(const State &glState, + bool isCallValid, + GLsizei n, + GLenum type, + const void *lists); +angle::CallCapture CaptureClearAccum(const State &glState, + bool isCallValid, + GLfloat red, + GLfloat green, + GLfloat blue, + GLfloat alpha); +angle::CallCapture CaptureClearDepth(const State &glState, bool isCallValid, GLdouble depth); +angle::CallCapture CaptureClearIndex(const State &glState, bool isCallValid, GLfloat c); +angle::CallCapture CaptureClipPlane(const State &glState, + bool isCallValid, + GLenum plane, + const GLdouble *equation); +angle::CallCapture CaptureColor3b(const State &glState, + bool isCallValid, + GLbyte red, + GLbyte green, + GLbyte blue); +angle::CallCapture CaptureColor3bv(const State &glState, bool isCallValid, const GLbyte *v); +angle::CallCapture CaptureColor3d(const State &glState, + bool isCallValid, + GLdouble red, + GLdouble green, + GLdouble blue); +angle::CallCapture CaptureColor3dv(const State &glState, bool isCallValid, const GLdouble *v); +angle::CallCapture CaptureColor3f(const State &glState, + bool isCallValid, + GLfloat red, + GLfloat green, + GLfloat blue); +angle::CallCapture CaptureColor3fv(const State &glState, bool isCallValid, const GLfloat *v); +angle::CallCapture CaptureColor3i(const State &glState, + bool isCallValid, + GLint red, + GLint green, + GLint blue); +angle::CallCapture CaptureColor3iv(const State &glState, bool isCallValid, const GLint *v); +angle::CallCapture CaptureColor3s(const State &glState, + bool isCallValid, + GLshort red, + GLshort green, + GLshort blue); +angle::CallCapture CaptureColor3sv(const State &glState, bool isCallValid, const GLshort *v); +angle::CallCapture CaptureColor3ub(const State &glState, + bool isCallValid, + GLubyte red, + GLubyte green, + GLubyte blue); +angle::CallCapture CaptureColor3ubv(const State &glState, bool isCallValid, const GLubyte *v); +angle::CallCapture CaptureColor3ui(const State &glState, + bool isCallValid, + GLuint red, + GLuint green, + GLuint blue); +angle::CallCapture CaptureColor3uiv(const State &glState, bool isCallValid, const GLuint *v); +angle::CallCapture CaptureColor3us(const State &glState, + bool isCallValid, + GLushort red, + GLushort green, + GLushort blue); +angle::CallCapture CaptureColor3usv(const State &glState, bool isCallValid, const GLushort *v); +angle::CallCapture CaptureColor4b(const State &glState, + bool isCallValid, + GLbyte red, + GLbyte green, + GLbyte blue, + GLbyte alpha); +angle::CallCapture CaptureColor4bv(const State &glState, bool isCallValid, const GLbyte *v); +angle::CallCapture CaptureColor4d(const State &glState, + bool isCallValid, + GLdouble red, + GLdouble green, + GLdouble blue, + GLdouble alpha); +angle::CallCapture CaptureColor4dv(const State &glState, bool isCallValid, const GLdouble *v); +angle::CallCapture CaptureColor4fv(const State &glState, bool isCallValid, const GLfloat *v); +angle::CallCapture CaptureColor4i(const State &glState, + bool isCallValid, + GLint red, + GLint green, + GLint blue, + GLint alpha); +angle::CallCapture CaptureColor4iv(const State &glState, bool isCallValid, const GLint *v); +angle::CallCapture CaptureColor4s(const State &glState, + bool isCallValid, + GLshort red, + GLshort green, + GLshort blue, + GLshort alpha); +angle::CallCapture CaptureColor4sv(const State &glState, bool isCallValid, const GLshort *v); +angle::CallCapture CaptureColor4ubv(const State &glState, bool isCallValid, const GLubyte *v); +angle::CallCapture CaptureColor4ui(const State &glState, + bool isCallValid, + GLuint red, + GLuint green, + GLuint blue, + GLuint alpha); +angle::CallCapture CaptureColor4uiv(const State &glState, bool isCallValid, const GLuint *v); +angle::CallCapture CaptureColor4us(const State &glState, + bool isCallValid, + GLushort red, + GLushort green, + GLushort blue, + GLushort alpha); +angle::CallCapture CaptureColor4usv(const State &glState, bool isCallValid, const GLushort *v); +angle::CallCapture CaptureColorMaterial(const State &glState, + bool isCallValid, + GLenum face, + GLenum mode); +angle::CallCapture CaptureCopyPixels(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum type); +angle::CallCapture CaptureDeleteLists(const State &glState, + bool isCallValid, + GLuint list, + GLsizei range); +angle::CallCapture CaptureDepthRange(const State &glState, + bool isCallValid, + GLdouble n, + GLdouble f); +angle::CallCapture CaptureDrawBuffer(const State &glState, bool isCallValid, GLenum buf); +angle::CallCapture CaptureDrawPixels(const State &glState, + bool isCallValid, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + const void *pixels); +angle::CallCapture CaptureEdgeFlag(const State &glState, bool isCallValid, GLboolean flag); +angle::CallCapture CaptureEdgeFlagv(const State &glState, bool isCallValid, const GLboolean *flag); +angle::CallCapture CaptureEnd(const State &glState, bool isCallValid); +angle::CallCapture CaptureEndList(const State &glState, bool isCallValid); +angle::CallCapture CaptureEvalCoord1d(const State &glState, bool isCallValid, GLdouble u); +angle::CallCapture CaptureEvalCoord1dv(const State &glState, bool isCallValid, const GLdouble *u); +angle::CallCapture CaptureEvalCoord1f(const State &glState, bool isCallValid, GLfloat u); +angle::CallCapture CaptureEvalCoord1fv(const State &glState, bool isCallValid, const GLfloat *u); +angle::CallCapture CaptureEvalCoord2d(const State &glState, + bool isCallValid, + GLdouble u, + GLdouble v); +angle::CallCapture CaptureEvalCoord2dv(const State &glState, bool isCallValid, const GLdouble *u); +angle::CallCapture CaptureEvalCoord2f(const State &glState, bool isCallValid, GLfloat u, GLfloat v); +angle::CallCapture CaptureEvalCoord2fv(const State &glState, bool isCallValid, const GLfloat *u); +angle::CallCapture CaptureEvalMesh1(const State &glState, + bool isCallValid, + GLenum mode, + GLint i1, + GLint i2); +angle::CallCapture CaptureEvalMesh2(const State &glState, + bool isCallValid, + GLenum mode, + GLint i1, + GLint i2, + GLint j1, + GLint j2); +angle::CallCapture CaptureEvalPoint1(const State &glState, bool isCallValid, GLint i); +angle::CallCapture CaptureEvalPoint2(const State &glState, bool isCallValid, GLint i, GLint j); +angle::CallCapture CaptureFeedbackBuffer(const State &glState, + bool isCallValid, + GLsizei size, + GLenum type, + GLfloat *buffer); +angle::CallCapture CaptureFogi(const State &glState, bool isCallValid, GLenum pname, GLint param); +angle::CallCapture CaptureFogiv(const State &glState, + bool isCallValid, + GLenum pname, + const GLint *params); +angle::CallCapture CaptureFrustum(const State &glState, + bool isCallValid, + GLdouble left, + GLdouble right, + GLdouble bottom, + GLdouble top, + GLdouble zNear, + GLdouble zFar); +angle::CallCapture CaptureGenLists(const State &glState, + bool isCallValid, + GLsizei range, + GLuint returnValue); +angle::CallCapture CaptureGetClipPlane(const State &glState, + bool isCallValid, + GLenum plane, + GLdouble *equation); +angle::CallCapture CaptureGetDoublev(const State &glState, + bool isCallValid, + GLenum pname, + GLdouble *data); +angle::CallCapture CaptureGetLightiv(const State &glState, + bool isCallValid, + GLenum light, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetMapdv(const State &glState, + bool isCallValid, + GLenum target, + GLenum query, + GLdouble *v); +angle::CallCapture CaptureGetMapfv(const State &glState, + bool isCallValid, + GLenum target, + GLenum query, + GLfloat *v); +angle::CallCapture CaptureGetMapiv(const State &glState, + bool isCallValid, + GLenum target, + GLenum query, + GLint *v); +angle::CallCapture CaptureGetMaterialiv(const State &glState, + bool isCallValid, + GLenum face, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetPixelMapfv(const State &glState, + bool isCallValid, + GLenum map, + GLfloat *values); +angle::CallCapture CaptureGetPixelMapuiv(const State &glState, + bool isCallValid, + GLenum map, + GLuint *values); +angle::CallCapture CaptureGetPixelMapusv(const State &glState, + bool isCallValid, + GLenum map, + GLushort *values); +angle::CallCapture CaptureGetPolygonStipple(const State &glState, bool isCallValid, GLubyte *mask); +angle::CallCapture CaptureGetTexGendv(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLdouble *params); +angle::CallCapture CaptureGetTexGenfv(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLfloat *params); +angle::CallCapture CaptureGetTexGeniv(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetTexImage(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum format, + GLenum type, + void *pixels); +angle::CallCapture CaptureIndexMask(const State &glState, bool isCallValid, GLuint mask); +angle::CallCapture CaptureIndexd(const State &glState, bool isCallValid, GLdouble c); +angle::CallCapture CaptureIndexdv(const State &glState, bool isCallValid, const GLdouble *c); +angle::CallCapture CaptureIndexf(const State &glState, bool isCallValid, GLfloat c); +angle::CallCapture CaptureIndexfv(const State &glState, bool isCallValid, const GLfloat *c); +angle::CallCapture CaptureIndexi(const State &glState, bool isCallValid, GLint c); +angle::CallCapture CaptureIndexiv(const State &glState, bool isCallValid, const GLint *c); +angle::CallCapture CaptureIndexs(const State &glState, bool isCallValid, GLshort c); +angle::CallCapture CaptureIndexsv(const State &glState, bool isCallValid, const GLshort *c); +angle::CallCapture CaptureInitNames(const State &glState, bool isCallValid); +angle::CallCapture CaptureIsList(const State &glState, + bool isCallValid, + GLuint list, + GLboolean returnValue); +angle::CallCapture CaptureLightModeli(const State &glState, + bool isCallValid, + GLenum pname, + GLint param); +angle::CallCapture CaptureLightModeliv(const State &glState, + bool isCallValid, + GLenum pname, + const GLint *params); +angle::CallCapture CaptureLighti(const State &glState, + bool isCallValid, + GLenum light, + GLenum pname, + GLint param); +angle::CallCapture CaptureLightiv(const State &glState, + bool isCallValid, + GLenum light, + GLenum pname, + const GLint *params); +angle::CallCapture CaptureLineStipple(const State &glState, + bool isCallValid, + GLint factor, + GLushort pattern); +angle::CallCapture CaptureListBase(const State &glState, bool isCallValid, GLuint base); +angle::CallCapture CaptureLoadMatrixd(const State &glState, bool isCallValid, const GLdouble *m); +angle::CallCapture CaptureLoadName(const State &glState, bool isCallValid, GLuint name); +angle::CallCapture CaptureMap1d(const State &glState, + bool isCallValid, + GLenum target, + GLdouble u1, + GLdouble u2, + GLint stride, + GLint order, + const GLdouble *points); +angle::CallCapture CaptureMap1f(const State &glState, + bool isCallValid, + GLenum target, + GLfloat u1, + GLfloat u2, + GLint stride, + GLint order, + const GLfloat *points); +angle::CallCapture CaptureMap2d(const State &glState, + bool isCallValid, + GLenum target, + GLdouble u1, + GLdouble u2, + GLint ustride, + GLint uorder, + GLdouble v1, + GLdouble v2, + GLint vstride, + GLint vorder, + const GLdouble *points); +angle::CallCapture CaptureMap2f(const State &glState, + bool isCallValid, + GLenum target, + GLfloat u1, + GLfloat u2, + GLint ustride, + GLint uorder, + GLfloat v1, + GLfloat v2, + GLint vstride, + GLint vorder, + const GLfloat *points); +angle::CallCapture CaptureMapGrid1d(const State &glState, + bool isCallValid, + GLint un, + GLdouble u1, + GLdouble u2); +angle::CallCapture CaptureMapGrid1f(const State &glState, + bool isCallValid, + GLint un, + GLfloat u1, + GLfloat u2); +angle::CallCapture CaptureMapGrid2d(const State &glState, + bool isCallValid, + GLint un, + GLdouble u1, + GLdouble u2, + GLint vn, + GLdouble v1, + GLdouble v2); +angle::CallCapture CaptureMapGrid2f(const State &glState, + bool isCallValid, + GLint un, + GLfloat u1, + GLfloat u2, + GLint vn, + GLfloat v1, + GLfloat v2); +angle::CallCapture CaptureMateriali(const State &glState, + bool isCallValid, + GLenum face, + GLenum pname, + GLint param); +angle::CallCapture CaptureMaterialiv(const State &glState, + bool isCallValid, + GLenum face, + GLenum pname, + const GLint *params); +angle::CallCapture CaptureMultMatrixd(const State &glState, bool isCallValid, const GLdouble *m); +angle::CallCapture CaptureNewList(const State &glState, bool isCallValid, GLuint list, GLenum mode); +angle::CallCapture CaptureNormal3b(const State &glState, + bool isCallValid, + GLbyte nx, + GLbyte ny, + GLbyte nz); +angle::CallCapture CaptureNormal3bv(const State &glState, bool isCallValid, const GLbyte *v); +angle::CallCapture CaptureNormal3d(const State &glState, + bool isCallValid, + GLdouble nx, + GLdouble ny, + GLdouble nz); +angle::CallCapture CaptureNormal3dv(const State &glState, bool isCallValid, const GLdouble *v); +angle::CallCapture CaptureNormal3fv(const State &glState, bool isCallValid, const GLfloat *v); +angle::CallCapture CaptureNormal3i(const State &glState, + bool isCallValid, + GLint nx, + GLint ny, + GLint nz); +angle::CallCapture CaptureNormal3iv(const State &glState, bool isCallValid, const GLint *v); +angle::CallCapture CaptureNormal3s(const State &glState, + bool isCallValid, + GLshort nx, + GLshort ny, + GLshort nz); +angle::CallCapture CaptureNormal3sv(const State &glState, bool isCallValid, const GLshort *v); +angle::CallCapture CaptureOrtho(const State &glState, + bool isCallValid, + GLdouble left, + GLdouble right, + GLdouble bottom, + GLdouble top, + GLdouble zNear, + GLdouble zFar); +angle::CallCapture CapturePassThrough(const State &glState, bool isCallValid, GLfloat token); +angle::CallCapture CapturePixelMapfv(const State &glState, + bool isCallValid, + GLenum map, + GLsizei mapsize, + const GLfloat *values); +angle::CallCapture CapturePixelMapuiv(const State &glState, + bool isCallValid, + GLenum map, + GLsizei mapsize, + const GLuint *values); +angle::CallCapture CapturePixelMapusv(const State &glState, + bool isCallValid, + GLenum map, + GLsizei mapsize, + const GLushort *values); +angle::CallCapture CapturePixelStoref(const State &glState, + bool isCallValid, + GLenum pname, + GLfloat param); +angle::CallCapture CapturePixelTransferf(const State &glState, + bool isCallValid, + GLenum pname, + GLfloat param); +angle::CallCapture CapturePixelTransferi(const State &glState, + bool isCallValid, + GLenum pname, + GLint param); +angle::CallCapture CapturePixelZoom(const State &glState, + bool isCallValid, + GLfloat xfactor, + GLfloat yfactor); +angle::CallCapture CapturePolygonMode(const State &glState, + bool isCallValid, + GLenum face, + GLenum mode); +angle::CallCapture CapturePolygonStipple(const State &glState, + bool isCallValid, + const GLubyte *mask); +angle::CallCapture CapturePopAttrib(const State &glState, bool isCallValid); +angle::CallCapture CapturePopName(const State &glState, bool isCallValid); +angle::CallCapture CapturePushAttrib(const State &glState, bool isCallValid, GLbitfield mask); +angle::CallCapture CapturePushName(const State &glState, bool isCallValid, GLuint name); +angle::CallCapture CaptureRasterPos2d(const State &glState, + bool isCallValid, + GLdouble x, + GLdouble y); +angle::CallCapture CaptureRasterPos2dv(const State &glState, bool isCallValid, const GLdouble *v); +angle::CallCapture CaptureRasterPos2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y); +angle::CallCapture CaptureRasterPos2fv(const State &glState, bool isCallValid, const GLfloat *v); +angle::CallCapture CaptureRasterPos2i(const State &glState, bool isCallValid, GLint x, GLint y); +angle::CallCapture CaptureRasterPos2iv(const State &glState, bool isCallValid, const GLint *v); +angle::CallCapture CaptureRasterPos2s(const State &glState, bool isCallValid, GLshort x, GLshort y); +angle::CallCapture CaptureRasterPos2sv(const State &glState, bool isCallValid, const GLshort *v); +angle::CallCapture CaptureRasterPos3d(const State &glState, + bool isCallValid, + GLdouble x, + GLdouble y, + GLdouble z); +angle::CallCapture CaptureRasterPos3dv(const State &glState, bool isCallValid, const GLdouble *v); +angle::CallCapture CaptureRasterPos3f(const State &glState, + bool isCallValid, + GLfloat x, + GLfloat y, + GLfloat z); +angle::CallCapture CaptureRasterPos3fv(const State &glState, bool isCallValid, const GLfloat *v); +angle::CallCapture CaptureRasterPos3i(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLint z); +angle::CallCapture CaptureRasterPos3iv(const State &glState, bool isCallValid, const GLint *v); +angle::CallCapture CaptureRasterPos3s(const State &glState, + bool isCallValid, + GLshort x, + GLshort y, + GLshort z); +angle::CallCapture CaptureRasterPos3sv(const State &glState, bool isCallValid, const GLshort *v); +angle::CallCapture CaptureRasterPos4d(const State &glState, + bool isCallValid, + GLdouble x, + GLdouble y, + GLdouble z, + GLdouble w); +angle::CallCapture CaptureRasterPos4dv(const State &glState, bool isCallValid, const GLdouble *v); +angle::CallCapture CaptureRasterPos4f(const State &glState, + bool isCallValid, + GLfloat x, + GLfloat y, + GLfloat z, + GLfloat w); +angle::CallCapture CaptureRasterPos4fv(const State &glState, bool isCallValid, const GLfloat *v); +angle::CallCapture CaptureRasterPos4i(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLint z, + GLint w); +angle::CallCapture CaptureRasterPos4iv(const State &glState, bool isCallValid, const GLint *v); +angle::CallCapture CaptureRasterPos4s(const State &glState, + bool isCallValid, + GLshort x, + GLshort y, + GLshort z, + GLshort w); +angle::CallCapture CaptureRasterPos4sv(const State &glState, bool isCallValid, const GLshort *v); +angle::CallCapture CaptureRectd(const State &glState, + bool isCallValid, + GLdouble x1, + GLdouble y1, + GLdouble x2, + GLdouble y2); +angle::CallCapture CaptureRectdv(const State &glState, + bool isCallValid, + const GLdouble *v1, + const GLdouble *v2); +angle::CallCapture CaptureRectf(const State &glState, + bool isCallValid, + GLfloat x1, + GLfloat y1, + GLfloat x2, + GLfloat y2); +angle::CallCapture CaptureRectfv(const State &glState, + bool isCallValid, + const GLfloat *v1, + const GLfloat *v2); +angle::CallCapture CaptureRecti(const State &glState, + bool isCallValid, + GLint x1, + GLint y1, + GLint x2, + GLint y2); +angle::CallCapture CaptureRectiv(const State &glState, + bool isCallValid, + const GLint *v1, + const GLint *v2); +angle::CallCapture CaptureRects(const State &glState, + bool isCallValid, + GLshort x1, + GLshort y1, + GLshort x2, + GLshort y2); +angle::CallCapture CaptureRectsv(const State &glState, + bool isCallValid, + const GLshort *v1, + const GLshort *v2); +angle::CallCapture CaptureRenderMode(const State &glState, + bool isCallValid, + GLenum mode, + GLint returnValue); +angle::CallCapture CaptureRotated(const State &glState, + bool isCallValid, + GLdouble angle, + GLdouble x, + GLdouble y, + GLdouble z); +angle::CallCapture CaptureScaled(const State &glState, + bool isCallValid, + GLdouble x, + GLdouble y, + GLdouble z); +angle::CallCapture CaptureSelectBuffer(const State &glState, + bool isCallValid, + GLsizei size, + GLuint *buffer); +angle::CallCapture CaptureTexCoord1d(const State &glState, bool isCallValid, GLdouble s); +angle::CallCapture CaptureTexCoord1dv(const State &glState, bool isCallValid, const GLdouble *v); +angle::CallCapture CaptureTexCoord1f(const State &glState, bool isCallValid, GLfloat s); +angle::CallCapture CaptureTexCoord1fv(const State &glState, bool isCallValid, const GLfloat *v); +angle::CallCapture CaptureTexCoord1i(const State &glState, bool isCallValid, GLint s); +angle::CallCapture CaptureTexCoord1iv(const State &glState, bool isCallValid, const GLint *v); +angle::CallCapture CaptureTexCoord1s(const State &glState, bool isCallValid, GLshort s); +angle::CallCapture CaptureTexCoord1sv(const State &glState, bool isCallValid, const GLshort *v); +angle::CallCapture CaptureTexCoord2d(const State &glState, + bool isCallValid, + GLdouble s, + GLdouble t); +angle::CallCapture CaptureTexCoord2dv(const State &glState, bool isCallValid, const GLdouble *v); +angle::CallCapture CaptureTexCoord2f(const State &glState, bool isCallValid, GLfloat s, GLfloat t); +angle::CallCapture CaptureTexCoord2fv(const State &glState, bool isCallValid, const GLfloat *v); +angle::CallCapture CaptureTexCoord2i(const State &glState, bool isCallValid, GLint s, GLint t); +angle::CallCapture CaptureTexCoord2iv(const State &glState, bool isCallValid, const GLint *v); +angle::CallCapture CaptureTexCoord2s(const State &glState, bool isCallValid, GLshort s, GLshort t); +angle::CallCapture CaptureTexCoord2sv(const State &glState, bool isCallValid, const GLshort *v); +angle::CallCapture CaptureTexCoord3d(const State &glState, + bool isCallValid, + GLdouble s, + GLdouble t, + GLdouble r); +angle::CallCapture CaptureTexCoord3dv(const State &glState, bool isCallValid, const GLdouble *v); +angle::CallCapture CaptureTexCoord3f(const State &glState, + bool isCallValid, + GLfloat s, + GLfloat t, + GLfloat r); +angle::CallCapture CaptureTexCoord3fv(const State &glState, bool isCallValid, const GLfloat *v); +angle::CallCapture CaptureTexCoord3i(const State &glState, + bool isCallValid, + GLint s, + GLint t, + GLint r); +angle::CallCapture CaptureTexCoord3iv(const State &glState, bool isCallValid, const GLint *v); +angle::CallCapture CaptureTexCoord3s(const State &glState, + bool isCallValid, + GLshort s, + GLshort t, + GLshort r); +angle::CallCapture CaptureTexCoord3sv(const State &glState, bool isCallValid, const GLshort *v); +angle::CallCapture CaptureTexCoord4d(const State &glState, + bool isCallValid, + GLdouble s, + GLdouble t, + GLdouble r, + GLdouble q); +angle::CallCapture CaptureTexCoord4dv(const State &glState, bool isCallValid, const GLdouble *v); +angle::CallCapture CaptureTexCoord4f(const State &glState, + bool isCallValid, + GLfloat s, + GLfloat t, + GLfloat r, + GLfloat q); +angle::CallCapture CaptureTexCoord4fv(const State &glState, bool isCallValid, const GLfloat *v); +angle::CallCapture CaptureTexCoord4i(const State &glState, + bool isCallValid, + GLint s, + GLint t, + GLint r, + GLint q); +angle::CallCapture CaptureTexCoord4iv(const State &glState, bool isCallValid, const GLint *v); +angle::CallCapture CaptureTexCoord4s(const State &glState, + bool isCallValid, + GLshort s, + GLshort t, + GLshort r, + GLshort q); +angle::CallCapture CaptureTexCoord4sv(const State &glState, bool isCallValid, const GLshort *v); +angle::CallCapture CaptureTexGend(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLdouble param); +angle::CallCapture CaptureTexGendv(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + const GLdouble *params); +angle::CallCapture CaptureTexGenf(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLfloat param); +angle::CallCapture CaptureTexGenfv(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + const GLfloat *params); +angle::CallCapture CaptureTexGeni(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLint param); +angle::CallCapture CaptureTexGeniv(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + const GLint *params); +angle::CallCapture CaptureTexImage1D(const State &glState, + bool isCallValid, + GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLint border, + GLenum format, + GLenum type, + const void *pixels); +angle::CallCapture CaptureTranslated(const State &glState, + bool isCallValid, + GLdouble x, + GLdouble y, + GLdouble z); +angle::CallCapture CaptureVertex2d(const State &glState, bool isCallValid, GLdouble x, GLdouble y); +angle::CallCapture CaptureVertex2dv(const State &glState, bool isCallValid, const GLdouble *v); +angle::CallCapture CaptureVertex2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y); +angle::CallCapture CaptureVertex2fv(const State &glState, bool isCallValid, const GLfloat *v); +angle::CallCapture CaptureVertex2i(const State &glState, bool isCallValid, GLint x, GLint y); +angle::CallCapture CaptureVertex2iv(const State &glState, bool isCallValid, const GLint *v); +angle::CallCapture CaptureVertex2s(const State &glState, bool isCallValid, GLshort x, GLshort y); +angle::CallCapture CaptureVertex2sv(const State &glState, bool isCallValid, const GLshort *v); +angle::CallCapture CaptureVertex3d(const State &glState, + bool isCallValid, + GLdouble x, + GLdouble y, + GLdouble z); +angle::CallCapture CaptureVertex3dv(const State &glState, bool isCallValid, const GLdouble *v); +angle::CallCapture CaptureVertex3f(const State &glState, + bool isCallValid, + GLfloat x, + GLfloat y, + GLfloat z); +angle::CallCapture CaptureVertex3fv(const State &glState, bool isCallValid, const GLfloat *v); +angle::CallCapture CaptureVertex3i(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLint z); +angle::CallCapture CaptureVertex3iv(const State &glState, bool isCallValid, const GLint *v); +angle::CallCapture CaptureVertex3s(const State &glState, + bool isCallValid, + GLshort x, + GLshort y, + GLshort z); +angle::CallCapture CaptureVertex3sv(const State &glState, bool isCallValid, const GLshort *v); +angle::CallCapture CaptureVertex4d(const State &glState, + bool isCallValid, + GLdouble x, + GLdouble y, + GLdouble z, + GLdouble w); +angle::CallCapture CaptureVertex4dv(const State &glState, bool isCallValid, const GLdouble *v); +angle::CallCapture CaptureVertex4f(const State &glState, + bool isCallValid, + GLfloat x, + GLfloat y, + GLfloat z, + GLfloat w); +angle::CallCapture CaptureVertex4fv(const State &glState, bool isCallValid, const GLfloat *v); +angle::CallCapture CaptureVertex4i(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLint z, + GLint w); +angle::CallCapture CaptureVertex4iv(const State &glState, bool isCallValid, const GLint *v); +angle::CallCapture CaptureVertex4s(const State &glState, + bool isCallValid, + GLshort x, + GLshort y, + GLshort z, + GLshort w); +angle::CallCapture CaptureVertex4sv(const State &glState, bool isCallValid, const GLshort *v); + +// GL 1.1 +angle::CallCapture CaptureAreTexturesResident(const State &glState, + bool isCallValid, + GLsizei n, + const GLuint *textures, + GLboolean *residences, + GLboolean returnValue); +angle::CallCapture CaptureArrayElement(const State &glState, bool isCallValid, GLint i); +angle::CallCapture CaptureCopyTexImage1D(const State &glState, + bool isCallValid, + GLenum target, + GLint level, + GLenum internalformat, + GLint x, + GLint y, + GLsizei width, + GLint border); +angle::CallCapture CaptureCopyTexSubImage1D(const State &glState, + bool isCallValid, + GLenum target, + GLint level, + GLint xoffset, + GLint x, + GLint y, + GLsizei width); +angle::CallCapture CaptureEdgeFlagPointer(const State &glState, + bool isCallValid, + GLsizei stride, + const void *pointer); +angle::CallCapture CaptureIndexPointer(const State &glState, + bool isCallValid, + GLenum type, + GLsizei stride, + const void *pointer); +angle::CallCapture CaptureIndexub(const State &glState, bool isCallValid, GLubyte c); +angle::CallCapture CaptureIndexubv(const State &glState, bool isCallValid, const GLubyte *c); +angle::CallCapture CaptureInterleavedArrays(const State &glState, + bool isCallValid, + GLenum format, + GLsizei stride, + const void *pointer); +angle::CallCapture CapturePopClientAttrib(const State &glState, bool isCallValid); +angle::CallCapture CapturePrioritizeTextures(const State &glState, + bool isCallValid, + GLsizei n, + const GLuint *textures, + const GLfloat *priorities); +angle::CallCapture CapturePushClientAttrib(const State &glState, bool isCallValid, GLbitfield mask); +angle::CallCapture CaptureTexSubImage1D(const State &glState, + bool isCallValid, + GLenum target, + GLint level, + GLint xoffset, + GLsizei width, + GLenum format, + GLenum type, + const void *pixels); + +// GL 1.2 + +// GL 1.3 +angle::CallCapture CaptureCompressedTexImage1D(const State &glState, + bool isCallValid, + GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLint border, + GLsizei imageSize, + const void *data); +angle::CallCapture CaptureCompressedTexSubImage1D(const State &glState, + bool isCallValid, + GLenum target, + GLint level, + GLint xoffset, + GLsizei width, + GLenum format, + GLsizei imageSize, + const void *data); +angle::CallCapture CaptureGetCompressedTexImage(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + void *img); +angle::CallCapture CaptureLoadTransposeMatrixd(const State &glState, + bool isCallValid, + const GLdouble *m); +angle::CallCapture CaptureLoadTransposeMatrixf(const State &glState, + bool isCallValid, + const GLfloat *m); +angle::CallCapture CaptureMultTransposeMatrixd(const State &glState, + bool isCallValid, + const GLdouble *m); +angle::CallCapture CaptureMultTransposeMatrixf(const State &glState, + bool isCallValid, + const GLfloat *m); +angle::CallCapture CaptureMultiTexCoord1d(const State &glState, + bool isCallValid, + GLenum target, + GLdouble s); +angle::CallCapture CaptureMultiTexCoord1dv(const State &glState, + bool isCallValid, + GLenum target, + const GLdouble *v); +angle::CallCapture CaptureMultiTexCoord1f(const State &glState, + bool isCallValid, + GLenum target, + GLfloat s); +angle::CallCapture CaptureMultiTexCoord1fv(const State &glState, + bool isCallValid, + GLenum target, + const GLfloat *v); +angle::CallCapture CaptureMultiTexCoord1i(const State &glState, + bool isCallValid, + GLenum target, + GLint s); +angle::CallCapture CaptureMultiTexCoord1iv(const State &glState, + bool isCallValid, + GLenum target, + const GLint *v); +angle::CallCapture CaptureMultiTexCoord1s(const State &glState, + bool isCallValid, + GLenum target, + GLshort s); +angle::CallCapture CaptureMultiTexCoord1sv(const State &glState, + bool isCallValid, + GLenum target, + const GLshort *v); +angle::CallCapture CaptureMultiTexCoord2d(const State &glState, + bool isCallValid, + GLenum target, + GLdouble s, + GLdouble t); +angle::CallCapture CaptureMultiTexCoord2dv(const State &glState, + bool isCallValid, + GLenum target, + const GLdouble *v); +angle::CallCapture CaptureMultiTexCoord2f(const State &glState, + bool isCallValid, + GLenum target, + GLfloat s, + GLfloat t); +angle::CallCapture CaptureMultiTexCoord2fv(const State &glState, + bool isCallValid, + GLenum target, + const GLfloat *v); +angle::CallCapture CaptureMultiTexCoord2i(const State &glState, + bool isCallValid, + GLenum target, + GLint s, + GLint t); +angle::CallCapture CaptureMultiTexCoord2iv(const State &glState, + bool isCallValid, + GLenum target, + const GLint *v); +angle::CallCapture CaptureMultiTexCoord2s(const State &glState, + bool isCallValid, + GLenum target, + GLshort s, + GLshort t); +angle::CallCapture CaptureMultiTexCoord2sv(const State &glState, + bool isCallValid, + GLenum target, + const GLshort *v); +angle::CallCapture CaptureMultiTexCoord3d(const State &glState, + bool isCallValid, + GLenum target, + GLdouble s, + GLdouble t, + GLdouble r); +angle::CallCapture CaptureMultiTexCoord3dv(const State &glState, + bool isCallValid, + GLenum target, + const GLdouble *v); +angle::CallCapture CaptureMultiTexCoord3f(const State &glState, + bool isCallValid, + GLenum target, + GLfloat s, + GLfloat t, + GLfloat r); +angle::CallCapture CaptureMultiTexCoord3fv(const State &glState, + bool isCallValid, + GLenum target, + const GLfloat *v); +angle::CallCapture CaptureMultiTexCoord3i(const State &glState, + bool isCallValid, + GLenum target, + GLint s, + GLint t, + GLint r); +angle::CallCapture CaptureMultiTexCoord3iv(const State &glState, + bool isCallValid, + GLenum target, + const GLint *v); +angle::CallCapture CaptureMultiTexCoord3s(const State &glState, + bool isCallValid, + GLenum target, + GLshort s, + GLshort t, + GLshort r); +angle::CallCapture CaptureMultiTexCoord3sv(const State &glState, + bool isCallValid, + GLenum target, + const GLshort *v); +angle::CallCapture CaptureMultiTexCoord4d(const State &glState, + bool isCallValid, + GLenum target, + GLdouble s, + GLdouble t, + GLdouble r, + GLdouble q); +angle::CallCapture CaptureMultiTexCoord4dv(const State &glState, + bool isCallValid, + GLenum target, + const GLdouble *v); +angle::CallCapture CaptureMultiTexCoord4fv(const State &glState, + bool isCallValid, + GLenum target, + const GLfloat *v); +angle::CallCapture CaptureMultiTexCoord4i(const State &glState, + bool isCallValid, + GLenum target, + GLint s, + GLint t, + GLint r, + GLint q); +angle::CallCapture CaptureMultiTexCoord4iv(const State &glState, + bool isCallValid, + GLenum target, + const GLint *v); +angle::CallCapture CaptureMultiTexCoord4s(const State &glState, + bool isCallValid, + GLenum target, + GLshort s, + GLshort t, + GLshort r, + GLshort q); +angle::CallCapture CaptureMultiTexCoord4sv(const State &glState, + bool isCallValid, + GLenum target, + const GLshort *v); + +// GL 1.4 +angle::CallCapture CaptureFogCoordPointer(const State &glState, + bool isCallValid, + GLenum type, + GLsizei stride, + const void *pointer); +angle::CallCapture CaptureFogCoordd(const State &glState, bool isCallValid, GLdouble coord); +angle::CallCapture CaptureFogCoorddv(const State &glState, bool isCallValid, const GLdouble *coord); +angle::CallCapture CaptureFogCoordf(const State &glState, bool isCallValid, GLfloat coord); +angle::CallCapture CaptureFogCoordfv(const State &glState, bool isCallValid, const GLfloat *coord); +angle::CallCapture CaptureMultiDrawArrays(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLint *first, + const GLsizei *count, + GLsizei drawcount); +angle::CallCapture CaptureMultiDrawElements(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *count, + DrawElementsType typePacked, + const void *const *indices, + GLsizei drawcount); +angle::CallCapture CapturePointParameteri(const State &glState, + bool isCallValid, + GLenum pname, + GLint param); +angle::CallCapture CapturePointParameteriv(const State &glState, + bool isCallValid, + GLenum pname, + const GLint *params); +angle::CallCapture CaptureSecondaryColor3b(const State &glState, + bool isCallValid, + GLbyte red, + GLbyte green, + GLbyte blue); +angle::CallCapture CaptureSecondaryColor3bv(const State &glState, + bool isCallValid, + const GLbyte *v); +angle::CallCapture CaptureSecondaryColor3d(const State &glState, + bool isCallValid, + GLdouble red, + GLdouble green, + GLdouble blue); +angle::CallCapture CaptureSecondaryColor3dv(const State &glState, + bool isCallValid, + const GLdouble *v); +angle::CallCapture CaptureSecondaryColor3f(const State &glState, + bool isCallValid, + GLfloat red, + GLfloat green, + GLfloat blue); +angle::CallCapture CaptureSecondaryColor3fv(const State &glState, + bool isCallValid, + const GLfloat *v); +angle::CallCapture CaptureSecondaryColor3i(const State &glState, + bool isCallValid, + GLint red, + GLint green, + GLint blue); +angle::CallCapture CaptureSecondaryColor3iv(const State &glState, bool isCallValid, const GLint *v); +angle::CallCapture CaptureSecondaryColor3s(const State &glState, + bool isCallValid, + GLshort red, + GLshort green, + GLshort blue); +angle::CallCapture CaptureSecondaryColor3sv(const State &glState, + bool isCallValid, + const GLshort *v); +angle::CallCapture CaptureSecondaryColor3ub(const State &glState, + bool isCallValid, + GLubyte red, + GLubyte green, + GLubyte blue); +angle::CallCapture CaptureSecondaryColor3ubv(const State &glState, + bool isCallValid, + const GLubyte *v); +angle::CallCapture CaptureSecondaryColor3ui(const State &glState, + bool isCallValid, + GLuint red, + GLuint green, + GLuint blue); +angle::CallCapture CaptureSecondaryColor3uiv(const State &glState, + bool isCallValid, + const GLuint *v); +angle::CallCapture CaptureSecondaryColor3us(const State &glState, + bool isCallValid, + GLushort red, + GLushort green, + GLushort blue); +angle::CallCapture CaptureSecondaryColor3usv(const State &glState, + bool isCallValid, + const GLushort *v); +angle::CallCapture CaptureSecondaryColorPointer(const State &glState, + bool isCallValid, + GLint size, + GLenum type, + GLsizei stride, + const void *pointer); +angle::CallCapture CaptureWindowPos2d(const State &glState, + bool isCallValid, + GLdouble x, + GLdouble y); +angle::CallCapture CaptureWindowPos2dv(const State &glState, bool isCallValid, const GLdouble *v); +angle::CallCapture CaptureWindowPos2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y); +angle::CallCapture CaptureWindowPos2fv(const State &glState, bool isCallValid, const GLfloat *v); +angle::CallCapture CaptureWindowPos2i(const State &glState, bool isCallValid, GLint x, GLint y); +angle::CallCapture CaptureWindowPos2iv(const State &glState, bool isCallValid, const GLint *v); +angle::CallCapture CaptureWindowPos2s(const State &glState, bool isCallValid, GLshort x, GLshort y); +angle::CallCapture CaptureWindowPos2sv(const State &glState, bool isCallValid, const GLshort *v); +angle::CallCapture CaptureWindowPos3d(const State &glState, + bool isCallValid, + GLdouble x, + GLdouble y, + GLdouble z); +angle::CallCapture CaptureWindowPos3dv(const State &glState, bool isCallValid, const GLdouble *v); +angle::CallCapture CaptureWindowPos3f(const State &glState, + bool isCallValid, + GLfloat x, + GLfloat y, + GLfloat z); +angle::CallCapture CaptureWindowPos3fv(const State &glState, bool isCallValid, const GLfloat *v); +angle::CallCapture CaptureWindowPos3i(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLint z); +angle::CallCapture CaptureWindowPos3iv(const State &glState, bool isCallValid, const GLint *v); +angle::CallCapture CaptureWindowPos3s(const State &glState, + bool isCallValid, + GLshort x, + GLshort y, + GLshort z); +angle::CallCapture CaptureWindowPos3sv(const State &glState, bool isCallValid, const GLshort *v); + +// GL 1.5 +angle::CallCapture CaptureGetBufferSubData(const State &glState, + bool isCallValid, + GLenum target, + GLintptr offset, + GLsizeiptr size, + void *data); +angle::CallCapture CaptureGetQueryObjectiv(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureMapBuffer(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum access, + void *returnValue); + +// Parameter Captures + +// GL 1.0 +void CaptureBitmap_bitmap(const State &glState, + bool isCallValid, + GLsizei width, + GLsizei height, + GLfloat xorig, + GLfloat yorig, + GLfloat xmove, + GLfloat ymove, + const GLubyte *bitmap, + angle::ParamCapture *paramCapture); +void CaptureCallLists_lists(const State &glState, + bool isCallValid, + GLsizei n, + GLenum type, + const void *lists, + angle::ParamCapture *paramCapture); +void CaptureClipPlane_equation(const State &glState, + bool isCallValid, + GLenum plane, + const GLdouble *equation, + angle::ParamCapture *paramCapture); +void CaptureColor3bv_v(const State &glState, + bool isCallValid, + const GLbyte *v, + angle::ParamCapture *paramCapture); +void CaptureColor3dv_v(const State &glState, + bool isCallValid, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureColor3fv_v(const State &glState, + bool isCallValid, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureColor3iv_v(const State &glState, + bool isCallValid, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureColor3sv_v(const State &glState, + bool isCallValid, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureColor3ubv_v(const State &glState, + bool isCallValid, + const GLubyte *v, + angle::ParamCapture *paramCapture); +void CaptureColor3uiv_v(const State &glState, + bool isCallValid, + const GLuint *v, + angle::ParamCapture *paramCapture); +void CaptureColor3usv_v(const State &glState, + bool isCallValid, + const GLushort *v, + angle::ParamCapture *paramCapture); +void CaptureColor4bv_v(const State &glState, + bool isCallValid, + const GLbyte *v, + angle::ParamCapture *paramCapture); +void CaptureColor4dv_v(const State &glState, + bool isCallValid, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureColor4fv_v(const State &glState, + bool isCallValid, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureColor4iv_v(const State &glState, + bool isCallValid, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureColor4sv_v(const State &glState, + bool isCallValid, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureColor4ubv_v(const State &glState, + bool isCallValid, + const GLubyte *v, + angle::ParamCapture *paramCapture); +void CaptureColor4uiv_v(const State &glState, + bool isCallValid, + const GLuint *v, + angle::ParamCapture *paramCapture); +void CaptureColor4usv_v(const State &glState, + bool isCallValid, + const GLushort *v, + angle::ParamCapture *paramCapture); +void CaptureDrawPixels_pixels(const State &glState, + bool isCallValid, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + const void *pixels, + angle::ParamCapture *paramCapture); +void CaptureEdgeFlagv_flag(const State &glState, + bool isCallValid, + const GLboolean *flag, + angle::ParamCapture *paramCapture); +void CaptureEvalCoord1dv_u(const State &glState, + bool isCallValid, + const GLdouble *u, + angle::ParamCapture *paramCapture); +void CaptureEvalCoord1fv_u(const State &glState, + bool isCallValid, + const GLfloat *u, + angle::ParamCapture *paramCapture); +void CaptureEvalCoord2dv_u(const State &glState, + bool isCallValid, + const GLdouble *u, + angle::ParamCapture *paramCapture); +void CaptureEvalCoord2fv_u(const State &glState, + bool isCallValid, + const GLfloat *u, + angle::ParamCapture *paramCapture); +void CaptureFeedbackBuffer_buffer(const State &glState, + bool isCallValid, + GLsizei size, + GLenum type, + GLfloat *buffer, + angle::ParamCapture *paramCapture); +void CaptureFogiv_params(const State &glState, + bool isCallValid, + GLenum pname, + const GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetClipPlane_equation(const State &glState, + bool isCallValid, + GLenum plane, + GLdouble *equation, + angle::ParamCapture *paramCapture); +void CaptureGetDoublev_data(const State &glState, + bool isCallValid, + GLenum pname, + GLdouble *data, + angle::ParamCapture *paramCapture); +void CaptureGetLightiv_params(const State &glState, + bool isCallValid, + GLenum light, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetMapdv_v(const State &glState, + bool isCallValid, + GLenum target, + GLenum query, + GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureGetMapfv_v(const State &glState, + bool isCallValid, + GLenum target, + GLenum query, + GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureGetMapiv_v(const State &glState, + bool isCallValid, + GLenum target, + GLenum query, + GLint *v, + angle::ParamCapture *paramCapture); +void CaptureGetMaterialiv_params(const State &glState, + bool isCallValid, + GLenum face, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetPixelMapfv_values(const State &glState, + bool isCallValid, + GLenum map, + GLfloat *values, + angle::ParamCapture *paramCapture); +void CaptureGetPixelMapuiv_values(const State &glState, + bool isCallValid, + GLenum map, + GLuint *values, + angle::ParamCapture *paramCapture); +void CaptureGetPixelMapusv_values(const State &glState, + bool isCallValid, + GLenum map, + GLushort *values, + angle::ParamCapture *paramCapture); +void CaptureGetPolygonStipple_mask(const State &glState, + bool isCallValid, + GLubyte *mask, + angle::ParamCapture *paramCapture); +void CaptureGetTexGendv_params(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLdouble *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexGenfv_params(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexGeniv_params(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexImage_pixels(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum format, + GLenum type, + void *pixels, + angle::ParamCapture *paramCapture); +void CaptureIndexdv_c(const State &glState, + bool isCallValid, + const GLdouble *c, + angle::ParamCapture *paramCapture); +void CaptureIndexfv_c(const State &glState, + bool isCallValid, + const GLfloat *c, + angle::ParamCapture *paramCapture); +void CaptureIndexiv_c(const State &glState, + bool isCallValid, + const GLint *c, + angle::ParamCapture *paramCapture); +void CaptureIndexsv_c(const State &glState, + bool isCallValid, + const GLshort *c, + angle::ParamCapture *paramCapture); +void CaptureLightModeliv_params(const State &glState, + bool isCallValid, + GLenum pname, + const GLint *params, + angle::ParamCapture *paramCapture); +void CaptureLightiv_params(const State &glState, + bool isCallValid, + GLenum light, + GLenum pname, + const GLint *params, + angle::ParamCapture *paramCapture); +void CaptureLoadMatrixd_m(const State &glState, + bool isCallValid, + const GLdouble *m, + angle::ParamCapture *paramCapture); +void CaptureMap1d_points(const State &glState, + bool isCallValid, + GLenum target, + GLdouble u1, + GLdouble u2, + GLint stride, + GLint order, + const GLdouble *points, + angle::ParamCapture *paramCapture); +void CaptureMap1f_points(const State &glState, + bool isCallValid, + GLenum target, + GLfloat u1, + GLfloat u2, + GLint stride, + GLint order, + const GLfloat *points, + angle::ParamCapture *paramCapture); +void CaptureMap2d_points(const State &glState, + bool isCallValid, + GLenum target, + GLdouble u1, + GLdouble u2, + GLint ustride, + GLint uorder, + GLdouble v1, + GLdouble v2, + GLint vstride, + GLint vorder, + const GLdouble *points, + angle::ParamCapture *paramCapture); +void CaptureMap2f_points(const State &glState, + bool isCallValid, + GLenum target, + GLfloat u1, + GLfloat u2, + GLint ustride, + GLint uorder, + GLfloat v1, + GLfloat v2, + GLint vstride, + GLint vorder, + const GLfloat *points, + angle::ParamCapture *paramCapture); +void CaptureMaterialiv_params(const State &glState, + bool isCallValid, + GLenum face, + GLenum pname, + const GLint *params, + angle::ParamCapture *paramCapture); +void CaptureMultMatrixd_m(const State &glState, + bool isCallValid, + const GLdouble *m, + angle::ParamCapture *paramCapture); +void CaptureNormal3bv_v(const State &glState, + bool isCallValid, + const GLbyte *v, + angle::ParamCapture *paramCapture); +void CaptureNormal3dv_v(const State &glState, + bool isCallValid, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureNormal3fv_v(const State &glState, + bool isCallValid, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureNormal3iv_v(const State &glState, + bool isCallValid, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureNormal3sv_v(const State &glState, + bool isCallValid, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CapturePixelMapfv_values(const State &glState, + bool isCallValid, + GLenum map, + GLsizei mapsize, + const GLfloat *values, + angle::ParamCapture *paramCapture); +void CapturePixelMapuiv_values(const State &glState, + bool isCallValid, + GLenum map, + GLsizei mapsize, + const GLuint *values, + angle::ParamCapture *paramCapture); +void CapturePixelMapusv_values(const State &glState, + bool isCallValid, + GLenum map, + GLsizei mapsize, + const GLushort *values, + angle::ParamCapture *paramCapture); +void CapturePolygonStipple_mask(const State &glState, + bool isCallValid, + const GLubyte *mask, + angle::ParamCapture *paramCapture); +void CaptureRasterPos2dv_v(const State &glState, + bool isCallValid, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureRasterPos2fv_v(const State &glState, + bool isCallValid, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureRasterPos2iv_v(const State &glState, + bool isCallValid, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureRasterPos2sv_v(const State &glState, + bool isCallValid, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureRasterPos3dv_v(const State &glState, + bool isCallValid, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureRasterPos3fv_v(const State &glState, + bool isCallValid, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureRasterPos3iv_v(const State &glState, + bool isCallValid, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureRasterPos3sv_v(const State &glState, + bool isCallValid, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureRasterPos4dv_v(const State &glState, + bool isCallValid, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureRasterPos4fv_v(const State &glState, + bool isCallValid, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureRasterPos4iv_v(const State &glState, + bool isCallValid, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureRasterPos4sv_v(const State &glState, + bool isCallValid, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureRectdv_v1(const State &glState, + bool isCallValid, + const GLdouble *v1, + const GLdouble *v2, + angle::ParamCapture *paramCapture); +void CaptureRectdv_v2(const State &glState, + bool isCallValid, + const GLdouble *v1, + const GLdouble *v2, + angle::ParamCapture *paramCapture); +void CaptureRectfv_v1(const State &glState, + bool isCallValid, + const GLfloat *v1, + const GLfloat *v2, + angle::ParamCapture *paramCapture); +void CaptureRectfv_v2(const State &glState, + bool isCallValid, + const GLfloat *v1, + const GLfloat *v2, + angle::ParamCapture *paramCapture); +void CaptureRectiv_v1(const State &glState, + bool isCallValid, + const GLint *v1, + const GLint *v2, + angle::ParamCapture *paramCapture); +void CaptureRectiv_v2(const State &glState, + bool isCallValid, + const GLint *v1, + const GLint *v2, + angle::ParamCapture *paramCapture); +void CaptureRectsv_v1(const State &glState, + bool isCallValid, + const GLshort *v1, + const GLshort *v2, + angle::ParamCapture *paramCapture); +void CaptureRectsv_v2(const State &glState, + bool isCallValid, + const GLshort *v1, + const GLshort *v2, + angle::ParamCapture *paramCapture); +void CaptureSelectBuffer_buffer(const State &glState, + bool isCallValid, + GLsizei size, + GLuint *buffer, + angle::ParamCapture *paramCapture); +void CaptureTexCoord1dv_v(const State &glState, + bool isCallValid, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureTexCoord1fv_v(const State &glState, + bool isCallValid, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureTexCoord1iv_v(const State &glState, + bool isCallValid, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureTexCoord1sv_v(const State &glState, + bool isCallValid, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureTexCoord2dv_v(const State &glState, + bool isCallValid, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureTexCoord2fv_v(const State &glState, + bool isCallValid, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureTexCoord2iv_v(const State &glState, + bool isCallValid, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureTexCoord2sv_v(const State &glState, + bool isCallValid, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureTexCoord3dv_v(const State &glState, + bool isCallValid, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureTexCoord3fv_v(const State &glState, + bool isCallValid, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureTexCoord3iv_v(const State &glState, + bool isCallValid, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureTexCoord3sv_v(const State &glState, + bool isCallValid, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureTexCoord4dv_v(const State &glState, + bool isCallValid, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureTexCoord4fv_v(const State &glState, + bool isCallValid, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureTexCoord4iv_v(const State &glState, + bool isCallValid, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureTexCoord4sv_v(const State &glState, + bool isCallValid, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureTexGendv_params(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + const GLdouble *params, + angle::ParamCapture *paramCapture); +void CaptureTexGenfv_params(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + const GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureTexGeniv_params(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + const GLint *params, + angle::ParamCapture *paramCapture); +void CaptureTexImage1D_pixels(const State &glState, + bool isCallValid, + GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLint border, + GLenum format, + GLenum type, + const void *pixels, + angle::ParamCapture *paramCapture); +void CaptureVertex2dv_v(const State &glState, + bool isCallValid, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureVertex2fv_v(const State &glState, + bool isCallValid, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureVertex2iv_v(const State &glState, + bool isCallValid, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureVertex2sv_v(const State &glState, + bool isCallValid, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureVertex3dv_v(const State &glState, + bool isCallValid, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureVertex3fv_v(const State &glState, + bool isCallValid, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureVertex3iv_v(const State &glState, + bool isCallValid, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureVertex3sv_v(const State &glState, + bool isCallValid, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureVertex4dv_v(const State &glState, + bool isCallValid, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureVertex4fv_v(const State &glState, + bool isCallValid, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureVertex4iv_v(const State &glState, + bool isCallValid, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureVertex4sv_v(const State &glState, + bool isCallValid, + const GLshort *v, + angle::ParamCapture *paramCapture); + +// GL 1.1 +void CaptureAreTexturesResident_textures(const State &glState, + bool isCallValid, + GLsizei n, + const GLuint *textures, + GLboolean *residences, + angle::ParamCapture *paramCapture); +void CaptureAreTexturesResident_residences(const State &glState, + bool isCallValid, + GLsizei n, + const GLuint *textures, + GLboolean *residences, + angle::ParamCapture *paramCapture); +void CaptureEdgeFlagPointer_pointer(const State &glState, + bool isCallValid, + GLsizei stride, + const void *pointer, + angle::ParamCapture *paramCapture); +void CaptureIndexPointer_pointer(const State &glState, + bool isCallValid, + GLenum type, + GLsizei stride, + const void *pointer, + angle::ParamCapture *paramCapture); +void CaptureIndexubv_c(const State &glState, + bool isCallValid, + const GLubyte *c, + angle::ParamCapture *paramCapture); +void CaptureInterleavedArrays_pointer(const State &glState, + bool isCallValid, + GLenum format, + GLsizei stride, + const void *pointer, + angle::ParamCapture *paramCapture); +void CapturePrioritizeTextures_textures(const State &glState, + bool isCallValid, + GLsizei n, + const GLuint *textures, + const GLfloat *priorities, + angle::ParamCapture *paramCapture); +void CapturePrioritizeTextures_priorities(const State &glState, + bool isCallValid, + GLsizei n, + const GLuint *textures, + const GLfloat *priorities, + angle::ParamCapture *paramCapture); +void CaptureTexSubImage1D_pixels(const State &glState, + bool isCallValid, + GLenum target, + GLint level, + GLint xoffset, + GLsizei width, + GLenum format, + GLenum type, + const void *pixels, + angle::ParamCapture *paramCapture); + +// GL 1.2 + +// GL 1.3 +void CaptureCompressedTexImage1D_data(const State &glState, + bool isCallValid, + GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLint border, + GLsizei imageSize, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureCompressedTexSubImage1D_data(const State &glState, + bool isCallValid, + GLenum target, + GLint level, + GLint xoffset, + GLsizei width, + GLenum format, + GLsizei imageSize, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureGetCompressedTexImage_img(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + void *img, + angle::ParamCapture *paramCapture); +void CaptureLoadTransposeMatrixd_m(const State &glState, + bool isCallValid, + const GLdouble *m, + angle::ParamCapture *paramCapture); +void CaptureLoadTransposeMatrixf_m(const State &glState, + bool isCallValid, + const GLfloat *m, + angle::ParamCapture *paramCapture); +void CaptureMultTransposeMatrixd_m(const State &glState, + bool isCallValid, + const GLdouble *m, + angle::ParamCapture *paramCapture); +void CaptureMultTransposeMatrixf_m(const State &glState, + bool isCallValid, + const GLfloat *m, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoord1dv_v(const State &glState, + bool isCallValid, + GLenum target, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoord1fv_v(const State &glState, + bool isCallValid, + GLenum target, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoord1iv_v(const State &glState, + bool isCallValid, + GLenum target, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoord1sv_v(const State &glState, + bool isCallValid, + GLenum target, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoord2dv_v(const State &glState, + bool isCallValid, + GLenum target, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoord2fv_v(const State &glState, + bool isCallValid, + GLenum target, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoord2iv_v(const State &glState, + bool isCallValid, + GLenum target, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoord2sv_v(const State &glState, + bool isCallValid, + GLenum target, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoord3dv_v(const State &glState, + bool isCallValid, + GLenum target, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoord3fv_v(const State &glState, + bool isCallValid, + GLenum target, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoord3iv_v(const State &glState, + bool isCallValid, + GLenum target, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoord3sv_v(const State &glState, + bool isCallValid, + GLenum target, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoord4dv_v(const State &glState, + bool isCallValid, + GLenum target, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoord4fv_v(const State &glState, + bool isCallValid, + GLenum target, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoord4iv_v(const State &glState, + bool isCallValid, + GLenum target, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoord4sv_v(const State &glState, + bool isCallValid, + GLenum target, + const GLshort *v, + angle::ParamCapture *paramCapture); + +// GL 1.4 +void CaptureFogCoordPointer_pointer(const State &glState, + bool isCallValid, + GLenum type, + GLsizei stride, + const void *pointer, + angle::ParamCapture *paramCapture); +void CaptureFogCoorddv_coord(const State &glState, + bool isCallValid, + const GLdouble *coord, + angle::ParamCapture *paramCapture); +void CaptureFogCoordfv_coord(const State &glState, + bool isCallValid, + const GLfloat *coord, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawArrays_first(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLint *first, + const GLsizei *count, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawArrays_count(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLint *first, + const GLsizei *count, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElements_count(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *count, + DrawElementsType typePacked, + const void *const *indices, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElements_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *count, + DrawElementsType typePacked, + const void *const *indices, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CapturePointParameteriv_params(const State &glState, + bool isCallValid, + GLenum pname, + const GLint *params, + angle::ParamCapture *paramCapture); +void CaptureSecondaryColor3bv_v(const State &glState, + bool isCallValid, + const GLbyte *v, + angle::ParamCapture *paramCapture); +void CaptureSecondaryColor3dv_v(const State &glState, + bool isCallValid, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureSecondaryColor3fv_v(const State &glState, + bool isCallValid, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureSecondaryColor3iv_v(const State &glState, + bool isCallValid, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureSecondaryColor3sv_v(const State &glState, + bool isCallValid, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureSecondaryColor3ubv_v(const State &glState, + bool isCallValid, + const GLubyte *v, + angle::ParamCapture *paramCapture); +void CaptureSecondaryColor3uiv_v(const State &glState, + bool isCallValid, + const GLuint *v, + angle::ParamCapture *paramCapture); +void CaptureSecondaryColor3usv_v(const State &glState, + bool isCallValid, + const GLushort *v, + angle::ParamCapture *paramCapture); +void CaptureSecondaryColorPointer_pointer(const State &glState, + bool isCallValid, + GLint size, + GLenum type, + GLsizei stride, + const void *pointer, + angle::ParamCapture *paramCapture); +void CaptureWindowPos2dv_v(const State &glState, + bool isCallValid, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureWindowPos2fv_v(const State &glState, + bool isCallValid, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureWindowPos2iv_v(const State &glState, + bool isCallValid, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureWindowPos2sv_v(const State &glState, + bool isCallValid, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureWindowPos3dv_v(const State &glState, + bool isCallValid, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureWindowPos3fv_v(const State &glState, + bool isCallValid, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureWindowPos3iv_v(const State &glState, + bool isCallValid, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureWindowPos3sv_v(const State &glState, + bool isCallValid, + const GLshort *v, + angle::ParamCapture *paramCapture); + +// GL 1.5 +void CaptureGetBufferSubData_data(const State &glState, + bool isCallValid, + GLenum target, + GLintptr offset, + GLsizeiptr size, + void *data, + angle::ParamCapture *paramCapture); +void CaptureGetQueryObjectiv_params(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +} // namespace gl + +#endif // LIBANGLE_CAPTURE_GL_1_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gl_2_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gl_2_autogen.h new file mode 100644 index 0000000000..5ab30a6b9a --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gl_2_autogen.h @@ -0,0 +1,266 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml. +// +// 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. +// +// capture_gl_2_autogen.h: +// Capture functions for the OpenGL ES Desktop GL 2.x entry points. + +#ifndef LIBANGLE_CAPTURE_GL_2_AUTOGEN_H_ +#define LIBANGLE_CAPTURE_GL_2_AUTOGEN_H_ + +#include "common/PackedEnums.h" +#include "libANGLE/capture/FrameCapture.h" + +namespace gl +{ + +// Method Captures + +// GL 2.0 +angle::CallCapture CaptureGetVertexAttribdv(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLdouble *params); +angle::CallCapture CaptureVertexAttrib1d(const State &glState, + bool isCallValid, + GLuint index, + GLdouble x); +angle::CallCapture CaptureVertexAttrib1dv(const State &glState, + bool isCallValid, + GLuint index, + const GLdouble *v); +angle::CallCapture CaptureVertexAttrib1s(const State &glState, + bool isCallValid, + GLuint index, + GLshort x); +angle::CallCapture CaptureVertexAttrib1sv(const State &glState, + bool isCallValid, + GLuint index, + const GLshort *v); +angle::CallCapture CaptureVertexAttrib2d(const State &glState, + bool isCallValid, + GLuint index, + GLdouble x, + GLdouble y); +angle::CallCapture CaptureVertexAttrib2dv(const State &glState, + bool isCallValid, + GLuint index, + const GLdouble *v); +angle::CallCapture CaptureVertexAttrib2s(const State &glState, + bool isCallValid, + GLuint index, + GLshort x, + GLshort y); +angle::CallCapture CaptureVertexAttrib2sv(const State &glState, + bool isCallValid, + GLuint index, + const GLshort *v); +angle::CallCapture CaptureVertexAttrib3d(const State &glState, + bool isCallValid, + GLuint index, + GLdouble x, + GLdouble y, + GLdouble z); +angle::CallCapture CaptureVertexAttrib3dv(const State &glState, + bool isCallValid, + GLuint index, + const GLdouble *v); +angle::CallCapture CaptureVertexAttrib3s(const State &glState, + bool isCallValid, + GLuint index, + GLshort x, + GLshort y, + GLshort z); +angle::CallCapture CaptureVertexAttrib3sv(const State &glState, + bool isCallValid, + GLuint index, + const GLshort *v); +angle::CallCapture CaptureVertexAttrib4Nbv(const State &glState, + bool isCallValid, + GLuint index, + const GLbyte *v); +angle::CallCapture CaptureVertexAttrib4Niv(const State &glState, + bool isCallValid, + GLuint index, + const GLint *v); +angle::CallCapture CaptureVertexAttrib4Nsv(const State &glState, + bool isCallValid, + GLuint index, + const GLshort *v); +angle::CallCapture CaptureVertexAttrib4Nub(const State &glState, + bool isCallValid, + GLuint index, + GLubyte x, + GLubyte y, + GLubyte z, + GLubyte w); +angle::CallCapture CaptureVertexAttrib4Nubv(const State &glState, + bool isCallValid, + GLuint index, + const GLubyte *v); +angle::CallCapture CaptureVertexAttrib4Nuiv(const State &glState, + bool isCallValid, + GLuint index, + const GLuint *v); +angle::CallCapture CaptureVertexAttrib4Nusv(const State &glState, + bool isCallValid, + GLuint index, + const GLushort *v); +angle::CallCapture CaptureVertexAttrib4bv(const State &glState, + bool isCallValid, + GLuint index, + const GLbyte *v); +angle::CallCapture CaptureVertexAttrib4d(const State &glState, + bool isCallValid, + GLuint index, + GLdouble x, + GLdouble y, + GLdouble z, + GLdouble w); +angle::CallCapture CaptureVertexAttrib4dv(const State &glState, + bool isCallValid, + GLuint index, + const GLdouble *v); +angle::CallCapture CaptureVertexAttrib4iv(const State &glState, + bool isCallValid, + GLuint index, + const GLint *v); +angle::CallCapture CaptureVertexAttrib4s(const State &glState, + bool isCallValid, + GLuint index, + GLshort x, + GLshort y, + GLshort z, + GLshort w); +angle::CallCapture CaptureVertexAttrib4sv(const State &glState, + bool isCallValid, + GLuint index, + const GLshort *v); +angle::CallCapture CaptureVertexAttrib4ubv(const State &glState, + bool isCallValid, + GLuint index, + const GLubyte *v); +angle::CallCapture CaptureVertexAttrib4uiv(const State &glState, + bool isCallValid, + GLuint index, + const GLuint *v); +angle::CallCapture CaptureVertexAttrib4usv(const State &glState, + bool isCallValid, + GLuint index, + const GLushort *v); + +// GL 2.1 + +// Parameter Captures + +// GL 2.0 +void CaptureGetVertexAttribdv_params(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLdouble *params, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib1dv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib1sv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib2dv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib2sv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib3dv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib3sv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib4Nbv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLbyte *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib4Niv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib4Nsv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib4Nubv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLubyte *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib4Nuiv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLuint *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib4Nusv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLushort *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib4bv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLbyte *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib4dv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib4iv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib4sv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib4ubv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLubyte *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib4uiv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLuint *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib4usv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLushort *v, + angle::ParamCapture *paramCapture); + +// GL 2.1 +} // namespace gl + +#endif // LIBANGLE_CAPTURE_GL_2_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gl_3_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gl_3_autogen.h new file mode 100644 index 0000000000..b365fbec7c --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gl_3_autogen.h @@ -0,0 +1,609 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml. +// +// 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. +// +// capture_gl_3_autogen.h: +// Capture functions for the OpenGL ES Desktop GL 3.x entry points. + +#ifndef LIBANGLE_CAPTURE_GL_3_AUTOGEN_H_ +#define LIBANGLE_CAPTURE_GL_3_AUTOGEN_H_ + +#include "common/PackedEnums.h" +#include "libANGLE/capture/FrameCapture.h" + +namespace gl +{ + +// Method Captures + +// GL 3.0 +angle::CallCapture CaptureBeginConditionalRender(const State &glState, + bool isCallValid, + GLuint id, + GLenum mode); +angle::CallCapture CaptureBindFragDataLocation(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint color, + const GLchar *name); +angle::CallCapture CaptureClampColor(const State &glState, + bool isCallValid, + GLenum target, + GLenum clamp); +angle::CallCapture CaptureEndConditionalRender(const State &glState, bool isCallValid); +angle::CallCapture CaptureFramebufferTexture1D(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + TextureTarget textargetPacked, + TextureID texturePacked, + GLint level); +angle::CallCapture CaptureFramebufferTexture3D(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + TextureTarget textargetPacked, + TextureID texturePacked, + GLint level, + GLint zoffset); +angle::CallCapture CaptureVertexAttribI1i(const State &glState, + bool isCallValid, + GLuint index, + GLint x); +angle::CallCapture CaptureVertexAttribI1iv(const State &glState, + bool isCallValid, + GLuint index, + const GLint *v); +angle::CallCapture CaptureVertexAttribI1ui(const State &glState, + bool isCallValid, + GLuint index, + GLuint x); +angle::CallCapture CaptureVertexAttribI1uiv(const State &glState, + bool isCallValid, + GLuint index, + const GLuint *v); +angle::CallCapture CaptureVertexAttribI2i(const State &glState, + bool isCallValid, + GLuint index, + GLint x, + GLint y); +angle::CallCapture CaptureVertexAttribI2iv(const State &glState, + bool isCallValid, + GLuint index, + const GLint *v); +angle::CallCapture CaptureVertexAttribI2ui(const State &glState, + bool isCallValid, + GLuint index, + GLuint x, + GLuint y); +angle::CallCapture CaptureVertexAttribI2uiv(const State &glState, + bool isCallValid, + GLuint index, + const GLuint *v); +angle::CallCapture CaptureVertexAttribI3i(const State &glState, + bool isCallValid, + GLuint index, + GLint x, + GLint y, + GLint z); +angle::CallCapture CaptureVertexAttribI3iv(const State &glState, + bool isCallValid, + GLuint index, + const GLint *v); +angle::CallCapture CaptureVertexAttribI3ui(const State &glState, + bool isCallValid, + GLuint index, + GLuint x, + GLuint y, + GLuint z); +angle::CallCapture CaptureVertexAttribI3uiv(const State &glState, + bool isCallValid, + GLuint index, + const GLuint *v); +angle::CallCapture CaptureVertexAttribI4bv(const State &glState, + bool isCallValid, + GLuint index, + const GLbyte *v); +angle::CallCapture CaptureVertexAttribI4sv(const State &glState, + bool isCallValid, + GLuint index, + const GLshort *v); +angle::CallCapture CaptureVertexAttribI4ubv(const State &glState, + bool isCallValid, + GLuint index, + const GLubyte *v); +angle::CallCapture CaptureVertexAttribI4usv(const State &glState, + bool isCallValid, + GLuint index, + const GLushort *v); + +// GL 3.1 +angle::CallCapture CaptureGetActiveUniformName(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint uniformIndex, + GLsizei bufSize, + GLsizei *length, + GLchar *uniformName); +angle::CallCapture CapturePrimitiveRestartIndex(const State &glState, + bool isCallValid, + GLuint index); + +// GL 3.2 +angle::CallCapture CaptureMultiDrawElementsBaseVertex(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *count, + DrawElementsType typePacked, + const void *const *indices, + GLsizei drawcount, + const GLint *basevertex); +angle::CallCapture CaptureProvokingVertex(const State &glState, + bool isCallValid, + ProvokingVertexConvention modePacked); +angle::CallCapture CaptureTexImage2DMultisample(const State &glState, + bool isCallValid, + GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLboolean fixedsamplelocations); +angle::CallCapture CaptureTexImage3DMultisample(const State &glState, + bool isCallValid, + GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedsamplelocations); + +// GL 3.3 +angle::CallCapture CaptureBindFragDataLocationIndexed(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint colorNumber, + GLuint index, + const GLchar *name); +angle::CallCapture CaptureColorP3ui(const State &glState, + bool isCallValid, + GLenum type, + GLuint color); +angle::CallCapture CaptureColorP3uiv(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *color); +angle::CallCapture CaptureColorP4ui(const State &glState, + bool isCallValid, + GLenum type, + GLuint color); +angle::CallCapture CaptureColorP4uiv(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *color); +angle::CallCapture CaptureGetFragDataIndex(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + const GLchar *name, + GLint returnValue); +angle::CallCapture CaptureGetQueryObjecti64v(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLint64 *params); +angle::CallCapture CaptureGetQueryObjectui64v(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLuint64 *params); +angle::CallCapture CaptureMultiTexCoordP1ui(const State &glState, + bool isCallValid, + GLenum texture, + GLenum type, + GLuint coords); +angle::CallCapture CaptureMultiTexCoordP1uiv(const State &glState, + bool isCallValid, + GLenum texture, + GLenum type, + const GLuint *coords); +angle::CallCapture CaptureMultiTexCoordP2ui(const State &glState, + bool isCallValid, + GLenum texture, + GLenum type, + GLuint coords); +angle::CallCapture CaptureMultiTexCoordP2uiv(const State &glState, + bool isCallValid, + GLenum texture, + GLenum type, + const GLuint *coords); +angle::CallCapture CaptureMultiTexCoordP3ui(const State &glState, + bool isCallValid, + GLenum texture, + GLenum type, + GLuint coords); +angle::CallCapture CaptureMultiTexCoordP3uiv(const State &glState, + bool isCallValid, + GLenum texture, + GLenum type, + const GLuint *coords); +angle::CallCapture CaptureMultiTexCoordP4ui(const State &glState, + bool isCallValid, + GLenum texture, + GLenum type, + GLuint coords); +angle::CallCapture CaptureMultiTexCoordP4uiv(const State &glState, + bool isCallValid, + GLenum texture, + GLenum type, + const GLuint *coords); +angle::CallCapture CaptureNormalP3ui(const State &glState, + bool isCallValid, + GLenum type, + GLuint coords); +angle::CallCapture CaptureNormalP3uiv(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *coords); +angle::CallCapture CaptureQueryCounter(const State &glState, + bool isCallValid, + QueryID idPacked, + QueryType targetPacked); +angle::CallCapture CaptureSecondaryColorP3ui(const State &glState, + bool isCallValid, + GLenum type, + GLuint color); +angle::CallCapture CaptureSecondaryColorP3uiv(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *color); +angle::CallCapture CaptureTexCoordP1ui(const State &glState, + bool isCallValid, + GLenum type, + GLuint coords); +angle::CallCapture CaptureTexCoordP1uiv(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *coords); +angle::CallCapture CaptureTexCoordP2ui(const State &glState, + bool isCallValid, + GLenum type, + GLuint coords); +angle::CallCapture CaptureTexCoordP2uiv(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *coords); +angle::CallCapture CaptureTexCoordP3ui(const State &glState, + bool isCallValid, + GLenum type, + GLuint coords); +angle::CallCapture CaptureTexCoordP3uiv(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *coords); +angle::CallCapture CaptureTexCoordP4ui(const State &glState, + bool isCallValid, + GLenum type, + GLuint coords); +angle::CallCapture CaptureTexCoordP4uiv(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *coords); +angle::CallCapture CaptureVertexAttribP1ui(const State &glState, + bool isCallValid, + GLuint index, + GLenum type, + GLboolean normalized, + GLuint value); +angle::CallCapture CaptureVertexAttribP1uiv(const State &glState, + bool isCallValid, + GLuint index, + GLenum type, + GLboolean normalized, + const GLuint *value); +angle::CallCapture CaptureVertexAttribP2ui(const State &glState, + bool isCallValid, + GLuint index, + GLenum type, + GLboolean normalized, + GLuint value); +angle::CallCapture CaptureVertexAttribP2uiv(const State &glState, + bool isCallValid, + GLuint index, + GLenum type, + GLboolean normalized, + const GLuint *value); +angle::CallCapture CaptureVertexAttribP3ui(const State &glState, + bool isCallValid, + GLuint index, + GLenum type, + GLboolean normalized, + GLuint value); +angle::CallCapture CaptureVertexAttribP3uiv(const State &glState, + bool isCallValid, + GLuint index, + GLenum type, + GLboolean normalized, + const GLuint *value); +angle::CallCapture CaptureVertexAttribP4ui(const State &glState, + bool isCallValid, + GLuint index, + GLenum type, + GLboolean normalized, + GLuint value); +angle::CallCapture CaptureVertexAttribP4uiv(const State &glState, + bool isCallValid, + GLuint index, + GLenum type, + GLboolean normalized, + const GLuint *value); +angle::CallCapture CaptureVertexP2ui(const State &glState, + bool isCallValid, + GLenum type, + GLuint value); +angle::CallCapture CaptureVertexP2uiv(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *value); +angle::CallCapture CaptureVertexP3ui(const State &glState, + bool isCallValid, + GLenum type, + GLuint value); +angle::CallCapture CaptureVertexP3uiv(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *value); +angle::CallCapture CaptureVertexP4ui(const State &glState, + bool isCallValid, + GLenum type, + GLuint value); +angle::CallCapture CaptureVertexP4uiv(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *value); + +// Parameter Captures + +// GL 3.0 +void CaptureBindFragDataLocation_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint color, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribI1iv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribI1uiv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLuint *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribI2iv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribI2uiv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLuint *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribI3iv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribI3uiv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLuint *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribI4bv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLbyte *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribI4sv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLshort *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribI4ubv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLubyte *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribI4usv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLushort *v, + angle::ParamCapture *paramCapture); + +// GL 3.1 +void CaptureGetActiveUniformName_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint uniformIndex, + GLsizei bufSize, + GLsizei *length, + GLchar *uniformName, + angle::ParamCapture *paramCapture); +void CaptureGetActiveUniformName_uniformName(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint uniformIndex, + GLsizei bufSize, + GLsizei *length, + GLchar *uniformName, + angle::ParamCapture *paramCapture); + +// GL 3.2 +void CaptureMultiDrawElementsBaseVertex_count(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *count, + DrawElementsType typePacked, + const void *const *indices, + GLsizei drawcount, + const GLint *basevertex, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsBaseVertex_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *count, + DrawElementsType typePacked, + const void *const *indices, + GLsizei drawcount, + const GLint *basevertex, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsBaseVertex_basevertex(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *count, + DrawElementsType typePacked, + const void *const *indices, + GLsizei drawcount, + const GLint *basevertex, + angle::ParamCapture *paramCapture); + +// GL 3.3 +void CaptureBindFragDataLocationIndexed_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint colorNumber, + GLuint index, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureColorP3uiv_color(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *color, + angle::ParamCapture *paramCapture); +void CaptureColorP4uiv_color(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *color, + angle::ParamCapture *paramCapture); +void CaptureGetFragDataIndex_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetQueryObjecti64v_params(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLint64 *params, + angle::ParamCapture *paramCapture); +void CaptureGetQueryObjectui64v_params(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLuint64 *params, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoordP1uiv_coords(const State &glState, + bool isCallValid, + GLenum texture, + GLenum type, + const GLuint *coords, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoordP2uiv_coords(const State &glState, + bool isCallValid, + GLenum texture, + GLenum type, + const GLuint *coords, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoordP3uiv_coords(const State &glState, + bool isCallValid, + GLenum texture, + GLenum type, + const GLuint *coords, + angle::ParamCapture *paramCapture); +void CaptureMultiTexCoordP4uiv_coords(const State &glState, + bool isCallValid, + GLenum texture, + GLenum type, + const GLuint *coords, + angle::ParamCapture *paramCapture); +void CaptureNormalP3uiv_coords(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *coords, + angle::ParamCapture *paramCapture); +void CaptureSecondaryColorP3uiv_color(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *color, + angle::ParamCapture *paramCapture); +void CaptureTexCoordP1uiv_coords(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *coords, + angle::ParamCapture *paramCapture); +void CaptureTexCoordP2uiv_coords(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *coords, + angle::ParamCapture *paramCapture); +void CaptureTexCoordP3uiv_coords(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *coords, + angle::ParamCapture *paramCapture); +void CaptureTexCoordP4uiv_coords(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *coords, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribP1uiv_value(const State &glState, + bool isCallValid, + GLuint index, + GLenum type, + GLboolean normalized, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribP2uiv_value(const State &glState, + bool isCallValid, + GLuint index, + GLenum type, + GLboolean normalized, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribP3uiv_value(const State &glState, + bool isCallValid, + GLuint index, + GLenum type, + GLboolean normalized, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribP4uiv_value(const State &glState, + bool isCallValid, + GLuint index, + GLenum type, + GLboolean normalized, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureVertexP2uiv_value(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureVertexP3uiv_value(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureVertexP4uiv_value(const State &glState, + bool isCallValid, + GLenum type, + const GLuint *value, + angle::ParamCapture *paramCapture); +} // namespace gl + +#endif // LIBANGLE_CAPTURE_GL_3_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gl_4_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gl_4_autogen.h new file mode 100644 index 0000000000..495bf4cb7f --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gl_4_autogen.h @@ -0,0 +1,2524 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml. +// +// 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. +// +// capture_gl_4_autogen.h: +// Capture functions for the OpenGL ES Desktop GL 4.x entry points. + +#ifndef LIBANGLE_CAPTURE_GL_4_AUTOGEN_H_ +#define LIBANGLE_CAPTURE_GL_4_AUTOGEN_H_ + +#include "common/PackedEnums.h" +#include "libANGLE/capture/FrameCapture.h" + +namespace gl +{ + +// Method Captures + +// GL 4.0 +angle::CallCapture CaptureBeginQueryIndexed(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + QueryID idPacked); +angle::CallCapture CaptureDrawTransformFeedback(const State &glState, + bool isCallValid, + GLenum mode, + TransformFeedbackID idPacked); +angle::CallCapture CaptureDrawTransformFeedbackStream(const State &glState, + bool isCallValid, + GLenum mode, + TransformFeedbackID idPacked, + GLuint stream); +angle::CallCapture CaptureEndQueryIndexed(const State &glState, + bool isCallValid, + GLenum target, + GLuint index); +angle::CallCapture CaptureGetActiveSubroutineName(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum shadertype, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLchar *name); +angle::CallCapture CaptureGetActiveSubroutineUniformName(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum shadertype, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLchar *name); +angle::CallCapture CaptureGetActiveSubroutineUniformiv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum shadertype, + GLuint index, + GLenum pname, + GLint *values); +angle::CallCapture CaptureGetProgramStageiv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum shadertype, + GLenum pname, + GLint *values); +angle::CallCapture CaptureGetQueryIndexediv(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetSubroutineIndex(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum shadertype, + const GLchar *name, + GLuint returnValue); +angle::CallCapture CaptureGetSubroutineUniformLocation(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum shadertype, + const GLchar *name, + GLint returnValue); +angle::CallCapture CaptureGetUniformSubroutineuiv(const State &glState, + bool isCallValid, + GLenum shadertype, + GLint location, + GLuint *params); +angle::CallCapture CaptureGetUniformdv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLdouble *params); +angle::CallCapture CapturePatchParameterfv(const State &glState, + bool isCallValid, + GLenum pname, + const GLfloat *values); +angle::CallCapture CaptureUniform1d(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLdouble x); +angle::CallCapture CaptureUniform1dv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLdouble *value); +angle::CallCapture CaptureUniform2d(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLdouble x, + GLdouble y); +angle::CallCapture CaptureUniform2dv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLdouble *value); +angle::CallCapture CaptureUniform3d(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLdouble x, + GLdouble y, + GLdouble z); +angle::CallCapture CaptureUniform3dv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLdouble *value); +angle::CallCapture CaptureUniform4d(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLdouble x, + GLdouble y, + GLdouble z, + GLdouble w); +angle::CallCapture CaptureUniform4dv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLdouble *value); +angle::CallCapture CaptureUniformMatrix2dv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureUniformMatrix2x3dv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureUniformMatrix2x4dv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureUniformMatrix3dv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureUniformMatrix3x2dv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureUniformMatrix3x4dv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureUniformMatrix4dv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureUniformMatrix4x2dv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureUniformMatrix4x3dv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureUniformSubroutinesuiv(const State &glState, + bool isCallValid, + GLenum shadertype, + GLsizei count, + const GLuint *indices); + +// GL 4.1 +angle::CallCapture CaptureDepthRangeArrayv(const State &glState, + bool isCallValid, + GLuint first, + GLsizei count, + const GLdouble *v); +angle::CallCapture CaptureDepthRangeIndexed(const State &glState, + bool isCallValid, + GLuint index, + GLdouble n, + GLdouble f); +angle::CallCapture CaptureGetDoublei_v(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLdouble *data); +angle::CallCapture CaptureGetFloati_v(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLfloat *data); +angle::CallCapture CaptureGetVertexAttribLdv(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLdouble *params); +angle::CallCapture CaptureProgramUniform1d(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLdouble v0); +angle::CallCapture CaptureProgramUniform1dv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLdouble *value); +angle::CallCapture CaptureProgramUniform2d(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLdouble v0, + GLdouble v1); +angle::CallCapture CaptureProgramUniform2dv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLdouble *value); +angle::CallCapture CaptureProgramUniform3d(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLdouble v0, + GLdouble v1, + GLdouble v2); +angle::CallCapture CaptureProgramUniform3dv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLdouble *value); +angle::CallCapture CaptureProgramUniform4d(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLdouble v0, + GLdouble v1, + GLdouble v2, + GLdouble v3); +angle::CallCapture CaptureProgramUniform4dv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLdouble *value); +angle::CallCapture CaptureProgramUniformMatrix2dv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureProgramUniformMatrix2x3dv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureProgramUniformMatrix2x4dv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureProgramUniformMatrix3dv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureProgramUniformMatrix3x2dv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureProgramUniformMatrix3x4dv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureProgramUniformMatrix4dv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureProgramUniformMatrix4x2dv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureProgramUniformMatrix4x3dv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value); +angle::CallCapture CaptureScissorArrayv(const State &glState, + bool isCallValid, + GLuint first, + GLsizei count, + const GLint *v); +angle::CallCapture CaptureScissorIndexed(const State &glState, + bool isCallValid, + GLuint index, + GLint left, + GLint bottom, + GLsizei width, + GLsizei height); +angle::CallCapture CaptureScissorIndexedv(const State &glState, + bool isCallValid, + GLuint index, + const GLint *v); +angle::CallCapture CaptureVertexAttribL1d(const State &glState, + bool isCallValid, + GLuint index, + GLdouble x); +angle::CallCapture CaptureVertexAttribL1dv(const State &glState, + bool isCallValid, + GLuint index, + const GLdouble *v); +angle::CallCapture CaptureVertexAttribL2d(const State &glState, + bool isCallValid, + GLuint index, + GLdouble x, + GLdouble y); +angle::CallCapture CaptureVertexAttribL2dv(const State &glState, + bool isCallValid, + GLuint index, + const GLdouble *v); +angle::CallCapture CaptureVertexAttribL3d(const State &glState, + bool isCallValid, + GLuint index, + GLdouble x, + GLdouble y, + GLdouble z); +angle::CallCapture CaptureVertexAttribL3dv(const State &glState, + bool isCallValid, + GLuint index, + const GLdouble *v); +angle::CallCapture CaptureVertexAttribL4d(const State &glState, + bool isCallValid, + GLuint index, + GLdouble x, + GLdouble y, + GLdouble z, + GLdouble w); +angle::CallCapture CaptureVertexAttribL4dv(const State &glState, + bool isCallValid, + GLuint index, + const GLdouble *v); +angle::CallCapture CaptureVertexAttribLPointer(const State &glState, + bool isCallValid, + GLuint index, + GLint size, + GLenum type, + GLsizei stride, + const void *pointer); +angle::CallCapture CaptureViewportArrayv(const State &glState, + bool isCallValid, + GLuint first, + GLsizei count, + const GLfloat *v); +angle::CallCapture CaptureViewportIndexedf(const State &glState, + bool isCallValid, + GLuint index, + GLfloat x, + GLfloat y, + GLfloat w, + GLfloat h); +angle::CallCapture CaptureViewportIndexedfv(const State &glState, + bool isCallValid, + GLuint index, + const GLfloat *v); + +// GL 4.2 +angle::CallCapture CaptureDrawArraysInstancedBaseInstance(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLint first, + GLsizei count, + GLsizei instancecount, + GLuint baseinstance); +angle::CallCapture CaptureDrawElementsInstancedBaseInstance(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei instancecount, + GLuint baseinstance); +angle::CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstance(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei instancecount, + GLint basevertex, + GLuint baseinstance); +angle::CallCapture CaptureDrawTransformFeedbackInstanced(const State &glState, + bool isCallValid, + GLenum mode, + TransformFeedbackID idPacked, + GLsizei instancecount); +angle::CallCapture CaptureDrawTransformFeedbackStreamInstanced(const State &glState, + bool isCallValid, + GLenum mode, + TransformFeedbackID idPacked, + GLuint stream, + GLsizei instancecount); +angle::CallCapture CaptureGetActiveAtomicCounterBufferiv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint bufferIndex, + GLenum pname, + GLint *params); +angle::CallCapture CaptureTexStorage1D(const State &glState, + bool isCallValid, + GLenum target, + GLsizei levels, + GLenum internalformat, + GLsizei width); + +// GL 4.3 +angle::CallCapture CaptureClearBufferData(const State &glState, + bool isCallValid, + GLenum target, + GLenum internalformat, + GLenum format, + GLenum type, + const void *data); +angle::CallCapture CaptureClearBufferSubData(const State &glState, + bool isCallValid, + GLenum target, + GLenum internalformat, + GLintptr offset, + GLsizeiptr size, + GLenum format, + GLenum type, + const void *data); +angle::CallCapture CaptureGetInternalformati64v(const State &glState, + bool isCallValid, + GLenum target, + GLenum internalformat, + GLenum pname, + GLsizei count, + GLint64 *params); +angle::CallCapture CaptureGetProgramResourceLocationIndex(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + const GLchar *name, + GLint returnValue); +angle::CallCapture CaptureInvalidateBufferData(const State &glState, + bool isCallValid, + BufferID bufferPacked); +angle::CallCapture CaptureInvalidateBufferSubData(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLintptr offset, + GLsizeiptr length); +angle::CallCapture CaptureInvalidateTexImage(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level); +angle::CallCapture CaptureInvalidateTexSubImage(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth); +angle::CallCapture CaptureMultiDrawArraysIndirect(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const void *indirect, + GLsizei drawcount, + GLsizei stride); +angle::CallCapture CaptureMultiDrawElementsIndirect(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + DrawElementsType typePacked, + const void *indirect, + GLsizei drawcount, + GLsizei stride); +angle::CallCapture CaptureShaderStorageBlockBinding(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint storageBlockIndex, + GLuint storageBlockBinding); +angle::CallCapture CaptureTextureView(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum target, + GLuint origtexture, + GLenum internalformat, + GLuint minlevel, + GLuint numlevels, + GLuint minlayer, + GLuint numlayers); +angle::CallCapture CaptureVertexAttribLFormat(const State &glState, + bool isCallValid, + GLuint attribindex, + GLint size, + GLenum type, + GLuint relativeoffset); + +// GL 4.4 +angle::CallCapture CaptureBindBuffersBase(const State &glState, + bool isCallValid, + GLenum target, + GLuint first, + GLsizei count, + const BufferID *buffersPacked); +angle::CallCapture CaptureBindBuffersRange(const State &glState, + bool isCallValid, + GLenum target, + GLuint first, + GLsizei count, + const BufferID *buffersPacked, + const GLintptr *offsets, + const GLsizeiptr *sizes); +angle::CallCapture CaptureBindImageTextures(const State &glState, + bool isCallValid, + GLuint first, + GLsizei count, + const GLuint *textures); +angle::CallCapture CaptureBindSamplers(const State &glState, + bool isCallValid, + GLuint first, + GLsizei count, + const GLuint *samplers); +angle::CallCapture CaptureBindTextures(const State &glState, + bool isCallValid, + GLuint first, + GLsizei count, + const GLuint *textures); +angle::CallCapture CaptureBindVertexBuffers(const State &glState, + bool isCallValid, + GLuint first, + GLsizei count, + const BufferID *buffersPacked, + const GLintptr *offsets, + const GLsizei *strides); +angle::CallCapture CaptureBufferStorage(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLsizeiptr size, + const void *data, + GLbitfield flags); +angle::CallCapture CaptureClearTexImage(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLenum format, + GLenum type, + const void *data); +angle::CallCapture CaptureClearTexSubImage(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + const void *data); + +// GL 4.5 +angle::CallCapture CaptureBindTextureUnit(const State &glState, + bool isCallValid, + GLuint unit, + TextureID texturePacked); +angle::CallCapture CaptureBlitNamedFramebuffer(const State &glState, + bool isCallValid, + GLuint readFramebuffer, + GLuint drawFramebuffer, + GLint srcX0, + GLint srcY0, + GLint srcX1, + GLint srcY1, + GLint dstX0, + GLint dstY0, + GLint dstX1, + GLint dstY1, + GLbitfield mask, + GLenum filter); +angle::CallCapture CaptureCheckNamedFramebufferStatus(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum target, + GLenum returnValue); +angle::CallCapture CaptureClearNamedBufferData(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLenum internalformat, + GLenum format, + GLenum type, + const void *data); +angle::CallCapture CaptureClearNamedBufferSubData(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLenum internalformat, + GLintptr offset, + GLsizeiptr size, + GLenum format, + GLenum type, + const void *data); +angle::CallCapture CaptureClearNamedFramebufferfi(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum buffer, + GLint drawbuffer, + GLfloat depth, + GLint stencil); +angle::CallCapture CaptureClearNamedFramebufferfv(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum buffer, + GLint drawbuffer, + const GLfloat *value); +angle::CallCapture CaptureClearNamedFramebufferiv(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum buffer, + GLint drawbuffer, + const GLint *value); +angle::CallCapture CaptureClearNamedFramebufferuiv(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum buffer, + GLint drawbuffer, + const GLuint *value); +angle::CallCapture CaptureClipControl(const State &glState, + bool isCallValid, + GLenum origin, + GLenum depth); +angle::CallCapture CaptureCompressedTextureSubImage1D(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLsizei width, + GLenum format, + GLsizei imageSize, + const void *data); +angle::CallCapture CaptureCompressedTextureSubImage2D(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLsizei imageSize, + const void *data); +angle::CallCapture CaptureCompressedTextureSubImage3D(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + const void *data); +angle::CallCapture CaptureCopyNamedBufferSubData(const State &glState, + bool isCallValid, + GLuint readBuffer, + GLuint writeBuffer, + GLintptr readOffset, + GLintptr writeOffset, + GLsizeiptr size); +angle::CallCapture CaptureCopyTextureSubImage1D(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint x, + GLint y, + GLsizei width); +angle::CallCapture CaptureCopyTextureSubImage2D(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint x, + GLint y, + GLsizei width, + GLsizei height); +angle::CallCapture CaptureCopyTextureSubImage3D(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLint x, + GLint y, + GLsizei width, + GLsizei height); +angle::CallCapture CaptureCreateBuffers(const State &glState, + bool isCallValid, + GLsizei n, + BufferID *buffersPacked); +angle::CallCapture CaptureCreateFramebuffers(const State &glState, + bool isCallValid, + GLsizei n, + GLuint *framebuffers); +angle::CallCapture CaptureCreateProgramPipelines(const State &glState, + bool isCallValid, + GLsizei n, + GLuint *pipelines); +angle::CallCapture CaptureCreateQueries(const State &glState, + bool isCallValid, + GLenum target, + GLsizei n, + GLuint *ids); +angle::CallCapture CaptureCreateRenderbuffers(const State &glState, + bool isCallValid, + GLsizei n, + RenderbufferID *renderbuffersPacked); +angle::CallCapture CaptureCreateSamplers(const State &glState, + bool isCallValid, + GLsizei n, + GLuint *samplers); +angle::CallCapture CaptureCreateTextures(const State &glState, + bool isCallValid, + GLenum target, + GLsizei n, + GLuint *textures); +angle::CallCapture CaptureCreateTransformFeedbacks(const State &glState, + bool isCallValid, + GLsizei n, + GLuint *ids); +angle::CallCapture CaptureCreateVertexArrays(const State &glState, + bool isCallValid, + GLsizei n, + VertexArrayID *arraysPacked); +angle::CallCapture CaptureDisableVertexArrayAttrib(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLuint index); +angle::CallCapture CaptureEnableVertexArrayAttrib(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLuint index); +angle::CallCapture CaptureFlushMappedNamedBufferRange(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLintptr offset, + GLsizeiptr length); +angle::CallCapture CaptureGenerateTextureMipmap(const State &glState, + bool isCallValid, + TextureID texturePacked); +angle::CallCapture CaptureGetCompressedTextureImage(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLsizei bufSize, + void *pixels); +angle::CallCapture CaptureGetCompressedTextureSubImage(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLsizei bufSize, + void *pixels); +angle::CallCapture CaptureGetNamedBufferParameteri64v(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLenum pname, + GLint64 *params); +angle::CallCapture CaptureGetNamedBufferParameteriv(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetNamedBufferPointerv(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLenum pname, + void **params); +angle::CallCapture CaptureGetNamedBufferSubData(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLintptr offset, + GLsizeiptr size, + void *data); +angle::CallCapture CaptureGetNamedFramebufferAttachmentParameteriv(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum attachment, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetNamedFramebufferParameteriv(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum pname, + GLint *param); +angle::CallCapture CaptureGetNamedRenderbufferParameteriv(const State &glState, + bool isCallValid, + RenderbufferID renderbufferPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetQueryBufferObjecti64v(const State &glState, + bool isCallValid, + GLuint id, + BufferID bufferPacked, + GLenum pname, + GLintptr offset); +angle::CallCapture CaptureGetQueryBufferObjectiv(const State &glState, + bool isCallValid, + GLuint id, + BufferID bufferPacked, + GLenum pname, + GLintptr offset); +angle::CallCapture CaptureGetQueryBufferObjectui64v(const State &glState, + bool isCallValid, + GLuint id, + BufferID bufferPacked, + GLenum pname, + GLintptr offset); +angle::CallCapture CaptureGetQueryBufferObjectuiv(const State &glState, + bool isCallValid, + GLuint id, + BufferID bufferPacked, + GLenum pname, + GLintptr offset); +angle::CallCapture CaptureGetTextureImage(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLenum format, + GLenum type, + GLsizei bufSize, + void *pixels); +angle::CallCapture CaptureGetTextureLevelParameterfv(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLenum pname, + GLfloat *params); +angle::CallCapture CaptureGetTextureLevelParameteriv(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetTextureParameterIiv(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetTextureParameterIuiv(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + GLuint *params); +angle::CallCapture CaptureGetTextureParameterfv(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + GLfloat *params); +angle::CallCapture CaptureGetTextureParameteriv(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetTextureSubImage(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + GLsizei bufSize, + void *pixels); +angle::CallCapture CaptureGetTransformFeedbacki64_v(const State &glState, + bool isCallValid, + GLuint xfb, + GLenum pname, + GLuint index, + GLint64 *param); +angle::CallCapture CaptureGetTransformFeedbacki_v(const State &glState, + bool isCallValid, + GLuint xfb, + GLenum pname, + GLuint index, + GLint *param); +angle::CallCapture CaptureGetTransformFeedbackiv(const State &glState, + bool isCallValid, + GLuint xfb, + GLenum pname, + GLint *param); +angle::CallCapture CaptureGetVertexArrayIndexed64iv(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLuint index, + GLenum pname, + GLint64 *param); +angle::CallCapture CaptureGetVertexArrayIndexediv(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLuint index, + GLenum pname, + GLint *param); +angle::CallCapture CaptureGetVertexArrayiv(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLenum pname, + GLint *param); +angle::CallCapture CaptureGetnColorTable(const State &glState, + bool isCallValid, + GLenum target, + GLenum format, + GLenum type, + GLsizei bufSize, + void *table); +angle::CallCapture CaptureGetnCompressedTexImage(const State &glState, + bool isCallValid, + GLenum target, + GLint lod, + GLsizei bufSize, + void *pixels); +angle::CallCapture CaptureGetnConvolutionFilter(const State &glState, + bool isCallValid, + GLenum target, + GLenum format, + GLenum type, + GLsizei bufSize, + void *image); +angle::CallCapture CaptureGetnHistogram(const State &glState, + bool isCallValid, + GLenum target, + GLboolean reset, + GLenum format, + GLenum type, + GLsizei bufSize, + void *values); +angle::CallCapture CaptureGetnMapdv(const State &glState, + bool isCallValid, + GLenum target, + GLenum query, + GLsizei bufSize, + GLdouble *v); +angle::CallCapture CaptureGetnMapfv(const State &glState, + bool isCallValid, + GLenum target, + GLenum query, + GLsizei bufSize, + GLfloat *v); +angle::CallCapture CaptureGetnMapiv(const State &glState, + bool isCallValid, + GLenum target, + GLenum query, + GLsizei bufSize, + GLint *v); +angle::CallCapture CaptureGetnMinmax(const State &glState, + bool isCallValid, + GLenum target, + GLboolean reset, + GLenum format, + GLenum type, + GLsizei bufSize, + void *values); +angle::CallCapture CaptureGetnPixelMapfv(const State &glState, + bool isCallValid, + GLenum map, + GLsizei bufSize, + GLfloat *values); +angle::CallCapture CaptureGetnPixelMapuiv(const State &glState, + bool isCallValid, + GLenum map, + GLsizei bufSize, + GLuint *values); +angle::CallCapture CaptureGetnPixelMapusv(const State &glState, + bool isCallValid, + GLenum map, + GLsizei bufSize, + GLushort *values); +angle::CallCapture CaptureGetnPolygonStipple(const State &glState, + bool isCallValid, + GLsizei bufSize, + GLubyte *pattern); +angle::CallCapture CaptureGetnSeparableFilter(const State &glState, + bool isCallValid, + GLenum target, + GLenum format, + GLenum type, + GLsizei rowBufSize, + void *row, + GLsizei columnBufSize, + void *column, + void *span); +angle::CallCapture CaptureGetnTexImage(const State &glState, + bool isCallValid, + GLenum target, + GLint level, + GLenum format, + GLenum type, + GLsizei bufSize, + void *pixels); +angle::CallCapture CaptureGetnUniformdv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLdouble *params); +angle::CallCapture CaptureInvalidateNamedFramebufferData(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLsizei numAttachments, + const GLenum *attachments); +angle::CallCapture CaptureInvalidateNamedFramebufferSubData(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLsizei numAttachments, + const GLenum *attachments, + GLint x, + GLint y, + GLsizei width, + GLsizei height); +angle::CallCapture CaptureMapNamedBuffer(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLenum access, + void *returnValue); +angle::CallCapture CaptureMapNamedBufferRange(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLintptr offset, + GLsizeiptr length, + GLbitfield access, + void *returnValue); +angle::CallCapture CaptureNamedBufferData(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLsizeiptr size, + const void *data, + GLenum usage); +angle::CallCapture CaptureNamedBufferStorage(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLsizeiptr size, + const void *data, + GLbitfield flags); +angle::CallCapture CaptureNamedBufferSubData(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLintptr offset, + GLsizeiptr size, + const void *data); +angle::CallCapture CaptureNamedFramebufferDrawBuffer(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum buf); +angle::CallCapture CaptureNamedFramebufferDrawBuffers(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLsizei n, + const GLenum *bufs); +angle::CallCapture CaptureNamedFramebufferParameteri(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum pname, + GLint param); +angle::CallCapture CaptureNamedFramebufferReadBuffer(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum src); +angle::CallCapture CaptureNamedFramebufferRenderbuffer(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum attachment, + GLenum renderbuffertarget, + RenderbufferID renderbufferPacked); +angle::CallCapture CaptureNamedFramebufferTexture(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum attachment, + TextureID texturePacked, + GLint level); +angle::CallCapture CaptureNamedFramebufferTextureLayer(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum attachment, + TextureID texturePacked, + GLint level, + GLint layer); +angle::CallCapture CaptureNamedRenderbufferStorage(const State &glState, + bool isCallValid, + RenderbufferID renderbufferPacked, + GLenum internalformat, + GLsizei width, + GLsizei height); +angle::CallCapture CaptureNamedRenderbufferStorageMultisample(const State &glState, + bool isCallValid, + RenderbufferID renderbufferPacked, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height); +angle::CallCapture CaptureTextureBarrier(const State &glState, bool isCallValid); +angle::CallCapture CaptureTextureBuffer(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum internalformat, + BufferID bufferPacked); +angle::CallCapture CaptureTextureBufferRange(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum internalformat, + BufferID bufferPacked, + GLintptr offset, + GLsizeiptr size); +angle::CallCapture CaptureTextureParameterIiv(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + const GLint *params); +angle::CallCapture CaptureTextureParameterIuiv(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + const GLuint *params); +angle::CallCapture CaptureTextureParameterf(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + GLfloat param); +angle::CallCapture CaptureTextureParameterfv(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + const GLfloat *param); +angle::CallCapture CaptureTextureParameteri(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + GLint param); +angle::CallCapture CaptureTextureParameteriv(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + const GLint *param); +angle::CallCapture CaptureTextureStorage1D(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLsizei levels, + GLenum internalformat, + GLsizei width); +angle::CallCapture CaptureTextureStorage2D(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height); +angle::CallCapture CaptureTextureStorage2DMultisample(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLboolean fixedsamplelocations); +angle::CallCapture CaptureTextureStorage3D(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth); +angle::CallCapture CaptureTextureStorage3DMultisample(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedsamplelocations); +angle::CallCapture CaptureTextureSubImage1D(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLsizei width, + GLenum format, + GLenum type, + const void *pixels); +angle::CallCapture CaptureTextureSubImage2D(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + const void *pixels); +angle::CallCapture CaptureTextureSubImage3D(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + const void *pixels); +angle::CallCapture CaptureTransformFeedbackBufferBase(const State &glState, + bool isCallValid, + GLuint xfb, + GLuint index, + BufferID bufferPacked); +angle::CallCapture CaptureTransformFeedbackBufferRange(const State &glState, + bool isCallValid, + GLuint xfb, + GLuint index, + BufferID bufferPacked, + GLintptr offset, + GLsizeiptr size); +angle::CallCapture CaptureUnmapNamedBuffer(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLboolean returnValue); +angle::CallCapture CaptureVertexArrayAttribBinding(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLuint attribindex, + GLuint bindingindex); +angle::CallCapture CaptureVertexArrayAttribFormat(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLuint attribindex, + GLint size, + GLenum type, + GLboolean normalized, + GLuint relativeoffset); +angle::CallCapture CaptureVertexArrayAttribIFormat(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLuint attribindex, + GLint size, + GLenum type, + GLuint relativeoffset); +angle::CallCapture CaptureVertexArrayAttribLFormat(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLuint attribindex, + GLint size, + GLenum type, + GLuint relativeoffset); +angle::CallCapture CaptureVertexArrayBindingDivisor(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLuint bindingindex, + GLuint divisor); +angle::CallCapture CaptureVertexArrayElementBuffer(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + BufferID bufferPacked); +angle::CallCapture CaptureVertexArrayVertexBuffer(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLuint bindingindex, + BufferID bufferPacked, + GLintptr offset, + GLsizei stride); +angle::CallCapture CaptureVertexArrayVertexBuffers(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLuint first, + GLsizei count, + const BufferID *buffersPacked, + const GLintptr *offsets, + const GLsizei *strides); + +// GL 4.6 +angle::CallCapture CaptureMultiDrawArraysIndirectCount(const State &glState, + bool isCallValid, + GLenum mode, + const void *indirect, + GLintptr drawcount, + GLsizei maxdrawcount, + GLsizei stride); +angle::CallCapture CaptureMultiDrawElementsIndirectCount(const State &glState, + bool isCallValid, + GLenum mode, + GLenum type, + const void *indirect, + GLintptr drawcount, + GLsizei maxdrawcount, + GLsizei stride); +angle::CallCapture CapturePolygonOffsetClamp(const State &glState, + bool isCallValid, + GLfloat factor, + GLfloat units, + GLfloat clamp); +angle::CallCapture CaptureSpecializeShader(const State &glState, + bool isCallValid, + GLuint shader, + const GLchar *pEntryPoint, + GLuint numSpecializationConstants, + const GLuint *pConstantIndex, + const GLuint *pConstantValue); + +// Parameter Captures + +// GL 4.0 +void CaptureGetActiveSubroutineName_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum shadertype, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetActiveSubroutineName_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum shadertype, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetActiveSubroutineUniformName_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum shadertype, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetActiveSubroutineUniformName_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum shadertype, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetActiveSubroutineUniformiv_values(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum shadertype, + GLuint index, + GLenum pname, + GLint *values, + angle::ParamCapture *paramCapture); +void CaptureGetProgramStageiv_values(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum shadertype, + GLenum pname, + GLint *values, + angle::ParamCapture *paramCapture); +void CaptureGetQueryIndexediv_params(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetSubroutineIndex_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum shadertype, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetSubroutineUniformLocation_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum shadertype, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetUniformSubroutineuiv_params(const State &glState, + bool isCallValid, + GLenum shadertype, + GLint location, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetUniformdv_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLdouble *params, + angle::ParamCapture *paramCapture); +void CapturePatchParameterfv_values(const State &glState, + bool isCallValid, + GLenum pname, + const GLfloat *values, + angle::ParamCapture *paramCapture); +void CaptureUniform1dv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureUniform2dv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureUniform3dv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureUniform4dv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix2dv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix2x3dv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix2x4dv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix3dv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix3x2dv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix3x4dv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix4dv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix4x2dv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix4x3dv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureUniformSubroutinesuiv_indices(const State &glState, + bool isCallValid, + GLenum shadertype, + GLsizei count, + const GLuint *indices, + angle::ParamCapture *paramCapture); + +// GL 4.1 +void CaptureDepthRangeArrayv_v(const State &glState, + bool isCallValid, + GLuint first, + GLsizei count, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureGetDoublei_v_data(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLdouble *data, + angle::ParamCapture *paramCapture); +void CaptureGetFloati_v_data(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLfloat *data, + angle::ParamCapture *paramCapture); +void CaptureGetVertexAttribLdv_params(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLdouble *params, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform1dv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform2dv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform3dv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform4dv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix2dv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix2x3dv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix2x4dv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix3dv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix3x2dv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix3x4dv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix4dv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix4x2dv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix4x3dv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLdouble *value, + angle::ParamCapture *paramCapture); +void CaptureScissorArrayv_v(const State &glState, + bool isCallValid, + GLuint first, + GLsizei count, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureScissorIndexedv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribL1dv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribL2dv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribL3dv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribL4dv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribLPointer_pointer(const State &glState, + bool isCallValid, + GLuint index, + GLint size, + GLenum type, + GLsizei stride, + const void *pointer, + angle::ParamCapture *paramCapture); +void CaptureViewportArrayv_v(const State &glState, + bool isCallValid, + GLuint first, + GLsizei count, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureViewportIndexedfv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLfloat *v, + angle::ParamCapture *paramCapture); + +// GL 4.2 +void CaptureDrawElementsInstancedBaseInstance_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei instancecount, + GLuint baseinstance, + angle::ParamCapture *paramCapture); +void CaptureDrawElementsInstancedBaseVertexBaseInstance_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei instancecount, + GLint basevertex, + GLuint baseinstance, + angle::ParamCapture *paramCapture); +void CaptureGetActiveAtomicCounterBufferiv_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint bufferIndex, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); + +// GL 4.3 +void CaptureClearBufferData_data(const State &glState, + bool isCallValid, + GLenum target, + GLenum internalformat, + GLenum format, + GLenum type, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureClearBufferSubData_data(const State &glState, + bool isCallValid, + GLenum target, + GLenum internalformat, + GLintptr offset, + GLsizeiptr size, + GLenum format, + GLenum type, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureGetInternalformati64v_params(const State &glState, + bool isCallValid, + GLenum target, + GLenum internalformat, + GLenum pname, + GLsizei count, + GLint64 *params, + angle::ParamCapture *paramCapture); +void CaptureGetProgramResourceLocationIndex_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawArraysIndirect_indirect(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const void *indirect, + GLsizei drawcount, + GLsizei stride, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsIndirect_indirect(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + DrawElementsType typePacked, + const void *indirect, + GLsizei drawcount, + GLsizei stride, + angle::ParamCapture *paramCapture); + +// GL 4.4 +void CaptureBindBuffersBase_buffersPacked(const State &glState, + bool isCallValid, + GLenum target, + GLuint first, + GLsizei count, + const BufferID *buffersPacked, + angle::ParamCapture *paramCapture); +void CaptureBindBuffersRange_buffersPacked(const State &glState, + bool isCallValid, + GLenum target, + GLuint first, + GLsizei count, + const BufferID *buffersPacked, + const GLintptr *offsets, + const GLsizeiptr *sizes, + angle::ParamCapture *paramCapture); +void CaptureBindBuffersRange_offsets(const State &glState, + bool isCallValid, + GLenum target, + GLuint first, + GLsizei count, + const BufferID *buffersPacked, + const GLintptr *offsets, + const GLsizeiptr *sizes, + angle::ParamCapture *paramCapture); +void CaptureBindBuffersRange_sizes(const State &glState, + bool isCallValid, + GLenum target, + GLuint first, + GLsizei count, + const BufferID *buffersPacked, + const GLintptr *offsets, + const GLsizeiptr *sizes, + angle::ParamCapture *paramCapture); +void CaptureBindImageTextures_textures(const State &glState, + bool isCallValid, + GLuint first, + GLsizei count, + const GLuint *textures, + angle::ParamCapture *paramCapture); +void CaptureBindSamplers_samplers(const State &glState, + bool isCallValid, + GLuint first, + GLsizei count, + const GLuint *samplers, + angle::ParamCapture *paramCapture); +void CaptureBindTextures_textures(const State &glState, + bool isCallValid, + GLuint first, + GLsizei count, + const GLuint *textures, + angle::ParamCapture *paramCapture); +void CaptureBindVertexBuffers_buffersPacked(const State &glState, + bool isCallValid, + GLuint first, + GLsizei count, + const BufferID *buffersPacked, + const GLintptr *offsets, + const GLsizei *strides, + angle::ParamCapture *paramCapture); +void CaptureBindVertexBuffers_offsets(const State &glState, + bool isCallValid, + GLuint first, + GLsizei count, + const BufferID *buffersPacked, + const GLintptr *offsets, + const GLsizei *strides, + angle::ParamCapture *paramCapture); +void CaptureBindVertexBuffers_strides(const State &glState, + bool isCallValid, + GLuint first, + GLsizei count, + const BufferID *buffersPacked, + const GLintptr *offsets, + const GLsizei *strides, + angle::ParamCapture *paramCapture); +void CaptureBufferStorage_data(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLsizeiptr size, + const void *data, + GLbitfield flags, + angle::ParamCapture *paramCapture); +void CaptureClearTexImage_data(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLenum format, + GLenum type, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureClearTexSubImage_data(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + const void *data, + angle::ParamCapture *paramCapture); + +// GL 4.5 +void CaptureClearNamedBufferData_data(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLenum internalformat, + GLenum format, + GLenum type, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureClearNamedBufferSubData_data(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLenum internalformat, + GLintptr offset, + GLsizeiptr size, + GLenum format, + GLenum type, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureClearNamedFramebufferfv_value(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum buffer, + GLint drawbuffer, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureClearNamedFramebufferiv_value(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum buffer, + GLint drawbuffer, + const GLint *value, + angle::ParamCapture *paramCapture); +void CaptureClearNamedFramebufferuiv_value(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum buffer, + GLint drawbuffer, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureCompressedTextureSubImage1D_data(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLsizei width, + GLenum format, + GLsizei imageSize, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureCompressedTextureSubImage2D_data(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLsizei imageSize, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureCompressedTextureSubImage3D_data(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureCreateBuffers_buffersPacked(const State &glState, + bool isCallValid, + GLsizei n, + BufferID *buffersPacked, + angle::ParamCapture *paramCapture); +void CaptureCreateFramebuffers_framebuffers(const State &glState, + bool isCallValid, + GLsizei n, + GLuint *framebuffers, + angle::ParamCapture *paramCapture); +void CaptureCreateProgramPipelines_pipelines(const State &glState, + bool isCallValid, + GLsizei n, + GLuint *pipelines, + angle::ParamCapture *paramCapture); +void CaptureCreateQueries_ids(const State &glState, + bool isCallValid, + GLenum target, + GLsizei n, + GLuint *ids, + angle::ParamCapture *paramCapture); +void CaptureCreateRenderbuffers_renderbuffersPacked(const State &glState, + bool isCallValid, + GLsizei n, + RenderbufferID *renderbuffersPacked, + angle::ParamCapture *paramCapture); +void CaptureCreateSamplers_samplers(const State &glState, + bool isCallValid, + GLsizei n, + GLuint *samplers, + angle::ParamCapture *paramCapture); +void CaptureCreateTextures_textures(const State &glState, + bool isCallValid, + GLenum target, + GLsizei n, + GLuint *textures, + angle::ParamCapture *paramCapture); +void CaptureCreateTransformFeedbacks_ids(const State &glState, + bool isCallValid, + GLsizei n, + GLuint *ids, + angle::ParamCapture *paramCapture); +void CaptureCreateVertexArrays_arraysPacked(const State &glState, + bool isCallValid, + GLsizei n, + VertexArrayID *arraysPacked, + angle::ParamCapture *paramCapture); +void CaptureGetCompressedTextureImage_pixels(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLsizei bufSize, + void *pixels, + angle::ParamCapture *paramCapture); +void CaptureGetCompressedTextureSubImage_pixels(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLsizei bufSize, + void *pixels, + angle::ParamCapture *paramCapture); +void CaptureGetNamedBufferParameteri64v_params(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLenum pname, + GLint64 *params, + angle::ParamCapture *paramCapture); +void CaptureGetNamedBufferParameteriv_params(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetNamedBufferPointerv_params(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLenum pname, + void **params, + angle::ParamCapture *paramCapture); +void CaptureGetNamedBufferSubData_data(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLintptr offset, + GLsizeiptr size, + void *data, + angle::ParamCapture *paramCapture); +void CaptureGetNamedFramebufferAttachmentParameteriv_params(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum attachment, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetNamedFramebufferParameteriv_param(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLenum pname, + GLint *param, + angle::ParamCapture *paramCapture); +void CaptureGetNamedRenderbufferParameteriv_params(const State &glState, + bool isCallValid, + RenderbufferID renderbufferPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTextureImage_pixels(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLenum format, + GLenum type, + GLsizei bufSize, + void *pixels, + angle::ParamCapture *paramCapture); +void CaptureGetTextureLevelParameterfv_params(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLenum pname, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetTextureLevelParameteriv_params(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTextureParameterIiv_params(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTextureParameterIuiv_params(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTextureParameterfv_params(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetTextureParameteriv_params(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTextureSubImage_pixels(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + GLsizei bufSize, + void *pixels, + angle::ParamCapture *paramCapture); +void CaptureGetTransformFeedbacki64_v_param(const State &glState, + bool isCallValid, + GLuint xfb, + GLenum pname, + GLuint index, + GLint64 *param, + angle::ParamCapture *paramCapture); +void CaptureGetTransformFeedbacki_v_param(const State &glState, + bool isCallValid, + GLuint xfb, + GLenum pname, + GLuint index, + GLint *param, + angle::ParamCapture *paramCapture); +void CaptureGetTransformFeedbackiv_param(const State &glState, + bool isCallValid, + GLuint xfb, + GLenum pname, + GLint *param, + angle::ParamCapture *paramCapture); +void CaptureGetVertexArrayIndexed64iv_param(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLuint index, + GLenum pname, + GLint64 *param, + angle::ParamCapture *paramCapture); +void CaptureGetVertexArrayIndexediv_param(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLuint index, + GLenum pname, + GLint *param, + angle::ParamCapture *paramCapture); +void CaptureGetVertexArrayiv_param(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLenum pname, + GLint *param, + angle::ParamCapture *paramCapture); +void CaptureGetnColorTable_table(const State &glState, + bool isCallValid, + GLenum target, + GLenum format, + GLenum type, + GLsizei bufSize, + void *table, + angle::ParamCapture *paramCapture); +void CaptureGetnCompressedTexImage_pixels(const State &glState, + bool isCallValid, + GLenum target, + GLint lod, + GLsizei bufSize, + void *pixels, + angle::ParamCapture *paramCapture); +void CaptureGetnConvolutionFilter_image(const State &glState, + bool isCallValid, + GLenum target, + GLenum format, + GLenum type, + GLsizei bufSize, + void *image, + angle::ParamCapture *paramCapture); +void CaptureGetnHistogram_values(const State &glState, + bool isCallValid, + GLenum target, + GLboolean reset, + GLenum format, + GLenum type, + GLsizei bufSize, + void *values, + angle::ParamCapture *paramCapture); +void CaptureGetnMapdv_v(const State &glState, + bool isCallValid, + GLenum target, + GLenum query, + GLsizei bufSize, + GLdouble *v, + angle::ParamCapture *paramCapture); +void CaptureGetnMapfv_v(const State &glState, + bool isCallValid, + GLenum target, + GLenum query, + GLsizei bufSize, + GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureGetnMapiv_v(const State &glState, + bool isCallValid, + GLenum target, + GLenum query, + GLsizei bufSize, + GLint *v, + angle::ParamCapture *paramCapture); +void CaptureGetnMinmax_values(const State &glState, + bool isCallValid, + GLenum target, + GLboolean reset, + GLenum format, + GLenum type, + GLsizei bufSize, + void *values, + angle::ParamCapture *paramCapture); +void CaptureGetnPixelMapfv_values(const State &glState, + bool isCallValid, + GLenum map, + GLsizei bufSize, + GLfloat *values, + angle::ParamCapture *paramCapture); +void CaptureGetnPixelMapuiv_values(const State &glState, + bool isCallValid, + GLenum map, + GLsizei bufSize, + GLuint *values, + angle::ParamCapture *paramCapture); +void CaptureGetnPixelMapusv_values(const State &glState, + bool isCallValid, + GLenum map, + GLsizei bufSize, + GLushort *values, + angle::ParamCapture *paramCapture); +void CaptureGetnPolygonStipple_pattern(const State &glState, + bool isCallValid, + GLsizei bufSize, + GLubyte *pattern, + angle::ParamCapture *paramCapture); +void CaptureGetnSeparableFilter_row(const State &glState, + bool isCallValid, + GLenum target, + GLenum format, + GLenum type, + GLsizei rowBufSize, + void *row, + GLsizei columnBufSize, + void *column, + void *span, + angle::ParamCapture *paramCapture); +void CaptureGetnSeparableFilter_column(const State &glState, + bool isCallValid, + GLenum target, + GLenum format, + GLenum type, + GLsizei rowBufSize, + void *row, + GLsizei columnBufSize, + void *column, + void *span, + angle::ParamCapture *paramCapture); +void CaptureGetnSeparableFilter_span(const State &glState, + bool isCallValid, + GLenum target, + GLenum format, + GLenum type, + GLsizei rowBufSize, + void *row, + GLsizei columnBufSize, + void *column, + void *span, + angle::ParamCapture *paramCapture); +void CaptureGetnTexImage_pixels(const State &glState, + bool isCallValid, + GLenum target, + GLint level, + GLenum format, + GLenum type, + GLsizei bufSize, + void *pixels, + angle::ParamCapture *paramCapture); +void CaptureGetnUniformdv_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLdouble *params, + angle::ParamCapture *paramCapture); +void CaptureInvalidateNamedFramebufferData_attachments(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLsizei numAttachments, + const GLenum *attachments, + angle::ParamCapture *paramCapture); +void CaptureInvalidateNamedFramebufferSubData_attachments(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLsizei numAttachments, + const GLenum *attachments, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + angle::ParamCapture *paramCapture); +void CaptureNamedBufferData_data(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLsizeiptr size, + const void *data, + GLenum usage, + angle::ParamCapture *paramCapture); +void CaptureNamedBufferStorage_data(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLsizeiptr size, + const void *data, + GLbitfield flags, + angle::ParamCapture *paramCapture); +void CaptureNamedBufferSubData_data(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLintptr offset, + GLsizeiptr size, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureNamedFramebufferDrawBuffers_bufs(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLsizei n, + const GLenum *bufs, + angle::ParamCapture *paramCapture); +void CaptureTextureParameterIiv_params(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + const GLint *params, + angle::ParamCapture *paramCapture); +void CaptureTextureParameterIuiv_params(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + const GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureTextureParameterfv_param(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + const GLfloat *param, + angle::ParamCapture *paramCapture); +void CaptureTextureParameteriv_param(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLenum pname, + const GLint *param, + angle::ParamCapture *paramCapture); +void CaptureTextureSubImage1D_pixels(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLsizei width, + GLenum format, + GLenum type, + const void *pixels, + angle::ParamCapture *paramCapture); +void CaptureTextureSubImage2D_pixels(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + const void *pixels, + angle::ParamCapture *paramCapture); +void CaptureTextureSubImage3D_pixels(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + const void *pixels, + angle::ParamCapture *paramCapture); +void CaptureVertexArrayVertexBuffers_buffersPacked(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLuint first, + GLsizei count, + const BufferID *buffersPacked, + const GLintptr *offsets, + const GLsizei *strides, + angle::ParamCapture *paramCapture); +void CaptureVertexArrayVertexBuffers_offsets(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLuint first, + GLsizei count, + const BufferID *buffersPacked, + const GLintptr *offsets, + const GLsizei *strides, + angle::ParamCapture *paramCapture); +void CaptureVertexArrayVertexBuffers_strides(const State &glState, + bool isCallValid, + VertexArrayID vaobjPacked, + GLuint first, + GLsizei count, + const BufferID *buffersPacked, + const GLintptr *offsets, + const GLsizei *strides, + angle::ParamCapture *paramCapture); + +// GL 4.6 +void CaptureMultiDrawArraysIndirectCount_indirect(const State &glState, + bool isCallValid, + GLenum mode, + const void *indirect, + GLintptr drawcount, + GLsizei maxdrawcount, + GLsizei stride, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsIndirectCount_indirect(const State &glState, + bool isCallValid, + GLenum mode, + GLenum type, + const void *indirect, + GLintptr drawcount, + GLsizei maxdrawcount, + GLsizei stride, + angle::ParamCapture *paramCapture); +void CaptureSpecializeShader_pEntryPoint(const State &glState, + bool isCallValid, + GLuint shader, + const GLchar *pEntryPoint, + GLuint numSpecializationConstants, + const GLuint *pConstantIndex, + const GLuint *pConstantValue, + angle::ParamCapture *paramCapture); +void CaptureSpecializeShader_pConstantIndex(const State &glState, + bool isCallValid, + GLuint shader, + const GLchar *pEntryPoint, + GLuint numSpecializationConstants, + const GLuint *pConstantIndex, + const GLuint *pConstantValue, + angle::ParamCapture *paramCapture); +void CaptureSpecializeShader_pConstantValue(const State &glState, + bool isCallValid, + GLuint shader, + const GLchar *pEntryPoint, + GLuint numSpecializationConstants, + const GLuint *pConstantIndex, + const GLuint *pConstantValue, + angle::ParamCapture *paramCapture); +} // namespace gl + +#endif // LIBANGLE_CAPTURE_GL_4_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gles_1_0_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_1_0_autogen.h new file mode 100644 index 0000000000..009ddb9977 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_1_0_autogen.h @@ -0,0 +1,582 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml. +// +// 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. +// +// capture_gles_1_0_autogen.h: +// Capture functions for the OpenGL ES 1.0 entry points. + +#ifndef LIBANGLE_CAPTURE_GLES_1_0_AUTOGEN_H_ +#define LIBANGLE_CAPTURE_GLES_1_0_AUTOGEN_H_ + +#include "common/PackedEnums.h" +#include "libANGLE/capture/FrameCapture.h" + +namespace gl +{ + +// Method Captures + +angle::CallCapture CaptureAlphaFunc(const State &glState, + bool isCallValid, + AlphaTestFunc funcPacked, + GLfloat ref); +angle::CallCapture CaptureAlphaFuncx(const State &glState, + bool isCallValid, + AlphaTestFunc funcPacked, + GLfixed ref); +angle::CallCapture CaptureClearColorx(const State &glState, + bool isCallValid, + GLfixed red, + GLfixed green, + GLfixed blue, + GLfixed alpha); +angle::CallCapture CaptureClearDepthx(const State &glState, bool isCallValid, GLfixed depth); +angle::CallCapture CaptureClientActiveTexture(const State &glState, + bool isCallValid, + GLenum texture); +angle::CallCapture CaptureClipPlanef(const State &glState, + bool isCallValid, + GLenum p, + const GLfloat *eqn); +angle::CallCapture CaptureClipPlanex(const State &glState, + bool isCallValid, + GLenum plane, + const GLfixed *equation); +angle::CallCapture CaptureColor4f(const State &glState, + bool isCallValid, + GLfloat red, + GLfloat green, + GLfloat blue, + GLfloat alpha); +angle::CallCapture CaptureColor4ub(const State &glState, + bool isCallValid, + GLubyte red, + GLubyte green, + GLubyte blue, + GLubyte alpha); +angle::CallCapture CaptureColor4x(const State &glState, + bool isCallValid, + GLfixed red, + GLfixed green, + GLfixed blue, + GLfixed alpha); +angle::CallCapture CaptureColorPointer(const State &glState, + bool isCallValid, + GLint size, + VertexAttribType typePacked, + GLsizei stride, + const void *pointer); +angle::CallCapture CaptureDepthRangex(const State &glState, bool isCallValid, GLfixed n, GLfixed f); +angle::CallCapture CaptureDisableClientState(const State &glState, + bool isCallValid, + ClientVertexArrayType arrayPacked); +angle::CallCapture CaptureEnableClientState(const State &glState, + bool isCallValid, + ClientVertexArrayType arrayPacked); +angle::CallCapture CaptureFogf(const State &glState, bool isCallValid, GLenum pname, GLfloat param); +angle::CallCapture CaptureFogfv(const State &glState, + bool isCallValid, + GLenum pname, + const GLfloat *params); +angle::CallCapture CaptureFogx(const State &glState, bool isCallValid, GLenum pname, GLfixed param); +angle::CallCapture CaptureFogxv(const State &glState, + bool isCallValid, + GLenum pname, + const GLfixed *param); +angle::CallCapture CaptureFrustumf(const State &glState, + bool isCallValid, + GLfloat l, + GLfloat r, + GLfloat b, + GLfloat t, + GLfloat n, + GLfloat f); +angle::CallCapture CaptureFrustumx(const State &glState, + bool isCallValid, + GLfixed l, + GLfixed r, + GLfixed b, + GLfixed t, + GLfixed n, + GLfixed f); +angle::CallCapture CaptureGetClipPlanef(const State &glState, + bool isCallValid, + GLenum plane, + GLfloat *equation); +angle::CallCapture CaptureGetClipPlanex(const State &glState, + bool isCallValid, + GLenum plane, + GLfixed *equation); +angle::CallCapture CaptureGetFixedv(const State &glState, + bool isCallValid, + GLenum pname, + GLfixed *params); +angle::CallCapture CaptureGetLightfv(const State &glState, + bool isCallValid, + GLenum light, + LightParameter pnamePacked, + GLfloat *params); +angle::CallCapture CaptureGetLightxv(const State &glState, + bool isCallValid, + GLenum light, + LightParameter pnamePacked, + GLfixed *params); +angle::CallCapture CaptureGetMaterialfv(const State &glState, + bool isCallValid, + GLenum face, + MaterialParameter pnamePacked, + GLfloat *params); +angle::CallCapture CaptureGetMaterialxv(const State &glState, + bool isCallValid, + GLenum face, + MaterialParameter pnamePacked, + GLfixed *params); +angle::CallCapture CaptureGetTexEnvfv(const State &glState, + bool isCallValid, + TextureEnvTarget targetPacked, + TextureEnvParameter pnamePacked, + GLfloat *params); +angle::CallCapture CaptureGetTexEnviv(const State &glState, + bool isCallValid, + TextureEnvTarget targetPacked, + TextureEnvParameter pnamePacked, + GLint *params); +angle::CallCapture CaptureGetTexEnvxv(const State &glState, + bool isCallValid, + TextureEnvTarget targetPacked, + TextureEnvParameter pnamePacked, + GLfixed *params); +angle::CallCapture CaptureGetTexParameterxv(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLfixed *params); +angle::CallCapture CaptureLightModelf(const State &glState, + bool isCallValid, + GLenum pname, + GLfloat param); +angle::CallCapture CaptureLightModelfv(const State &glState, + bool isCallValid, + GLenum pname, + const GLfloat *params); +angle::CallCapture CaptureLightModelx(const State &glState, + bool isCallValid, + GLenum pname, + GLfixed param); +angle::CallCapture CaptureLightModelxv(const State &glState, + bool isCallValid, + GLenum pname, + const GLfixed *param); +angle::CallCapture CaptureLightf(const State &glState, + bool isCallValid, + GLenum light, + LightParameter pnamePacked, + GLfloat param); +angle::CallCapture CaptureLightfv(const State &glState, + bool isCallValid, + GLenum light, + LightParameter pnamePacked, + const GLfloat *params); +angle::CallCapture CaptureLightx(const State &glState, + bool isCallValid, + GLenum light, + LightParameter pnamePacked, + GLfixed param); +angle::CallCapture CaptureLightxv(const State &glState, + bool isCallValid, + GLenum light, + LightParameter pnamePacked, + const GLfixed *params); +angle::CallCapture CaptureLineWidthx(const State &glState, bool isCallValid, GLfixed width); +angle::CallCapture CaptureLoadIdentity(const State &glState, bool isCallValid); +angle::CallCapture CaptureLoadMatrixf(const State &glState, bool isCallValid, const GLfloat *m); +angle::CallCapture CaptureLoadMatrixx(const State &glState, bool isCallValid, const GLfixed *m); +angle::CallCapture CaptureLogicOp(const State &glState, + bool isCallValid, + LogicalOperation opcodePacked); +angle::CallCapture CaptureMaterialf(const State &glState, + bool isCallValid, + GLenum face, + MaterialParameter pnamePacked, + GLfloat param); +angle::CallCapture CaptureMaterialfv(const State &glState, + bool isCallValid, + GLenum face, + MaterialParameter pnamePacked, + const GLfloat *params); +angle::CallCapture CaptureMaterialx(const State &glState, + bool isCallValid, + GLenum face, + MaterialParameter pnamePacked, + GLfixed param); +angle::CallCapture CaptureMaterialxv(const State &glState, + bool isCallValid, + GLenum face, + MaterialParameter pnamePacked, + const GLfixed *param); +angle::CallCapture CaptureMatrixMode(const State &glState, bool isCallValid, MatrixType modePacked); +angle::CallCapture CaptureMultMatrixf(const State &glState, bool isCallValid, const GLfloat *m); +angle::CallCapture CaptureMultMatrixx(const State &glState, bool isCallValid, const GLfixed *m); +angle::CallCapture CaptureMultiTexCoord4f(const State &glState, + bool isCallValid, + GLenum target, + GLfloat s, + GLfloat t, + GLfloat r, + GLfloat q); +angle::CallCapture CaptureMultiTexCoord4x(const State &glState, + bool isCallValid, + GLenum texture, + GLfixed s, + GLfixed t, + GLfixed r, + GLfixed q); +angle::CallCapture CaptureNormal3f(const State &glState, + bool isCallValid, + GLfloat nx, + GLfloat ny, + GLfloat nz); +angle::CallCapture CaptureNormal3x(const State &glState, + bool isCallValid, + GLfixed nx, + GLfixed ny, + GLfixed nz); +angle::CallCapture CaptureNormalPointer(const State &glState, + bool isCallValid, + VertexAttribType typePacked, + GLsizei stride, + const void *pointer); +angle::CallCapture CaptureOrthof(const State &glState, + bool isCallValid, + GLfloat l, + GLfloat r, + GLfloat b, + GLfloat t, + GLfloat n, + GLfloat f); +angle::CallCapture CaptureOrthox(const State &glState, + bool isCallValid, + GLfixed l, + GLfixed r, + GLfixed b, + GLfixed t, + GLfixed n, + GLfixed f); +angle::CallCapture CapturePointParameterf(const State &glState, + bool isCallValid, + PointParameter pnamePacked, + GLfloat param); +angle::CallCapture CapturePointParameterfv(const State &glState, + bool isCallValid, + PointParameter pnamePacked, + const GLfloat *params); +angle::CallCapture CapturePointParameterx(const State &glState, + bool isCallValid, + PointParameter pnamePacked, + GLfixed param); +angle::CallCapture CapturePointParameterxv(const State &glState, + bool isCallValid, + PointParameter pnamePacked, + const GLfixed *params); +angle::CallCapture CapturePointSize(const State &glState, bool isCallValid, GLfloat size); +angle::CallCapture CapturePointSizex(const State &glState, bool isCallValid, GLfixed size); +angle::CallCapture CapturePolygonOffsetx(const State &glState, + bool isCallValid, + GLfixed factor, + GLfixed units); +angle::CallCapture CapturePopMatrix(const State &glState, bool isCallValid); +angle::CallCapture CapturePushMatrix(const State &glState, bool isCallValid); +angle::CallCapture CaptureRotatef(const State &glState, + bool isCallValid, + GLfloat angle, + GLfloat x, + GLfloat y, + GLfloat z); +angle::CallCapture CaptureRotatex(const State &glState, + bool isCallValid, + GLfixed angle, + GLfixed x, + GLfixed y, + GLfixed z); +angle::CallCapture CaptureSampleCoveragex(const State &glState, + bool isCallValid, + GLclampx value, + GLboolean invert); +angle::CallCapture CaptureScalef(const State &glState, + bool isCallValid, + GLfloat x, + GLfloat y, + GLfloat z); +angle::CallCapture CaptureScalex(const State &glState, + bool isCallValid, + GLfixed x, + GLfixed y, + GLfixed z); +angle::CallCapture CaptureShadeModel(const State &glState, + bool isCallValid, + ShadingModel modePacked); +angle::CallCapture CaptureTexCoordPointer(const State &glState, + bool isCallValid, + GLint size, + VertexAttribType typePacked, + GLsizei stride, + const void *pointer); +angle::CallCapture CaptureTexEnvf(const State &glState, + bool isCallValid, + TextureEnvTarget targetPacked, + TextureEnvParameter pnamePacked, + GLfloat param); +angle::CallCapture CaptureTexEnvfv(const State &glState, + bool isCallValid, + TextureEnvTarget targetPacked, + TextureEnvParameter pnamePacked, + const GLfloat *params); +angle::CallCapture CaptureTexEnvi(const State &glState, + bool isCallValid, + TextureEnvTarget targetPacked, + TextureEnvParameter pnamePacked, + GLint param); +angle::CallCapture CaptureTexEnviv(const State &glState, + bool isCallValid, + TextureEnvTarget targetPacked, + TextureEnvParameter pnamePacked, + const GLint *params); +angle::CallCapture CaptureTexEnvx(const State &glState, + bool isCallValid, + TextureEnvTarget targetPacked, + TextureEnvParameter pnamePacked, + GLfixed param); +angle::CallCapture CaptureTexEnvxv(const State &glState, + bool isCallValid, + TextureEnvTarget targetPacked, + TextureEnvParameter pnamePacked, + const GLfixed *params); +angle::CallCapture CaptureTexParameterx(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLfixed param); +angle::CallCapture CaptureTexParameterxv(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLfixed *params); +angle::CallCapture CaptureTranslatef(const State &glState, + bool isCallValid, + GLfloat x, + GLfloat y, + GLfloat z); +angle::CallCapture CaptureTranslatex(const State &glState, + bool isCallValid, + GLfixed x, + GLfixed y, + GLfixed z); +angle::CallCapture CaptureVertexPointer(const State &glState, + bool isCallValid, + GLint size, + VertexAttribType typePacked, + GLsizei stride, + const void *pointer); + +// Parameter Captures + +void CaptureClipPlanef_eqn(const State &glState, + bool isCallValid, + GLenum p, + const GLfloat *eqn, + angle::ParamCapture *paramCapture); +void CaptureClipPlanex_equation(const State &glState, + bool isCallValid, + GLenum plane, + const GLfixed *equation, + angle::ParamCapture *paramCapture); +void CaptureColorPointer_pointer(const State &glState, + bool isCallValid, + GLint size, + VertexAttribType typePacked, + GLsizei stride, + const void *pointer, + angle::ParamCapture *paramCapture); +void CaptureFogfv_params(const State &glState, + bool isCallValid, + GLenum pname, + const GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureFogxv_param(const State &glState, + bool isCallValid, + GLenum pname, + const GLfixed *param, + angle::ParamCapture *paramCapture); +void CaptureGetClipPlanef_equation(const State &glState, + bool isCallValid, + GLenum plane, + GLfloat *equation, + angle::ParamCapture *paramCapture); +void CaptureGetClipPlanex_equation(const State &glState, + bool isCallValid, + GLenum plane, + GLfixed *equation, + angle::ParamCapture *paramCapture); +void CaptureGetFixedv_params(const State &glState, + bool isCallValid, + GLenum pname, + GLfixed *params, + angle::ParamCapture *paramCapture); +void CaptureGetLightfv_params(const State &glState, + bool isCallValid, + GLenum light, + LightParameter pnamePacked, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetLightxv_params(const State &glState, + bool isCallValid, + GLenum light, + LightParameter pnamePacked, + GLfixed *params, + angle::ParamCapture *paramCapture); +void CaptureGetMaterialfv_params(const State &glState, + bool isCallValid, + GLenum face, + MaterialParameter pnamePacked, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetMaterialxv_params(const State &glState, + bool isCallValid, + GLenum face, + MaterialParameter pnamePacked, + GLfixed *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexEnvfv_params(const State &glState, + bool isCallValid, + TextureEnvTarget targetPacked, + TextureEnvParameter pnamePacked, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexEnviv_params(const State &glState, + bool isCallValid, + TextureEnvTarget targetPacked, + TextureEnvParameter pnamePacked, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexEnvxv_params(const State &glState, + bool isCallValid, + TextureEnvTarget targetPacked, + TextureEnvParameter pnamePacked, + GLfixed *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexParameterxv_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLfixed *params, + angle::ParamCapture *paramCapture); +void CaptureLightModelfv_params(const State &glState, + bool isCallValid, + GLenum pname, + const GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureLightModelxv_param(const State &glState, + bool isCallValid, + GLenum pname, + const GLfixed *param, + angle::ParamCapture *paramCapture); +void CaptureLightfv_params(const State &glState, + bool isCallValid, + GLenum light, + LightParameter pnamePacked, + const GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureLightxv_params(const State &glState, + bool isCallValid, + GLenum light, + LightParameter pnamePacked, + const GLfixed *params, + angle::ParamCapture *paramCapture); +void CaptureLoadMatrixf_m(const State &glState, + bool isCallValid, + const GLfloat *m, + angle::ParamCapture *paramCapture); +void CaptureLoadMatrixx_m(const State &glState, + bool isCallValid, + const GLfixed *m, + angle::ParamCapture *paramCapture); +void CaptureMaterialfv_params(const State &glState, + bool isCallValid, + GLenum face, + MaterialParameter pnamePacked, + const GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureMaterialxv_param(const State &glState, + bool isCallValid, + GLenum face, + MaterialParameter pnamePacked, + const GLfixed *param, + angle::ParamCapture *paramCapture); +void CaptureMultMatrixf_m(const State &glState, + bool isCallValid, + const GLfloat *m, + angle::ParamCapture *paramCapture); +void CaptureMultMatrixx_m(const State &glState, + bool isCallValid, + const GLfixed *m, + angle::ParamCapture *paramCapture); +void CaptureNormalPointer_pointer(const State &glState, + bool isCallValid, + VertexAttribType typePacked, + GLsizei stride, + const void *pointer, + angle::ParamCapture *paramCapture); +void CapturePointParameterfv_params(const State &glState, + bool isCallValid, + PointParameter pnamePacked, + const GLfloat *params, + angle::ParamCapture *paramCapture); +void CapturePointParameterxv_params(const State &glState, + bool isCallValid, + PointParameter pnamePacked, + const GLfixed *params, + angle::ParamCapture *paramCapture); +void CaptureTexCoordPointer_pointer(const State &glState, + bool isCallValid, + GLint size, + VertexAttribType typePacked, + GLsizei stride, + const void *pointer, + angle::ParamCapture *paramCapture); +void CaptureTexEnvfv_params(const State &glState, + bool isCallValid, + TextureEnvTarget targetPacked, + TextureEnvParameter pnamePacked, + const GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureTexEnviv_params(const State &glState, + bool isCallValid, + TextureEnvTarget targetPacked, + TextureEnvParameter pnamePacked, + const GLint *params, + angle::ParamCapture *paramCapture); +void CaptureTexEnvxv_params(const State &glState, + bool isCallValid, + TextureEnvTarget targetPacked, + TextureEnvParameter pnamePacked, + const GLfixed *params, + angle::ParamCapture *paramCapture); +void CaptureTexParameterxv_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLfixed *params, + angle::ParamCapture *paramCapture); +void CaptureVertexPointer_pointer(const State &glState, + bool isCallValid, + GLint size, + VertexAttribType typePacked, + GLsizei stride, + const void *pointer, + angle::ParamCapture *paramCapture); +} // namespace gl + +#endif // LIBANGLE_CAPTURE_GLES_1_0_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gles_2_0_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_2_0_autogen.h new file mode 100644 index 0000000000..d4d1d978a2 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_2_0_autogen.h @@ -0,0 +1,1195 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml. +// +// 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. +// +// capture_gles_2_0_autogen.h: +// Capture functions for the OpenGL ES 2.0 entry points. + +#ifndef LIBANGLE_CAPTURE_GLES_2_0_AUTOGEN_H_ +#define LIBANGLE_CAPTURE_GLES_2_0_AUTOGEN_H_ + +#include "common/PackedEnums.h" +#include "libANGLE/capture/FrameCapture.h" + +namespace gl +{ + +// Method Captures + +angle::CallCapture CaptureActiveTexture(const State &glState, bool isCallValid, GLenum texture); +angle::CallCapture CaptureAttachShader(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + ShaderProgramID shaderPacked); +angle::CallCapture CaptureBindAttribLocation(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint index, + const GLchar *name); +angle::CallCapture CaptureBindBuffer(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + BufferID bufferPacked); +angle::CallCapture CaptureBindFramebuffer(const State &glState, + bool isCallValid, + GLenum target, + FramebufferID framebufferPacked); +angle::CallCapture CaptureBindRenderbuffer(const State &glState, + bool isCallValid, + GLenum target, + RenderbufferID renderbufferPacked); +angle::CallCapture CaptureBindTexture(const State &glState, + bool isCallValid, + TextureType targetPacked, + TextureID texturePacked); +angle::CallCapture CaptureBlendColor(const State &glState, + bool isCallValid, + GLfloat red, + GLfloat green, + GLfloat blue, + GLfloat alpha); +angle::CallCapture CaptureBlendEquation(const State &glState, bool isCallValid, GLenum mode); +angle::CallCapture CaptureBlendEquationSeparate(const State &glState, + bool isCallValid, + GLenum modeRGB, + GLenum modeAlpha); +angle::CallCapture CaptureBlendFunc(const State &glState, + bool isCallValid, + GLenum sfactor, + GLenum dfactor); +angle::CallCapture CaptureBlendFuncSeparate(const State &glState, + bool isCallValid, + GLenum sfactorRGB, + GLenum dfactorRGB, + GLenum sfactorAlpha, + GLenum dfactorAlpha); +angle::CallCapture CaptureBufferData(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLsizeiptr size, + const void *data, + BufferUsage usagePacked); +angle::CallCapture CaptureBufferSubData(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLintptr offset, + GLsizeiptr size, + const void *data); +angle::CallCapture CaptureCheckFramebufferStatus(const State &glState, + bool isCallValid, + GLenum target, + GLenum returnValue); +angle::CallCapture CaptureClear(const State &glState, bool isCallValid, GLbitfield mask); +angle::CallCapture CaptureClearColor(const State &glState, + bool isCallValid, + GLfloat red, + GLfloat green, + GLfloat blue, + GLfloat alpha); +angle::CallCapture CaptureClearDepthf(const State &glState, bool isCallValid, GLfloat d); +angle::CallCapture CaptureClearStencil(const State &glState, bool isCallValid, GLint s); +angle::CallCapture CaptureColorMask(const State &glState, + bool isCallValid, + GLboolean red, + GLboolean green, + GLboolean blue, + GLboolean alpha); +angle::CallCapture CaptureCompileShader(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked); +angle::CallCapture CaptureCompressedTexImage2D(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLsizei imageSize, + const void *data); +angle::CallCapture CaptureCompressedTexSubImage2D(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLsizei imageSize, + const void *data); +angle::CallCapture CaptureCopyTexImage2D(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum internalformat, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLint border); +angle::CallCapture CaptureCopyTexSubImage2D(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint x, + GLint y, + GLsizei width, + GLsizei height); +angle::CallCapture CaptureCreateProgram(const State &glState, bool isCallValid, GLuint returnValue); +angle::CallCapture CaptureCreateShader(const State &glState, + bool isCallValid, + ShaderType typePacked, + GLuint returnValue); +angle::CallCapture CaptureCullFace(const State &glState, bool isCallValid, CullFaceMode modePacked); +angle::CallCapture CaptureDeleteBuffers(const State &glState, + bool isCallValid, + GLsizei n, + const BufferID *buffersPacked); +angle::CallCapture CaptureDeleteFramebuffers(const State &glState, + bool isCallValid, + GLsizei n, + const FramebufferID *framebuffersPacked); +angle::CallCapture CaptureDeleteProgram(const State &glState, + bool isCallValid, + ShaderProgramID programPacked); +angle::CallCapture CaptureDeleteRenderbuffers(const State &glState, + bool isCallValid, + GLsizei n, + const RenderbufferID *renderbuffersPacked); +angle::CallCapture CaptureDeleteShader(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked); +angle::CallCapture CaptureDeleteTextures(const State &glState, + bool isCallValid, + GLsizei n, + const TextureID *texturesPacked); +angle::CallCapture CaptureDepthFunc(const State &glState, bool isCallValid, GLenum func); +angle::CallCapture CaptureDepthMask(const State &glState, bool isCallValid, GLboolean flag); +angle::CallCapture CaptureDepthRangef(const State &glState, bool isCallValid, GLfloat n, GLfloat f); +angle::CallCapture CaptureDetachShader(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + ShaderProgramID shaderPacked); +angle::CallCapture CaptureDisable(const State &glState, bool isCallValid, GLenum cap); +angle::CallCapture CaptureDisableVertexAttribArray(const State &glState, + bool isCallValid, + GLuint index); +angle::CallCapture CaptureDrawArrays(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLint first, + GLsizei count); +angle::CallCapture CaptureDrawElements(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices); +angle::CallCapture CaptureEnable(const State &glState, bool isCallValid, GLenum cap); +angle::CallCapture CaptureEnableVertexAttribArray(const State &glState, + bool isCallValid, + GLuint index); +angle::CallCapture CaptureFinish(const State &glState, bool isCallValid); +angle::CallCapture CaptureFlush(const State &glState, bool isCallValid); +angle::CallCapture CaptureFramebufferRenderbuffer(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + GLenum renderbuffertarget, + RenderbufferID renderbufferPacked); +angle::CallCapture CaptureFramebufferTexture2D(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + TextureTarget textargetPacked, + TextureID texturePacked, + GLint level); +angle::CallCapture CaptureFrontFace(const State &glState, bool isCallValid, GLenum mode); +angle::CallCapture CaptureGenBuffers(const State &glState, + bool isCallValid, + GLsizei n, + BufferID *buffersPacked); +angle::CallCapture CaptureGenFramebuffers(const State &glState, + bool isCallValid, + GLsizei n, + FramebufferID *framebuffersPacked); +angle::CallCapture CaptureGenRenderbuffers(const State &glState, + bool isCallValid, + GLsizei n, + RenderbufferID *renderbuffersPacked); +angle::CallCapture CaptureGenTextures(const State &glState, + bool isCallValid, + GLsizei n, + TextureID *texturesPacked); +angle::CallCapture CaptureGenerateMipmap(const State &glState, + bool isCallValid, + TextureType targetPacked); +angle::CallCapture CaptureGetActiveAttrib(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *size, + GLenum *type, + GLchar *name); +angle::CallCapture CaptureGetActiveUniform(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *size, + GLenum *type, + GLchar *name); +angle::CallCapture CaptureGetAttachedShaders(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei maxCount, + GLsizei *count, + ShaderProgramID *shadersPacked); +angle::CallCapture CaptureGetAttribLocation(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + const GLchar *name, + GLint returnValue); +angle::CallCapture CaptureGetBooleanv(const State &glState, + bool isCallValid, + GLenum pname, + GLboolean *data); +angle::CallCapture CaptureGetBufferParameteriv(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetError(const State &glState, bool isCallValid, GLenum returnValue); +angle::CallCapture CaptureGetFloatv(const State &glState, + bool isCallValid, + GLenum pname, + GLfloat *data); +angle::CallCapture CaptureGetFramebufferAttachmentParameteriv(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetIntegerv(const State &glState, + bool isCallValid, + GLenum pname, + GLint *data); +angle::CallCapture CaptureGetProgramInfoLog(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog); +angle::CallCapture CaptureGetProgramiv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetRenderbufferParameteriv(const State &glState, + bool isCallValid, + GLenum target, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetShaderInfoLog(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog); +angle::CallCapture CaptureGetShaderPrecisionFormat(const State &glState, + bool isCallValid, + GLenum shadertype, + GLenum precisiontype, + GLint *range, + GLint *precision); +angle::CallCapture CaptureGetShaderSource(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLsizei bufSize, + GLsizei *length, + GLchar *source); +angle::CallCapture CaptureGetShaderiv(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetString(const State &glState, + bool isCallValid, + GLenum name, + const GLubyte *returnValue); +angle::CallCapture CaptureGetTexParameterfv(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLfloat *params); +angle::CallCapture CaptureGetTexParameteriv(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetUniformLocation(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + const GLchar *name, + GLint returnValue); +angle::CallCapture CaptureGetUniformfv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLfloat *params); +angle::CallCapture CaptureGetUniformiv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLint *params); +angle::CallCapture CaptureGetVertexAttribPointerv(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + void **pointer); +angle::CallCapture CaptureGetVertexAttribfv(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLfloat *params); +angle::CallCapture CaptureGetVertexAttribiv(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLint *params); +angle::CallCapture CaptureHint(const State &glState, bool isCallValid, GLenum target, GLenum mode); +angle::CallCapture CaptureIsBuffer(const State &glState, + bool isCallValid, + BufferID bufferPacked, + GLboolean returnValue); +angle::CallCapture CaptureIsEnabled(const State &glState, + bool isCallValid, + GLenum cap, + GLboolean returnValue); +angle::CallCapture CaptureIsFramebuffer(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLboolean returnValue); +angle::CallCapture CaptureIsProgram(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLboolean returnValue); +angle::CallCapture CaptureIsRenderbuffer(const State &glState, + bool isCallValid, + RenderbufferID renderbufferPacked, + GLboolean returnValue); +angle::CallCapture CaptureIsShader(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLboolean returnValue); +angle::CallCapture CaptureIsTexture(const State &glState, + bool isCallValid, + TextureID texturePacked, + GLboolean returnValue); +angle::CallCapture CaptureLineWidth(const State &glState, bool isCallValid, GLfloat width); +angle::CallCapture CaptureLinkProgram(const State &glState, + bool isCallValid, + ShaderProgramID programPacked); +angle::CallCapture CapturePixelStorei(const State &glState, + bool isCallValid, + GLenum pname, + GLint param); +angle::CallCapture CapturePolygonOffset(const State &glState, + bool isCallValid, + GLfloat factor, + GLfloat units); +angle::CallCapture CaptureReadPixels(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + void *pixels); +angle::CallCapture CaptureReleaseShaderCompiler(const State &glState, bool isCallValid); +angle::CallCapture CaptureRenderbufferStorage(const State &glState, + bool isCallValid, + GLenum target, + GLenum internalformat, + GLsizei width, + GLsizei height); +angle::CallCapture CaptureSampleCoverage(const State &glState, + bool isCallValid, + GLfloat value, + GLboolean invert); +angle::CallCapture CaptureScissor(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height); +angle::CallCapture CaptureShaderBinary(const State &glState, + bool isCallValid, + GLsizei count, + const ShaderProgramID *shadersPacked, + GLenum binaryFormat, + const void *binary, + GLsizei length); +angle::CallCapture CaptureShaderSource(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLsizei count, + const GLchar *const *string, + const GLint *length); +angle::CallCapture CaptureStencilFunc(const State &glState, + bool isCallValid, + GLenum func, + GLint ref, + GLuint mask); +angle::CallCapture CaptureStencilFuncSeparate(const State &glState, + bool isCallValid, + GLenum face, + GLenum func, + GLint ref, + GLuint mask); +angle::CallCapture CaptureStencilMask(const State &glState, bool isCallValid, GLuint mask); +angle::CallCapture CaptureStencilMaskSeparate(const State &glState, + bool isCallValid, + GLenum face, + GLuint mask); +angle::CallCapture CaptureStencilOp(const State &glState, + bool isCallValid, + GLenum fail, + GLenum zfail, + GLenum zpass); +angle::CallCapture CaptureStencilOpSeparate(const State &glState, + bool isCallValid, + GLenum face, + GLenum sfail, + GLenum dpfail, + GLenum dppass); +angle::CallCapture CaptureTexImage2D(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLenum format, + GLenum type, + const void *pixels); +angle::CallCapture CaptureTexParameterf(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLfloat param); +angle::CallCapture CaptureTexParameterfv(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLfloat *params); +angle::CallCapture CaptureTexParameteri(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLint param); +angle::CallCapture CaptureTexParameteriv(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLint *params); +angle::CallCapture CaptureTexSubImage2D(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + const void *pixels); +angle::CallCapture CaptureUniform1f(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLfloat v0); +angle::CallCapture CaptureUniform1fv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value); +angle::CallCapture CaptureUniform1i(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLint v0); +angle::CallCapture CaptureUniform1iv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLint *value); +angle::CallCapture CaptureUniform2f(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLfloat v0, + GLfloat v1); +angle::CallCapture CaptureUniform2fv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value); +angle::CallCapture CaptureUniform2i(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLint v0, + GLint v1); +angle::CallCapture CaptureUniform2iv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLint *value); +angle::CallCapture CaptureUniform3f(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLfloat v0, + GLfloat v1, + GLfloat v2); +angle::CallCapture CaptureUniform3fv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value); +angle::CallCapture CaptureUniform3i(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLint v0, + GLint v1, + GLint v2); +angle::CallCapture CaptureUniform3iv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLint *value); +angle::CallCapture CaptureUniform4f(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLfloat v0, + GLfloat v1, + GLfloat v2, + GLfloat v3); +angle::CallCapture CaptureUniform4fv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value); +angle::CallCapture CaptureUniform4i(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLint v0, + GLint v1, + GLint v2, + GLint v3); +angle::CallCapture CaptureUniform4iv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLint *value); +angle::CallCapture CaptureUniformMatrix2fv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureUniformMatrix3fv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureUniformMatrix4fv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureUseProgram(const State &glState, + bool isCallValid, + ShaderProgramID programPacked); +angle::CallCapture CaptureValidateProgram(const State &glState, + bool isCallValid, + ShaderProgramID programPacked); +angle::CallCapture CaptureVertexAttrib1f(const State &glState, + bool isCallValid, + GLuint index, + GLfloat x); +angle::CallCapture CaptureVertexAttrib1fv(const State &glState, + bool isCallValid, + GLuint index, + const GLfloat *v); +angle::CallCapture CaptureVertexAttrib2f(const State &glState, + bool isCallValid, + GLuint index, + GLfloat x, + GLfloat y); +angle::CallCapture CaptureVertexAttrib2fv(const State &glState, + bool isCallValid, + GLuint index, + const GLfloat *v); +angle::CallCapture CaptureVertexAttrib3f(const State &glState, + bool isCallValid, + GLuint index, + GLfloat x, + GLfloat y, + GLfloat z); +angle::CallCapture CaptureVertexAttrib3fv(const State &glState, + bool isCallValid, + GLuint index, + const GLfloat *v); +angle::CallCapture CaptureVertexAttrib4f(const State &glState, + bool isCallValid, + GLuint index, + GLfloat x, + GLfloat y, + GLfloat z, + GLfloat w); +angle::CallCapture CaptureVertexAttrib4fv(const State &glState, + bool isCallValid, + GLuint index, + const GLfloat *v); +angle::CallCapture CaptureVertexAttribPointer(const State &glState, + bool isCallValid, + GLuint index, + GLint size, + VertexAttribType typePacked, + GLboolean normalized, + GLsizei stride, + const void *pointer); +angle::CallCapture CaptureViewport(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height); + +// Parameter Captures + +void CaptureBindAttribLocation_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint index, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureBufferData_data(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLsizeiptr size, + const void *data, + BufferUsage usagePacked, + angle::ParamCapture *paramCapture); +void CaptureBufferSubData_data(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLintptr offset, + GLsizeiptr size, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureCompressedTexImage2D_data(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLsizei imageSize, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureCompressedTexSubImage2D_data(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLsizei imageSize, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureDeleteBuffers_buffersPacked(const State &glState, + bool isCallValid, + GLsizei n, + const BufferID *buffersPacked, + angle::ParamCapture *paramCapture); +void CaptureDeleteFramebuffers_framebuffersPacked(const State &glState, + bool isCallValid, + GLsizei n, + const FramebufferID *framebuffersPacked, + angle::ParamCapture *paramCapture); +void CaptureDeleteRenderbuffers_renderbuffersPacked(const State &glState, + bool isCallValid, + GLsizei n, + const RenderbufferID *renderbuffersPacked, + angle::ParamCapture *paramCapture); +void CaptureDeleteTextures_texturesPacked(const State &glState, + bool isCallValid, + GLsizei n, + const TextureID *texturesPacked, + angle::ParamCapture *paramCapture); +void CaptureDrawElements_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + angle::ParamCapture *paramCapture); +void CaptureGenBuffers_buffersPacked(const State &glState, + bool isCallValid, + GLsizei n, + BufferID *buffersPacked, + angle::ParamCapture *paramCapture); +void CaptureGenFramebuffers_framebuffersPacked(const State &glState, + bool isCallValid, + GLsizei n, + FramebufferID *framebuffersPacked, + angle::ParamCapture *paramCapture); +void CaptureGenRenderbuffers_renderbuffersPacked(const State &glState, + bool isCallValid, + GLsizei n, + RenderbufferID *renderbuffersPacked, + angle::ParamCapture *paramCapture); +void CaptureGenTextures_texturesPacked(const State &glState, + bool isCallValid, + GLsizei n, + TextureID *texturesPacked, + angle::ParamCapture *paramCapture); +void CaptureGetActiveAttrib_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *size, + GLenum *type, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetActiveAttrib_size(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *size, + GLenum *type, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetActiveAttrib_type(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *size, + GLenum *type, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetActiveAttrib_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *size, + GLenum *type, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetActiveUniform_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *size, + GLenum *type, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetActiveUniform_size(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *size, + GLenum *type, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetActiveUniform_type(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *size, + GLenum *type, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetActiveUniform_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *size, + GLenum *type, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetAttachedShaders_count(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei maxCount, + GLsizei *count, + ShaderProgramID *shadersPacked, + angle::ParamCapture *paramCapture); +void CaptureGetAttachedShaders_shadersPacked(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei maxCount, + GLsizei *count, + ShaderProgramID *shadersPacked, + angle::ParamCapture *paramCapture); +void CaptureGetAttribLocation_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetBooleanv_data(const State &glState, + bool isCallValid, + GLenum pname, + GLboolean *data, + angle::ParamCapture *paramCapture); +void CaptureGetBufferParameteriv_params(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetFloatv_data(const State &glState, + bool isCallValid, + GLenum pname, + GLfloat *data, + angle::ParamCapture *paramCapture); +void CaptureGetFramebufferAttachmentParameteriv_params(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetIntegerv_data(const State &glState, + bool isCallValid, + GLenum pname, + GLint *data, + angle::ParamCapture *paramCapture); +void CaptureGetProgramInfoLog_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog, + angle::ParamCapture *paramCapture); +void CaptureGetProgramInfoLog_infoLog(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog, + angle::ParamCapture *paramCapture); +void CaptureGetProgramiv_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetRenderbufferParameteriv_params(const State &glState, + bool isCallValid, + GLenum target, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetShaderInfoLog_length(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog, + angle::ParamCapture *paramCapture); +void CaptureGetShaderInfoLog_infoLog(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog, + angle::ParamCapture *paramCapture); +void CaptureGetShaderPrecisionFormat_range(const State &glState, + bool isCallValid, + GLenum shadertype, + GLenum precisiontype, + GLint *range, + GLint *precision, + angle::ParamCapture *paramCapture); +void CaptureGetShaderPrecisionFormat_precision(const State &glState, + bool isCallValid, + GLenum shadertype, + GLenum precisiontype, + GLint *range, + GLint *precision, + angle::ParamCapture *paramCapture); +void CaptureGetShaderSource_length(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLsizei bufSize, + GLsizei *length, + GLchar *source, + angle::ParamCapture *paramCapture); +void CaptureGetShaderSource_source(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLsizei bufSize, + GLsizei *length, + GLchar *source, + angle::ParamCapture *paramCapture); +void CaptureGetShaderiv_params(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexParameterfv_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexParameteriv_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetUniformLocation_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetUniformfv_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetUniformiv_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetVertexAttribPointerv_pointer(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + void **pointer, + angle::ParamCapture *paramCapture); +void CaptureGetVertexAttribfv_params(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetVertexAttribiv_params(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureReadPixels_pixels(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + void *pixels, + angle::ParamCapture *paramCapture); +void CaptureShaderBinary_shadersPacked(const State &glState, + bool isCallValid, + GLsizei count, + const ShaderProgramID *shadersPacked, + GLenum binaryFormat, + const void *binary, + GLsizei length, + angle::ParamCapture *paramCapture); +void CaptureShaderBinary_binary(const State &glState, + bool isCallValid, + GLsizei count, + const ShaderProgramID *shadersPacked, + GLenum binaryFormat, + const void *binary, + GLsizei length, + angle::ParamCapture *paramCapture); +void CaptureShaderSource_string(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLsizei count, + const GLchar *const *string, + const GLint *length, + angle::ParamCapture *paramCapture); +void CaptureShaderSource_length(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLsizei count, + const GLchar *const *string, + const GLint *length, + angle::ParamCapture *paramCapture); +void CaptureTexImage2D_pixels(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLenum format, + GLenum type, + const void *pixels, + angle::ParamCapture *paramCapture); +void CaptureTexParameterfv_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureTexParameteriv_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLint *params, + angle::ParamCapture *paramCapture); +void CaptureTexSubImage2D_pixels(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + const void *pixels, + angle::ParamCapture *paramCapture); +void CaptureUniform1fv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureUniform1iv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLint *value, + angle::ParamCapture *paramCapture); +void CaptureUniform2fv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureUniform2iv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLint *value, + angle::ParamCapture *paramCapture); +void CaptureUniform3fv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureUniform3iv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLint *value, + angle::ParamCapture *paramCapture); +void CaptureUniform4fv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureUniform4iv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLint *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix2fv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix3fv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix4fv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib1fv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib2fv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib3fv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttrib4fv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLfloat *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribPointer_pointer(const State &glState, + bool isCallValid, + GLuint index, + GLint size, + VertexAttribType typePacked, + GLboolean normalized, + GLsizei stride, + const void *pointer, + angle::ParamCapture *paramCapture); +} // namespace gl + +#endif // LIBANGLE_CAPTURE_GLES_2_0_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_0_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_0_autogen.h new file mode 100644 index 0000000000..83e2f441b4 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_0_autogen.h @@ -0,0 +1,1079 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml. +// +// 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. +// +// capture_gles_3_0_autogen.h: +// Capture functions for the OpenGL ES 3.0 entry points. + +#ifndef LIBANGLE_CAPTURE_GLES_3_0_AUTOGEN_H_ +#define LIBANGLE_CAPTURE_GLES_3_0_AUTOGEN_H_ + +#include "common/PackedEnums.h" +#include "libANGLE/capture/FrameCapture.h" + +namespace gl +{ + +// Method Captures + +angle::CallCapture CaptureBeginQuery(const State &glState, + bool isCallValid, + QueryType targetPacked, + QueryID idPacked); +angle::CallCapture CaptureBeginTransformFeedback(const State &glState, + bool isCallValid, + PrimitiveMode primitiveModePacked); +angle::CallCapture CaptureBindBufferBase(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLuint index, + BufferID bufferPacked); +angle::CallCapture CaptureBindBufferRange(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLuint index, + BufferID bufferPacked, + GLintptr offset, + GLsizeiptr size); +angle::CallCapture CaptureBindSampler(const State &glState, + bool isCallValid, + GLuint unit, + SamplerID samplerPacked); +angle::CallCapture CaptureBindTransformFeedback(const State &glState, + bool isCallValid, + GLenum target, + TransformFeedbackID idPacked); +angle::CallCapture CaptureBindVertexArray(const State &glState, + bool isCallValid, + VertexArrayID arrayPacked); +angle::CallCapture CaptureBlitFramebuffer(const State &glState, + bool isCallValid, + GLint srcX0, + GLint srcY0, + GLint srcX1, + GLint srcY1, + GLint dstX0, + GLint dstY0, + GLint dstX1, + GLint dstY1, + GLbitfield mask, + GLenum filter); +angle::CallCapture CaptureClearBufferfi(const State &glState, + bool isCallValid, + GLenum buffer, + GLint drawbuffer, + GLfloat depth, + GLint stencil); +angle::CallCapture CaptureClearBufferfv(const State &glState, + bool isCallValid, + GLenum buffer, + GLint drawbuffer, + const GLfloat *value); +angle::CallCapture CaptureClearBufferiv(const State &glState, + bool isCallValid, + GLenum buffer, + GLint drawbuffer, + const GLint *value); +angle::CallCapture CaptureClearBufferuiv(const State &glState, + bool isCallValid, + GLenum buffer, + GLint drawbuffer, + const GLuint *value); +angle::CallCapture CaptureClientWaitSync(const State &glState, + bool isCallValid, + GLsync sync, + GLbitfield flags, + GLuint64 timeout, + GLenum returnValue); +angle::CallCapture CaptureCompressedTexImage3D(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLsizei imageSize, + const void *data); +angle::CallCapture CaptureCompressedTexSubImage3D(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + const void *data); +angle::CallCapture CaptureCopyBufferSubData(const State &glState, + bool isCallValid, + BufferBinding readTargetPacked, + BufferBinding writeTargetPacked, + GLintptr readOffset, + GLintptr writeOffset, + GLsizeiptr size); +angle::CallCapture CaptureCopyTexSubImage3D(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLint x, + GLint y, + GLsizei width, + GLsizei height); +angle::CallCapture CaptureDeleteQueries(const State &glState, + bool isCallValid, + GLsizei n, + const QueryID *idsPacked); +angle::CallCapture CaptureDeleteSamplers(const State &glState, + bool isCallValid, + GLsizei count, + const SamplerID *samplersPacked); +angle::CallCapture CaptureDeleteSync(const State &glState, bool isCallValid, GLsync sync); +angle::CallCapture CaptureDeleteTransformFeedbacks(const State &glState, + bool isCallValid, + GLsizei n, + const TransformFeedbackID *idsPacked); +angle::CallCapture CaptureDeleteVertexArrays(const State &glState, + bool isCallValid, + GLsizei n, + const VertexArrayID *arraysPacked); +angle::CallCapture CaptureDrawArraysInstanced(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLint first, + GLsizei count, + GLsizei instancecount); +angle::CallCapture CaptureDrawBuffers(const State &glState, + bool isCallValid, + GLsizei n, + const GLenum *bufs); +angle::CallCapture CaptureDrawElementsInstanced(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei instancecount); +angle::CallCapture CaptureDrawRangeElements(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLuint start, + GLuint end, + GLsizei count, + DrawElementsType typePacked, + const void *indices); +angle::CallCapture CaptureEndQuery(const State &glState, bool isCallValid, QueryType targetPacked); +angle::CallCapture CaptureEndTransformFeedback(const State &glState, bool isCallValid); +angle::CallCapture CaptureFenceSync(const State &glState, + bool isCallValid, + GLenum condition, + GLbitfield flags, + GLsync returnValue); +angle::CallCapture CaptureFlushMappedBufferRange(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLintptr offset, + GLsizeiptr length); +angle::CallCapture CaptureFramebufferTextureLayer(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + TextureID texturePacked, + GLint level, + GLint layer); +angle::CallCapture CaptureGenQueries(const State &glState, + bool isCallValid, + GLsizei n, + QueryID *idsPacked); +angle::CallCapture CaptureGenSamplers(const State &glState, + bool isCallValid, + GLsizei count, + SamplerID *samplersPacked); +angle::CallCapture CaptureGenTransformFeedbacks(const State &glState, + bool isCallValid, + GLsizei n, + TransformFeedbackID *idsPacked); +angle::CallCapture CaptureGenVertexArrays(const State &glState, + bool isCallValid, + GLsizei n, + VertexArrayID *arraysPacked); +angle::CallCapture CaptureGetActiveUniformBlockName(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformBlockIndex uniformBlockIndexPacked, + GLsizei bufSize, + GLsizei *length, + GLchar *uniformBlockName); +angle::CallCapture CaptureGetActiveUniformBlockiv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformBlockIndex uniformBlockIndexPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetActiveUniformsiv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei uniformCount, + const GLuint *uniformIndices, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetBufferParameteri64v(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum pname, + GLint64 *params); +angle::CallCapture CaptureGetBufferPointerv(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum pname, + void **params); +angle::CallCapture CaptureGetFragDataLocation(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + const GLchar *name, + GLint returnValue); +angle::CallCapture CaptureGetInteger64i_v(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLint64 *data); +angle::CallCapture CaptureGetInteger64v(const State &glState, + bool isCallValid, + GLenum pname, + GLint64 *data); +angle::CallCapture CaptureGetIntegeri_v(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLint *data); +angle::CallCapture CaptureGetInternalformativ(const State &glState, + bool isCallValid, + GLenum target, + GLenum internalformat, + GLenum pname, + GLsizei count, + GLint *params); +angle::CallCapture CaptureGetProgramBinary(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei bufSize, + GLsizei *length, + GLenum *binaryFormat, + void *binary); +angle::CallCapture CaptureGetQueryObjectuiv(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLuint *params); +angle::CallCapture CaptureGetQueryiv(const State &glState, + bool isCallValid, + QueryType targetPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetSamplerParameterfv(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLfloat *params); +angle::CallCapture CaptureGetSamplerParameteriv(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetStringi(const State &glState, + bool isCallValid, + GLenum name, + GLuint index, + const GLubyte *returnValue); +angle::CallCapture CaptureGetSynciv(const State &glState, + bool isCallValid, + GLsync sync, + GLenum pname, + GLsizei count, + GLsizei *length, + GLint *values); +angle::CallCapture CaptureGetTransformFeedbackVarying(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLsizei *size, + GLenum *type, + GLchar *name); +angle::CallCapture CaptureGetUniformBlockIndex(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + const GLchar *uniformBlockName, + GLuint returnValue); +angle::CallCapture CaptureGetUniformIndices(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei uniformCount, + const GLchar *const *uniformNames, + GLuint *uniformIndices); +angle::CallCapture CaptureGetUniformuiv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLuint *params); +angle::CallCapture CaptureGetVertexAttribIiv(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetVertexAttribIuiv(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLuint *params); +angle::CallCapture CaptureInvalidateFramebuffer(const State &glState, + bool isCallValid, + GLenum target, + GLsizei numAttachments, + const GLenum *attachments); +angle::CallCapture CaptureInvalidateSubFramebuffer(const State &glState, + bool isCallValid, + GLenum target, + GLsizei numAttachments, + const GLenum *attachments, + GLint x, + GLint y, + GLsizei width, + GLsizei height); +angle::CallCapture CaptureIsQuery(const State &glState, + bool isCallValid, + QueryID idPacked, + GLboolean returnValue); +angle::CallCapture CaptureIsSampler(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLboolean returnValue); +angle::CallCapture CaptureIsSync(const State &glState, + bool isCallValid, + GLsync sync, + GLboolean returnValue); +angle::CallCapture CaptureIsTransformFeedback(const State &glState, + bool isCallValid, + TransformFeedbackID idPacked, + GLboolean returnValue); +angle::CallCapture CaptureIsVertexArray(const State &glState, + bool isCallValid, + VertexArrayID arrayPacked, + GLboolean returnValue); +angle::CallCapture CaptureMapBufferRange(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLintptr offset, + GLsizeiptr length, + GLbitfield access, + void *returnValue); +angle::CallCapture CapturePauseTransformFeedback(const State &glState, bool isCallValid); +angle::CallCapture CaptureProgramBinary(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum binaryFormat, + const void *binary, + GLsizei length); +angle::CallCapture CaptureProgramParameteri(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum pname, + GLint value); +angle::CallCapture CaptureReadBuffer(const State &glState, bool isCallValid, GLenum src); +angle::CallCapture CaptureRenderbufferStorageMultisample(const State &glState, + bool isCallValid, + GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height); +angle::CallCapture CaptureResumeTransformFeedback(const State &glState, bool isCallValid); +angle::CallCapture CaptureSamplerParameterf(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLfloat param); +angle::CallCapture CaptureSamplerParameterfv(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + const GLfloat *param); +angle::CallCapture CaptureSamplerParameteri(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLint param); +angle::CallCapture CaptureSamplerParameteriv(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + const GLint *param); +angle::CallCapture CaptureTexImage3D(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLenum format, + GLenum type, + const void *pixels); +angle::CallCapture CaptureTexStorage2D(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height); +angle::CallCapture CaptureTexStorage3D(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth); +angle::CallCapture CaptureTexSubImage3D(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + const void *pixels); +angle::CallCapture CaptureTransformFeedbackVaryings(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei count, + const GLchar *const *varyings, + GLenum bufferMode); +angle::CallCapture CaptureUniform1ui(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLuint v0); +angle::CallCapture CaptureUniform1uiv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value); +angle::CallCapture CaptureUniform2ui(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLuint v0, + GLuint v1); +angle::CallCapture CaptureUniform2uiv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value); +angle::CallCapture CaptureUniform3ui(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLuint v0, + GLuint v1, + GLuint v2); +angle::CallCapture CaptureUniform3uiv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value); +angle::CallCapture CaptureUniform4ui(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLuint v0, + GLuint v1, + GLuint v2, + GLuint v3); +angle::CallCapture CaptureUniform4uiv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value); +angle::CallCapture CaptureUniformBlockBinding(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformBlockIndex uniformBlockIndexPacked, + GLuint uniformBlockBinding); +angle::CallCapture CaptureUniformMatrix2x3fv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureUniformMatrix2x4fv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureUniformMatrix3x2fv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureUniformMatrix3x4fv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureUniformMatrix4x2fv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureUniformMatrix4x3fv(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureUnmapBuffer(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLboolean returnValue); +angle::CallCapture CaptureVertexAttribDivisor(const State &glState, + bool isCallValid, + GLuint index, + GLuint divisor); +angle::CallCapture CaptureVertexAttribI4i(const State &glState, + bool isCallValid, + GLuint index, + GLint x, + GLint y, + GLint z, + GLint w); +angle::CallCapture CaptureVertexAttribI4iv(const State &glState, + bool isCallValid, + GLuint index, + const GLint *v); +angle::CallCapture CaptureVertexAttribI4ui(const State &glState, + bool isCallValid, + GLuint index, + GLuint x, + GLuint y, + GLuint z, + GLuint w); +angle::CallCapture CaptureVertexAttribI4uiv(const State &glState, + bool isCallValid, + GLuint index, + const GLuint *v); +angle::CallCapture CaptureVertexAttribIPointer(const State &glState, + bool isCallValid, + GLuint index, + GLint size, + VertexAttribType typePacked, + GLsizei stride, + const void *pointer); +angle::CallCapture CaptureWaitSync(const State &glState, + bool isCallValid, + GLsync sync, + GLbitfield flags, + GLuint64 timeout); + +// Parameter Captures + +void CaptureClearBufferfv_value(const State &glState, + bool isCallValid, + GLenum buffer, + GLint drawbuffer, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureClearBufferiv_value(const State &glState, + bool isCallValid, + GLenum buffer, + GLint drawbuffer, + const GLint *value, + angle::ParamCapture *paramCapture); +void CaptureClearBufferuiv_value(const State &glState, + bool isCallValid, + GLenum buffer, + GLint drawbuffer, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureCompressedTexImage3D_data(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLsizei imageSize, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureCompressedTexSubImage3D_data(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureDeleteQueries_idsPacked(const State &glState, + bool isCallValid, + GLsizei n, + const QueryID *idsPacked, + angle::ParamCapture *paramCapture); +void CaptureDeleteSamplers_samplersPacked(const State &glState, + bool isCallValid, + GLsizei count, + const SamplerID *samplersPacked, + angle::ParamCapture *paramCapture); +void CaptureDeleteTransformFeedbacks_idsPacked(const State &glState, + bool isCallValid, + GLsizei n, + const TransformFeedbackID *idsPacked, + angle::ParamCapture *paramCapture); +void CaptureDeleteVertexArrays_arraysPacked(const State &glState, + bool isCallValid, + GLsizei n, + const VertexArrayID *arraysPacked, + angle::ParamCapture *paramCapture); +void CaptureDrawBuffers_bufs(const State &glState, + bool isCallValid, + GLsizei n, + const GLenum *bufs, + angle::ParamCapture *paramCapture); +void CaptureDrawElementsInstanced_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei instancecount, + angle::ParamCapture *paramCapture); +void CaptureDrawRangeElements_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLuint start, + GLuint end, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + angle::ParamCapture *paramCapture); +void CaptureGenQueries_idsPacked(const State &glState, + bool isCallValid, + GLsizei n, + QueryID *idsPacked, + angle::ParamCapture *paramCapture); +void CaptureGenSamplers_samplersPacked(const State &glState, + bool isCallValid, + GLsizei count, + SamplerID *samplersPacked, + angle::ParamCapture *paramCapture); +void CaptureGenTransformFeedbacks_idsPacked(const State &glState, + bool isCallValid, + GLsizei n, + TransformFeedbackID *idsPacked, + angle::ParamCapture *paramCapture); +void CaptureGenVertexArrays_arraysPacked(const State &glState, + bool isCallValid, + GLsizei n, + VertexArrayID *arraysPacked, + angle::ParamCapture *paramCapture); +void CaptureGetActiveUniformBlockName_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformBlockIndex uniformBlockIndexPacked, + GLsizei bufSize, + GLsizei *length, + GLchar *uniformBlockName, + angle::ParamCapture *paramCapture); +void CaptureGetActiveUniformBlockName_uniformBlockName(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformBlockIndex uniformBlockIndexPacked, + GLsizei bufSize, + GLsizei *length, + GLchar *uniformBlockName, + angle::ParamCapture *paramCapture); +void CaptureGetActiveUniformBlockiv_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformBlockIndex uniformBlockIndexPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetActiveUniformsiv_uniformIndices(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei uniformCount, + const GLuint *uniformIndices, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetActiveUniformsiv_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei uniformCount, + const GLuint *uniformIndices, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetBufferParameteri64v_params(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum pname, + GLint64 *params, + angle::ParamCapture *paramCapture); +void CaptureGetBufferPointerv_params(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum pname, + void **params, + angle::ParamCapture *paramCapture); +void CaptureGetFragDataLocation_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetInteger64i_v_data(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLint64 *data, + angle::ParamCapture *paramCapture); +void CaptureGetInteger64v_data(const State &glState, + bool isCallValid, + GLenum pname, + GLint64 *data, + angle::ParamCapture *paramCapture); +void CaptureGetIntegeri_v_data(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLint *data, + angle::ParamCapture *paramCapture); +void CaptureGetInternalformativ_params(const State &glState, + bool isCallValid, + GLenum target, + GLenum internalformat, + GLenum pname, + GLsizei count, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetProgramBinary_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei bufSize, + GLsizei *length, + GLenum *binaryFormat, + void *binary, + angle::ParamCapture *paramCapture); +void CaptureGetProgramBinary_binaryFormat(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei bufSize, + GLsizei *length, + GLenum *binaryFormat, + void *binary, + angle::ParamCapture *paramCapture); +void CaptureGetProgramBinary_binary(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei bufSize, + GLsizei *length, + GLenum *binaryFormat, + void *binary, + angle::ParamCapture *paramCapture); +void CaptureGetQueryObjectuiv_params(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetQueryiv_params(const State &glState, + bool isCallValid, + QueryType targetPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetSamplerParameterfv_params(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetSamplerParameteriv_params(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetSynciv_length(const State &glState, + bool isCallValid, + GLsync sync, + GLenum pname, + GLsizei count, + GLsizei *length, + GLint *values, + angle::ParamCapture *paramCapture); +void CaptureGetSynciv_values(const State &glState, + bool isCallValid, + GLsync sync, + GLenum pname, + GLsizei count, + GLsizei *length, + GLint *values, + angle::ParamCapture *paramCapture); +void CaptureGetTransformFeedbackVarying_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLsizei *size, + GLenum *type, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetTransformFeedbackVarying_size(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLsizei *size, + GLenum *type, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetTransformFeedbackVarying_type(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLsizei *size, + GLenum *type, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetTransformFeedbackVarying_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLsizei *size, + GLenum *type, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetUniformBlockIndex_uniformBlockName(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + const GLchar *uniformBlockName, + angle::ParamCapture *paramCapture); +void CaptureGetUniformIndices_uniformNames(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei uniformCount, + const GLchar *const *uniformNames, + GLuint *uniformIndices, + angle::ParamCapture *paramCapture); +void CaptureGetUniformIndices_uniformIndices(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei uniformCount, + const GLchar *const *uniformNames, + GLuint *uniformIndices, + angle::ParamCapture *paramCapture); +void CaptureGetUniformuiv_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetVertexAttribIiv_params(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetVertexAttribIuiv_params(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureInvalidateFramebuffer_attachments(const State &glState, + bool isCallValid, + GLenum target, + GLsizei numAttachments, + const GLenum *attachments, + angle::ParamCapture *paramCapture); +void CaptureInvalidateSubFramebuffer_attachments(const State &glState, + bool isCallValid, + GLenum target, + GLsizei numAttachments, + const GLenum *attachments, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + angle::ParamCapture *paramCapture); +void CaptureProgramBinary_binary(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum binaryFormat, + const void *binary, + GLsizei length, + angle::ParamCapture *paramCapture); +void CaptureSamplerParameterfv_param(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + const GLfloat *param, + angle::ParamCapture *paramCapture); +void CaptureSamplerParameteriv_param(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + const GLint *param, + angle::ParamCapture *paramCapture); +void CaptureTexImage3D_pixels(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLenum format, + GLenum type, + const void *pixels, + angle::ParamCapture *paramCapture); +void CaptureTexSubImage3D_pixels(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + const void *pixels, + angle::ParamCapture *paramCapture); +void CaptureTransformFeedbackVaryings_varyings(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei count, + const GLchar *const *varyings, + GLenum bufferMode, + angle::ParamCapture *paramCapture); +void CaptureUniform1uiv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureUniform2uiv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureUniform3uiv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureUniform4uiv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix2x3fv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix2x4fv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix3x2fv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix3x4fv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix4x2fv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureUniformMatrix4x3fv_value(const State &glState, + bool isCallValid, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribI4iv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLint *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribI4uiv_v(const State &glState, + bool isCallValid, + GLuint index, + const GLuint *v, + angle::ParamCapture *paramCapture); +void CaptureVertexAttribIPointer_pointer(const State &glState, + bool isCallValid, + GLuint index, + GLint size, + VertexAttribType typePacked, + GLsizei stride, + const void *pointer, + angle::ParamCapture *paramCapture); +} // namespace gl + +#endif // LIBANGLE_CAPTURE_GLES_3_0_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_1_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_1_autogen.h new file mode 100644 index 0000000000..ee594a1c79 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_1_autogen.h @@ -0,0 +1,728 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml. +// +// 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. +// +// capture_gles_3_1_autogen.h: +// Capture functions for the OpenGL ES 3.1 entry points. + +#ifndef LIBANGLE_CAPTURE_GLES_3_1_AUTOGEN_H_ +#define LIBANGLE_CAPTURE_GLES_3_1_AUTOGEN_H_ + +#include "common/PackedEnums.h" +#include "libANGLE/capture/FrameCapture.h" + +namespace gl +{ + +// Method Captures + +angle::CallCapture CaptureActiveShaderProgram(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked, + ShaderProgramID programPacked); +angle::CallCapture CaptureBindImageTexture(const State &glState, + bool isCallValid, + GLuint unit, + TextureID texturePacked, + GLint level, + GLboolean layered, + GLint layer, + GLenum access, + GLenum format); +angle::CallCapture CaptureBindProgramPipeline(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked); +angle::CallCapture CaptureBindVertexBuffer(const State &glState, + bool isCallValid, + GLuint bindingindex, + BufferID bufferPacked, + GLintptr offset, + GLsizei stride); +angle::CallCapture CaptureCreateShaderProgramv(const State &glState, + bool isCallValid, + ShaderType typePacked, + GLsizei count, + const GLchar *const *strings, + GLuint returnValue); +angle::CallCapture CaptureDeleteProgramPipelines(const State &glState, + bool isCallValid, + GLsizei n, + const ProgramPipelineID *pipelinesPacked); +angle::CallCapture CaptureDispatchCompute(const State &glState, + bool isCallValid, + GLuint num_groups_x, + GLuint num_groups_y, + GLuint num_groups_z); +angle::CallCapture CaptureDispatchComputeIndirect(const State &glState, + bool isCallValid, + GLintptr indirect); +angle::CallCapture CaptureDrawArraysIndirect(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const void *indirect); +angle::CallCapture CaptureDrawElementsIndirect(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + DrawElementsType typePacked, + const void *indirect); +angle::CallCapture CaptureFramebufferParameteri(const State &glState, + bool isCallValid, + GLenum target, + GLenum pname, + GLint param); +angle::CallCapture CaptureGenProgramPipelines(const State &glState, + bool isCallValid, + GLsizei n, + ProgramPipelineID *pipelinesPacked); +angle::CallCapture CaptureGetBooleani_v(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLboolean *data); +angle::CallCapture CaptureGetFramebufferParameteriv(const State &glState, + bool isCallValid, + GLenum target, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetMultisamplefv(const State &glState, + bool isCallValid, + GLenum pname, + GLuint index, + GLfloat *val); +angle::CallCapture CaptureGetProgramInterfaceiv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetProgramPipelineInfoLog(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog); +angle::CallCapture CaptureGetProgramPipelineiv(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetProgramResourceIndex(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + const GLchar *name, + GLuint returnValue); +angle::CallCapture CaptureGetProgramResourceLocation(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + const GLchar *name, + GLint returnValue); +angle::CallCapture CaptureGetProgramResourceName(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLchar *name); +angle::CallCapture CaptureGetProgramResourceiv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + GLuint index, + GLsizei propCount, + const GLenum *props, + GLsizei count, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetTexLevelParameterfv(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum pname, + GLfloat *params); +angle::CallCapture CaptureGetTexLevelParameteriv(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum pname, + GLint *params); +angle::CallCapture CaptureIsProgramPipeline(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked, + GLboolean returnValue); +angle::CallCapture CaptureMemoryBarrier(const State &glState, + bool isCallValid, + GLbitfield barriers); +angle::CallCapture CaptureMemoryBarrierByRegion(const State &glState, + bool isCallValid, + GLbitfield barriers); +angle::CallCapture CaptureProgramUniform1f(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLfloat v0); +angle::CallCapture CaptureProgramUniform1fv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value); +angle::CallCapture CaptureProgramUniform1i(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLint v0); +angle::CallCapture CaptureProgramUniform1iv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLint *value); +angle::CallCapture CaptureProgramUniform1ui(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLuint v0); +angle::CallCapture CaptureProgramUniform1uiv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value); +angle::CallCapture CaptureProgramUniform2f(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLfloat v0, + GLfloat v1); +angle::CallCapture CaptureProgramUniform2fv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value); +angle::CallCapture CaptureProgramUniform2i(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLint v0, + GLint v1); +angle::CallCapture CaptureProgramUniform2iv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLint *value); +angle::CallCapture CaptureProgramUniform2ui(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLuint v0, + GLuint v1); +angle::CallCapture CaptureProgramUniform2uiv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value); +angle::CallCapture CaptureProgramUniform3f(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLfloat v0, + GLfloat v1, + GLfloat v2); +angle::CallCapture CaptureProgramUniform3fv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value); +angle::CallCapture CaptureProgramUniform3i(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLint v0, + GLint v1, + GLint v2); +angle::CallCapture CaptureProgramUniform3iv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLint *value); +angle::CallCapture CaptureProgramUniform3ui(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLuint v0, + GLuint v1, + GLuint v2); +angle::CallCapture CaptureProgramUniform3uiv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value); +angle::CallCapture CaptureProgramUniform4f(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLfloat v0, + GLfloat v1, + GLfloat v2, + GLfloat v3); +angle::CallCapture CaptureProgramUniform4fv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value); +angle::CallCapture CaptureProgramUniform4i(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLint v0, + GLint v1, + GLint v2, + GLint v3); +angle::CallCapture CaptureProgramUniform4iv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLint *value); +angle::CallCapture CaptureProgramUniform4ui(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLuint v0, + GLuint v1, + GLuint v2, + GLuint v3); +angle::CallCapture CaptureProgramUniform4uiv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value); +angle::CallCapture CaptureProgramUniformMatrix2fv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureProgramUniformMatrix2x3fv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureProgramUniformMatrix2x4fv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureProgramUniformMatrix3fv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureProgramUniformMatrix3x2fv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureProgramUniformMatrix3x4fv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureProgramUniformMatrix4fv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureProgramUniformMatrix4x2fv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureProgramUniformMatrix4x3fv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureSampleMaski(const State &glState, + bool isCallValid, + GLuint maskNumber, + GLbitfield mask); +angle::CallCapture CaptureTexStorage2DMultisample(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLboolean fixedsamplelocations); +angle::CallCapture CaptureUseProgramStages(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked, + GLbitfield stages, + ShaderProgramID programPacked); +angle::CallCapture CaptureValidateProgramPipeline(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked); +angle::CallCapture CaptureVertexAttribBinding(const State &glState, + bool isCallValid, + GLuint attribindex, + GLuint bindingindex); +angle::CallCapture CaptureVertexAttribFormat(const State &glState, + bool isCallValid, + GLuint attribindex, + GLint size, + VertexAttribType typePacked, + GLboolean normalized, + GLuint relativeoffset); +angle::CallCapture CaptureVertexAttribIFormat(const State &glState, + bool isCallValid, + GLuint attribindex, + GLint size, + VertexAttribType typePacked, + GLuint relativeoffset); +angle::CallCapture CaptureVertexBindingDivisor(const State &glState, + bool isCallValid, + GLuint bindingindex, + GLuint divisor); + +// Parameter Captures + +void CaptureCreateShaderProgramv_strings(const State &glState, + bool isCallValid, + ShaderType typePacked, + GLsizei count, + const GLchar *const *strings, + angle::ParamCapture *paramCapture); +void CaptureDeleteProgramPipelines_pipelinesPacked(const State &glState, + bool isCallValid, + GLsizei n, + const ProgramPipelineID *pipelinesPacked, + angle::ParamCapture *paramCapture); +void CaptureDrawArraysIndirect_indirect(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const void *indirect, + angle::ParamCapture *paramCapture); +void CaptureDrawElementsIndirect_indirect(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + DrawElementsType typePacked, + const void *indirect, + angle::ParamCapture *paramCapture); +void CaptureGenProgramPipelines_pipelinesPacked(const State &glState, + bool isCallValid, + GLsizei n, + ProgramPipelineID *pipelinesPacked, + angle::ParamCapture *paramCapture); +void CaptureGetBooleani_v_data(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLboolean *data, + angle::ParamCapture *paramCapture); +void CaptureGetFramebufferParameteriv_params(const State &glState, + bool isCallValid, + GLenum target, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetMultisamplefv_val(const State &glState, + bool isCallValid, + GLenum pname, + GLuint index, + GLfloat *val, + angle::ParamCapture *paramCapture); +void CaptureGetProgramInterfaceiv_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetProgramPipelineInfoLog_length(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog, + angle::ParamCapture *paramCapture); +void CaptureGetProgramPipelineInfoLog_infoLog(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog, + angle::ParamCapture *paramCapture); +void CaptureGetProgramPipelineiv_params(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetProgramResourceIndex_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetProgramResourceLocation_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetProgramResourceName_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetProgramResourceName_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetProgramResourceiv_props(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + GLuint index, + GLsizei propCount, + const GLenum *props, + GLsizei count, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetProgramResourceiv_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + GLuint index, + GLsizei propCount, + const GLenum *props, + GLsizei count, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetProgramResourceiv_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + GLuint index, + GLsizei propCount, + const GLenum *props, + GLsizei count, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexLevelParameterfv_params(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum pname, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexLevelParameteriv_params(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform1fv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform1iv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLint *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform1uiv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform2fv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform2iv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLint *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform2uiv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform3fv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform3iv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLint *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform3uiv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform4fv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform4iv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLint *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform4uiv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix2fv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix2x3fv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix2x4fv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix3fv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix3x2fv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix3x4fv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix4fv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix4x2fv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix4x3fv_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +} // namespace gl + +#endif // LIBANGLE_CAPTURE_GLES_3_1_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_2_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_2_autogen.h new file mode 100644 index 0000000000..80001a0348 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_3_2_autogen.h @@ -0,0 +1,553 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml. +// +// 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. +// +// capture_gles_3_2_autogen.h: +// Capture functions for the OpenGL ES 3.2 entry points. + +#ifndef LIBANGLE_CAPTURE_GLES_3_2_AUTOGEN_H_ +#define LIBANGLE_CAPTURE_GLES_3_2_AUTOGEN_H_ + +#include "common/PackedEnums.h" +#include "libANGLE/capture/FrameCapture.h" + +namespace gl +{ + +// Method Captures + +angle::CallCapture CaptureBlendBarrier(const State &glState, bool isCallValid); +angle::CallCapture CaptureBlendEquationSeparatei(const State &glState, + bool isCallValid, + GLuint buf, + GLenum modeRGB, + GLenum modeAlpha); +angle::CallCapture CaptureBlendEquationi(const State &glState, + bool isCallValid, + GLuint buf, + GLenum mode); +angle::CallCapture CaptureBlendFuncSeparatei(const State &glState, + bool isCallValid, + GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha); +angle::CallCapture CaptureBlendFunci(const State &glState, + bool isCallValid, + GLuint buf, + GLenum src, + GLenum dst); +angle::CallCapture CaptureColorMaski(const State &glState, + bool isCallValid, + GLuint index, + GLboolean r, + GLboolean g, + GLboolean b, + GLboolean a); +angle::CallCapture CaptureCopyImageSubData(const State &glState, + bool isCallValid, + GLuint srcName, + GLenum srcTarget, + GLint srcLevel, + GLint srcX, + GLint srcY, + GLint srcZ, + GLuint dstName, + GLenum dstTarget, + GLint dstLevel, + GLint dstX, + GLint dstY, + GLint dstZ, + GLsizei srcWidth, + GLsizei srcHeight, + GLsizei srcDepth); +angle::CallCapture CaptureDebugMessageCallback(const State &glState, + bool isCallValid, + GLDEBUGPROC callback, + const void *userParam); +angle::CallCapture CaptureDebugMessageControl(const State &glState, + bool isCallValid, + GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint *ids, + GLboolean enabled); +angle::CallCapture CaptureDebugMessageInsert(const State &glState, + bool isCallValid, + GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar *buf); +angle::CallCapture CaptureDisablei(const State &glState, + bool isCallValid, + GLenum target, + GLuint index); +angle::CallCapture CaptureDrawElementsBaseVertex(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLint basevertex); +angle::CallCapture CaptureDrawElementsInstancedBaseVertex(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei instancecount, + GLint basevertex); +angle::CallCapture CaptureDrawRangeElementsBaseVertex(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLuint start, + GLuint end, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLint basevertex); +angle::CallCapture CaptureEnablei(const State &glState, + bool isCallValid, + GLenum target, + GLuint index); +angle::CallCapture CaptureFramebufferTexture(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + TextureID texturePacked, + GLint level); +angle::CallCapture CaptureGetDebugMessageLog(const State &glState, + bool isCallValid, + GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog, + GLuint returnValue); +angle::CallCapture CaptureGetGraphicsResetStatus(const State &glState, + bool isCallValid, + GLenum returnValue); +angle::CallCapture CaptureGetObjectLabel(const State &glState, + bool isCallValid, + GLenum identifier, + GLuint name, + GLsizei bufSize, + GLsizei *length, + GLchar *label); +angle::CallCapture CaptureGetObjectPtrLabel(const State &glState, + bool isCallValid, + const void *ptr, + GLsizei bufSize, + GLsizei *length, + GLchar *label); +angle::CallCapture CaptureGetPointerv(const State &glState, + bool isCallValid, + GLenum pname, + void **params); +angle::CallCapture CaptureGetSamplerParameterIiv(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetSamplerParameterIuiv(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLuint *params); +angle::CallCapture CaptureGetTexParameterIiv(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetTexParameterIuiv(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLuint *params); +angle::CallCapture CaptureGetnUniformfv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLfloat *params); +angle::CallCapture CaptureGetnUniformiv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLint *params); +angle::CallCapture CaptureGetnUniformuiv(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLuint *params); +angle::CallCapture CaptureIsEnabledi(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLboolean returnValue); +angle::CallCapture CaptureMinSampleShading(const State &glState, bool isCallValid, GLfloat value); +angle::CallCapture CaptureObjectLabel(const State &glState, + bool isCallValid, + GLenum identifier, + GLuint name, + GLsizei length, + const GLchar *label); +angle::CallCapture CaptureObjectPtrLabel(const State &glState, + bool isCallValid, + const void *ptr, + GLsizei length, + const GLchar *label); +angle::CallCapture CapturePatchParameteri(const State &glState, + bool isCallValid, + GLenum pname, + GLint value); +angle::CallCapture CapturePopDebugGroup(const State &glState, bool isCallValid); +angle::CallCapture CapturePrimitiveBoundingBox(const State &glState, + bool isCallValid, + GLfloat minX, + GLfloat minY, + GLfloat minZ, + GLfloat minW, + GLfloat maxX, + GLfloat maxY, + GLfloat maxZ, + GLfloat maxW); +angle::CallCapture CapturePushDebugGroup(const State &glState, + bool isCallValid, + GLenum source, + GLuint id, + GLsizei length, + const GLchar *message); +angle::CallCapture CaptureReadnPixels(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + void *data); +angle::CallCapture CaptureSamplerParameterIiv(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + const GLint *param); +angle::CallCapture CaptureSamplerParameterIuiv(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + const GLuint *param); +angle::CallCapture CaptureTexBuffer(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum internalformat, + BufferID bufferPacked); +angle::CallCapture CaptureTexBufferRange(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum internalformat, + BufferID bufferPacked, + GLintptr offset, + GLsizeiptr size); +angle::CallCapture CaptureTexParameterIiv(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLint *params); +angle::CallCapture CaptureTexParameterIuiv(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLuint *params); +angle::CallCapture CaptureTexStorage3DMultisample(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedsamplelocations); + +// Parameter Captures + +void CaptureDebugMessageCallback_userParam(const State &glState, + bool isCallValid, + GLDEBUGPROC callback, + const void *userParam, + angle::ParamCapture *paramCapture); +void CaptureDebugMessageControl_ids(const State &glState, + bool isCallValid, + GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint *ids, + GLboolean enabled, + angle::ParamCapture *paramCapture); +void CaptureDebugMessageInsert_buf(const State &glState, + bool isCallValid, + GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar *buf, + angle::ParamCapture *paramCapture); +void CaptureDrawElementsBaseVertex_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLint basevertex, + angle::ParamCapture *paramCapture); +void CaptureDrawElementsInstancedBaseVertex_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei instancecount, + GLint basevertex, + angle::ParamCapture *paramCapture); +void CaptureDrawRangeElementsBaseVertex_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLuint start, + GLuint end, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLint basevertex, + angle::ParamCapture *paramCapture); +void CaptureGetDebugMessageLog_sources(const State &glState, + bool isCallValid, + GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog, + angle::ParamCapture *paramCapture); +void CaptureGetDebugMessageLog_types(const State &glState, + bool isCallValid, + GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog, + angle::ParamCapture *paramCapture); +void CaptureGetDebugMessageLog_ids(const State &glState, + bool isCallValid, + GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog, + angle::ParamCapture *paramCapture); +void CaptureGetDebugMessageLog_severities(const State &glState, + bool isCallValid, + GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog, + angle::ParamCapture *paramCapture); +void CaptureGetDebugMessageLog_lengths(const State &glState, + bool isCallValid, + GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog, + angle::ParamCapture *paramCapture); +void CaptureGetDebugMessageLog_messageLog(const State &glState, + bool isCallValid, + GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog, + angle::ParamCapture *paramCapture); +void CaptureGetObjectLabel_length(const State &glState, + bool isCallValid, + GLenum identifier, + GLuint name, + GLsizei bufSize, + GLsizei *length, + GLchar *label, + angle::ParamCapture *paramCapture); +void CaptureGetObjectLabel_label(const State &glState, + bool isCallValid, + GLenum identifier, + GLuint name, + GLsizei bufSize, + GLsizei *length, + GLchar *label, + angle::ParamCapture *paramCapture); +void CaptureGetObjectPtrLabel_ptr(const State &glState, + bool isCallValid, + const void *ptr, + GLsizei bufSize, + GLsizei *length, + GLchar *label, + angle::ParamCapture *paramCapture); +void CaptureGetObjectPtrLabel_length(const State &glState, + bool isCallValid, + const void *ptr, + GLsizei bufSize, + GLsizei *length, + GLchar *label, + angle::ParamCapture *paramCapture); +void CaptureGetObjectPtrLabel_label(const State &glState, + bool isCallValid, + const void *ptr, + GLsizei bufSize, + GLsizei *length, + GLchar *label, + angle::ParamCapture *paramCapture); +void CaptureGetPointerv_params(const State &glState, + bool isCallValid, + GLenum pname, + void **params, + angle::ParamCapture *paramCapture); +void CaptureGetSamplerParameterIiv_params(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetSamplerParameterIuiv_params(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexParameterIiv_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexParameterIuiv_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetnUniformfv_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetnUniformiv_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetnUniformuiv_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureObjectLabel_label(const State &glState, + bool isCallValid, + GLenum identifier, + GLuint name, + GLsizei length, + const GLchar *label, + angle::ParamCapture *paramCapture); +void CaptureObjectPtrLabel_ptr(const State &glState, + bool isCallValid, + const void *ptr, + GLsizei length, + const GLchar *label, + angle::ParamCapture *paramCapture); +void CaptureObjectPtrLabel_label(const State &glState, + bool isCallValid, + const void *ptr, + GLsizei length, + const GLchar *label, + angle::ParamCapture *paramCapture); +void CapturePushDebugGroup_message(const State &glState, + bool isCallValid, + GLenum source, + GLuint id, + GLsizei length, + const GLchar *message, + angle::ParamCapture *paramCapture); +void CaptureReadnPixels_data(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + void *data, + angle::ParamCapture *paramCapture); +void CaptureSamplerParameterIiv_param(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + const GLint *param, + angle::ParamCapture *paramCapture); +void CaptureSamplerParameterIuiv_param(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + const GLuint *param, + angle::ParamCapture *paramCapture); +void CaptureTexParameterIiv_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLint *params, + angle::ParamCapture *paramCapture); +void CaptureTexParameterIuiv_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLuint *params, + angle::ParamCapture *paramCapture); +} // namespace gl + +#endif // LIBANGLE_CAPTURE_GLES_3_2_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libANGLE/capture/capture_gles_ext_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_ext_autogen.h new file mode 100644 index 0000000000..03211ffeb9 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/capture_gles_ext_autogen.h @@ -0,0 +1,5231 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml. +// +// 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. +// +// capture_gles_ext_autogen.h: +// Capture functions for the OpenGL ES extension entry points. + +#ifndef LIBANGLE_CAPTURE_GLES_EXT_AUTOGEN_H_ +#define LIBANGLE_CAPTURE_GLES_EXT_AUTOGEN_H_ + +#include "common/PackedEnums.h" +#include "libANGLE/capture/FrameCapture.h" + +namespace gl +{ + +// Method Captures + +// GL_AMD_performance_monitor +angle::CallCapture CaptureBeginPerfMonitorAMD(const State &glState, + bool isCallValid, + GLuint monitor); +angle::CallCapture CaptureDeletePerfMonitorsAMD(const State &glState, + bool isCallValid, + GLsizei n, + GLuint *monitors); +angle::CallCapture CaptureEndPerfMonitorAMD(const State &glState, bool isCallValid, GLuint monitor); +angle::CallCapture CaptureGenPerfMonitorsAMD(const State &glState, + bool isCallValid, + GLsizei n, + GLuint *monitors); +angle::CallCapture CaptureGetPerfMonitorCounterDataAMD(const State &glState, + bool isCallValid, + GLuint monitor, + GLenum pname, + GLsizei dataSize, + GLuint *data, + GLint *bytesWritten); +angle::CallCapture CaptureGetPerfMonitorCounterInfoAMD(const State &glState, + bool isCallValid, + GLuint group, + GLuint counter, + GLenum pname, + void *data); +angle::CallCapture CaptureGetPerfMonitorCounterStringAMD(const State &glState, + bool isCallValid, + GLuint group, + GLuint counter, + GLsizei bufSize, + GLsizei *length, + GLchar *counterString); +angle::CallCapture CaptureGetPerfMonitorCountersAMD(const State &glState, + bool isCallValid, + GLuint group, + GLint *numCounters, + GLint *maxActiveCounters, + GLsizei counterSize, + GLuint *counters); +angle::CallCapture CaptureGetPerfMonitorGroupStringAMD(const State &glState, + bool isCallValid, + GLuint group, + GLsizei bufSize, + GLsizei *length, + GLchar *groupString); +angle::CallCapture CaptureGetPerfMonitorGroupsAMD(const State &glState, + bool isCallValid, + GLint *numGroups, + GLsizei groupsSize, + GLuint *groups); +angle::CallCapture CaptureSelectPerfMonitorCountersAMD(const State &glState, + bool isCallValid, + GLuint monitor, + GLboolean enable, + GLuint group, + GLint numCounters, + GLuint *counterList); + +// GL_ANDROID_extension_pack_es31a + +// GL_ANGLE_base_vertex_base_instance +angle::CallCapture CaptureDrawArraysInstancedBaseInstanceANGLE(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLint first, + GLsizei count, + GLsizei instanceCount, + GLuint baseInstance); +angle::CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE( + const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const GLvoid *indices, + GLsizei instanceCount, + GLint baseVertex, + GLuint baseInstance); +angle::CallCapture CaptureMultiDrawArraysInstancedBaseInstanceANGLE(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + const GLuint *baseInstances, + GLsizei drawcount); +angle::CallCapture CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE( + const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *counts, + DrawElementsType typePacked, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + const GLint *baseVertices, + const GLuint *baseInstances, + GLsizei drawcount); + +// GL_ANGLE_copy_texture_3d +angle::CallCapture CaptureCopyTexture3DANGLE(const State &glState, + bool isCallValid, + TextureID sourceIdPacked, + GLint sourceLevel, + TextureTarget destTargetPacked, + TextureID destIdPacked, + GLint destLevel, + GLint internalFormat, + GLenum destType, + GLboolean unpackFlipY, + GLboolean unpackPremultiplyAlpha, + GLboolean unpackUnmultiplyAlpha); +angle::CallCapture CaptureCopySubTexture3DANGLE(const State &glState, + bool isCallValid, + TextureID sourceIdPacked, + GLint sourceLevel, + TextureTarget destTargetPacked, + TextureID destIdPacked, + GLint destLevel, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLint x, + GLint y, + GLint z, + GLint width, + GLint height, + GLint depth, + GLboolean unpackFlipY, + GLboolean unpackPremultiplyAlpha, + GLboolean unpackUnmultiplyAlpha); + +// GL_ANGLE_depth_texture + +// GL_ANGLE_framebuffer_blit +angle::CallCapture CaptureBlitFramebufferANGLE(const State &glState, + bool isCallValid, + GLint srcX0, + GLint srcY0, + GLint srcX1, + GLint srcY1, + GLint dstX0, + GLint dstY0, + GLint dstX1, + GLint dstY1, + GLbitfield mask, + GLenum filter); + +// GL_ANGLE_framebuffer_multisample +angle::CallCapture CaptureRenderbufferStorageMultisampleANGLE(const State &glState, + bool isCallValid, + GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height); + +// GL_ANGLE_get_image +angle::CallCapture CaptureGetTexImageANGLE(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum format, + GLenum type, + void *pixels); +angle::CallCapture CaptureGetCompressedTexImageANGLE(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + void *pixels); +angle::CallCapture CaptureGetRenderbufferImageANGLE(const State &glState, + bool isCallValid, + GLenum target, + GLenum format, + GLenum type, + void *pixels); + +// GL_ANGLE_get_tex_level_parameter +angle::CallCapture CaptureGetTexLevelParameterivANGLE(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetTexLevelParameterfvANGLE(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum pname, + GLfloat *params); + +// GL_ANGLE_instanced_arrays +angle::CallCapture CaptureDrawArraysInstancedANGLE(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLint first, + GLsizei count, + GLsizei primcount); +angle::CallCapture CaptureDrawElementsInstancedANGLE(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei primcount); +angle::CallCapture CaptureVertexAttribDivisorANGLE(const State &glState, + bool isCallValid, + GLuint index, + GLuint divisor); + +// GL_ANGLE_logic_op +angle::CallCapture CaptureLogicOpANGLE(const State &glState, + bool isCallValid, + LogicalOperation opcodePacked); + +// GL_ANGLE_memory_object_flags +angle::CallCapture CaptureTexStorageMemFlags2DANGLE(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + MemoryObjectID memoryPacked, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext); +angle::CallCapture CaptureTexStorageMemFlags2DMultisampleANGLE(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLboolean fixedSampleLocations, + MemoryObjectID memoryPacked, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext); +angle::CallCapture CaptureTexStorageMemFlags3DANGLE(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + MemoryObjectID memoryPacked, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext); +angle::CallCapture CaptureTexStorageMemFlags3DMultisampleANGLE(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedSampleLocations, + MemoryObjectID memoryPacked, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext); + +// GL_ANGLE_memory_object_fuchsia +angle::CallCapture CaptureImportMemoryZirconHandleANGLE(const State &glState, + bool isCallValid, + MemoryObjectID memoryPacked, + GLuint64 size, + HandleType handleTypePacked, + GLuint handle); + +// GL_ANGLE_multi_draw +angle::CallCapture CaptureMultiDrawArraysANGLE(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLint *firsts, + const GLsizei *counts, + GLsizei drawcount); +angle::CallCapture CaptureMultiDrawArraysInstancedANGLE(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + GLsizei drawcount); +angle::CallCapture CaptureMultiDrawElementsANGLE(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *counts, + DrawElementsType typePacked, + const GLvoid *const *indices, + GLsizei drawcount); +angle::CallCapture CaptureMultiDrawElementsInstancedANGLE(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *counts, + DrawElementsType typePacked, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + GLsizei drawcount); + +// GL_ANGLE_pack_reverse_row_order + +// GL_ANGLE_program_binary + +// GL_ANGLE_provoking_vertex +angle::CallCapture CaptureProvokingVertexANGLE(const State &glState, + bool isCallValid, + ProvokingVertexConvention modePacked); + +// GL_ANGLE_request_extension +angle::CallCapture CaptureRequestExtensionANGLE(const State &glState, + bool isCallValid, + const GLchar *name); +angle::CallCapture CaptureDisableExtensionANGLE(const State &glState, + bool isCallValid, + const GLchar *name); + +// GL_ANGLE_robust_client_memory +angle::CallCapture CaptureGetBooleanvRobustANGLE(const State &glState, + bool isCallValid, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLboolean *params); +angle::CallCapture CaptureGetBufferParameterivRobustANGLE(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetFloatvRobustANGLE(const State &glState, + bool isCallValid, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params); +angle::CallCapture CaptureGetFramebufferAttachmentParameterivRobustANGLE(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetIntegervRobustANGLE(const State &glState, + bool isCallValid, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *data); +angle::CallCapture CaptureGetProgramivRobustANGLE(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetRenderbufferParameterivRobustANGLE(const State &glState, + bool isCallValid, + GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetShaderivRobustANGLE(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetTexParameterfvRobustANGLE(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params); +angle::CallCapture CaptureGetTexParameterivRobustANGLE(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetUniformfvRobustANGLE(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLfloat *params); +angle::CallCapture CaptureGetUniformivRobustANGLE(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetVertexAttribfvRobustANGLE(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params); +angle::CallCapture CaptureGetVertexAttribivRobustANGLE(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetVertexAttribPointervRobustANGLE(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **pointer); +angle::CallCapture CaptureReadPixelsRobustANGLE(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + GLsizei *length, + GLsizei *columns, + GLsizei *rows, + void *pixels); +angle::CallCapture CaptureTexImage2DRobustANGLE(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels); +angle::CallCapture CaptureTexParameterfvRobustANGLE(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + const GLfloat *params); +angle::CallCapture CaptureTexParameterivRobustANGLE(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + const GLint *params); +angle::CallCapture CaptureTexSubImage2DRobustANGLE(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels); +angle::CallCapture CaptureTexImage3DRobustANGLE(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels); +angle::CallCapture CaptureTexSubImage3DRobustANGLE(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels); +angle::CallCapture CaptureCompressedTexImage2DRobustANGLE(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data); +angle::CallCapture CaptureCompressedTexSubImage2DRobustANGLE(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLsizei xoffset, + GLsizei yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data); +angle::CallCapture CaptureCompressedTexImage3DRobustANGLE(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data); +angle::CallCapture CaptureCompressedTexSubImage3DRobustANGLE(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data); +angle::CallCapture CaptureGetQueryivRobustANGLE(const State &glState, + bool isCallValid, + QueryType targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetQueryObjectuivRobustANGLE(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params); +angle::CallCapture CaptureGetBufferPointervRobustANGLE(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **params); +angle::CallCapture CaptureGetIntegeri_vRobustANGLE(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *data); +angle::CallCapture CaptureGetInternalformativRobustANGLE(const State &glState, + bool isCallValid, + GLenum target, + GLenum internalformat, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetVertexAttribIivRobustANGLE(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetVertexAttribIuivRobustANGLE(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params); +angle::CallCapture CaptureGetUniformuivRobustANGLE(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLuint *params); +angle::CallCapture CaptureGetActiveUniformBlockivRobustANGLE( + const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformBlockIndex uniformBlockIndexPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetInteger64vRobustANGLE(const State &glState, + bool isCallValid, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *data); +angle::CallCapture CaptureGetInteger64i_vRobustANGLE(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint64 *data); +angle::CallCapture CaptureGetBufferParameteri64vRobustANGLE(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *params); +angle::CallCapture CaptureSamplerParameterivRobustANGLE(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLuint pname, + GLsizei bufSize, + const GLint *param); +angle::CallCapture CaptureSamplerParameterfvRobustANGLE(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + const GLfloat *param); +angle::CallCapture CaptureGetSamplerParameterivRobustANGLE(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetSamplerParameterfvRobustANGLE(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params); +angle::CallCapture CaptureGetFramebufferParameterivRobustANGLE(const State &glState, + bool isCallValid, + GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetProgramInterfaceivRobustANGLE(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetBooleani_vRobustANGLE(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLboolean *data); +angle::CallCapture CaptureGetMultisamplefvRobustANGLE(const State &glState, + bool isCallValid, + GLenum pname, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLfloat *val); +angle::CallCapture CaptureGetTexLevelParameterivRobustANGLE(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetTexLevelParameterfvRobustANGLE(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params); +angle::CallCapture CaptureGetPointervRobustANGLERobustANGLE(const State &glState, + bool isCallValid, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **params); +angle::CallCapture CaptureReadnPixelsRobustANGLE(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + GLsizei *length, + GLsizei *columns, + GLsizei *rows, + void *data); +angle::CallCapture CaptureGetnUniformfvRobustANGLE(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLfloat *params); +angle::CallCapture CaptureGetnUniformivRobustANGLE(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetnUniformuivRobustANGLE(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLuint *params); +angle::CallCapture CaptureTexParameterIivRobustANGLE(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + const GLint *params); +angle::CallCapture CaptureTexParameterIuivRobustANGLE(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + const GLuint *params); +angle::CallCapture CaptureGetTexParameterIivRobustANGLE(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetTexParameterIuivRobustANGLE(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params); +angle::CallCapture CaptureSamplerParameterIivRobustANGLE(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + const GLint *param); +angle::CallCapture CaptureSamplerParameterIuivRobustANGLE(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + const GLuint *param); +angle::CallCapture CaptureGetSamplerParameterIivRobustANGLE(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetSamplerParameterIuivRobustANGLE(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params); +angle::CallCapture CaptureGetQueryObjectivRobustANGLE(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +angle::CallCapture CaptureGetQueryObjecti64vRobustANGLE(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *params); +angle::CallCapture CaptureGetQueryObjectui64vRobustANGLE(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint64 *params); + +// GL_ANGLE_robust_resource_initialization + +// GL_ANGLE_semaphore_fuchsia +angle::CallCapture CaptureImportSemaphoreZirconHandleANGLE(const State &glState, + bool isCallValid, + SemaphoreID semaphorePacked, + HandleType handleTypePacked, + GLuint handle); + +// GL_ANGLE_shader_pixel_local_storage +angle::CallCapture CaptureFramebufferMemorylessPixelLocalStorageANGLE(const State &glState, + bool isCallValid, + GLint plane, + GLenum internalformat); +angle::CallCapture CaptureFramebufferTexturePixelLocalStorageANGLE(const State &glState, + bool isCallValid, + GLint plane, + TextureID backingtexturePacked, + GLint level, + GLint layer); +angle::CallCapture CaptureBeginPixelLocalStorageANGLE(const State &glState, + bool isCallValid, + GLsizei planes, + const GLenum *loadops, + const void *cleardata); +angle::CallCapture CaptureEndPixelLocalStorageANGLE(const State &glState, bool isCallValid); +angle::CallCapture CapturePixelLocalStorageBarrierANGLE(const State &glState, bool isCallValid); + +// GL_ANGLE_texture_compression_dxt3 + +// GL_ANGLE_texture_compression_dxt5 + +// GL_ANGLE_texture_external_update +angle::CallCapture CaptureTexImage2DExternalANGLE(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLenum format, + GLenum type); +angle::CallCapture CaptureInvalidateTextureANGLE(const State &glState, + bool isCallValid, + TextureType targetPacked); + +// GL_ANGLE_texture_multisample +angle::CallCapture CaptureTexStorage2DMultisampleANGLE(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLboolean fixedsamplelocations); +angle::CallCapture CaptureGetMultisamplefvANGLE(const State &glState, + bool isCallValid, + GLenum pname, + GLuint index, + GLfloat *val); +angle::CallCapture CaptureSampleMaskiANGLE(const State &glState, + bool isCallValid, + GLuint maskNumber, + GLbitfield mask); + +// GL_ANGLE_texture_usage + +// GL_ANGLE_translated_shader_source +angle::CallCapture CaptureGetTranslatedShaderSourceANGLE(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLsizei bufSize, + GLsizei *length, + GLchar *source); + +// GL_ANGLE_vulkan_image +angle::CallCapture CaptureAcquireTexturesANGLE(const State &glState, + bool isCallValid, + GLuint numTextures, + const TextureID *texturesPacked, + const GLenum *layouts); +angle::CallCapture CaptureReleaseTexturesANGLE(const State &glState, + bool isCallValid, + GLuint numTextures, + const TextureID *texturesPacked, + GLenum *layouts); + +// GL_APPLE_clip_distance + +// GL_ARB_sync + +// GL_CHROMIUM_bind_uniform_location +angle::CallCapture CaptureBindUniformLocationCHROMIUM(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + const GLchar *name); + +// GL_CHROMIUM_copy_compressed_texture +angle::CallCapture CaptureCompressedCopyTextureCHROMIUM(const State &glState, + bool isCallValid, + TextureID sourceIdPacked, + TextureID destIdPacked); + +// GL_CHROMIUM_copy_texture +angle::CallCapture CaptureCopyTextureCHROMIUM(const State &glState, + bool isCallValid, + TextureID sourceIdPacked, + GLint sourceLevel, + TextureTarget destTargetPacked, + TextureID destIdPacked, + GLint destLevel, + GLint internalFormat, + GLenum destType, + GLboolean unpackFlipY, + GLboolean unpackPremultiplyAlpha, + GLboolean unpackUnmultiplyAlpha); +angle::CallCapture CaptureCopySubTextureCHROMIUM(const State &glState, + bool isCallValid, + TextureID sourceIdPacked, + GLint sourceLevel, + TextureTarget destTargetPacked, + TextureID destIdPacked, + GLint destLevel, + GLint xoffset, + GLint yoffset, + GLint x, + GLint y, + GLint width, + GLint height, + GLboolean unpackFlipY, + GLboolean unpackPremultiplyAlpha, + GLboolean unpackUnmultiplyAlpha); + +// GL_CHROMIUM_framebuffer_mixed_samples +angle::CallCapture CaptureCoverageModulationCHROMIUM(const State &glState, + bool isCallValid, + GLenum components); + +// GL_CHROMIUM_lose_context +angle::CallCapture CaptureLoseContextCHROMIUM(const State &glState, + bool isCallValid, + GraphicsResetStatus currentPacked, + GraphicsResetStatus otherPacked); + +// GL_EXT_EGL_image_array + +// GL_EXT_EGL_image_storage +angle::CallCapture CaptureEGLImageTargetTexStorageEXT(const State &glState, + bool isCallValid, + GLenum target, + GLeglImageOES image, + const GLint *attrib_list); +angle::CallCapture CaptureEGLImageTargetTextureStorageEXT(const State &glState, + bool isCallValid, + GLuint texture, + GLeglImageOES image, + const GLint *attrib_list); + +// GL_EXT_YUV_target + +// GL_EXT_base_instance +angle::CallCapture CaptureDrawArraysInstancedBaseInstanceEXT(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLint first, + GLsizei count, + GLsizei instancecount, + GLuint baseinstance); +angle::CallCapture CaptureDrawElementsInstancedBaseInstanceEXT(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei instancecount, + GLuint baseinstance); +angle::CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstanceEXT( + const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei instancecount, + GLint basevertex, + GLuint baseinstance); + +// GL_EXT_blend_func_extended +angle::CallCapture CaptureBindFragDataLocationEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint color, + const GLchar *name); +angle::CallCapture CaptureBindFragDataLocationIndexedEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint colorNumber, + GLuint index, + const GLchar *name); +angle::CallCapture CaptureGetFragDataIndexEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + const GLchar *name, + GLint returnValue); +angle::CallCapture CaptureGetProgramResourceLocationIndexEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + const GLchar *name, + GLint returnValue); + +// GL_EXT_blend_minmax + +// GL_EXT_buffer_storage +angle::CallCapture CaptureBufferStorageEXT(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLsizeiptr size, + const void *data, + GLbitfield flags); + +// GL_EXT_clip_control +angle::CallCapture CaptureClipControlEXT(const State &glState, + bool isCallValid, + GLenum origin, + GLenum depth); + +// GL_EXT_clip_cull_distance + +// GL_EXT_color_buffer_float + +// GL_EXT_color_buffer_half_float + +// GL_EXT_copy_image +angle::CallCapture CaptureCopyImageSubDataEXT(const State &glState, + bool isCallValid, + GLuint srcName, + GLenum srcTarget, + GLint srcLevel, + GLint srcX, + GLint srcY, + GLint srcZ, + GLuint dstName, + GLenum dstTarget, + GLint dstLevel, + GLint dstX, + GLint dstY, + GLint dstZ, + GLsizei srcWidth, + GLsizei srcHeight, + GLsizei srcDepth); + +// GL_EXT_debug_label +angle::CallCapture CaptureGetObjectLabelEXT(const State &glState, + bool isCallValid, + GLenum type, + GLuint object, + GLsizei bufSize, + GLsizei *length, + GLchar *label); +angle::CallCapture CaptureLabelObjectEXT(const State &glState, + bool isCallValid, + GLenum type, + GLuint object, + GLsizei length, + const GLchar *label); + +// GL_EXT_debug_marker +angle::CallCapture CaptureInsertEventMarkerEXT(const State &glState, + bool isCallValid, + GLsizei length, + const GLchar *marker); +angle::CallCapture CapturePopGroupMarkerEXT(const State &glState, bool isCallValid); +angle::CallCapture CapturePushGroupMarkerEXT(const State &glState, + bool isCallValid, + GLsizei length, + const GLchar *marker); + +// GL_EXT_discard_framebuffer +angle::CallCapture CaptureDiscardFramebufferEXT(const State &glState, + bool isCallValid, + GLenum target, + GLsizei numAttachments, + const GLenum *attachments); + +// GL_EXT_disjoint_timer_query +angle::CallCapture CaptureBeginQueryEXT(const State &glState, + bool isCallValid, + QueryType targetPacked, + QueryID idPacked); +angle::CallCapture CaptureDeleteQueriesEXT(const State &glState, + bool isCallValid, + GLsizei n, + const QueryID *idsPacked); +angle::CallCapture CaptureEndQueryEXT(const State &glState, + bool isCallValid, + QueryType targetPacked); +angle::CallCapture CaptureGenQueriesEXT(const State &glState, + bool isCallValid, + GLsizei n, + QueryID *idsPacked); +angle::CallCapture CaptureGetInteger64vEXT(const State &glState, + bool isCallValid, + GLenum pname, + GLint64 *data); +angle::CallCapture CaptureGetQueryObjecti64vEXT(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLint64 *params); +angle::CallCapture CaptureGetQueryObjectivEXT(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetQueryObjectui64vEXT(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLuint64 *params); +angle::CallCapture CaptureGetQueryObjectuivEXT(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLuint *params); +angle::CallCapture CaptureGetQueryivEXT(const State &glState, + bool isCallValid, + QueryType targetPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureIsQueryEXT(const State &glState, + bool isCallValid, + QueryID idPacked, + GLboolean returnValue); +angle::CallCapture CaptureQueryCounterEXT(const State &glState, + bool isCallValid, + QueryID idPacked, + QueryType targetPacked); + +// GL_EXT_draw_buffers +angle::CallCapture CaptureDrawBuffersEXT(const State &glState, + bool isCallValid, + GLsizei n, + const GLenum *bufs); + +// GL_EXT_draw_buffers_indexed +angle::CallCapture CaptureBlendEquationSeparateiEXT(const State &glState, + bool isCallValid, + GLuint buf, + GLenum modeRGB, + GLenum modeAlpha); +angle::CallCapture CaptureBlendEquationiEXT(const State &glState, + bool isCallValid, + GLuint buf, + GLenum mode); +angle::CallCapture CaptureBlendFuncSeparateiEXT(const State &glState, + bool isCallValid, + GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha); +angle::CallCapture CaptureBlendFunciEXT(const State &glState, + bool isCallValid, + GLuint buf, + GLenum src, + GLenum dst); +angle::CallCapture CaptureColorMaskiEXT(const State &glState, + bool isCallValid, + GLuint index, + GLboolean r, + GLboolean g, + GLboolean b, + GLboolean a); +angle::CallCapture CaptureDisableiEXT(const State &glState, + bool isCallValid, + GLenum target, + GLuint index); +angle::CallCapture CaptureEnableiEXT(const State &glState, + bool isCallValid, + GLenum target, + GLuint index); +angle::CallCapture CaptureIsEnablediEXT(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLboolean returnValue); + +// GL_EXT_draw_elements_base_vertex +angle::CallCapture CaptureDrawElementsBaseVertexEXT(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLint basevertex); +angle::CallCapture CaptureDrawElementsInstancedBaseVertexEXT(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei instancecount, + GLint basevertex); +angle::CallCapture CaptureDrawRangeElementsBaseVertexEXT(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLuint start, + GLuint end, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLint basevertex); +angle::CallCapture CaptureMultiDrawElementsBaseVertexEXT(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *count, + DrawElementsType typePacked, + const void *const *indices, + GLsizei drawcount, + const GLint *basevertex); + +// GL_EXT_external_buffer +angle::CallCapture CaptureBufferStorageExternalEXT(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLintptr offset, + GLsizeiptr size, + GLeglClientBufferEXT clientBuffer, + GLbitfield flags); +angle::CallCapture CaptureNamedBufferStorageExternalEXT(const State &glState, + bool isCallValid, + GLuint buffer, + GLintptr offset, + GLsizeiptr size, + GLeglClientBufferEXT clientBuffer, + GLbitfield flags); + +// GL_EXT_float_blend + +// GL_EXT_geometry_shader +angle::CallCapture CaptureFramebufferTextureEXT(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + TextureID texturePacked, + GLint level); + +// GL_EXT_gpu_shader5 + +// GL_EXT_instanced_arrays +angle::CallCapture CaptureDrawArraysInstancedEXT(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLint start, + GLsizei count, + GLsizei primcount); +angle::CallCapture CaptureDrawElementsInstancedEXT(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei primcount); +angle::CallCapture CaptureVertexAttribDivisorEXT(const State &glState, + bool isCallValid, + GLuint index, + GLuint divisor); + +// GL_EXT_map_buffer_range +angle::CallCapture CaptureFlushMappedBufferRangeEXT(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLintptr offset, + GLsizeiptr length); +angle::CallCapture CaptureMapBufferRangeEXT(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLintptr offset, + GLsizeiptr length, + GLbitfield access, + void *returnValue); + +// GL_EXT_memory_object +angle::CallCapture CaptureBufferStorageMemEXT(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizeiptr size, + MemoryObjectID memoryPacked, + GLuint64 offset); +angle::CallCapture CaptureCreateMemoryObjectsEXT(const State &glState, + bool isCallValid, + GLsizei n, + MemoryObjectID *memoryObjectsPacked); +angle::CallCapture CaptureDeleteMemoryObjectsEXT(const State &glState, + bool isCallValid, + GLsizei n, + const MemoryObjectID *memoryObjectsPacked); +angle::CallCapture CaptureGetMemoryObjectParameterivEXT(const State &glState, + bool isCallValid, + MemoryObjectID memoryObjectPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetUnsignedBytevEXT(const State &glState, + bool isCallValid, + GLenum pname, + GLubyte *data); +angle::CallCapture CaptureGetUnsignedBytei_vEXT(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLubyte *data); +angle::CallCapture CaptureIsMemoryObjectEXT(const State &glState, + bool isCallValid, + MemoryObjectID memoryObjectPacked, + GLboolean returnValue); +angle::CallCapture CaptureMemoryObjectParameterivEXT(const State &glState, + bool isCallValid, + MemoryObjectID memoryObjectPacked, + GLenum pname, + const GLint *params); +angle::CallCapture CaptureTexStorageMem2DEXT(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + MemoryObjectID memoryPacked, + GLuint64 offset); +angle::CallCapture CaptureTexStorageMem2DMultisampleEXT(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLboolean fixedSampleLocations, + MemoryObjectID memoryPacked, + GLuint64 offset); +angle::CallCapture CaptureTexStorageMem3DEXT(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + MemoryObjectID memoryPacked, + GLuint64 offset); +angle::CallCapture CaptureTexStorageMem3DMultisampleEXT(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedSampleLocations, + MemoryObjectID memoryPacked, + GLuint64 offset); + +// GL_EXT_memory_object_fd +angle::CallCapture CaptureImportMemoryFdEXT(const State &glState, + bool isCallValid, + MemoryObjectID memoryPacked, + GLuint64 size, + HandleType handleTypePacked, + GLint fd); + +// GL_EXT_multi_draw_indirect +angle::CallCapture CaptureMultiDrawArraysIndirectEXT(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const void *indirect, + GLsizei drawcount, + GLsizei stride); +angle::CallCapture CaptureMultiDrawElementsIndirectEXT(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + DrawElementsType typePacked, + const void *indirect, + GLsizei drawcount, + GLsizei stride); + +// GL_EXT_multisampled_render_to_texture +angle::CallCapture CaptureFramebufferTexture2DMultisampleEXT(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + TextureTarget textargetPacked, + TextureID texturePacked, + GLint level, + GLsizei samples); +angle::CallCapture CaptureRenderbufferStorageMultisampleEXT(const State &glState, + bool isCallValid, + GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height); + +// GL_EXT_multisampled_render_to_texture2 + +// GL_EXT_occlusion_query_boolean + +// GL_EXT_primitive_bounding_box +angle::CallCapture CapturePrimitiveBoundingBoxEXT(const State &glState, + bool isCallValid, + GLfloat minX, + GLfloat minY, + GLfloat minZ, + GLfloat minW, + GLfloat maxX, + GLfloat maxY, + GLfloat maxZ, + GLfloat maxW); + +// GL_EXT_protected_textures + +// GL_EXT_pvrtc_sRGB + +// GL_EXT_read_format_bgra + +// GL_EXT_robustness +angle::CallCapture CaptureGetGraphicsResetStatusEXT(const State &glState, + bool isCallValid, + GLenum returnValue); +angle::CallCapture CaptureGetnUniformfvEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLfloat *params); +angle::CallCapture CaptureGetnUniformivEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLint *params); +angle::CallCapture CaptureReadnPixelsEXT(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + void *data); + +// GL_EXT_sRGB + +// GL_EXT_sRGB_write_control + +// GL_EXT_semaphore +angle::CallCapture CaptureDeleteSemaphoresEXT(const State &glState, + bool isCallValid, + GLsizei n, + const SemaphoreID *semaphoresPacked); +angle::CallCapture CaptureGenSemaphoresEXT(const State &glState, + bool isCallValid, + GLsizei n, + SemaphoreID *semaphoresPacked); +angle::CallCapture CaptureGetSemaphoreParameterui64vEXT(const State &glState, + bool isCallValid, + SemaphoreID semaphorePacked, + GLenum pname, + GLuint64 *params); +angle::CallCapture CaptureIsSemaphoreEXT(const State &glState, + bool isCallValid, + SemaphoreID semaphorePacked, + GLboolean returnValue); +angle::CallCapture CaptureSemaphoreParameterui64vEXT(const State &glState, + bool isCallValid, + SemaphoreID semaphorePacked, + GLenum pname, + const GLuint64 *params); +angle::CallCapture CaptureSignalSemaphoreEXT(const State &glState, + bool isCallValid, + SemaphoreID semaphorePacked, + GLuint numBufferBarriers, + const BufferID *buffersPacked, + GLuint numTextureBarriers, + const TextureID *texturesPacked, + const GLenum *dstLayouts); +angle::CallCapture CaptureWaitSemaphoreEXT(const State &glState, + bool isCallValid, + SemaphoreID semaphorePacked, + GLuint numBufferBarriers, + const BufferID *buffersPacked, + GLuint numTextureBarriers, + const TextureID *texturesPacked, + const GLenum *srcLayouts); + +// GL_EXT_semaphore_fd +angle::CallCapture CaptureImportSemaphoreFdEXT(const State &glState, + bool isCallValid, + SemaphoreID semaphorePacked, + HandleType handleTypePacked, + GLint fd); + +// GL_EXT_separate_shader_objects +angle::CallCapture CaptureActiveShaderProgramEXT(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked, + ShaderProgramID programPacked); +angle::CallCapture CaptureBindProgramPipelineEXT(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked); +angle::CallCapture CaptureCreateShaderProgramvEXT(const State &glState, + bool isCallValid, + ShaderType typePacked, + GLsizei count, + const GLchar **strings, + GLuint returnValue); +angle::CallCapture CaptureDeleteProgramPipelinesEXT(const State &glState, + bool isCallValid, + GLsizei n, + const ProgramPipelineID *pipelinesPacked); +angle::CallCapture CaptureGenProgramPipelinesEXT(const State &glState, + bool isCallValid, + GLsizei n, + ProgramPipelineID *pipelinesPacked); +angle::CallCapture CaptureGetProgramPipelineInfoLogEXT(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog); +angle::CallCapture CaptureGetProgramPipelineivEXT(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureIsProgramPipelineEXT(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked, + GLboolean returnValue); +angle::CallCapture CaptureProgramParameteriEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum pname, + GLint value); +angle::CallCapture CaptureProgramUniform1fEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLfloat v0); +angle::CallCapture CaptureProgramUniform1fvEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value); +angle::CallCapture CaptureProgramUniform1iEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLint v0); +angle::CallCapture CaptureProgramUniform1ivEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLint *value); +angle::CallCapture CaptureProgramUniform1uiEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLuint v0); +angle::CallCapture CaptureProgramUniform1uivEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value); +angle::CallCapture CaptureProgramUniform2fEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLfloat v0, + GLfloat v1); +angle::CallCapture CaptureProgramUniform2fvEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value); +angle::CallCapture CaptureProgramUniform2iEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLint v0, + GLint v1); +angle::CallCapture CaptureProgramUniform2ivEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLint *value); +angle::CallCapture CaptureProgramUniform2uiEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLuint v0, + GLuint v1); +angle::CallCapture CaptureProgramUniform2uivEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value); +angle::CallCapture CaptureProgramUniform3fEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLfloat v0, + GLfloat v1, + GLfloat v2); +angle::CallCapture CaptureProgramUniform3fvEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value); +angle::CallCapture CaptureProgramUniform3iEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLint v0, + GLint v1, + GLint v2); +angle::CallCapture CaptureProgramUniform3ivEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLint *value); +angle::CallCapture CaptureProgramUniform3uiEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLuint v0, + GLuint v1, + GLuint v2); +angle::CallCapture CaptureProgramUniform3uivEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value); +angle::CallCapture CaptureProgramUniform4fEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLfloat v0, + GLfloat v1, + GLfloat v2, + GLfloat v3); +angle::CallCapture CaptureProgramUniform4fvEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value); +angle::CallCapture CaptureProgramUniform4iEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLint v0, + GLint v1, + GLint v2, + GLint v3); +angle::CallCapture CaptureProgramUniform4ivEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLint *value); +angle::CallCapture CaptureProgramUniform4uiEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLuint v0, + GLuint v1, + GLuint v2, + GLuint v3); +angle::CallCapture CaptureProgramUniform4uivEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value); +angle::CallCapture CaptureProgramUniformMatrix2fvEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureProgramUniformMatrix2x3fvEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureProgramUniformMatrix2x4fvEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureProgramUniformMatrix3fvEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureProgramUniformMatrix3x2fvEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureProgramUniformMatrix3x4fvEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureProgramUniformMatrix4fvEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureProgramUniformMatrix4x2fvEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureProgramUniformMatrix4x3fvEXT(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +angle::CallCapture CaptureUseProgramStagesEXT(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked, + GLbitfield stages, + ShaderProgramID programPacked); +angle::CallCapture CaptureValidateProgramPipelineEXT(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked); + +// GL_EXT_shader_framebuffer_fetch + +// GL_EXT_shader_framebuffer_fetch_non_coherent +angle::CallCapture CaptureFramebufferFetchBarrierEXT(const State &glState, bool isCallValid); + +// GL_EXT_shader_io_blocks + +// GL_EXT_shader_non_constant_global_initializers + +// GL_EXT_shader_texture_lod + +// GL_EXT_shadow_samplers + +// GL_EXT_tessellation_shader +angle::CallCapture CapturePatchParameteriEXT(const State &glState, + bool isCallValid, + GLenum pname, + GLint value); + +// GL_EXT_texture_border_clamp +angle::CallCapture CaptureGetSamplerParameterIivEXT(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetSamplerParameterIuivEXT(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLuint *params); +angle::CallCapture CaptureGetTexParameterIivEXT(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetTexParameterIuivEXT(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLuint *params); +angle::CallCapture CaptureSamplerParameterIivEXT(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + const GLint *param); +angle::CallCapture CaptureSamplerParameterIuivEXT(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + const GLuint *param); +angle::CallCapture CaptureTexParameterIivEXT(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLint *params); +angle::CallCapture CaptureTexParameterIuivEXT(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLuint *params); + +// GL_EXT_texture_buffer +angle::CallCapture CaptureTexBufferEXT(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum internalformat, + BufferID bufferPacked); +angle::CallCapture CaptureTexBufferRangeEXT(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum internalformat, + BufferID bufferPacked, + GLintptr offset, + GLsizeiptr size); + +// GL_EXT_texture_compression_bptc + +// GL_EXT_texture_compression_dxt1 + +// GL_EXT_texture_compression_rgtc + +// GL_EXT_texture_compression_s3tc + +// GL_EXT_texture_compression_s3tc_srgb + +// GL_EXT_texture_cube_map_array + +// GL_EXT_texture_filter_anisotropic + +// GL_EXT_texture_format_BGRA8888 + +// GL_EXT_texture_format_sRGB_override + +// GL_EXT_texture_norm16 + +// GL_EXT_texture_rg + +// GL_EXT_texture_sRGB_R8 + +// GL_EXT_texture_sRGB_RG8 + +// GL_EXT_texture_sRGB_decode + +// GL_EXT_texture_storage +angle::CallCapture CaptureTexStorage1DEXT(const State &glState, + bool isCallValid, + GLenum target, + GLsizei levels, + GLenum internalformat, + GLsizei width); +angle::CallCapture CaptureTexStorage2DEXT(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height); +angle::CallCapture CaptureTexStorage3DEXT(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth); + +// GL_EXT_texture_type_2_10_10_10_REV + +// GL_EXT_unpack_subimage + +// GL_IMG_texture_compression_pvrtc + +// GL_IMG_texture_compression_pvrtc2 + +// GL_KHR_blend_equation_advanced +angle::CallCapture CaptureBlendBarrierKHR(const State &glState, bool isCallValid); + +// GL_KHR_debug +angle::CallCapture CaptureDebugMessageCallbackKHR(const State &glState, + bool isCallValid, + GLDEBUGPROCKHR callback, + const void *userParam); +angle::CallCapture CaptureDebugMessageControlKHR(const State &glState, + bool isCallValid, + GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint *ids, + GLboolean enabled); +angle::CallCapture CaptureDebugMessageInsertKHR(const State &glState, + bool isCallValid, + GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar *buf); +angle::CallCapture CaptureGetDebugMessageLogKHR(const State &glState, + bool isCallValid, + GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog, + GLuint returnValue); +angle::CallCapture CaptureGetObjectLabelKHR(const State &glState, + bool isCallValid, + GLenum identifier, + GLuint name, + GLsizei bufSize, + GLsizei *length, + GLchar *label); +angle::CallCapture CaptureGetObjectPtrLabelKHR(const State &glState, + bool isCallValid, + const void *ptr, + GLsizei bufSize, + GLsizei *length, + GLchar *label); +angle::CallCapture CaptureGetPointervKHR(const State &glState, + bool isCallValid, + GLenum pname, + void **params); +angle::CallCapture CaptureObjectLabelKHR(const State &glState, + bool isCallValid, + GLenum identifier, + GLuint name, + GLsizei length, + const GLchar *label); +angle::CallCapture CaptureObjectPtrLabelKHR(const State &glState, + bool isCallValid, + const void *ptr, + GLsizei length, + const GLchar *label); +angle::CallCapture CapturePopDebugGroupKHR(const State &glState, bool isCallValid); +angle::CallCapture CapturePushDebugGroupKHR(const State &glState, + bool isCallValid, + GLenum source, + GLuint id, + GLsizei length, + const GLchar *message); + +// GL_KHR_no_error + +// GL_KHR_parallel_shader_compile +angle::CallCapture CaptureMaxShaderCompilerThreadsKHR(const State &glState, + bool isCallValid, + GLuint count); + +// GL_KHR_robust_buffer_access_behavior + +// GL_KHR_texture_compression_astc_hdr + +// GL_KHR_texture_compression_astc_ldr + +// GL_KHR_texture_compression_astc_sliced_3d + +// GL_MESA_framebuffer_flip_y +angle::CallCapture CaptureFramebufferParameteriMESA(const State &glState, + bool isCallValid, + GLenum target, + GLenum pname, + GLint param); +angle::CallCapture CaptureGetFramebufferParameterivMESA(const State &glState, + bool isCallValid, + GLenum target, + GLenum pname, + GLint *params); + +// GL_NV_fence +angle::CallCapture CaptureDeleteFencesNV(const State &glState, + bool isCallValid, + GLsizei n, + const FenceNVID *fencesPacked); +angle::CallCapture CaptureFinishFenceNV(const State &glState, + bool isCallValid, + FenceNVID fencePacked); +angle::CallCapture CaptureGenFencesNV(const State &glState, + bool isCallValid, + GLsizei n, + FenceNVID *fencesPacked); +angle::CallCapture CaptureGetFenceivNV(const State &glState, + bool isCallValid, + FenceNVID fencePacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureIsFenceNV(const State &glState, + bool isCallValid, + FenceNVID fencePacked, + GLboolean returnValue); +angle::CallCapture CaptureSetFenceNV(const State &glState, + bool isCallValid, + FenceNVID fencePacked, + GLenum condition); +angle::CallCapture CaptureTestFenceNV(const State &glState, + bool isCallValid, + FenceNVID fencePacked, + GLboolean returnValue); + +// GL_NV_framebuffer_blit +angle::CallCapture CaptureBlitFramebufferNV(const State &glState, + bool isCallValid, + GLint srcX0, + GLint srcY0, + GLint srcX1, + GLint srcY1, + GLint dstX0, + GLint dstY0, + GLint dstX1, + GLint dstY1, + GLbitfield mask, + GLenum filter); + +// GL_NV_pixel_buffer_object + +// GL_NV_read_depth + +// GL_NV_read_depth_stencil + +// GL_NV_read_stencil + +// GL_NV_robustness_video_memory_purge + +// GL_NV_shader_noperspective_interpolation + +// GL_OES_EGL_image +angle::CallCapture CaptureEGLImageTargetRenderbufferStorageOES(const State &glState, + bool isCallValid, + GLenum target, + GLeglImageOES image); +angle::CallCapture CaptureEGLImageTargetTexture2DOES(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLeglImageOES image); + +// GL_OES_EGL_image_external + +// GL_OES_EGL_image_external_essl3 + +// GL_OES_compressed_ETC1_RGB8_texture + +// GL_OES_compressed_paletted_texture + +// GL_OES_copy_image +angle::CallCapture CaptureCopyImageSubDataOES(const State &glState, + bool isCallValid, + GLuint srcName, + GLenum srcTarget, + GLint srcLevel, + GLint srcX, + GLint srcY, + GLint srcZ, + GLuint dstName, + GLenum dstTarget, + GLint dstLevel, + GLint dstX, + GLint dstY, + GLint dstZ, + GLsizei srcWidth, + GLsizei srcHeight, + GLsizei srcDepth); + +// GL_OES_depth24 + +// GL_OES_depth32 + +// GL_OES_depth_texture + +// GL_OES_draw_buffers_indexed +angle::CallCapture CaptureBlendEquationSeparateiOES(const State &glState, + bool isCallValid, + GLuint buf, + GLenum modeRGB, + GLenum modeAlpha); +angle::CallCapture CaptureBlendEquationiOES(const State &glState, + bool isCallValid, + GLuint buf, + GLenum mode); +angle::CallCapture CaptureBlendFuncSeparateiOES(const State &glState, + bool isCallValid, + GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha); +angle::CallCapture CaptureBlendFunciOES(const State &glState, + bool isCallValid, + GLuint buf, + GLenum src, + GLenum dst); +angle::CallCapture CaptureColorMaskiOES(const State &glState, + bool isCallValid, + GLuint index, + GLboolean r, + GLboolean g, + GLboolean b, + GLboolean a); +angle::CallCapture CaptureDisableiOES(const State &glState, + bool isCallValid, + GLenum target, + GLuint index); +angle::CallCapture CaptureEnableiOES(const State &glState, + bool isCallValid, + GLenum target, + GLuint index); +angle::CallCapture CaptureIsEnablediOES(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLboolean returnValue); + +// GL_OES_draw_elements_base_vertex +angle::CallCapture CaptureDrawElementsBaseVertexOES(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLint basevertex); +angle::CallCapture CaptureDrawElementsInstancedBaseVertexOES(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei instancecount, + GLint basevertex); +angle::CallCapture CaptureDrawRangeElementsBaseVertexOES(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLuint start, + GLuint end, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLint basevertex); + +// GL_OES_draw_texture +angle::CallCapture CaptureDrawTexfOES(const State &glState, + bool isCallValid, + GLfloat x, + GLfloat y, + GLfloat z, + GLfloat width, + GLfloat height); +angle::CallCapture CaptureDrawTexfvOES(const State &glState, + bool isCallValid, + const GLfloat *coords); +angle::CallCapture CaptureDrawTexiOES(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLint z, + GLint width, + GLint height); +angle::CallCapture CaptureDrawTexivOES(const State &glState, bool isCallValid, const GLint *coords); +angle::CallCapture CaptureDrawTexsOES(const State &glState, + bool isCallValid, + GLshort x, + GLshort y, + GLshort z, + GLshort width, + GLshort height); +angle::CallCapture CaptureDrawTexsvOES(const State &glState, + bool isCallValid, + const GLshort *coords); +angle::CallCapture CaptureDrawTexxOES(const State &glState, + bool isCallValid, + GLfixed x, + GLfixed y, + GLfixed z, + GLfixed width, + GLfixed height); +angle::CallCapture CaptureDrawTexxvOES(const State &glState, + bool isCallValid, + const GLfixed *coords); + +// GL_OES_element_index_uint + +// GL_OES_fbo_render_mipmap + +// GL_OES_framebuffer_object +angle::CallCapture CaptureBindFramebufferOES(const State &glState, + bool isCallValid, + GLenum target, + FramebufferID framebufferPacked); +angle::CallCapture CaptureBindRenderbufferOES(const State &glState, + bool isCallValid, + GLenum target, + RenderbufferID renderbufferPacked); +angle::CallCapture CaptureCheckFramebufferStatusOES(const State &glState, + bool isCallValid, + GLenum target, + GLenum returnValue); +angle::CallCapture CaptureDeleteFramebuffersOES(const State &glState, + bool isCallValid, + GLsizei n, + const FramebufferID *framebuffersPacked); +angle::CallCapture CaptureDeleteRenderbuffersOES(const State &glState, + bool isCallValid, + GLsizei n, + const RenderbufferID *renderbuffersPacked); +angle::CallCapture CaptureFramebufferRenderbufferOES(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + GLenum renderbuffertarget, + RenderbufferID renderbufferPacked); +angle::CallCapture CaptureFramebufferTexture2DOES(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + TextureTarget textargetPacked, + TextureID texturePacked, + GLint level); +angle::CallCapture CaptureGenFramebuffersOES(const State &glState, + bool isCallValid, + GLsizei n, + FramebufferID *framebuffersPacked); +angle::CallCapture CaptureGenRenderbuffersOES(const State &glState, + bool isCallValid, + GLsizei n, + RenderbufferID *renderbuffersPacked); +angle::CallCapture CaptureGenerateMipmapOES(const State &glState, + bool isCallValid, + TextureType targetPacked); +angle::CallCapture CaptureGetFramebufferAttachmentParameterivOES(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetRenderbufferParameterivOES(const State &glState, + bool isCallValid, + GLenum target, + GLenum pname, + GLint *params); +angle::CallCapture CaptureIsFramebufferOES(const State &glState, + bool isCallValid, + FramebufferID framebufferPacked, + GLboolean returnValue); +angle::CallCapture CaptureIsRenderbufferOES(const State &glState, + bool isCallValid, + RenderbufferID renderbufferPacked, + GLboolean returnValue); +angle::CallCapture CaptureRenderbufferStorageOES(const State &glState, + bool isCallValid, + GLenum target, + GLenum internalformat, + GLsizei width, + GLsizei height); + +// GL_OES_geometry_shader +angle::CallCapture CaptureFramebufferTextureOES(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + TextureID texturePacked, + GLint level); + +// GL_OES_get_program_binary +angle::CallCapture CaptureGetProgramBinaryOES(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei bufSize, + GLsizei *length, + GLenum *binaryFormat, + void *binary); +angle::CallCapture CaptureProgramBinaryOES(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum binaryFormat, + const void *binary, + GLint length); + +// GL_OES_mapbuffer +angle::CallCapture CaptureGetBufferPointervOES(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum pname, + void **params); +angle::CallCapture CaptureMapBufferOES(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum access, + void *returnValue); +angle::CallCapture CaptureUnmapBufferOES(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLboolean returnValue); + +// GL_OES_matrix_palette +angle::CallCapture CaptureCurrentPaletteMatrixOES(const State &glState, + bool isCallValid, + GLuint matrixpaletteindex); +angle::CallCapture CaptureLoadPaletteFromModelViewMatrixOES(const State &glState, bool isCallValid); +angle::CallCapture CaptureMatrixIndexPointerOES(const State &glState, + bool isCallValid, + GLint size, + GLenum type, + GLsizei stride, + const void *pointer); +angle::CallCapture CaptureWeightPointerOES(const State &glState, + bool isCallValid, + GLint size, + GLenum type, + GLsizei stride, + const void *pointer); + +// GL_OES_packed_depth_stencil + +// GL_OES_point_size_array +angle::CallCapture CapturePointSizePointerOES(const State &glState, + bool isCallValid, + VertexAttribType typePacked, + GLsizei stride, + const void *pointer); + +// GL_OES_point_sprite + +// GL_OES_primitive_bounding_box +angle::CallCapture CapturePrimitiveBoundingBoxOES(const State &glState, + bool isCallValid, + GLfloat minX, + GLfloat minY, + GLfloat minZ, + GLfloat minW, + GLfloat maxX, + GLfloat maxY, + GLfloat maxZ, + GLfloat maxW); + +// GL_OES_query_matrix +angle::CallCapture CaptureQueryMatrixxOES(const State &glState, + bool isCallValid, + GLfixed *mantissa, + GLint *exponent, + GLbitfield returnValue); + +// GL_OES_rgb8_rgba8 + +// GL_OES_sample_shading +angle::CallCapture CaptureMinSampleShadingOES(const State &glState, + bool isCallValid, + GLfloat value); + +// GL_OES_sample_variables + +// GL_OES_shader_image_atomic + +// GL_OES_shader_io_blocks + +// GL_OES_shader_multisample_interpolation + +// GL_OES_standard_derivatives + +// GL_OES_surfaceless_context + +// GL_OES_texture_3D +angle::CallCapture CaptureCompressedTexImage3DOES(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLsizei imageSize, + const void *data); +angle::CallCapture CaptureCompressedTexSubImage3DOES(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + const void *data); +angle::CallCapture CaptureCopyTexSubImage3DOES(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLint x, + GLint y, + GLsizei width, + GLsizei height); +angle::CallCapture CaptureFramebufferTexture3DOES(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + TextureTarget textargetPacked, + TextureID texturePacked, + GLint level, + GLint zoffset); +angle::CallCapture CaptureTexImage3DOES(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLenum format, + GLenum type, + const void *pixels); +angle::CallCapture CaptureTexSubImage3DOES(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + const void *pixels); + +// GL_OES_texture_border_clamp +angle::CallCapture CaptureGetSamplerParameterIivOES(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetSamplerParameterIuivOES(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLuint *params); +angle::CallCapture CaptureGetTexParameterIivOES(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetTexParameterIuivOES(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLuint *params); +angle::CallCapture CaptureSamplerParameterIivOES(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + const GLint *param); +angle::CallCapture CaptureSamplerParameterIuivOES(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + const GLuint *param); +angle::CallCapture CaptureTexParameterIivOES(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLint *params); +angle::CallCapture CaptureTexParameterIuivOES(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLuint *params); + +// GL_OES_texture_buffer +angle::CallCapture CaptureTexBufferOES(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum internalformat, + BufferID bufferPacked); +angle::CallCapture CaptureTexBufferRangeOES(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum internalformat, + BufferID bufferPacked, + GLintptr offset, + GLsizeiptr size); + +// GL_OES_texture_compression_astc + +// GL_OES_texture_cube_map +angle::CallCapture CaptureGetTexGenfvOES(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLfloat *params); +angle::CallCapture CaptureGetTexGenivOES(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLint *params); +angle::CallCapture CaptureGetTexGenxvOES(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLfixed *params); +angle::CallCapture CaptureTexGenfOES(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLfloat param); +angle::CallCapture CaptureTexGenfvOES(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + const GLfloat *params); +angle::CallCapture CaptureTexGeniOES(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLint param); +angle::CallCapture CaptureTexGenivOES(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + const GLint *params); +angle::CallCapture CaptureTexGenxOES(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLfixed param); +angle::CallCapture CaptureTexGenxvOES(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + const GLfixed *params); + +// GL_OES_texture_cube_map_array + +// GL_OES_texture_float + +// GL_OES_texture_float_linear + +// GL_OES_texture_half_float + +// GL_OES_texture_half_float_linear + +// GL_OES_texture_npot + +// GL_OES_texture_stencil8 + +// GL_OES_texture_storage_multisample_2d_array +angle::CallCapture CaptureTexStorage3DMultisampleOES(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedsamplelocations); + +// GL_OES_vertex_array_object +angle::CallCapture CaptureBindVertexArrayOES(const State &glState, + bool isCallValid, + VertexArrayID arrayPacked); +angle::CallCapture CaptureDeleteVertexArraysOES(const State &glState, + bool isCallValid, + GLsizei n, + const VertexArrayID *arraysPacked); +angle::CallCapture CaptureGenVertexArraysOES(const State &glState, + bool isCallValid, + GLsizei n, + VertexArrayID *arraysPacked); +angle::CallCapture CaptureIsVertexArrayOES(const State &glState, + bool isCallValid, + VertexArrayID arrayPacked, + GLboolean returnValue); + +// GL_OES_vertex_half_float + +// GL_OES_vertex_type_10_10_10_2 + +// GL_OVR_multiview +angle::CallCapture CaptureFramebufferTextureMultiviewOVR(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + TextureID texturePacked, + GLint level, + GLint baseViewIndex, + GLsizei numViews); + +// GL_OVR_multiview2 + +// GL_QCOM_shading_rate +angle::CallCapture CaptureShadingRateQCOM(const State &glState, bool isCallValid, GLenum rate); + +// Parameter Captures + +void CaptureDeletePerfMonitorsAMD_monitors(const State &glState, + bool isCallValid, + GLsizei n, + GLuint *monitors, + angle::ParamCapture *paramCapture); +void CaptureGenPerfMonitorsAMD_monitors(const State &glState, + bool isCallValid, + GLsizei n, + GLuint *monitors, + angle::ParamCapture *paramCapture); +void CaptureGetPerfMonitorCounterDataAMD_data(const State &glState, + bool isCallValid, + GLuint monitor, + GLenum pname, + GLsizei dataSize, + GLuint *data, + GLint *bytesWritten, + angle::ParamCapture *paramCapture); +void CaptureGetPerfMonitorCounterDataAMD_bytesWritten(const State &glState, + bool isCallValid, + GLuint monitor, + GLenum pname, + GLsizei dataSize, + GLuint *data, + GLint *bytesWritten, + angle::ParamCapture *paramCapture); +void CaptureGetPerfMonitorCounterInfoAMD_data(const State &glState, + bool isCallValid, + GLuint group, + GLuint counter, + GLenum pname, + void *data, + angle::ParamCapture *paramCapture); +void CaptureGetPerfMonitorCounterStringAMD_length(const State &glState, + bool isCallValid, + GLuint group, + GLuint counter, + GLsizei bufSize, + GLsizei *length, + GLchar *counterString, + angle::ParamCapture *paramCapture); +void CaptureGetPerfMonitorCounterStringAMD_counterString(const State &glState, + bool isCallValid, + GLuint group, + GLuint counter, + GLsizei bufSize, + GLsizei *length, + GLchar *counterString, + angle::ParamCapture *paramCapture); +void CaptureGetPerfMonitorCountersAMD_numCounters(const State &glState, + bool isCallValid, + GLuint group, + GLint *numCounters, + GLint *maxActiveCounters, + GLsizei counterSize, + GLuint *counters, + angle::ParamCapture *paramCapture); +void CaptureGetPerfMonitorCountersAMD_maxActiveCounters(const State &glState, + bool isCallValid, + GLuint group, + GLint *numCounters, + GLint *maxActiveCounters, + GLsizei counterSize, + GLuint *counters, + angle::ParamCapture *paramCapture); +void CaptureGetPerfMonitorCountersAMD_counters(const State &glState, + bool isCallValid, + GLuint group, + GLint *numCounters, + GLint *maxActiveCounters, + GLsizei counterSize, + GLuint *counters, + angle::ParamCapture *paramCapture); +void CaptureGetPerfMonitorGroupStringAMD_length(const State &glState, + bool isCallValid, + GLuint group, + GLsizei bufSize, + GLsizei *length, + GLchar *groupString, + angle::ParamCapture *paramCapture); +void CaptureGetPerfMonitorGroupStringAMD_groupString(const State &glState, + bool isCallValid, + GLuint group, + GLsizei bufSize, + GLsizei *length, + GLchar *groupString, + angle::ParamCapture *paramCapture); +void CaptureGetPerfMonitorGroupsAMD_numGroups(const State &glState, + bool isCallValid, + GLint *numGroups, + GLsizei groupsSize, + GLuint *groups, + angle::ParamCapture *paramCapture); +void CaptureGetPerfMonitorGroupsAMD_groups(const State &glState, + bool isCallValid, + GLint *numGroups, + GLsizei groupsSize, + GLuint *groups, + angle::ParamCapture *paramCapture); +void CaptureSelectPerfMonitorCountersAMD_counterList(const State &glState, + bool isCallValid, + GLuint monitor, + GLboolean enable, + GLuint group, + GLint numCounters, + GLuint *counterList, + angle::ParamCapture *paramCapture); +void CaptureDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices( + const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const GLvoid *indices, + GLsizei instanceCount, + GLint baseVertex, + GLuint baseInstance, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_firsts(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + const GLuint *baseInstances, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_counts(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + const GLuint *baseInstances, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_instanceCounts( + const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + const GLuint *baseInstances, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawArraysInstancedBaseInstanceANGLE_baseInstances( + const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + const GLuint *baseInstances, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_counts( + const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *counts, + DrawElementsType typePacked, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + const GLint *baseVertices, + const GLuint *baseInstances, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_indices( + const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *counts, + DrawElementsType typePacked, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + const GLint *baseVertices, + const GLuint *baseInstances, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_instanceCounts( + const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *counts, + DrawElementsType typePacked, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + const GLint *baseVertices, + const GLuint *baseInstances, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseVertices( + const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *counts, + DrawElementsType typePacked, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + const GLint *baseVertices, + const GLuint *baseInstances, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE_baseInstances( + const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *counts, + DrawElementsType typePacked, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + const GLint *baseVertices, + const GLuint *baseInstances, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureGetTexImageANGLE_pixels(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum format, + GLenum type, + void *pixels, + angle::ParamCapture *paramCapture); +void CaptureGetCompressedTexImageANGLE_pixels(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + void *pixels, + angle::ParamCapture *paramCapture); +void CaptureGetRenderbufferImageANGLE_pixels(const State &glState, + bool isCallValid, + GLenum target, + GLenum format, + GLenum type, + void *pixels, + angle::ParamCapture *paramCapture); +void CaptureGetTexLevelParameterivANGLE_params(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexLevelParameterfvANGLE_params(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum pname, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureDrawElementsInstancedANGLE_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei primcount, + angle::ParamCapture *paramCapture); +void CaptureTexStorageMemFlags2DANGLE_imageCreateInfoPNext(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + MemoryObjectID memoryPacked, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext, + angle::ParamCapture *paramCapture); +void CaptureTexStorageMemFlags2DMultisampleANGLE_imageCreateInfoPNext( + const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLboolean fixedSampleLocations, + MemoryObjectID memoryPacked, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext, + angle::ParamCapture *paramCapture); +void CaptureTexStorageMemFlags3DANGLE_imageCreateInfoPNext(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + MemoryObjectID memoryPacked, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext, + angle::ParamCapture *paramCapture); +void CaptureTexStorageMemFlags3DMultisampleANGLE_imageCreateInfoPNext( + const State &glState, + bool isCallValid, + TextureType targetPacked, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedSampleLocations, + MemoryObjectID memoryPacked, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawArraysANGLE_firsts(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLint *firsts, + const GLsizei *counts, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawArraysANGLE_counts(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLint *firsts, + const GLsizei *counts, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawArraysInstancedANGLE_firsts(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawArraysInstancedANGLE_counts(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawArraysInstancedANGLE_instanceCounts(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsANGLE_counts(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *counts, + DrawElementsType typePacked, + const GLvoid *const *indices, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsANGLE_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *counts, + DrawElementsType typePacked, + const GLvoid *const *indices, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsInstancedANGLE_counts(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *counts, + DrawElementsType typePacked, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsInstancedANGLE_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *counts, + DrawElementsType typePacked, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsInstancedANGLE_instanceCounts(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *counts, + DrawElementsType typePacked, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + GLsizei drawcount, + angle::ParamCapture *paramCapture); +void CaptureRequestExtensionANGLE_name(const State &glState, + bool isCallValid, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureDisableExtensionANGLE_name(const State &glState, + bool isCallValid, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetBooleanvRobustANGLE_length(const State &glState, + bool isCallValid, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLboolean *params, + angle::ParamCapture *paramCapture); +void CaptureGetBooleanvRobustANGLE_params(const State &glState, + bool isCallValid, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLboolean *params, + angle::ParamCapture *paramCapture); +void CaptureGetBufferParameterivRobustANGLE_length(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetBufferParameterivRobustANGLE_params(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetFloatvRobustANGLE_length(const State &glState, + bool isCallValid, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetFloatvRobustANGLE_params(const State &glState, + bool isCallValid, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetFramebufferAttachmentParameterivRobustANGLE_length( + const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetFramebufferAttachmentParameterivRobustANGLE_params( + const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetIntegervRobustANGLE_length(const State &glState, + bool isCallValid, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *data, + angle::ParamCapture *paramCapture); +void CaptureGetIntegervRobustANGLE_data(const State &glState, + bool isCallValid, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *data, + angle::ParamCapture *paramCapture); +void CaptureGetProgramivRobustANGLE_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetProgramivRobustANGLE_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetRenderbufferParameterivRobustANGLE_length(const State &glState, + bool isCallValid, + GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetRenderbufferParameterivRobustANGLE_params(const State &glState, + bool isCallValid, + GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetShaderivRobustANGLE_length(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetShaderivRobustANGLE_params(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexParameterfvRobustANGLE_length(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexParameterfvRobustANGLE_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexParameterivRobustANGLE_length(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexParameterivRobustANGLE_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetUniformfvRobustANGLE_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetUniformfvRobustANGLE_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetUniformivRobustANGLE_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetUniformivRobustANGLE_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetVertexAttribfvRobustANGLE_length(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetVertexAttribfvRobustANGLE_params(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetVertexAttribivRobustANGLE_length(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetVertexAttribivRobustANGLE_params(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetVertexAttribPointervRobustANGLE_length(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **pointer, + angle::ParamCapture *paramCapture); +void CaptureGetVertexAttribPointervRobustANGLE_pointer(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **pointer, + angle::ParamCapture *paramCapture); +void CaptureReadPixelsRobustANGLE_length(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + GLsizei *length, + GLsizei *columns, + GLsizei *rows, + void *pixels, + angle::ParamCapture *paramCapture); +void CaptureReadPixelsRobustANGLE_columns(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + GLsizei *length, + GLsizei *columns, + GLsizei *rows, + void *pixels, + angle::ParamCapture *paramCapture); +void CaptureReadPixelsRobustANGLE_rows(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + GLsizei *length, + GLsizei *columns, + GLsizei *rows, + void *pixels, + angle::ParamCapture *paramCapture); +void CaptureReadPixelsRobustANGLE_pixels(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + GLsizei *length, + GLsizei *columns, + GLsizei *rows, + void *pixels, + angle::ParamCapture *paramCapture); +void CaptureTexImage2DRobustANGLE_pixels(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels, + angle::ParamCapture *paramCapture); +void CaptureTexParameterfvRobustANGLE_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + const GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureTexParameterivRobustANGLE_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + const GLint *params, + angle::ParamCapture *paramCapture); +void CaptureTexSubImage2DRobustANGLE_pixels(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels, + angle::ParamCapture *paramCapture); +void CaptureTexImage3DRobustANGLE_pixels(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels, + angle::ParamCapture *paramCapture); +void CaptureTexSubImage3DRobustANGLE_pixels(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels, + angle::ParamCapture *paramCapture); +void CaptureCompressedTexImage2DRobustANGLE_data(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data, + angle::ParamCapture *paramCapture); +void CaptureCompressedTexSubImage2DRobustANGLE_data(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLsizei xoffset, + GLsizei yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data, + angle::ParamCapture *paramCapture); +void CaptureCompressedTexImage3DRobustANGLE_data(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data, + angle::ParamCapture *paramCapture); +void CaptureCompressedTexSubImage3DRobustANGLE_data(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data, + angle::ParamCapture *paramCapture); +void CaptureGetQueryivRobustANGLE_length(const State &glState, + bool isCallValid, + QueryType targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetQueryivRobustANGLE_params(const State &glState, + bool isCallValid, + QueryType targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetQueryObjectuivRobustANGLE_length(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetQueryObjectuivRobustANGLE_params(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetBufferPointervRobustANGLE_length(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **params, + angle::ParamCapture *paramCapture); +void CaptureGetBufferPointervRobustANGLE_params(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **params, + angle::ParamCapture *paramCapture); +void CaptureGetIntegeri_vRobustANGLE_length(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *data, + angle::ParamCapture *paramCapture); +void CaptureGetIntegeri_vRobustANGLE_data(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *data, + angle::ParamCapture *paramCapture); +void CaptureGetInternalformativRobustANGLE_length(const State &glState, + bool isCallValid, + GLenum target, + GLenum internalformat, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetInternalformativRobustANGLE_params(const State &glState, + bool isCallValid, + GLenum target, + GLenum internalformat, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetVertexAttribIivRobustANGLE_length(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetVertexAttribIivRobustANGLE_params(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetVertexAttribIuivRobustANGLE_length(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetVertexAttribIuivRobustANGLE_params(const State &glState, + bool isCallValid, + GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetUniformuivRobustANGLE_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetUniformuivRobustANGLE_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetActiveUniformBlockivRobustANGLE_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformBlockIndex uniformBlockIndexPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetActiveUniformBlockivRobustANGLE_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformBlockIndex uniformBlockIndexPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetInteger64vRobustANGLE_length(const State &glState, + bool isCallValid, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *data, + angle::ParamCapture *paramCapture); +void CaptureGetInteger64vRobustANGLE_data(const State &glState, + bool isCallValid, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *data, + angle::ParamCapture *paramCapture); +void CaptureGetInteger64i_vRobustANGLE_length(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint64 *data, + angle::ParamCapture *paramCapture); +void CaptureGetInteger64i_vRobustANGLE_data(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint64 *data, + angle::ParamCapture *paramCapture); +void CaptureGetBufferParameteri64vRobustANGLE_length(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *params, + angle::ParamCapture *paramCapture); +void CaptureGetBufferParameteri64vRobustANGLE_params(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *params, + angle::ParamCapture *paramCapture); +void CaptureSamplerParameterivRobustANGLE_param(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLuint pname, + GLsizei bufSize, + const GLint *param, + angle::ParamCapture *paramCapture); +void CaptureSamplerParameterfvRobustANGLE_param(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + const GLfloat *param, + angle::ParamCapture *paramCapture); +void CaptureGetSamplerParameterivRobustANGLE_length(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetSamplerParameterivRobustANGLE_params(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetSamplerParameterfvRobustANGLE_length(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetSamplerParameterfvRobustANGLE_params(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetFramebufferParameterivRobustANGLE_length(const State &glState, + bool isCallValid, + GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetFramebufferParameterivRobustANGLE_params(const State &glState, + bool isCallValid, + GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetProgramInterfaceivRobustANGLE_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetProgramInterfaceivRobustANGLE_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetBooleani_vRobustANGLE_length(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLboolean *data, + angle::ParamCapture *paramCapture); +void CaptureGetBooleani_vRobustANGLE_data(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLboolean *data, + angle::ParamCapture *paramCapture); +void CaptureGetMultisamplefvRobustANGLE_length(const State &glState, + bool isCallValid, + GLenum pname, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLfloat *val, + angle::ParamCapture *paramCapture); +void CaptureGetMultisamplefvRobustANGLE_val(const State &glState, + bool isCallValid, + GLenum pname, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLfloat *val, + angle::ParamCapture *paramCapture); +void CaptureGetTexLevelParameterivRobustANGLE_length(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexLevelParameterivRobustANGLE_params(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexLevelParameterfvRobustANGLE_length(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexLevelParameterfvRobustANGLE_params(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetPointervRobustANGLERobustANGLE_length(const State &glState, + bool isCallValid, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **params, + angle::ParamCapture *paramCapture); +void CaptureGetPointervRobustANGLERobustANGLE_params(const State &glState, + bool isCallValid, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **params, + angle::ParamCapture *paramCapture); +void CaptureReadnPixelsRobustANGLE_length(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + GLsizei *length, + GLsizei *columns, + GLsizei *rows, + void *data, + angle::ParamCapture *paramCapture); +void CaptureReadnPixelsRobustANGLE_columns(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + GLsizei *length, + GLsizei *columns, + GLsizei *rows, + void *data, + angle::ParamCapture *paramCapture); +void CaptureReadnPixelsRobustANGLE_rows(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + GLsizei *length, + GLsizei *columns, + GLsizei *rows, + void *data, + angle::ParamCapture *paramCapture); +void CaptureReadnPixelsRobustANGLE_data(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + GLsizei *length, + GLsizei *columns, + GLsizei *rows, + void *data, + angle::ParamCapture *paramCapture); +void CaptureGetnUniformfvRobustANGLE_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetnUniformfvRobustANGLE_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetnUniformivRobustANGLE_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetnUniformivRobustANGLE_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetnUniformuivRobustANGLE_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetnUniformuivRobustANGLE_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLsizei *length, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureTexParameterIivRobustANGLE_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + const GLint *params, + angle::ParamCapture *paramCapture); +void CaptureTexParameterIuivRobustANGLE_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + const GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexParameterIivRobustANGLE_length(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexParameterIivRobustANGLE_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexParameterIuivRobustANGLE_length(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexParameterIuivRobustANGLE_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureSamplerParameterIivRobustANGLE_param(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + const GLint *param, + angle::ParamCapture *paramCapture); +void CaptureSamplerParameterIuivRobustANGLE_param(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + const GLuint *param, + angle::ParamCapture *paramCapture); +void CaptureGetSamplerParameterIivRobustANGLE_length(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetSamplerParameterIivRobustANGLE_params(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetSamplerParameterIuivRobustANGLE_length(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetSamplerParameterIuivRobustANGLE_params(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetQueryObjectivRobustANGLE_length(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetQueryObjectivRobustANGLE_params(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetQueryObjecti64vRobustANGLE_length(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *params, + angle::ParamCapture *paramCapture); +void CaptureGetQueryObjecti64vRobustANGLE_params(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *params, + angle::ParamCapture *paramCapture); +void CaptureGetQueryObjectui64vRobustANGLE_length(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint64 *params, + angle::ParamCapture *paramCapture); +void CaptureGetQueryObjectui64vRobustANGLE_params(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint64 *params, + angle::ParamCapture *paramCapture); +void CaptureBeginPixelLocalStorageANGLE_loadops(const State &glState, + bool isCallValid, + GLsizei planes, + const GLenum *loadops, + const void *cleardata, + angle::ParamCapture *paramCapture); +void CaptureBeginPixelLocalStorageANGLE_cleardata(const State &glState, + bool isCallValid, + GLsizei planes, + const GLenum *loadops, + const void *cleardata, + angle::ParamCapture *paramCapture); +void CaptureGetMultisamplefvANGLE_val(const State &glState, + bool isCallValid, + GLenum pname, + GLuint index, + GLfloat *val, + angle::ParamCapture *paramCapture); +void CaptureGetTranslatedShaderSourceANGLE_length(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLsizei bufSize, + GLsizei *length, + GLchar *source, + angle::ParamCapture *paramCapture); +void CaptureGetTranslatedShaderSourceANGLE_source(const State &glState, + bool isCallValid, + ShaderProgramID shaderPacked, + GLsizei bufSize, + GLsizei *length, + GLchar *source, + angle::ParamCapture *paramCapture); +void CaptureAcquireTexturesANGLE_texturesPacked(const State &glState, + bool isCallValid, + GLuint numTextures, + const TextureID *texturesPacked, + const GLenum *layouts, + angle::ParamCapture *paramCapture); +void CaptureAcquireTexturesANGLE_layouts(const State &glState, + bool isCallValid, + GLuint numTextures, + const TextureID *texturesPacked, + const GLenum *layouts, + angle::ParamCapture *paramCapture); +void CaptureReleaseTexturesANGLE_texturesPacked(const State &glState, + bool isCallValid, + GLuint numTextures, + const TextureID *texturesPacked, + GLenum *layouts, + angle::ParamCapture *paramCapture); +void CaptureReleaseTexturesANGLE_layouts(const State &glState, + bool isCallValid, + GLuint numTextures, + const TextureID *texturesPacked, + GLenum *layouts, + angle::ParamCapture *paramCapture); +void CaptureBindUniformLocationCHROMIUM_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureEGLImageTargetTexStorageEXT_attrib_list(const State &glState, + bool isCallValid, + GLenum target, + GLeglImageOES image, + const GLint *attrib_list, + angle::ParamCapture *paramCapture); +void CaptureEGLImageTargetTextureStorageEXT_attrib_list(const State &glState, + bool isCallValid, + GLuint texture, + GLeglImageOES image, + const GLint *attrib_list, + angle::ParamCapture *paramCapture); +void CaptureDrawElementsInstancedBaseInstanceEXT_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei instancecount, + GLuint baseinstance, + angle::ParamCapture *paramCapture); +void CaptureDrawElementsInstancedBaseVertexBaseInstanceEXT_indices( + const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei instancecount, + GLint basevertex, + GLuint baseinstance, + angle::ParamCapture *paramCapture); +void CaptureBindFragDataLocationEXT_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint color, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureBindFragDataLocationIndexedEXT_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLuint colorNumber, + GLuint index, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetFragDataIndexEXT_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureGetProgramResourceLocationIndexEXT_name(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum programInterface, + const GLchar *name, + angle::ParamCapture *paramCapture); +void CaptureBufferStorageEXT_data(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLsizeiptr size, + const void *data, + GLbitfield flags, + angle::ParamCapture *paramCapture); +void CaptureGetObjectLabelEXT_length(const State &glState, + bool isCallValid, + GLenum type, + GLuint object, + GLsizei bufSize, + GLsizei *length, + GLchar *label, + angle::ParamCapture *paramCapture); +void CaptureGetObjectLabelEXT_label(const State &glState, + bool isCallValid, + GLenum type, + GLuint object, + GLsizei bufSize, + GLsizei *length, + GLchar *label, + angle::ParamCapture *paramCapture); +void CaptureLabelObjectEXT_label(const State &glState, + bool isCallValid, + GLenum type, + GLuint object, + GLsizei length, + const GLchar *label, + angle::ParamCapture *paramCapture); +void CaptureInsertEventMarkerEXT_marker(const State &glState, + bool isCallValid, + GLsizei length, + const GLchar *marker, + angle::ParamCapture *paramCapture); +void CapturePushGroupMarkerEXT_marker(const State &glState, + bool isCallValid, + GLsizei length, + const GLchar *marker, + angle::ParamCapture *paramCapture); +void CaptureDiscardFramebufferEXT_attachments(const State &glState, + bool isCallValid, + GLenum target, + GLsizei numAttachments, + const GLenum *attachments, + angle::ParamCapture *paramCapture); +void CaptureDeleteQueriesEXT_idsPacked(const State &glState, + bool isCallValid, + GLsizei n, + const QueryID *idsPacked, + angle::ParamCapture *paramCapture); +void CaptureGenQueriesEXT_idsPacked(const State &glState, + bool isCallValid, + GLsizei n, + QueryID *idsPacked, + angle::ParamCapture *paramCapture); +void CaptureGetInteger64vEXT_data(const State &glState, + bool isCallValid, + GLenum pname, + GLint64 *data, + angle::ParamCapture *paramCapture); +void CaptureGetQueryObjecti64vEXT_params(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLint64 *params, + angle::ParamCapture *paramCapture); +void CaptureGetQueryObjectivEXT_params(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetQueryObjectui64vEXT_params(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLuint64 *params, + angle::ParamCapture *paramCapture); +void CaptureGetQueryObjectuivEXT_params(const State &glState, + bool isCallValid, + QueryID idPacked, + GLenum pname, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetQueryivEXT_params(const State &glState, + bool isCallValid, + QueryType targetPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureDrawBuffersEXT_bufs(const State &glState, + bool isCallValid, + GLsizei n, + const GLenum *bufs, + angle::ParamCapture *paramCapture); +void CaptureDrawElementsBaseVertexEXT_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLint basevertex, + angle::ParamCapture *paramCapture); +void CaptureDrawElementsInstancedBaseVertexEXT_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei instancecount, + GLint basevertex, + angle::ParamCapture *paramCapture); +void CaptureDrawRangeElementsBaseVertexEXT_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLuint start, + GLuint end, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLint basevertex, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsBaseVertexEXT_count(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *count, + DrawElementsType typePacked, + const void *const *indices, + GLsizei drawcount, + const GLint *basevertex, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsBaseVertexEXT_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *count, + DrawElementsType typePacked, + const void *const *indices, + GLsizei drawcount, + const GLint *basevertex, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsBaseVertexEXT_basevertex(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const GLsizei *count, + DrawElementsType typePacked, + const void *const *indices, + GLsizei drawcount, + const GLint *basevertex, + angle::ParamCapture *paramCapture); +void CaptureDrawElementsInstancedEXT_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei primcount, + angle::ParamCapture *paramCapture); +void CaptureCreateMemoryObjectsEXT_memoryObjectsPacked(const State &glState, + bool isCallValid, + GLsizei n, + MemoryObjectID *memoryObjectsPacked, + angle::ParamCapture *paramCapture); +void CaptureDeleteMemoryObjectsEXT_memoryObjectsPacked(const State &glState, + bool isCallValid, + GLsizei n, + const MemoryObjectID *memoryObjectsPacked, + angle::ParamCapture *paramCapture); +void CaptureGetMemoryObjectParameterivEXT_params(const State &glState, + bool isCallValid, + MemoryObjectID memoryObjectPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetUnsignedBytevEXT_data(const State &glState, + bool isCallValid, + GLenum pname, + GLubyte *data, + angle::ParamCapture *paramCapture); +void CaptureGetUnsignedBytei_vEXT_data(const State &glState, + bool isCallValid, + GLenum target, + GLuint index, + GLubyte *data, + angle::ParamCapture *paramCapture); +void CaptureMemoryObjectParameterivEXT_params(const State &glState, + bool isCallValid, + MemoryObjectID memoryObjectPacked, + GLenum pname, + const GLint *params, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawArraysIndirectEXT_indirect(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + const void *indirect, + GLsizei drawcount, + GLsizei stride, + angle::ParamCapture *paramCapture); +void CaptureMultiDrawElementsIndirectEXT_indirect(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + DrawElementsType typePacked, + const void *indirect, + GLsizei drawcount, + GLsizei stride, + angle::ParamCapture *paramCapture); +void CaptureGetnUniformfvEXT_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetnUniformivEXT_params(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei bufSize, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureReadnPixelsEXT_data(const State &glState, + bool isCallValid, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + void *data, + angle::ParamCapture *paramCapture); +void CaptureDeleteSemaphoresEXT_semaphoresPacked(const State &glState, + bool isCallValid, + GLsizei n, + const SemaphoreID *semaphoresPacked, + angle::ParamCapture *paramCapture); +void CaptureGenSemaphoresEXT_semaphoresPacked(const State &glState, + bool isCallValid, + GLsizei n, + SemaphoreID *semaphoresPacked, + angle::ParamCapture *paramCapture); +void CaptureGetSemaphoreParameterui64vEXT_params(const State &glState, + bool isCallValid, + SemaphoreID semaphorePacked, + GLenum pname, + GLuint64 *params, + angle::ParamCapture *paramCapture); +void CaptureSemaphoreParameterui64vEXT_params(const State &glState, + bool isCallValid, + SemaphoreID semaphorePacked, + GLenum pname, + const GLuint64 *params, + angle::ParamCapture *paramCapture); +void CaptureSignalSemaphoreEXT_buffersPacked(const State &glState, + bool isCallValid, + SemaphoreID semaphorePacked, + GLuint numBufferBarriers, + const BufferID *buffersPacked, + GLuint numTextureBarriers, + const TextureID *texturesPacked, + const GLenum *dstLayouts, + angle::ParamCapture *paramCapture); +void CaptureSignalSemaphoreEXT_texturesPacked(const State &glState, + bool isCallValid, + SemaphoreID semaphorePacked, + GLuint numBufferBarriers, + const BufferID *buffersPacked, + GLuint numTextureBarriers, + const TextureID *texturesPacked, + const GLenum *dstLayouts, + angle::ParamCapture *paramCapture); +void CaptureSignalSemaphoreEXT_dstLayouts(const State &glState, + bool isCallValid, + SemaphoreID semaphorePacked, + GLuint numBufferBarriers, + const BufferID *buffersPacked, + GLuint numTextureBarriers, + const TextureID *texturesPacked, + const GLenum *dstLayouts, + angle::ParamCapture *paramCapture); +void CaptureWaitSemaphoreEXT_buffersPacked(const State &glState, + bool isCallValid, + SemaphoreID semaphorePacked, + GLuint numBufferBarriers, + const BufferID *buffersPacked, + GLuint numTextureBarriers, + const TextureID *texturesPacked, + const GLenum *srcLayouts, + angle::ParamCapture *paramCapture); +void CaptureWaitSemaphoreEXT_texturesPacked(const State &glState, + bool isCallValid, + SemaphoreID semaphorePacked, + GLuint numBufferBarriers, + const BufferID *buffersPacked, + GLuint numTextureBarriers, + const TextureID *texturesPacked, + const GLenum *srcLayouts, + angle::ParamCapture *paramCapture); +void CaptureWaitSemaphoreEXT_srcLayouts(const State &glState, + bool isCallValid, + SemaphoreID semaphorePacked, + GLuint numBufferBarriers, + const BufferID *buffersPacked, + GLuint numTextureBarriers, + const TextureID *texturesPacked, + const GLenum *srcLayouts, + angle::ParamCapture *paramCapture); +void CaptureCreateShaderProgramvEXT_strings(const State &glState, + bool isCallValid, + ShaderType typePacked, + GLsizei count, + const GLchar **strings, + angle::ParamCapture *paramCapture); +void CaptureDeleteProgramPipelinesEXT_pipelinesPacked(const State &glState, + bool isCallValid, + GLsizei n, + const ProgramPipelineID *pipelinesPacked, + angle::ParamCapture *paramCapture); +void CaptureGenProgramPipelinesEXT_pipelinesPacked(const State &glState, + bool isCallValid, + GLsizei n, + ProgramPipelineID *pipelinesPacked, + angle::ParamCapture *paramCapture); +void CaptureGetProgramPipelineInfoLogEXT_length(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog, + angle::ParamCapture *paramCapture); +void CaptureGetProgramPipelineInfoLogEXT_infoLog(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog, + angle::ParamCapture *paramCapture); +void CaptureGetProgramPipelineivEXT_params(const State &glState, + bool isCallValid, + ProgramPipelineID pipelinePacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform1fvEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform1ivEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLint *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform1uivEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform2fvEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform2ivEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLint *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform2uivEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform3fvEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform3ivEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLint *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform3uivEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform4fvEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform4ivEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLint *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniform4uivEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + const GLuint *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix2fvEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix2x3fvEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix2x4fvEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix3fvEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix3x2fvEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix3x4fvEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix4fvEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix4x2fvEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureProgramUniformMatrix4x3fvEXT_value(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + UniformLocation locationPacked, + GLsizei count, + GLboolean transpose, + const GLfloat *value, + angle::ParamCapture *paramCapture); +void CaptureGetSamplerParameterIivEXT_params(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetSamplerParameterIuivEXT_params(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexParameterIivEXT_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexParameterIuivEXT_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureSamplerParameterIivEXT_param(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + const GLint *param, + angle::ParamCapture *paramCapture); +void CaptureSamplerParameterIuivEXT_param(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + const GLuint *param, + angle::ParamCapture *paramCapture); +void CaptureTexParameterIivEXT_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLint *params, + angle::ParamCapture *paramCapture); +void CaptureTexParameterIuivEXT_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureDebugMessageCallbackKHR_userParam(const State &glState, + bool isCallValid, + GLDEBUGPROCKHR callback, + const void *userParam, + angle::ParamCapture *paramCapture); +void CaptureDebugMessageControlKHR_ids(const State &glState, + bool isCallValid, + GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint *ids, + GLboolean enabled, + angle::ParamCapture *paramCapture); +void CaptureDebugMessageInsertKHR_buf(const State &glState, + bool isCallValid, + GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar *buf, + angle::ParamCapture *paramCapture); +void CaptureGetDebugMessageLogKHR_sources(const State &glState, + bool isCallValid, + GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog, + angle::ParamCapture *paramCapture); +void CaptureGetDebugMessageLogKHR_types(const State &glState, + bool isCallValid, + GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog, + angle::ParamCapture *paramCapture); +void CaptureGetDebugMessageLogKHR_ids(const State &glState, + bool isCallValid, + GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog, + angle::ParamCapture *paramCapture); +void CaptureGetDebugMessageLogKHR_severities(const State &glState, + bool isCallValid, + GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog, + angle::ParamCapture *paramCapture); +void CaptureGetDebugMessageLogKHR_lengths(const State &glState, + bool isCallValid, + GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog, + angle::ParamCapture *paramCapture); +void CaptureGetDebugMessageLogKHR_messageLog(const State &glState, + bool isCallValid, + GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog, + angle::ParamCapture *paramCapture); +void CaptureGetObjectLabelKHR_length(const State &glState, + bool isCallValid, + GLenum identifier, + GLuint name, + GLsizei bufSize, + GLsizei *length, + GLchar *label, + angle::ParamCapture *paramCapture); +void CaptureGetObjectLabelKHR_label(const State &glState, + bool isCallValid, + GLenum identifier, + GLuint name, + GLsizei bufSize, + GLsizei *length, + GLchar *label, + angle::ParamCapture *paramCapture); +void CaptureGetObjectPtrLabelKHR_ptr(const State &glState, + bool isCallValid, + const void *ptr, + GLsizei bufSize, + GLsizei *length, + GLchar *label, + angle::ParamCapture *paramCapture); +void CaptureGetObjectPtrLabelKHR_length(const State &glState, + bool isCallValid, + const void *ptr, + GLsizei bufSize, + GLsizei *length, + GLchar *label, + angle::ParamCapture *paramCapture); +void CaptureGetObjectPtrLabelKHR_label(const State &glState, + bool isCallValid, + const void *ptr, + GLsizei bufSize, + GLsizei *length, + GLchar *label, + angle::ParamCapture *paramCapture); +void CaptureGetPointervKHR_params(const State &glState, + bool isCallValid, + GLenum pname, + void **params, + angle::ParamCapture *paramCapture); +void CaptureObjectLabelKHR_label(const State &glState, + bool isCallValid, + GLenum identifier, + GLuint name, + GLsizei length, + const GLchar *label, + angle::ParamCapture *paramCapture); +void CaptureObjectPtrLabelKHR_ptr(const State &glState, + bool isCallValid, + const void *ptr, + GLsizei length, + const GLchar *label, + angle::ParamCapture *paramCapture); +void CaptureObjectPtrLabelKHR_label(const State &glState, + bool isCallValid, + const void *ptr, + GLsizei length, + const GLchar *label, + angle::ParamCapture *paramCapture); +void CapturePushDebugGroupKHR_message(const State &glState, + bool isCallValid, + GLenum source, + GLuint id, + GLsizei length, + const GLchar *message, + angle::ParamCapture *paramCapture); +void CaptureGetFramebufferParameterivMESA_params(const State &glState, + bool isCallValid, + GLenum target, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureDeleteFencesNV_fencesPacked(const State &glState, + bool isCallValid, + GLsizei n, + const FenceNVID *fencesPacked, + angle::ParamCapture *paramCapture); +void CaptureGenFencesNV_fencesPacked(const State &glState, + bool isCallValid, + GLsizei n, + FenceNVID *fencesPacked, + angle::ParamCapture *paramCapture); +void CaptureGetFenceivNV_params(const State &glState, + bool isCallValid, + FenceNVID fencePacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureDrawElementsBaseVertexOES_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLint basevertex, + angle::ParamCapture *paramCapture); +void CaptureDrawElementsInstancedBaseVertexOES_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLsizei instancecount, + GLint basevertex, + angle::ParamCapture *paramCapture); +void CaptureDrawRangeElementsBaseVertexOES_indices(const State &glState, + bool isCallValid, + PrimitiveMode modePacked, + GLuint start, + GLuint end, + GLsizei count, + DrawElementsType typePacked, + const void *indices, + GLint basevertex, + angle::ParamCapture *paramCapture); +void CaptureDrawTexfvOES_coords(const State &glState, + bool isCallValid, + const GLfloat *coords, + angle::ParamCapture *paramCapture); +void CaptureDrawTexivOES_coords(const State &glState, + bool isCallValid, + const GLint *coords, + angle::ParamCapture *paramCapture); +void CaptureDrawTexsvOES_coords(const State &glState, + bool isCallValid, + const GLshort *coords, + angle::ParamCapture *paramCapture); +void CaptureDrawTexxvOES_coords(const State &glState, + bool isCallValid, + const GLfixed *coords, + angle::ParamCapture *paramCapture); +void CaptureDeleteFramebuffersOES_framebuffersPacked(const State &glState, + bool isCallValid, + GLsizei n, + const FramebufferID *framebuffersPacked, + angle::ParamCapture *paramCapture); +void CaptureDeleteRenderbuffersOES_renderbuffersPacked(const State &glState, + bool isCallValid, + GLsizei n, + const RenderbufferID *renderbuffersPacked, + angle::ParamCapture *paramCapture); +void CaptureGenFramebuffersOES_framebuffersPacked(const State &glState, + bool isCallValid, + GLsizei n, + FramebufferID *framebuffersPacked, + angle::ParamCapture *paramCapture); +void CaptureGenRenderbuffersOES_renderbuffersPacked(const State &glState, + bool isCallValid, + GLsizei n, + RenderbufferID *renderbuffersPacked, + angle::ParamCapture *paramCapture); +void CaptureGetFramebufferAttachmentParameterivOES_params(const State &glState, + bool isCallValid, + GLenum target, + GLenum attachment, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetRenderbufferParameterivOES_params(const State &glState, + bool isCallValid, + GLenum target, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetProgramBinaryOES_length(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei bufSize, + GLsizei *length, + GLenum *binaryFormat, + void *binary, + angle::ParamCapture *paramCapture); +void CaptureGetProgramBinaryOES_binaryFormat(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei bufSize, + GLsizei *length, + GLenum *binaryFormat, + void *binary, + angle::ParamCapture *paramCapture); +void CaptureGetProgramBinaryOES_binary(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLsizei bufSize, + GLsizei *length, + GLenum *binaryFormat, + void *binary, + angle::ParamCapture *paramCapture); +void CaptureProgramBinaryOES_binary(const State &glState, + bool isCallValid, + ShaderProgramID programPacked, + GLenum binaryFormat, + const void *binary, + GLint length, + angle::ParamCapture *paramCapture); +void CaptureGetBufferPointervOES_params(const State &glState, + bool isCallValid, + BufferBinding targetPacked, + GLenum pname, + void **params, + angle::ParamCapture *paramCapture); +void CaptureMatrixIndexPointerOES_pointer(const State &glState, + bool isCallValid, + GLint size, + GLenum type, + GLsizei stride, + const void *pointer, + angle::ParamCapture *paramCapture); +void CaptureWeightPointerOES_pointer(const State &glState, + bool isCallValid, + GLint size, + GLenum type, + GLsizei stride, + const void *pointer, + angle::ParamCapture *paramCapture); +void CapturePointSizePointerOES_pointer(const State &glState, + bool isCallValid, + VertexAttribType typePacked, + GLsizei stride, + const void *pointer, + angle::ParamCapture *paramCapture); +void CaptureQueryMatrixxOES_mantissa(const State &glState, + bool isCallValid, + GLfixed *mantissa, + GLint *exponent, + angle::ParamCapture *paramCapture); +void CaptureQueryMatrixxOES_exponent(const State &glState, + bool isCallValid, + GLfixed *mantissa, + GLint *exponent, + angle::ParamCapture *paramCapture); +void CaptureCompressedTexImage3DOES_data(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLsizei imageSize, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureCompressedTexSubImage3DOES_data(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + const void *data, + angle::ParamCapture *paramCapture); +void CaptureTexImage3DOES_pixels(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLenum format, + GLenum type, + const void *pixels, + angle::ParamCapture *paramCapture); +void CaptureTexSubImage3DOES_pixels(const State &glState, + bool isCallValid, + TextureTarget targetPacked, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + const void *pixels, + angle::ParamCapture *paramCapture); +void CaptureGetSamplerParameterIivOES_params(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetSamplerParameterIuivOES_params(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexParameterIivOES_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexParameterIuivOES_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureSamplerParameterIivOES_param(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + const GLint *param, + angle::ParamCapture *paramCapture); +void CaptureSamplerParameterIuivOES_param(const State &glState, + bool isCallValid, + SamplerID samplerPacked, + GLenum pname, + const GLuint *param, + angle::ParamCapture *paramCapture); +void CaptureTexParameterIivOES_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLint *params, + angle::ParamCapture *paramCapture); +void CaptureTexParameterIuivOES_params(const State &glState, + bool isCallValid, + TextureType targetPacked, + GLenum pname, + const GLuint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexGenfvOES_params(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexGenivOES_params(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLint *params, + angle::ParamCapture *paramCapture); +void CaptureGetTexGenxvOES_params(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + GLfixed *params, + angle::ParamCapture *paramCapture); +void CaptureTexGenfvOES_params(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + const GLfloat *params, + angle::ParamCapture *paramCapture); +void CaptureTexGenivOES_params(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + const GLint *params, + angle::ParamCapture *paramCapture); +void CaptureTexGenxvOES_params(const State &glState, + bool isCallValid, + GLenum coord, + GLenum pname, + const GLfixed *params, + angle::ParamCapture *paramCapture); +void CaptureDeleteVertexArraysOES_arraysPacked(const State &glState, + bool isCallValid, + GLsizei n, + const VertexArrayID *arraysPacked, + angle::ParamCapture *paramCapture); +void CaptureGenVertexArraysOES_arraysPacked(const State &glState, + bool isCallValid, + GLsizei n, + VertexArrayID *arraysPacked, + angle::ParamCapture *paramCapture); +} // namespace gl + +#endif // LIBANGLE_CAPTURE_GLES_EXT_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils.h b/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils.h new file mode 100644 index 0000000000..18e2fe41cc --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils.h @@ -0,0 +1,23 @@ +// +// 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. +// +// frame_capture_utils.h: +// ANGLE frame capture utils interface. +// +#ifndef FRAME_CAPTURE_UTILS_H_ +#define FRAME_CAPTURE_UTILS_H_ + +#include "libANGLE/Error.h" + +namespace gl +{ +class Context; +} // namespace gl + +namespace angle +{ +Result SerializeContextToString(const gl::Context *context, std::string *stringOut); +} // namespace angle +#endif // FRAME_CAPTURE_UTILS_H_ diff --git a/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils_autogen.h new file mode 100644 index 0000000000..9c76c2fc15 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils_autogen.h @@ -0,0 +1,3257 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml. +// +// 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. +// +// frame_capture_utils_autogen.h: +// ANGLE Frame capture types and helper functions. + +#ifndef LIBANGLE_FRAME_CAPTURE_UTILS_AUTOGEN_H_ +#define LIBANGLE_FRAME_CAPTURE_UTILS_AUTOGEN_H_ + +#include "common/PackedEnums.h" + +namespace angle +{ +enum class ParamType +{ + TAHardwareBufferConstPointer, + TAlphaTestFunc, + TBufferBinding, + TBufferID, + TBufferIDConstPointer, + TBufferIDPointer, + TBufferUsage, + TClientVertexArrayType, + TCompositorTiming, + TCullFaceMode, + TDrawElementsType, + TEGLAttrib, + TEGLAttribKHR, + TEGLBoolean, + TEGLClientBuffer, + TEGLConfig, + TEGLContext, + TEGLDEBUGPROCKHR, + TEGLDeviceEXT, + TEGLDisplay, + TEGLFrameTokenANGLE, + TEGLGetBlobFuncANDROID, + TEGLImage, + TEGLLabelKHR, + TEGLNativeDisplayType, + TEGLNativePixmapType, + TEGLNativeWindowType, + TEGLObjectKHR, + TEGLSetBlobFuncANDROID, + TEGLStreamKHR, + TEGLSurface, + TEGLSync, + TEGLTime, + TEGLTimeKHR, + TEGLenum, + TEGLint, + TEGLnsecsANDROID, + TEGLuint64KHR, + TFenceNVID, + TFenceNVIDConstPointer, + TFenceNVIDPointer, + TFramebufferID, + TFramebufferIDConstPointer, + TFramebufferIDPointer, + TGLDEBUGPROC, + TGLDEBUGPROCKHR, + TGLbitfield, + TGLboolean, + TGLbooleanConstPointer, + TGLbooleanPointer, + TGLbyte, + TGLbyteConstPointer, + TGLcharConstPointer, + TGLcharConstPointerPointer, + TGLcharPointer, + TGLclampx, + TGLdouble, + TGLdoubleConstPointer, + TGLdoublePointer, + TGLeglClientBufferEXT, + TGLeglImageOES, + TGLenum, + TGLenumConstPointer, + TGLenumPointer, + TGLfixed, + TGLfixedConstPointer, + TGLfixedPointer, + TGLfloat, + TGLfloatConstPointer, + TGLfloatPointer, + TGLint, + TGLint64Pointer, + TGLintConstPointer, + TGLintPointer, + TGLintptr, + TGLintptrConstPointer, + TGLshort, + TGLshortConstPointer, + TGLsizei, + TGLsizeiConstPointer, + TGLsizeiPointer, + TGLsizeiptr, + TGLsizeiptrConstPointer, + TGLsync, + TGLubyte, + TGLubyteConstPointer, + TGLubytePointer, + TGLuint, + TGLuint64, + TGLuint64ConstPointer, + TGLuint64Pointer, + TGLuintConstPointer, + TGLuintPointer, + TGLushort, + TGLushortConstPointer, + TGLushortPointer, + TGLvoidConstPointer, + TGLvoidConstPointerPointer, + TGraphicsResetStatus, + THandleType, + TLightParameter, + TLogicalOperation, + TMaterialParameter, + TMatrixType, + TMemoryObjectID, + TMemoryObjectIDConstPointer, + TMemoryObjectIDPointer, + TObjectType, + TPointParameter, + TPrimitiveMode, + TProgramPipelineID, + TProgramPipelineIDConstPointer, + TProgramPipelineIDPointer, + TProvokingVertexConvention, + TQueryID, + TQueryIDConstPointer, + TQueryIDPointer, + TQueryType, + TRenderbufferID, + TRenderbufferIDConstPointer, + TRenderbufferIDPointer, + TSamplerID, + TSamplerIDConstPointer, + TSamplerIDPointer, + TSemaphoreID, + TSemaphoreIDConstPointer, + TSemaphoreIDPointer, + TShaderProgramID, + TShaderProgramIDConstPointer, + TShaderProgramIDPointer, + TShaderType, + TShadingModel, + TTextureEnvParameter, + TTextureEnvTarget, + TTextureID, + TTextureIDConstPointer, + TTextureIDPointer, + TTextureTarget, + TTextureType, + TTimestamp, + TTransformFeedbackID, + TTransformFeedbackIDConstPointer, + TTransformFeedbackIDPointer, + TUniformBlockIndex, + TUniformLocation, + TVertexArrayID, + TVertexArrayIDConstPointer, + TVertexArrayIDPointer, + TVertexAttribType, + TcharConstPointer, + TvoidConstPointer, + TvoidConstPointerPointer, + TvoidPointer, + TvoidPointerPointer, +}; + +constexpr uint32_t kParamTypeCount = 154; + +union ParamValue +{ + const AHardwareBuffer *AHardwareBufferConstPointerVal; + gl::AlphaTestFunc AlphaTestFuncVal; + gl::BufferBinding BufferBindingVal; + gl::BufferID BufferIDVal; + const gl::BufferID *BufferIDConstPointerVal; + gl::BufferID *BufferIDPointerVal; + gl::BufferUsage BufferUsageVal; + gl::ClientVertexArrayType ClientVertexArrayTypeVal; + egl::CompositorTiming CompositorTimingVal; + gl::CullFaceMode CullFaceModeVal; + gl::DrawElementsType DrawElementsTypeVal; + EGLAttrib EGLAttribVal; + EGLAttribKHR EGLAttribKHRVal; + EGLBoolean EGLBooleanVal; + EGLClientBuffer EGLClientBufferVal; + EGLConfig EGLConfigVal; + EGLContext EGLContextVal; + EGLDEBUGPROCKHR EGLDEBUGPROCKHRVal; + EGLDeviceEXT EGLDeviceEXTVal; + EGLDisplay EGLDisplayVal; + EGLFrameTokenANGLE EGLFrameTokenANGLEVal; + EGLGetBlobFuncANDROID EGLGetBlobFuncANDROIDVal; + EGLImage EGLImageVal; + EGLLabelKHR EGLLabelKHRVal; + EGLNativeDisplayType EGLNativeDisplayTypeVal; + EGLNativePixmapType EGLNativePixmapTypeVal; + EGLNativeWindowType EGLNativeWindowTypeVal; + EGLObjectKHR EGLObjectKHRVal; + EGLSetBlobFuncANDROID EGLSetBlobFuncANDROIDVal; + EGLStreamKHR EGLStreamKHRVal; + EGLSurface EGLSurfaceVal; + EGLSync EGLSyncVal; + EGLTime EGLTimeVal; + EGLTimeKHR EGLTimeKHRVal; + EGLenum EGLenumVal; + EGLint EGLintVal; + EGLnsecsANDROID EGLnsecsANDROIDVal; + EGLuint64KHR EGLuint64KHRVal; + gl::FenceNVID FenceNVIDVal; + const gl::FenceNVID *FenceNVIDConstPointerVal; + gl::FenceNVID *FenceNVIDPointerVal; + gl::FramebufferID FramebufferIDVal; + const gl::FramebufferID *FramebufferIDConstPointerVal; + gl::FramebufferID *FramebufferIDPointerVal; + GLDEBUGPROC GLDEBUGPROCVal; + GLDEBUGPROCKHR GLDEBUGPROCKHRVal; + GLbitfield GLbitfieldVal; + GLboolean GLbooleanVal; + const GLboolean *GLbooleanConstPointerVal; + GLboolean *GLbooleanPointerVal; + GLbyte GLbyteVal; + const GLbyte *GLbyteConstPointerVal; + const GLchar *GLcharConstPointerVal; + const GLchar *const *GLcharConstPointerPointerVal; + GLchar *GLcharPointerVal; + GLclampx GLclampxVal; + GLdouble GLdoubleVal; + const GLdouble *GLdoubleConstPointerVal; + GLdouble *GLdoublePointerVal; + GLeglClientBufferEXT GLeglClientBufferEXTVal; + GLeglImageOES GLeglImageOESVal; + GLenum GLenumVal; + const GLenum *GLenumConstPointerVal; + GLenum *GLenumPointerVal; + GLfixed GLfixedVal; + const GLfixed *GLfixedConstPointerVal; + GLfixed *GLfixedPointerVal; + GLfloat GLfloatVal; + const GLfloat *GLfloatConstPointerVal; + GLfloat *GLfloatPointerVal; + GLint GLintVal; + GLint64 *GLint64PointerVal; + const GLint *GLintConstPointerVal; + GLint *GLintPointerVal; + GLintptr GLintptrVal; + const GLintptr *GLintptrConstPointerVal; + GLshort GLshortVal; + const GLshort *GLshortConstPointerVal; + GLsizei GLsizeiVal; + const GLsizei *GLsizeiConstPointerVal; + GLsizei *GLsizeiPointerVal; + GLsizeiptr GLsizeiptrVal; + const GLsizeiptr *GLsizeiptrConstPointerVal; + GLsync GLsyncVal; + GLubyte GLubyteVal; + const GLubyte *GLubyteConstPointerVal; + GLubyte *GLubytePointerVal; + GLuint GLuintVal; + GLuint64 GLuint64Val; + const GLuint64 *GLuint64ConstPointerVal; + GLuint64 *GLuint64PointerVal; + const GLuint *GLuintConstPointerVal; + GLuint *GLuintPointerVal; + GLushort GLushortVal; + const GLushort *GLushortConstPointerVal; + GLushort *GLushortPointerVal; + const GLvoid *GLvoidConstPointerVal; + const GLvoid *const *GLvoidConstPointerPointerVal; + gl::GraphicsResetStatus GraphicsResetStatusVal; + gl::HandleType HandleTypeVal; + gl::LightParameter LightParameterVal; + gl::LogicalOperation LogicalOperationVal; + gl::MaterialParameter MaterialParameterVal; + gl::MatrixType MatrixTypeVal; + gl::MemoryObjectID MemoryObjectIDVal; + const gl::MemoryObjectID *MemoryObjectIDConstPointerVal; + gl::MemoryObjectID *MemoryObjectIDPointerVal; + egl::ObjectType ObjectTypeVal; + gl::PointParameter PointParameterVal; + gl::PrimitiveMode PrimitiveModeVal; + gl::ProgramPipelineID ProgramPipelineIDVal; + const gl::ProgramPipelineID *ProgramPipelineIDConstPointerVal; + gl::ProgramPipelineID *ProgramPipelineIDPointerVal; + gl::ProvokingVertexConvention ProvokingVertexConventionVal; + gl::QueryID QueryIDVal; + const gl::QueryID *QueryIDConstPointerVal; + gl::QueryID *QueryIDPointerVal; + gl::QueryType QueryTypeVal; + gl::RenderbufferID RenderbufferIDVal; + const gl::RenderbufferID *RenderbufferIDConstPointerVal; + gl::RenderbufferID *RenderbufferIDPointerVal; + gl::SamplerID SamplerIDVal; + const gl::SamplerID *SamplerIDConstPointerVal; + gl::SamplerID *SamplerIDPointerVal; + gl::SemaphoreID SemaphoreIDVal; + const gl::SemaphoreID *SemaphoreIDConstPointerVal; + gl::SemaphoreID *SemaphoreIDPointerVal; + gl::ShaderProgramID ShaderProgramIDVal; + const gl::ShaderProgramID *ShaderProgramIDConstPointerVal; + gl::ShaderProgramID *ShaderProgramIDPointerVal; + gl::ShaderType ShaderTypeVal; + gl::ShadingModel ShadingModelVal; + gl::TextureEnvParameter TextureEnvParameterVal; + gl::TextureEnvTarget TextureEnvTargetVal; + gl::TextureID TextureIDVal; + const gl::TextureID *TextureIDConstPointerVal; + gl::TextureID *TextureIDPointerVal; + gl::TextureTarget TextureTargetVal; + gl::TextureType TextureTypeVal; + egl::Timestamp TimestampVal; + gl::TransformFeedbackID TransformFeedbackIDVal; + const gl::TransformFeedbackID *TransformFeedbackIDConstPointerVal; + gl::TransformFeedbackID *TransformFeedbackIDPointerVal; + gl::UniformBlockIndex UniformBlockIndexVal; + gl::UniformLocation UniformLocationVal; + gl::VertexArrayID VertexArrayIDVal; + const gl::VertexArrayID *VertexArrayIDConstPointerVal; + gl::VertexArrayID *VertexArrayIDPointerVal; + gl::VertexAttribType VertexAttribTypeVal; + const char *charConstPointerVal; + const void *voidConstPointerVal; + const void *const *voidConstPointerPointerVal; + void *voidPointerVal; + void **voidPointerPointerVal; +}; + +template <ParamType PType, typename T> +T GetParamVal(const ParamValue &value); + +template <> +inline const AHardwareBuffer *GetParamVal<ParamType::TAHardwareBufferConstPointer, + const AHardwareBuffer *>(const ParamValue &value) +{ + return value.AHardwareBufferConstPointerVal; +} + +template <> +inline gl::AlphaTestFunc GetParamVal<ParamType::TAlphaTestFunc, gl::AlphaTestFunc>( + const ParamValue &value) +{ + return value.AlphaTestFuncVal; +} + +template <> +inline gl::BufferBinding GetParamVal<ParamType::TBufferBinding, gl::BufferBinding>( + const ParamValue &value) +{ + return value.BufferBindingVal; +} + +template <> +inline gl::BufferID GetParamVal<ParamType::TBufferID, gl::BufferID>(const ParamValue &value) +{ + return value.BufferIDVal; +} + +template <> +inline const gl::BufferID *GetParamVal<ParamType::TBufferIDConstPointer, const gl::BufferID *>( + const ParamValue &value) +{ + return value.BufferIDConstPointerVal; +} + +template <> +inline gl::BufferID *GetParamVal<ParamType::TBufferIDPointer, gl::BufferID *>( + const ParamValue &value) +{ + return value.BufferIDPointerVal; +} + +template <> +inline gl::BufferUsage GetParamVal<ParamType::TBufferUsage, gl::BufferUsage>( + const ParamValue &value) +{ + return value.BufferUsageVal; +} + +template <> +inline gl::ClientVertexArrayType +GetParamVal<ParamType::TClientVertexArrayType, gl::ClientVertexArrayType>(const ParamValue &value) +{ + return value.ClientVertexArrayTypeVal; +} + +template <> +inline egl::CompositorTiming GetParamVal<ParamType::TCompositorTiming, egl::CompositorTiming>( + const ParamValue &value) +{ + return value.CompositorTimingVal; +} + +template <> +inline gl::CullFaceMode GetParamVal<ParamType::TCullFaceMode, gl::CullFaceMode>( + const ParamValue &value) +{ + return value.CullFaceModeVal; +} + +template <> +inline gl::DrawElementsType GetParamVal<ParamType::TDrawElementsType, gl::DrawElementsType>( + const ParamValue &value) +{ + return value.DrawElementsTypeVal; +} + +template <> +inline EGLAttrib GetParamVal<ParamType::TEGLAttrib, EGLAttrib>(const ParamValue &value) +{ + return value.EGLAttribVal; +} + +template <> +inline EGLAttribKHR GetParamVal<ParamType::TEGLAttribKHR, EGLAttribKHR>(const ParamValue &value) +{ + return value.EGLAttribKHRVal; +} + +template <> +inline EGLBoolean GetParamVal<ParamType::TEGLBoolean, EGLBoolean>(const ParamValue &value) +{ + return value.EGLBooleanVal; +} + +template <> +inline EGLClientBuffer GetParamVal<ParamType::TEGLClientBuffer, EGLClientBuffer>( + const ParamValue &value) +{ + return value.EGLClientBufferVal; +} + +template <> +inline EGLConfig GetParamVal<ParamType::TEGLConfig, EGLConfig>(const ParamValue &value) +{ + return value.EGLConfigVal; +} + +template <> +inline EGLContext GetParamVal<ParamType::TEGLContext, EGLContext>(const ParamValue &value) +{ + return value.EGLContextVal; +} + +template <> +inline EGLDEBUGPROCKHR GetParamVal<ParamType::TEGLDEBUGPROCKHR, EGLDEBUGPROCKHR>( + const ParamValue &value) +{ + return value.EGLDEBUGPROCKHRVal; +} + +template <> +inline EGLDeviceEXT GetParamVal<ParamType::TEGLDeviceEXT, EGLDeviceEXT>(const ParamValue &value) +{ + return value.EGLDeviceEXTVal; +} + +template <> +inline EGLDisplay GetParamVal<ParamType::TEGLDisplay, EGLDisplay>(const ParamValue &value) +{ + return value.EGLDisplayVal; +} + +template <> +inline EGLFrameTokenANGLE GetParamVal<ParamType::TEGLFrameTokenANGLE, EGLFrameTokenANGLE>( + const ParamValue &value) +{ + return value.EGLFrameTokenANGLEVal; +} + +template <> +inline EGLGetBlobFuncANDROID GetParamVal<ParamType::TEGLGetBlobFuncANDROID, EGLGetBlobFuncANDROID>( + const ParamValue &value) +{ + return value.EGLGetBlobFuncANDROIDVal; +} + +template <> +inline EGLImage GetParamVal<ParamType::TEGLImage, EGLImage>(const ParamValue &value) +{ + return value.EGLImageVal; +} + +template <> +inline EGLLabelKHR GetParamVal<ParamType::TEGLLabelKHR, EGLLabelKHR>(const ParamValue &value) +{ + return value.EGLLabelKHRVal; +} + +template <> +inline EGLNativeDisplayType GetParamVal<ParamType::TEGLNativeDisplayType, EGLNativeDisplayType>( + const ParamValue &value) +{ + return value.EGLNativeDisplayTypeVal; +} + +template <> +inline EGLNativePixmapType GetParamVal<ParamType::TEGLNativePixmapType, EGLNativePixmapType>( + const ParamValue &value) +{ + return value.EGLNativePixmapTypeVal; +} + +template <> +inline EGLNativeWindowType GetParamVal<ParamType::TEGLNativeWindowType, EGLNativeWindowType>( + const ParamValue &value) +{ + return value.EGLNativeWindowTypeVal; +} + +template <> +inline EGLObjectKHR GetParamVal<ParamType::TEGLObjectKHR, EGLObjectKHR>(const ParamValue &value) +{ + return value.EGLObjectKHRVal; +} + +template <> +inline EGLSetBlobFuncANDROID GetParamVal<ParamType::TEGLSetBlobFuncANDROID, EGLSetBlobFuncANDROID>( + const ParamValue &value) +{ + return value.EGLSetBlobFuncANDROIDVal; +} + +template <> +inline EGLStreamKHR GetParamVal<ParamType::TEGLStreamKHR, EGLStreamKHR>(const ParamValue &value) +{ + return value.EGLStreamKHRVal; +} + +template <> +inline EGLSurface GetParamVal<ParamType::TEGLSurface, EGLSurface>(const ParamValue &value) +{ + return value.EGLSurfaceVal; +} + +template <> +inline EGLSync GetParamVal<ParamType::TEGLSync, EGLSync>(const ParamValue &value) +{ + return value.EGLSyncVal; +} + +template <> +inline EGLTime GetParamVal<ParamType::TEGLTime, EGLTime>(const ParamValue &value) +{ + return value.EGLTimeVal; +} + +template <> +inline EGLTimeKHR GetParamVal<ParamType::TEGLTimeKHR, EGLTimeKHR>(const ParamValue &value) +{ + return value.EGLTimeKHRVal; +} + +template <> +inline EGLenum GetParamVal<ParamType::TEGLenum, EGLenum>(const ParamValue &value) +{ + return value.EGLenumVal; +} + +template <> +inline EGLint GetParamVal<ParamType::TEGLint, EGLint>(const ParamValue &value) +{ + return value.EGLintVal; +} + +template <> +inline EGLnsecsANDROID GetParamVal<ParamType::TEGLnsecsANDROID, EGLnsecsANDROID>( + const ParamValue &value) +{ + return value.EGLnsecsANDROIDVal; +} + +template <> +inline EGLuint64KHR GetParamVal<ParamType::TEGLuint64KHR, EGLuint64KHR>(const ParamValue &value) +{ + return value.EGLuint64KHRVal; +} + +template <> +inline gl::FenceNVID GetParamVal<ParamType::TFenceNVID, gl::FenceNVID>(const ParamValue &value) +{ + return value.FenceNVIDVal; +} + +template <> +inline const gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDConstPointer, const gl::FenceNVID *>( + const ParamValue &value) +{ + return value.FenceNVIDConstPointerVal; +} + +template <> +inline gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDPointer, gl::FenceNVID *>( + const ParamValue &value) +{ + return value.FenceNVIDPointerVal; +} + +template <> +inline gl::FramebufferID GetParamVal<ParamType::TFramebufferID, gl::FramebufferID>( + const ParamValue &value) +{ + return value.FramebufferIDVal; +} + +template <> +inline const gl::FramebufferID *GetParamVal<ParamType::TFramebufferIDConstPointer, + const gl::FramebufferID *>(const ParamValue &value) +{ + return value.FramebufferIDConstPointerVal; +} + +template <> +inline gl::FramebufferID *GetParamVal<ParamType::TFramebufferIDPointer, gl::FramebufferID *>( + const ParamValue &value) +{ + return value.FramebufferIDPointerVal; +} + +template <> +inline GLDEBUGPROC GetParamVal<ParamType::TGLDEBUGPROC, GLDEBUGPROC>(const ParamValue &value) +{ + return value.GLDEBUGPROCVal; +} + +template <> +inline GLDEBUGPROCKHR GetParamVal<ParamType::TGLDEBUGPROCKHR, GLDEBUGPROCKHR>( + const ParamValue &value) +{ + return value.GLDEBUGPROCKHRVal; +} + +template <> +inline GLbitfield GetParamVal<ParamType::TGLbitfield, GLbitfield>(const ParamValue &value) +{ + return value.GLbitfieldVal; +} + +template <> +inline GLboolean GetParamVal<ParamType::TGLboolean, GLboolean>(const ParamValue &value) +{ + return value.GLbooleanVal; +} + +template <> +inline const GLboolean *GetParamVal<ParamType::TGLbooleanConstPointer, const GLboolean *>( + const ParamValue &value) +{ + return value.GLbooleanConstPointerVal; +} + +template <> +inline GLboolean *GetParamVal<ParamType::TGLbooleanPointer, GLboolean *>(const ParamValue &value) +{ + return value.GLbooleanPointerVal; +} + +template <> +inline GLbyte GetParamVal<ParamType::TGLbyte, GLbyte>(const ParamValue &value) +{ + return value.GLbyteVal; +} + +template <> +inline const GLbyte *GetParamVal<ParamType::TGLbyteConstPointer, const GLbyte *>( + const ParamValue &value) +{ + return value.GLbyteConstPointerVal; +} + +template <> +inline const GLchar *GetParamVal<ParamType::TGLcharConstPointer, const GLchar *>( + const ParamValue &value) +{ + return value.GLcharConstPointerVal; +} + +template <> +inline const GLchar *const * +GetParamVal<ParamType::TGLcharConstPointerPointer, const GLchar *const *>(const ParamValue &value) +{ + return value.GLcharConstPointerPointerVal; +} + +template <> +inline GLchar *GetParamVal<ParamType::TGLcharPointer, GLchar *>(const ParamValue &value) +{ + return value.GLcharPointerVal; +} + +template <> +inline GLclampx GetParamVal<ParamType::TGLclampx, GLclampx>(const ParamValue &value) +{ + return value.GLclampxVal; +} + +template <> +inline GLdouble GetParamVal<ParamType::TGLdouble, GLdouble>(const ParamValue &value) +{ + return value.GLdoubleVal; +} + +template <> +inline const GLdouble *GetParamVal<ParamType::TGLdoubleConstPointer, const GLdouble *>( + const ParamValue &value) +{ + return value.GLdoubleConstPointerVal; +} + +template <> +inline GLdouble *GetParamVal<ParamType::TGLdoublePointer, GLdouble *>(const ParamValue &value) +{ + return value.GLdoublePointerVal; +} + +template <> +inline GLeglClientBufferEXT GetParamVal<ParamType::TGLeglClientBufferEXT, GLeglClientBufferEXT>( + const ParamValue &value) +{ + return value.GLeglClientBufferEXTVal; +} + +template <> +inline GLeglImageOES GetParamVal<ParamType::TGLeglImageOES, GLeglImageOES>(const ParamValue &value) +{ + return value.GLeglImageOESVal; +} + +template <> +inline GLenum GetParamVal<ParamType::TGLenum, GLenum>(const ParamValue &value) +{ + return value.GLenumVal; +} + +template <> +inline const GLenum *GetParamVal<ParamType::TGLenumConstPointer, const GLenum *>( + const ParamValue &value) +{ + return value.GLenumConstPointerVal; +} + +template <> +inline GLenum *GetParamVal<ParamType::TGLenumPointer, GLenum *>(const ParamValue &value) +{ + return value.GLenumPointerVal; +} + +template <> +inline GLfixed GetParamVal<ParamType::TGLfixed, GLfixed>(const ParamValue &value) +{ + return value.GLfixedVal; +} + +template <> +inline const GLfixed *GetParamVal<ParamType::TGLfixedConstPointer, const GLfixed *>( + const ParamValue &value) +{ + return value.GLfixedConstPointerVal; +} + +template <> +inline GLfixed *GetParamVal<ParamType::TGLfixedPointer, GLfixed *>(const ParamValue &value) +{ + return value.GLfixedPointerVal; +} + +template <> +inline GLfloat GetParamVal<ParamType::TGLfloat, GLfloat>(const ParamValue &value) +{ + return value.GLfloatVal; +} + +template <> +inline const GLfloat *GetParamVal<ParamType::TGLfloatConstPointer, const GLfloat *>( + const ParamValue &value) +{ + return value.GLfloatConstPointerVal; +} + +template <> +inline GLfloat *GetParamVal<ParamType::TGLfloatPointer, GLfloat *>(const ParamValue &value) +{ + return value.GLfloatPointerVal; +} + +template <> +inline GLint GetParamVal<ParamType::TGLint, GLint>(const ParamValue &value) +{ + return value.GLintVal; +} + +template <> +inline GLint64 *GetParamVal<ParamType::TGLint64Pointer, GLint64 *>(const ParamValue &value) +{ + return value.GLint64PointerVal; +} + +template <> +inline const GLint *GetParamVal<ParamType::TGLintConstPointer, const GLint *>( + const ParamValue &value) +{ + return value.GLintConstPointerVal; +} + +template <> +inline GLint *GetParamVal<ParamType::TGLintPointer, GLint *>(const ParamValue &value) +{ + return value.GLintPointerVal; +} + +template <> +inline GLintptr GetParamVal<ParamType::TGLintptr, GLintptr>(const ParamValue &value) +{ + return value.GLintptrVal; +} + +template <> +inline const GLintptr *GetParamVal<ParamType::TGLintptrConstPointer, const GLintptr *>( + const ParamValue &value) +{ + return value.GLintptrConstPointerVal; +} + +template <> +inline GLshort GetParamVal<ParamType::TGLshort, GLshort>(const ParamValue &value) +{ + return value.GLshortVal; +} + +template <> +inline const GLshort *GetParamVal<ParamType::TGLshortConstPointer, const GLshort *>( + const ParamValue &value) +{ + return value.GLshortConstPointerVal; +} + +template <> +inline GLsizei GetParamVal<ParamType::TGLsizei, GLsizei>(const ParamValue &value) +{ + return value.GLsizeiVal; +} + +template <> +inline const GLsizei *GetParamVal<ParamType::TGLsizeiConstPointer, const GLsizei *>( + const ParamValue &value) +{ + return value.GLsizeiConstPointerVal; +} + +template <> +inline GLsizei *GetParamVal<ParamType::TGLsizeiPointer, GLsizei *>(const ParamValue &value) +{ + return value.GLsizeiPointerVal; +} + +template <> +inline GLsizeiptr GetParamVal<ParamType::TGLsizeiptr, GLsizeiptr>(const ParamValue &value) +{ + return value.GLsizeiptrVal; +} + +template <> +inline const GLsizeiptr *GetParamVal<ParamType::TGLsizeiptrConstPointer, const GLsizeiptr *>( + const ParamValue &value) +{ + return value.GLsizeiptrConstPointerVal; +} + +template <> +inline GLsync GetParamVal<ParamType::TGLsync, GLsync>(const ParamValue &value) +{ + return value.GLsyncVal; +} + +template <> +inline GLubyte GetParamVal<ParamType::TGLubyte, GLubyte>(const ParamValue &value) +{ + return value.GLubyteVal; +} + +template <> +inline const GLubyte *GetParamVal<ParamType::TGLubyteConstPointer, const GLubyte *>( + const ParamValue &value) +{ + return value.GLubyteConstPointerVal; +} + +template <> +inline GLubyte *GetParamVal<ParamType::TGLubytePointer, GLubyte *>(const ParamValue &value) +{ + return value.GLubytePointerVal; +} + +template <> +inline GLuint GetParamVal<ParamType::TGLuint, GLuint>(const ParamValue &value) +{ + return value.GLuintVal; +} + +template <> +inline GLuint64 GetParamVal<ParamType::TGLuint64, GLuint64>(const ParamValue &value) +{ + return value.GLuint64Val; +} + +template <> +inline const GLuint64 *GetParamVal<ParamType::TGLuint64ConstPointer, const GLuint64 *>( + const ParamValue &value) +{ + return value.GLuint64ConstPointerVal; +} + +template <> +inline GLuint64 *GetParamVal<ParamType::TGLuint64Pointer, GLuint64 *>(const ParamValue &value) +{ + return value.GLuint64PointerVal; +} + +template <> +inline const GLuint *GetParamVal<ParamType::TGLuintConstPointer, const GLuint *>( + const ParamValue &value) +{ + return value.GLuintConstPointerVal; +} + +template <> +inline GLuint *GetParamVal<ParamType::TGLuintPointer, GLuint *>(const ParamValue &value) +{ + return value.GLuintPointerVal; +} + +template <> +inline GLushort GetParamVal<ParamType::TGLushort, GLushort>(const ParamValue &value) +{ + return value.GLushortVal; +} + +template <> +inline const GLushort *GetParamVal<ParamType::TGLushortConstPointer, const GLushort *>( + const ParamValue &value) +{ + return value.GLushortConstPointerVal; +} + +template <> +inline GLushort *GetParamVal<ParamType::TGLushortPointer, GLushort *>(const ParamValue &value) +{ + return value.GLushortPointerVal; +} + +template <> +inline const GLvoid *GetParamVal<ParamType::TGLvoidConstPointer, const GLvoid *>( + const ParamValue &value) +{ + return value.GLvoidConstPointerVal; +} + +template <> +inline const GLvoid *const * +GetParamVal<ParamType::TGLvoidConstPointerPointer, const GLvoid *const *>(const ParamValue &value) +{ + return value.GLvoidConstPointerPointerVal; +} + +template <> +inline gl::GraphicsResetStatus +GetParamVal<ParamType::TGraphicsResetStatus, gl::GraphicsResetStatus>(const ParamValue &value) +{ + return value.GraphicsResetStatusVal; +} + +template <> +inline gl::HandleType GetParamVal<ParamType::THandleType, gl::HandleType>(const ParamValue &value) +{ + return value.HandleTypeVal; +} + +template <> +inline gl::LightParameter GetParamVal<ParamType::TLightParameter, gl::LightParameter>( + const ParamValue &value) +{ + return value.LightParameterVal; +} + +template <> +inline gl::LogicalOperation GetParamVal<ParamType::TLogicalOperation, gl::LogicalOperation>( + const ParamValue &value) +{ + return value.LogicalOperationVal; +} + +template <> +inline gl::MaterialParameter GetParamVal<ParamType::TMaterialParameter, gl::MaterialParameter>( + const ParamValue &value) +{ + return value.MaterialParameterVal; +} + +template <> +inline gl::MatrixType GetParamVal<ParamType::TMatrixType, gl::MatrixType>(const ParamValue &value) +{ + return value.MatrixTypeVal; +} + +template <> +inline gl::MemoryObjectID GetParamVal<ParamType::TMemoryObjectID, gl::MemoryObjectID>( + const ParamValue &value) +{ + return value.MemoryObjectIDVal; +} + +template <> +inline const gl::MemoryObjectID *GetParamVal<ParamType::TMemoryObjectIDConstPointer, + const gl::MemoryObjectID *>(const ParamValue &value) +{ + return value.MemoryObjectIDConstPointerVal; +} + +template <> +inline gl::MemoryObjectID *GetParamVal<ParamType::TMemoryObjectIDPointer, gl::MemoryObjectID *>( + const ParamValue &value) +{ + return value.MemoryObjectIDPointerVal; +} + +template <> +inline egl::ObjectType GetParamVal<ParamType::TObjectType, egl::ObjectType>(const ParamValue &value) +{ + return value.ObjectTypeVal; +} + +template <> +inline gl::PointParameter GetParamVal<ParamType::TPointParameter, gl::PointParameter>( + const ParamValue &value) +{ + return value.PointParameterVal; +} + +template <> +inline gl::PrimitiveMode GetParamVal<ParamType::TPrimitiveMode, gl::PrimitiveMode>( + const ParamValue &value) +{ + return value.PrimitiveModeVal; +} + +template <> +inline gl::ProgramPipelineID GetParamVal<ParamType::TProgramPipelineID, gl::ProgramPipelineID>( + const ParamValue &value) +{ + return value.ProgramPipelineIDVal; +} + +template <> +inline const gl::ProgramPipelineID * +GetParamVal<ParamType::TProgramPipelineIDConstPointer, const gl::ProgramPipelineID *>( + const ParamValue &value) +{ + return value.ProgramPipelineIDConstPointerVal; +} + +template <> +inline gl::ProgramPipelineID * +GetParamVal<ParamType::TProgramPipelineIDPointer, gl::ProgramPipelineID *>(const ParamValue &value) +{ + return value.ProgramPipelineIDPointerVal; +} + +template <> +inline gl::ProvokingVertexConvention +GetParamVal<ParamType::TProvokingVertexConvention, gl::ProvokingVertexConvention>( + const ParamValue &value) +{ + return value.ProvokingVertexConventionVal; +} + +template <> +inline gl::QueryID GetParamVal<ParamType::TQueryID, gl::QueryID>(const ParamValue &value) +{ + return value.QueryIDVal; +} + +template <> +inline const gl::QueryID *GetParamVal<ParamType::TQueryIDConstPointer, const gl::QueryID *>( + const ParamValue &value) +{ + return value.QueryIDConstPointerVal; +} + +template <> +inline gl::QueryID *GetParamVal<ParamType::TQueryIDPointer, gl::QueryID *>(const ParamValue &value) +{ + return value.QueryIDPointerVal; +} + +template <> +inline gl::QueryType GetParamVal<ParamType::TQueryType, gl::QueryType>(const ParamValue &value) +{ + return value.QueryTypeVal; +} + +template <> +inline gl::RenderbufferID GetParamVal<ParamType::TRenderbufferID, gl::RenderbufferID>( + const ParamValue &value) +{ + return value.RenderbufferIDVal; +} + +template <> +inline const gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDConstPointer, + const gl::RenderbufferID *>(const ParamValue &value) +{ + return value.RenderbufferIDConstPointerVal; +} + +template <> +inline gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDPointer, gl::RenderbufferID *>( + const ParamValue &value) +{ + return value.RenderbufferIDPointerVal; +} + +template <> +inline gl::SamplerID GetParamVal<ParamType::TSamplerID, gl::SamplerID>(const ParamValue &value) +{ + return value.SamplerIDVal; +} + +template <> +inline const gl::SamplerID *GetParamVal<ParamType::TSamplerIDConstPointer, const gl::SamplerID *>( + const ParamValue &value) +{ + return value.SamplerIDConstPointerVal; +} + +template <> +inline gl::SamplerID *GetParamVal<ParamType::TSamplerIDPointer, gl::SamplerID *>( + const ParamValue &value) +{ + return value.SamplerIDPointerVal; +} + +template <> +inline gl::SemaphoreID GetParamVal<ParamType::TSemaphoreID, gl::SemaphoreID>( + const ParamValue &value) +{ + return value.SemaphoreIDVal; +} + +template <> +inline const gl::SemaphoreID * +GetParamVal<ParamType::TSemaphoreIDConstPointer, const gl::SemaphoreID *>(const ParamValue &value) +{ + return value.SemaphoreIDConstPointerVal; +} + +template <> +inline gl::SemaphoreID *GetParamVal<ParamType::TSemaphoreIDPointer, gl::SemaphoreID *>( + const ParamValue &value) +{ + return value.SemaphoreIDPointerVal; +} + +template <> +inline gl::ShaderProgramID GetParamVal<ParamType::TShaderProgramID, gl::ShaderProgramID>( + const ParamValue &value) +{ + return value.ShaderProgramIDVal; +} + +template <> +inline const gl::ShaderProgramID *GetParamVal<ParamType::TShaderProgramIDConstPointer, + const gl::ShaderProgramID *>(const ParamValue &value) +{ + return value.ShaderProgramIDConstPointerVal; +} + +template <> +inline gl::ShaderProgramID *GetParamVal<ParamType::TShaderProgramIDPointer, gl::ShaderProgramID *>( + const ParamValue &value) +{ + return value.ShaderProgramIDPointerVal; +} + +template <> +inline gl::ShaderType GetParamVal<ParamType::TShaderType, gl::ShaderType>(const ParamValue &value) +{ + return value.ShaderTypeVal; +} + +template <> +inline gl::ShadingModel GetParamVal<ParamType::TShadingModel, gl::ShadingModel>( + const ParamValue &value) +{ + return value.ShadingModelVal; +} + +template <> +inline gl::TextureEnvParameter +GetParamVal<ParamType::TTextureEnvParameter, gl::TextureEnvParameter>(const ParamValue &value) +{ + return value.TextureEnvParameterVal; +} + +template <> +inline gl::TextureEnvTarget GetParamVal<ParamType::TTextureEnvTarget, gl::TextureEnvTarget>( + const ParamValue &value) +{ + return value.TextureEnvTargetVal; +} + +template <> +inline gl::TextureID GetParamVal<ParamType::TTextureID, gl::TextureID>(const ParamValue &value) +{ + return value.TextureIDVal; +} + +template <> +inline const gl::TextureID *GetParamVal<ParamType::TTextureIDConstPointer, const gl::TextureID *>( + const ParamValue &value) +{ + return value.TextureIDConstPointerVal; +} + +template <> +inline gl::TextureID *GetParamVal<ParamType::TTextureIDPointer, gl::TextureID *>( + const ParamValue &value) +{ + return value.TextureIDPointerVal; +} + +template <> +inline gl::TextureTarget GetParamVal<ParamType::TTextureTarget, gl::TextureTarget>( + const ParamValue &value) +{ + return value.TextureTargetVal; +} + +template <> +inline gl::TextureType GetParamVal<ParamType::TTextureType, gl::TextureType>( + const ParamValue &value) +{ + return value.TextureTypeVal; +} + +template <> +inline egl::Timestamp GetParamVal<ParamType::TTimestamp, egl::Timestamp>(const ParamValue &value) +{ + return value.TimestampVal; +} + +template <> +inline gl::TransformFeedbackID +GetParamVal<ParamType::TTransformFeedbackID, gl::TransformFeedbackID>(const ParamValue &value) +{ + return value.TransformFeedbackIDVal; +} + +template <> +inline const gl::TransformFeedbackID * +GetParamVal<ParamType::TTransformFeedbackIDConstPointer, const gl::TransformFeedbackID *>( + const ParamValue &value) +{ + return value.TransformFeedbackIDConstPointerVal; +} + +template <> +inline gl::TransformFeedbackID *GetParamVal<ParamType::TTransformFeedbackIDPointer, + gl::TransformFeedbackID *>(const ParamValue &value) +{ + return value.TransformFeedbackIDPointerVal; +} + +template <> +inline gl::UniformBlockIndex GetParamVal<ParamType::TUniformBlockIndex, gl::UniformBlockIndex>( + const ParamValue &value) +{ + return value.UniformBlockIndexVal; +} + +template <> +inline gl::UniformLocation GetParamVal<ParamType::TUniformLocation, gl::UniformLocation>( + const ParamValue &value) +{ + return value.UniformLocationVal; +} + +template <> +inline gl::VertexArrayID GetParamVal<ParamType::TVertexArrayID, gl::VertexArrayID>( + const ParamValue &value) +{ + return value.VertexArrayIDVal; +} + +template <> +inline const gl::VertexArrayID *GetParamVal<ParamType::TVertexArrayIDConstPointer, + const gl::VertexArrayID *>(const ParamValue &value) +{ + return value.VertexArrayIDConstPointerVal; +} + +template <> +inline gl::VertexArrayID *GetParamVal<ParamType::TVertexArrayIDPointer, gl::VertexArrayID *>( + const ParamValue &value) +{ + return value.VertexArrayIDPointerVal; +} + +template <> +inline gl::VertexAttribType GetParamVal<ParamType::TVertexAttribType, gl::VertexAttribType>( + const ParamValue &value) +{ + return value.VertexAttribTypeVal; +} + +template <> +inline const char *GetParamVal<ParamType::TcharConstPointer, const char *>(const ParamValue &value) +{ + return value.charConstPointerVal; +} + +template <> +inline const void *GetParamVal<ParamType::TvoidConstPointer, const void *>(const ParamValue &value) +{ + return value.voidConstPointerVal; +} + +template <> +inline const void *const *GetParamVal<ParamType::TvoidConstPointerPointer, const void *const *>( + const ParamValue &value) +{ + return value.voidConstPointerPointerVal; +} + +template <> +inline void *GetParamVal<ParamType::TvoidPointer, void *>(const ParamValue &value) +{ + return value.voidPointerVal; +} + +template <> +inline void **GetParamVal<ParamType::TvoidPointerPointer, void **>(const ParamValue &value) +{ + return value.voidPointerPointerVal; +} + +template <ParamType PType, typename T> +T GetParamVal(const ParamValue &value) +{ + UNREACHABLE(); + return T(); +} + +template <typename T> +T AccessParamValue(ParamType paramType, const ParamValue &value) +{ + switch (paramType) + { + case ParamType::TAHardwareBufferConstPointer: + return GetParamVal<ParamType::TAHardwareBufferConstPointer, T>(value); + case ParamType::TAlphaTestFunc: + return GetParamVal<ParamType::TAlphaTestFunc, T>(value); + case ParamType::TBufferBinding: + return GetParamVal<ParamType::TBufferBinding, T>(value); + case ParamType::TBufferID: + return GetParamVal<ParamType::TBufferID, T>(value); + case ParamType::TBufferIDConstPointer: + return GetParamVal<ParamType::TBufferIDConstPointer, T>(value); + case ParamType::TBufferIDPointer: + return GetParamVal<ParamType::TBufferIDPointer, T>(value); + case ParamType::TBufferUsage: + return GetParamVal<ParamType::TBufferUsage, T>(value); + case ParamType::TClientVertexArrayType: + return GetParamVal<ParamType::TClientVertexArrayType, T>(value); + case ParamType::TCompositorTiming: + return GetParamVal<ParamType::TCompositorTiming, T>(value); + case ParamType::TCullFaceMode: + return GetParamVal<ParamType::TCullFaceMode, T>(value); + case ParamType::TDrawElementsType: + return GetParamVal<ParamType::TDrawElementsType, T>(value); + case ParamType::TEGLAttrib: + return GetParamVal<ParamType::TEGLAttrib, T>(value); + case ParamType::TEGLAttribKHR: + return GetParamVal<ParamType::TEGLAttribKHR, T>(value); + case ParamType::TEGLBoolean: + return GetParamVal<ParamType::TEGLBoolean, T>(value); + case ParamType::TEGLClientBuffer: + return GetParamVal<ParamType::TEGLClientBuffer, T>(value); + case ParamType::TEGLConfig: + return GetParamVal<ParamType::TEGLConfig, T>(value); + case ParamType::TEGLContext: + return GetParamVal<ParamType::TEGLContext, T>(value); + case ParamType::TEGLDEBUGPROCKHR: + return GetParamVal<ParamType::TEGLDEBUGPROCKHR, T>(value); + case ParamType::TEGLDeviceEXT: + return GetParamVal<ParamType::TEGLDeviceEXT, T>(value); + case ParamType::TEGLDisplay: + return GetParamVal<ParamType::TEGLDisplay, T>(value); + case ParamType::TEGLFrameTokenANGLE: + return GetParamVal<ParamType::TEGLFrameTokenANGLE, T>(value); + case ParamType::TEGLGetBlobFuncANDROID: + return GetParamVal<ParamType::TEGLGetBlobFuncANDROID, T>(value); + case ParamType::TEGLImage: + return GetParamVal<ParamType::TEGLImage, T>(value); + case ParamType::TEGLLabelKHR: + return GetParamVal<ParamType::TEGLLabelKHR, T>(value); + case ParamType::TEGLNativeDisplayType: + return GetParamVal<ParamType::TEGLNativeDisplayType, T>(value); + case ParamType::TEGLNativePixmapType: + return GetParamVal<ParamType::TEGLNativePixmapType, T>(value); + case ParamType::TEGLNativeWindowType: + return GetParamVal<ParamType::TEGLNativeWindowType, T>(value); + case ParamType::TEGLObjectKHR: + return GetParamVal<ParamType::TEGLObjectKHR, T>(value); + case ParamType::TEGLSetBlobFuncANDROID: + return GetParamVal<ParamType::TEGLSetBlobFuncANDROID, T>(value); + case ParamType::TEGLStreamKHR: + return GetParamVal<ParamType::TEGLStreamKHR, T>(value); + case ParamType::TEGLSurface: + return GetParamVal<ParamType::TEGLSurface, T>(value); + case ParamType::TEGLSync: + return GetParamVal<ParamType::TEGLSync, T>(value); + case ParamType::TEGLTime: + return GetParamVal<ParamType::TEGLTime, T>(value); + case ParamType::TEGLTimeKHR: + return GetParamVal<ParamType::TEGLTimeKHR, T>(value); + case ParamType::TEGLenum: + return GetParamVal<ParamType::TEGLenum, T>(value); + case ParamType::TEGLint: + return GetParamVal<ParamType::TEGLint, T>(value); + case ParamType::TEGLnsecsANDROID: + return GetParamVal<ParamType::TEGLnsecsANDROID, T>(value); + case ParamType::TEGLuint64KHR: + return GetParamVal<ParamType::TEGLuint64KHR, T>(value); + case ParamType::TFenceNVID: + return GetParamVal<ParamType::TFenceNVID, T>(value); + case ParamType::TFenceNVIDConstPointer: + return GetParamVal<ParamType::TFenceNVIDConstPointer, T>(value); + case ParamType::TFenceNVIDPointer: + return GetParamVal<ParamType::TFenceNVIDPointer, T>(value); + case ParamType::TFramebufferID: + return GetParamVal<ParamType::TFramebufferID, T>(value); + case ParamType::TFramebufferIDConstPointer: + return GetParamVal<ParamType::TFramebufferIDConstPointer, T>(value); + case ParamType::TFramebufferIDPointer: + return GetParamVal<ParamType::TFramebufferIDPointer, T>(value); + case ParamType::TGLDEBUGPROC: + return GetParamVal<ParamType::TGLDEBUGPROC, T>(value); + case ParamType::TGLDEBUGPROCKHR: + return GetParamVal<ParamType::TGLDEBUGPROCKHR, T>(value); + case ParamType::TGLbitfield: + return GetParamVal<ParamType::TGLbitfield, T>(value); + case ParamType::TGLboolean: + return GetParamVal<ParamType::TGLboolean, T>(value); + case ParamType::TGLbooleanConstPointer: + return GetParamVal<ParamType::TGLbooleanConstPointer, T>(value); + case ParamType::TGLbooleanPointer: + return GetParamVal<ParamType::TGLbooleanPointer, T>(value); + case ParamType::TGLbyte: + return GetParamVal<ParamType::TGLbyte, T>(value); + case ParamType::TGLbyteConstPointer: + return GetParamVal<ParamType::TGLbyteConstPointer, T>(value); + case ParamType::TGLcharConstPointer: + return GetParamVal<ParamType::TGLcharConstPointer, T>(value); + case ParamType::TGLcharConstPointerPointer: + return GetParamVal<ParamType::TGLcharConstPointerPointer, T>(value); + case ParamType::TGLcharPointer: + return GetParamVal<ParamType::TGLcharPointer, T>(value); + case ParamType::TGLclampx: + return GetParamVal<ParamType::TGLclampx, T>(value); + case ParamType::TGLdouble: + return GetParamVal<ParamType::TGLdouble, T>(value); + case ParamType::TGLdoubleConstPointer: + return GetParamVal<ParamType::TGLdoubleConstPointer, T>(value); + case ParamType::TGLdoublePointer: + return GetParamVal<ParamType::TGLdoublePointer, T>(value); + case ParamType::TGLeglClientBufferEXT: + return GetParamVal<ParamType::TGLeglClientBufferEXT, T>(value); + case ParamType::TGLeglImageOES: + return GetParamVal<ParamType::TGLeglImageOES, T>(value); + case ParamType::TGLenum: + return GetParamVal<ParamType::TGLenum, T>(value); + case ParamType::TGLenumConstPointer: + return GetParamVal<ParamType::TGLenumConstPointer, T>(value); + case ParamType::TGLenumPointer: + return GetParamVal<ParamType::TGLenumPointer, T>(value); + case ParamType::TGLfixed: + return GetParamVal<ParamType::TGLfixed, T>(value); + case ParamType::TGLfixedConstPointer: + return GetParamVal<ParamType::TGLfixedConstPointer, T>(value); + case ParamType::TGLfixedPointer: + return GetParamVal<ParamType::TGLfixedPointer, T>(value); + case ParamType::TGLfloat: + return GetParamVal<ParamType::TGLfloat, T>(value); + case ParamType::TGLfloatConstPointer: + return GetParamVal<ParamType::TGLfloatConstPointer, T>(value); + case ParamType::TGLfloatPointer: + return GetParamVal<ParamType::TGLfloatPointer, T>(value); + case ParamType::TGLint: + return GetParamVal<ParamType::TGLint, T>(value); + case ParamType::TGLint64Pointer: + return GetParamVal<ParamType::TGLint64Pointer, T>(value); + case ParamType::TGLintConstPointer: + return GetParamVal<ParamType::TGLintConstPointer, T>(value); + case ParamType::TGLintPointer: + return GetParamVal<ParamType::TGLintPointer, T>(value); + case ParamType::TGLintptr: + return GetParamVal<ParamType::TGLintptr, T>(value); + case ParamType::TGLintptrConstPointer: + return GetParamVal<ParamType::TGLintptrConstPointer, T>(value); + case ParamType::TGLshort: + return GetParamVal<ParamType::TGLshort, T>(value); + case ParamType::TGLshortConstPointer: + return GetParamVal<ParamType::TGLshortConstPointer, T>(value); + case ParamType::TGLsizei: + return GetParamVal<ParamType::TGLsizei, T>(value); + case ParamType::TGLsizeiConstPointer: + return GetParamVal<ParamType::TGLsizeiConstPointer, T>(value); + case ParamType::TGLsizeiPointer: + return GetParamVal<ParamType::TGLsizeiPointer, T>(value); + case ParamType::TGLsizeiptr: + return GetParamVal<ParamType::TGLsizeiptr, T>(value); + case ParamType::TGLsizeiptrConstPointer: + return GetParamVal<ParamType::TGLsizeiptrConstPointer, T>(value); + case ParamType::TGLsync: + return GetParamVal<ParamType::TGLsync, T>(value); + case ParamType::TGLubyte: + return GetParamVal<ParamType::TGLubyte, T>(value); + case ParamType::TGLubyteConstPointer: + return GetParamVal<ParamType::TGLubyteConstPointer, T>(value); + case ParamType::TGLubytePointer: + return GetParamVal<ParamType::TGLubytePointer, T>(value); + case ParamType::TGLuint: + return GetParamVal<ParamType::TGLuint, T>(value); + case ParamType::TGLuint64: + return GetParamVal<ParamType::TGLuint64, T>(value); + case ParamType::TGLuint64ConstPointer: + return GetParamVal<ParamType::TGLuint64ConstPointer, T>(value); + case ParamType::TGLuint64Pointer: + return GetParamVal<ParamType::TGLuint64Pointer, T>(value); + case ParamType::TGLuintConstPointer: + return GetParamVal<ParamType::TGLuintConstPointer, T>(value); + case ParamType::TGLuintPointer: + return GetParamVal<ParamType::TGLuintPointer, T>(value); + case ParamType::TGLushort: + return GetParamVal<ParamType::TGLushort, T>(value); + case ParamType::TGLushortConstPointer: + return GetParamVal<ParamType::TGLushortConstPointer, T>(value); + case ParamType::TGLushortPointer: + return GetParamVal<ParamType::TGLushortPointer, T>(value); + case ParamType::TGLvoidConstPointer: + return GetParamVal<ParamType::TGLvoidConstPointer, T>(value); + case ParamType::TGLvoidConstPointerPointer: + return GetParamVal<ParamType::TGLvoidConstPointerPointer, T>(value); + case ParamType::TGraphicsResetStatus: + return GetParamVal<ParamType::TGraphicsResetStatus, T>(value); + case ParamType::THandleType: + return GetParamVal<ParamType::THandleType, T>(value); + case ParamType::TLightParameter: + return GetParamVal<ParamType::TLightParameter, T>(value); + case ParamType::TLogicalOperation: + return GetParamVal<ParamType::TLogicalOperation, T>(value); + case ParamType::TMaterialParameter: + return GetParamVal<ParamType::TMaterialParameter, T>(value); + case ParamType::TMatrixType: + return GetParamVal<ParamType::TMatrixType, T>(value); + case ParamType::TMemoryObjectID: + return GetParamVal<ParamType::TMemoryObjectID, T>(value); + case ParamType::TMemoryObjectIDConstPointer: + return GetParamVal<ParamType::TMemoryObjectIDConstPointer, T>(value); + case ParamType::TMemoryObjectIDPointer: + return GetParamVal<ParamType::TMemoryObjectIDPointer, T>(value); + case ParamType::TObjectType: + return GetParamVal<ParamType::TObjectType, T>(value); + case ParamType::TPointParameter: + return GetParamVal<ParamType::TPointParameter, T>(value); + case ParamType::TPrimitiveMode: + return GetParamVal<ParamType::TPrimitiveMode, T>(value); + case ParamType::TProgramPipelineID: + return GetParamVal<ParamType::TProgramPipelineID, T>(value); + case ParamType::TProgramPipelineIDConstPointer: + return GetParamVal<ParamType::TProgramPipelineIDConstPointer, T>(value); + case ParamType::TProgramPipelineIDPointer: + return GetParamVal<ParamType::TProgramPipelineIDPointer, T>(value); + case ParamType::TProvokingVertexConvention: + return GetParamVal<ParamType::TProvokingVertexConvention, T>(value); + case ParamType::TQueryID: + return GetParamVal<ParamType::TQueryID, T>(value); + case ParamType::TQueryIDConstPointer: + return GetParamVal<ParamType::TQueryIDConstPointer, T>(value); + case ParamType::TQueryIDPointer: + return GetParamVal<ParamType::TQueryIDPointer, T>(value); + case ParamType::TQueryType: + return GetParamVal<ParamType::TQueryType, T>(value); + case ParamType::TRenderbufferID: + return GetParamVal<ParamType::TRenderbufferID, T>(value); + case ParamType::TRenderbufferIDConstPointer: + return GetParamVal<ParamType::TRenderbufferIDConstPointer, T>(value); + case ParamType::TRenderbufferIDPointer: + return GetParamVal<ParamType::TRenderbufferIDPointer, T>(value); + case ParamType::TSamplerID: + return GetParamVal<ParamType::TSamplerID, T>(value); + case ParamType::TSamplerIDConstPointer: + return GetParamVal<ParamType::TSamplerIDConstPointer, T>(value); + case ParamType::TSamplerIDPointer: + return GetParamVal<ParamType::TSamplerIDPointer, T>(value); + case ParamType::TSemaphoreID: + return GetParamVal<ParamType::TSemaphoreID, T>(value); + case ParamType::TSemaphoreIDConstPointer: + return GetParamVal<ParamType::TSemaphoreIDConstPointer, T>(value); + case ParamType::TSemaphoreIDPointer: + return GetParamVal<ParamType::TSemaphoreIDPointer, T>(value); + case ParamType::TShaderProgramID: + return GetParamVal<ParamType::TShaderProgramID, T>(value); + case ParamType::TShaderProgramIDConstPointer: + return GetParamVal<ParamType::TShaderProgramIDConstPointer, T>(value); + case ParamType::TShaderProgramIDPointer: + return GetParamVal<ParamType::TShaderProgramIDPointer, T>(value); + case ParamType::TShaderType: + return GetParamVal<ParamType::TShaderType, T>(value); + case ParamType::TShadingModel: + return GetParamVal<ParamType::TShadingModel, T>(value); + case ParamType::TTextureEnvParameter: + return GetParamVal<ParamType::TTextureEnvParameter, T>(value); + case ParamType::TTextureEnvTarget: + return GetParamVal<ParamType::TTextureEnvTarget, T>(value); + case ParamType::TTextureID: + return GetParamVal<ParamType::TTextureID, T>(value); + case ParamType::TTextureIDConstPointer: + return GetParamVal<ParamType::TTextureIDConstPointer, T>(value); + case ParamType::TTextureIDPointer: + return GetParamVal<ParamType::TTextureIDPointer, T>(value); + case ParamType::TTextureTarget: + return GetParamVal<ParamType::TTextureTarget, T>(value); + case ParamType::TTextureType: + return GetParamVal<ParamType::TTextureType, T>(value); + case ParamType::TTimestamp: + return GetParamVal<ParamType::TTimestamp, T>(value); + case ParamType::TTransformFeedbackID: + return GetParamVal<ParamType::TTransformFeedbackID, T>(value); + case ParamType::TTransformFeedbackIDConstPointer: + return GetParamVal<ParamType::TTransformFeedbackIDConstPointer, T>(value); + case ParamType::TTransformFeedbackIDPointer: + return GetParamVal<ParamType::TTransformFeedbackIDPointer, T>(value); + case ParamType::TUniformBlockIndex: + return GetParamVal<ParamType::TUniformBlockIndex, T>(value); + case ParamType::TUniformLocation: + return GetParamVal<ParamType::TUniformLocation, T>(value); + case ParamType::TVertexArrayID: + return GetParamVal<ParamType::TVertexArrayID, T>(value); + case ParamType::TVertexArrayIDConstPointer: + return GetParamVal<ParamType::TVertexArrayIDConstPointer, T>(value); + case ParamType::TVertexArrayIDPointer: + return GetParamVal<ParamType::TVertexArrayIDPointer, T>(value); + case ParamType::TVertexAttribType: + return GetParamVal<ParamType::TVertexAttribType, T>(value); + case ParamType::TcharConstPointer: + return GetParamVal<ParamType::TcharConstPointer, T>(value); + case ParamType::TvoidConstPointer: + return GetParamVal<ParamType::TvoidConstPointer, T>(value); + case ParamType::TvoidConstPointerPointer: + return GetParamVal<ParamType::TvoidConstPointerPointer, T>(value); + case ParamType::TvoidPointer: + return GetParamVal<ParamType::TvoidPointer, T>(value); + case ParamType::TvoidPointerPointer: + return GetParamVal<ParamType::TvoidPointerPointer, T>(value); + } + UNREACHABLE(); + return T(); +} + +template <ParamType PType, typename T> +void SetParamVal(T valueIn, ParamValue *valueOut); + +template <> +inline void SetParamVal<ParamType::TAHardwareBufferConstPointer>(const AHardwareBuffer *valueIn, + ParamValue *valueOut) +{ + valueOut->AHardwareBufferConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TAlphaTestFunc>(gl::AlphaTestFunc valueIn, ParamValue *valueOut) +{ + valueOut->AlphaTestFuncVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TBufferBinding>(gl::BufferBinding valueIn, ParamValue *valueOut) +{ + valueOut->BufferBindingVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TBufferID>(gl::BufferID valueIn, ParamValue *valueOut) +{ + valueOut->BufferIDVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TBufferIDConstPointer>(const gl::BufferID *valueIn, + ParamValue *valueOut) +{ + valueOut->BufferIDConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TBufferIDPointer>(gl::BufferID *valueIn, ParamValue *valueOut) +{ + valueOut->BufferIDPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TBufferUsage>(gl::BufferUsage valueIn, ParamValue *valueOut) +{ + valueOut->BufferUsageVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TClientVertexArrayType>(gl::ClientVertexArrayType valueIn, + ParamValue *valueOut) +{ + valueOut->ClientVertexArrayTypeVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TCompositorTiming>(egl::CompositorTiming valueIn, + ParamValue *valueOut) +{ + valueOut->CompositorTimingVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TCullFaceMode>(gl::CullFaceMode valueIn, ParamValue *valueOut) +{ + valueOut->CullFaceModeVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TDrawElementsType>(gl::DrawElementsType valueIn, + ParamValue *valueOut) +{ + valueOut->DrawElementsTypeVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLAttrib>(EGLAttrib valueIn, ParamValue *valueOut) +{ + valueOut->EGLAttribVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLAttribKHR>(EGLAttribKHR valueIn, ParamValue *valueOut) +{ + valueOut->EGLAttribKHRVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLBoolean>(EGLBoolean valueIn, ParamValue *valueOut) +{ + valueOut->EGLBooleanVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLClientBuffer>(EGLClientBuffer valueIn, ParamValue *valueOut) +{ + valueOut->EGLClientBufferVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLConfig>(EGLConfig valueIn, ParamValue *valueOut) +{ + valueOut->EGLConfigVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLContext>(EGLContext valueIn, ParamValue *valueOut) +{ + valueOut->EGLContextVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLDEBUGPROCKHR>(EGLDEBUGPROCKHR valueIn, ParamValue *valueOut) +{ + valueOut->EGLDEBUGPROCKHRVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLDeviceEXT>(EGLDeviceEXT valueIn, ParamValue *valueOut) +{ + valueOut->EGLDeviceEXTVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLDisplay>(EGLDisplay valueIn, ParamValue *valueOut) +{ + valueOut->EGLDisplayVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLFrameTokenANGLE>(EGLFrameTokenANGLE valueIn, + ParamValue *valueOut) +{ + valueOut->EGLFrameTokenANGLEVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLGetBlobFuncANDROID>(EGLGetBlobFuncANDROID valueIn, + ParamValue *valueOut) +{ + valueOut->EGLGetBlobFuncANDROIDVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLImage>(EGLImage valueIn, ParamValue *valueOut) +{ + valueOut->EGLImageVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLLabelKHR>(EGLLabelKHR valueIn, ParamValue *valueOut) +{ + valueOut->EGLLabelKHRVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLNativeDisplayType>(EGLNativeDisplayType valueIn, + ParamValue *valueOut) +{ + valueOut->EGLNativeDisplayTypeVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLNativePixmapType>(EGLNativePixmapType valueIn, + ParamValue *valueOut) +{ + valueOut->EGLNativePixmapTypeVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLNativeWindowType>(EGLNativeWindowType valueIn, + ParamValue *valueOut) +{ + valueOut->EGLNativeWindowTypeVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLObjectKHR>(EGLObjectKHR valueIn, ParamValue *valueOut) +{ + valueOut->EGLObjectKHRVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLSetBlobFuncANDROID>(EGLSetBlobFuncANDROID valueIn, + ParamValue *valueOut) +{ + valueOut->EGLSetBlobFuncANDROIDVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLStreamKHR>(EGLStreamKHR valueIn, ParamValue *valueOut) +{ + valueOut->EGLStreamKHRVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLSurface>(EGLSurface valueIn, ParamValue *valueOut) +{ + valueOut->EGLSurfaceVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLSync>(EGLSync valueIn, ParamValue *valueOut) +{ + valueOut->EGLSyncVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLTime>(EGLTime valueIn, ParamValue *valueOut) +{ + valueOut->EGLTimeVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLTimeKHR>(EGLTimeKHR valueIn, ParamValue *valueOut) +{ + valueOut->EGLTimeKHRVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLenum>(EGLenum valueIn, ParamValue *valueOut) +{ + valueOut->EGLenumVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLint>(EGLint valueIn, ParamValue *valueOut) +{ + valueOut->EGLintVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLnsecsANDROID>(EGLnsecsANDROID valueIn, ParamValue *valueOut) +{ + valueOut->EGLnsecsANDROIDVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TEGLuint64KHR>(EGLuint64KHR valueIn, ParamValue *valueOut) +{ + valueOut->EGLuint64KHRVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TFenceNVID>(gl::FenceNVID valueIn, ParamValue *valueOut) +{ + valueOut->FenceNVIDVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TFenceNVIDConstPointer>(const gl::FenceNVID *valueIn, + ParamValue *valueOut) +{ + valueOut->FenceNVIDConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TFenceNVIDPointer>(gl::FenceNVID *valueIn, ParamValue *valueOut) +{ + valueOut->FenceNVIDPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TFramebufferID>(gl::FramebufferID valueIn, ParamValue *valueOut) +{ + valueOut->FramebufferIDVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TFramebufferIDConstPointer>(const gl::FramebufferID *valueIn, + ParamValue *valueOut) +{ + valueOut->FramebufferIDConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TFramebufferIDPointer>(gl::FramebufferID *valueIn, + ParamValue *valueOut) +{ + valueOut->FramebufferIDPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLDEBUGPROC>(GLDEBUGPROC valueIn, ParamValue *valueOut) +{ + valueOut->GLDEBUGPROCVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLDEBUGPROCKHR>(GLDEBUGPROCKHR valueIn, ParamValue *valueOut) +{ + valueOut->GLDEBUGPROCKHRVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLbitfield>(GLbitfield valueIn, ParamValue *valueOut) +{ + valueOut->GLbitfieldVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLboolean>(GLboolean valueIn, ParamValue *valueOut) +{ + valueOut->GLbooleanVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLbooleanConstPointer>(const GLboolean *valueIn, + ParamValue *valueOut) +{ + valueOut->GLbooleanConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLbooleanPointer>(GLboolean *valueIn, ParamValue *valueOut) +{ + valueOut->GLbooleanPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLbyte>(GLbyte valueIn, ParamValue *valueOut) +{ + valueOut->GLbyteVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLbyteConstPointer>(const GLbyte *valueIn, ParamValue *valueOut) +{ + valueOut->GLbyteConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLcharConstPointer>(const GLchar *valueIn, ParamValue *valueOut) +{ + valueOut->GLcharConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLcharConstPointerPointer>(const GLchar *const *valueIn, + ParamValue *valueOut) +{ + valueOut->GLcharConstPointerPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLcharPointer>(GLchar *valueIn, ParamValue *valueOut) +{ + valueOut->GLcharPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLclampx>(GLclampx valueIn, ParamValue *valueOut) +{ + valueOut->GLclampxVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLdouble>(GLdouble valueIn, ParamValue *valueOut) +{ + valueOut->GLdoubleVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLdoubleConstPointer>(const GLdouble *valueIn, + ParamValue *valueOut) +{ + valueOut->GLdoubleConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLdoublePointer>(GLdouble *valueIn, ParamValue *valueOut) +{ + valueOut->GLdoublePointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLeglClientBufferEXT>(GLeglClientBufferEXT valueIn, + ParamValue *valueOut) +{ + valueOut->GLeglClientBufferEXTVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLeglImageOES>(GLeglImageOES valueIn, ParamValue *valueOut) +{ + valueOut->GLeglImageOESVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLenum>(GLenum valueIn, ParamValue *valueOut) +{ + valueOut->GLenumVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLenumConstPointer>(const GLenum *valueIn, ParamValue *valueOut) +{ + valueOut->GLenumConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLenumPointer>(GLenum *valueIn, ParamValue *valueOut) +{ + valueOut->GLenumPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLfixed>(GLfixed valueIn, ParamValue *valueOut) +{ + valueOut->GLfixedVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLfixedConstPointer>(const GLfixed *valueIn, + ParamValue *valueOut) +{ + valueOut->GLfixedConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLfixedPointer>(GLfixed *valueIn, ParamValue *valueOut) +{ + valueOut->GLfixedPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLfloat>(GLfloat valueIn, ParamValue *valueOut) +{ + valueOut->GLfloatVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLfloatConstPointer>(const GLfloat *valueIn, + ParamValue *valueOut) +{ + valueOut->GLfloatConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLfloatPointer>(GLfloat *valueIn, ParamValue *valueOut) +{ + valueOut->GLfloatPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLint>(GLint valueIn, ParamValue *valueOut) +{ + valueOut->GLintVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLint64Pointer>(GLint64 *valueIn, ParamValue *valueOut) +{ + valueOut->GLint64PointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLintConstPointer>(const GLint *valueIn, ParamValue *valueOut) +{ + valueOut->GLintConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLintPointer>(GLint *valueIn, ParamValue *valueOut) +{ + valueOut->GLintPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLintptr>(GLintptr valueIn, ParamValue *valueOut) +{ + valueOut->GLintptrVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLintptrConstPointer>(const GLintptr *valueIn, + ParamValue *valueOut) +{ + valueOut->GLintptrConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLshort>(GLshort valueIn, ParamValue *valueOut) +{ + valueOut->GLshortVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLshortConstPointer>(const GLshort *valueIn, + ParamValue *valueOut) +{ + valueOut->GLshortConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLsizei>(GLsizei valueIn, ParamValue *valueOut) +{ + valueOut->GLsizeiVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLsizeiConstPointer>(const GLsizei *valueIn, + ParamValue *valueOut) +{ + valueOut->GLsizeiConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLsizeiPointer>(GLsizei *valueIn, ParamValue *valueOut) +{ + valueOut->GLsizeiPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLsizeiptr>(GLsizeiptr valueIn, ParamValue *valueOut) +{ + valueOut->GLsizeiptrVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLsizeiptrConstPointer>(const GLsizeiptr *valueIn, + ParamValue *valueOut) +{ + valueOut->GLsizeiptrConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLsync>(GLsync valueIn, ParamValue *valueOut) +{ + valueOut->GLsyncVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLubyte>(GLubyte valueIn, ParamValue *valueOut) +{ + valueOut->GLubyteVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLubyteConstPointer>(const GLubyte *valueIn, + ParamValue *valueOut) +{ + valueOut->GLubyteConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLubytePointer>(GLubyte *valueIn, ParamValue *valueOut) +{ + valueOut->GLubytePointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLuint>(GLuint valueIn, ParamValue *valueOut) +{ + valueOut->GLuintVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLuint64>(GLuint64 valueIn, ParamValue *valueOut) +{ + valueOut->GLuint64Val = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLuint64ConstPointer>(const GLuint64 *valueIn, + ParamValue *valueOut) +{ + valueOut->GLuint64ConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLuint64Pointer>(GLuint64 *valueIn, ParamValue *valueOut) +{ + valueOut->GLuint64PointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLuintConstPointer>(const GLuint *valueIn, ParamValue *valueOut) +{ + valueOut->GLuintConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLuintPointer>(GLuint *valueIn, ParamValue *valueOut) +{ + valueOut->GLuintPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLushort>(GLushort valueIn, ParamValue *valueOut) +{ + valueOut->GLushortVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLushortConstPointer>(const GLushort *valueIn, + ParamValue *valueOut) +{ + valueOut->GLushortConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLushortPointer>(GLushort *valueIn, ParamValue *valueOut) +{ + valueOut->GLushortPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLvoidConstPointer>(const GLvoid *valueIn, ParamValue *valueOut) +{ + valueOut->GLvoidConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGLvoidConstPointerPointer>(const GLvoid *const *valueIn, + ParamValue *valueOut) +{ + valueOut->GLvoidConstPointerPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TGraphicsResetStatus>(gl::GraphicsResetStatus valueIn, + ParamValue *valueOut) +{ + valueOut->GraphicsResetStatusVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::THandleType>(gl::HandleType valueIn, ParamValue *valueOut) +{ + valueOut->HandleTypeVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TLightParameter>(gl::LightParameter valueIn, + ParamValue *valueOut) +{ + valueOut->LightParameterVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TLogicalOperation>(gl::LogicalOperation valueIn, + ParamValue *valueOut) +{ + valueOut->LogicalOperationVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TMaterialParameter>(gl::MaterialParameter valueIn, + ParamValue *valueOut) +{ + valueOut->MaterialParameterVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TMatrixType>(gl::MatrixType valueIn, ParamValue *valueOut) +{ + valueOut->MatrixTypeVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TMemoryObjectID>(gl::MemoryObjectID valueIn, + ParamValue *valueOut) +{ + valueOut->MemoryObjectIDVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TMemoryObjectIDConstPointer>(const gl::MemoryObjectID *valueIn, + ParamValue *valueOut) +{ + valueOut->MemoryObjectIDConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TMemoryObjectIDPointer>(gl::MemoryObjectID *valueIn, + ParamValue *valueOut) +{ + valueOut->MemoryObjectIDPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TObjectType>(egl::ObjectType valueIn, ParamValue *valueOut) +{ + valueOut->ObjectTypeVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TPointParameter>(gl::PointParameter valueIn, + ParamValue *valueOut) +{ + valueOut->PointParameterVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TPrimitiveMode>(gl::PrimitiveMode valueIn, ParamValue *valueOut) +{ + valueOut->PrimitiveModeVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TProgramPipelineID>(gl::ProgramPipelineID valueIn, + ParamValue *valueOut) +{ + valueOut->ProgramPipelineIDVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TProgramPipelineIDConstPointer>( + const gl::ProgramPipelineID *valueIn, + ParamValue *valueOut) +{ + valueOut->ProgramPipelineIDConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TProgramPipelineIDPointer>(gl::ProgramPipelineID *valueIn, + ParamValue *valueOut) +{ + valueOut->ProgramPipelineIDPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TProvokingVertexConvention>( + gl::ProvokingVertexConvention valueIn, + ParamValue *valueOut) +{ + valueOut->ProvokingVertexConventionVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TQueryID>(gl::QueryID valueIn, ParamValue *valueOut) +{ + valueOut->QueryIDVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TQueryIDConstPointer>(const gl::QueryID *valueIn, + ParamValue *valueOut) +{ + valueOut->QueryIDConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TQueryIDPointer>(gl::QueryID *valueIn, ParamValue *valueOut) +{ + valueOut->QueryIDPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TQueryType>(gl::QueryType valueIn, ParamValue *valueOut) +{ + valueOut->QueryTypeVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TRenderbufferID>(gl::RenderbufferID valueIn, + ParamValue *valueOut) +{ + valueOut->RenderbufferIDVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TRenderbufferIDConstPointer>(const gl::RenderbufferID *valueIn, + ParamValue *valueOut) +{ + valueOut->RenderbufferIDConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TRenderbufferIDPointer>(gl::RenderbufferID *valueIn, + ParamValue *valueOut) +{ + valueOut->RenderbufferIDPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TSamplerID>(gl::SamplerID valueIn, ParamValue *valueOut) +{ + valueOut->SamplerIDVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TSamplerIDConstPointer>(const gl::SamplerID *valueIn, + ParamValue *valueOut) +{ + valueOut->SamplerIDConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TSamplerIDPointer>(gl::SamplerID *valueIn, ParamValue *valueOut) +{ + valueOut->SamplerIDPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TSemaphoreID>(gl::SemaphoreID valueIn, ParamValue *valueOut) +{ + valueOut->SemaphoreIDVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TSemaphoreIDConstPointer>(const gl::SemaphoreID *valueIn, + ParamValue *valueOut) +{ + valueOut->SemaphoreIDConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TSemaphoreIDPointer>(gl::SemaphoreID *valueIn, + ParamValue *valueOut) +{ + valueOut->SemaphoreIDPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TShaderProgramID>(gl::ShaderProgramID valueIn, + ParamValue *valueOut) +{ + valueOut->ShaderProgramIDVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TShaderProgramIDConstPointer>(const gl::ShaderProgramID *valueIn, + ParamValue *valueOut) +{ + valueOut->ShaderProgramIDConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TShaderProgramIDPointer>(gl::ShaderProgramID *valueIn, + ParamValue *valueOut) +{ + valueOut->ShaderProgramIDPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TShaderType>(gl::ShaderType valueIn, ParamValue *valueOut) +{ + valueOut->ShaderTypeVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TShadingModel>(gl::ShadingModel valueIn, ParamValue *valueOut) +{ + valueOut->ShadingModelVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TTextureEnvParameter>(gl::TextureEnvParameter valueIn, + ParamValue *valueOut) +{ + valueOut->TextureEnvParameterVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TTextureEnvTarget>(gl::TextureEnvTarget valueIn, + ParamValue *valueOut) +{ + valueOut->TextureEnvTargetVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TTextureID>(gl::TextureID valueIn, ParamValue *valueOut) +{ + valueOut->TextureIDVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TTextureIDConstPointer>(const gl::TextureID *valueIn, + ParamValue *valueOut) +{ + valueOut->TextureIDConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TTextureIDPointer>(gl::TextureID *valueIn, ParamValue *valueOut) +{ + valueOut->TextureIDPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TTextureTarget>(gl::TextureTarget valueIn, ParamValue *valueOut) +{ + valueOut->TextureTargetVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TTextureType>(gl::TextureType valueIn, ParamValue *valueOut) +{ + valueOut->TextureTypeVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TTimestamp>(egl::Timestamp valueIn, ParamValue *valueOut) +{ + valueOut->TimestampVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TTransformFeedbackID>(gl::TransformFeedbackID valueIn, + ParamValue *valueOut) +{ + valueOut->TransformFeedbackIDVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TTransformFeedbackIDConstPointer>( + const gl::TransformFeedbackID *valueIn, + ParamValue *valueOut) +{ + valueOut->TransformFeedbackIDConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TTransformFeedbackIDPointer>(gl::TransformFeedbackID *valueIn, + ParamValue *valueOut) +{ + valueOut->TransformFeedbackIDPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TUniformBlockIndex>(gl::UniformBlockIndex valueIn, + ParamValue *valueOut) +{ + valueOut->UniformBlockIndexVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TUniformLocation>(gl::UniformLocation valueIn, + ParamValue *valueOut) +{ + valueOut->UniformLocationVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TVertexArrayID>(gl::VertexArrayID valueIn, ParamValue *valueOut) +{ + valueOut->VertexArrayIDVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TVertexArrayIDConstPointer>(const gl::VertexArrayID *valueIn, + ParamValue *valueOut) +{ + valueOut->VertexArrayIDConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TVertexArrayIDPointer>(gl::VertexArrayID *valueIn, + ParamValue *valueOut) +{ + valueOut->VertexArrayIDPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TVertexAttribType>(gl::VertexAttribType valueIn, + ParamValue *valueOut) +{ + valueOut->VertexAttribTypeVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TcharConstPointer>(const char *valueIn, ParamValue *valueOut) +{ + valueOut->charConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TvoidConstPointer>(const void *valueIn, ParamValue *valueOut) +{ + valueOut->voidConstPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TvoidConstPointerPointer>(const void *const *valueIn, + ParamValue *valueOut) +{ + valueOut->voidConstPointerPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TvoidPointer>(void *valueIn, ParamValue *valueOut) +{ + valueOut->voidPointerVal = valueIn; +} + +template <> +inline void SetParamVal<ParamType::TvoidPointerPointer>(void **valueIn, ParamValue *valueOut) +{ + valueOut->voidPointerPointerVal = valueIn; +} + +template <ParamType PType, typename T> +void SetParamVal(T valueIn, ParamValue *valueOut) +{ + UNREACHABLE(); +} + +template <typename T> +void InitParamValue(ParamType paramType, T valueIn, ParamValue *valueOut) +{ + switch (paramType) + { + case ParamType::TAHardwareBufferConstPointer: + SetParamVal<ParamType::TAHardwareBufferConstPointer>(valueIn, valueOut); + break; + case ParamType::TAlphaTestFunc: + SetParamVal<ParamType::TAlphaTestFunc>(valueIn, valueOut); + break; + case ParamType::TBufferBinding: + SetParamVal<ParamType::TBufferBinding>(valueIn, valueOut); + break; + case ParamType::TBufferID: + SetParamVal<ParamType::TBufferID>(valueIn, valueOut); + break; + case ParamType::TBufferIDConstPointer: + SetParamVal<ParamType::TBufferIDConstPointer>(valueIn, valueOut); + break; + case ParamType::TBufferIDPointer: + SetParamVal<ParamType::TBufferIDPointer>(valueIn, valueOut); + break; + case ParamType::TBufferUsage: + SetParamVal<ParamType::TBufferUsage>(valueIn, valueOut); + break; + case ParamType::TClientVertexArrayType: + SetParamVal<ParamType::TClientVertexArrayType>(valueIn, valueOut); + break; + case ParamType::TCompositorTiming: + SetParamVal<ParamType::TCompositorTiming>(valueIn, valueOut); + break; + case ParamType::TCullFaceMode: + SetParamVal<ParamType::TCullFaceMode>(valueIn, valueOut); + break; + case ParamType::TDrawElementsType: + SetParamVal<ParamType::TDrawElementsType>(valueIn, valueOut); + break; + case ParamType::TEGLAttrib: + SetParamVal<ParamType::TEGLAttrib>(valueIn, valueOut); + break; + case ParamType::TEGLAttribKHR: + SetParamVal<ParamType::TEGLAttribKHR>(valueIn, valueOut); + break; + case ParamType::TEGLBoolean: + SetParamVal<ParamType::TEGLBoolean>(valueIn, valueOut); + break; + case ParamType::TEGLClientBuffer: + SetParamVal<ParamType::TEGLClientBuffer>(valueIn, valueOut); + break; + case ParamType::TEGLConfig: + SetParamVal<ParamType::TEGLConfig>(valueIn, valueOut); + break; + case ParamType::TEGLContext: + SetParamVal<ParamType::TEGLContext>(valueIn, valueOut); + break; + case ParamType::TEGLDEBUGPROCKHR: + SetParamVal<ParamType::TEGLDEBUGPROCKHR>(valueIn, valueOut); + break; + case ParamType::TEGLDeviceEXT: + SetParamVal<ParamType::TEGLDeviceEXT>(valueIn, valueOut); + break; + case ParamType::TEGLDisplay: + SetParamVal<ParamType::TEGLDisplay>(valueIn, valueOut); + break; + case ParamType::TEGLFrameTokenANGLE: + SetParamVal<ParamType::TEGLFrameTokenANGLE>(valueIn, valueOut); + break; + case ParamType::TEGLGetBlobFuncANDROID: + SetParamVal<ParamType::TEGLGetBlobFuncANDROID>(valueIn, valueOut); + break; + case ParamType::TEGLImage: + SetParamVal<ParamType::TEGLImage>(valueIn, valueOut); + break; + case ParamType::TEGLLabelKHR: + SetParamVal<ParamType::TEGLLabelKHR>(valueIn, valueOut); + break; + case ParamType::TEGLNativeDisplayType: + SetParamVal<ParamType::TEGLNativeDisplayType>(valueIn, valueOut); + break; + case ParamType::TEGLNativePixmapType: + SetParamVal<ParamType::TEGLNativePixmapType>(valueIn, valueOut); + break; + case ParamType::TEGLNativeWindowType: + SetParamVal<ParamType::TEGLNativeWindowType>(valueIn, valueOut); + break; + case ParamType::TEGLObjectKHR: + SetParamVal<ParamType::TEGLObjectKHR>(valueIn, valueOut); + break; + case ParamType::TEGLSetBlobFuncANDROID: + SetParamVal<ParamType::TEGLSetBlobFuncANDROID>(valueIn, valueOut); + break; + case ParamType::TEGLStreamKHR: + SetParamVal<ParamType::TEGLStreamKHR>(valueIn, valueOut); + break; + case ParamType::TEGLSurface: + SetParamVal<ParamType::TEGLSurface>(valueIn, valueOut); + break; + case ParamType::TEGLSync: + SetParamVal<ParamType::TEGLSync>(valueIn, valueOut); + break; + case ParamType::TEGLTime: + SetParamVal<ParamType::TEGLTime>(valueIn, valueOut); + break; + case ParamType::TEGLTimeKHR: + SetParamVal<ParamType::TEGLTimeKHR>(valueIn, valueOut); + break; + case ParamType::TEGLenum: + SetParamVal<ParamType::TEGLenum>(valueIn, valueOut); + break; + case ParamType::TEGLint: + SetParamVal<ParamType::TEGLint>(valueIn, valueOut); + break; + case ParamType::TEGLnsecsANDROID: + SetParamVal<ParamType::TEGLnsecsANDROID>(valueIn, valueOut); + break; + case ParamType::TEGLuint64KHR: + SetParamVal<ParamType::TEGLuint64KHR>(valueIn, valueOut); + break; + case ParamType::TFenceNVID: + SetParamVal<ParamType::TFenceNVID>(valueIn, valueOut); + break; + case ParamType::TFenceNVIDConstPointer: + SetParamVal<ParamType::TFenceNVIDConstPointer>(valueIn, valueOut); + break; + case ParamType::TFenceNVIDPointer: + SetParamVal<ParamType::TFenceNVIDPointer>(valueIn, valueOut); + break; + case ParamType::TFramebufferID: + SetParamVal<ParamType::TFramebufferID>(valueIn, valueOut); + break; + case ParamType::TFramebufferIDConstPointer: + SetParamVal<ParamType::TFramebufferIDConstPointer>(valueIn, valueOut); + break; + case ParamType::TFramebufferIDPointer: + SetParamVal<ParamType::TFramebufferIDPointer>(valueIn, valueOut); + break; + case ParamType::TGLDEBUGPROC: + SetParamVal<ParamType::TGLDEBUGPROC>(valueIn, valueOut); + break; + case ParamType::TGLDEBUGPROCKHR: + SetParamVal<ParamType::TGLDEBUGPROCKHR>(valueIn, valueOut); + break; + case ParamType::TGLbitfield: + SetParamVal<ParamType::TGLbitfield>(valueIn, valueOut); + break; + case ParamType::TGLboolean: + SetParamVal<ParamType::TGLboolean>(valueIn, valueOut); + break; + case ParamType::TGLbooleanConstPointer: + SetParamVal<ParamType::TGLbooleanConstPointer>(valueIn, valueOut); + break; + case ParamType::TGLbooleanPointer: + SetParamVal<ParamType::TGLbooleanPointer>(valueIn, valueOut); + break; + case ParamType::TGLbyte: + SetParamVal<ParamType::TGLbyte>(valueIn, valueOut); + break; + case ParamType::TGLbyteConstPointer: + SetParamVal<ParamType::TGLbyteConstPointer>(valueIn, valueOut); + break; + case ParamType::TGLcharConstPointer: + SetParamVal<ParamType::TGLcharConstPointer>(valueIn, valueOut); + break; + case ParamType::TGLcharConstPointerPointer: + SetParamVal<ParamType::TGLcharConstPointerPointer>(valueIn, valueOut); + break; + case ParamType::TGLcharPointer: + SetParamVal<ParamType::TGLcharPointer>(valueIn, valueOut); + break; + case ParamType::TGLclampx: + SetParamVal<ParamType::TGLclampx>(valueIn, valueOut); + break; + case ParamType::TGLdouble: + SetParamVal<ParamType::TGLdouble>(valueIn, valueOut); + break; + case ParamType::TGLdoubleConstPointer: + SetParamVal<ParamType::TGLdoubleConstPointer>(valueIn, valueOut); + break; + case ParamType::TGLdoublePointer: + SetParamVal<ParamType::TGLdoublePointer>(valueIn, valueOut); + break; + case ParamType::TGLeglClientBufferEXT: + SetParamVal<ParamType::TGLeglClientBufferEXT>(valueIn, valueOut); + break; + case ParamType::TGLeglImageOES: + SetParamVal<ParamType::TGLeglImageOES>(valueIn, valueOut); + break; + case ParamType::TGLenum: + SetParamVal<ParamType::TGLenum>(valueIn, valueOut); + break; + case ParamType::TGLenumConstPointer: + SetParamVal<ParamType::TGLenumConstPointer>(valueIn, valueOut); + break; + case ParamType::TGLenumPointer: + SetParamVal<ParamType::TGLenumPointer>(valueIn, valueOut); + break; + case ParamType::TGLfixed: + SetParamVal<ParamType::TGLfixed>(valueIn, valueOut); + break; + case ParamType::TGLfixedConstPointer: + SetParamVal<ParamType::TGLfixedConstPointer>(valueIn, valueOut); + break; + case ParamType::TGLfixedPointer: + SetParamVal<ParamType::TGLfixedPointer>(valueIn, valueOut); + break; + case ParamType::TGLfloat: + SetParamVal<ParamType::TGLfloat>(valueIn, valueOut); + break; + case ParamType::TGLfloatConstPointer: + SetParamVal<ParamType::TGLfloatConstPointer>(valueIn, valueOut); + break; + case ParamType::TGLfloatPointer: + SetParamVal<ParamType::TGLfloatPointer>(valueIn, valueOut); + break; + case ParamType::TGLint: + SetParamVal<ParamType::TGLint>(valueIn, valueOut); + break; + case ParamType::TGLint64Pointer: + SetParamVal<ParamType::TGLint64Pointer>(valueIn, valueOut); + break; + case ParamType::TGLintConstPointer: + SetParamVal<ParamType::TGLintConstPointer>(valueIn, valueOut); + break; + case ParamType::TGLintPointer: + SetParamVal<ParamType::TGLintPointer>(valueIn, valueOut); + break; + case ParamType::TGLintptr: + SetParamVal<ParamType::TGLintptr>(valueIn, valueOut); + break; + case ParamType::TGLintptrConstPointer: + SetParamVal<ParamType::TGLintptrConstPointer>(valueIn, valueOut); + break; + case ParamType::TGLshort: + SetParamVal<ParamType::TGLshort>(valueIn, valueOut); + break; + case ParamType::TGLshortConstPointer: + SetParamVal<ParamType::TGLshortConstPointer>(valueIn, valueOut); + break; + case ParamType::TGLsizei: + SetParamVal<ParamType::TGLsizei>(valueIn, valueOut); + break; + case ParamType::TGLsizeiConstPointer: + SetParamVal<ParamType::TGLsizeiConstPointer>(valueIn, valueOut); + break; + case ParamType::TGLsizeiPointer: + SetParamVal<ParamType::TGLsizeiPointer>(valueIn, valueOut); + break; + case ParamType::TGLsizeiptr: + SetParamVal<ParamType::TGLsizeiptr>(valueIn, valueOut); + break; + case ParamType::TGLsizeiptrConstPointer: + SetParamVal<ParamType::TGLsizeiptrConstPointer>(valueIn, valueOut); + break; + case ParamType::TGLsync: + SetParamVal<ParamType::TGLsync>(valueIn, valueOut); + break; + case ParamType::TGLubyte: + SetParamVal<ParamType::TGLubyte>(valueIn, valueOut); + break; + case ParamType::TGLubyteConstPointer: + SetParamVal<ParamType::TGLubyteConstPointer>(valueIn, valueOut); + break; + case ParamType::TGLubytePointer: + SetParamVal<ParamType::TGLubytePointer>(valueIn, valueOut); + break; + case ParamType::TGLuint: + SetParamVal<ParamType::TGLuint>(valueIn, valueOut); + break; + case ParamType::TGLuint64: + SetParamVal<ParamType::TGLuint64>(valueIn, valueOut); + break; + case ParamType::TGLuint64ConstPointer: + SetParamVal<ParamType::TGLuint64ConstPointer>(valueIn, valueOut); + break; + case ParamType::TGLuint64Pointer: + SetParamVal<ParamType::TGLuint64Pointer>(valueIn, valueOut); + break; + case ParamType::TGLuintConstPointer: + SetParamVal<ParamType::TGLuintConstPointer>(valueIn, valueOut); + break; + case ParamType::TGLuintPointer: + SetParamVal<ParamType::TGLuintPointer>(valueIn, valueOut); + break; + case ParamType::TGLushort: + SetParamVal<ParamType::TGLushort>(valueIn, valueOut); + break; + case ParamType::TGLushortConstPointer: + SetParamVal<ParamType::TGLushortConstPointer>(valueIn, valueOut); + break; + case ParamType::TGLushortPointer: + SetParamVal<ParamType::TGLushortPointer>(valueIn, valueOut); + break; + case ParamType::TGLvoidConstPointer: + SetParamVal<ParamType::TGLvoidConstPointer>(valueIn, valueOut); + break; + case ParamType::TGLvoidConstPointerPointer: + SetParamVal<ParamType::TGLvoidConstPointerPointer>(valueIn, valueOut); + break; + case ParamType::TGraphicsResetStatus: + SetParamVal<ParamType::TGraphicsResetStatus>(valueIn, valueOut); + break; + case ParamType::THandleType: + SetParamVal<ParamType::THandleType>(valueIn, valueOut); + break; + case ParamType::TLightParameter: + SetParamVal<ParamType::TLightParameter>(valueIn, valueOut); + break; + case ParamType::TLogicalOperation: + SetParamVal<ParamType::TLogicalOperation>(valueIn, valueOut); + break; + case ParamType::TMaterialParameter: + SetParamVal<ParamType::TMaterialParameter>(valueIn, valueOut); + break; + case ParamType::TMatrixType: + SetParamVal<ParamType::TMatrixType>(valueIn, valueOut); + break; + case ParamType::TMemoryObjectID: + SetParamVal<ParamType::TMemoryObjectID>(valueIn, valueOut); + break; + case ParamType::TMemoryObjectIDConstPointer: + SetParamVal<ParamType::TMemoryObjectIDConstPointer>(valueIn, valueOut); + break; + case ParamType::TMemoryObjectIDPointer: + SetParamVal<ParamType::TMemoryObjectIDPointer>(valueIn, valueOut); + break; + case ParamType::TObjectType: + SetParamVal<ParamType::TObjectType>(valueIn, valueOut); + break; + case ParamType::TPointParameter: + SetParamVal<ParamType::TPointParameter>(valueIn, valueOut); + break; + case ParamType::TPrimitiveMode: + SetParamVal<ParamType::TPrimitiveMode>(valueIn, valueOut); + break; + case ParamType::TProgramPipelineID: + SetParamVal<ParamType::TProgramPipelineID>(valueIn, valueOut); + break; + case ParamType::TProgramPipelineIDConstPointer: + SetParamVal<ParamType::TProgramPipelineIDConstPointer>(valueIn, valueOut); + break; + case ParamType::TProgramPipelineIDPointer: + SetParamVal<ParamType::TProgramPipelineIDPointer>(valueIn, valueOut); + break; + case ParamType::TProvokingVertexConvention: + SetParamVal<ParamType::TProvokingVertexConvention>(valueIn, valueOut); + break; + case ParamType::TQueryID: + SetParamVal<ParamType::TQueryID>(valueIn, valueOut); + break; + case ParamType::TQueryIDConstPointer: + SetParamVal<ParamType::TQueryIDConstPointer>(valueIn, valueOut); + break; + case ParamType::TQueryIDPointer: + SetParamVal<ParamType::TQueryIDPointer>(valueIn, valueOut); + break; + case ParamType::TQueryType: + SetParamVal<ParamType::TQueryType>(valueIn, valueOut); + break; + case ParamType::TRenderbufferID: + SetParamVal<ParamType::TRenderbufferID>(valueIn, valueOut); + break; + case ParamType::TRenderbufferIDConstPointer: + SetParamVal<ParamType::TRenderbufferIDConstPointer>(valueIn, valueOut); + break; + case ParamType::TRenderbufferIDPointer: + SetParamVal<ParamType::TRenderbufferIDPointer>(valueIn, valueOut); + break; + case ParamType::TSamplerID: + SetParamVal<ParamType::TSamplerID>(valueIn, valueOut); + break; + case ParamType::TSamplerIDConstPointer: + SetParamVal<ParamType::TSamplerIDConstPointer>(valueIn, valueOut); + break; + case ParamType::TSamplerIDPointer: + SetParamVal<ParamType::TSamplerIDPointer>(valueIn, valueOut); + break; + case ParamType::TSemaphoreID: + SetParamVal<ParamType::TSemaphoreID>(valueIn, valueOut); + break; + case ParamType::TSemaphoreIDConstPointer: + SetParamVal<ParamType::TSemaphoreIDConstPointer>(valueIn, valueOut); + break; + case ParamType::TSemaphoreIDPointer: + SetParamVal<ParamType::TSemaphoreIDPointer>(valueIn, valueOut); + break; + case ParamType::TShaderProgramID: + SetParamVal<ParamType::TShaderProgramID>(valueIn, valueOut); + break; + case ParamType::TShaderProgramIDConstPointer: + SetParamVal<ParamType::TShaderProgramIDConstPointer>(valueIn, valueOut); + break; + case ParamType::TShaderProgramIDPointer: + SetParamVal<ParamType::TShaderProgramIDPointer>(valueIn, valueOut); + break; + case ParamType::TShaderType: + SetParamVal<ParamType::TShaderType>(valueIn, valueOut); + break; + case ParamType::TShadingModel: + SetParamVal<ParamType::TShadingModel>(valueIn, valueOut); + break; + case ParamType::TTextureEnvParameter: + SetParamVal<ParamType::TTextureEnvParameter>(valueIn, valueOut); + break; + case ParamType::TTextureEnvTarget: + SetParamVal<ParamType::TTextureEnvTarget>(valueIn, valueOut); + break; + case ParamType::TTextureID: + SetParamVal<ParamType::TTextureID>(valueIn, valueOut); + break; + case ParamType::TTextureIDConstPointer: + SetParamVal<ParamType::TTextureIDConstPointer>(valueIn, valueOut); + break; + case ParamType::TTextureIDPointer: + SetParamVal<ParamType::TTextureIDPointer>(valueIn, valueOut); + break; + case ParamType::TTextureTarget: + SetParamVal<ParamType::TTextureTarget>(valueIn, valueOut); + break; + case ParamType::TTextureType: + SetParamVal<ParamType::TTextureType>(valueIn, valueOut); + break; + case ParamType::TTimestamp: + SetParamVal<ParamType::TTimestamp>(valueIn, valueOut); + break; + case ParamType::TTransformFeedbackID: + SetParamVal<ParamType::TTransformFeedbackID>(valueIn, valueOut); + break; + case ParamType::TTransformFeedbackIDConstPointer: + SetParamVal<ParamType::TTransformFeedbackIDConstPointer>(valueIn, valueOut); + break; + case ParamType::TTransformFeedbackIDPointer: + SetParamVal<ParamType::TTransformFeedbackIDPointer>(valueIn, valueOut); + break; + case ParamType::TUniformBlockIndex: + SetParamVal<ParamType::TUniformBlockIndex>(valueIn, valueOut); + break; + case ParamType::TUniformLocation: + SetParamVal<ParamType::TUniformLocation>(valueIn, valueOut); + break; + case ParamType::TVertexArrayID: + SetParamVal<ParamType::TVertexArrayID>(valueIn, valueOut); + break; + case ParamType::TVertexArrayIDConstPointer: + SetParamVal<ParamType::TVertexArrayIDConstPointer>(valueIn, valueOut); + break; + case ParamType::TVertexArrayIDPointer: + SetParamVal<ParamType::TVertexArrayIDPointer>(valueIn, valueOut); + break; + case ParamType::TVertexAttribType: + SetParamVal<ParamType::TVertexAttribType>(valueIn, valueOut); + break; + case ParamType::TcharConstPointer: + SetParamVal<ParamType::TcharConstPointer>(valueIn, valueOut); + break; + case ParamType::TvoidConstPointer: + SetParamVal<ParamType::TvoidConstPointer>(valueIn, valueOut); + break; + case ParamType::TvoidConstPointerPointer: + SetParamVal<ParamType::TvoidConstPointerPointer>(valueIn, valueOut); + break; + case ParamType::TvoidPointer: + SetParamVal<ParamType::TvoidPointer>(valueIn, valueOut); + break; + case ParamType::TvoidPointerPointer: + SetParamVal<ParamType::TvoidPointerPointer>(valueIn, valueOut); + break; + } +} + +struct CallCapture; +struct ParamCapture; + +void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const ParamCapture ¶m); +const char *ParamTypeToString(ParamType paramType); + +enum class ResourceIDType +{ + Buffer, + FenceNV, + Framebuffer, + MemoryObject, + ProgramPipeline, + Query, + Renderbuffer, + Sampler, + Semaphore, + ShaderProgram, + Texture, + TransformFeedback, + VertexArray, + EnumCount, + InvalidEnum = EnumCount +}; + +ResourceIDType GetResourceIDTypeFromParamType(ParamType paramType); +const char *GetResourceIDTypeName(ResourceIDType resourceIDType); + +template <typename ResourceType> +struct GetResourceIDTypeFromType; + +template <> +struct GetResourceIDTypeFromType<gl::BufferID> +{ + static constexpr ResourceIDType IDType = ResourceIDType::Buffer; +}; + +template <> +struct GetResourceIDTypeFromType<gl::FenceNVID> +{ + static constexpr ResourceIDType IDType = ResourceIDType::FenceNV; +}; + +template <> +struct GetResourceIDTypeFromType<gl::FramebufferID> +{ + static constexpr ResourceIDType IDType = ResourceIDType::Framebuffer; +}; + +template <> +struct GetResourceIDTypeFromType<gl::MemoryObjectID> +{ + static constexpr ResourceIDType IDType = ResourceIDType::MemoryObject; +}; + +template <> +struct GetResourceIDTypeFromType<gl::ProgramPipelineID> +{ + static constexpr ResourceIDType IDType = ResourceIDType::ProgramPipeline; +}; + +template <> +struct GetResourceIDTypeFromType<gl::QueryID> +{ + static constexpr ResourceIDType IDType = ResourceIDType::Query; +}; + +template <> +struct GetResourceIDTypeFromType<gl::RenderbufferID> +{ + static constexpr ResourceIDType IDType = ResourceIDType::Renderbuffer; +}; + +template <> +struct GetResourceIDTypeFromType<gl::SamplerID> +{ + static constexpr ResourceIDType IDType = ResourceIDType::Sampler; +}; + +template <> +struct GetResourceIDTypeFromType<gl::SemaphoreID> +{ + static constexpr ResourceIDType IDType = ResourceIDType::Semaphore; +}; + +template <> +struct GetResourceIDTypeFromType<gl::ShaderProgramID> +{ + static constexpr ResourceIDType IDType = ResourceIDType::ShaderProgram; +}; + +template <> +struct GetResourceIDTypeFromType<gl::TextureID> +{ + static constexpr ResourceIDType IDType = ResourceIDType::Texture; +}; + +template <> +struct GetResourceIDTypeFromType<gl::TransformFeedbackID> +{ + static constexpr ResourceIDType IDType = ResourceIDType::TransformFeedback; +}; + +template <> +struct GetResourceIDTypeFromType<gl::VertexArrayID> +{ + static constexpr ResourceIDType IDType = ResourceIDType::VertexArray; +}; + +} // namespace angle + +#endif // LIBANGLE_FRAME_CAPTURE_UTILS_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils_mock.cpp b/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils_mock.cpp new file mode 100644 index 0000000000..f136a3c17d --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/frame_capture_utils_mock.cpp @@ -0,0 +1,19 @@ +// +// Copyright 2021 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. +// +// frame_capture_utils_mock.cpp: +// ANGLE frame capture util stub implementation. +// + +#include "libANGLE/capture/frame_capture_utils.h" + +namespace angle +{ +Result SerializeContextToString(const gl::Context *context, std::string *stringOut) +{ + *stringOut = "SerializationNotAvailable"; + return angle::Result::Continue; +} +} // namespace angle diff --git a/gfx/angle/checkout/src/libANGLE/capture/gl_enum_utils.h b/gfx/angle/checkout/src/libANGLE/capture/gl_enum_utils.h new file mode 100644 index 0000000000..1fac416138 --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/gl_enum_utils.h @@ -0,0 +1,32 @@ +// +// Copyright 2019 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. +// +// gl_enum_utils.h: +// Utility functions for converting GLenums to string. + +#ifndef LIBANGLE_GL_ENUM_UTILS_H_ +#define LIBANGLE_GL_ENUM_UTILS_H_ + +#include <ostream> +#include <string> + +#include "libANGLE/capture/gl_enum_utils_autogen.h" + +namespace gl +{ +const char *GLbooleanToString(unsigned int value); +const char *GLenumToString(GLESEnum enumGroup, unsigned int value); +const char *GLenumToString(BigGLEnum enumGroup, unsigned int value); +std::string GLbitfieldToString(GLESEnum enumGroup, unsigned int value); +std::string GLbitfieldToString(BigGLEnum enumGroup, unsigned int value); +void OutputGLenumString(std::ostream &out, GLESEnum enumGroup, unsigned int value); +void OutputGLenumString(std::ostream &out, BigGLEnum enumGroup, unsigned int value); +void OutputGLbitfieldString(std::ostream &out, GLESEnum enumGroup, unsigned int value); +const char *GLinternalFormatToString(unsigned int format); + +extern const char kUnknownGLenumString[]; +} // namespace gl + +#endif // LIBANGLE_GL_ENUM_UTILS_H_ diff --git a/gfx/angle/checkout/src/libANGLE/capture/gl_enum_utils_autogen.h b/gfx/angle/checkout/src/libANGLE/capture/gl_enum_utils_autogen.h new file mode 100644 index 0000000000..6d0fe3da3e --- /dev/null +++ b/gfx/angle/checkout/src/libANGLE/capture/gl_enum_utils_autogen.h @@ -0,0 +1,419 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by gen_gl_enum_utils.py using data from gl.xml and gl_angle_ext.xml. +// +// Copyright 2019 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. +// +// gl_enum_utils_autogen.h: +// mapping of GLenum value to string. + +#ifndef LIBANGLE_GL_ENUM_UTILS_AUTOGEN_H_ +#define LIBANGLE_GL_ENUM_UTILS_AUTOGEN_H_ + +namespace gl +{ +enum class GLESEnum +{ + AccumOp, + AllEnums, + AlphaFunction, + AtomicCounterBufferPName, + AttribMask, + AttributeType, + BindTransformFeedbackTarget, + BinormalPointerTypeEXT, + BlendEquationModeEXT, + BlendingFactor, + BlitFramebufferFilter, + Boolean, + Buffer, + BufferAccessARB, + BufferPNameARB, + BufferPointerNameARB, + BufferStorageMask, + BufferStorageTarget, + BufferTargetARB, + BufferUsageARB, + ClampColorModeARB, + ClearBufferMask, + ClipPlaneName, + ColorBuffer, + ColorMaterialParameter, + ColorPointerType, + CombinerBiasNV, + CombinerComponentUsageNV, + CombinerPortionNV, + CombinerScaleNV, + ContainerType, + ContextFlagMask, + CopyBufferSubDataTarget, + CopyImageSubDataTarget, + DebugSeverity, + DebugSource, + DebugType, + DepthFunction, + DepthStencilTextureMode, + DrawBufferMode, + DrawElementsType, + ElementPointerTypeATI, + EnableCap, + ErrorCode, + ExternalHandleType, + FenceConditionNV, + FenceParameterNameNV, + FogCoordinatePointerType, + FogMode, + FogPName, + FogParameter, + FogPointerTypeEXT, + FogPointerTypeIBM, + FragmentLightParameterSGIX, + FragmentShaderDestMaskATI, + FragmentShaderDestModMaskATI, + FragmentShaderGenericSourceATI, + FragmentShaderTextureSourceATI, + FragmentShaderValueRepATI, + FramebufferAttachment, + FramebufferAttachmentParameterName, + FramebufferParameterName, + FramebufferStatus, + FramebufferTarget, + FrontFaceDirection, + GetFramebufferParameter, + GetMultisamplePNameNV, + GetPName, + GetPointervPName, + GetTextureParameter, + GraphicsResetStatus, + HintMode, + HintTarget, + IndexFunctionEXT, + IndexPointerType, + InternalFormat, + InternalFormatPName, + InvalidateFramebufferAttachment, + LightEnvModeSGIX, + LightModelParameter, + LightName, + LightParameter, + ListNameType, + LogicOp, + MapBufferAccessMask, + MapTypeNV, + MaterialParameter, + MatrixIndexPointerTypeARB, + MatrixMode, + MemoryBarrierMask, + MemoryObjectParameterName, + NormalPointerType, + ObjectIdentifier, + PatchParameterName, + PathColor, + PathColorFormat, + PathFillMode, + PathFontStyle, + PathGenMode, + PathTransformType, + PipelineParameterName, + PixelCopyType, + PixelFormat, + PixelStoreParameter, + PixelTexGenModeSGIX, + PixelTransferParameter, + PixelType, + PointParameterNameARB, + PrecisionType, + PrimitiveType, + ProgramInterface, + ProgramInterfacePName, + ProgramParameterPName, + ProgramPropertyARB, + ProgramResourceProperty, + QueryCounterTarget, + QueryObjectParameterName, + QueryParameterName, + QueryTarget, + ReadBufferMode, + RenderbufferParameterName, + RenderbufferTarget, + ReplacementCodeTypeSUN, + SamplerParameterF, + SamplerParameterI, + ScalarType, + SecondaryColorPointerTypeIBM, + SemaphoreParameterName, + ShaderBinaryFormat, + ShaderParameterName, + ShaderType, + ShadingModel, + ShadingRateQCOM, + SizedInternalFormat, + StencilFunction, + StencilOp, + StringName, + SubroutineParameterName, + SyncBehaviorFlags, + SyncCondition, + SyncObjectMask, + SyncParameterName, + SyncStatus, + TangentPointerTypeEXT, + TexCoordPointerType, + TextureCompareMode, + TextureCoordName, + TextureEnvMode, + TextureEnvParameter, + TextureEnvTarget, + TextureGenParameter, + TextureLayout, + TextureMagFilter, + TextureMinFilter, + TextureParameterName, + TextureSwizzle, + TextureTarget, + TextureUnit, + TextureWrapMode, + TransformFeedbackBufferMode, + TransformFeedbackPName, + TriangleFace, + UniformBlockPName, + UniformPName, + UniformType, + UseProgramStageMask, + VertexArrayPName, + VertexAttribEnum, + VertexAttribIType, + VertexAttribPointerPropertyARB, + VertexAttribPointerType, + VertexAttribPropertyARB, + VertexAttribType, + VertexBufferObjectUsage, + VertexPointerType, + VertexProvokingMode, + VertexShaderTextureUnitParameter, + VertexShaderWriteMaskEXT, + VertexWeightPointerTypeEXT, + WeightPointerTypeARB +}; + +enum class BigGLEnum +{ + AccumOp, + AllEnums, + AlphaFunction, + AtomicCounterBufferPName, + AttribMask, + AttributeType, + BindTransformFeedbackTarget, + BinormalPointerTypeEXT, + BlendEquationModeEXT, + BlendingFactor, + BlitFramebufferFilter, + Boolean, + Buffer, + BufferAccessARB, + BufferPNameARB, + BufferPointerNameARB, + BufferStorageMask, + BufferStorageTarget, + BufferTargetARB, + BufferUsageARB, + ClampColorModeARB, + ClampColorTargetARB, + ClearBufferMask, + ClientAttribMask, + ClipControlDepth, + ClipControlOrigin, + ClipPlaneName, + ColorBuffer, + ColorMaterialParameter, + ColorPointerType, + ColorTableTarget, + ColorTableTargetSGI, + CombinerBiasNV, + CombinerComponentUsageNV, + CombinerPortionNV, + CombinerScaleNV, + ConditionalRenderMode, + ContainerType, + ContextFlagMask, + ContextProfileMask, + ConvolutionTarget, + ConvolutionTargetEXT, + CopyBufferSubDataTarget, + CopyImageSubDataTarget, + DebugSeverity, + DebugSource, + DebugType, + DepthFunction, + DepthStencilTextureMode, + DrawBufferMode, + DrawElementsType, + ElementPointerTypeATI, + EnableCap, + ErrorCode, + ExternalHandleType, + FeedBackToken, + FeedbackType, + FenceConditionNV, + FenceParameterNameNV, + FogCoordSrc, + FogCoordinatePointerType, + FogMode, + FogPName, + FogParameter, + FogPointerTypeEXT, + FogPointerTypeIBM, + FragmentLightParameterSGIX, + FragmentShaderDestMaskATI, + FragmentShaderDestModMaskATI, + FragmentShaderGenericSourceATI, + FragmentShaderTextureSourceATI, + FragmentShaderValueRepATI, + FramebufferAttachment, + FramebufferAttachmentParameterName, + FramebufferParameterName, + FramebufferStatus, + FramebufferTarget, + FrontFaceDirection, + GetFramebufferParameter, + GetMapQuery, + GetMultisamplePNameNV, + GetPName, + GetPointervPName, + GetTextureParameter, + GraphicsResetStatus, + HintMode, + HintTarget, + HistogramTarget, + HistogramTargetEXT, + IndexFunctionEXT, + IndexMaterialParameterEXT, + IndexPointerType, + InterleavedArrayFormat, + InternalFormat, + InternalFormatPName, + InvalidateFramebufferAttachment, + LightEnvModeSGIX, + LightModelColorControl, + LightModelParameter, + LightName, + LightParameter, + LightTextureModeEXT, + ListMode, + ListNameType, + LogicOp, + MapBufferAccessMask, + MapQuery, + MapTarget, + MapTypeNV, + MaterialParameter, + MatrixIndexPointerTypeARB, + MatrixMode, + MemoryBarrierMask, + MemoryObjectParameterName, + MeshMode1, + MeshMode2, + MinmaxTarget, + MinmaxTargetEXT, + NormalPointerType, + ObjectIdentifier, + PatchParameterName, + PathColor, + PathColorFormat, + PathFillMode, + PathFontStyle, + PathGenMode, + PathTransformType, + PipelineParameterName, + PixelCopyType, + PixelFormat, + PixelMap, + PixelStoreParameter, + PixelTexGenModeSGIX, + PixelTransferParameter, + PixelType, + PointParameterNameARB, + PolygonMode, + PrecisionType, + PrimitiveType, + ProgramInterface, + ProgramInterfacePName, + ProgramParameterPName, + ProgramPropertyARB, + ProgramResourceProperty, + ProgramStagePName, + QueryCounterTarget, + QueryObjectParameterName, + QueryParameterName, + QueryTarget, + ReadBufferMode, + RenderbufferParameterName, + RenderbufferTarget, + RenderingMode, + ReplacementCodeTypeSUN, + SamplerParameterF, + SamplerParameterI, + ScalarType, + SecondaryColorPointerTypeIBM, + SemaphoreParameterName, + SeparableTarget, + SeparableTargetEXT, + ShaderBinaryFormat, + ShaderParameterName, + ShaderType, + ShadingModel, + SizedInternalFormat, + StencilFunction, + StencilOp, + StringName, + SubroutineParameterName, + SyncBehaviorFlags, + SyncCondition, + SyncObjectMask, + SyncParameterName, + SyncStatus, + TangentPointerTypeEXT, + TexCoordPointerType, + TextureCompareMode, + TextureCoordName, + TextureEnvMode, + TextureEnvParameter, + TextureEnvTarget, + TextureGenMode, + TextureGenParameter, + TextureLayout, + TextureMagFilter, + TextureMinFilter, + TextureParameterName, + TextureSwizzle, + TextureTarget, + TextureUnit, + TextureWrapMode, + TransformFeedbackBufferMode, + TransformFeedbackPName, + TriangleFace, + UniformBlockPName, + UniformPName, + UniformType, + UseProgramStageMask, + VertexArrayPName, + VertexAttribEnum, + VertexAttribIType, + VertexAttribLType, + VertexAttribPointerPropertyARB, + VertexAttribPointerType, + VertexAttribPropertyARB, + VertexAttribType, + VertexBufferObjectUsage, + VertexPointerType, + VertexProvokingMode, + VertexShaderTextureUnitParameter, + VertexShaderWriteMaskEXT, + VertexWeightPointerTypeEXT, + WeightPointerTypeARB +}; +} // namespace gl + +#endif // LIBANGLE_GL_ENUM_UTILS_AUTOGEN_H_ |