Cycles / Sky Texture:
[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_memory.h"
21
22 #include "film.h"
23
24 #include "kernel_types.h"
25
26 #include "util_string.h"
27 #include "util_thread.h"
28 #include "util_types.h"
29
30 CCL_NAMESPACE_BEGIN
31
32 class Device;
33 struct float4;
34
35 /* Buffer Parameters
36  * Size of render buffer and how it fits in the full image (border render). */
37
38 class BufferParams {
39 public:
40         /* width/height of the physical buffer */
41         int width;
42         int height;
43
44         /* offset into and width/height of the full buffer */
45         int full_x;
46         int full_y;
47         int full_width;
48         int full_height;
49
50         /* passes */
51         vector<Pass> passes;
52
53         /* functions */
54         BufferParams();
55
56         void get_offset_stride(int& offset, int& stride);
57         bool modified(const BufferParams& params);
58         void add_pass(PassType type);
59         int get_passes_size();
60 };
61
62 /* Render Buffers */
63
64 class RenderBuffers {
65 public:
66         /* buffer parameters */
67         BufferParams params;
68
69         /* float buffer */
70         device_vector<float> buffer;
71         /* random number generator state */
72         device_vector<uint> rng_state;
73
74         RenderBuffers(Device *device);
75         ~RenderBuffers();
76
77         void reset(Device *device, BufferParams& params);
78
79         bool copy_from_device();
80         bool get_pass_rect(PassType type, float exposure, int sample, int components, float *pixels);
81
82 protected:
83         void device_free();
84
85         Device *device;
86 };
87
88 /* Display Buffer
89  *
90  * The buffer used for drawing during render, filled by tonemapping the render
91  * buffers and converting to uchar4 storage. */
92
93 class DisplayBuffer {
94 public:
95         /* buffer parameters */
96         BufferParams params;
97         /* dimensions for how much of the buffer is actually ready for display.
98          * with progressive render we can be using only a subset of the buffer.
99          * if these are zero, it means nothing can be drawn yet */
100         int draw_width, draw_height;
101         /* draw alpha channel? */
102         bool transparent;
103         /* byte buffer for tonemapped result */
104         device_vector<uchar4> rgba;
105
106         DisplayBuffer(Device *device);
107         ~DisplayBuffer();
108
109         void reset(Device *device, BufferParams& params);
110         void write(Device *device, const string& filename);
111
112         void draw_set(int width, int height);
113         void draw(Device *device);
114         bool draw_ready();
115
116 protected:
117         void device_free();
118
119         Device *device;
120 };
121
122 /* Render Tile
123  * Rendering task on a buffer */
124
125 class RenderTile {
126 public:
127         int x, y, w, h;
128         int start_sample;
129         int num_samples;
130         int sample;
131         int resolution;
132         int offset;
133         int stride;
134
135         device_ptr buffer;
136         device_ptr rng_state;
137         device_ptr rgba;
138
139         RenderBuffers *buffers;
140
141         RenderTile();
142 };
143
144 CCL_NAMESPACE_END
145
146 #endif /* __BUFFERS_H__ */
147