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
|
//TEST:SIMPLE(filecheck=CHECK): -target spirv
// CHECK: OpEntryPoint
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
[ForceInline]
__generic<T : __BuiltinFloatingPointType>
public T accumulateSample(uint64_t pSampleIdx, T pOldValue, T pNewValue) {
T lTmp = isfinite(pOldValue) ? pOldValue : T(0);
return lTmp + (pNewValue - lTmp) / T(pSampleIdx + 1);
}
[ForceInline]
__generic<T : __BuiltinFloatingPointType, let N : int>
public vector<T, N> accumulateSample(uint64_t pSampleIdx, vector<T, N> pOldValue, vector<T, N> pNewValue) {
vector<T, N> lTmp = select(isfinite(pOldValue), pOldValue, T(0));
return lTmp + (pNewValue - lTmp) / vector<T, N>(pSampleIdx + 1);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public struct RenderBuffer2D<T : ITexelElement> {
public Texture2D<T> handle;
public uint16_t2 offset;
public uint16_t2 size;
public __init() {
handle = {};
offset = {};
size = {};
}
[ForceInline] public bool isValid() { return size[0] > 0u && size[1] > 0u; }
[ForceInline] public uint64_t getPixelCount() { return (uint64_t)(size[0]) * (uint64_t)(size[1]); }
}
public struct RWRenderBuffer2D<T : ITexelElement> {
public RWTexture2D<T> handle;
public uint16_t2 offset;
public uint16_t2 size;
public __init() {
handle = {};
offset = {};
size = {};
}
[ForceInline] public bool isValid() { return size[0] > 0u && size[1] > 0u; }
[ForceInline] public uint64_t getPixelCount() { return (uint64_t)(size[0]) * (uint64_t)(size[1]); }
}
__generic<T : __BuiltinFloatingPointType>
public extension RWRenderBuffer2D<T> where T : ITexelElement {
[ForceInline]
public void accumulate(uint32_t2 pDestIdx, uint64_t pSampleIdx, T pSampleValue) {
uint32_t2 lIndex = offset + pDestIdx;
handle[lIndex] = accumulateSample(pSampleIdx, handle[lIndex], pSampleValue);
}
}
__generic<T : __BuiltinFloatingPointType, let N : int>
public extension RWRenderBuffer2D<vector<T, N>> where vector<T,N>:ITexelElement {
[ForceInline]
public void accumulate(uint32_t2 pDestIdx, uint64_t pSampleIdx, vector<T, N> pSampleValue) {
uint32_t2 lIndex = offset + pDestIdx;
handle[lIndex] = accumulateSample(pSampleIdx, handle[lIndex], pSampleValue);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Global Parameters
public uniform uint32_t gSampleIdx;
public uniform RenderBuffer2D<float4> gInput;
public uniform RWRenderBuffer2D<float4> gOutput;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
[shader("compute")]
[numthreads(16, 16, 1)]
void refineImage(uint3 pDispatchThreadIdx: SV_DispatchThreadID) {
const uint2 lPixelCoordinates = { pDispatchThreadIdx.x, pDispatchThreadIdx.y };
// Some sanity checks.
if (!gInput.isValid() || any(lPixelCoordinates >= gInput.size)) {
return;
}
if (!gOutput.isValid() || any(lPixelCoordinates >= gOutput.size)) {
return;
}
gOutput.accumulate(lPixelCoordinates, gSampleIdx, gInput.handle[lPixelCoordinates]);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
