Cycles: change __device and similar qualifiers to ccl_device in kernel code.
[blender.git] / intern / cycles / kernel / svm / svm_geometry.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 /* Geometry Node */
20
21 ccl_device void svm_node_geometry(KernelGlobals *kg, ShaderData *sd, float *stack, uint type, uint out_offset)
22 {
23         float3 data;
24
25         switch(type) {
26                 case NODE_GEOM_P: data = sd->P; break;
27                 case NODE_GEOM_N: data = sd->N; break;
28 #ifdef __DPDU__
29                 case NODE_GEOM_T: data = primitive_tangent(kg, sd); break;
30 #endif
31                 case NODE_GEOM_I: data = sd->I; break;
32                 case NODE_GEOM_Ng: data = sd->Ng; break;
33 #ifdef __UV__
34                 case NODE_GEOM_uv: data = make_float3(sd->u, sd->v, 0.0f); break;
35 #endif
36         }
37
38         stack_store_float3(stack, out_offset, data);
39 }
40
41 ccl_device void svm_node_geometry_bump_dx(KernelGlobals *kg, ShaderData *sd, float *stack, uint type, uint out_offset)
42 {
43 #ifdef __RAY_DIFFERENTIALS__
44         float3 data;
45
46         switch(type) {
47                 case NODE_GEOM_P: data = sd->P + sd->dP.dx; break;
48                 case NODE_GEOM_uv: data = make_float3(sd->u + sd->du.dx, sd->v + sd->dv.dx, 0.0f); break;
49                 default: svm_node_geometry(kg, sd, stack, type, out_offset); return;
50         }
51
52         stack_store_float3(stack, out_offset, data);
53 #else
54         svm_node_geometry(kg, sd, stack, type, out_offset);
55 #endif
56 }
57
58 ccl_device void svm_node_geometry_bump_dy(KernelGlobals *kg, ShaderData *sd, float *stack, uint type, uint out_offset)
59 {
60 #ifdef __RAY_DIFFERENTIALS__
61         float3 data;
62
63         switch(type) {
64                 case NODE_GEOM_P: data = sd->P + sd->dP.dy; break;
65                 case NODE_GEOM_uv: data = make_float3(sd->u + sd->du.dy, sd->v + sd->dv.dy, 0.0f); break;
66                 default: svm_node_geometry(kg, sd, stack, type, out_offset); return;
67         }
68
69         stack_store_float3(stack, out_offset, data);
70 #else
71         svm_node_geometry(kg, sd, stack, type, out_offset);
72 #endif
73 }
74
75 /* Object Info */
76
77 ccl_device void svm_node_object_info(KernelGlobals *kg, ShaderData *sd, float *stack, uint type, uint out_offset)
78 {
79         float data;
80
81         switch(type) {
82                 case NODE_INFO_OB_LOCATION: {
83                         stack_store_float3(stack, out_offset, object_location(kg, sd));
84                         return;
85                 }
86                 case NODE_INFO_OB_INDEX: data = object_pass_id(kg, sd->object); break;
87                 case NODE_INFO_MAT_INDEX: data = shader_pass_id(kg, sd); break;
88                 case NODE_INFO_OB_RANDOM: data = object_random_number(kg, sd->object); break;
89                 default: data = 0.0f; break;
90         }
91
92         stack_store_float(stack, out_offset, data);
93 }
94
95 /* Particle Info */
96
97 ccl_device void svm_node_particle_info(KernelGlobals *kg, ShaderData *sd, float *stack, uint type, uint out_offset)
98 {
99         switch(type) {
100                 case NODE_INFO_PAR_INDEX: {
101                         uint particle_id = object_particle_id(kg, sd->object);
102                         stack_store_float(stack, out_offset, particle_index(kg, particle_id));
103                         break;
104                 }
105                 case NODE_INFO_PAR_AGE: {
106                         uint particle_id = object_particle_id(kg, sd->object);
107                         stack_store_float(stack, out_offset, particle_age(kg, particle_id));
108                         break;
109                 }
110                 case NODE_INFO_PAR_LIFETIME: {
111                         uint particle_id = object_particle_id(kg, sd->object);
112                         stack_store_float(stack, out_offset, particle_lifetime(kg, particle_id));
113                         break;
114                 }
115                 case NODE_INFO_PAR_LOCATION: {
116                         uint particle_id = object_particle_id(kg, sd->object);
117                         stack_store_float3(stack, out_offset, particle_location(kg, particle_id));
118                         break;
119                 }
120                 #if 0   /* XXX float4 currently not supported in SVM stack */
121                 case NODE_INFO_PAR_ROTATION: {
122                         uint particle_id = object_particle_id(kg, sd->object);
123                         stack_store_float4(stack, out_offset, particle_rotation(kg, particle_id));
124                         break;
125                 }
126                 #endif
127                 case NODE_INFO_PAR_SIZE: {
128                         uint particle_id = object_particle_id(kg, sd->object);
129                         stack_store_float(stack, out_offset, particle_size(kg, particle_id));
130                         break;
131                 }
132                 case NODE_INFO_PAR_VELOCITY: {
133                         uint particle_id = object_particle_id(kg, sd->object);
134                         stack_store_float3(stack, out_offset, particle_velocity(kg, particle_id));
135                         break;
136                 }
137                 case NODE_INFO_PAR_ANGULAR_VELOCITY: {
138                         uint particle_id = object_particle_id(kg, sd->object);
139                         stack_store_float3(stack, out_offset, particle_angular_velocity(kg, particle_id));
140                         break;
141                 }
142         }
143 }
144
145 #ifdef __HAIR__
146
147 /* Hair Info */
148
149 ccl_device void svm_node_hair_info(KernelGlobals *kg, ShaderData *sd, float *stack, uint type, uint out_offset)
150 {
151         float data;
152         float3 data3;
153
154         switch(type) {
155                 case NODE_INFO_CURVE_IS_STRAND: {
156                         data = (sd->segment != ~0);
157                         stack_store_float(stack, out_offset, data);
158                         break;
159                 }
160                 case NODE_INFO_CURVE_INTERCEPT:
161                         break; /* handled as attribute */
162                 case NODE_INFO_CURVE_THICKNESS: {
163                         data = curve_thickness(kg, sd);
164                         stack_store_float(stack, out_offset, data);
165                         break;
166                 }
167                 /*case NODE_INFO_CURVE_FADE: {
168                         data = sd->curve_transparency;
169                         stack_store_float(stack, out_offset, data);
170                         break;
171                 }*/
172                 case NODE_INFO_CURVE_TANGENT_NORMAL: {
173                         data3 = curve_tangent_normal(kg, sd);
174                         stack_store_float3(stack, out_offset, data3);
175                         break;
176                 }
177         }
178 }
179 #endif
180
181 CCL_NAMESPACE_END
182