13# include <optix_denoiser_tiling.h>
18 :
DenoiserGPU(denoiser_device, params), state_(denoiser_device,
"__denoiser_state",
true)
22OptiXDenoiser::~OptiXDenoiser()
27 if (optix_denoiser_ !=
nullptr) {
28 optixDenoiserDestroy(optix_denoiser_);
32bool OptiXDenoiser::is_device_supported(
const DeviceInfo &device)
40bool OptiXDenoiser::denoise_buffer(
const BufferParams &buffer_params,
43 const int num_samples,
44 const bool allow_inplace_modification,
47 OptiXDevice *
const optix_device =
static_cast<OptiXDevice *
>(denoiser_device_);
48 const CUDAContextScope scope(optix_device);
51 denoised_buffer_params,
54 allow_inplace_modification,
58bool OptiXDenoiser::denoise_create_if_needed(DenoiseContext &context)
62 const bool use_pass_motion =
context.denoise_params.temporally_stable &&
64 const bool use_upscale_model =
context.denoise_params.upscale_factor == 2.0f;
66 const bool recreate_denoiser = (optix_denoiser_ ==
nullptr) ||
67 (use_pass_albedo_ != use_pass_albedo) ||
68 (use_pass_normal_ != use_pass_normal) ||
69 (use_pass_motion_ != use_pass_motion) ||
70 (use_upscale_model_ != use_upscale_model);
71 if (!recreate_denoiser) {
76 if (optix_denoiser_) {
77 optixDenoiserDestroy(optix_denoiser_);
81 OptixDenoiserModelKind model;
82 if (use_pass_motion) {
83 if (use_upscale_model) {
84 model = OPTIX_DENOISER_MODEL_KIND_TEMPORAL_UPSCALE2X;
87 model = OPTIX_DENOISER_MODEL_KIND_TEMPORAL;
91 if (use_upscale_model) {
92 model = OPTIX_DENOISER_MODEL_KIND_UPSCALE2X;
95 model = OPTIX_DENOISER_MODEL_KIND_AOV;
99 OptixDenoiserOptions denoiser_options = {};
100 denoiser_options.guideAlbedo = use_pass_albedo;
101 denoiser_options.guideNormal = use_pass_normal;
102 denoiser_options.denoiseAlpha = OPTIX_DENOISER_ALPHA_MODE_COPY;
104 const OptixResult
result = optixDenoiserCreate(
105 static_cast<OptiXDevice *
>(denoiser_device_)->context,
110 if (result != OPTIX_SUCCESS) {
111 set_error(
"Failed to create OptiX denoiser");
116 use_pass_albedo_ = use_pass_albedo;
117 use_pass_normal_ = use_pass_normal;
118 use_pass_motion_ = use_pass_motion;
119 use_upscale_model_ = use_upscale_model;
122 is_configured_ =
false;
127bool OptiXDenoiser::denoise_configure_if_needed(DenoiseContext &context)
133 if (is_configured_ && (configured_size_.x == tile_size.
x && configured_size_.y == tile_size.
y)) {
139 optixDenoiserComputeMemoryResources(optix_denoiser_, tile_size.
x, tile_size.
y, &sizes_));
141 const bool tiled = tile_size.
x <
context.buffer_params.width ||
142 tile_size.
y <
context.buffer_params.height;
145 state_.device = denoiser_device_;
146 state_.alloc_to_device(sizes_.stateSizeInBytes + sizes_.withOverlapScratchSizeInBytes);
149 const OptixResult
result = optixDenoiserSetup(
153 tile_size.
x + (tiled ? sizes_.overlapWindowSizeInPixels * 2 : 0),
154 tile_size.
y + (tiled ? sizes_.overlapWindowSizeInPixels * 2 : 0),
155 state_.device_pointer,
156 sizes_.stateSizeInBytes,
157 state_.device_pointer + sizes_.stateSizeInBytes,
158 sizes_.withOverlapScratchSizeInBytes);
159 if (result != OPTIX_SUCCESS) {
160 set_error(
"Failed to set up OptiX denoiser");
164 cuda_device_assert(denoiser_device_, cuCtxSynchronize());
166 is_configured_ =
true;
167 configured_size_ = tile_size;
172bool OptiXDenoiser::denoise_run(
const DenoiseContext &context,
const DenoisePass &pass)
175 OptixImage2D color_layer = {0};
176 OptixImage2D albedo_layer = {0};
177 OptixImage2D normal_layer = {0};
178 OptixImage2D flow_layer = {0};
180 OptixImage2D output_layer = {0};
181 OptixImage2D prev_output_layer = {0};
185 const int pass_denoised = pass.denoised_offset;
188 color_layer.data =
context.render_buffers->buffer.device_pointer +
189 pass_denoised *
sizeof(
float);
190 color_layer.width =
context.buffer_params.width;
191 color_layer.height =
context.buffer_params.height;
192 color_layer.rowStrideInBytes = pass_stride_in_bytes *
context.buffer_params.stride;
193 color_layer.pixelStrideInBytes = pass_stride_in_bytes;
194 color_layer.format = pass.num_components > 3 && use_upscale_model_ ?
195 OPTIX_PIXEL_FORMAT_FLOAT4 :
196 OPTIX_PIXEL_FORMAT_FLOAT3;
203 prev_output_layer.data =
context.prev_output.device_pointer +
205 prev_output_layer.width =
context.denoised_buffer_params.width;
206 prev_output_layer.height =
context.denoised_buffer_params.height;
207 prev_output_layer.rowStrideInBytes = pass_stride_in_bytes *
context.prev_output.stride;
208 prev_output_layer.pixelStrideInBytes = pass_stride_in_bytes;
209 prev_output_layer.format = OPTIX_PIXEL_FORMAT_FLOAT3;
215 const int64_t row_stride_in_bytes =
context.guiding_params.stride * pixel_stride_in_bytes;
217 if (use_pass_albedo_) {
218 albedo_layer.data = d_guiding_buffer +
context.guiding_params.pass_albedo *
sizeof(
float);
219 albedo_layer.width =
context.buffer_params.width;
220 albedo_layer.height =
context.buffer_params.height;
221 albedo_layer.rowStrideInBytes = row_stride_in_bytes;
222 albedo_layer.pixelStrideInBytes = pixel_stride_in_bytes;
223 albedo_layer.format = OPTIX_PIXEL_FORMAT_FLOAT3;
226 if (use_pass_normal_) {
227 normal_layer.data = d_guiding_buffer +
context.guiding_params.pass_normal *
sizeof(
float);
228 normal_layer.width =
context.buffer_params.width;
229 normal_layer.height =
context.buffer_params.height;
230 normal_layer.rowStrideInBytes = row_stride_in_bytes;
231 normal_layer.pixelStrideInBytes = pixel_stride_in_bytes;
232 normal_layer.format = OPTIX_PIXEL_FORMAT_FLOAT3;
235 if (use_pass_motion_) {
236 flow_layer.data = d_guiding_buffer +
context.guiding_params.pass_flow *
sizeof(
float);
237 flow_layer.width =
context.buffer_params.width;
238 flow_layer.height =
context.buffer_params.height;
239 flow_layer.rowStrideInBytes = row_stride_in_bytes;
240 flow_layer.pixelStrideInBytes = pixel_stride_in_bytes;
241 flow_layer.format = OPTIX_PIXEL_FORMAT_FLOAT2;
248 output_layer = color_layer;
249 output_layer.width =
context.denoised_buffer_params.width;
250 output_layer.height =
context.denoised_buffer_params.height;
251 output_layer.rowStrideInBytes = output_layer.pixelStrideInBytes *
252 context.denoised_buffer_params.stride;
255 OptixDenoiserGuideLayer guide_layers = {};
256 guide_layers.albedo = albedo_layer;
257 guide_layers.normal = normal_layer;
258 guide_layers.flow = flow_layer;
260 OptixDenoiserLayer image_layers = {};
261 image_layers.input = color_layer;
262 image_layers.previousOutput = prev_output_layer;
263 image_layers.output = output_layer;
266 OptixDenoiserParams params = {};
268 optix_device_assert(denoiser_device_,
269 optixUtilDenoiserInvokeTiled(
271 static_cast<OptiXDeviceQueue *
>(denoiser_queue_.get())->stream(),
273 state_.device_pointer,
274 sizes_.stateSizeInBytes,
278 state_.device_pointer + sizes_.stateSizeInBytes,
279 sizes_.withOverlapScratchSizeInBytes,
280 sizes_.overlapWindowSizeInPixels,
282 configured_size_.y));
bool denoise_buffer(const BufferParams &buffer_params, const BufferParams &denoised_buffer_params, RenderBuffers *render_buffers, int num_samples, bool allow_inplace_modification, float2 pixel_jitter) override
DenoiserTypeMask denoisers
#define CCL_NAMESPACE_END
int context(const bContext *C, const char *member, bContextDataResult *result)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float