mirror of
https://github.com/baldurk/renderdoc.git
synced 2026-09-02 20:05:44 +00:00
baldurk
153cd2aa16
* This will allow a UI viewer or consumer of the replay API to more easily query 'all' descriptors for a given store.
211 lines
9.2 KiB
C++
211 lines
9.2 KiB
C++
/******************************************************************************
|
|
* The MIT License (MIT)
|
|
*
|
|
* Copyright (c) 2021-2024 Baldur Karlsson
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
******************************************************************************/
|
|
|
|
#pragma once
|
|
|
|
#include "replay_driver.h"
|
|
|
|
// this is a dummy driver that can be swapped to if the underlying replay/remote driver encounters
|
|
// some fatal problem and shouldn't be used further. It saves significantly on needing to
|
|
// bullet-proof each driver since instead we just need to make error paths clear and short, and rely
|
|
// on the replay controller to detect errors and swap to a dummy driver immediately
|
|
class DummyDriver : public IReplayDriver
|
|
{
|
|
public:
|
|
DummyDriver(IReplayDriver *original, const rdcarray<ShaderReflection *> &shaders, SDFile *sdfile);
|
|
|
|
void Shutdown();
|
|
|
|
APIProperties GetAPIProperties();
|
|
|
|
rdcarray<ResourceDescription> GetResources();
|
|
|
|
rdcarray<DescriptorStoreDescription> GetDescriptorStores();
|
|
|
|
rdcarray<BufferDescription> GetBuffers();
|
|
BufferDescription GetBuffer(ResourceId id);
|
|
|
|
rdcarray<TextureDescription> GetTextures();
|
|
TextureDescription GetTexture(ResourceId id);
|
|
|
|
rdcarray<DebugMessage> GetDebugMessages();
|
|
|
|
rdcarray<ShaderEntryPoint> GetShaderEntryPoints(ResourceId shader);
|
|
ShaderReflection *GetShader(ResourceId pipeline, ResourceId shader, ShaderEntryPoint entry);
|
|
|
|
rdcarray<rdcstr> GetDisassemblyTargets(bool withPipeline);
|
|
rdcstr DisassembleShader(ResourceId pipeline, const ShaderReflection *refl, const rdcstr &target);
|
|
|
|
rdcarray<EventUsage> GetUsage(ResourceId id);
|
|
|
|
void SetPipelineStates(D3D11Pipe::State *d3d11, D3D12Pipe::State *d3d12, GLPipe::State *gl,
|
|
VKPipe::State *vk);
|
|
void SavePipelineState(uint32_t eventId);
|
|
rdcarray<Descriptor> GetDescriptors(ResourceId descriptorStore,
|
|
const rdcarray<DescriptorRange> &ranges);
|
|
rdcarray<SamplerDescriptor> GetSamplerDescriptors(ResourceId descriptorStore,
|
|
const rdcarray<DescriptorRange> &ranges);
|
|
rdcarray<DescriptorAccess> GetDescriptorAccess(uint32_t eventId);
|
|
rdcarray<DescriptorLogicalLocation> GetDescriptorLocations(ResourceId descriptorStore,
|
|
const rdcarray<DescriptorRange> &ranges);
|
|
|
|
FrameRecord GetFrameRecord();
|
|
|
|
RDResult ReadLogInitialisation(RDCFile *rdc, bool storeStructuredBuffers);
|
|
void ReplayLog(uint32_t endEventID, ReplayLogType replayType);
|
|
SDFile *GetStructuredFile();
|
|
|
|
rdcarray<uint32_t> GetPassEvents(uint32_t eventId);
|
|
|
|
void InitPostVSBuffers(uint32_t eventId);
|
|
void InitPostVSBuffers(const rdcarray<uint32_t> &passEvents);
|
|
|
|
ResourceId GetLiveID(ResourceId id);
|
|
|
|
MeshFormat GetPostVSBuffers(uint32_t eventId, uint32_t instID, uint32_t viewID,
|
|
MeshDataStage stage);
|
|
|
|
void GetBufferData(ResourceId buff, uint64_t offset, uint64_t len, bytebuf &retData);
|
|
void GetTextureData(ResourceId tex, const Subresource &sub, const GetTextureDataParams ¶ms,
|
|
bytebuf &data);
|
|
|
|
void BuildTargetShader(ShaderEncoding sourceEncoding, const bytebuf &source, const rdcstr &entry,
|
|
const ShaderCompileFlags &compileFlags, ShaderStage type, ResourceId &id,
|
|
rdcstr &errors);
|
|
rdcarray<ShaderEncoding> GetTargetShaderEncodings();
|
|
void ReplaceResource(ResourceId from, ResourceId to);
|
|
void RemoveReplacement(ResourceId id);
|
|
void FreeTargetResource(ResourceId id);
|
|
|
|
rdcarray<GPUCounter> EnumerateCounters();
|
|
CounterDescription DescribeCounter(GPUCounter counterID);
|
|
rdcarray<CounterResult> FetchCounters(const rdcarray<GPUCounter> &counterID);
|
|
|
|
void FillCBufferVariables(ResourceId pipeline, ResourceId shader, ShaderStage stage,
|
|
rdcstr entryPoint, uint32_t cbufSlot, rdcarray<ShaderVariable> &outvars,
|
|
const bytebuf &data);
|
|
|
|
rdcarray<PixelModification> PixelHistory(rdcarray<EventUsage> events, ResourceId target, uint32_t x,
|
|
uint32_t y, const Subresource &sub, CompType typeCast);
|
|
ShaderDebugTrace *DebugVertex(uint32_t eventId, uint32_t vertid, uint32_t instid, uint32_t idx,
|
|
uint32_t view);
|
|
ShaderDebugTrace *DebugPixel(uint32_t eventId, uint32_t x, uint32_t y,
|
|
const DebugPixelInputs &inputs);
|
|
ShaderDebugTrace *DebugThread(uint32_t eventId, const rdcfixedarray<uint32_t, 3> &groupid,
|
|
const rdcfixedarray<uint32_t, 3> &threadid);
|
|
rdcarray<ShaderDebugState> ContinueDebug(ShaderDebugger *debugger);
|
|
void FreeDebugger(ShaderDebugger *debugger);
|
|
|
|
ResourceId RenderOverlay(ResourceId texid, FloatVector clearCol, DebugOverlay overlay,
|
|
uint32_t eventId, const rdcarray<uint32_t> &passEvents);
|
|
|
|
bool IsRenderOutput(ResourceId id);
|
|
|
|
void FileChanged();
|
|
|
|
bool NeedRemapForFetch(const ResourceFormat &format);
|
|
|
|
DriverInformation GetDriverInfo();
|
|
|
|
rdcarray<GPUDevice> GetAvailableGPUs();
|
|
|
|
// IReplayDriver
|
|
bool IsRemoteProxy();
|
|
|
|
RDResult FatalErrorCheck();
|
|
IReplayDriver *MakeDummyDriver();
|
|
|
|
rdcarray<WindowingSystem> GetSupportedWindowSystems();
|
|
|
|
AMDRGPControl *GetRGPControl();
|
|
|
|
uint64_t MakeOutputWindow(WindowingData window, bool depth);
|
|
void DestroyOutputWindow(uint64_t id);
|
|
bool CheckResizeOutputWindow(uint64_t id);
|
|
void SetOutputWindowDimensions(uint64_t id, int32_t w, int32_t h);
|
|
void GetOutputWindowDimensions(uint64_t id, int32_t &w, int32_t &h);
|
|
void GetOutputWindowData(uint64_t id, bytebuf &retData);
|
|
void ClearOutputWindowColor(uint64_t id, FloatVector col);
|
|
void ClearOutputWindowDepth(uint64_t id, float depth, uint8_t stencil);
|
|
void BindOutputWindow(uint64_t id, bool depth);
|
|
bool IsOutputWindowVisible(uint64_t id);
|
|
void FlipOutputWindow(uint64_t id);
|
|
|
|
bool GetMinMax(ResourceId texid, const Subresource &sub, CompType typeCast, float *minval,
|
|
float *maxval);
|
|
bool GetHistogram(ResourceId texid, const Subresource &sub, CompType typeCast, float minval,
|
|
float maxval, const rdcfixedarray<bool, 4> &channels,
|
|
rdcarray<uint32_t> &histogram);
|
|
void PickPixel(ResourceId texture, uint32_t x, uint32_t y, const Subresource &sub,
|
|
CompType typeCast, float pixel[4]);
|
|
|
|
ResourceId CreateProxyTexture(const TextureDescription &templateTex);
|
|
void SetProxyTextureData(ResourceId texid, const Subresource &sub, byte *data, size_t dataSize);
|
|
bool IsTextureSupported(const TextureDescription &tex);
|
|
|
|
ResourceId CreateProxyBuffer(const BufferDescription &templateBuf);
|
|
void SetProxyBufferData(ResourceId bufid, byte *data, size_t dataSize);
|
|
|
|
void RenderMesh(uint32_t eventId, const rdcarray<MeshFormat> &secondaryDraws,
|
|
const MeshDisplay &cfg);
|
|
bool RenderTexture(TextureDisplay cfg);
|
|
|
|
void SetCustomShaderIncludes(const rdcarray<rdcstr> &directories);
|
|
void BuildCustomShader(ShaderEncoding sourceEncoding, const bytebuf &source, const rdcstr &entry,
|
|
const ShaderCompileFlags &compileFlags, ShaderStage type, ResourceId &id,
|
|
rdcstr &errors);
|
|
rdcarray<ShaderEncoding> GetCustomShaderEncodings();
|
|
rdcarray<ShaderSourcePrefix> GetCustomShaderSourcePrefixes();
|
|
ResourceId ApplyCustomShader(TextureDisplay &display);
|
|
void FreeCustomShader(ResourceId id);
|
|
|
|
void RenderCheckerboard(FloatVector dark, FloatVector light);
|
|
|
|
void RenderHighlightBox(float w, float h, float scale);
|
|
|
|
uint32_t PickVertex(uint32_t eventId, int32_t width, int32_t height, const MeshDisplay &cfg,
|
|
uint32_t x, uint32_t y);
|
|
|
|
private:
|
|
virtual ~DummyDriver();
|
|
|
|
rdcarray<ShaderReflection *> m_Shaders;
|
|
SDFile *m_SDFile;
|
|
|
|
APIProperties m_Props;
|
|
rdcarray<ResourceDescription> m_Resources;
|
|
rdcarray<DescriptorStoreDescription> m_DescriptorStores;
|
|
rdcarray<BufferDescription> m_Buffers;
|
|
rdcarray<TextureDescription> m_Textures;
|
|
FrameRecord m_FrameRecord;
|
|
rdcarray<ShaderEncoding> m_TargetEncodings;
|
|
DriverInformation m_DriverInfo;
|
|
|
|
bool m_Proxy;
|
|
rdcarray<GPUDevice> m_GPUs;
|
|
rdcarray<WindowingSystem> m_WindowSystems;
|
|
rdcarray<ShaderEncoding> m_CustomEncodings;
|
|
rdcarray<ShaderSourcePrefix> m_CustomPrefixes;
|
|
};
|