GPencil: Create blank texture only once by engine
[blender.git] / intern / cycles / render / buffers.cpp
1 /*
2  * Copyright 2011-2013 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <stdlib.h>
18
19 #include "render/buffers.h"
20 #include "device/device.h"
21
22 #include "util/util_foreach.h"
23 #include "util/util_hash.h"
24 #include "util/util_math.h"
25 #include "util/util_opengl.h"
26 #include "util/util_time.h"
27 #include "util/util_types.h"
28
29 CCL_NAMESPACE_BEGIN
30
31 /* Buffer Params */
32
33 BufferParams::BufferParams()
34 {
35   width = 0;
36   height = 0;
37
38   full_x = 0;
39   full_y = 0;
40   full_width = 0;
41   full_height = 0;
42
43   denoising_data_pass = false;
44   denoising_clean_pass = false;
45   denoising_prefiltered_pass = false;
46 }
47
48 void BufferParams::get_offset_stride(int &offset, int &stride)
49 {
50   offset = -(full_x + full_y * width);
51   stride = width;
52 }
53
54 bool BufferParams::modified(const BufferParams &params)
55 {
56   return !(full_x == params.full_x && full_y == params.full_y && width == params.width &&
57            height == params.height && full_width == params.full_width &&
58            full_height == params.full_height && Pass::equals(passes, params.passes));
59 }
60
61 int BufferParams::get_passes_size()
62 {
63   int size = 0;
64
65   for (size_t i = 0; i < passes.size(); i++)
66     size += passes[i].components;
67
68   if (denoising_data_pass) {
69     size += DENOISING_PASS_SIZE_BASE;
70     if (denoising_clean_pass)
71       size += DENOISING_PASS_SIZE_CLEAN;
72     if (denoising_prefiltered_pass)
73       size += DENOISING_PASS_SIZE_PREFILTERED;
74   }
75
76   return align_up(size, 4);
77 }
78
79 int BufferParams::get_denoising_offset()
80 {
81   int offset = 0;
82
83   for (size_t i = 0; i < passes.size(); i++)
84     offset += passes[i].components;
85
86   return offset;
87 }
88
89 int BufferParams::get_denoising_prefiltered_offset()
90 {
91   assert(denoising_prefiltered_pass);
92
93   int offset = get_denoising_offset();
94
95   offset += DENOISING_PASS_SIZE_BASE;
96   if (denoising_clean_pass) {
97     offset += DENOISING_PASS_SIZE_CLEAN;
98   }
99
100   return offset;
101 }
102
103 /* Render Buffer Task */
104
105 RenderTile::RenderTile()
106 {
107   x = 0;
108   y = 0;
109   w = 0;
110   h = 0;
111
112   sample = 0;
113   start_sample = 0;
114   num_samples = 0;
115   resolution = 0;
116
117   offset = 0;
118   stride = 0;
119
120   buffer = 0;
121
122   buffers = NULL;
123 }
124
125 /* Render Buffers */
126
127 RenderBuffers::RenderBuffers(Device *device)
128     : buffer(device, "RenderBuffers", MEM_READ_WRITE),
129       map_neighbor_copied(false),
130       render_time(0.0f)
131 {
132 }
133
134 RenderBuffers::~RenderBuffers()
135 {
136   buffer.free();
137 }
138
139 void RenderBuffers::reset(BufferParams &params_)
140 {
141   params = params_;
142
143   /* re-allocate buffer */
144   buffer.alloc(params.width * params.height * params.get_passes_size());
145   buffer.zero_to_device();
146 }
147
148 void RenderBuffers::zero()
149 {
150   buffer.zero_to_device();
151 }
152
153 bool RenderBuffers::copy_from_device()
154 {
155   if (!buffer.device_pointer)
156     return false;
157
158   buffer.copy_from_device(0, params.width * params.get_passes_size(), params.height);
159
160   return true;
161 }
162
163 bool RenderBuffers::get_denoising_pass_rect(
164     int type, float exposure, int sample, int components, float *pixels)
165 {
166   if (buffer.data() == NULL) {
167     return false;
168   }
169
170   float scale = 1.0f;
171   float alpha_scale = 1.0f / sample;
172   if (type == DENOISING_PASS_PREFILTERED_COLOR || type == DENOISING_PASS_CLEAN ||
173       type == DENOISING_PASS_PREFILTERED_INTENSITY) {
174     scale *= exposure;
175   }
176   else if (type == DENOISING_PASS_PREFILTERED_VARIANCE) {
177     scale *= exposure * exposure * (sample - 1);
178   }
179
180   int offset;
181   if (type == DENOISING_PASS_CLEAN) {
182     /* The clean pass isn't changed by prefiltering, so we use the original one there. */
183     offset = type + params.get_denoising_offset();
184     scale /= sample;
185   }
186   else if (type == DENOISING_PASS_PREFILTERED_COLOR && !params.denoising_prefiltered_pass) {
187     /* If we're not saving the prefiltering result, return the original noisy pass. */
188     offset = params.get_denoising_offset() + DENOISING_PASS_COLOR;
189     scale /= sample;
190   }
191   else {
192     offset = type + params.get_denoising_prefiltered_offset();
193   }
194
195   int pass_stride = params.get_passes_size();
196   int size = params.width * params.height;
197
198   float *in = buffer.data() + offset;
199
200   if (components == 1) {
201     for (int i = 0; i < size; i++, in += pass_stride, pixels++) {
202       pixels[0] = in[0] * scale;
203     }
204   }
205   else if (components == 3) {
206     for (int i = 0; i < size; i++, in += pass_stride, pixels += 3) {
207       pixels[0] = in[0] * scale;
208       pixels[1] = in[1] * scale;
209       pixels[2] = in[2] * scale;
210     }
211   }
212   else if (components == 4) {
213     /* Since the alpha channel is not involved in denoising, output the Combined alpha channel. */
214     assert(params.passes[0].type == PASS_COMBINED);
215     float *in_combined = buffer.data();
216
217     for (int i = 0; i < size; i++, in += pass_stride, in_combined += pass_stride, pixels += 4) {
218       float3 val = make_float3(in[0], in[1], in[2]);
219       if (type == DENOISING_PASS_PREFILTERED_COLOR && params.denoising_prefiltered_pass) {
220         /* Remove highlight compression from the image. */
221         val = color_highlight_uncompress(val);
222       }
223       pixels[0] = val.x * scale;
224       pixels[1] = val.y * scale;
225       pixels[2] = val.z * scale;
226       pixels[3] = saturate(in_combined[3] * alpha_scale);
227     }
228   }
229   else {
230     return false;
231   }
232
233   return true;
234 }
235
236 bool RenderBuffers::get_pass_rect(
237     PassType type, float exposure, int sample, int components, float *pixels, const string &name)
238 {
239   if (buffer.data() == NULL) {
240     return false;
241   }
242
243   int pass_offset = 0;
244
245   for (size_t j = 0; j < params.passes.size(); j++) {
246     Pass &pass = params.passes[j];
247
248     if (pass.type != type) {
249       pass_offset += pass.components;
250       continue;
251     }
252
253     /* Tell Cryptomatte passes apart by their name. */
254     if (pass.type == PASS_CRYPTOMATTE) {
255       if (pass.name != name) {
256         pass_offset += pass.components;
257         continue;
258       }
259     }
260
261     float *in = buffer.data() + pass_offset;
262     int pass_stride = params.get_passes_size();
263
264     float scale = (pass.filter) ? 1.0f / (float)sample : 1.0f;
265     float scale_exposure = (pass.exposure) ? scale * exposure : scale;
266
267     int size = params.width * params.height;
268
269     if (components == 1 && type == PASS_RENDER_TIME) {
270       /* Render time is not stored by kernel, but measured per tile. */
271       float val = (float)(1000.0 * render_time / (params.width * params.height * sample));
272       for (int i = 0; i < size; i++, pixels++) {
273         pixels[0] = val;
274       }
275     }
276     else if (components == 1) {
277       assert(pass.components == components);
278
279       /* Scalar */
280       if (type == PASS_DEPTH) {
281         for (int i = 0; i < size; i++, in += pass_stride, pixels++) {
282           float f = *in;
283           pixels[0] = (f == 0.0f) ? 1e10f : f * scale_exposure;
284         }
285       }
286       else if (type == PASS_MIST) {
287         for (int i = 0; i < size; i++, in += pass_stride, pixels++) {
288           float f = *in;
289           pixels[0] = saturate(f * scale_exposure);
290         }
291       }
292 #ifdef WITH_CYCLES_DEBUG
293       else if (type == PASS_BVH_TRAVERSED_NODES || type == PASS_BVH_TRAVERSED_INSTANCES ||
294                type == PASS_BVH_INTERSECTIONS || type == PASS_RAY_BOUNCES) {
295         for (int i = 0; i < size; i++, in += pass_stride, pixels++) {
296           float f = *in;
297           pixels[0] = f * scale;
298         }
299       }
300 #endif
301       else {
302         for (int i = 0; i < size; i++, in += pass_stride, pixels++) {
303           float f = *in;
304           pixels[0] = f * scale_exposure;
305         }
306       }
307     }
308     else if (components == 3) {
309       assert(pass.components == 4);
310
311       /* RGBA */
312       if (type == PASS_SHADOW) {
313         for (int i = 0; i < size; i++, in += pass_stride, pixels += 3) {
314           float4 f = make_float4(in[0], in[1], in[2], in[3]);
315           float invw = (f.w > 0.0f) ? 1.0f / f.w : 1.0f;
316
317           pixels[0] = f.x * invw;
318           pixels[1] = f.y * invw;
319           pixels[2] = f.z * invw;
320         }
321       }
322       else if (pass.divide_type != PASS_NONE) {
323         /* RGB lighting passes that need to divide out color */
324         pass_offset = 0;
325         for (size_t k = 0; k < params.passes.size(); k++) {
326           Pass &color_pass = params.passes[k];
327           if (color_pass.type == pass.divide_type)
328             break;
329           pass_offset += color_pass.components;
330         }
331
332         float *in_divide = buffer.data() + pass_offset;
333
334         for (int i = 0; i < size; i++, in += pass_stride, in_divide += pass_stride, pixels += 3) {
335           float3 f = make_float3(in[0], in[1], in[2]);
336           float3 f_divide = make_float3(in_divide[0], in_divide[1], in_divide[2]);
337
338           f = safe_divide_even_color(f * exposure, f_divide);
339
340           pixels[0] = f.x;
341           pixels[1] = f.y;
342           pixels[2] = f.z;
343         }
344       }
345       else {
346         /* RGB/vector */
347         for (int i = 0; i < size; i++, in += pass_stride, pixels += 3) {
348           float3 f = make_float3(in[0], in[1], in[2]);
349
350           pixels[0] = f.x * scale_exposure;
351           pixels[1] = f.y * scale_exposure;
352           pixels[2] = f.z * scale_exposure;
353         }
354       }
355     }
356     else if (components == 4) {
357       assert(pass.components == components);
358
359       /* RGBA */
360       if (type == PASS_SHADOW) {
361         for (int i = 0; i < size; i++, in += pass_stride, pixels += 4) {
362           float4 f = make_float4(in[0], in[1], in[2], in[3]);
363           float invw = (f.w > 0.0f) ? 1.0f / f.w : 1.0f;
364
365           pixels[0] = f.x * invw;
366           pixels[1] = f.y * invw;
367           pixels[2] = f.z * invw;
368           pixels[3] = 1.0f;
369         }
370       }
371       else if (type == PASS_MOTION) {
372         /* need to normalize by number of samples accumulated for motion */
373         pass_offset = 0;
374         for (size_t k = 0; k < params.passes.size(); k++) {
375           Pass &color_pass = params.passes[k];
376           if (color_pass.type == PASS_MOTION_WEIGHT)
377             break;
378           pass_offset += color_pass.components;
379         }
380
381         float *in_weight = buffer.data() + pass_offset;
382
383         for (int i = 0; i < size; i++, in += pass_stride, in_weight += pass_stride, pixels += 4) {
384           float4 f = make_float4(in[0], in[1], in[2], in[3]);
385           float w = in_weight[0];
386           float invw = (w > 0.0f) ? 1.0f / w : 0.0f;
387
388           pixels[0] = f.x * invw;
389           pixels[1] = f.y * invw;
390           pixels[2] = f.z * invw;
391           pixels[3] = f.w * invw;
392         }
393       }
394       else if (type == PASS_CRYPTOMATTE) {
395         for (int i = 0; i < size; i++, in += pass_stride, pixels += 4) {
396           float4 f = make_float4(in[0], in[1], in[2], in[3]);
397           /* x and z contain integer IDs, don't rescale them.
398              y and w contain matte weights, they get scaled. */
399           pixels[0] = f.x;
400           pixels[1] = f.y * scale;
401           pixels[2] = f.z;
402           pixels[3] = f.w * scale;
403         }
404       }
405       else {
406         for (int i = 0; i < size; i++, in += pass_stride, pixels += 4) {
407           float4 f = make_float4(in[0], in[1], in[2], in[3]);
408
409           pixels[0] = f.x * scale_exposure;
410           pixels[1] = f.y * scale_exposure;
411           pixels[2] = f.z * scale_exposure;
412
413           /* clamp since alpha might be > 1.0 due to russian roulette */
414           pixels[3] = saturate(f.w * scale);
415         }
416       }
417     }
418
419     return true;
420   }
421
422   return false;
423 }
424
425 /* Display Buffer */
426
427 DisplayBuffer::DisplayBuffer(Device *device, bool linear)
428     : draw_width(0),
429       draw_height(0),
430       transparent(true), /* todo: determine from background */
431       half_float(linear),
432       rgba_byte(device, "display buffer byte"),
433       rgba_half(device, "display buffer half")
434 {
435 }
436
437 DisplayBuffer::~DisplayBuffer()
438 {
439   rgba_byte.free();
440   rgba_half.free();
441 }
442
443 void DisplayBuffer::reset(BufferParams &params_)
444 {
445   draw_width = 0;
446   draw_height = 0;
447
448   params = params_;
449
450   /* allocate display pixels */
451   if (half_float) {
452     rgba_half.alloc_to_device(params.width, params.height);
453   }
454   else {
455     rgba_byte.alloc_to_device(params.width, params.height);
456   }
457 }
458
459 void DisplayBuffer::draw_set(int width, int height)
460 {
461   assert(width <= params.width && height <= params.height);
462
463   draw_width = width;
464   draw_height = height;
465 }
466
467 void DisplayBuffer::draw(Device *device, const DeviceDrawParams &draw_params)
468 {
469   if (draw_width != 0 && draw_height != 0) {
470     device_memory &rgba = (half_float) ? (device_memory &)rgba_half : (device_memory &)rgba_byte;
471
472     device->draw_pixels(rgba,
473                         0,
474                         draw_width,
475                         draw_height,
476                         params.width,
477                         params.height,
478                         params.full_x,
479                         params.full_y,
480                         params.full_width,
481                         params.full_height,
482                         transparent,
483                         draw_params);
484   }
485 }
486
487 bool DisplayBuffer::draw_ready()
488 {
489   return (draw_width != 0 && draw_height != 0);
490 }
491
492 CCL_NAMESPACE_END