Fix build error on Windows 32 bit.
[blender-staging.git] / intern / cycles / kernel / svm / svm_image.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 svm_image_texture(KernelGlobals *kg, int id, float x, float y, uint srgb, uint use_alpha)
20 {
21         float4 r = kernel_tex_image_interp(kg, id, x, y);
22         const float alpha = r.w;
23
24         if(use_alpha && alpha != 1.0f && alpha != 0.0f) {
25                 r /= alpha;
26                 const int texture_type = kernel_tex_type(id);
27                 if(texture_type == IMAGE_DATA_TYPE_BYTE4 ||
28                    texture_type == IMAGE_DATA_TYPE_BYTE)
29                 {
30                         r = min(r, make_float4(1.0f, 1.0f, 1.0f, 1.0f));
31                 }
32                 r.w = alpha;
33         }
34
35         if(srgb) {
36                 r = color_srgb_to_scene_linear_v4(r);
37         }
38
39         return r;
40 }
41
42 /* Remap coordnate from 0..1 box to -1..-1 */
43 ccl_device_inline float3 texco_remap_square(float3 co)
44 {
45         return (co - make_float3(0.5f, 0.5f, 0.5f)) * 2.0f;
46 }
47
48 ccl_device void svm_node_tex_image(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node)
49 {
50         uint id = node.y;
51         uint co_offset, out_offset, alpha_offset, srgb;
52
53         decode_node_uchar4(node.z, &co_offset, &out_offset, &alpha_offset, &srgb);
54
55         float3 co = stack_load_float3(stack, co_offset);
56         float2 tex_co;
57         uint use_alpha = stack_valid(alpha_offset);
58         if(node.w == NODE_IMAGE_PROJ_SPHERE) {
59                 co = texco_remap_square(co);
60                 tex_co = map_to_sphere(co);
61         }
62         else if(node.w == NODE_IMAGE_PROJ_TUBE) {
63                 co = texco_remap_square(co);
64                 tex_co = map_to_tube(co);
65         }
66         else {
67                 tex_co = make_float2(co.x, co.y);
68         }
69         float4 f = svm_image_texture(kg, id, tex_co.x, tex_co.y, srgb, use_alpha);
70
71         if(stack_valid(out_offset))
72                 stack_store_float3(stack, out_offset, make_float3(f.x, f.y, f.z));
73         if(stack_valid(alpha_offset))
74                 stack_store_float(stack, alpha_offset, f.w);
75 }
76
77 ccl_device void svm_node_tex_image_box(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node)
78 {
79         /* get object space normal */
80         float3 N = sd->N;
81
82         N = sd->N;
83         object_inverse_normal_transform(kg, sd, &N);
84
85         /* project from direction vector to barycentric coordinates in triangles */
86         float3 signed_N = N;
87
88         N.x = fabsf(N.x);
89         N.y = fabsf(N.y);
90         N.z = fabsf(N.z);
91
92         N /= (N.x + N.y + N.z);
93
94         /* basic idea is to think of this as a triangle, each corner representing
95          * one of the 3 faces of the cube. in the corners we have single textures,
96          * in between we blend between two textures, and in the middle we a blend
97          * between three textures.
98          *
99          * the Nxyz values are the barycentric coordinates in an equilateral
100          * triangle, which in case of blending, in the middle has a smaller
101          * equilateral triangle where 3 textures blend. this divides things into
102          * 7 zones, with an if() test for each zone */
103
104         float3 weight = make_float3(0.0f, 0.0f, 0.0f);
105         float blend = __int_as_float(node.w);
106         float limit = 0.5f*(1.0f + blend);
107
108         /* first test for corners with single texture */
109         if(N.x > limit*(N.x + N.y) && N.x > limit*(N.x + N.z)) {
110                 weight.x = 1.0f;
111         }
112         else if(N.y > limit*(N.x + N.y) && N.y > limit*(N.y + N.z)) {
113                 weight.y = 1.0f;
114         }
115         else if(N.z > limit*(N.x + N.z) && N.z > limit*(N.y + N.z)) {
116                 weight.z = 1.0f;
117         }
118         else if(blend > 0.0f) {
119                 /* in case of blending, test for mixes between two textures */
120                 if(N.z < (1.0f - limit)*(N.y + N.x)) {
121                         weight.x = N.x/(N.x + N.y);
122                         weight.x = saturate((weight.x - 0.5f*(1.0f - blend))/blend);
123                         weight.y = 1.0f - weight.x;
124                 }
125                 else if(N.x < (1.0f - limit)*(N.y + N.z)) {
126                         weight.y = N.y/(N.y + N.z);
127                         weight.y = saturate((weight.y - 0.5f*(1.0f - blend))/blend);
128                         weight.z = 1.0f - weight.y;
129                 }
130                 else if(N.y < (1.0f - limit)*(N.x + N.z)) {
131                         weight.x = N.x/(N.x + N.z);
132                         weight.x = saturate((weight.x - 0.5f*(1.0f - blend))/blend);
133                         weight.z = 1.0f - weight.x;
134                 }
135                 else {
136                         /* last case, we have a mix between three */
137                         weight.x = ((2.0f - limit)*N.x + (limit - 1.0f))/(2.0f*limit - 1.0f);
138                         weight.y = ((2.0f - limit)*N.y + (limit - 1.0f))/(2.0f*limit - 1.0f);
139                         weight.z = ((2.0f - limit)*N.z + (limit - 1.0f))/(2.0f*limit - 1.0f);
140                 }
141         }
142         else {
143                 /* Desperate mode, no valid choice anyway, fallback to one side.*/
144                 weight.x = 1.0f;
145         }
146
147         /* now fetch textures */
148         uint co_offset, out_offset, alpha_offset, srgb;
149         decode_node_uchar4(node.z, &co_offset, &out_offset, &alpha_offset, &srgb);
150
151         float3 co = stack_load_float3(stack, co_offset);
152         uint id = node.y;
153
154         float4 f = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
155         uint use_alpha = stack_valid(alpha_offset);
156
157         /* Map so that no textures are flipped, rotation is somewhat arbitrary. */
158         if(weight.x > 0.0f) {
159                 float2 uv = make_float2((signed_N.x < 0.0f)? 1.0f - co.y: co.y, co.z);
160                 f += weight.x*svm_image_texture(kg, id, uv.x, uv.y, srgb, use_alpha);
161         }
162         if(weight.y > 0.0f) {
163                 float2 uv = make_float2((signed_N.y > 0.0f)? 1.0f - co.x: co.x, co.z);
164                 f += weight.y*svm_image_texture(kg, id, uv.x, uv.y, srgb, use_alpha);
165         }
166         if(weight.z > 0.0f) {
167                 float2 uv = make_float2((signed_N.z > 0.0f)? 1.0f - co.y: co.y, co.x);
168                 f += weight.z*svm_image_texture(kg, id, uv.x, uv.y, srgb, use_alpha);
169         }
170
171         if(stack_valid(out_offset))
172                 stack_store_float3(stack, out_offset, make_float3(f.x, f.y, f.z));
173         if(stack_valid(alpha_offset))
174                 stack_store_float(stack, alpha_offset, f.w);
175 }
176
177 ccl_device void svm_node_tex_environment(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node)
178 {
179         uint id = node.y;
180         uint co_offset, out_offset, alpha_offset, srgb;
181         uint projection = node.w;
182
183         decode_node_uchar4(node.z, &co_offset, &out_offset, &alpha_offset, &srgb);
184
185         float3 co = stack_load_float3(stack, co_offset);
186         float2 uv;
187
188         co = safe_normalize(co);
189
190         if(projection == 0)
191                 uv = direction_to_equirectangular(co);
192         else
193                 uv = direction_to_mirrorball(co);
194
195         uint use_alpha = stack_valid(alpha_offset);
196         float4 f = svm_image_texture(kg, id, uv.x, uv.y, srgb, use_alpha);
197
198         if(stack_valid(out_offset))
199                 stack_store_float3(stack, out_offset, make_float3(f.x, f.y, f.z));
200         if(stack_valid(alpha_offset))
201                 stack_store_float(stack, alpha_offset, f.w);
202 }
203
204 CCL_NAMESPACE_END
205