Cycles: Make object flag names more obvious that hey are object and not shader
[blender.git] / intern / cycles / kernel / svm / svm_wireframe.h
index 42fe3e8e42908bacc7f5a1bb57ee0ff06c160497..29af11c36b66e0ec7c46c0dd9c1c3bc78cd2e7f5 100644 (file)
@@ -34,16 +34,16 @@ CCL_NAMESPACE_BEGIN
 
 /* Wireframe Node */
 
-ccl_device float wireframe(KernelGlobals *kg,
-                           ShaderData *sd,
-                           float size,
-                           int pixel_size,
-                           float3 *P)
+ccl_device_inline float wireframe(KernelGlobals *kg,
+                                  ShaderData *sd,
+                                  float size,
+                                  int pixel_size,
+                                  float3 *P)
 {
 #ifdef __HAIR__
-       if (sd->prim != PRIM_NONE && sd->type & PRIMITIVE_ALL_TRIANGLE)
+       if(ccl_fetch(sd, prim) != PRIM_NONE && ccl_fetch(sd, type) & PRIMITIVE_ALL_TRIANGLE)
 #else
-       if (sd->prim != PRIM_NONE)
+       if(ccl_fetch(sd, prim) != PRIM_NONE)
 #endif
        {
                float3 Co[3];
@@ -52,12 +52,12 @@ ccl_device float wireframe(KernelGlobals *kg,
                /* Triangles */
                int np = 3;
 
-               if(sd->type & PRIMITIVE_TRIANGLE)
-                       triangle_vertices(kg, sd->prim, Co);
+               if(ccl_fetch(sd, type) & PRIMITIVE_TRIANGLE)
+                       triangle_vertices(kg, ccl_fetch(sd, prim), Co);
                else
-                       motion_triangle_vertices(kg, sd->object, sd->prim, sd->time, Co);
+                       motion_triangle_vertices(kg, ccl_fetch(sd, object), ccl_fetch(sd, prim), ccl_fetch(sd, time), Co);
 
-               if(!(sd->flag & SD_TRANSFORM_APPLIED)) {
+               if(!(ccl_fetch(sd, flag) & SD_OBJECT_TRANSFORM_APPLIED)) {
                        object_position_transform(kg, sd, &Co[0]);
                        object_position_transform(kg, sd, &Co[1]);
                        object_position_transform(kg, sd, &Co[2]);
@@ -66,8 +66,8 @@ ccl_device float wireframe(KernelGlobals *kg,
                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
-                       float pixelwidth_x = len(sd->dP.dx - dot(sd->dP.dx, sd->I) * sd->I);
-                       float pixelwidth_y = len(sd->dP.dy - dot(sd->dP.dy, sd->I) * sd->I);
+                       float pixelwidth_x = len(ccl_fetch(sd, dP).dx - dot(ccl_fetch(sd, dP).dx, ccl_fetch(sd, I)) * ccl_fetch(sd, I));
+                       float pixelwidth_y = len(ccl_fetch(sd, dP).dy - dot(ccl_fetch(sd, dP).dy, ccl_fetch(sd, I)) * ccl_fetch(sd, I));
                        // Take the average of both axis' length
                        pixelwidth = (pixelwidth_x + pixelwidth_y) * 0.5f;
                }
@@ -76,7 +76,7 @@ ccl_device float wireframe(KernelGlobals *kg,
                // 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 = *P - Co[i];
                        float3 edge = Co[i] - Co[i2];
@@ -84,7 +84,7 @@ ccl_device float wireframe(KernelGlobals *kg,
                        // 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))
+                       if(dot(crs, crs) < (dot(edge, edge) * pixelwidth))
                                return 1.0f;
                }
        }
@@ -106,19 +106,30 @@ ccl_device void svm_node_wireframe(KernelGlobals *kg,
        int pixel_size = (int)use_pixel_size;
 
        /* Calculate wireframe */
-       float f = wireframe(kg, sd, size, pixel_size, &sd->P);
+#ifdef __SPLIT_KERNEL__
+       /* TODO(sergey): This is because sd is actually a global space,
+        * which makes it difficult to re-use same wireframe() function.
+        *
+        * With OpenCL 2.0 it's possible to avoid this change, but for until
+        * then we'll be living with such an exception.
+        */
+       float3 P = ccl_fetch(sd, P);
+       float f = wireframe(kg, sd, size, pixel_size, &P);
+#else
+       float f = wireframe(kg, sd, size, pixel_size, &ccl_fetch(sd, P));
+#endif
 
        /* 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);
+               float3 Px = ccl_fetch(sd, P) - ccl_fetch(sd, dP).dx;
+               f += (f - wireframe(kg, sd, size, pixel_size, &Px)) / len(ccl_fetch(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);
+       else if(bump_offset == NODE_BUMP_OFFSET_DY) {
+               float3 Py = ccl_fetch(sd, P) - ccl_fetch(sd, dP).dy;
+               f += (f - wireframe(kg, sd, size, pixel_size, &Py)) / len(ccl_fetch(sd, dP).dy);
        }
 
-       if (stack_valid(out_fac))
+       if(stack_valid(out_fac))
                stack_store_float(stack, out_fac, f);
 }