ClangFormat: apply to source, most of intern
[blender.git] / intern / cycles / kernel / kernel_film.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 CCL_NAMESPACE_BEGIN
18
19 ccl_device float4 film_map(KernelGlobals *kg, float4 irradiance, float scale)
20 {
21   float exposure = kernel_data.film.exposure;
22   float4 result = irradiance * scale;
23
24   /* conversion to srgb */
25   result.x = color_linear_to_srgb(result.x * exposure);
26   result.y = color_linear_to_srgb(result.y * exposure);
27   result.z = color_linear_to_srgb(result.z * exposure);
28
29   /* clamp since alpha might be > 1.0 due to russian roulette */
30   result.w = saturate(result.w);
31
32   return result;
33 }
34
35 ccl_device uchar4 film_float_to_byte(float4 color)
36 {
37   uchar4 result;
38
39   /* simple float to byte conversion */
40   result.x = (uchar)(saturate(color.x) * 255.0f);
41   result.y = (uchar)(saturate(color.y) * 255.0f);
42   result.z = (uchar)(saturate(color.z) * 255.0f);
43   result.w = (uchar)(saturate(color.w) * 255.0f);
44
45   return result;
46 }
47
48 ccl_device void kernel_film_convert_to_byte(KernelGlobals *kg,
49                                             ccl_global uchar4 *rgba,
50                                             ccl_global float *buffer,
51                                             float sample_scale,
52                                             int x,
53                                             int y,
54                                             int offset,
55                                             int stride)
56 {
57   /* buffer offset */
58   int index = offset + x + y * stride;
59
60   rgba += index;
61   buffer += index * kernel_data.film.pass_stride;
62
63   /* map colors */
64   float4 irradiance = *((ccl_global float4 *)buffer);
65   float4 float_result = film_map(kg, irradiance, sample_scale);
66   uchar4 byte_result = film_float_to_byte(float_result);
67
68   *rgba = byte_result;
69 }
70
71 ccl_device void kernel_film_convert_to_half_float(KernelGlobals *kg,
72                                                   ccl_global uchar4 *rgba,
73                                                   ccl_global float *buffer,
74                                                   float sample_scale,
75                                                   int x,
76                                                   int y,
77                                                   int offset,
78                                                   int stride)
79 {
80   /* buffer offset */
81   int index = offset + x + y * stride;
82
83   ccl_global float4 *in = (ccl_global float4 *)(buffer + index * kernel_data.film.pass_stride);
84   ccl_global half *out = (ccl_global half *)rgba + index * 4;
85
86   float exposure = kernel_data.film.exposure;
87
88   float4 rgba_in = *in;
89
90   if (exposure != 1.0f) {
91     rgba_in.x *= exposure;
92     rgba_in.y *= exposure;
93     rgba_in.z *= exposure;
94   }
95
96   float4_store_half(out, rgba_in, sample_scale);
97 }
98
99 CCL_NAMESPACE_END