Cycles: Code cleanup, spaces around keywords
[blender-staging.git] / intern / cycles / kernel / svm / svm_wireframe.h
index 7262a7904bb9ecc82561b8316ea0571f80112396..eaa17f8ce57d5ffa688a9c1df3be4d84280768d1 100644 (file)
@@ -34,27 +34,24 @@ CCL_NAMESPACE_BEGIN
 
 /* Wireframe Node */
 
-ccl_device void svm_node_wireframe(KernelGlobals *kg, ShaderData *sd, float *stack, uint in_size, uint out_fac, uint use_pixel_size)
+ccl_device float wireframe(KernelGlobals *kg,
+                           ShaderData *sd,
+                           float size,
+                           int pixel_size,
+                           float3 *P)
 {
-       /* Input Data */
-       float size = stack_load_float(stack, in_size);
-       int pixel_size = (int)use_pixel_size;
-       
-       /* Output */
-       float f = 0.0f;
-
-       /* Calculate wireframe */
 #ifdef __HAIR__
-       if (sd->prim != PRIM_NONE && sd->type & PRIMITIVE_ALL_TRIANGLE) {
+       if(sd->prim != PRIM_NONE && sd->type & PRIMITIVE_ALL_TRIANGLE)
 #else
-       if (sd->prim != PRIM_NONE) {
+       if(sd->prim != PRIM_NONE)
 #endif
+       {
                float3 Co[3];
                float pixelwidth = 1.0f;
 
                /* Triangles */
                int np = 3;
-               
+
                if(sd->type & PRIMITIVE_TRIANGLE)
                        triangle_vertices(kg, sd->prim, Co);
                else
@@ -65,7 +62,7 @@ ccl_device void svm_node_wireframe(KernelGlobals *kg, ShaderData *sd, float *sta
                        object_position_transform(kg, sd, &Co[1]);
                        object_position_transform(kg, sd, &Co[2]);
                }
-               
+
                if(pixel_size) {
                        // Project the derivatives of P to the viewing plane defined
                        // by I so we have a measure of how big is a pixel at this point
@@ -74,25 +71,54 @@ ccl_device void svm_node_wireframe(KernelGlobals *kg, ShaderData *sd, float *sta
                        // Take the average of both axis' length
                        pixelwidth = (pixelwidth_x + pixelwidth_y) * 0.5f;
                }
-               
+
                // Use half the width as the neighbor face will render the
                // other half. And take the square for fast comparison
                pixelwidth *= 0.5f * size;
                pixelwidth *= pixelwidth;
-               for (int i = 0; i < np; i++) {
+               for(int i = 0; i < np; i++) {
                        int i2 = i ? i - 1 : np - 1;
-                       float3 dir = sd->P - Co[i];
+                       float3 dir = *P - Co[i];
                        float3 edge = Co[i] - Co[i2];
                        float3 crs = cross(edge, dir);
                        // At this point dot(crs, crs) / dot(edge, edge) is
                        // the square of area / length(edge) == square of the
                        // distance to the edge.
-                       if (dot(crs, crs) < (dot(edge, edge) * pixelwidth))
-                               f = 1.0f;
+                       if(dot(crs, crs) < (dot(edge, edge) * pixelwidth))
+                               return 1.0f;
                }
        }
-       
-       if (stack_valid(out_fac))
+       return 0.0f;
+}
+
+ccl_device void svm_node_wireframe(KernelGlobals *kg,
+                                   ShaderData *sd,
+                                   float *stack,
+                                   uint4 node)
+{
+       uint in_size = node.y;
+       uint out_fac = node.z;
+       uint use_pixel_size, bump_offset;
+       decode_node_uchar4(node.w, &use_pixel_size, &bump_offset, NULL, NULL);
+
+       /* Input Data */
+       float size = stack_load_float(stack, in_size);
+       int pixel_size = (int)use_pixel_size;
+
+       /* Calculate wireframe */
+       float f = wireframe(kg, sd, size, pixel_size, &sd->P);
+
+       /* TODO(sergey): Think of faster way to calculate derivatives. */
+       if(bump_offset == NODE_BUMP_OFFSET_DX) {
+               float3 Px = sd->P - sd->dP.dx;
+               f += (f - wireframe(kg, sd, size, pixel_size, &Px)) / len(sd->dP.dx);
+       }
+       else if(bump_offset == NODE_BUMP_OFFSET_DY) {
+               float3 Py = sd->P - sd->dP.dy;
+               f += (f - wireframe(kg, sd, size, pixel_size, &Py)) / len(sd->dP.dy);
+       }
+
+       if(stack_valid(out_fac))
                stack_store_float(stack, out_fac, f);
 }