D7270.diff

Index: intern/cycles/blender/blender_shader.cpp
===================================================================
--- intern/cycles/blender/blender_shader.cpp
+++ intern/cycles/blender/blender_shader.cpp
@@ -621,6 +621,11 @@
     ao->set_only_local(b_ao_node.only_local());
     node = ao;
   }
+  else if (b_node.is_a(&RNA_ShaderNodeOutline)) {
+    BL::ShaderNodeOutline b_outline_node(b_node);
+    OutlineNode *outline = new OutlineNode();
+    node = outline;
+  }
   else if (b_node.is_a(&RNA_ShaderNodeVolumeScatter)) {
     node = graph->create_node<ScatterVolumeNode>();
   }
Index: intern/cycles/kernel/CMakeLists.txt
===================================================================
--- intern/cycles/kernel/CMakeLists.txt
+++ intern/cycles/kernel/CMakeLists.txt
@@ -229,6 +229,7 @@
   svm/svm_noise.h
   svm/svm_noisetex.h
   svm/svm_normal.h
+  svm/svm_outline.h
   svm/svm_ramp.h
   svm/svm_ramp_util.h
   svm/svm_sepcomb_hsv.h
Index: intern/cycles/kernel/shaders/CMakeLists.txt
===================================================================
--- intern/cycles/kernel/shaders/CMakeLists.txt
+++ intern/cycles/kernel/shaders/CMakeLists.txt
@@ -70,6 +70,7 @@
   node_normal.osl
   node_normal_map.osl
   node_object_info.osl
+  node_outline.osl
   node_output_displacement.osl
   node_output_surface.osl
   node_output_volume.osl
Index: intern/cycles/kernel/shaders/node_outline.osl
===================================================================
--- /dev/null
+++ intern/cycles/kernel/shaders/node_outline.osl
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2011-2018 Blender Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "stdosl.h"
+
+shader node_outline
+(
+    normal Normal = normal(1,0,0), float Width = 1.0,
+    output float Depth = 0.0, output vector DepthHitPosition = vector(0,0,0),
+    output float NegativeDepth = 0.0, output vector NegativeDepthHitPosition = vector(0,0,0),
+    output float Object = 0.0,
+    output float WidthWorldSpaceSize = 0
+)
+{
+    string object_name = "";
+    getattribute("geom:name", object_name);
+    string projection = "";
+    getattribute("camera:projection", projection);
+
+    point offsets[4] = {
+        point(-1,0,0),point(1, 0,0),
+        point( 0,1,0),point(0,-1,0)
+    };
+
+    float max_depth = 0.0;
+    float min_depth = 0.0;
+
+    float ray_length = 0;
+    getattribute("path:ray_length", ray_length);
+
+    point trace_start = P + I * ray_length;
+    point raster_P = transform("common","raster",P);
+
+    for (int i = 0; i < 4; i++)
+    {
+        point trace_target_raster = raster_P + (offsets[i] * Width);
+        point trace_target = transform("raster", "common", trace_target_raster);
+
+        if (projection == "orthographic")
+        {
+            trace_start = trace_target + I * ray_length;
+        }
+
+        WidthWorldSpaceSize = length(trace_target - P);
+
+        vector trace_direction = normalize(trace_target - trace_start);
+
+        if(trace(trace_start, trace_direction))
+        {
+            float hit_distance = 0;
+            getmessage("trace", "hitdist", hit_distance);
+
+            string hit_name = "";
+            getmessage("trace", "geom:name", hit_name);
+
+            normal hit_normal;
+            getmessage("trace", "N", hit_normal);
+
+            // ray-plane intersection
+            float expected_distance = (dot(Normal, P) - dot(trace_start, Normal)) / dot(trace_direction, Normal);
+
+            float delta_depth = hit_distance - expected_distance;
+
+            max_depth = max(max_depth, delta_depth);
+            if (max_depth == delta_depth)
+            {
+                DepthHitPosition = (trace_start + (trace_direction * hit_distance)) - P;
+            }
+
+            min_depth = min(min_depth, delta_depth);
+            if (min_depth == delta_depth)
+            {
+                NegativeDepthHitPosition = (trace_start + (trace_direction * hit_distance)) - P;
+            }
+
+            if(hit_name != object_name)
+            {
+                Object = 1.0;
+            }
+        }
+        else
+        {
+            max_depth = 1000000000000.0;
+            Object = 1.0;
+        }
+    }
+
+    Depth = max_depth;
+    NegativeDepth = -min_depth;
+}
Index: intern/cycles/kernel/svm/svm.h
===================================================================
--- intern/cycles/kernel/svm/svm.h
+++ intern/cycles/kernel/svm/svm.h
@@ -212,6 +212,7 @@
 #ifdef __SHADER_RAYTRACE__
 #  include "kernel/svm/svm_ao.h"
 #  include "kernel/svm/svm_bevel.h"
+#  include "kernel/svm/svm_outline.h"
 #endif
 
 CCL_NAMESPACE_BEGIN
@@ -534,6 +535,9 @@
       case NODE_AMBIENT_OCCLUSION:
         svm_node_ao(kg, sd, state, stack, node);
         break;
+      case NODE_OUTLINE:
+        svm_node_outline(kg, sd, state, stack, node);
+        break;
 #  endif /* __SHADER_RAYTRACE__ */
 #endif   /* NODES_GROUP(NODE_GROUP_LEVEL_3) */
 
Index: intern/cycles/kernel/svm/svm_outline.h
===================================================================
--- /dev/null
+++ intern/cycles/kernel/svm/svm_outline.h
@@ -0,0 +1,192 @@
+/*
+ * Copyright 2011-2018 Blender Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+CCL_NAMESPACE_BEGIN
+
+#ifdef __SHADER_RAYTRACE__
+
+typedef struct OutlineResult
+{
+  float max_depth;
+  float3 max_depth_hit_position;
+  float min_depth;
+  float3 min_depth_hit_position;
+  //float min_dot;
+  float contour;
+  float width_ws_size;
+} OutlineResult;
+
+ccl_device_noinline OutlineResult svm_outline(KernelGlobals *kg, ShaderData *sd, ccl_addr_space PathState *state, float3 N, float width)
+{
+  OutlineResult result;
+  result.max_depth = 0.0f;
+  result.min_depth = 0.0f;
+  //result.min_dot = 1.0f;
+  result.contour = 0.0f;
+  result.max_depth_hit_position = make_float3(0,0,0);
+  result.min_depth_hit_position = make_float3(0,0,0);
+
+  /* Early out if no sampling needed. */
+  if (/*num_samples < 1 ||*/ sd->object == OBJECT_NONE) {
+    return result;
+  }
+
+  //TODO: early out if non camera, transparent or reflection ray ???
+
+  /* Can't raytrace from shaders like displacement, before BVH exists. */
+  if (kernel_data.bvh.bvh_layout == BVH_LAYOUT_NONE) {
+    return result;
+  }
+
+  float3 offsets[4] = {
+      make_float3(-1, 0, 0),
+      make_float3( 1, 0, 0),
+      make_float3( 0,-1, 0),
+      make_float3( 0, 1, 0)
+  };
+
+  /*
+  float sample_rotation = path_rng_1D(
+      kg, state->rng_hash, state->sample, state->num_samples, PRNG_BEVEL_U);
+  sample_rotation *= M_PI_2_F;
+
+  float cosine = cos(sample_rotation);
+  float sine = sin(sample_rotation);
+
+  for (int i = 0; i < 4; i++)
+  {
+    offsets[i].x = offsets[i].x * cosine - offsets[i].y * sine;
+    offsets[i].y = offsets[i].x * sine   + offsets[i].y * cosine;
+  }
+  */
+
+  float max_depth = 0.0f;
+  float min_depth = 0.0f;
+  //float min_dot = 1.0f;
+  bool contour = false;
+
+  float3 trace_start = sd->P + sd->I * sd->ray_length;
+
+  float3 raster_P = transform_perspective(&kernel_data.cam.worldtoraster, sd->P);
+
+  for (int i = 0; i < 4; i++)
+  {
+    float3 trace_target_raster = raster_P + (offsets[i] * width);
+    float3 trace_target = transform_perspective(&kernel_data.cam.rastertoworld,
+                                                trace_target_raster);
+
+    result.width_ws_size = len(sd->P - trace_target);
+
+
+    if (kernel_data.cam.type == CAMERA_ORTHOGRAPHIC)
+    {
+      trace_start = trace_target + sd->I * sd->ray_length;
+    }
+
+    float3 trace_direction = normalize(trace_target - trace_start);
+
+    Ray ray;
+    ray.P = trace_start;
+    ray.D = trace_direction;
+    ray.t = 1000000000000.0f;  // TODO
+    ray.time = sd->time;
+    ray.dP = sd->dP;
+    ray.dD = differential3_zero();
+
+    Intersection intersection;
+    if (scene_intersect(kg, &ray, PATH_RAY_CAMERA, &intersection))
+    {
+      // ray-plane intersection
+      float expected_distance = (dot(N, sd->P) - dot(trace_start, N)) / dot(trace_direction, N);
+
+      float delta_depth = intersection.t - expected_distance;
+
+      max_depth = max(max_depth, delta_depth);
+      if (max_depth == delta_depth)
+      {
+        result.max_depth_hit_position = (trace_start + trace_direction * intersection.t) - sd->P;
+      }
+      min_depth = min(min_depth, delta_depth);
+      if (min_depth == delta_depth)
+      {
+        result.min_depth_hit_position = (trace_start + trace_direction * intersection.t) - sd->P;
+      }
+
+      //TODO: primitive and shader ID contour
+      if (intersection.object != sd->object)
+      {
+        contour = true;
+      }
+    }
+    else
+    {
+      max_depth = 1000000000000.0f;
+      result.max_depth_hit_position = (trace_start + trace_direction * max_depth) - sd->P;
+      //min_dot = -1.0f;
+      contour = true;
+    }
+  }
+
+  result.max_depth = max_depth;
+  result.min_depth = min_depth;
+  //result.min_dot = min_dot;
+  if (contour) result.contour = 1.0f;
+
+  return result;
+}
+
+ccl_device void svm_node_outline(
+    KernelGlobals *kg, ShaderData *sd, ccl_addr_space PathState *state, float *stack, uint4 node)
+{
+  uint normal_offset, width_offset, depth_offset, depth_hit_position_offset, negative_depth_offset,
+      negative_depth_hit_position_offset, object_offset, width_ws_size_offset;
+
+  svm_unpack_node_uchar4(
+      node.y, &normal_offset, &width_offset, &depth_offset, &depth_hit_position_offset);
+
+  svm_unpack_node_uchar4(node.z,
+                         &negative_depth_offset,
+                         &negative_depth_hit_position_offset,
+                         &object_offset,
+                         &width_ws_size_offset);
+
+  float3 normal = stack_valid(normal_offset) ? stack_load_float3(stack, normal_offset) : sd->N;
+  float width = stack_load_float(stack, width_offset);
+  OutlineResult result = svm_outline(kg, sd, state, normal, width);
+
+  if (stack_valid(depth_offset)) {
+    stack_store_float(stack, depth_offset, result.max_depth);
+  }
+  if (stack_valid(depth_hit_position_offset)) {
+    stack_store_float3(stack, depth_hit_position_offset, result.max_depth_hit_position);
+  }
+  if (stack_valid(negative_depth_offset)) {
+    stack_store_float(stack, negative_depth_offset, -result.min_depth);
+  }
+  if (stack_valid(negative_depth_hit_position_offset)) {
+    stack_store_float3(stack, negative_depth_hit_position_offset, result.min_depth_hit_position);
+  }
+  if (stack_valid(object_offset)) {
+    stack_store_float(stack, object_offset, result.contour);
+  }
+  if (stack_valid(width_ws_size_offset)) {
+    stack_store_float(stack, width_ws_size_offset, result.width_ws_size);
+  }
+}
+
+#endif /* __SHADER_RAYTRACE__ */
+
+CCL_NAMESPACE_END
Index: intern/cycles/kernel/svm/svm_types.h
===================================================================
--- intern/cycles/kernel/svm/svm_types.h
+++ intern/cycles/kernel/svm/svm_types.h
@@ -153,6 +153,7 @@
   NODE_AOV_START,
   NODE_AOV_COLOR,
   NODE_AOV_VALUE,
+  NODE_OUTLINE,
   /* NOTE: for best OpenCL performance, item definition in the enum must
    * match the switch case order in svm.h. */
 } ShaderNodeType;
Index: intern/cycles/render/nodes.h
===================================================================
--- intern/cycles/render/nodes.h
+++ intern/cycles/render/nodes.h
@@ -839,6 +839,34 @@
   NODE_SOCKET_API(bool, inside)
 };
 
+class OutlineNode : public ShaderNode {
+ public:
+  SHADER_NODE_CLASS(OutlineNode)
+
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
+  virtual bool has_raytrace()
+  {
+    return true;
+  }
+
+  float3 normal;
+  float width;
+  float depth;
+  float3 depth_hit_position;
+  float negative_depth;
+  float3 negative_depth_hit_position;
+  //float dot;
+  float object;
+  float width_ws_size;
+};
+
 class VolumeNode : public ShaderNode {
  public:
   VolumeNode(const NodeType *node_type);
Index: intern/cycles/render/nodes.cpp
===================================================================
--- intern/cycles/render/nodes.cpp
+++ intern/cycles/render/nodes.cpp
@@ -3278,6 +3278,59 @@
   compiler.add(this, "node_ambient_occlusion");
 }
 
+/* Outline */
+
+NODE_DEFINE(OutlineNode)
+{
+  NodeType *type = NodeType::add("outline", create, NodeType::SHADER);
+
+  SOCKET_IN_NORMAL(normal, "Normal", make_float3(0.0f, 0.0f, 0.0f), SocketType::LINK_NORMAL);
+  SOCKET_IN_FLOAT(width, "Width", 1.0f);
+
+  SOCKET_OUT_FLOAT(delta_depth, "Depth");
+  SOCKET_OUT_POINT(delta_depth_position, "Depth Hit Position");
+  SOCKET_OUT_FLOAT(negative_depth, "Negative Depth");
+  SOCKET_OUT_POINT(negative_depth_position, "Negative Depth Hit Position");
+  //SOCKET_OUT_FLOAT(delta_dot, "Dot");
+  SOCKET_OUT_FLOAT(object, "Object");
+  SOCKET_OUT_FLOAT(width_ws_size, "Width WorldSpace Size");
+
+  return type;
+}
+
+OutlineNode::OutlineNode() : ShaderNode(get_node_type())
+{
+}
+
+void OutlineNode::compile(SVMCompiler &compiler)
+{
+  ShaderInput *normal = input("Normal");
+  ShaderInput *width_in = input("Width");
+  ShaderOutput *depth_out = output("Depth");
+  ShaderOutput *depth_hit_position_out = output("Depth Hit Position");
+  ShaderOutput *negative_depth_out = output("Negative Depth");
+  ShaderOutput *negative_depth_hit_position_out = output("Negative Depth Hit Position");
+  //ShaderOutput *dot_out = output("Dot");
+  ShaderOutput *object_out = output("Object");
+  ShaderOutput *width_ws_size_out = output("Width WorldSpace Size");
+
+  compiler.add_node(
+      NODE_OUTLINE,
+      compiler.encode_uchar4(compiler.stack_assign_if_linked(normal),
+                             compiler.stack_assign(width_in),
+                             compiler.stack_assign_if_linked(depth_out),
+                             compiler.stack_assign_if_linked(depth_hit_position_out)),
+      compiler.encode_uchar4(compiler.stack_assign_if_linked(negative_depth_out),
+                             compiler.stack_assign_if_linked(negative_depth_hit_position_out),
+                             compiler.stack_assign_if_linked(object_out),
+                             compiler.stack_assign_if_linked(width_ws_size_out)));
+}
+
+void OutlineNode::compile(OSLCompiler &compiler)
+{
+  compiler.add(this, "node_outline");
+}
+
 /* Volume Closure */
 
 VolumeNode::VolumeNode(const NodeType *node_type) : ShaderNode(node_type)
Index: release/scripts/startup/nodeitems_builtins.py
===================================================================
--- release/scripts/startup/nodeitems_builtins.py
+++ release/scripts/startup/nodeitems_builtins.py
@@ -197,6 +197,7 @@
         NodeItem("ShaderNodeWireframe"),
         NodeItem("ShaderNodeBevel"),
         NodeItem("ShaderNodeAmbientOcclusion"),
+        NodeItem("ShaderNodeOutline"),
         NodeItem("ShaderNodeObjectInfo"),
         NodeItem("ShaderNodeHairInfo"),
         NodeItem("ShaderNodeVolumeInfo"),
Index: source/blender/blenkernel/BKE_node.h
===================================================================
--- source/blender/blenkernel/BKE_node.h
+++ source/blender/blenkernel/BKE_node.h
@@ -1075,6 +1075,7 @@
 #define SH_NODE_VERTEX_COLOR 706
 #define SH_NODE_OUTPUT_AOV 707
 #define SH_NODE_VECTOR_ROTATE 708
+#define SH_NODE_OUTLINE 709
 
 /* custom defines options for Material node */
 // #define SH_NODE_MAT_DIFF 1
Index: source/blender/blenkernel/intern/node.cc
===================================================================
--- source/blender/blenkernel/intern/node.cc
+++ source/blender/blenkernel/intern/node.cc
@@ -4916,6 +4916,7 @@
 
   register_node_type_sh_attribute();
   register_node_type_sh_bevel();
+  register_node_type_sh_outline();
   register_node_type_sh_displacement();
   register_node_type_sh_vector_displacement();
   register_node_type_sh_geometry();
Index: source/blender/gpu/CMakeLists.txt
===================================================================
--- source/blender/gpu/CMakeLists.txt
+++ source/blender/gpu/CMakeLists.txt
@@ -318,6 +318,7 @@
 data_to_c_simple(shaders/material/gpu_shader_material_normal.glsl SRC)
 data_to_c_simple(shaders/material/gpu_shader_material_normal_map.glsl SRC)
 data_to_c_simple(shaders/material/gpu_shader_material_object_info.glsl SRC)
+data_to_c_simple(shaders/material/gpu_shader_material_outline.glsl SRC)
 data_to_c_simple(shaders/material/gpu_shader_material_output_aov.glsl SRC)
 data_to_c_simple(shaders/material/gpu_shader_material_output_material.glsl SRC)
 data_to_c_simple(shaders/material/gpu_shader_material_output_world.glsl SRC)
Index: source/blender/gpu/intern/gpu_material_library.c
===================================================================
--- source/blender/gpu/intern/gpu_material_library.c
+++ source/blender/gpu/intern/gpu_material_library.c
@@ -86,6 +86,7 @@
 extern char datatoc_gpu_shader_material_normal_glsl[];
 extern char datatoc_gpu_shader_material_normal_map_glsl[];
 extern char datatoc_gpu_shader_material_object_info_glsl[];
+extern char datatoc_gpu_shader_material_outline_glsl[];
 extern char datatoc_gpu_shader_material_output_aov_glsl[];
 extern char datatoc_gpu_shader_material_output_material_glsl[];
 extern char datatoc_gpu_shader_material_output_world_glsl[];
@@ -367,6 +368,11 @@
     .dependencies = {NULL},
 };
 
+static GPUMaterialLibrary gpu_shader_material_outline_library = {
+    .code = datatoc_gpu_shader_material_outline_glsl,
+    .dependencies = {NULL},
+};
+
 static GPUMaterialLibrary gpu_shader_material_output_material_library = {
     .code = datatoc_gpu_shader_material_output_material_glsl,
     .dependencies = {NULL},
@@ -633,6 +639,7 @@
     &gpu_shader_material_normal_library,
     &gpu_shader_material_normal_map_library,
     &gpu_shader_material_object_info_library,
+    &gpu_shader_material_outline_library,
     &gpu_shader_material_output_aov_library,
     &gpu_shader_material_output_material_library,
     &gpu_shader_material_output_world_library,
Index: source/blender/gpu/shaders/material/gpu_shader_material_outline.glsl
===================================================================
--- /dev/null
+++ source/blender/gpu/shaders/material/gpu_shader_material_outline.glsl
@@ -0,0 +1,95 @@
+
+void node_outline(vec3 normal,
+                  float width,
+                  out float depth,
+                  out vec3 depth_hit_position,
+                  out float negative_depth,
+                  out vec3 negative_depth_hit_position,
+                  out float object,
+                  out float width_ws_size)
+{
+  vec3 viewNormal = normalize(normal_world_to_view(normal));
+  depth_hit_position = vec3(0,0,0);
+  negative_depth_hit_position = vec3(0, 0, 0);
+
+  ivec2 texel = ivec2(gl_FragCoord.xy);
+  float texel_depth = texelFetch(maxzBuffer, texel, 0).r;
+  float texel_z = get_view_z_from_depth(texel_depth);
+
+  //ivec2 offsets[4] = ivec2[4](ivec2(-1, -1), ivec2(-1, 1), ivec2(1, -1), ivec2(1, 1));
+  ivec2 offsets[4] = ivec2[4](ivec2(-1, 0), ivec2(1, 0), ivec2(0, -1), ivec2(0, 1));
+
+  float camera_dot = dot(viewNormal, normalize(-viewPosition));
+
+  /*
+  vec2 camera_jitter = vec2(ProjectionMatrix[2][0], ProjectionMatrix[2][1]);
+
+  // If orthographic projection
+  if (ProjectionMatrix[3][3] != 0.0)
+  {
+    camera_jitter = vec2(ProjectionMatrix[3][0], ProjectionMatrix[3][1]);
+  }
+  */
+
+  float max_depth = 0.0;
+  float min_depth = 0.0;
+
+  float noise = texelFetch(utilTex, ivec3(0, 0, 2.0), 0).r;
+
+  if (noise < fract(width))
+  {
+    width = ceil(width);
+  }
+  else
+  {
+    width = floor(width);
+  }
+
+  for (int i = 0; i < 4; i++)
+  {
+    ivec2 sample_offset = offsets[i] * int(round(width));
+
+    ivec2 offset = texel + sample_offset;
+    float offset_depth = texelFetch(maxzBuffer, offset, 0).r;
+    float offset_z = get_view_z_from_depth(offset_depth);
+
+    vec2 offset_uv = vec2(offset) / textureSize(maxzBuffer, 0).xy;
+    vec3 offset_vs = get_view_space_from_depth(offset_uv, texel_depth);
+    vec3 actual_offset_vs = get_view_space_from_depth(offset_uv, offset_depth);
+
+    vec2 texel_uv = vec2(texel) / textureSize(maxzBuffer, 0).xy;
+    vec3 texel_vs = get_view_space_from_depth(texel_uv, texel_depth);
+
+    width_ws_size = length(offset_vs - texel_vs);
+
+    vec3 ray_origin = vec3(0,0,0);
+    // If orthographic projection
+    if (ProjectionMatrix[3][3] != 0.0)
+    {
+      ray_origin = get_view_space_from_depth(offset_uv, 0);
+    }
+
+    vec3 ray_direction = normalize(offset_vs - ray_origin);
+
+    // ray-plane intersection
+    float expected_distance = (dot(viewNormal, texel_vs) - dot(ray_origin, viewNormal)) /
+                      dot(ray_direction, viewNormal);
+
+    float delta_depth = length(actual_offset_vs - ray_origin) - expected_distance;
+
+    max_depth = max(max_depth, delta_depth);
+    if (max_depth == delta_depth)
+    {
+      depth_hit_position = point_view_to_world(actual_offset_vs) - point_view_to_world(texel_vs);
+    }
+    min_depth = min(min_depth, delta_depth);
+    if (min_depth == delta_depth)
+    {
+      negative_depth_hit_position = point_view_to_world(actual_offset_vs) - point_view_to_world(texel_vs);
+    }
+  }
+
+  depth = max_depth;
+  negative_depth = -min_depth;
+  object = 0;
+}
Index: source/blender/makesrna/intern/rna_nodetree.c
===================================================================
--- source/blender/makesrna/intern/rna_nodetree.c
+++ source/blender/makesrna/intern/rna_nodetree.c
@@ -6049,6 +6049,11 @@
   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
 }
 
+static void def_sh_outline(StructRNA *srna)
+{
+  //PropertyRNA *prop;
+}
+
 static void def_sh_subsurface(StructRNA *srna)
 {
   static const EnumPropertyItem prop_subsurface_falloff_items[] = {
Index: source/blender/nodes/CMakeLists.txt
===================================================================
--- source/blender/nodes/CMakeLists.txt
+++ source/blender/nodes/CMakeLists.txt
@@ -243,6 +243,7 @@
   shader/nodes/node_shader_normal.c
   shader/nodes/node_shader_normal_map.c
   shader/nodes/node_shader_object_info.c
+  shader/nodes/node_shader_outline.c
   shader/nodes/node_shader_output_aov.c
   shader/nodes/node_shader_output_light.c
   shader/nodes/node_shader_output_linestyle.c
Index: source/blender/nodes/NOD_shader.h
===================================================================
--- source/blender/nodes/NOD_shader.h
+++ source/blender/nodes/NOD_shader.h
@@ -93,6 +93,7 @@
 void register_node_type_sh_vertex_color(void);
 
 void register_node_type_sh_ambient_occlusion(void);
+void register_node_type_sh_outline(void);
 void register_node_type_sh_background(void);
 void register_node_type_sh_bsdf_diffuse(void);
 void register_node_type_sh_bsdf_glossy(void);
Index: source/blender/nodes/NOD_static_types.h
===================================================================
--- source/blender/nodes/NOD_static_types.h
+++ source/blender/nodes/NOD_static_types.h
@@ -71,6 +71,7 @@
 DefNode(ShaderNode,     SH_NODE_ADD_SHADER,         0,                      "ADD_SHADER",         AddShader,        "Add Shader",        ""       )
 DefNode(ShaderNode,     SH_NODE_ATTRIBUTE,          def_sh_attribute,       "ATTRIBUTE",          Attribute,        "Attribute",         ""       )
 DefNode(ShaderNode,     SH_NODE_AMBIENT_OCCLUSION,  def_sh_ambient_occlusion,"AMBIENT_OCCLUSION", AmbientOcclusion, "Ambient Occlusion", ""       )
+DefNode(ShaderNode,     SH_NODE_OUTLINE,            def_sh_outline,         "OUTLINE",            Outline,          "Outline",           ""       )
 DefNode(ShaderNode,     SH_NODE_BACKGROUND,         0,                      "BACKGROUND",         Background,       "Background",        ""       )
 DefNode(ShaderNode,     SH_NODE_HOLDOUT,            0,                      "HOLDOUT",            Holdout,          "Holdout",           ""       )
 DefNode(ShaderNode,     SH_NODE_BSDF_ANISOTROPIC,   def_anisotropic,        "BSDF_ANISOTROPIC",   BsdfAnisotropic,  "Anisotropic BSDF",  ""       )
Index: source/blender/nodes/shader/nodes/node_shader_outline.c
===================================================================
--- /dev/null
+++ source/blender/nodes/shader/nodes/node_shader_outline.c
@@ -0,0 +1,96 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2005 Blender Foundation.
+ * All rights reserved.
+ */
+
+#include "../node_shader_util.h"
+
+/* **************** OUTPUT ******************** */
+
+static bNodeSocketTemplate sh_node_outline_in[] = {
+    {SOCK_VECTOR,
+     N_("Normal"),
+     0.0f,
+     0.0f,
+     0.0f,
+     0.0f,
+     -1.0f,
+     1.0f,
+     PROP_NONE,
+     SOCK_HIDE_VALUE},
+    {SOCK_FLOAT, N_("Width"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
+    {-1, ""},
+};
+
+static bNodeSocketTemplate sh_node_outline_out[] = {
+    {SOCK_FLOAT, N_("Depth"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
+    {SOCK_VECTOR,
+     N_("Depth Hit Position"),
+     0.0f,
+     0.0f,
+     0.0f,
+     0.0f,
+     -100000000000.0f,
+     100000000000.0f},
+    {SOCK_FLOAT, N_("Negative Depth"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
+    {SOCK_VECTOR,
+     N_("Negative Depth Hit Position"),
+     0.0f,
+     0.0f,
+     0.0f,
+     0.0f,
+     -100000000000.0f,
+     100000000000.0f},
+    //{SOCK_FLOAT, N_("Dot"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Object"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Width WorldSpace Size"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
+    {-1, ""},
+};
+
+static int node_shader_gpu_outline(GPUMaterial *mat,
+                                             bNode *node,
+                                             bNodeExecData *UNUSED(execdata),
+                                             GPUNodeStack *in,
+                                             GPUNodeStack *out)
+{
+  if (!in[0].link) {
+    GPU_link(mat, "world_normals_get", &in[0].link);
+  }
+
+  GPU_material_flag_set(mat, GPU_MATFLAG_DIFFUSE);
+
+  return GPU_stack_link(mat, node, "node_outline", in, out);
+}
+
+static void node_shader_init_outline(bNodeTree *UNUSED(ntree), bNode *node)
+{
+
+}
+
+/* node type definition */
+void register_node_type_sh_outline(void)
+{
+  static bNodeType ntype;
+
+  sh_node_type_base(&ntype, SH_NODE_OUTLINE, "Outline", NODE_CLASS_INPUT, 0);
+  node_type_socket_templates(&ntype, sh_node_outline_in, sh_node_outline_out);
+  node_type_init(&ntype, node_shader_init_outline);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_outline);
+
+  nodeRegisterType(&ntype);
+}