blob: 3785bcd43ab31d5c2e3efca0ad686717e80aede3 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
// debug-command-buffer.cpp
#include "debug-command-buffer.h"
#include "debug-framebuffer.h"
#include "debug-render-pass.h"
#include "debug-helper-functions.h"
namespace gfx
{
using namespace Slang;
namespace debug
{
DebugCommandBuffer::DebugCommandBuffer()
{
SLANG_GFX_API_FUNC;
m_renderCommandEncoder.commandBuffer = this;
m_computeCommandEncoder.commandBuffer = this;
m_resourceCommandEncoder.commandBuffer = this;
m_rayTracingCommandEncoder.commandBuffer = this;
}
void DebugCommandBuffer::encodeRenderCommands(
IRenderPassLayout* renderPass,
IFramebuffer* framebuffer,
IRenderCommandEncoder** outEncoder)
{
SLANG_GFX_API_FUNC;
checkCommandBufferOpenWhenCreatingEncoder();
checkEncodersClosedBeforeNewEncoder();
auto innerRenderPass =
renderPass ? static_cast<DebugRenderPassLayout*>(renderPass)->baseObject : nullptr;
auto innerFramebuffer =
framebuffer ? static_cast<DebugFramebuffer*>(framebuffer)->baseObject : nullptr;
m_renderCommandEncoder.isOpen = true;
baseObject->encodeRenderCommands(
innerRenderPass, innerFramebuffer, &m_renderCommandEncoder.baseObject);
if (m_renderCommandEncoder.baseObject)
*outEncoder = &m_renderCommandEncoder;
else
*outEncoder = nullptr;
}
void DebugCommandBuffer::encodeComputeCommands(IComputeCommandEncoder** outEncoder)
{
SLANG_GFX_API_FUNC;
checkCommandBufferOpenWhenCreatingEncoder();
checkEncodersClosedBeforeNewEncoder();
m_computeCommandEncoder.isOpen = true;
baseObject->encodeComputeCommands(&m_computeCommandEncoder.baseObject);
if (m_computeCommandEncoder.baseObject)
{
*outEncoder = &m_computeCommandEncoder;
}
else
{
*outEncoder = nullptr;
}
}
void DebugCommandBuffer::encodeResourceCommands(IResourceCommandEncoder** outEncoder)
{
SLANG_GFX_API_FUNC;
checkCommandBufferOpenWhenCreatingEncoder();
checkEncodersClosedBeforeNewEncoder();
m_resourceCommandEncoder.isOpen = true;
baseObject->encodeResourceCommands(&m_resourceCommandEncoder.baseObject);
if (m_resourceCommandEncoder.baseObject)
{
*outEncoder = &m_resourceCommandEncoder;
}
else
{
*outEncoder = nullptr;
}
}
void DebugCommandBuffer::encodeRayTracingCommands(IRayTracingCommandEncoder** outEncoder)
{
SLANG_GFX_API_FUNC;
checkCommandBufferOpenWhenCreatingEncoder();
checkEncodersClosedBeforeNewEncoder();
m_rayTracingCommandEncoder.isOpen = true;
baseObject->encodeRayTracingCommands(&m_rayTracingCommandEncoder.baseObject);
if (m_rayTracingCommandEncoder.baseObject)
{
*outEncoder = &m_rayTracingCommandEncoder;
}
else
{
*outEncoder = nullptr;
}
}
void DebugCommandBuffer::close()
{
SLANG_GFX_API_FUNC;
if (!isOpen)
{
GFX_DIAGNOSE_ERROR("command buffer is already closed.");
}
if (m_renderCommandEncoder.isOpen)
{
GFX_DIAGNOSE_ERROR(
"A render command encoder on this command buffer is still open. "
"IRenderCommandEncoder::endEncoding() must be called before closing a command buffer.");
}
if (m_computeCommandEncoder.isOpen)
{
GFX_DIAGNOSE_ERROR(
"A compute command encoder on this command buffer is still open. "
"IComputeCommandEncoder::endEncoding() must be called before closing a command buffer.");
}
if (m_resourceCommandEncoder.isOpen)
{
GFX_DIAGNOSE_ERROR(
"A resource command encoder on this command buffer is still open. "
"IResourceCommandEncoder::endEncoding() must be called before closing a command buffer.");
}
isOpen = false;
baseObject->close();
}
Result DebugCommandBuffer::getNativeHandle(InteropHandle* outHandle)
{
SLANG_GFX_API_FUNC;
return baseObject->getNativeHandle(outHandle);
}
void DebugCommandBuffer::checkEncodersClosedBeforeNewEncoder()
{
if (m_renderCommandEncoder.isOpen || m_resourceCommandEncoder.isOpen ||
m_computeCommandEncoder.isOpen)
{
GFX_DIAGNOSE_ERROR(
"A previouse command encoder created on this command buffer is still open. "
"endEncoding() must be called on the encoder before creating an encoder.");
}
}
void DebugCommandBuffer::checkCommandBufferOpenWhenCreatingEncoder()
{
if (!isOpen)
{
GFX_DIAGNOSE_ERROR("The command buffer is already closed. Encoders can only be retrieved "
"while the command buffer is open.");
}
}
} // namespace debug
} // namespace gfx
|
