Code refactor: move more memory allocation logic into device API.
[blender.git] / intern / cycles / render / buffers.h
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 #ifndef __BUFFERS_H__
18 #define __BUFFERS_H__
19
20 #include "device/device_memory.h"
21
22 #include "render/film.h"
23
24 #include "kernel/kernel_types.h"
25
26 #include "util/util_half.h"
27 #include "util/util_string.h"
28 #include "util/util_thread.h"
29 #include "util/util_types.h"
30
31 CCL_NAMESPACE_BEGIN
32
33 class Device;
34 struct DeviceDrawParams;
35 struct float4;
36
37 /* Buffer Parameters
38  * Size of render buffer and how it fits in the full image (border render). */
39
40 class BufferParams {
41 public:
42         /* width/height of the physical buffer */
43         int width;
44         int height;
45
46         /* offset into and width/height of the full buffer */
47         int full_x;
48         int full_y;
49         int full_width;
50         int full_height;
51
52         /* passes */
53         array<Pass> passes;
54         bool denoising_data_pass;
55         /* If only some light path types should be denoised, an additional pass is needed. */
56         bool denoising_clean_pass;
57
58         /* functions */
59         BufferParams();
60
61         void get_offset_stride(int& offset, int& stride);
62         bool modified(const BufferParams& params);
63         void add_pass(PassType type);
64         int get_passes_size();
65         int get_denoising_offset();
66 };
67
68 /* Render Buffers */
69
70 class RenderBuffers {
71 public:
72         /* buffer parameters */
73         BufferParams params;
74
75         /* float buffer */
76         device_vector<float> buffer;
77
78         explicit RenderBuffers(Device *device);
79         ~RenderBuffers();
80
81         void reset(BufferParams& params);
82         void zero();
83
84         bool copy_from_device();
85         bool get_pass_rect(PassType type, float exposure, int sample, int components, float *pixels);
86         bool get_denoising_pass_rect(int offset, float exposure, int sample, int components, float *pixels);
87 };
88
89 /* Display Buffer
90  *
91  * The buffer used for drawing during render, filled by converting the render
92  * buffers to byte of half float storage */
93
94 class DisplayBuffer {
95 public:
96         /* buffer parameters */
97         BufferParams params;
98         /* dimensions for how much of the buffer is actually ready for display.
99          * with progressive render we can be using only a subset of the buffer.
100          * if these are zero, it means nothing can be drawn yet */
101         int draw_width, draw_height;
102         /* draw alpha channel? */
103         bool transparent;
104         /* use half float? */
105         bool half_float;
106         /* byte buffer for converted result */
107         device_pixels<uchar4> rgba_byte;
108         device_pixels<half4> rgba_half;
109
110         DisplayBuffer(Device *device, bool linear = false);
111         ~DisplayBuffer();
112
113         void reset(BufferParams& params);
114         void write(const string& filename);
115
116         void draw_set(int width, int height);
117         void draw(Device *device, const DeviceDrawParams& draw_params);
118         bool draw_ready();
119 };
120
121 /* Render Tile
122  * Rendering task on a buffer */
123
124 class RenderTile {
125 public:
126         typedef enum { PATH_TRACE, DENOISE } Task;
127
128         Task task;
129         int x, y, w, h;
130         int start_sample;
131         int num_samples;
132         int sample;
133         int resolution;
134         int offset;
135         int stride;
136         int tile_index;
137
138         device_ptr buffer;
139
140         RenderBuffers *buffers;
141
142         RenderTile();
143 };
144
145 CCL_NAMESPACE_END
146
147 #endif /* __BUFFERS_H__ */
148