code cleanup: remove unused and unsupported functions from libmv-capi
[blender.git] / intern / cycles / kernel / svm / svm_attribute.h
1 /*
2  * Copyright 2011, Blender Foundation.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  */
18
19 CCL_NAMESPACE_BEGIN
20
21 /* Attribute Node */
22
23 __device void svm_node_attr_init(KernelGlobals *kg, ShaderData *sd,
24         uint4 node, NodeAttributeType *type,
25         NodeAttributeType *mesh_type, AttributeElement *elem, int *offset, uint *out_offset)
26 {
27         if(sd->object != ~0) {
28                 /* find attribute by unique id */
29                 uint id = node.y;
30                 uint attr_offset = sd->object*kernel_data.bvh.attributes_map_stride;
31 #ifdef __HAIR__
32                 attr_offset = (sd->segment == ~0)? attr_offset: attr_offset + ATTR_PRIM_CURVE;
33 #endif
34                 uint4 attr_map = kernel_tex_fetch(__attributes_map, attr_offset);
35                 
36                 while(attr_map.x != id) {
37                         attr_offset += ATTR_PRIM_TYPES;
38                         attr_map = kernel_tex_fetch(__attributes_map, attr_offset);
39                 }
40
41                 /* return result */
42                 *elem = (AttributeElement)attr_map.y;
43                 *offset = as_int(attr_map.z);
44                 *mesh_type = (NodeAttributeType)attr_map.w;
45         }
46         else {
47                 /* background */
48                 *elem = ATTR_ELEMENT_NONE;
49                 *offset = 0;
50                 *mesh_type = (NodeAttributeType)node.w;
51         }
52
53         *out_offset = node.z;
54         *type = (NodeAttributeType)node.w;
55 }
56
57 __device void svm_node_attr(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node)
58 {
59         NodeAttributeType type, mesh_type;
60         AttributeElement elem;
61         uint out_offset;
62         int offset;
63
64         svm_node_attr_init(kg, sd, node, &type, &mesh_type, &elem, &offset, &out_offset);
65
66         /* fetch and store attribute */
67         if(type == NODE_ATTR_FLOAT) {
68                 if(mesh_type == NODE_ATTR_FLOAT) {
69                         float f = primitive_attribute_float(kg, sd, elem, offset, NULL, NULL);
70                         stack_store_float(stack, out_offset, f);
71                 }
72                 else {
73                         float3 f = primitive_attribute_float3(kg, sd, elem, offset, NULL, NULL);
74                         stack_store_float(stack, out_offset, average(f));
75                 }
76         }
77         else {
78                 if(mesh_type == NODE_ATTR_FLOAT3) {
79                         float3 f = primitive_attribute_float3(kg, sd, elem, offset, NULL, NULL);
80                         stack_store_float3(stack, out_offset, f);
81                 }
82                 else {
83                         float f = primitive_attribute_float(kg, sd, elem, offset, NULL, NULL);
84                         stack_store_float3(stack, out_offset, make_float3(f, f, f));
85                 }
86         }
87 }
88
89 __device void svm_node_attr_bump_dx(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node)
90 {
91         NodeAttributeType type, mesh_type;
92         AttributeElement elem;
93         uint out_offset;
94         int offset;
95
96         svm_node_attr_init(kg, sd, node, &type, &mesh_type, &elem, &offset, &out_offset);
97
98         /* fetch and store attribute */
99         if(type == NODE_ATTR_FLOAT) {
100                 if(mesh_type == NODE_ATTR_FLOAT) {
101                         float dx;
102                         float f = primitive_attribute_float(kg, sd, elem, offset, &dx, NULL);
103                         stack_store_float(stack, out_offset, f+dx);
104                 }
105                 else {
106                         float3 dx;
107                         float3 f = primitive_attribute_float3(kg, sd, elem, offset, &dx, NULL);
108                         stack_store_float(stack, out_offset, average(f+dx));
109                 }
110         }
111         else {
112                 if(mesh_type == NODE_ATTR_FLOAT3) {
113                         float3 dx;
114                         float3 f = primitive_attribute_float3(kg, sd, elem, offset, &dx, NULL);
115                         stack_store_float3(stack, out_offset, f+dx);
116                 }
117                 else {
118                         float dx;
119                         float f = primitive_attribute_float(kg, sd, elem, offset, &dx, NULL);
120                         stack_store_float3(stack, out_offset, make_float3(f+dx, f+dx, f+dx));
121                 }
122         }
123 }
124
125 __device void svm_node_attr_bump_dy(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node)
126 {
127         NodeAttributeType type, mesh_type;
128         AttributeElement elem;
129         uint out_offset;
130         int offset;
131
132         svm_node_attr_init(kg, sd, node, &type, &mesh_type, &elem, &offset, &out_offset);
133
134         /* fetch and store attribute */
135         if(type == NODE_ATTR_FLOAT) {
136                 if(mesh_type == NODE_ATTR_FLOAT) {
137                         float dy;
138                         float f = primitive_attribute_float(kg, sd, elem, offset, NULL, &dy);
139                         stack_store_float(stack, out_offset, f+dy);
140                 }
141                 else {
142                         float3 dy;
143                         float3 f = primitive_attribute_float3(kg, sd, elem, offset, NULL, &dy);
144                         stack_store_float(stack, out_offset, average(f+dy));
145                 }
146         }
147         else {
148                 if(mesh_type == NODE_ATTR_FLOAT3) {
149                         float3 dy;
150                         float3 f = primitive_attribute_float3(kg, sd, elem, offset, NULL, &dy);
151                         stack_store_float3(stack, out_offset, f+dy);
152                 }
153                 else {
154                         float dy;
155                         float f = primitive_attribute_float(kg, sd, elem, offset, NULL, &dy);
156                         stack_store_float3(stack, out_offset, make_float3(f+dy, f+dy, f+dy));
157                 }
158         }
159 }
160
161 CCL_NAMESPACE_END
162