Solve merge errors in shader calls.

# Conflicts:
#	source/blender/blenloader/intern/readfile.c

intern/opensubdiv/internal/opensubdiv_evaluator.cc

@@ -25,105 +25,123 @@
 
 namespace {
 
-void setCoarsePositions(OpenSubdiv_Evaluator *evaluator,
-                        const float *positions,
-                        const int start_vertex_index,
-                        const int num_vertices)
-{
-  evaluator->internal->eval_output->setCoarsePositions(
-      positions, start_vertex_index, num_vertices);
+void setCoarsePositions(OpenSubdiv_Evaluator* evaluator,
+                        const float* positions,
+                        const int start_vertex_index, const int num_vertices) {
+  evaluator->internal->eval_output->setCoarsePositions(positions,
+                                                       start_vertex_index,
+                                                       num_vertices);
 }
 
-void setVaryingData(OpenSubdiv_Evaluator *evaluator,
-                    const float *varying_data,
-                    const int start_vertex_index,
-                    const int num_vertices)
-{
-  evaluator->internal->eval_output->setVaryingData(varying_data, start_vertex_index, num_vertices);
+void setVaryingData(OpenSubdiv_Evaluator* evaluator,
+                    const float* varying_data,
+                    const int start_vertex_index, const int num_vertices) {
+  evaluator->internal->eval_output->setVaryingData(varying_data,
+                                                   start_vertex_index,
+                                                   num_vertices);
 }
 
-void setFaceVaryingData(OpenSubdiv_Evaluator *evaluator,
+void setFaceVaryingData(OpenSubdiv_Evaluator* evaluator,
                         const int face_varying_channel,
-                        const float *face_varying_data,
-                        const int start_vertex_index,
-                        const int num_vertices)
-{
-  evaluator->internal->eval_output->setFaceVaryingData(
-      face_varying_channel, face_varying_data, start_vertex_index, num_vertices);
+                        const float* face_varying_data,
+                        const int start_vertex_index, const int num_vertices) {
+  evaluator->internal->eval_output->setFaceVaryingData(face_varying_channel,
+                                                       face_varying_data,
+                                                       start_vertex_index,
+                                                       num_vertices);
 }
 
-void setCoarsePositionsFromBuffer(OpenSubdiv_Evaluator *evaluator,
-                                  const void *buffer,
+void setCoarsePositionsFromBuffer(OpenSubdiv_Evaluator* evaluator,
+                                  const void* buffer,
                                   const int start_offset,
                                   const int stride,
                                   const int start_vertex_index,
-                                  const int num_vertices)
-{
+                                  const int num_vertices) {
   evaluator->internal->eval_output->setCoarsePositionsFromBuffer(
-      buffer, start_offset, stride, start_vertex_index, num_vertices);
+          buffer,
+          start_offset,
+          stride,
+          start_vertex_index,
+          num_vertices);
 }
 
-void setVaryingDataFromBuffer(OpenSubdiv_Evaluator *evaluator,
-                              const void *buffer,
+void setVaryingDataFromBuffer(OpenSubdiv_Evaluator* evaluator,
+                              const void* buffer,
                               const int start_offset,
                               const int stride,
                               const int start_vertex_index,
-                              const int num_vertices)
-{
+                              const int num_vertices) {
   evaluator->internal->eval_output->setVaryingDataFromBuffer(
-      buffer, start_offset, stride, start_vertex_index, num_vertices);
+          buffer,
+          start_offset,
+          stride,
+          start_vertex_index,
+          num_vertices);
 }
 
-void setFaceVaryingDataFromBuffer(OpenSubdiv_Evaluator *evaluator,
+void setFaceVaryingDataFromBuffer(OpenSubdiv_Evaluator* evaluator,
                                   const int face_varying_channel,
-                                  const void *buffer,
+                                  const void* buffer,
                                   const int start_offset,
                                   const int stride,
                                   const int start_vertex_index,
-                                  const int num_vertices)
-{
+                                  const int num_vertices) {
   evaluator->internal->eval_output->setFaceVaryingDataFromBuffer(
-      face_varying_channel, buffer, start_offset, stride, start_vertex_index, num_vertices);
+          face_varying_channel,
+          buffer,
+          start_offset,
+          stride,
+          start_vertex_index,
+          num_vertices);
 }
 
-void refine(OpenSubdiv_Evaluator *evaluator)
-{
+void refine(OpenSubdiv_Evaluator* evaluator) {
   evaluator->internal->eval_output->refine();
 }
 
-void evaluateLimit(OpenSubdiv_Evaluator *evaluator,
+void evaluateLimit(OpenSubdiv_Evaluator* evaluator,
                    const int ptex_face_index,
-                   const float face_u,
-                   const float face_v,
-                   float P[3],
-                   float dPdu[3],
-                   float dPdv[3])
-{
-  evaluator->internal->eval_output->evaluateLimit(ptex_face_index, face_u, face_v, P, dPdu, dPdv);
+                   const float face_u, const float face_v,
+                   float P[3], float dPdu[3], float dPdv[3]) {
+  evaluator->internal->eval_output->evaluateLimit(ptex_face_index,
+                                                  face_u, face_v,
+                                                  P, dPdu, dPdv);
 }
 
-void evaluateVarying(OpenSubdiv_Evaluator *evaluator,
+void evaluateLimit2(OpenSubdiv_Evaluator* evaluator,
+                   const int ptex_face_index,
+                   const float face_u, const float face_v,
+				   float P[3],
+				   float dPdu[3],
+				   float dPdv[3],
+				   float dPduu[3],
+				   float dPduv[3],
+				   float dPdvv[3]) {
+  evaluator->internal->eval_output->evaluateLimit2(ptex_face_index,
+                                                  face_u, face_v,
+                                                  P, dPdu, dPdv,
+												  dPduu, dPduv, dPdvv);
+}
+
+void evaluateVarying(OpenSubdiv_Evaluator* evaluator,
                      const int ptex_face_index,
-                     float face_u,
-                     float face_v,
-                     float varying[3])
-{
-  evaluator->internal->eval_output->evaluateVarying(ptex_face_index, face_u, face_v, varying);
+                     float face_u, float face_v,
+                     float varying[3]) {
+  evaluator->internal->eval_output->evaluateVarying(ptex_face_index,
+                                                    face_u, face_v,
+                                                    varying);
 }
 
-void evaluateFaceVarying(OpenSubdiv_Evaluator *evaluator,
+void evaluateFaceVarying(OpenSubdiv_Evaluator* evaluator,
                          const int face_varying_channel,
                          const int ptex_face_index,
-                         float face_u,
-                         float face_v,
-                         float face_varying[2])
-{
+                         float face_u, float face_v,
+                         float face_varying[2]) {
   evaluator->internal->eval_output->evaluateFaceVarying(
       face_varying_channel, ptex_face_index, face_u, face_v, face_varying);
 }
 
-void assignFunctionPointers(OpenSubdiv_Evaluator *evaluator)
-{
+void assignFunctionPointers(OpenSubdiv_Evaluator* evaluator) {
   evaluator->setCoarsePositions = setCoarsePositions;
   evaluator->setVaryingData = setVaryingData;
   evaluator->setFaceVaryingData = setFaceVaryingData;
@@ -135,23 +153,22 @@ void assignFunctionPointers(OpenSubdiv_Evaluator *evaluator)
   evaluator->refine = refine;
 
   evaluator->evaluateLimit = evaluateLimit;
+  evaluator->evaluateLimit2 = evaluateLimit2;
   evaluator->evaluateVarying = evaluateVarying;
   evaluator->evaluateFaceVarying = evaluateFaceVarying;
 }
 
 }  // namespace
 
-OpenSubdiv_Evaluator *openSubdiv_createEvaluatorFromTopologyRefiner(
-    OpenSubdiv_TopologyRefiner *topology_refiner)
-{
-  OpenSubdiv_Evaluator *evaluator = OBJECT_GUARDED_NEW(OpenSubdiv_Evaluator);
+OpenSubdiv_Evaluator* openSubdiv_createEvaluatorFromTopologyRefiner(
+    OpenSubdiv_TopologyRefiner* topology_refiner) {
+  OpenSubdiv_Evaluator* evaluator = OBJECT_GUARDED_NEW(OpenSubdiv_Evaluator);
   assignFunctionPointers(evaluator);
   evaluator->internal = openSubdiv_createEvaluatorInternal(topology_refiner);
   return evaluator;
 }
 
-void openSubdiv_deleteEvaluator(OpenSubdiv_Evaluator *evaluator)
-{
+void openSubdiv_deleteEvaluator(OpenSubdiv_Evaluator* evaluator) {
   openSubdiv_deleteEvaluatorInternal(evaluator->internal);
   OBJECT_GUARDED_DELETE(evaluator, OpenSubdiv_Evaluator);
 }

intern/opensubdiv/internal/opensubdiv_evaluator_internal.h

@@ -42,30 +42,29 @@ class CpuEvalOutput;
 class CpuEvalOutputAPI {
  public:
   // NOTE: API object becomes an owner of evaluator. Patch we are referencing.
-  CpuEvalOutputAPI(CpuEvalOutput *implementation, OpenSubdiv::Far::PatchMap *patch_map);
+  CpuEvalOutputAPI(CpuEvalOutput* implementation,
+                   OpenSubdiv::Far::PatchMap* patch_map);
   ~CpuEvalOutputAPI();
 
   // Set coarse positions from a continuous array of coordinates.
-  void setCoarsePositions(const float *positions,
+  void setCoarsePositions(const float* positions,
                           const int start_vertex_index,
                           const int num_vertices);
   // Set varying data from a continuous array of data.
-  void setVaryingData(const float *varying_data,
-                      const int start_vertex_index,
-                      const int num_vertices);
+  void setVaryingData(const float* varying_data,
+                      const int start_vertex_index, const int num_vertices);
   // Set face varying data from a continuous array of data.
   //
   // TODO(sergey): Find a better name for vertex here. It is not the vertex of
   // geometry, but a vertex of UV map.
   void setFaceVaryingData(const int face_varying_channel,
-                          const float *varying_data,
-                          const int start_vertex_index,
-                          const int num_vertices);
+                          const float* varying_data,
+                          const int start_vertex_index, const int num_vertices);
 
   // Set coarse vertex position from a continuous memory buffer where
   // first coordinate starts at offset of `start_offset` and there is `stride`
   // bytes between adjacent vertex coordinates.
-  void setCoarsePositionsFromBuffer(const void *buffer,
+  void setCoarsePositionsFromBuffer(const void* buffer,
                                     const int start_offset,
                                     const int stride,
                                     const int start_vertex_index,
@@ -73,7 +72,7 @@ class CpuEvalOutputAPI {
   // Set varying data from a continuous memory buffer where
   // first coordinate starts at offset of `start_offset` and there is `stride`
   // bytes between adjacent vertex coordinates.
-  void setVaryingDataFromBuffer(const void *buffer,
+  void setVaryingDataFromBuffer(const void* buffer,
                                 const int start_offset,
                                 const int stride,
                                 const int start_vertex_index,
@@ -85,7 +84,7 @@ class CpuEvalOutputAPI {
   // TODO(sergey): Find a better name for vertex here. It is not the vertex of
   // geometry, but a vertex of UV map.
   void setFaceVaryingDataFromBuffer(const int face_varying_channel,
-                                    const void *buffer,
+                                    const void* buffer,
                                     const int start_offset,
                                     const int stride,
                                     const int start_vertex_index,
@@ -97,26 +96,33 @@ class CpuEvalOutputAPI {
   // Evaluate given ptex face at given bilinear coordinate.
   // If derivatives are NULL, they will not be evaluated.
   void evaluateLimit(const int ptex_face_index,
-                     float face_u,
-                     float face_v,
-                     float P[3],
-                     float dPdu[3],
-                     float dPdv[3]);
+                     float face_u, float face_v,
+                     float P[3], float dPdu[3], float dPdv[3]);
+
+  void evaluateLimit2(const int ptex_face_index,
+		  			  float face_u, float face_v,
+		  			  float P[3],
+		  			  float dPdu[3],
+		  			  float dPdv[3],
+		  			  float dPduu[3],
+		  			  float dPduv[3],
+		  			  float dPdvv[3]);
 
   // Evaluate varying data at a given bilinear coordinate of given ptex face.
-  void evaluateVarying(const int ptes_face_index, float face_u, float face_v, float varying[3]);
+  void evaluateVarying(const int ptes_face_index,
+                       float face_u, float face_v,
+                       float varying[3]);
 
   // Evaluate facee-varying data at a given bilinear coordinate of given
   // ptex face.
   void evaluateFaceVarying(const int face_varying_channel,
                            const int ptes_face_index,
-                           float face_u,
-                           float face_v,
+                           float face_u, float face_v,
                            float face_varying[2]);
 
  protected:
-  CpuEvalOutput *implementation_;
-  OpenSubdiv::Far::PatchMap *patch_map_;
+  CpuEvalOutput* implementation_;
+  OpenSubdiv::Far::PatchMap* patch_map_;
 };
 
 }  // namespace opensubdiv_capi
@@ -126,14 +132,15 @@ struct OpenSubdiv_EvaluatorInternal {
   OpenSubdiv_EvaluatorInternal();
   ~OpenSubdiv_EvaluatorInternal();
 
-  opensubdiv_capi::CpuEvalOutputAPI *eval_output;
-  const OpenSubdiv::Far::PatchMap *patch_map;
-  const OpenSubdiv::Far::PatchTable *patch_table;
+  opensubdiv_capi::CpuEvalOutputAPI* eval_output;
+  const OpenSubdiv::Far::PatchMap* patch_map;
+  const OpenSubdiv::Far::PatchTable* patch_table;
 };
 
-OpenSubdiv_EvaluatorInternal *openSubdiv_createEvaluatorInternal(
-    struct OpenSubdiv_TopologyRefiner *topology_refiner);
+OpenSubdiv_EvaluatorInternal* openSubdiv_createEvaluatorInternal(
+    struct OpenSubdiv_TopologyRefiner* topology_refiner);
 
-void openSubdiv_deleteEvaluatorInternal(OpenSubdiv_EvaluatorInternal *evaluator);
+void openSubdiv_deleteEvaluatorInternal(
+    OpenSubdiv_EvaluatorInternal* evaluator);
 
 #endif  // OPENSUBDIV_EVALUATOR_INTERNAL_H_

intern/opensubdiv/opensubdiv_evaluator_capi.h

@@ -92,6 +92,16 @@ typedef struct OpenSubdiv_Evaluator {
                         float dPdu[3],
                         float dPdv[3]);
 
+  void (*evaluateLimit2)(struct OpenSubdiv_Evaluator* evaluator,
+                        const int ptex_face_index,
+                        float face_u, float face_v,
+						float P[3],
+						float dPdu[3],
+						float dPdv[3],
+						float dPduu[3],
+						float dPduv[3],
+						float dPdvv[3]);
+
   // Evaluate varying data at a given bilinear coordinate of given ptex face.
   void (*evaluateVarying)(struct OpenSubdiv_Evaluator *evaluator,
                           const int ptex_face_index,

release/scripts/startup/bl_operators/__init__.py

@@ -32,6 +32,7 @@ _modules = [
     "constraint",
     "file",
     "image",
+    "lanpr",
     "mask",
     "mesh",
     "node",

release/scripts/startup/bl_operators/lanpr.py

@@ -0,0 +1,241 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  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.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+import bpy
+import string
+
+GLOBAL_OUTPUT_PATH = ''
+
+def lanpr_get_composition_scene(scene):
+    n = scene.name+'_lanpr_comp'
+    for s in bpy.data.scenes:
+        if s.name == n: return s
+    return None
+
+def lanpr_make_composition_scene(scene):
+    name = scene.name;
+    new_name = scene.name+'_lanpr_comp'
+    scene.name = new_name
+    bpy.ops.scene.new(type='LINK_COPY')
+    for s in bpy.data.scenes:
+        if s.name == new_name+'.001':
+            new_scene = s
+            break
+    scene.name = name
+    new_scene.name = new_name
+    
+    s = new_scene
+    
+    s.render.engine = 'BLENDER_LANPR'
+    s.use_nodes = True
+    
+    comp = s.node_tree
+    
+    comp.nodes.clear()
+    n1 = comp.nodes.new("CompositorNodeRLayers")
+    n1.scene = scene
+    n1.location = (0,0)
+    n2 = comp.nodes.new("CompositorNodeRLayers")
+    n2.scene = s
+    n2.location = (0,-300)
+    
+    mix = comp.nodes.new("CompositorNodeAlphaOver")
+    mix.location = (300,-150)
+    comp.links.new(n1.outputs['Image'],mix.inputs[1])
+    comp.links.new(n2.outputs['Image'],mix.inputs[2])
+    
+    out = comp.nodes.new("CompositorNodeComposite")
+    out.location = (500,-150)
+    comp.links.new(mix.outputs['Image'],out.inputs['Image'])
+    
+    
+class LANPR_make_composition_scene(bpy.types.Operator):
+    """Make Composition Scene"""
+    bl_idname = "lanpr.make_composition_scene"
+    bl_label = "Make Composition Scene"
+
+    @classmethod
+    def poll(cls, context):
+        return (lanpr_get_composition_scene(context.scene) is None)
+
+    def execute(self, context):
+        lanpr_make_composition_scene(context.scene)
+        return {'FINISHED'}
+
+def lanpr_remove_composition_scene(scene):
+    bpy.data.scenes.remove(lanpr_get_composition_scene(scene))
+
+class LANPR_remove_composition_scene(bpy.types.Operator):
+    """Remove Composition Scene"""
+    bl_idname = "lanpr.remove_composition_scene"
+    bl_label = "Remove Composition Scene"
+
+    @classmethod
+    def poll(cls, context):
+        return (lanpr_get_composition_scene(context.scene) is not None)
+
+    def execute(self, context):
+        lanpr_remove_composition_scene(context.scene)
+        return {'FINISHED'}
+    
+def lanpr_is_composition_scene(scene):
+    return scene.name.endswith('_lanpr_comp')
+
+def lanpr_get_original_scene(scene):
+    name = scene.name[:-len('_lanpr_comp')]
+    for s in bpy.data.scenes:
+        if s.name == name: return s
+    return None
+
+def lanpr_goto_original_scene(scene):
+    s = lanpr_get_original_scene(scene)
+    if s: bpy.context.window.scene = s
+    
+            
+class LANPR_goto_original_scene(bpy.types.Operator):
+    """Goto Original Scene"""
+    bl_idname = "lanpr.goto_original_scene"
+    bl_label = "Goto Original Scene"
+
+    @classmethod
+    def poll(cls, context):
+        return lanpr_is_composition_scene(context.scene)
+
+    def execute(self, context):
+        lanpr_goto_original_scene(context.scene)
+        return {'FINISHED'}
+    
+def lanpr_goto_composition_scene(scene):
+    name = scene.name+'_lanpr_comp'
+    for s in bpy.data.scenes:
+        if s.name == name:
+            bpy.context.window.scene = s
+            break
+            
+class LANPR_goto_composition_scene(bpy.types.Operator):
+    """Goto Composition Scene"""
+    bl_idname = "lanpr.goto_composition_scene"
+    bl_label = "Goto Composition Scene"
+
+    @classmethod
+    def poll(cls, context):
+        return lanpr_get_composition_scene(context.scene) is not None
+
+    def execute(self, context):
+        lanpr_goto_composition_scene(context.scene)
+        return {'FINISHED'}
+
+
+#callbacks
+
+GC = None
+
+def lanpr_render_next_frame(sc):
+    global GLOBAL_OUTPUT_PATH
+    sc.frame_current = sc.frame_current+1
+    if sc.frame_current>sc.frame_end: 
+        bpy.app.handlers.render_complete.remove(lanpr_render_next_frame)
+        bpy.context.scene.render.filepath = GLOBAL_OUTPUT_PATH
+        return
+    
+    #bpy.app.handlers.render_cancel.append(lanpr_render_canceled)
+    #bpy.app.handlers.render_complete.remove(lanpr_render_next_frame)
+    
+    #lanpr_render_backdrop_first(sc)
+
+def lanpr_render_this_scene_next(scene):
+    
+    #bpy.app.handlers.render_complete.remove(lanpr_render_this_scene_next)
+    #bpy.app.handlers.render_cancel.remove(lanpr_render_canceled)
+    
+    #bpy.app.handlers.render_cancel.append(lanpr_render_canceled)
+    
+    sc = scene #lanpr_get_composition_scene(scene)
+    write = sc.lanpr.composite_render_animation
+    
+    bpy.context.scene.render.filepath = GLOBAL_OUTPUT_PATH + '/%04d'%sc.frame_current + bpy.context.scene.render.file_extension
+    
+    if sc.lanpr.composite_render_animation:
+        #bpy.app.handlers.render_complete.append(lanpr_render_next_frame)
+        global GC
+        bpy.ops.render.render(scene=sc.name, write_still = write)
+    else:
+        #'INVOKE_DEAFULT' still cause trouble on windows.
+        #bpy.ops.render.render(GC,'INVOKE_DEFAULT',scene=sc.name)
+        bpy.ops.render.render(scene=sc.name)
+    
+def lanpr_render_canceled(scene):
+    
+    bpy.app.handlers.render_complete.remove(lanpr_render_this_scene_next)
+    
+    bpy.app.handlers.render_cancel.remove(lanpr_render_canceled)
+
+def lanpr_render_backdrop_first(this_scene):
+    s = lanpr_get_original_scene(this_scene)
+    if not s: return
+
+    s.frame_current = this_scene.frame_current
+    #bpy.app.handlers.render_complete.append(lanpr_render_this_scene_next)
+    bpy.ops.render.render(scene=s.name)
+            
+class LANPR_render_composited(bpy.types.Operator):
+    """Render Composited"""
+    bl_idname = "lanpr.render_composited"
+    bl_label = "Render Composited"
+
+    @classmethod
+    def poll(cls, context):
+        return True
+    
+    def execute(self, context):
+        if bpy.context.scene.lanpr.composite_render_animation:
+            s = lanpr_get_original_scene(bpy.context.scene)
+            bpy.context.scene.frame_current = bpy.context.scene.frame_start
+            s.frame_current = bpy.context.scene.frame_start
+            bpy.context.scene.frame_end = s.frame_end
+            bpy.context.scene.render.filepath = s.render.filepath
+            
+        global GLOBAL_OUTPUT_PATH
+        GLOBAL_OUTPUT_PATH = bpy.context.scene.render.filepath
+
+        bpy.app.handlers.render_cancel.append(lanpr_render_canceled)
+        global GC
+        GC = bpy.context.copy()
+        
+        while True :
+        
+            lanpr_render_backdrop_first(bpy.context.scene)
+            
+            lanpr_render_this_scene_next(bpy.context.scene)
+            
+            bpy.context.scene.frame_current = bpy.context.scene.frame_current+1
+            if not bpy.context.scene.lanpr.composite_render_animation or bpy.context.scene.frame_current>bpy.context.scene.frame_end: 
+                bpy.context.scene.render.filepath = GLOBAL_OUTPUT_PATH
+                return {'FINISHED'}
+        
+        return {'FINISHED'}
+
+classes=(
+    LANPR_make_composition_scene,
+    LANPR_remove_composition_scene,
+    LANPR_goto_original_scene,
+    LANPR_goto_composition_scene,
+    LANPR_render_composited,
+)

release/scripts/startup/bl_ui/properties_data_modifier.py

@@ -673,7 +673,32 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
             row.operator("object.multires_external_save", text="Save External...")
             row.label()
 
-    def OCEAN(self, layout, _ob, md):
+    def MY_BMESH(self, layout, ob, md):
+        split = layout.split(factor=0.25)
+
+        col = split.column()
+        col.label(text="§6.1:")
+        col.prop(md, "do_tri")
+        col.prop(md, "do_ff_bb_split")
+
+        col = split.column()
+        col.label(text="§6.2:")
+        col.prop(md, "do_cusp_dect")
+        col.prop(md, "do_insert")
+        col.prop(md, "do_cusp_insert")
+
+        col = split.column()
+        col.label(text="§6.3:")
+        col.prop(md, "do_rad_insert")
+        col.prop(md, "do_rad_flip")
+        col.prop(md, "do_opti")
+
+
+        col = layout.column()
+        col.label(text="Camera Object:")
+        col.prop(md, "camera_object", text="")
+
+    def OCEAN(self, layout, ob, md):
         if not bpy.app.build_options.mod_oceansim:
             layout.label(text="Built without OceanSim modifier")
             return

release/scripts/startup/bl_ui/properties_physics_fluid.py

@@ -65,7 +65,7 @@ class PhysicButtonsPanel:
 
 class PHYSICS_PT_fluid(PhysicButtonsPanel, Panel):
     bl_label = "Fluid"
-    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE'}
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_LANPR'}
 
     @classmethod
     def poll(cls, context):
@@ -308,7 +308,7 @@ class PHYSICS_PT_domain_gravity(PhysicButtonsPanel, Panel):
     bl_label = "World"
     bl_parent_id = 'PHYSICS_PT_fluid'
     bl_options = {'DEFAULT_CLOSED'}
-    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE'}
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_LANPR'}
 
     @classmethod
     def poll(cls, context):
@@ -391,7 +391,7 @@ class PHYSICS_PT_domain_boundary(PhysicButtonsPanel, Panel):
     bl_label = "Boundary"
     bl_parent_id = 'PHYSICS_PT_fluid'
     bl_options = {'DEFAULT_CLOSED'}
-    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE'}
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_LANPR'}
 
     @classmethod
     def poll(cls, context):
@@ -425,7 +425,7 @@ class PHYSICS_PT_domain_particles(PhysicButtonsPanel, Panel):
     bl_label = "Particles"
     bl_parent_id = 'PHYSICS_PT_fluid'
     bl_options = {'DEFAULT_CLOSED'}
-    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE'}
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_LANPR'}
 
     @classmethod
     def poll(cls, context):

release/scripts/startup/bl_ui/properties_scene.py

@@ -164,8 +164,8 @@ class SCENE_PT_keying_sets(SceneButtonsPanel, SceneKeyingSetsPanel, Panel):
         col.template_list("UI_UL_list", "keying_sets", scene, "keying_sets", scene.keying_sets, "active_index", rows=1)
 
         col = row.column(align=True)
-        col.operator("anim.keying_set_add", icon='ADD', text="")
-        col.operator("anim.keying_set_remove", icon='REMOVE', text="")
+        col.operator("anim.keying_set_add", icon='ZOOMIN', text="")
+        col.operator("anim.keying_set_remove", icon='ZOOMOUT', text="")
 
         layout.use_property_split = True
         layout.use_property_decorate = False  # No animation.
@@ -242,8 +242,8 @@ class SCENE_PT_keying_set_paths(SceneButtonsPanel, SceneKeyingSetsPanel, Panel):
         col.template_list("SCENE_UL_keying_set_paths", "", ks, "paths", ks.paths, "active_index", rows=1)
 
         col = row.column(align=True)
-        col.operator("anim.keying_set_path_add", icon='ADD', text="")
-        col.operator("anim.keying_set_path_remove", icon='REMOVE', text="")
+        col.operator("anim.keying_set_path_add", icon='ZOOMIN', text="")
+        col.operator("anim.keying_set_path_remove", icon='ZOOMOUT', text="")
 
         # TODO: 1) the template_any_ID needs to be fixed for the text alignment.
         #       2) use_property_decorate has to properly skip the non animatable properties.
@@ -280,6 +280,62 @@ class SCENE_PT_keying_set_paths(SceneButtonsPanel, SceneKeyingSetsPanel, Panel):
                 col.prop(ksp, "group")
 
 
+class SCENE_PT_color_management(SceneButtonsPanel, Panel):
+    bl_label = "Color Management"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_OPENGL', 'BLENDER_LANPR'}
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+
+        scene = context.scene
+        view = scene.view_settings
+
+        flow = layout.grid_flow(row_major=True, columns=0, even_columns=False, even_rows=False, align=True)
+
+        col = flow.column()
+        col.prop(scene.display_settings, "display_device")
+
+        col.separator()
+
+        col.prop(view, "view_transform")
+        col.prop(view, "look")
+
+        col = flow.column()
+        col.prop(view, "exposure")
+        col.prop(view, "gamma")
+
+        col.separator()
+
+        col.prop(scene.sequencer_colorspace_settings, "name", text="Sequencer")
+
+
+class SCENE_PT_color_management_curves(SceneButtonsPanel, Panel):
+    bl_label = "Use Curves"
+    bl_parent_id = "SCENE_PT_color_management"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_OPENGL', 'BLENDER_LANPR'}
+
+    def draw_header(self, context):
+
+        scene = context.scene
+        view = scene.view_settings
+
+        self.layout.prop(view, "use_curve_mapping", text="")
+
+    def draw(self, context):
+        layout = self.layout
+
+        scene = context.scene
+        view = scene.view_settings
+
+        layout.use_property_split = False
+        layout.enabled = view.use_curve_mapping
+
+        layout.template_curve_mapping(view, "curve_mapping", levels=True)
+
+
 class SCENE_PT_audio(SceneButtonsPanel, Panel):
     bl_label = "Audio"
     bl_options = {'DEFAULT_CLOSED'}
@@ -423,6 +479,492 @@ class SCENE_PT_rigid_body_field_weights(RigidBodySubPanel, Panel):
         effector_weights_ui(self, rbw.effector_weights, 'RIGID_BODY')
 
 
+class SCENE_PT_simplify(SceneButtonsPanel, Panel):
+    bl_label = "Simplify"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_OPENGL', 'BLENDER_LANPR'}
+
+    def draw_header(self, context):
+        rd = context.scene.render
+        self.layout.prop(rd, "use_simplify", text="")
+
+    def draw(self, context):
+        pass
+
+
+class SCENE_PT_simplify_viewport(SceneButtonsPanel, Panel):
+    bl_label = "Viewport"
+    bl_parent_id = "SCENE_PT_simplify"
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_OPENGL', 'BLENDER_LANPR'}
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+
+        rd = context.scene.render
+
+        layout.active = rd.use_simplify
+
+        flow = layout.grid_flow(row_major=True, columns=0, even_columns=False, even_rows=False, align=True)
+
+        col = flow.column()
+        col.prop(rd, "simplify_subdivision", text="Max Subdivision")
+
+        col = flow.column()
+        col.prop(rd, "simplify_child_particles", text="Max Child Particles")
+
+
+class SCENE_PT_simplify_render(SceneButtonsPanel, Panel):
+    bl_label = "Render"
+    bl_parent_id = "SCENE_PT_simplify"
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_OPENGL', 'BLENDER_LANPR'}
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+
+        rd = context.scene.render
+
+        layout.active = rd.use_simplify
+
+        flow = layout.grid_flow(row_major=True, columns=0, even_columns=False, even_rows=False, align=True)
+
+        col = flow.column()
+        col.prop(rd, "simplify_subdivision_render", text="Max Subdivision")
+
+        col = flow.column()
+        col.prop(rd, "simplify_child_particles_render", text="Max Child Particles")
+
+
+class SCENE_PT_simplify_greasepencil(SceneButtonsPanel, Panel):
+    bl_label = "Grease Pencil"
+    bl_parent_id = "SCENE_PT_simplify"
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME', 'BLENDER_CLAY', 'BLENDER_EEVEE'}
+    bl_options = {'DEFAULT_CLOSED'}
+
+    def draw_header(self, context):
+        rd = context.scene.render
+        self.layout.prop(rd, "simplify_gpencil", text="")
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+
+        rd = context.scene.render
+
+        layout.active = rd.simplify_gpencil
+
+        col = layout.column()
+        col.prop(rd, "simplify_gpencil_onplay", text="Playback Only")
+        col.prop(rd, "simplify_gpencil_view_modifier", text="Modifiers")
+        col.prop(rd, "simplify_gpencil_shader_fx", text="ShaderFX")
+
+        col = layout.column(align=True)
+        col.prop(rd, "simplify_gpencil_view_fill")
+        sub = col.column()
+        sub.active = rd.simplify_gpencil_view_fill
+        sub.prop(rd, "simplify_gpencil_remove_lines", text="Lines")
+
+class SCENE_PT_viewport_display(SceneButtonsPanel, Panel):
+    bl_label = "Viewport Display"
+    bl_options = {'DEFAULT_CLOSED'}
+
+    @classmethod
+    def poll(cls, context):
+        return True
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+        scene = context.scene
+        col = layout.column()
+        col.prop(scene.display, "light_direction")
+        col.prop(scene.display, "shadow_shift")
+
+class LANPR_linesets(UIList):
+    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
+        lineset = item
+        if self.layout_type in {'DEFAULT', 'COMPACT'}:
+            split = layout.split(factor=0.6)
+            split.label(text="Layer")
+            row = split.row(align=True)
+            row.prop(lineset, "color", text="", icon_value=icon)
+            row.prop(lineset, "thickness", text="", icon_value=icon)
+        elif self.layout_type == 'GRID':
+            layout.alignment = 'CENTER'
+            layout.label("", icon_value=icon)
+
+def lanpr_get_composition_scene(scene):
+    n = scene.name+'_lanpr_comp'
+    for s in bpy.data.scenes:
+        if s.name == n: return s
+    return None
+
+def lanpr_is_composition_scene(scene):
+    return scene.name.endswith('_lanpr_comp')
+
+class SCENE_PT_lanpr(SceneButtonsPanel, Panel):
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_LANPR', 'BLENDER_OPENGL', 'BLENDER_EEVEE'}
+    bl_label = "LANPR"
+    bl_options = {'DEFAULT_CLOSED'}
+    
+    @classmethod
+    def poll(cls, context):
+        return True
+
+    def draw(self, context):
+        layout = self.layout
+        scene = context.scene
+        lanpr = scene.lanpr
+        active_layer = lanpr.layers.active_layer 
+        
+        sc = lanpr_get_composition_scene(scene)
+        
+        if sc is not None:
+            layout.label(text = 'You are adjusting values for LANPR compostion scene.')
+            row = layout.row()
+            row.scale_y=1.5
+            row.operator("lanpr.goto_composition_scene")
+            layout.operator("lanpr.remove_composition_scene")
+            scene = sc
+            lanpr = scene.lanpr
+            active_layer = lanpr.layers.active_layer
+            return
+        elif scene.render.engine!='BLENDER_LANPR':
+            layout.label(text = 'Select LANPR engine or use composition scene.')
+            layout.operator("lanpr.make_composition_scene")
+            return
+
+        if lanpr_is_composition_scene(scene):
+            row = layout.row()
+            row.scale_y=1.5
+            row.operator("lanpr.goto_original_scene") 
+            
+            layout.label(text='LANPR Composition')
+            row = layout.row()
+            row.scale_y=1.5
+            row.scale_x=4
+            row.operator("lanpr.render_composited", icon = 'RENDER_STILL')
+            row.scale_x=1
+            row.prop(lanpr,"composite_render_animation", toggle=True, icon = 'RENDER_ANIMATION')
+        
+        layout.label(text='Mode:')
+        
+        layout.prop(lanpr, "master_mode", expand=True) 
+
+        if lanpr.master_mode == "DPIX" or lanpr.master_mode == "SOFTWARE":
+            
+            layout.prop(lanpr, "background_color")
+
+            if lanpr.master_mode == "SOFTWARE":
+                layout.label(text="Enable On Demand:")
+                row = layout.row()
+                row.prop(lanpr,"enable_intersections", text = "Intersection Lines")
+                row.prop(lanpr,"enable_chaining", text = "Chaining (SLOW!)")
+                layout.label(text="RUN:")
+                layout.operator("scene.lanpr_calculate", icon='RENDER_STILL')
+
+                split = layout.split(factor=0.7)
+                col = split.column()
+                col.label(text="Layer Composition:")
+                col = split.column()
+                col.operator("scene.lanpr_auto_create_line_layer", text = "Default")#, icon = "ZOOMIN")
+                layout.template_list("LANPR_linesets", "", lanpr, "layers", lanpr.layers, "active_layer_index", rows=4)
+                if active_layer:
+                    split = layout.split()
+                    col = split.column()
+                    col.operator("scene.lanpr_add_line_layer")#icon="ZOOMIN")
+                    col.operator("scene.lanpr_delete_line_layer")#, icon="ZOOMOUT")
+                    col = split.column()
+                    col.operator("scene.lanpr_move_line_layer").direction = "UP"
+                    col.operator("scene.lanpr_move_line_layer").direction = "DOWN"
+                    layout.operator("scene.lanpr_rebuild_all_commands")
+                else:
+                    layout.operator("scene.lanpr_add_line_layer")
+            
+            if active_layer:
+                layout.label(text= "Normal:")
+                layout.prop(active_layer,"normal_mode", expand = True)
+                if active_layer.normal_mode != "DISABLED":
+                    layout.prop(active_layer,"normal_control_object")
+                    layout.prop(active_layer,"normal_effect_inverse", toggle = True)
+                    layout.prop(active_layer,"normal_ramp_begin")
+                    layout.prop(active_layer,"normal_ramp_end")
+                    layout.prop(active_layer,"normal_thickness_begin", slider=True)
+                    layout.prop(active_layer,"normal_thickness_end", slider=True)
+            
+        else:
+            layout.label(text="Vectorization:")
+            layout.prop(lanpr, "enable_vector_trace", expand = True)
+
+
+class SCENE_PT_lanpr_line_types(SceneButtonsPanel, Panel):
+    bl_label = "Types"
+    bl_parent_id = "SCENE_PT_lanpr"
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_LANPR', 'BLENDER_OPENGL'}
+
+    @classmethod
+    def poll(cls, context):
+        scene = context.scene
+        lanpr = scene.lanpr
+        active_layer = lanpr.layers.active_layer
+        return active_layer and lanpr.master_mode != "SNAKE"
+
+    def draw(self, context):
+        layout = self.layout
+        scene = context.scene
+        lanpr = scene.lanpr
+        active_layer = lanpr.layers.active_layer
+        if active_layer and lanpr.master_mode == "DPIX":
+            active_layer = lanpr.layers[0]
+
+        layout.operator("scene.lanpr_enable_all_line_types")
+
+        split = layout.split(factor=0.3)
+        col = split.column()
+        col.prop(active_layer, "enable_contour", text="Contour", toggle=True)
+        col.prop(active_layer, "enable_crease", text="Crease", toggle=True)
+        col.prop(active_layer, "enable_edge_mark", text="Mark", toggle=True)
+        col.prop(active_layer, "enable_material_seperate", text="Material", toggle=True)
+        col.prop(active_layer, "enable_intersection", text="Intersection", toggle=True)
+        col = split.column()
+        row = col.row(align = True)
+        #row.enabled = active_layer.enable_contour this is always enabled now
+        row.prop(active_layer, "color", text="")
+        row.prop(active_layer, "thickness", text="")
+        row = col.row(align = True)
+        row.enabled = active_layer.enable_crease
+        row.prop(active_layer, "crease_color", text="")
+        row.prop(active_layer, "thickness_crease", text="")
+        row = col.row(align = True)
+        row.enabled = active_layer.enable_edge_mark
+        row.prop(active_layer, "edge_mark_color", text="")
+        row.prop(active_layer, "thickness_edge_mark", text="")
+        row = col.row(align = True)
+        row.enabled = active_layer.enable_material_seperate
+        row.prop(active_layer, "material_color", text="")
+        row.prop(active_layer, "thickness_material", text="")
+        row = col.row(align = True)
+        if lanpr.enable_intersections:
+            row.enabled = active_layer.enable_intersection
+            row.prop(active_layer, "intersection_color", text="")
+            row.prop(active_layer, "thickness_intersection", text="")
+        else:
+            row.label(text= "Intersection Calculation Disabled")
+
+        if lanpr.master_mode == "DPIX" and active_layer.enable_intersection:
+            row = col.row(align = True)
+            row.prop(lanpr,"enable_intersections", toggle = True, text = "Enable")
+            if lanpr.enable_intersections:
+                row.operator("scene.lanpr_calculate", text= "Recalculate")
+
+        if lanpr.master_mode == "SOFTWARE":
+            row = layout.row(align=True)
+            row.prop(active_layer, "qi_begin")
+            row.prop(active_layer, "qi_end")
+
+class SCENE_PT_lanpr_line_components(SceneButtonsPanel, Panel):
+    bl_label = "Including"
+    bl_parent_id = "SCENE_PT_lanpr"
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_LANPR', 'BLENDER_OPENGL'}
+
+    @classmethod
+    def poll(cls, context):
+        scene = context.scene
+        lanpr = scene.lanpr
+        active_layer = lanpr.layers.active_layer
+        return active_layer and lanpr.master_mode == "SOFTWARE" and not lanpr.enable_chaining
+
+    def draw(self, context):
+        layout = self.layout
+        scene = context.scene
+        lanpr = scene.lanpr
+        active_layer = lanpr.layers.active_layer
+
+        layout.operator("scene.lanpr_add_line_component")#, icon = "ZOOMIN")
+        
+        i=0
+        for c in active_layer.components:
+            split = layout.split(factor=0.85)
+            col = split.column()
+            sp2 = col.split(factor=0.4)
+            cl = sp2.column()
+            cl.prop(c,"component_mode", text = "")
+            cl = sp2.column()
+            if c.component_mode == "OBJECT":
+                cl.prop(c,"object_select", text = "")
+            elif c.component_mode == "MATERIAL":
+                cl.prop(c,"material_select", text = "")
+            elif c.component_mode == "COLLECTION":
+                cl.prop(c,"collection_select", text = "")
+            col = split.column()
+            col.operator("scene.lanpr_delete_line_component", text="").index=i
+            i=i+1
+
+
+class SCENE_PT_lanpr_line_effects(SceneButtonsPanel, Panel):
+    bl_label = "Effects"
+    bl_parent_id = "SCENE_PT_lanpr"
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_LANPR', 'BLENDER_OPENGL'}
+
+    @classmethod
+    def poll(cls, context):
+        scene = context.scene
+        lanpr = scene.lanpr
+        return lanpr.master_mode == "DPIX"
+
+    def draw(self, context):
+        layout = self.layout
+        scene = context.scene
+        lanpr = scene.lanpr
+        active_layer = lanpr.layers.active_layer
+
+        row = layout.row(align = True)
+        row.prop(lanpr, "crease_threshold")
+        row.prop(lanpr, "crease_fade_threshold")
+        row = layout.row(align = True)
+        row.prop(lanpr, "depth_width_influence")
+        row.prop(lanpr, "depth_width_curve")
+        row = layout.row(align = True)
+        row.prop(lanpr, "depth_alpha_influence")
+        row.prop(lanpr, "depth_alpha_curve")
+
+class SCENE_PT_lanpr_snake_sobel_parameters(SceneButtonsPanel, Panel):
+    bl_label = "Sobel Parameters"
+    bl_parent_id = "SCENE_PT_lanpr"
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_LANPR', 'BLENDER_OPENGL'}
+
+    @classmethod
+    def poll(cls, context):
+        scene = context.scene
+        lanpr = scene.lanpr
+        return lanpr.master_mode == "SNAKE"
+
+    def draw(self, context):
+        layout = self.layout
+        scene = context.scene
+        lanpr = scene.lanpr
+        layout.prop(lanpr, "depth_clamp")
+        layout.prop(lanpr, "depth_strength")
+        layout.prop(lanpr, "normal_clamp")
+        layout.prop(lanpr, "normal_strength")
+        if lanpr.enable_vector_trace == "DISABLED":
+            layout.prop(lanpr, "display_thinning_result")
+
+class SCENE_PT_lanpr_snake_settings(SceneButtonsPanel, Panel):
+    bl_label = "Snake Settings"
+    bl_parent_id = "SCENE_PT_lanpr"
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_LANPR', 'BLENDER_OPENGL'}
+
+    @classmethod
+    def poll(cls, context):
+        scene = context.scene
+        lanpr = scene.lanpr
+        return lanpr.master_mode == "SNAKE" and lanpr.enable_vector_trace == "ENABLED"
+
+    def draw(self, context):
+        layout = self.layout
+        scene = context.scene
+        lanpr = scene.lanpr
+
+        split = layout.split()
+        col = split.column()
+        col.prop(lanpr, "background_color")
+        col = split.column()
+        col.prop(lanpr, "line_color")
+        
+        layout.prop(lanpr, "line_thickness")
+
+        split = layout.split()
+        col = split.column()
+        col.prop(lanpr, "depth_width_influence")
+        col.prop(lanpr, "depth_alpha_influence")
+        col = split.column()
+        col.prop(lanpr, "depth_width_curve")
+        col.prop(lanpr, "depth_alpha_curve")
+        
+        layout.label(text="Taper:")
+        layout.prop(lanpr, "use_same_taper", expand = True)
+        if lanpr.use_same_taper == "DISABLED":
+            split = layout.split()
+            col = split.column(align = True)
+            col.label(text="Left:")
+            col.prop(lanpr,"taper_left_distance")
+            col.prop(lanpr,"taper_left_strength")
+            col = split.column(align = True)
+            col.label(text="Right:")
+            col.prop(lanpr,"taper_right_distance")
+            col.prop(lanpr,"taper_right_strength")
+        else:
+            split = layout.split()
+            col = split.column(align = True)
+            col.prop(lanpr,"taper_left_distance")
+            col.prop(lanpr,"taper_left_strength") 
+
+        layout.label(text="Tip Extend:")
+        layout.prop(lanpr, "enable_tip_extend",  expand = True)
+        if lanpr.enable_tip_extend == "ENABLED":
+            layout.label(text="---INOP---")
+            layout.prop(lanpr,"extend_length")
+
+class SCENE_PT_lanpr_software_chain_styles(SceneButtonsPanel, Panel):
+    bl_label = "Chain Styles"
+    bl_parent_id = "SCENE_PT_lanpr"
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_LANPR', 'BLENDER_OPENGL'}
+
+    @classmethod
+    def poll(cls, context):
+        scene = context.scene
+        lanpr = scene.lanpr
+        return lanpr.master_mode == "SOFTWARE" and lanpr.enable_chaining
+
+    def draw(self, context):
+        layout = self.layout
+        scene = context.scene
+        lanpr = scene.lanpr
+        layout.label(text="Taper:")
+        layout.prop(lanpr, "use_same_taper", expand = True)
+        if lanpr.use_same_taper == "DISABLED":
+            split = layout.split()
+            col = split.column(align = True)
+            col.label(text="Left:")
+            col.prop(lanpr,"taper_left_distance")
+            col.prop(lanpr,"taper_left_strength")
+            col = split.column(align = True)
+            col.label(text="Right:")
+            col.prop(lanpr,"taper_right_distance")
+            col.prop(lanpr,"taper_right_strength")
+        else:
+            split = layout.split()
+            col = split.column(align = True)
+            col.prop(lanpr,"taper_left_distance")
+            col.prop(lanpr,"taper_left_strength") 
+
+        layout.label(text="Tip Extend:")
+        layout.prop(lanpr, "enable_tip_extend",  expand = True)
+        if lanpr.enable_tip_extend == "ENABLED":
+            layout.label(text="---INOP---")
+            layout.prop(lanpr,"extend_length")
+
+
+class SCENE_PT_viewport_display_ssao(SceneButtonsPanel, Panel):
+    bl_label = "Screen Space Ambient Occlusion"
+    bl_parent_id = "SCENE_PT_viewport_display"
+
+    @classmethod
+    def poll(cls, context):
+        return True
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+        scene = context.scene
+        col = layout.column()
+        col.prop(scene.display, "matcap_ssao_samples")
+        col.prop(scene.display, "matcap_ssao_distance")
+        col.prop(scene.display, "matcap_ssao_attenuation")
+
+
 class SCENE_PT_custom_props(SceneButtonsPanel, PropertyPanel, Panel):
     _context_path = "scene"
     _property_type = bpy.types.Scene
@@ -432,16 +974,34 @@ classes = (
     SCENE_UL_keying_set_paths,
     SCENE_PT_scene,
     SCENE_PT_unit,
-    SCENE_PT_physics,
     SCENE_PT_keying_sets,
     SCENE_PT_keying_set_paths,
     SCENE_PT_keyframing_settings,
+    SCENE_PT_color_management,
+    SCENE_PT_color_management_curves,
+    SCENE_PT_viewport_display,
+    SCENE_PT_viewport_display_ssao,
     SCENE_PT_audio,
+    SCENE_PT_physics,
     SCENE_PT_rigid_body_world,
     SCENE_PT_rigid_body_world_settings,
     SCENE_PT_rigid_body_cache,
     SCENE_PT_rigid_body_field_weights,
+    SCENE_PT_simplify,
+    SCENE_PT_simplify_viewport,
+    SCENE_PT_simplify_render,
+    SCENE_PT_simplify_greasepencil,
     SCENE_PT_custom_props,
+
+    SCENE_PT_lanpr,
+    SCENE_PT_lanpr_line_types,
+    SCENE_PT_lanpr_line_components,
+    SCENE_PT_lanpr_line_effects,
+    SCENE_PT_lanpr_snake_sobel_parameters,
+    SCENE_PT_lanpr_snake_settings,
+    SCENE_PT_lanpr_software_chain_styles,
+
+    LANPR_linesets,
 )
 
 if __name__ == "__main__":  # only for live edit.

release/scripts/startup/bl_ui/space_view3d.py

@@ -3617,6 +3617,7 @@ class VIEW3D_MT_edit_mesh_edges_data(Menu):
         if render.use_freestyle:
             layout.separator()
 
+        #if with_freestyle:     we still presere freestyle mark functions.
             layout.operator("mesh.mark_freestyle_edge").clear = False
             layout.operator("mesh.mark_freestyle_edge", text="Clear Freestyle Edge").clear = True
 

source/blender/blenkernel/intern/scene.c

@@ -968,6 +968,29 @@ void BKE_scene_init(Scene *sce)
   sce->eevee.flag = SCE_EEVEE_VOLUMETRIC_LIGHTS | SCE_EEVEE_GTAO_BENT_NORMALS |
                     SCE_EEVEE_GTAO_BOUNCE | SCE_EEVEE_TAA_REPROJECTION |
                     SCE_EEVEE_SSR_HALF_RESOLUTION;
+
+	/* SceneLANPR */
+	
+	sce->lanpr.crease_threshold = 0.7;
+
+	sce->lanpr.line_thickness = 1.5;
+	sce->lanpr.depth_clamp = 0.001;
+	sce->lanpr.depth_strength = 800;
+	sce->lanpr.normal_clamp = 2;
+	sce->lanpr.normal_strength = 10;
+	
+	sce->lanpr.enable_intersections = 1;
+
+	sce->lanpr.background_color[0] = 0.76;
+	sce->lanpr.background_color[1] = 0.54;
+	sce->lanpr.background_color[2] = 0.29;
+	sce->lanpr.background_color[3] = 1;
+
+	sce->lanpr.line_color[0] = 0.39;
+	sce->lanpr.line_color[1] = 0.12;
+	sce->lanpr.line_color[2] = 0.04;
+	sce->lanpr.line_color[3] = 1;
+
 }
 
 Scene *BKE_scene_add(Main *bmain, const char *name)

source/blender/blenloader/intern/readfile.c

@@ -78,6 +78,7 @@
 #include "DNA_packedFile_types.h"
 #include "DNA_particle_types.h"
 #include "DNA_lightprobe_types.h"
+#include "DNA_lanpr_types.h"
 #include "DNA_rigidbody_types.h"
 #include "DNA_text_types.h"
 #include "DNA_view3d_types.h"
@@ -6539,6 +6540,16 @@ static void lib_link_scene(FileData *fd, Main *main)
           fls->group = newlibadr_us(fd, sce->id.lib, fls->group);
         }
       }
+
+			for (LANPR_LineLayer *ll = sce->lanpr.line_layers.first; ll; ll = ll->next) {
+				for (LANPR_LineLayerComponent *llc = ll->components.first; llc; llc = llc->next) {
+					llc->object_select = newlibadr_us(fd, sce->id.lib, llc->object_select);
+					llc->material_select = newlibadr_us(fd, sce->id.lib, llc->material_select);
+					llc->collection_select = newlibadr_us(fd, sce->id.lib, llc->collection_select);
+				}
+				ll->normal_control_object = newlibadr_us(fd, sce->id.lib, ll->normal_control_object);
+			}
+
       /* Motion Tracking */
       sce->clip = newlibadr_us(fd, sce->id.lib, sce->clip);
 
@@ -6991,6 +7002,22 @@ static void direct_link_scene(FileData *fd, Scene *sce)
     }
   }
 
+	/* LANPR things */
+	sce->lanpr.active_layer = newdataadr(fd, sce->lanpr.active_layer);
+	sce->lanpr.render_buffer = NULL;
+	link_list(fd, &sce->lanpr.line_layers);
+	for (LANPR_LineLayer *ll = sce->lanpr.line_layers.first; ll; ll = ll->next) {
+		link_list(fd, &ll->components);
+		for(LANPR_LineLayerComponent *llc = ll->components.first; llc;llc=llc->next){
+			//llc->object_select = newlibadr(fd, sce->id.lib, llc->object_select);
+			//llc->material_select = newlibadr(fd, sce->id.lib, llc->material_select);
+			//llc->collection_select = newlibadr(fd, sce->id.lib, llc->collection_select);
+		}
+		ll->batch = NULL;
+		ll->shgrp = NULL;
+		//ll->normal_control_object = newlibadr(fd, sce->id.lib, ll->normal_control_object);
+	}
+
   sce->layer_properties = newdataadr(fd, sce->layer_properties);
   IDP_DirectLinkGroup_OrFree(&sce->layer_properties, (fd->flags & FD_FLAGS_SWITCH_ENDIAN), fd);
 }
@@ -10656,6 +10683,8 @@ static void expand_scene(FileData *fd, Main *mainvar, Scene *sce)
   SceneRenderLayer *srl;
   FreestyleModuleConfig *module;
   FreestyleLineSet *lineset;
+	LANPR_LineLayer* ll;
+	LANPR_LineLayerComponent* llc;
 
   for (Base *base_legacy = sce->base.first; base_legacy; base_legacy = base_legacy->next) {
     expand_doit(fd, mainvar, base_legacy->object);
@@ -10708,9 +10737,17 @@ static void expand_scene(FileData *fd, Main *mainvar, Scene *sce)
     }
   }
 
-  if (sce->gpd) {
+	for (LANPR_LineLayer *ll = sce->lanpr.line_layers.first; ll; ll = ll->next) {
+		for (LANPR_LineLayerComponent *llc = ll->components.first; llc; llc = llc->next) {
+			if (llc->object_select) expand_doit(fd, mainvar, llc->object_select);
+			if (llc->material_select) expand_doit(fd, mainvar, llc->material_select);
+			if (llc->collection_select) expand_doit(fd, mainvar, llc->collection_select);
+		}
+		if (ll->normal_control_object) expand_doit(fd, mainvar, ll->normal_control_object);
+	}
+
+  if (sce->gpd)
     expand_doit(fd, mainvar, sce->gpd);
-  }
 
   if (sce->ed) {
     Sequence *seq;

source/blender/blenloader/intern/versioning_280.c

@@ -1749,6 +1749,32 @@ void blo_do_versions_280(FileData *fd, Library *UNUSED(lib), Main *bmain)
       }
     }
 
+		if (!DNA_struct_find(fd->filesdna, "SceneLANPR")) {
+			for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
+
+				scene->lanpr.crease_threshold = 0.7;
+
+				scene->lanpr.line_thickness = 1.5;
+				scene->lanpr.depth_clamp = 0.001;
+				scene->lanpr.depth_strength = 800;
+				scene->lanpr.normal_clamp = 2;
+				scene->lanpr.normal_strength = 10;
+				
+				scene->lanpr.enable_intersections = 1;
+				
+				scene->lanpr.background_color[0] = 0.76;
+				scene->lanpr.background_color[1] = 0.54;
+				scene->lanpr.background_color[2] = 0.29;
+				scene->lanpr.background_color[3] = 1;
+				
+				scene->lanpr.line_color[0] = 0.39;
+				scene->lanpr.line_color[1] = 0.12;
+				scene->lanpr.line_color[2] = 0.04;
+				scene->lanpr.line_color[3] = 1;
+
+			}
+		}
+
     if (!MAIN_VERSION_ATLEAST(bmain, 280, 15)) {
       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
         scene->display.matcap_ssao_distance = 0.2f;

source/blender/blenloader/intern/writefile.c

@@ -121,6 +121,7 @@
 #include "DNA_packedFile_types.h"
 #include "DNA_particle_types.h"
 #include "DNA_lightprobe_types.h"
+#include "DNA_lanpr_types.h"
 #include "DNA_rigidbody_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_sdna_types.h"
@@ -2682,6 +2683,14 @@ static void write_scene(WriteData *wd, Scene *sce)
     write_lightcache(wd, sce->eevee.light_cache);
   }
 
+	/* LANPR Line Layers */
+	for (LANPR_LineLayer *ll = sce->lanpr.line_layers.first; ll; ll = ll->next) {
+		writestruct(wd, DATA, LANPR_LineLayer, 1, ll);
+		for (LANPR_LineLayerComponent *llc = ll->components.first; llc; llc = llc->next) {
+			writestruct(wd, DATA, LANPR_LineLayerComponent, 1, llc);
+		}
+	}
+
   /* Freed on doversion. */
   BLI_assert(sce->layer_properties == NULL);
 }

source/blender/draw/CMakeLists.txt

@@ -126,6 +126,13 @@ set(SRC
   engines/gpencil/gpencil_engine.h
   engines/gpencil/gpencil_render.c
   engines/gpencil/gpencil_shader_fx.c
+	engines/lanpr/lanpr_dpix.c
+	engines/lanpr/lanpr_engine.c
+	engines/lanpr/lanpr_snake.c
+	engines/lanpr/lanpr_ops.c
+	engines/lanpr/lanpr_util.c
+	engines/lanpr/lanpr_chain.c
+
 
   DRW_engine.h
   intern/DRW_render.h
@@ -150,6 +157,8 @@ set(SRC
   engines/external/external_engine.h
   engines/workbench/workbench_engine.h
   engines/workbench/workbench_private.h
+	engines/lanpr/lanpr_util.h
+	engines/lanpr/lanpr_all.h
 )
 
 set(LIB
@@ -247,6 +256,21 @@ data_to_c_simple(engines/workbench/shaders/workbench_volume_vert.glsl SRC)
 data_to_c_simple(engines/workbench/shaders/workbench_volume_frag.glsl SRC)
 data_to_c_simple(engines/workbench/shaders/workbench_world_light_lib.glsl SRC)
 
+data_to_c_simple(engines/lanpr/shaders/lanpr_dpix_preview_geom.glsl SRC)
+data_to_c_simple(engines/lanpr/shaders/lanpr_dpix_preview_frag.glsl SRC)
+data_to_c_simple(engines/lanpr/shaders/lanpr_dpix_project_clip_frag.glsl SRC)
+data_to_c_simple(engines/lanpr/shaders/lanpr_dpix_project_passthrough_vert.glsl SRC)
+data_to_c_simple(engines/lanpr/shaders/lanpr_snake_image_peel_frag.glsl SRC)
+data_to_c_simple(engines/lanpr/shaders/lanpr_snake_line_connection_vert.glsl SRC)
+data_to_c_simple(engines/lanpr/shaders/lanpr_snake_line_connection_geom.glsl SRC)
+data_to_c_simple(engines/lanpr/shaders/lanpr_snake_line_connection_frag.glsl SRC)
+data_to_c_simple(engines/lanpr/shaders/lanpr_snake_edge_frag.glsl SRC)
+data_to_c_simple(engines/lanpr/shaders/lanpr_snake_multichannel_frag.glsl SRC)
+data_to_c_simple(engines/lanpr/shaders/lanpr_software_line_chain_geom.glsl SRC)
+data_to_c_simple(engines/lanpr/shaders/lanpr_software_passthrough_vert.glsl SRC)
+data_to_c_simple(engines/lanpr/shaders/lanpr_software_chain_geom.glsl SRC)
+
+
 data_to_c_simple(modes/shaders/common_globals_lib.glsl SRC)
 data_to_c_simple(modes/shaders/common_hair_lib.glsl SRC)
 data_to_c_simple(modes/shaders/common_hair_refine_vert.glsl SRC)

source/blender/draw/engines/lanpr/lanpr_all.h

@@ -0,0 +1,819 @@
+#pragma once
+
+#include "lanpr_util.h"
+#include "BLI_mempool.h"
+#include "BLI_utildefines.h"
+//#include "GPU_framebuffer.h"
+#include "GPU_batch.h"
+#include "GPU_framebuffer.h"
+#include "GPU_shader.h"
+#include "GPU_uniformbuffer.h"
+#include "GPU_viewport.h"
+#include "DNA_listBase.h"
+#include "DRW_render.h"
+#include "BKE_object.h"
+#include "DNA_mesh_types.h"
+#include "DNA_camera_types.h"
+#include "GPU_immediate.h"
+#include "GPU_immediate_util.h"
+#include "GPU_framebuffer.h"
+#include "DNA_lanpr_types.h"
+#include "DNA_meshdata_types.h"
+#include "BKE_customdata.h"
+#include "DEG_depsgraph_query.h"
+#include "GPU_draw.h"
+
+#include "BLI_threads.h"
+
+#include "GPU_batch.h"
+#include "GPU_framebuffer.h"
+#include "GPU_shader.h"
+#include "GPU_uniformbuffer.h"
+#include "GPU_viewport.h"
+#include "bmesh.h"
+
+#include "WM_types.h"
+#include "WM_api.h"
+
+
+
+#define LANPR_ENGINE "BLENDER_LANPR"
+
+#define TNS_PI 3.1415926535897932384626433832795
+#define deg(r) r / TNS_PI * 180.0
+#define rad(d) d *TNS_PI / 180.0
+
+#define tMatDist2v(p1, p2) \
+	sqrt(((p1)[0] - (p2)[0]) * ((p1)[0] - (p2)[0]) + ((p1)[1] - (p2)[1]) * ((p1)[1] - (p2)[1]))
+
+#define tnsLinearItp(L, R, T) \
+	((L) * (1.0f - (T)) + (R)*(T))
+
+typedef struct LANPR_RenderBuffer LANPR_RenderBuffer;
+
+typedef struct LANPR_SharedResource {
+
+	/* We only allocate once for all */
+	LANPR_RenderBuffer *render_buffer_shared;
+
+	/* Snake */
+	GPUShader *multichannel_shader;
+	GPUShader *edge_detect_shader;
+	GPUShader *edge_thinning_shader;
+	GPUShader *snake_connection_shader;
+
+	/* DPIX */
+	GPUShader *dpix_transform_shader;
+	GPUShader *dpix_preview_shader;
+
+	/* Software */
+	GPUShader *software_shader;
+	GPUShader *software_chaining_shader;
+
+	void *ved_viewport;
+	void *ved_render;
+
+
+	int init_complete;
+
+	SpinLock render_flag_lock;
+	int during_render;        // get/set using access funcion which uses render_flag_lock to lock.
+	                          // this prevents duplicate too much resource. (no render preview in viewport while rendering)
+
+} LANPR_SharedResource;
+
+#define TNS_DPIX_TEXTURE_SIZE 2048
+
+typedef struct LANPR_TextureSample {
+	Link Item;
+	int X, Y;
+	float Z;    // for future usage
+} LANPR_TextureSample;
+
+typedef struct LANPR_LineStripPoint {
+	Link Item;
+	float P[3];
+} LANPR_LineStripPoint;
+
+typedef struct LANPR_LineStrip {
+	Link Item;
+	ListBase points;
+	int point_count;
+	float total_length;
+}LANPR_LineStrip;
+
+typedef struct LANPR_PassList {
+	/* Snake */
+	struct DRWPass *depth_pass;
+	struct DRWPass *color_pass;
+	struct DRWPass *normal_pass;
+	struct DRWPass *edge_intermediate;
+	struct DRWPass *edge_thinning;
+	struct DRWPass *snake_pass;
+
+	/* DPIX */
+	struct DRWPass *dpix_transform_pass;
+	struct DRWPass *dpix_preview_pass;
+
+	/* SOFTWARE */
+	struct DRWPass *software_pass;
+
+} LANPR_PassList;
+
+typedef struct LANPR_FramebufferList {
+
+	/* Snake */
+	struct GPUFrameBuffer *passes;
+	struct GPUFrameBuffer *edge_intermediate;
+	struct GPUFrameBuffer *edge_thinning;
+
+	/* DPIX */
+	struct GPUFrameBuffer *dpix_transform;
+	struct GPUFrameBuffer *dpix_preview;
+
+	/* Software */
+	struct GPUFrameBuffer *software_ms;
+
+} LANPR_FramebufferList;
+
+typedef struct LANPR_TextureList {
+
+	struct GPUTexture *color;
+	struct GPUTexture *normal;
+	struct GPUTexture *depth;
+	struct GPUTexture *edge_intermediate;
+
+	struct GPUTexture *dpix_in_pl;/* point L */
+	struct GPUTexture *dpix_in_pr;/* point R */
+	struct GPUTexture *dpix_in_nl;/* normal L */
+	struct GPUTexture *dpix_in_nr;/* normal R */
+	struct GPUTexture *dpix_in_edge_mask;/* RGBA, R:Material, G: Freestyle Edge Mark, BA:Reserved for future usage */
+
+	struct GPUTexture *dpix_out_pl;
+	struct GPUTexture *dpix_out_pr;
+	struct GPUTexture *dpix_out_length;
+
+	/* multisample resolve */
+	struct GPUTexture *ms_resolve_depth;
+	struct GPUTexture *ms_resolve_color;
+
+} LANPR_TextureList;
+
+typedef struct LANPR_PrivateData {
+	DRWShadingGroup *multipass_shgrp;
+	DRWShadingGroup *edge_detect_shgrp;
+	DRWShadingGroup *edge_thinning_shgrp;
+	DRWShadingGroup *snake_shgrp;
+
+	DRWShadingGroup *dpix_transform_shgrp;
+	DRWShadingGroup *dpix_preview_shgrp;
+
+	DRWShadingGroup *debug_shgrp;
+
+	//snake
+
+	float normal_clamp;
+	float normal_strength;
+	float depth_clamp;
+	float depth_strength;
+
+	float zfar;
+	float znear;
+
+	int stage;//thinning
+
+	float         *line_result;
+	unsigned char *line_result_8bit;
+	int width, height;          // if not match recreate buffer.
+	void         **sample_table;
+
+	BLI_mempool *mp_sample;
+	BLI_mempool *mp_line_strip;
+	BLI_mempool *mp_line_strip_point;
+	BLI_mempool *mp_batch_list;
+
+	ListBase pending_samples;
+	ListBase erased_samples;
+	ListBase line_strips;
+
+	// dpix data
+
+	void *atlas_pl;
+	void *atlas_pr;
+	void *atlas_nl;
+	void *atlas_nr;
+	void *atlas_edge_mask;
+
+	int begin_index;
+
+	int dpix_sample_step;
+	int dpix_is_perspective;
+	float dpix_viewport[4];
+	float output_viewport[4];
+	int dpix_buffer_width;
+	float dpix_depth_offset;
+
+	float dpix_znear;
+	float dpix_zfar;
+
+	// drawing
+
+	unsigned v_buf;
+	unsigned i_buf;
+	unsigned l_buf;
+
+	GPUVertFormat snake_gwn_format;
+	GPUBatch *snake_batch;
+
+	ListBase dpix_batch_list;
+
+} LANPR_PrivateData;
+
+typedef struct LANPR_StorageList {
+	LANPR_PrivateData *g_data;
+} LANPR_StorageList;
+
+typedef struct LANPR_BatchItem {
+	Link Item;
+	GPUBatch *dpix_transform_batch;
+	GPUBatch *dpix_preview_batch;
+	Object *ob;
+} LANPR_BatchItem;
+
+typedef struct LANPR_Data {
+	void *engine_type;
+	LANPR_FramebufferList *fbl;
+	LANPR_TextureList *txl;
+	LANPR_PassList *psl;
+	LANPR_StorageList *stl;
+} LANPR_Data;
+
+
+
+/* Below ported from NUL_TNS.h */
+
+#define TNS_THREAD_LINE_COUNT 10000
+
+#define TNS_CALCULATION_IDLE         0
+#define TNS_CALCULATION_GEOMETRY     1
+#define TNS_CALCULATION_CONTOUR      2
+#define TNS_CALCULATION_INTERSECTION 3
+#define TNS_CALCULATION_OCCLUTION    4
+#define TNS_CALCULATION_FINISHED     100
+
+typedef struct LANPR_RenderTaskInfo {
+	//thrd_t           ThreadHandle;
+
+	struct LANPR_RenderBuffer *RenderBuffer;
+	int ThreadID;
+
+	struct nListItemPointer *Contour;
+	ListBase ContourPointers;
+
+	struct nListItemPointer *Intersection;
+	ListBase IntersectionPointers;
+
+	struct nListItemPointer *Crease;
+	ListBase CreasePointers;
+
+	struct nListItemPointer *Material;
+	ListBase MaterialPointers;
+
+	struct nListItemPointer *EdgeMark;
+	ListBase EdgeMarkPointers;
+
+} LANPR_RenderTaskInfo;
+
+typedef struct LANPR_RenderBuffer {
+	struct LANPR_RenderBuffer *prev, *next;
+
+	//nSafeString*       Name;
+
+	//tnsFrameBuffer*    FrameBuffer;
+	//now we move frame buffer content here
+	int W, H;
+	int SubPixelSample;//1,2,3,4, Use Squared Value.
+	int TileSizeW, TileSizeH;
+	int TileCountX, TileCountY;
+	real WidthPerTile, HeightPerTile;
+	tnsMatrix44d ViewProjection;
+	tnsMatrix44d VPInverse;
+
+	nSafeString *OutputFolder;   //end with a slash;
+	nSafeString *ImagePrefix;
+	nSafeString *ImageNameConnector;
+
+	int OutputMode;
+	int OutputAALevel;
+
+	struct LANPR_BoundingArea *InitialBoundingAreas;
+	u32bit BoundingAreaCount;
+	//u32bit             BaVBO;
+	//u32bit           BaFillVBO;
+
+	ListBase VertexBufferPointers;
+	ListBase LineBufferPointers;
+	ListBase TriangleBufferPointers;
+	ListBase AllRenderLines;
+
+	ListBase IntersectingVertexBuffer;
+
+	struct GPUBatch *DPIXIntersectionTransformBatch;
+	struct GPUBatch *DPIXIntersectionBatch;
+
+	/* use own-implemented one */
+	nStaticMemoryPool RenderDataPool;
+
+	Material           *MaterialPointers[2048];
+
+	//render status
+
+	int cached_for_frame;
+
+	real ViewVector[3];
+
+	int TriangleSize;
+
+	u32bit ContourCount;
+	u32bit ContourProcessed;
+	nListItemPointer *ContourManaged;
+	ListBase Contours;
+
+	u32bit IntersectionCount;
+	u32bit IntersectionProcessed;
+	nListItemPointer *IntersectionManaged;
+	ListBase IntersectionLines;
+
+	u32bit CreaseCount;
+	u32bit CreaseProcessed;
+	nListItemPointer *CreaseManaged;
+	ListBase CreaseLines;
+
+	u32bit MaterialLineCount;
+	u32bit MaterialProcessed;
+	nListItemPointer *MaterialManaged;
+	ListBase MaterialLines;
+
+	u32bit EdgeMarkCount;
+	u32bit EdgeMarkProcessed;
+	nListItemPointer *EdgeMarkManaged;
+	ListBase EdgeMarks;
+
+	ListBase Chains;
+	GPUBatch *ChainDrawBatch;
+	DRWShadingGroup *ChainShgrp;
+
+	SpinLock csInfo;
+	SpinLock csData;
+	SpinLock csManagement;
+
+	//settings
+
+	//int             OutputTransparent;
+	//real            Backgroundcolor[4];
+
+	int MaxOccludeLevel;
+	real CreaseAngle;
+	real CreaseCos;
+	int CreaseAllowOverride;
+	int ThreadCount;
+
+	real OverallProgress;
+	int CalculationStatus;
+
+	int DrawMaterialPreview;
+	real MaterialTransparency;
+
+	int ShowLine;
+	int ShowFast;
+	int ShowMaterial;
+	int OverrideDisplay;
+
+	//nListHandle DrawCommands; /* not used now */
+
+	//tnsRenderBufferPreviewNode RenderPreview[32];
+
+	struct Scene *Scene;
+	struct Object *Camera;
+
+	int enable_intersections;
+	int size;
+
+	//tnsRenderTriangles are in mesh object.
+}LANPR_RenderBuffer;
+
+
+#define TNS_CULL_DISCARD 2
+#define TNS_CULL_USED    1
+
+typedef struct LANPR_RenderTriangle {
+	nListItem Item;
+	struct LANPR_RenderVert *V[3];
+	struct LANPR_RenderLine *RL[3];
+	real GN[3];
+	real GC[3];
+	//struct BMFace *F;
+	short MaterialID;
+	ListBase IntersectingVerts;
+	char CullStatus;
+	struct LANPR_RenderTriangle *Testing;   //Should Be tRT** Testing[NumOfThreads]
+}LANPR_RenderTriangle;
+
+typedef struct LANPR_RenderTriangleThread {
+	struct LANPR_RenderTriangle Base;
+	struct LANPR_RenderLine *Testing[127];    //max thread support;
+}LANPR_RenderTriangleThread;
+
+typedef struct LANPR_RenderElementLinkNode {
+	nListItem Item;
+	void *Pointer;
+	int ElementCount;
+	void *ObjectRef;
+	char Additional;
+}LANPR_RenderElementLinkNode;
+
+typedef struct LANPR_RenderLineSegment {
+	nListItem Item;
+	//real     Begin, End;  // 0->At[L] 1->At[R]
+	real at;
+	u8bit OcclusionLevel;    //after
+}LANPR_RenderLineSegment;
+
+typedef struct LANPR_RenderVert {
+	nListItem Item;
+	real GLocation[4];
+	real FrameBufferCoord[4];
+	int FrameBufferCoordi[2];
+	struct BMVert *V;              //Used As R When Intersecting
+	struct LANPR_RenderLine *IntersectingLine;
+	struct LANPR_RenderLine *IntersectintLine2;
+	struct LANPR_RenderTriangle *IntersectWith;     //   Positive 1         Negative 0
+	//tnsRenderTriangle* IntersectingOnFace;       //         <|               |>
+	char Positive;                    //                 L---->|----->R	 L---->|----->R
+	char EdgeUsed;                    //                      <|		       |>
+}LANPR_RenderVert;
+
+#define LANPR_EDGE_FLAG_EDGE_MARK    1
+#define LANPR_EDGE_FLAG_CONTOUR      2
+#define LANPR_EDGE_FLAG_CREASE       4
+#define LANPR_EDGE_FLAG_MATERIAL     8
+#define LANPR_EDGE_FLAG_INTERSECTION 16
+#define LANPR_EDGE_FLAG_FLOATING     32 // floating edge, unimplemented yet
+#define LANPR_EDGE_FLAG_CHAIN_PICKED 64
+
+#define LANPR_EDGE_FLAG_ALL_TYPE     0x3f
+
+typedef struct LANPR_RenderLine {
+	nListItem Item;
+	struct LANPR_RenderVert *L, *R;
+	struct LANPR_RenderTriangle *TL, *TR;
+	ListBase Segments;
+	//tnsEdge*       Edge;//should be edge material
+	//tnsRenderTriangle* Testing;//Should Be tRT** Testing[NumOfThreads]
+	char MinOcclude;
+	char Flags; // also for line type determination on chainning
+	struct Object *ObjectRef;
+}LANPR_RenderLine;
+
+typedef struct LANPR_RenderLineChain {
+	nListItem Item;
+	ListBase Chain;
+	//int         SegmentCount;  // we count before draw cmd.
+	float Length;                // calculated before draw cmd.
+}LANPR_RenderLineChain;
+
+typedef struct LANPR_RenderLineChainItem {
+	nListItem Item;
+	float pos[3];       // need z value for fading
+	float normal[3];
+	char LineType;             //      style of [1]       style of [2]
+	char OcclusionLevel;         // [1]--------------->[2]---------------->[3]--....
+}LANPR_RenderLineChainItem;
+
+typedef struct LANPR_BoundingArea {
+	real L, R, U, B;
+	real CX, CY;
+
+	struct LANPR_BoundingArea *Child;//1,2,3,4 quadrant
+
+	ListBase LP;
+	ListBase RP;
+	ListBase UP;
+	ListBase BP;
+
+	int TriangleCount;
+	ListBase LinkedTriangles;
+	ListBase LinkedLines;
+	ListBase LinkedChains;//reserved for multithread chainning
+}LANPR_BoundingArea;
+
+
+#define TNS_COMMAND_LINE     0
+#define TNS_COMMAND_MATERIAL 1
+#define TNS_COMMAND_EDGE     2
+
+#define TNS_TRANSPARENCY_DRAW_SIMPLE  0
+#define TNS_TRANSPARENCY_DRAW_LAYERED 1
+
+#define TNS_OVERRIDE_ONLY                     0
+#define TNS_OVERRIDE_EXCLUDE                  1
+//#define TNS_OVERRIDE_ALL_OTHERS_OUTSIDE_GROUP 2
+//#define TNS_OVERRIDE_ALL_OTHERS_IN_GROUP      3
+//#define TNS_OVERRIDE_ALL_OTHERS               4
+
+extern RenderEngineType DRW_engine_viewport_lanpr_type;
+
+
+
+#define tnsLinearItp(L, R, T) \
+	((L) * (1.0f - (T)) + (R)*(T))
+
+
+#define TNS_TILE(tile, r, c, CCount) \
+	tile[r * CCount + c]
+
+#define TNS_CLAMP(a, Min, Max) \
+	a = a < Min ? Min : (a > Max ? Max : a)
+
+#define TNS_MAX2_INDEX(a, b) \
+	(a > b ? 0 : 1)
+
+#define TNS_MIN2_INDEX(a, b) \
+	(a < b ? 0 : 1)
+
+#define TNS_MAX3_INDEX(a, b, c) \
+	(a > b ? (a > c ? 0 : (b > c ? 1 : 2)) : (b > c ? 1 : 2))
+
+#define TNS_MIN3_INDEX(a, b, c) \
+	(a < b ? (a < c ? 0 : (b < c ? 1 : 2)) : (b < c ? 1 : 2))
+
+#define TNS_MAX3_INDEX_ABC(x, y, z) \
+	(x > y ? (x > z ? a : (y > z ? b : c)) : (y > z ? b : c))
+
+#define TNS_MIN3_INDEX_ABC(x, y, z) \
+	(x < y ? (x < z ? a : (y < z ? b : c)) : (y < z ? b : c))
+
+#define TNS_ABC(index) \
+	(index == 0 ? a : (index == 1 ? b : c))
+
+
+#define TNS_DOUBLE_CLOSE_ENOUGH(a, b) \
+	(((a) + DBL_EDGE_LIM) >= (b) && ((a) - DBL_EDGE_LIM) <= (b))
+
+//#define TNS_DOUBLE_CLOSE_ENOUGH(a,b)\
+// //(((a)+0.00000000001)>=(b) && ((a)-0.0000000001)<=(b))
+
+
+#define TNS_FLOAT_CLOSE_ENOUGH_WIDER(a, b) \
+	(((a) + 0.0000001) >= (b) && ((a) - 0.0000001) <= (b))
+
+#define TNS_IN_TILE_X(RenderTile, Fx) \
+	(RenderTile->FX <= Fx && RenderTile->FXLim >= Fx)
+
+#define TNS_IN_TILE_Y(RenderTile, Fy) \
+	(RenderTile->FY <= Fy && RenderTile->FYLim >= Fy)
+
+
+#define TNS_IN_TILE(RenderTile, Fx, Fy) \
+	(TNS_IN_TILE_X(RenderTile, Fx) && TNS_IN_TILE_Y(RenderTile, Fy))
+
+BLI_INLINE void tMatConvert44df(tnsMatrix44d from, tnsMatrix44f to) {
+	to[0] = from[0];
+	to[1] = from[1];
+	to[2] = from[2];
+	to[3] = from[3];
+	to[4] = from[4];
+	to[5] = from[5];
+	to[6] = from[6];
+	to[7] = from[7];
+	to[8] = from[8];
+	to[9] = from[9];
+	to[10] = from[10];
+	to[11] = from[11];
+	to[12] = from[12];
+	to[13] = from[13];
+	to[14] = from[14];
+	to[15] = from[15];
+}
+
+BLI_INLINE int lanpr_TrangleLineBoundBoxTest(LANPR_RenderTriangle *rt, LANPR_RenderLine *rl) {
+	if (MAX3(rt->V[0]->FrameBufferCoord[2], rt->V[1]->FrameBufferCoord[2], rt->V[2]->FrameBufferCoord[2]) > MIN2(rl->L->FrameBufferCoord[2], rl->R->FrameBufferCoord[2])) return 0;
+	if (MAX3(rt->V[0]->FrameBufferCoord[0], rt->V[1]->FrameBufferCoord[0], rt->V[2]->FrameBufferCoord[0]) < MIN2(rl->L->FrameBufferCoord[0], rl->R->FrameBufferCoord[0])) return 0;
+	if (MIN3(rt->V[0]->FrameBufferCoord[0], rt->V[1]->FrameBufferCoord[0], rt->V[2]->FrameBufferCoord[0]) > MAX2(rl->L->FrameBufferCoord[0], rl->R->FrameBufferCoord[0])) return 0;
+	if (MAX3(rt->V[0]->FrameBufferCoord[1], rt->V[1]->FrameBufferCoord[1], rt->V[2]->FrameBufferCoord[1]) < MIN2(rl->L->FrameBufferCoord[1], rl->R->FrameBufferCoord[1])) return 0;
+	if (MIN3(rt->V[0]->FrameBufferCoord[1], rt->V[1]->FrameBufferCoord[1], rt->V[2]->FrameBufferCoord[1]) > MAX2(rl->L->FrameBufferCoord[1], rl->R->FrameBufferCoord[1])) return 0;
+	return 1;
+}
+
+BLI_INLINE double tMatGetLinearRatio(real L, real R, real FromL);
+BLI_INLINE int lanpr_LineIntersectTest2d(const double *a1, const double *a2, const double *b1, const double *b2, double *aRatio) {
+	double k1, k2;
+	double x;
+	double y;
+	double Ratio;
+	double xDiff = (a2[0] - a1[0]);// +DBL_EPSILON;
+	double xDiff2 = (b2[0] - b1[0]);
+
+	if (xDiff == 0) {
+		if (xDiff2 == 0) {
+			*aRatio = 0;
+			return 0;
+		}
+		double r2 = tMatGetLinearRatio(b1[0], b2[0], a1[0]);
+		x = tnsLinearItp(b1[0], b2[0], r2);
+		y = tnsLinearItp(b1[1], b2[1], r2);
+		*aRatio = Ratio = tMatGetLinearRatio(a1[1], a2[1], y);
+	}
+	else {
+		if (xDiff2 == 0) {
+			Ratio = tMatGetLinearRatio(a1[0], a2[0], b1[0]);
+			x = tnsLinearItp(a1[0], a2[0], Ratio);
+			*aRatio = Ratio;
+		}
+		else {
+			k1 = (a2[1] - a1[1]) / xDiff;
+			k2 = (b2[1] - b1[1]) / xDiff2;
+
+			if ((k1 == k2))
+				return 0;
+
+			x = (a1[1] - b1[1] - k1 * a1[0] + k2 * b1[0]) / (k2 - k1);
+
+			Ratio = (x - a1[0]) / xDiff;
+
+			*aRatio = Ratio;
+		}
+	}
+
+
+
+	if (b1[0] == b2[0]) {
+		y = tnsLinearItp(a1[1], a2[1], Ratio);
+		if (y > MAX2(b1[1], b2[1]) || y < MIN2(b1[1], b2[1])) return 0;
+	}
+	else
+	if (Ratio <= 0 || Ratio > 1 ||
+	    (b1[0] > b2[0] && x > b1[0]) ||
+	    (b1[0] < b2[0] && x < b1[0]) ||
+	    (b2[0] > b1[0] && x > b2[0]) ||
+	    (b2[0] < b1[0] && x < b2[0]))
+		return 0;
+
+	return 1;
+}
+BLI_INLINE double lanpr_GetLineZ(tnsVector3d L, tnsVector3d R, real Ratio) {
+	//double z = 1 / tnsLinearItp(1 / L[2], 1 / R[2], Ratio);
+	double z = tnsLinearItp(L[2], R[2], Ratio);
+	return z;
+}
+BLI_INLINE double lanpr_GetLineZPoint(tnsVector3d L, tnsVector3d R, tnsVector3d FromL) {
+	double r = (FromL[0] - L[0]) / (R[0] - L[0]);
+	return tnsLinearItp(L[2], R[2], r);
+	//return 1 / tnsLinearItp(1 / L[2], 1 / R[2], r);
+}
+BLI_INLINE double lanpr_GetLinearRatio(tnsVector3d L, tnsVector3d R, tnsVector3d FromL) {
+	double r = (FromL[0] - L[0]) / (R[0] - L[0]);
+	return r;
+}
+
+BLI_INLINE double tMatGetLinearRatio(real L, real R, real FromL) {
+	double r = (FromL - L) / (R - L);
+	return r;
+}
+BLI_INLINE void tMatVectorMinus2d(tnsVector2d result, tnsVector2d l, tnsVector2d r) {
+	result[0] = l[0] - r[0];
+	result[1] = l[1] - r[1];
+}
+
+BLI_INLINE void tMatVectorMinus3d(tnsVector3d result, tnsVector3d l, tnsVector3d r) {
+	result[0] = l[0] - r[0];
+	result[1] = l[1] - r[1];
+	result[2] = l[2] - r[2];
+}
+BLI_INLINE void tMatVectorSubtract3d(tnsVector3d l, tnsVector3d r) {
+	l[0] = l[0] - r[0];
+	l[1] = l[1] - r[1];
+	l[2] = l[2] - r[2];
+}
+BLI_INLINE void tMatVectorPlus3d(tnsVector3d result, tnsVector3d l, tnsVector3d r) {
+	result[0] = l[0] + r[0];
+	result[1] = l[1] + r[1];
+	result[2] = l[2] + r[2];
+}
+BLI_INLINE void tMatVectorAccum3d(tnsVector3d l, tnsVector3d r) {
+	l[0] = l[0] + r[0];
+	l[1] = l[1] + r[1];
+	l[2] = l[2] + r[2];
+}
+BLI_INLINE void tMatVectorAccum2d(tnsVector2d l, tnsVector2d r) {
+	l[0] = l[0] + r[0];
+	l[1] = l[1] + r[1];
+}
+BLI_INLINE void tMatVectorNegate3d(tnsVector3d result, tnsVector3d l) {
+	result[0] = -l[0];
+	result[1] = -l[1];
+	result[2] = -l[2];
+}
+BLI_INLINE void tMatVectorNegateSelf3d(tnsVector3d l) {
+	l[0] = -l[0];
+	l[1] = -l[1];
+	l[2] = -l[2];
+}
+BLI_INLINE void tMatVectorCopy2d(tnsVector2d from, tnsVector2d to) {
+	to[0] = from[0];
+	to[1] = from[1];
+}
+BLI_INLINE void tMatVectorCopy3d(tnsVector3d from, tnsVector3d to) {
+	to[0] = from[0];
+	to[1] = from[1];
+	to[2] = from[2];
+}
+BLI_INLINE void tMatVectorCopy4d(tnsVector4d from, tnsVector4d to) {
+	to[0] = from[0];
+	to[1] = from[1];
+	to[2] = from[2];
+	to[3] = from[3];
+}
+BLI_INLINE void tMatVectorMultiSelf4d(tnsVector3d from, real num) {
+	from[0] *= num;
+	from[1] *= num;
+	from[2] *= num;
+	from[3] *= num;
+}
+BLI_INLINE void tMatVectorMultiSelf3d(tnsVector3d from, real num) {
+	from[0] *= num;
+	from[1] *= num;
+	from[2] *= num;
+}
+BLI_INLINE void tMatVectorMultiSelf2d(tnsVector3d from, real num) {
+	from[0] *= num;
+	from[1] *= num;
+}
+
+BLI_INLINE real tMatDirectionToRad(tnsVector2d Dir) {
+	real arcc = acos(Dir[0]);
+	real arcs = asin(Dir[1]);
+
+	if (Dir[0] >= 0) {
+		if (Dir[1] >= 0) return arcc;
+		else return TNS_PI * 2 - arcc;
+	}
+	else {
+		if (Dir[1] >= 0) return arcs + TNS_PI / 2;
+		else return TNS_PI + arcs;
+	}
+}
+
+
+BLI_INLINE void tMatVectorConvert4fd(tnsVector4f from, tnsVector4d to) {
+	to[0] = from[0];
+	to[1] = from[1];
+	to[2] = from[2];
+	to[3] = from[3];
+}
+
+BLI_INLINE void tMatVectorConvert3fd(tnsVector3f from, tnsVector3d to) {
+	to[0] = from[0];
+	to[1] = from[1];
+	to[2] = from[2];
+}
+
+
+int lanpr_point_inside_triangled(tnsVector2d v, tnsVector2d v0, tnsVector2d v1, tnsVector2d v2);
+real lanpr_LinearInterpolate(real L, real R, real T);
+void lanpr_LinearInterpolate2dv(real *L, real *R, real T, real *Result);
+void lanpr_LinearInterpolate3dv(real *L, real *R, real T, real *Result);
+
+
+
+// functions
+
+// dpix
+
+void lanpr_init_atlas_inputs(void *ved);
+void lanpr_destroy_atlas(void *ved);
+int lanpr_feed_atlas_data_obj(void *vedata,
+                              float *AtlasPointsL, float *AtlasPointsR,
+                              float *AtlasFaceNormalL, float *AtlasFaceNormalR,
+                              float *AtlasEdgeMask,
+                              Object *ob, int begin_index);
+
+int lanpr_feed_atlas_data_intersection_cache(void *vedata,
+                                             float *AtlasPointsL, float *AtlasPointsR,
+                                             float *AtlasFaceNormalL, float *AtlasFaceNormalR,
+                                             float *AtlasEdgeMask,
+                                             int begin_index);
+
+int lanpr_feed_atlas_trigger_preview_obj(void *vedata, Object *ob, int begin_index);
+void lanpr_create_atlas_intersection_preview(void *vedata, int begin_index);
+
+void lanpr_dpix_draw_scene(LANPR_TextureList *txl, LANPR_FramebufferList *fbl, LANPR_PassList *psl, LANPR_PrivateData *pd, SceneLANPR *lanpr, GPUFrameBuffer *DefaultFB, int is_render);
+
+void lanpr_snake_draw_scene(LANPR_TextureList *txl, LANPR_FramebufferList *fbl, LANPR_PassList *psl, LANPR_PrivateData *pd, SceneLANPR *lanpr, GPUFrameBuffer *DefaultFB, int is_render);
+
+void lanpr_software_draw_scene(void *vedata, GPUFrameBuffer *dfb, int is_render);
+
+void lanpr_set_render_flag();
+void lanpr_clear_render_flag();
+int lanpr_during_render();
+

source/blender/draw/engines/lanpr/lanpr_chain.c

@@ -0,0 +1,421 @@
+#include "DRW_engine.h"
+#include "DRW_render.h"
+#include "BLI_listbase.h"
+#include "BLI_linklist.h"
+#include "BLI_math.h"
+#include "lanpr_all.h"
+#include "DRW_render.h"
+#include "BKE_object.h"
+#include "DNA_mesh_types.h"
+#include "DNA_camera_types.h"
+#include "GPU_immediate.h"
+#include "GPU_immediate_util.h"
+#include "GPU_framebuffer.h"
+#include "DNA_lanpr_types.h"
+#include "DNA_meshdata_types.h"
+#include "BKE_customdata.h"
+#include "DEG_depsgraph_query.h"
+#include "GPU_draw.h"
+
+#include "GPU_batch.h"
+#include "GPU_framebuffer.h"
+#include "GPU_shader.h"
+#include "GPU_uniformbuffer.h"
+#include "GPU_viewport.h"
+#include "bmesh.h"
+
+#include <math.h>
+
+int lanpr_get_line_bounding_areas(LANPR_RenderBuffer *rb, LANPR_RenderLine *rl, int *rowBegin, int *rowEnd, int *colBegin, int *colEnd);
+LANPR_BoundingArea *lanpr_get_point_bounding_area(LANPR_RenderBuffer *rb, real x, real y);
+
+#define LANPR_OTHER_RV(rl, rv) ((rv) == (rl)->L ? (rl)->R : (rl)->L)
+
+LANPR_RenderLine *lanpr_get_connected_render_line(LANPR_BoundingArea *ba, LANPR_RenderVert *rv, LANPR_RenderVert **new_rv) {
+	nListItemPointer *lip;
+	LANPR_RenderLine *nrl;
+	real cosine;
+
+	for (lip = ba->LinkedLines.first; lip; lip = lip->pNext) {
+		nrl = lip->p;
+
+		if ((!(nrl->Flags & LANPR_EDGE_FLAG_ALL_TYPE)) || (nrl->Flags & LANPR_EDGE_FLAG_CHAIN_PICKED)) continue;
+
+		// always chain connected lines for now.
+		// simplification will take care of the sharp points.
+		// if(cosine whatever) continue;
+
+		if (rv != nrl->L && rv != nrl->R) {
+			if (nrl->Flags & LANPR_EDGE_FLAG_INTERSECTION) {
+				if (rv->FrameBufferCoord[0] == nrl->L->FrameBufferCoord[0] && rv->FrameBufferCoord[1] == nrl->L->FrameBufferCoord[1]) {
+					*new_rv = LANPR_OTHER_RV(nrl, nrl->L);
+					return nrl;
+				} elif(rv->FrameBufferCoord[0] == nrl->R->FrameBufferCoord[0] && rv->FrameBufferCoord[1] == nrl->R->FrameBufferCoord[1])
+				{
+					*new_rv = LANPR_OTHER_RV(nrl, nrl->R);
+					return nrl;
+				}
+			}
+			continue;
+		}
+
+		*new_rv = LANPR_OTHER_RV(nrl, rv);
+		return nrl;
+	}
+
+	return 0;
+}
+
+int lanpr_get_nearby_render_line(LANPR_BoundingArea *ba, LANPR_RenderLine *rl){
+	// hold on
+	return 1;
+}
+
+LANPR_RenderLineChain *lanpr_create_render_line_chain(LANPR_RenderBuffer *rb){
+	LANPR_RenderLineChain *rlc;
+	rlc = mem_static_aquire(&rb->RenderDataPool, sizeof(LANPR_RenderLineChain));
+
+	BLI_addtail(&rb->Chains, rlc);
+
+	return rlc;
+}
+
+LANPR_RenderLineChainItem *lanpr_append_render_line_chain_point(LANPR_RenderBuffer *rb, LANPR_RenderLineChain *rlc, float x, float y, float* normal, char type, int level){
+	LANPR_RenderLineChainItem *rlci;
+	rlci = mem_static_aquire(&rb->RenderDataPool, sizeof(LANPR_RenderLineChainItem));
+
+	rlci->pos[0] = x;
+	rlci->pos[1] = y;
+	copy_v3_v3(rlci->normal, normal);
+	rlci->LineType = type & LANPR_EDGE_FLAG_ALL_TYPE;
+	rlci->OcclusionLevel = level;
+	BLI_addtail(&rlc->Chain, rlci);
+
+	//printf("a %f,%f %d\n", x, y, level);
+
+	return rlci;
+}
+
+LANPR_RenderLineChainItem *lanpr_push_render_line_chain_point(LANPR_RenderBuffer *rb, LANPR_RenderLineChain *rlc, float x, float y, float* normal, char type, int level){
+	LANPR_RenderLineChainItem *rlci;
+	rlci = mem_static_aquire(&rb->RenderDataPool, sizeof(LANPR_RenderLineChainItem));
+
+	rlci->pos[0] = x;
+	rlci->pos[1] = y;
+	copy_v3_v3(rlci->normal, normal);
+	rlci->LineType = type & LANPR_EDGE_FLAG_ALL_TYPE;
+	rlci->OcclusionLevel = level;
+	BLI_addhead(&rlc->Chain, rlci);
+
+	//printf("p %f,%f %d\n", x, y, level);
+
+	return rlci;
+}
+
+// refer to http://karthaus.nl/rdp/ for description
+void lanpr_reduce_render_line_chain_recursive(LANPR_RenderLineChain *rlc, LANPR_RenderLineChainItem *from, LANPR_RenderLineChainItem *to, float dist_threshold){
+	LANPR_RenderLineChainItem *rlci, *next_rlci;
+	float l[2], r[2], c[2];
+	float max_dist = 0;
+	LANPR_RenderLineChainItem *max_rlci = 0;
+
+	// find the max distance item
+	for (rlci = from->Item.pNext; rlci != to; rlci = next_rlci) {
+		next_rlci = rlci->Item.pNext;
+
+		if (next_rlci && (next_rlci->OcclusionLevel != rlci->OcclusionLevel || next_rlci->LineType != rlci->LineType)) continue;
+
+		float dist = dist_to_line_segment_v2(rlci->pos, from->pos, to->pos);
+		if (dist > dist_threshold && dist > max_dist) { max_dist = dist; max_rlci = rlci; }
+		//if (dist <= dist_threshold) BLI_remlink(&rlc->Chain, (void*)rlci);
+	}
+
+	if (!max_rlci) {
+		if (from->Item.pNext == to) return;
+		for (rlci = from->Item.pNext; rlci != to; rlci = next_rlci) {
+			next_rlci = rlci->Item.pNext;
+			if (next_rlci && (next_rlci->OcclusionLevel != rlci->OcclusionLevel || next_rlci->LineType != rlci->LineType)) continue;
+			BLI_remlink(&rlc->Chain, (void *)rlci);
+		}
+	}
+	else {
+		if (from->Item.pNext != max_rlci) lanpr_reduce_render_line_chain_recursive(rlc, from, max_rlci, dist_threshold);
+		if (to->Item.pPrev != max_rlci) lanpr_reduce_render_line_chain_recursive(rlc, max_rlci, to, dist_threshold);
+	}
+}
+
+
+void lanpr_NO_THREAD_chain_feature_lines(LANPR_RenderBuffer *rb, float dist_threshold){
+	LANPR_RenderLineChain *rlc;
+	LANPR_RenderLineChainItem *rlci;
+	LANPR_RenderLine *rl;
+	LANPR_BoundingArea *ba;
+	LANPR_RenderLineSegment *rls;
+
+	for (rl = rb->AllRenderLines.first; rl; rl = rl->Item.pNext) {
+
+		if ((!(rl->Flags & LANPR_EDGE_FLAG_ALL_TYPE)) || (rl->Flags & LANPR_EDGE_FLAG_CHAIN_PICKED)) continue;
+
+		rl->Flags |= LANPR_EDGE_FLAG_CHAIN_PICKED;
+
+		rlc = lanpr_create_render_line_chain(rb);
+
+		int r1, r2, c1, c2, row, col;
+		LANPR_RenderLine *new_rl = rl;
+		LANPR_RenderVert *new_rv;
+		float N[3] = { 0 };
+
+		if (rl->TL) {
+			N[0] += rl->TL->GN[0];
+			N[1] += rl->TL->GN[1];
+			N[2] += rl->TL->GN[2];
+		}
+		if (rl->TR) {
+			N[0] += rl->TR->GN[0];
+			N[1] += rl->TR->GN[1];
+			N[2] += rl->TR->GN[2];
+		}
+		if (rl->TL || rl->TR) {
+			normalize_v3(N);
+		}
+
+		// step 1: grow left
+		ba = lanpr_get_point_bounding_area(rb, rl->L->FrameBufferCoord[0], rl->L->FrameBufferCoord[1]);
+		new_rv = rl->L;
+		rls = rl->Segments.first;
+		lanpr_push_render_line_chain_point(rb, rlc, new_rv->FrameBufferCoord[0], new_rv->FrameBufferCoord[1], N, rl->Flags, rls->OcclusionLevel);
+		while (ba && (new_rl = lanpr_get_connected_render_line(ba, new_rv, &new_rv))) {
+			new_rl->Flags |= LANPR_EDGE_FLAG_CHAIN_PICKED;
+
+			int last_occlusion;
+
+			N[0] = N[1] = N[2] = 0;
+			if (new_rl->TL) {
+				N[0] += new_rl ->TL->GN[0];
+				N[1] += new_rl ->TL->GN[1];
+				N[2] += new_rl ->TL->GN[2];
+			}
+			if (new_rl->TR) {
+				N[0] += new_rl->TR->GN[0];
+				N[1] += new_rl->TR->GN[1];
+				N[2] += new_rl->TR->GN[2];
+			}
+			if (rl->TL || rl->TR) {
+				normalize_v3(N);
+			}
+
+			if (new_rv == new_rl->L) {
+				for (rls = new_rl->Segments.last; rls; rls = rls->Item.pPrev) {
+					float px, py;
+					px = tnsLinearItp(new_rl->L->FrameBufferCoord[0], new_rl->R->FrameBufferCoord[0], rls->at);
+					py = tnsLinearItp(new_rl->L->FrameBufferCoord[1], new_rl->R->FrameBufferCoord[1], rls->at);
+					lanpr_push_render_line_chain_point(rb, rlc, px, py, N, new_rl->Flags, rls->OcclusionLevel);
+				}
+			} elif(new_rv == new_rl->R)
+			{
+				rls = new_rl->Segments.first;
+				last_occlusion = rls->OcclusionLevel;
+				rls = rls->Item.pNext;
+				for (rls; rls; rls = rls->Item.pNext) {
+					float px, py;
+					px = tnsLinearItp(new_rl->L->FrameBufferCoord[0], new_rl->R->FrameBufferCoord[0], rls->at);
+					py = tnsLinearItp(new_rl->L->FrameBufferCoord[1], new_rl->R->FrameBufferCoord[1], rls->at);
+					lanpr_push_render_line_chain_point(rb, rlc, px, py, N, new_rl->Flags, last_occlusion);
+					last_occlusion = rls->OcclusionLevel;
+				}
+				lanpr_push_render_line_chain_point(rb, rlc, new_rl->R->FrameBufferCoord[0], new_rl->R->FrameBufferCoord[1], N, new_rl->Flags, last_occlusion);
+			}
+			ba = lanpr_get_point_bounding_area(rb, new_rv->FrameBufferCoord[0], new_rv->FrameBufferCoord[1]);
+		}
+
+		// step 2: this line
+		rls = rl->Segments.first;
+		for (rls = rls->Item.pNext; rls; rls = rls->Item.pNext) {
+			float px, py;
+			px = tnsLinearItp(rl->L->FrameBufferCoord[0], rl->R->FrameBufferCoord[0], rls->at);
+			py = tnsLinearItp(rl->L->FrameBufferCoord[1], rl->R->FrameBufferCoord[1], rls->at);
+			lanpr_append_render_line_chain_point(rb, rlc, px, py, N, rl->Flags, rls->OcclusionLevel);
+		}
+		lanpr_append_render_line_chain_point(rb, rlc, rl->R->FrameBufferCoord[0], rl->R->FrameBufferCoord[1], N, rl->Flags, 0);
+
+		// step 3: grow right
+		ba = lanpr_get_point_bounding_area(rb, rl->R->FrameBufferCoord[0], rl->R->FrameBufferCoord[1]);
+		new_rv = rl->R;
+		// below already done in step 2
+		// lanpr_push_render_line_chain_point(rb,rlc,new_rv->FrameBufferCoord[0],new_rv->FrameBufferCoord[1],rl->Flags,0);
+		while (ba && (new_rl = lanpr_get_connected_render_line(ba, new_rv, &new_rv))) {
+			new_rl->Flags |= LANPR_EDGE_FLAG_CHAIN_PICKED;
+
+			int last_occlusion;
+
+			// fix leading vertex type
+			rlci = rlc->Chain.last;
+			rlci->LineType = new_rl->Flags & LANPR_EDGE_FLAG_ALL_TYPE;
+
+			if (new_rv == new_rl->L) {
+				rls = new_rl->Segments.last;
+				last_occlusion = rls->OcclusionLevel;
+				rlci->OcclusionLevel = last_occlusion;
+				rls = rls->Item.pPrev;
+				if (rls) last_occlusion = rls->OcclusionLevel;
+				for (rls = new_rl->Segments.last; rls; rls = rls->Item.pPrev) {
+					float px, py;
+					px = tnsLinearItp(new_rl->L->FrameBufferCoord[0], new_rl->R->FrameBufferCoord[0], rls->at);
+					py = tnsLinearItp(new_rl->L->FrameBufferCoord[1], new_rl->R->FrameBufferCoord[1], rls->at);
+					last_occlusion = rls->Item.pPrev ? ((LANPR_RenderLineSegment *)rls->Item.pPrev)->OcclusionLevel : 0;
+					lanpr_append_render_line_chain_point(rb, rlc, px, py, N, new_rl->Flags, last_occlusion);
+				}
+			} elif(new_rv == new_rl->R)
+			{
+				rls = new_rl->Segments.first;
+				last_occlusion = rls->OcclusionLevel;
+				rlci->OcclusionLevel = last_occlusion;
+				rls = rls->Item.pNext;
+				for (rls; rls; rls = rls->Item.pNext) {
+					float px, py;
+					px = tnsLinearItp(new_rl->L->FrameBufferCoord[0], new_rl->R->FrameBufferCoord[0], rls->at);
+					py = tnsLinearItp(new_rl->L->FrameBufferCoord[1], new_rl->R->FrameBufferCoord[1], rls->at);
+					lanpr_append_render_line_chain_point(rb, rlc, px, py, N, new_rl->Flags, rls->OcclusionLevel);
+					//last_occlusion = rls->OcclusionLevel;
+				}
+				lanpr_append_render_line_chain_point(rb, rlc, new_rl->R->FrameBufferCoord[0], new_rl->R->FrameBufferCoord[1], N, new_rl->Flags, 0);
+			}
+			ba = lanpr_get_point_bounding_area(rb, new_rv->FrameBufferCoord[0], new_rv->FrameBufferCoord[1]);
+		}
+
+		//LANPR_RenderLineChainItem* rlci;
+		//printf("line:\n");
+		//for (rlci = rlc->Chain.first; rlci; rlci = rlci->Item.pNext) {
+		//	printf("  %f,%f %d\n", rlci->pos[0],rlci->pos[1], rlci->OcclusionLevel);
+		//}
+		//printf("--------\n");
+
+		//lanpr_reduce_render_line_chain_recursive(rlc,rlc->Chain.first, rlc->Chain.last, dist_threshold);
+	}
+}
+
+int lanpr_count_chain(LANPR_RenderLineChain *rlc){
+	LANPR_RenderLineChainItem *rlci;
+	int Count = 0;
+	for (rlci = rlc->Chain.first; rlci; rlci = rlci->Item.pNext) {
+		Count++;
+	}
+	return Count;
+}
+
+float lanpr_compute_chain_length(LANPR_RenderLineChain *rlc, float *lengths, int begin_index) {
+	LANPR_RenderLineChainItem *rlci;
+	int i = 0;
+	float offset_accum = 0;
+	float dist;
+	float last_point[2];
+
+	rlci = rlc->Chain.first;
+	copy_v2_v2(last_point, rlci->pos);
+	for (rlci = rlc->Chain.first; rlci; rlci = rlci->Item.pNext) {
+		dist = len_v2v2(rlci->pos, last_point);
+		offset_accum += dist;
+		lengths[begin_index + i] = offset_accum;
+		copy_v2_v2(last_point, rlci->pos);
+		i++;
+	}
+	return offset_accum;
+}
+
+int lanpr_get_gpu_line_type(LANPR_RenderLineChainItem *rlci) {
+	switch (rlci->LineType) {
+		case LANPR_EDGE_FLAG_CONTOUR:         return 0;
+		case LANPR_EDGE_FLAG_CREASE:          return 1;
+		case LANPR_EDGE_FLAG_MATERIAL:        return 2;
+		case LANPR_EDGE_FLAG_EDGE_MARK:       return 3;
+		case LANPR_EDGE_FLAG_INTERSECTION:    return 4;
+		default: return 0;
+	}
+}
+
+void lanpr_chain_generate_draw_command(LANPR_RenderBuffer *rb){
+	LANPR_RenderLineChain *rlc;
+	LANPR_RenderLineChainItem *rlci;
+	int vert_count = 0;
+	int i = 0;
+	int arg;
+	float total_length;
+	float *lengths;
+	float length_target[2];
+
+	static GPUVertFormat format = { 0 };
+	static struct { uint pos, uvs, normal, type, level; } attr_id;
+	if (format.attr_len == 0) {
+		attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
+		attr_id.uvs = GPU_vertformat_attr_add(&format, "uvs", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
+		attr_id.normal = GPU_vertformat_attr_add(&format, "normal", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
+		attr_id.type = GPU_vertformat_attr_add(&format, "type", GPU_COMP_I32, 1, GPU_FETCH_INT);
+		attr_id.level = GPU_vertformat_attr_add(&format, "level", GPU_COMP_I32, 1, GPU_FETCH_INT);
+	}
+
+	GPUVertBuf *vbo = GPU_vertbuf_create_with_format(&format);
+
+	for (rlc = rb->Chains.first; rlc; rlc = rlc->Item.pNext) {
+		int count = lanpr_count_chain(rlc);
+		//printf("seg contains %d verts\n", count);
+		vert_count += count;
+	}
+
+	GPU_vertbuf_data_alloc(vbo, vert_count + 1); // serve as end point's adj.
+
+	lengths = MEM_callocN(sizeof(float) * vert_count, "chain lengths");
+
+	GPUIndexBufBuilder elb;
+	GPU_indexbuf_init_ex(&elb, GPU_PRIM_LINES_ADJ, vert_count * 4, vert_count, true);// elem count will not exceed vert_count
+
+	for (rlc = rb->Chains.first; rlc; rlc = rlc->Item.pNext) {
+
+		total_length = lanpr_compute_chain_length(rlc, lengths, i);
+
+		for (rlci = rlc->Chain.first; rlci; rlci = rlci->Item.pNext) {
+
+			length_target[0] = lengths[i];
+			length_target[1] = total_length - lengths[i];
+
+			GPU_vertbuf_attr_set(vbo, attr_id.pos, i, rlci->pos);
+			GPU_vertbuf_attr_set(vbo, attr_id.normal, i, rlci->normal);
+			GPU_vertbuf_attr_set(vbo, attr_id.uvs, i, length_target);
+
+			arg = lanpr_get_gpu_line_type(rlci);
+			GPU_vertbuf_attr_set(vbo, attr_id.type, i, &arg);
+
+			arg = (int)rlci->OcclusionLevel;
+			GPU_vertbuf_attr_set(vbo, attr_id.level, i, &arg);
+
+			if (rlci == rlc->Chain.last) {
+				if (rlci->Item.pPrev == rlc->Chain.first) {
+					length_target[1] = total_length;
+					GPU_vertbuf_attr_set(vbo, attr_id.uvs, i, length_target);
+				}
+				i++;
+				continue;
+			}
+
+			if (rlci == rlc->Chain.first) {
+				if (rlci->Item.pNext == rlc->Chain.last) GPU_indexbuf_add_line_adj_verts(&elb, vert_count, i, i + 1, vert_count);
+				else GPU_indexbuf_add_line_adj_verts(&elb, vert_count, i, i + 1, i + 2);
+			}
+			else {
+				if (rlci->Item.pNext == rlc->Chain.last) GPU_indexbuf_add_line_adj_verts(&elb, i - 1, i, i + 1, vert_count);
+				else GPU_indexbuf_add_line_adj_verts(&elb, i - 1, i, i + 1, i + 2);
+			}
+
+			i++;
+		}
+	}
+	//set end point flag value.
+	length_target[0] = 3e30f;
+	length_target[1] = 3e30f;
+	GPU_vertbuf_attr_set(vbo, attr_id.pos, vert_count, length_target);
+
+	MEM_freeN(lengths);
+
+	if (rb->ChainDrawBatch) GPU_batch_discard(rb->ChainDrawBatch);
+	rb->ChainDrawBatch = GPU_batch_create_ex(GPU_PRIM_LINES_ADJ, vbo, GPU_indexbuf_build(&elb), GPU_USAGE_DYNAMIC | GPU_BATCH_OWNS_VBO);
+
+}

source/blender/draw/engines/lanpr/lanpr_dpix.c

@@ -0,0 +1,396 @@
+#include "DRW_engine.h"
+#include "DRW_render.h"
+#include "BLI_listbase.h"
+#include "BLI_linklist.h"
+#include "lanpr_all.h"
+#include "DRW_render.h"
+#include "BKE_object.h"
+#include "DNA_mesh_types.h"
+#include "DNA_camera_types.h"
+#include "GPU_immediate.h"
+#include "GPU_immediate_util.h"
+#include "GPU_framebuffer.h"
+#include "DNA_lanpr_types.h"
+#include "DNA_meshdata_types.h"
+#include "BKE_customdata.h"
+#include "DEG_depsgraph_query.h"
+#include "GPU_draw.h"
+
+#include "GPU_batch.h"
+#include "GPU_framebuffer.h"
+#include "GPU_shader.h"
+#include "GPU_uniformbuffer.h"
+#include "GPU_viewport.h"
+#include "bmesh.h"
+
+#include <math.h>
+
+extern LANPR_SharedResource lanpr_share;
+extern char datatoc_lanpr_dpix_project_passthrough_vert_glsl[];
+extern char datatoc_lanpr_dpix_project_clip_frag_glsl[];
+extern char datatoc_lanpr_dpix_preview_geom_glsl[];
+extern char datatoc_lanpr_dpix_preview_frag_glsl[];
+
+void lanpr_init_atlas_inputs(void *ved){
+	lanpr_share.ved_viewport = ved;
+	LANPR_Data *vedata = (LANPR_Data *)ved;
+	LANPR_TextureList *txl = vedata->txl;
+	LANPR_FramebufferList *fbl = vedata->fbl;
+	LANPR_StorageList *stl = ((LANPR_Data *)vedata)->stl;
+	DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
+
+	const DRWContextState *draw_ctx = DRW_context_state_get();
+	View3D *v3d = draw_ctx->v3d;
+	RegionView3D *rv3d = draw_ctx->rv3d;
+	Object *camera = (rv3d && rv3d->persp == RV3D_CAMOB) ? v3d->camera : NULL;
+	SceneLANPR *lanpr = &draw_ctx->scene->lanpr;
+
+	if (lanpr->reloaded || !txl->dpix_in_pl) {
+		DRW_texture_ensure_2d(&txl->dpix_in_pl, TNS_DPIX_TEXTURE_SIZE, TNS_DPIX_TEXTURE_SIZE, GPU_RGBA32F, 0);
+		DRW_texture_ensure_2d(&txl->dpix_in_pr, TNS_DPIX_TEXTURE_SIZE, TNS_DPIX_TEXTURE_SIZE, GPU_RGBA32F, 0);
+		DRW_texture_ensure_2d(&txl->dpix_in_nl, TNS_DPIX_TEXTURE_SIZE, TNS_DPIX_TEXTURE_SIZE, GPU_RGBA32F, 0);
+		DRW_texture_ensure_2d(&txl->dpix_in_nr, TNS_DPIX_TEXTURE_SIZE, TNS_DPIX_TEXTURE_SIZE, GPU_RGBA32F, 0);
+		DRW_texture_ensure_2d(&txl->dpix_in_edge_mask, TNS_DPIX_TEXTURE_SIZE, TNS_DPIX_TEXTURE_SIZE, GPU_RGBA8, 0);
+		DRW_texture_ensure_2d(&txl->dpix_out_pl, TNS_DPIX_TEXTURE_SIZE, TNS_DPIX_TEXTURE_SIZE, GPU_RGBA32F, 0);
+		DRW_texture_ensure_2d(&txl->dpix_out_pr, TNS_DPIX_TEXTURE_SIZE, TNS_DPIX_TEXTURE_SIZE, GPU_RGBA32F, 0);
+		DRW_texture_ensure_2d(&txl->dpix_out_length, TNS_DPIX_TEXTURE_SIZE, TNS_DPIX_TEXTURE_SIZE, GPU_RGBA32F, 0);
+	}
+
+	GPU_framebuffer_ensure_config(&fbl->dpix_transform, {
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_TEXTURE(txl->dpix_out_pl),
+		GPU_ATTACHMENT_TEXTURE(txl->dpix_out_pr),
+		GPU_ATTACHMENT_TEXTURE(txl->dpix_out_length),
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE
+	});
+
+	GPU_framebuffer_ensure_config(&fbl->dpix_preview, {
+		GPU_ATTACHMENT_TEXTURE(txl->depth),
+		GPU_ATTACHMENT_TEXTURE(txl->color),
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE
+	});
+
+	if (!lanpr_share.dpix_transform_shader) {
+		lanpr_share.dpix_transform_shader =
+			DRW_shader_create(
+				datatoc_lanpr_dpix_project_passthrough_vert_glsl,
+				NULL,
+				datatoc_lanpr_dpix_project_clip_frag_glsl,
+				NULL);
+	}
+	if (!lanpr_share.dpix_preview_shader) {
+		lanpr_share.dpix_preview_shader =
+			DRW_shader_create(
+				datatoc_lanpr_dpix_project_passthrough_vert_glsl,
+				datatoc_lanpr_dpix_preview_geom_glsl,
+				datatoc_lanpr_dpix_preview_frag_glsl,
+				NULL);
+	}
+}
+void lanpr_destroy_atlas(void *ved){
+	//no need to free things, no custom data.
+}
+
+int lanpr_feed_atlas_data_obj(void *vedata,
+                              float *AtlasPointsL, float *AtlasPointsR,
+                              float *AtlasFaceNormalL, float *AtlasFaceNormalR,
+                              float *AtlasEdgeMask,
+                              Object *ob, int begin_index) {
+	LANPR_StorageList *stl = ((LANPR_Data *)vedata)->stl;
+
+	if (!DRW_object_is_renderable(ob)) return begin_index;
+	const DRWContextState *draw_ctx = DRW_context_state_get();
+	if (ob == draw_ctx->object_edit) return begin_index;
+	if (ob->type != OB_MESH) return begin_index;
+
+	Mesh *me = ob->data;
+	BMesh *bm;
+	struct BMFace *f1, *f2;
+	struct BMVert *v1, *v2;
+	struct BMEdge *e;
+	struct BMLoop *l1, *l2;
+	FreestyleEdge *fe;
+	int CanFindFreestyle = 0;
+	int vert_count = me->totvert, edge_count = me->totedge, face_count = me->totface;
+	int i, idx;
+
+	const BMAllocTemplate allocsize = BMALLOC_TEMPLATE_FROM_ME(me);
+	bm = BM_mesh_create(&allocsize,
+	                    &((struct BMeshCreateParams) {.use_toolflags = true, }));
+	BM_mesh_bm_from_me(bm, me, &((struct BMeshFromMeshParams) {.calc_face_normal = true, }));
+	BM_mesh_elem_table_ensure(bm, BM_VERT | BM_EDGE | BM_FACE);
+
+	if (CustomData_has_layer(&bm->edata, CD_FREESTYLE_EDGE)) {
+		CanFindFreestyle = 1;
+	}
+
+	for (i = 0; i < edge_count; i++) {
+		f1 = 0;
+		f2 = 0;
+		e = BM_edge_at_index(bm, i);
+		v1 = e->v1;
+		v2 = e->v2;
+		l1 = e->l;
+		l2 = e->l ? e->l->radial_next : 0;
+		if (l1) f1 = l1->f;
+		if (l2) f2 = l2->f;
+
+		idx = (begin_index + i) * 4;
+
+		AtlasPointsL[idx + 0] = v1->co[0];
+		AtlasPointsL[idx + 1] = v1->co[1];
+		AtlasPointsL[idx + 2] = v1->co[2];
+		AtlasPointsL[idx + 3] = 1;
+
+		AtlasPointsR[idx + 0] = v2->co[0];
+		AtlasPointsR[idx + 1] = v2->co[1];
+		AtlasPointsR[idx + 2] = v2->co[2];
+		AtlasPointsR[idx + 3] = 1;
+
+		if (CanFindFreestyle) {
+			fe = CustomData_bmesh_get(&bm->edata, e->head.data, CD_FREESTYLE_EDGE);
+			if (fe->flag & FREESTYLE_EDGE_MARK) AtlasEdgeMask[idx + 1] = 1; // channel G
+		}
+
+		if (f1) {
+			AtlasFaceNormalL[idx + 0] = f1->no[0];
+			AtlasFaceNormalL[idx + 1] = f1->no[1];
+			AtlasFaceNormalL[idx + 2] = f1->no[2];
+			AtlasFaceNormalL[idx + 3] = 1;
+		}
+		else {
+			AtlasFaceNormalL[idx + 0] = 0;
+			AtlasFaceNormalL[idx + 1] = 0;
+			AtlasFaceNormalL[idx + 2] = 0;
+			AtlasFaceNormalL[idx + 3] = 0;
+		}
+
+		if (f2 && f2 != f1) { // this is for edge condition
+			AtlasFaceNormalR[idx + 0] = f2->no[0];
+			AtlasFaceNormalR[idx + 1] = f2->no[1];
+			AtlasFaceNormalR[idx + 2] = f2->no[2];
+			AtlasFaceNormalR[idx + 3] = 1;
+
+			if (f2->mat_nr != f1->mat_nr) AtlasEdgeMask[idx] = 1; // channel R
+
+		}
+		else {
+			AtlasFaceNormalR[idx + 0] = 0;
+			AtlasFaceNormalR[idx + 1] = 0;
+			AtlasFaceNormalR[idx + 2] = 0;
+			AtlasFaceNormalR[idx + 3] = 0;
+		}
+
+	}
+
+	BM_mesh_free(bm);
+
+	return begin_index + edge_count;
+}
+
+int lanpr_feed_atlas_data_intersection_cache(void *vedata,
+                                             float *AtlasPointsL, float *AtlasPointsR,
+                                             float *AtlasFaceNormalL, float *AtlasFaceNormalR,
+                                             float *AtlasEdgeMask,
+                                             int begin_index) {
+	LANPR_StorageList *stl = ((LANPR_Data *)vedata)->stl;
+	LANPR_PrivateData *pd = stl->g_data;
+	const DRWContextState *draw_ctx = DRW_context_state_get();
+	SceneLANPR *lanpr = &draw_ctx->scene->lanpr;
+	LANPR_RenderBuffer *rb = lanpr->render_buffer;
+	nListItemPointer *lip;
+	LANPR_RenderLine *rl;
+	int i, idx;
+
+	i = 0;
+
+	if (!rb) return 0;
+
+	for (lip = rb->IntersectionLines.first; lip; lip = lip->pNext) {
+		rl = lip->p;
+
+		idx = (begin_index + i) * 4;
+		AtlasEdgeMask[idx + 2] = 1; // channel B
+
+		AtlasPointsL[idx + 0] = rl->L->GLocation[0];
+		AtlasPointsL[idx + 1] = rl->L->GLocation[1];
+		AtlasPointsL[idx + 2] = rl->L->GLocation[2];
+		AtlasPointsL[idx + 3] = 1;
+
+		AtlasPointsR[idx + 0] = rl->R->GLocation[0];
+		AtlasPointsR[idx + 1] = rl->R->GLocation[1];
+		AtlasPointsR[idx + 2] = rl->R->GLocation[2];
+		AtlasPointsR[idx + 3] = 1;
+
+		AtlasFaceNormalL[idx + 0] = 0;
+		AtlasFaceNormalL[idx + 1] = 0;
+		AtlasFaceNormalL[idx + 2] = 1;
+		AtlasFaceNormalL[idx + 3] = 0;
+
+		AtlasFaceNormalR[idx + 0] = 0;
+		AtlasFaceNormalR[idx + 1] = 0;
+		AtlasFaceNormalR[idx + 2] = 1;
+		AtlasFaceNormalR[idx + 3] = 0;
+
+		i++;
+	}
+
+	return begin_index + i;
+}
+
+void lanpr_dpix_index_to_coord(int index, float *x, float *y){
+	(*x) = tnsLinearItp(-1, 1, (float)(index % TNS_DPIX_TEXTURE_SIZE + 0.5) / (float)TNS_DPIX_TEXTURE_SIZE);
+	(*y) = tnsLinearItp(-1, 1, (float)(index / TNS_DPIX_TEXTURE_SIZE + 0.5) / (float)TNS_DPIX_TEXTURE_SIZE);
+}
+
+void lanpr_dpix_index_to_coord_absolute(int index, float *x, float *y){
+	(*x) = (float)(index % TNS_DPIX_TEXTURE_SIZE) + 0.5;
+	(*y) = (float)(index / TNS_DPIX_TEXTURE_SIZE) + 0.5;
+}
+
+int lanpr_feed_atlas_trigger_preview_obj(void *vedata, Object *ob, int begin_index) {
+	LANPR_StorageList *stl = ((LANPR_Data *)vedata)->stl;
+	LANPR_PrivateData *pd = stl->g_data;
+	Mesh *me = ob->data;
+	if (ob->type != OB_MESH) return begin_index;
+	int edge_count = me->totedge;
+	int i;
+	float co[2];
+
+	static GPUVertFormat format = { 0 };
+	static struct { uint pos, uvs; } attr_id;
+	if (format.attr_len == 0) {
+		attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
+	}
+
+	static GPUVertFormat format2 = { 0 };
+	static struct { uint pos, uvs; } attr_id2;
+	if (format2.attr_len == 0) {
+		attr_id2.pos = GPU_vertformat_attr_add(&format2, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
+	}
+
+	GPUVertBuf *vbo = GPU_vertbuf_create_with_format(&format);
+	GPUVertBuf *vbo2 = GPU_vertbuf_create_with_format(&format2);
+	GPU_vertbuf_data_alloc(vbo, edge_count);
+	GPU_vertbuf_data_alloc(vbo2, edge_count);
+
+	for (i = 0; i < edge_count; i++) {
+		lanpr_dpix_index_to_coord(i + begin_index, &co[0], &co[1]);
+		GPU_vertbuf_attr_set(vbo, attr_id.pos, i, co);
+		lanpr_dpix_index_to_coord_absolute(i + begin_index, &co[0], &co[1]);
+		GPU_vertbuf_attr_set(vbo2, attr_id2.pos, i, co);
+	}
+
+	GPUBatch *gb = GPU_batch_create_ex(GPU_PRIM_POINTS, vbo, 0, GPU_USAGE_STATIC | GPU_BATCH_OWNS_VBO);
+	GPUBatch *gb2 = GPU_batch_create_ex(GPU_PRIM_POINTS, vbo2, 0, GPU_USAGE_STATIC | GPU_BATCH_OWNS_VBO);
+
+	LANPR_BatchItem *bi = BLI_mempool_alloc(pd->mp_batch_list);
+	BLI_addtail(&pd->dpix_batch_list, bi);
+	bi->dpix_transform_batch = gb;
+	bi->dpix_preview_batch = gb2;
+	bi->ob = ob;
+
+	return begin_index + edge_count;
+}
+
+void lanpr_create_atlas_intersection_preview(void *vedata, int begin_index) {
+	LANPR_StorageList *stl = ((LANPR_Data *)vedata)->stl;
+	LANPR_PrivateData *pd = stl->g_data;
+	const DRWContextState *draw_ctx = DRW_context_state_get();
+	SceneLANPR *lanpr = &draw_ctx->scene->lanpr;
+	LANPR_RenderBuffer *rb = lanpr->render_buffer;
+	float co[2];
+	int i;
+
+	if (!rb) return;
+
+	if (rb->DPIXIntersectionBatch) GPU_batch_discard(rb->DPIXIntersectionBatch);
+	rb->DPIXIntersectionBatch = 0;
+
+	if (!rb->IntersectionCount) return;
+
+	static GPUVertFormat format = { 0 };
+	static struct { uint pos, uvs; } attr_id;
+	if (format.attr_len == 0) {
+		attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
+	}
+	static GPUVertFormat format2 = { 0 };
+	static struct { uint pos, uvs; } attr_id2;
+	if (format2.attr_len == 0) {
+		attr_id2.pos = GPU_vertformat_attr_add(&format2, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
+	}
+
+	GPUVertBuf *vbo = GPU_vertbuf_create_with_format(&format);
+	GPU_vertbuf_data_alloc(vbo, rb->IntersectionCount);
+
+	GPUVertBuf *vbo2 = GPU_vertbuf_create_with_format(&format2);
+	GPU_vertbuf_data_alloc(vbo2, rb->IntersectionCount);
+
+	for (i = 0; i < rb->IntersectionCount; i++) {
+		lanpr_dpix_index_to_coord(i + begin_index, &co[0], &co[1]);
+		GPU_vertbuf_attr_set(vbo, attr_id.pos, i, co);
+		lanpr_dpix_index_to_coord_absolute(i + begin_index, &co[0], &co[1]);
+		GPU_vertbuf_attr_set(vbo2, attr_id2.pos, i, co);
+	}
+	rb->DPIXIntersectionTransformBatch = GPU_batch_create_ex(GPU_PRIM_POINTS, vbo, 0, GPU_USAGE_STATIC | GPU_BATCH_OWNS_VBO);
+	rb->DPIXIntersectionBatch = GPU_batch_create_ex(GPU_PRIM_POINTS, vbo2, 0, GPU_USAGE_STATIC | GPU_BATCH_OWNS_VBO);
+}
+
+
+void lanpr_dpix_draw_scene(LANPR_TextureList *txl, LANPR_FramebufferList *fbl, LANPR_PassList *psl, LANPR_PrivateData *pd, SceneLANPR *lanpr, GPUFrameBuffer *DefaultFB, int is_render) {
+	float clear_col[4] = {0.0f, 0.0f, 0.0f, 0.0f};
+	float clear_depth = 1.0f;
+	uint clear_stencil = 0xFF;
+	int is_persp=1;
+
+	if (!lanpr->active_layer) return; /* return early in case we don't have line layers. DPIX only use the first layer. */
+
+	int texw = GPU_texture_width(txl->edge_intermediate), texh = GPU_texture_height(txl->edge_intermediate);;
+	int tsize = texw * texh;
+
+	const DRWContextState *draw_ctx = DRW_context_state_get();
+	Scene *scene = DEG_get_evaluated_scene(draw_ctx->depsgraph);
+	View3D *v3d = draw_ctx->v3d;
+	Object *camera = 0;
+	if (v3d) {
+		RegionView3D *rv3d = draw_ctx->rv3d;
+		camera = (rv3d && rv3d->persp == RV3D_CAMOB) ? v3d->camera : NULL;
+		is_persp = rv3d->is_persp;
+	}
+	if (!camera) {
+		camera = scene->camera;
+		if(!v3d)is_persp = ((Camera *)camera->data)->type == CAM_PERSP ? 1 : 0;
+	}
+	if (is_render && !camera) return;
+
+	//XXX: should implement view angle functions for ortho camera.
+
+	pd->dpix_viewport[2] = texw;
+	pd->dpix_viewport[3] = texh;
+	pd->dpix_is_perspective = is_persp;
+	pd->dpix_sample_step = 1;
+	pd->dpix_buffer_width = TNS_DPIX_TEXTURE_SIZE;
+	pd->dpix_depth_offset = 0.0001;
+	pd->dpix_znear = camera ? ((Camera *)camera->data)->clip_start : v3d->clip_start;
+	pd->dpix_zfar = camera ? ((Camera *)camera->data)->clip_end : v3d->clip_end;
+
+	GPU_point_size(1);
+	//GPU_line_width(2);
+	GPU_framebuffer_bind(fbl->dpix_transform);
+	DRW_draw_pass(psl->dpix_transform_pass);
+
+	GPU_framebuffer_bind(fbl->dpix_preview);
+	eGPUFrameBufferBits clear_bits = GPU_COLOR_BIT;
+	GPU_framebuffer_clear(fbl->dpix_preview, clear_bits, lanpr->background_color, clear_depth, clear_stencil);
+	DRW_draw_pass(psl->dpix_preview_pass);
+
+	GPU_framebuffer_bind(DefaultFB);
+	GPU_framebuffer_clear(DefaultFB, clear_bits, lanpr->background_color, clear_depth, clear_stencil);
+	DRW_multisamples_resolve(txl->depth, txl->color, 1);
+}

source/blender/draw/engines/lanpr/lanpr_engine.c

@@ -0,0 +1,674 @@
+#include "DRW_engine.h"
+#include "DRW_render.h"
+#include "BLI_listbase.h"
+#include "BLI_linklist.h"
+#include "BLI_math_matrix.h"
+#include "lanpr_all.h"
+#include "DRW_render.h"
+#include "BKE_object.h"
+#include "DNA_mesh_types.h"
+#include "DNA_camera_types.h"
+#include "GPU_immediate.h"
+#include "GPU_immediate_util.h"
+#include "GPU_framebuffer.h"
+#include "DNA_lanpr_types.h"
+#include "GPU_draw.h"
+#include "DEG_depsgraph_query.h"
+#include "RE_pipeline.h"
+#include "BLI_rect.h"
+
+#include "GPU_batch.h"
+#include "GPU_framebuffer.h"
+#include "GPU_shader.h"
+#include "GPU_uniformbuffer.h"
+#include "GPU_viewport.h"
+#include "bmesh.h"
+
+#include <math.h>
+
+
+extern char datatoc_common_fullscreen_vert_glsl[];
+extern char datatoc_gpu_shader_3D_normal_smooth_color_vert_glsl[];
+extern char datatoc_lanpr_snake_multichannel_frag_glsl[];
+extern char datatoc_lanpr_snake_edge_frag_glsl[];
+extern char datatoc_lanpr_snake_image_peel_frag_glsl[];
+extern char datatoc_lanpr_snake_line_connection_vert_glsl[];
+extern char datatoc_lanpr_snake_line_connection_frag_glsl[];
+extern char datatoc_lanpr_snake_line_connection_geom_glsl[];
+extern char datatoc_lanpr_software_line_chain_geom_glsl[];
+extern char datatoc_lanpr_software_chain_geom_glsl[];
+extern char datatoc_lanpr_dpix_project_passthrough_vert_glsl[];
+extern char datatoc_lanpr_dpix_project_clip_frag_glsl[];
+extern char datatoc_lanpr_dpix_preview_frag_glsl[];
+extern char datatoc_lanpr_software_passthrough_vert_glsl[];
+extern char datatoc_gpu_shader_2D_smooth_color_vert_glsl[];
+extern char datatoc_gpu_shader_2D_smooth_color_frag_glsl[];
+
+LANPR_SharedResource lanpr_share;
+
+
+static void lanpr_engine_init(void *ved){
+	lanpr_share.ved_viewport = ved;
+	LANPR_Data *vedata = (LANPR_Data *)ved;
+	LANPR_TextureList *txl = vedata->txl;
+	LANPR_FramebufferList *fbl = vedata->fbl;
+	LANPR_StorageList *stl = ((LANPR_Data *)vedata)->stl;
+	DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
+
+	const DRWContextState *draw_ctx = DRW_context_state_get();
+	Scene *scene = DEG_get_evaluated_scene(draw_ctx->depsgraph);
+	SceneLANPR *lanpr = &scene->lanpr;
+	View3D *v3d = draw_ctx->v3d;
+
+	if (!lanpr_share.init_complete)
+		BLI_spin_init(&lanpr_share.render_flag_lock);
+
+	/* SNAKE */
+
+	DRW_texture_ensure_fullscreen_2D_multisample(&txl->depth, GPU_DEPTH_COMPONENT32F, 8, 0);
+	DRW_texture_ensure_fullscreen_2D_multisample(&txl->color, GPU_RGBA32F, 8, 0);
+	DRW_texture_ensure_fullscreen_2D_multisample(&txl->normal, GPU_RGBA32F, 8, 0);
+	DRW_texture_ensure_fullscreen_2D_multisample(&txl->edge_intermediate, GPU_RGBA32F, 8, 0);
+
+	DRW_texture_ensure_fullscreen_2D_multisample(&txl->ms_resolve_depth, GPU_DEPTH_COMPONENT32F, 8, 0);
+	DRW_texture_ensure_fullscreen_2D_multisample(&txl->ms_resolve_color, GPU_RGBA32F, 8, 0);
+
+
+	GPU_framebuffer_ensure_config(&fbl->passes, {
+		GPU_ATTACHMENT_TEXTURE(txl->depth),
+		GPU_ATTACHMENT_TEXTURE(txl->color),
+		GPU_ATTACHMENT_TEXTURE(txl->normal),
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE
+	});
+
+	GPU_framebuffer_ensure_config(&fbl->edge_intermediate, {
+		GPU_ATTACHMENT_TEXTURE(txl->depth),
+		GPU_ATTACHMENT_TEXTURE(txl->edge_intermediate),
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE
+	});
+
+	GPU_framebuffer_ensure_config(&fbl->edge_thinning, {
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_TEXTURE(txl->color),
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE
+	});
+
+
+	if (!lanpr_share.multichannel_shader) {
+		lanpr_share.multichannel_shader =
+			DRW_shader_create(
+				datatoc_gpu_shader_3D_normal_smooth_color_vert_glsl,
+				NULL,
+				datatoc_lanpr_snake_multichannel_frag_glsl, 
+				NULL);
+
+	}
+	if (!lanpr_share.edge_detect_shader) {
+		lanpr_share.edge_detect_shader =
+			DRW_shader_create(
+				datatoc_common_fullscreen_vert_glsl,
+				NULL,
+				datatoc_lanpr_snake_edge_frag_glsl,
+				NULL);
+
+	}
+	if (!lanpr_share.edge_thinning_shader) {
+		lanpr_share.edge_thinning_shader =
+			DRW_shader_create(
+				datatoc_common_fullscreen_vert_glsl,
+				NULL,
+				datatoc_lanpr_snake_image_peel_frag_glsl, 
+				NULL);
+
+	}
+	if (!lanpr_share.snake_connection_shader) {
+		lanpr_share.snake_connection_shader =
+			DRW_shader_create(
+				datatoc_lanpr_snake_line_connection_vert_glsl,
+				datatoc_lanpr_snake_line_connection_geom_glsl,
+				datatoc_lanpr_snake_line_connection_frag_glsl,
+				NULL);
+	}
+
+	/* DPIX */
+	lanpr_init_atlas_inputs(ved);
+
+	/* SOFTWARE */
+	if (!lanpr_share.software_shader) {
+		lanpr_share.software_shader =
+			DRW_shader_create(
+				datatoc_lanpr_software_passthrough_vert_glsl,
+				datatoc_lanpr_software_line_chain_geom_glsl,
+				datatoc_lanpr_dpix_preview_frag_glsl,
+				NULL);
+	}
+
+	if (!lanpr_share.software_chaining_shader) {
+		lanpr_share.software_chaining_shader =
+			DRW_shader_create(
+				datatoc_lanpr_software_passthrough_vert_glsl,
+				datatoc_lanpr_software_chain_geom_glsl,
+				datatoc_lanpr_dpix_preview_frag_glsl,
+				NULL);
+	}
+
+	GPU_framebuffer_ensure_config(&fbl->software_ms, {
+		GPU_ATTACHMENT_TEXTURE(txl->ms_resolve_depth),
+		GPU_ATTACHMENT_TEXTURE(txl->ms_resolve_color),
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE
+	});
+
+	lanpr_share.init_complete = 1;
+
+}
+static void lanpr_engine_free(void){
+	void *ved = lanpr_share.ved_viewport;
+	LANPR_Data *vedata = (LANPR_Data *)ved;
+	LANPR_StorageList *stl = ((LANPR_Data *)vedata)->stl;
+
+	//only free custom data in storage list.
+
+	BLI_mempool_destroy(stl->g_data->mp_line_strip);
+	BLI_mempool_destroy(stl->g_data->mp_line_strip_point);
+	BLI_mempool_destroy(stl->g_data->mp_sample);
+	BLI_mempool_destroy(stl->g_data->mp_batch_list);
+
+	lanpr_destroy_atlas(vedata);
+
+	stl->g_data = 0;
+}
+
+void lanpr_calculate_normal_object_vector(LANPR_LineLayer* ll, float* normal_object_direction);
+
+static void lanpr_cache_init(void *vedata){
+
+	LANPR_PassList *psl = ((LANPR_Data *)vedata)->psl;
+	LANPR_StorageList *stl = ((LANPR_Data *)vedata)->stl;
+	LANPR_TextureList *txl = ((LANPR_Data *)vedata)->txl;
+
+	DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
+
+	static float normal_object_direction[3] = { 0,0,1 };
+
+	if (!stl->g_data) {
+		/* Alloc transient pointers */
+		stl->g_data = MEM_callocN(sizeof(*stl->g_data), __func__);
+		stl->g_data->mp_sample = BLI_mempool_create(sizeof(LANPR_TextureSample), 0, 512, BLI_MEMPOOL_NOP);
+		stl->g_data->mp_line_strip = BLI_mempool_create(sizeof(LANPR_LineStrip), 0, 512, BLI_MEMPOOL_NOP);
+		stl->g_data->mp_line_strip_point = BLI_mempool_create(sizeof(LANPR_LineStripPoint), 0, 1024, BLI_MEMPOOL_NOP);
+		stl->g_data->mp_batch_list = BLI_mempool_create(sizeof(LANPR_BatchItem), 0, 128, BLI_MEMPOOL_NOP);
+	}
+
+	LANPR_PrivateData *pd = stl->g_data;
+
+	const DRWContextState *draw_ctx = DRW_context_state_get();
+	Scene *scene = DEG_get_evaluated_scene(draw_ctx->depsgraph);
+	SceneLANPR *lanpr = &scene->lanpr;
+	View3D *v3d = draw_ctx->v3d;
+
+	psl->color_pass = DRW_pass_create("color Pass", DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_WRITE_DEPTH);
+	stl->g_data->multipass_shgrp = DRW_shgroup_create(lanpr_share.multichannel_shader, psl->color_pass);
+
+
+	if (lanpr->master_mode == LANPR_MASTER_MODE_SNAKE) {
+		struct GPUBatch *quad = DRW_cache_fullscreen_quad_get();
+
+		psl->edge_intermediate = DRW_pass_create("Edge Detection", DRW_STATE_WRITE_COLOR);
+		stl->g_data->edge_detect_shgrp = DRW_shgroup_create(lanpr_share.edge_detect_shader, psl->edge_intermediate);
+		DRW_shgroup_uniform_texture_ref(stl->g_data->edge_detect_shgrp, "tex_sample_0", &txl->depth);
+		DRW_shgroup_uniform_texture_ref(stl->g_data->edge_detect_shgrp, "tex_sample_1", &txl->color);
+		DRW_shgroup_uniform_texture_ref(stl->g_data->edge_detect_shgrp, "tex_sample_2", &txl->normal);
+
+		DRW_shgroup_uniform_float(stl->g_data->edge_detect_shgrp, "z_near", &stl->g_data->znear, 1);
+		DRW_shgroup_uniform_float(stl->g_data->edge_detect_shgrp, "z_far", &stl->g_data->zfar, 1);
+
+		DRW_shgroup_uniform_float(stl->g_data->edge_detect_shgrp, "normal_clamp", &stl->g_data->normal_clamp, 1);// normal clamp
+		DRW_shgroup_uniform_float(stl->g_data->edge_detect_shgrp, "normal_strength", &stl->g_data->normal_strength, 1);// normal strength
+		DRW_shgroup_uniform_float(stl->g_data->edge_detect_shgrp, "depth_clamp", &stl->g_data->depth_clamp, 1);// depth clamp
+		DRW_shgroup_uniform_float(stl->g_data->edge_detect_shgrp, "depth_strength", &stl->g_data->depth_strength, 1);// depth strength
+		DRW_shgroup_call(stl->g_data->edge_detect_shgrp, quad, NULL);
+
+		psl->edge_thinning = DRW_pass_create("Edge Thinning Stage 1", DRW_STATE_WRITE_COLOR);
+		stl->g_data->edge_thinning_shgrp = DRW_shgroup_create(lanpr_share.edge_thinning_shader, psl->edge_thinning);
+		DRW_shgroup_uniform_texture_ref(stl->g_data->edge_thinning_shgrp, "tex_sample_0", &dtxl->color);
+		DRW_shgroup_uniform_int(stl->g_data->edge_thinning_shgrp, "stage", &stl->g_data->stage, 1);
+		DRW_shgroup_call(stl->g_data->edge_thinning_shgrp, quad, NULL);
+
+	}
+	elif(lanpr->master_mode == LANPR_MASTER_MODE_DPIX && lanpr->active_layer)
+	{
+		LANPR_LineLayer *ll = lanpr->line_layers.first;
+		psl->dpix_transform_pass = DRW_pass_create("DPIX Transform Stage", DRW_STATE_WRITE_COLOR);
+		stl->g_data->dpix_transform_shgrp = DRW_shgroup_create(lanpr_share.dpix_transform_shader, psl->dpix_transform_pass);
+		DRW_shgroup_uniform_texture_ref(stl->g_data->dpix_transform_shgrp, "vert0_tex", &txl->dpix_in_pl);
+		DRW_shgroup_uniform_texture_ref(stl->g_data->dpix_transform_shgrp, "vert1_tex", &txl->dpix_in_pr);
+		DRW_shgroup_uniform_texture_ref(stl->g_data->dpix_transform_shgrp, "face_normal0_tex", &txl->dpix_in_nl);
+		DRW_shgroup_uniform_texture_ref(stl->g_data->dpix_transform_shgrp, "face_normal1_tex", &txl->dpix_in_nr);
+		DRW_shgroup_uniform_texture_ref(stl->g_data->dpix_transform_shgrp, "edge_mask_tex", &txl->dpix_in_edge_mask);
+		DRW_shgroup_uniform_int(stl->g_data->dpix_transform_shgrp, "sample_step", &stl->g_data->dpix_sample_step, 1);
+		DRW_shgroup_uniform_int(stl->g_data->dpix_transform_shgrp, "is_perspective", &stl->g_data->dpix_is_perspective, 1);
+		DRW_shgroup_uniform_vec4(stl->g_data->dpix_transform_shgrp, "viewport", stl->g_data->dpix_viewport, 1);
+		DRW_shgroup_uniform_int(stl->g_data->dpix_transform_shgrp, "buffer_width", &stl->g_data->dpix_buffer_width, 1);
+		DRW_shgroup_uniform_float(stl->g_data->dpix_transform_shgrp, "crease_threshold", &lanpr->crease_threshold, 1);
+		DRW_shgroup_uniform_float(stl->g_data->dpix_transform_shgrp, "crease_fade_threshold", &lanpr->crease_fade_threshold, 1);
+		DRW_shgroup_uniform_int(stl->g_data->dpix_transform_shgrp, "enable_crease", &ll->enable_crease, 1);
+		DRW_shgroup_uniform_int(stl->g_data->dpix_transform_shgrp, "enable_material", &ll->enable_material_seperate, 1);
+		DRW_shgroup_uniform_int(stl->g_data->dpix_transform_shgrp, "enable_edge_mark", &ll->enable_edge_mark, 1);
+		DRW_shgroup_uniform_int(stl->g_data->dpix_transform_shgrp, "enable_intersection", &ll->enable_intersection, 1);
+
+		psl->dpix_preview_pass = DRW_pass_create("DPIX Preview", DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL);
+		stl->g_data->dpix_preview_shgrp = DRW_shgroup_create(lanpr_share.dpix_preview_shader, psl->dpix_preview_pass);
+		DRW_shgroup_uniform_texture_ref(stl->g_data->dpix_preview_shgrp, "vert0_tex", &txl->dpix_out_pl);
+		DRW_shgroup_uniform_texture_ref(stl->g_data->dpix_preview_shgrp, "vert1_tex", &txl->dpix_out_pr);
+		DRW_shgroup_uniform_texture_ref(stl->g_data->dpix_preview_shgrp, "face_normal0_tex", &txl->dpix_in_nl);
+		DRW_shgroup_uniform_texture_ref(stl->g_data->dpix_preview_shgrp, "face_normal1_tex", &txl->dpix_in_nr);// these are for normal shading
+		DRW_shgroup_uniform_texture_ref(stl->g_data->dpix_preview_shgrp, "edge_mask_tex", &txl->dpix_in_edge_mask);
+		DRW_shgroup_uniform_vec4(stl->g_data->dpix_preview_shgrp, "viewport", stl->g_data->dpix_viewport, 1);
+		DRW_shgroup_uniform_vec4(stl->g_data->dpix_preview_shgrp, "color", ll->color, 1);
+		DRW_shgroup_uniform_vec4(stl->g_data->dpix_preview_shgrp, "crease_color", ll->crease_color, 1);
+		DRW_shgroup_uniform_vec4(stl->g_data->dpix_preview_shgrp, "material_color", ll->material_color, 1);
+		DRW_shgroup_uniform_vec4(stl->g_data->dpix_preview_shgrp, "edge_mark_color", ll->edge_mark_color, 1);
+		DRW_shgroup_uniform_vec4(stl->g_data->dpix_preview_shgrp, "intersection_color", ll->intersection_color, 1);
+		DRW_shgroup_uniform_vec4(stl->g_data->dpix_preview_shgrp, "background_color", lanpr->background_color, 1);
+		//DRW_shgroup_uniform_vec4(stl->g_data->dpix_preview_shgrp, "line_color", ll->line_color, 1); //we have color
+		DRW_shgroup_uniform_float(stl->g_data->dpix_preview_shgrp, "depth_offset", &stl->g_data->dpix_depth_offset, 1);
+		DRW_shgroup_uniform_float(stl->g_data->dpix_preview_shgrp, "depth_width_influence", &lanpr->depth_width_influence, 1);
+		DRW_shgroup_uniform_float(stl->g_data->dpix_preview_shgrp, "depth_width_curve", &lanpr->depth_width_curve, 1);
+		DRW_shgroup_uniform_float(stl->g_data->dpix_preview_shgrp, "depth_alpha_influence", &lanpr->depth_alpha_influence, 1);
+		DRW_shgroup_uniform_float(stl->g_data->dpix_preview_shgrp, "depth_alpha_curve", &lanpr->depth_alpha_curve, 1);
+		DRW_shgroup_uniform_float(stl->g_data->dpix_preview_shgrp, "line_thickness", &ll->thickness, 1);
+		DRW_shgroup_uniform_float(stl->g_data->dpix_preview_shgrp, "line_thickness_crease", &ll->thickness_crease, 1);
+		DRW_shgroup_uniform_float(stl->g_data->dpix_preview_shgrp, "line_thickness_material", &ll->thickness_material, 1);
+		DRW_shgroup_uniform_float(stl->g_data->dpix_preview_shgrp, "line_thickness_edge_mark", &ll->thickness_edge_mark, 1);
+		DRW_shgroup_uniform_float(stl->g_data->dpix_preview_shgrp, "line_thickness_intersection", &ll->thickness_intersection, 1);
+		DRW_shgroup_uniform_float(stl->g_data->dpix_preview_shgrp, "z_near", &stl->g_data->dpix_znear, 1);
+		DRW_shgroup_uniform_float(stl->g_data->dpix_preview_shgrp, "z_far", &stl->g_data->dpix_zfar, 1);
+
+		lanpr_calculate_normal_object_vector(ll, normal_object_direction);
+
+		DRW_shgroup_uniform_int(stl->g_data->dpix_preview_shgrp, "normal_mode", &ll->normal_mode, 1);
+		DRW_shgroup_uniform_int(stl->g_data->dpix_preview_shgrp, "normal_effect_inverse", &ll->normal_effect_inverse, 1);
+		DRW_shgroup_uniform_float(stl->g_data->dpix_preview_shgrp, "normal_ramp_begin", &ll->normal_ramp_begin, 1);
+		DRW_shgroup_uniform_float(stl->g_data->dpix_preview_shgrp, "normal_ramp_end", &ll->normal_ramp_end, 1);
+		DRW_shgroup_uniform_float(stl->g_data->dpix_preview_shgrp, "normal_thickness_begin", &ll->normal_thickness_begin, 1);
+		DRW_shgroup_uniform_float(stl->g_data->dpix_preview_shgrp, "normal_thickness_end", &ll->normal_thickness_end, 1);
+		DRW_shgroup_uniform_vec3(stl->g_data->dpix_preview_shgrp, "normal_direction", normal_object_direction, 1);
+
+		pd->begin_index = 0;
+		int fsize = sizeof(float) * 4 * TNS_DPIX_TEXTURE_SIZE * TNS_DPIX_TEXTURE_SIZE;
+
+		if (lanpr->reloaded) {
+			pd->atlas_pl = MEM_callocN(fsize, "atlas_point_l");
+			pd->atlas_pr = MEM_callocN(fsize, "atlas_point_r");
+			pd->atlas_nl = MEM_callocN(fsize, "atlas_normal_l");
+			pd->atlas_nr = MEM_callocN(fsize, "atlas_normal_l");
+			pd->atlas_edge_mask = MEM_callocN(fsize, "atlas_edge_mask"); // should always be float
+
+			pd->dpix_batch_list.first = pd->dpix_batch_list.last = 0;
+			BLI_mempool_clear(pd->mp_batch_list);
+		}
+	} elif(lanpr->master_mode == LANPR_MASTER_MODE_SOFTWARE)
+	{
+		;
+	}
+
+
+
+}
+
+static void lanpr_cache_populate(void *vedata, Object *ob){
+
+	LANPR_StorageList *stl = ((LANPR_Data *)vedata)->stl;
+	LANPR_PrivateData *pd = stl->g_data;
+	const DRWContextState *draw_ctx = DRW_context_state_get();
+	View3D *v3d = draw_ctx->v3d;
+	SceneLANPR *lanpr = &draw_ctx->scene->lanpr;
+
+	if (!DRW_object_is_renderable(ob)) return;
+	if (ob == draw_ctx->object_edit) return;
+	if (ob->type != OB_MESH) return;
+
+	struct GPUBatch *geom = DRW_cache_object_surface_get(ob);
+	if (geom) {
+		DRW_shgroup_call_object_no_cull(stl->g_data->multipass_shgrp, geom, ob);
+	}
+
+	if (lanpr->master_mode == LANPR_MASTER_MODE_DPIX && lanpr->active_layer) {
+		int idx = pd->begin_index;
+		if (lanpr->reloaded) {
+			pd->begin_index = lanpr_feed_atlas_data_obj(vedata, pd->atlas_pl, pd->atlas_pr, pd->atlas_nl, pd->atlas_nr, pd->atlas_edge_mask, ob, idx);
+			lanpr_feed_atlas_trigger_preview_obj(vedata, ob, idx);
+		}
+
+	}
+}
+
+static void lanpr_cache_finish(void *vedata){
+	LANPR_StorageList *stl = ((LANPR_Data *)vedata)->stl;
+	LANPR_PrivateData *pd = stl->g_data;
+	LANPR_TextureList *txl = ((LANPR_Data *)vedata)->txl;
+	const DRWContextState *draw_ctx = DRW_context_state_get();
+	View3D *v3d = draw_ctx->v3d;
+	SceneLANPR *lanpr = &draw_ctx->scene->lanpr;
+	float mat[4][4];
+	unit_m4(mat);
+
+	if (lanpr->master_mode == LANPR_MASTER_MODE_DPIX && lanpr->active_layer) {
+		if (lanpr->reloaded) {
+			if (lanpr->render_buffer) {
+				lanpr_feed_atlas_data_intersection_cache(vedata, pd->atlas_pl, pd->atlas_pr, pd->atlas_nl, pd->atlas_nr, pd->atlas_edge_mask, pd->begin_index);
+				lanpr_create_atlas_intersection_preview(vedata, pd->begin_index);
+			}
+			GPU_texture_update(txl->dpix_in_pl, GPU_DATA_FLOAT, pd->atlas_pl);
+			GPU_texture_update(txl->dpix_in_pr, GPU_DATA_FLOAT, pd->atlas_pr);
+			GPU_texture_update(txl->dpix_in_nl, GPU_DATA_FLOAT, pd->atlas_nl);
+			GPU_texture_update(txl->dpix_in_nr, GPU_DATA_FLOAT, pd->atlas_nr);
+			GPU_texture_update(txl->dpix_in_edge_mask, GPU_DATA_FLOAT, pd->atlas_edge_mask);
+
+			MEM_freeN(pd->atlas_pl);
+			MEM_freeN(pd->atlas_pr);
+			MEM_freeN(pd->atlas_nl);
+			MEM_freeN(pd->atlas_nr);
+			MEM_freeN(pd->atlas_edge_mask);
+			pd->atlas_pl = 0;
+			lanpr->reloaded = 0;
+		}
+
+
+
+		LANPR_BatchItem *bi;
+		for (bi = pd->dpix_batch_list.first; bi; bi = (void *)bi->Item.next) {
+			DRW_shgroup_call(pd->dpix_transform_shgrp, bi->dpix_transform_batch, bi->ob->obmat);
+			DRW_shgroup_call(pd->dpix_preview_shgrp, bi->dpix_preview_batch, 0);
+		}
+
+		if (lanpr->render_buffer && lanpr->render_buffer->DPIXIntersectionBatch) {
+			DRW_shgroup_call(pd->dpix_transform_shgrp, lanpr->render_buffer->DPIXIntersectionTransformBatch, 0);
+			DRW_shgroup_call(pd->dpix_preview_shgrp, lanpr->render_buffer->DPIXIntersectionBatch, 0);
+		}
+	}
+}
+
+void lanpr_batch_free(SceneLANPR *lanpr) {
+
+}
+
+// below are commented to prevent interface lock in some conditions.
+// should look into it,
+void lanpr_set_render_flag() {
+	//BLI_spin_lock(&lanpr_share.render_flag_lock);
+	//lanpr_share.during_render = 1;
+	//BLI_spin_unlock(&lanpr_share.render_flag_lock);
+}
+void lanpr_clear_render_flag() {
+	//BLI_spin_lock(&lanpr_share.render_flag_lock);
+	//lanpr_share.during_render = 0;
+	//BLI_spin_unlock(&lanpr_share.render_flag_lock);
+}
+int lanpr_during_render() {
+	int status;
+	BLI_spin_lock(&lanpr_share.render_flag_lock);
+	status = lanpr_share.during_render;
+	BLI_spin_unlock(&lanpr_share.render_flag_lock);
+	return status;
+}
+
+static void lanpr_draw_scene_exec(void *vedata, GPUFrameBuffer *dfb, int is_render) {
+	LANPR_PassList *psl = ((LANPR_Data *)vedata)->psl;
+	LANPR_TextureList *txl = ((LANPR_Data *)vedata)->txl;
+	LANPR_StorageList *stl = ((LANPR_Data *)vedata)->stl;
+	LANPR_FramebufferList *fbl = ((LANPR_Data *)vedata)->fbl;
+	LANPR_PrivateData *pd = stl->g_data;
+
+	float clear_col[4] = { 1.0f, 0.0f, 0.0f, 1.0f };
+	float clear_depth = 1.0f;
+	uint clear_stencil = 0xFF;
+
+	GPU_framebuffer_bind(fbl->passes);
+	eGPUFrameBufferBits clear_bits = GPU_DEPTH_BIT | GPU_COLOR_BIT;
+	GPU_framebuffer_clear(fbl->passes, clear_bits, clear_col, clear_depth, clear_stencil);
+
+	const DRWContextState *draw_ctx = DRW_context_state_get();
+	Scene *scene = DEG_get_evaluated_scene(draw_ctx->depsgraph);
+	SceneLANPR *lanpr = &scene->lanpr;
+	View3D *v3d = draw_ctx->v3d;
+
+	if (lanpr->master_mode == LANPR_MASTER_MODE_DPIX) {
+		DRW_draw_pass(psl->color_pass);
+		lanpr_dpix_draw_scene(txl, fbl, psl, stl->g_data, lanpr, dfb, is_render);
+	}
+	elif(lanpr->master_mode == LANPR_MASTER_MODE_SNAKE)
+	{
+		DRW_draw_pass(psl->color_pass);
+		lanpr_snake_draw_scene(txl, fbl, psl, stl->g_data, lanpr, dfb, is_render);
+	}
+	elif(lanpr->master_mode == LANPR_MASTER_MODE_SOFTWARE)
+	{
+		// should isolate these into a seperate function.
+		lanpr_software_draw_scene(vedata, dfb, is_render);
+	}
+}
+
+static void lanpr_draw_scene(void *vedata) {
+	DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get();
+	lanpr_draw_scene_exec(vedata, dfbl->default_fb, 0);
+}
+
+void LANPR_render_cache(
+	void *vedata, struct Object *ob,
+	struct RenderEngine *engine, struct Depsgraph *UNUSED(depsgraph)){
+
+	lanpr_cache_populate(vedata, ob);
+
+}
+
+static void workbench_render_matrices_init(RenderEngine *engine, Depsgraph *depsgraph)
+{
+	/* TODO(sergey): Shall render hold pointer to an evaluated camera instead? */
+	Scene *scene = DEG_get_evaluated_scene(depsgraph);
+	struct Object *ob_camera_eval = DEG_get_evaluated_object(depsgraph, RE_GetCamera(engine->re));
+	float frame = BKE_scene_frame_get(scene);
+
+	/* Set the persective, view and window matrix. */
+	float winmat[4][4], wininv[4][4];
+	float viewmat[4][4], viewinv[4][4];
+	float persmat[4][4], persinv[4][4];
+	float unitmat[4][4];
+
+	RE_GetCameraWindow(engine->re, ob_camera_eval, frame, winmat);
+	RE_GetCameraModelMatrix(engine->re, ob_camera_eval, viewinv);
+
+	invert_m4_m4(viewmat, viewinv);
+	mul_m4_m4m4(persmat, winmat, viewmat);
+	invert_m4_m4(persinv, persmat);
+	invert_m4_m4(wininv, winmat);
+
+	unit_m4(unitmat);
+
+	DRW_viewport_matrix_override_set(persmat, DRW_MAT_PERS);
+	DRW_viewport_matrix_override_set(persinv, DRW_MAT_PERSINV);
+	DRW_viewport_matrix_override_set(winmat, DRW_MAT_WIN);
+	DRW_viewport_matrix_override_set(wininv, DRW_MAT_WININV);
+	DRW_viewport_matrix_override_set(viewmat, DRW_MAT_VIEW);
+	DRW_viewport_matrix_override_set(viewinv, DRW_MAT_VIEWINV);
+}
+
+int lanpr_compute_feature_lines_internal(Depsgraph *depsgraph, SceneLANPR *lanpr, Scene *scene);
+LANPR_RenderBuffer *lanpr_create_render_buffer(SceneLANPR *lanpr);
+
+extern DrawEngineType draw_engine_lanpr_type;
+
+static int LANPR_GLOBAL_update_tag;
+
+void lanpr_id_update(LANPR_Data *vedata, ID *id){
+	//if (vedata->engine_type != &draw_engine_lanpr_type) return;
+
+	/* Handle updates based on ID type. */
+	switch (GS(id->name)) {
+	case ID_WO:
+	case ID_OB:
+	case ID_ME:
+		LANPR_GLOBAL_update_tag = 1;
+	default:
+		/* pass */
+		break;
+	}
+}
+
+static void lanpr_render_to_image(LANPR_Data *vedata, RenderEngine *engine, struct RenderLayer *render_layer, const rcti *rect){
+	LANPR_StorageList *stl = vedata->stl;
+	LANPR_TextureList *txl = vedata->txl;
+	LANPR_FramebufferList *fbl = vedata->fbl;
+	const DRWContextState *draw_ctx = DRW_context_state_get();
+	//int update_mark = DEG_id_type_any_updated(draw_ctx->depsgraph);
+	Scene *scene = DEG_get_evaluated_scene(draw_ctx->depsgraph);
+	SceneLANPR *lanpr = &scene->lanpr;
+
+
+	lanpr_set_render_flag();
+
+	if (lanpr->master_mode == LANPR_MASTER_MODE_SOFTWARE ||
+	    (lanpr->master_mode == LANPR_MASTER_MODE_DPIX && lanpr->enable_intersections)) {
+		if (!lanpr->render_buffer) lanpr_create_render_buffer(lanpr);
+		if (lanpr->render_buffer->cached_for_frame != scene->r.cfra || LANPR_GLOBAL_update_tag) {
+			lanpr_compute_feature_lines_internal(draw_ctx->depsgraph, lanpr, scene);
+		}
+	}
+
+	workbench_render_matrices_init(engine, draw_ctx->depsgraph);
+
+	/* refered to eevee's code */
+
+	/* Init default FB and render targets:
+	 * In render mode the default framebuffer is not generated
+	 * because there is no viewport. So we need to manually create it or
+	 * not use it. For code clarity we just allocate it make use of it. */
+	DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get();
+	DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
+
+	DRW_texture_ensure_fullscreen_2d(&dtxl->depth, GPU_DEPTH_COMPONENT32F, 0);
+	DRW_texture_ensure_fullscreen_2d(&dtxl->color, GPU_RGBA32F, 0);
+
+	GPU_framebuffer_ensure_config(&dfbl->default_fb, {
+		GPU_ATTACHMENT_TEXTURE(dtxl->depth),
+		GPU_ATTACHMENT_TEXTURE(dtxl->color),
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE,
+		GPU_ATTACHMENT_LEAVE
+	});
+
+	lanpr_engine_init(vedata);
+	lanpr->reloaded = 1; // force dpix batch to re-create
+	lanpr_cache_init(vedata);
+	DRW_render_object_iter(vedata, engine, draw_ctx->depsgraph, LANPR_render_cache);
+	lanpr_cache_finish(vedata);
+
+	DRW_render_instance_buffer_finish();
+
+	float clear_col[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
+	float clear_depth = 1.0f;
+	uint clear_stencil = 0xFF;
+	eGPUFrameBufferBits clear_bits = GPU_DEPTH_BIT | GPU_COLOR_BIT;
+
+	GPU_framebuffer_bind(dfbl->default_fb);
+	GPU_framebuffer_clear(dfbl->default_fb, clear_bits, clear_col, clear_depth, clear_stencil);
+
+	lanpr_draw_scene_exec(vedata, dfbl->default_fb, 1);
+
+	// read it back so we can again display and save it.
+	const char *viewname = RE_GetActiveRenderView(engine->re);
+	RenderPass *rp = RE_pass_find_by_name(render_layer, RE_PASSNAME_COMBINED, viewname);
+	GPU_framebuffer_bind(dfbl->default_fb);
+	GPU_framebuffer_read_color(dfbl->default_fb,
+	                           rect->xmin, rect->ymin,
+	                           BLI_rcti_size_x(rect), BLI_rcti_size_y(rect),
+	                           4, 0, rp->rect);
+
+	//we don't need to free pass/buffer/texture in the engine's list
+	//lanpr_engine_free();
+
+	lanpr_clear_render_flag();
+}
+
+static void lanpr_view_update(void *vedata){
+	//LANPR_StorageList *stl = ((LANPR_Data *)vedata)->stl;
+	//if (stl->g_data) {
+	//	stl->g_data->view_updated = true;
+	//}
+
+	//our update flag is in SceneLANPR.
+	const DRWContextState *draw_ctx = DRW_context_state_get();
+	SceneLANPR *lanpr = &DEG_get_evaluated_scene(draw_ctx->depsgraph)->lanpr;
+	lanpr->reloaded = 1; // very bad solution, this will slow down animation.
+}
+
+//static void lanpr_id_update(void *vedata, ID *id){
+//	const DRWContextState *draw_ctx = DRW_context_state_get();
+//    SceneLANPR *lanpr = &DEG_get_evaluated_scene(draw_ctx->depsgraph)->lanpr;
+//
+//	/* look at eevee_engine.c */
+//	switch (GS(id->name)) {
+//		case ID_OB:
+//		    //seems doesn't need this one currently...
+//			//eevee_id_object_update(vedata, (Object *)id);
+//			lanpr->reloaded = 1;
+//			break;
+//		case ID_ME:
+//		    lanpr->reloaded=1;
+//			break;
+//		default:
+//			/* pass */
+//			break;
+//	}
+//}
+
+
+static const DrawEngineDataSize lanpr_data_size = DRW_VIEWPORT_DATA_SIZE(LANPR_Data);
+
+DrawEngineType draw_engine_lanpr_type = {
+	NULL, NULL,
+	N_("LANPR"),
+	&lanpr_data_size, // why should we have the "&" ?
+	&lanpr_engine_init,
+	&lanpr_engine_free,
+	&lanpr_cache_init,
+	&lanpr_cache_populate,
+	&lanpr_cache_finish,
+	NULL,//draw background
+	&lanpr_draw_scene,//draw scene, looks like that not much difference except a camera overlay image.
+	&lanpr_view_update,
+	&lanpr_id_update, //&lanpr_id_update, wait till I figure out how to do this.
+	&lanpr_render_to_image,
+};
+
+RenderEngineType DRW_engine_viewport_lanpr_type = {
+	NULL, NULL,
+	LANPR_ENGINE, N_("LANPR"), RE_INTERNAL,
+	NULL,// update
+	&DRW_render_to_image,// render to img
+	NULL,// bake
+	NULL,// doesn't seem to be what I thought it was... &lanpr_view_update,// view update
+	NULL,// render to view
+	NULL,// update in script
+	NULL,// update in render pass
+	&draw_engine_lanpr_type,
+	{NULL, NULL, NULL}
+};
+

source/blender/draw/engines/lanpr/lanpr_snake.c

@@ -0,0 +1,490 @@
+#include "DRW_engine.h"
+#include "DRW_render.h"
+#include "BLI_listbase.h"
+#include "BLI_linklist.h"
+#include "lanpr_all.h"
+#include "DRW_render.h"
+#include "BKE_object.h"
+#include "DNA_mesh_types.h"
+#include "DNA_camera_types.h"
+#include "GPU_immediate.h"
+#include "GPU_immediate_util.h"
+#include "GPU_framebuffer.h"
+#include "DNA_lanpr_types.h"
+#include "DEG_depsgraph_query.h"
+#include "GPU_draw.h"
+#include "GPU_batch.h"
+#include "GPU_framebuffer.h"
+#include "GPU_shader.h"
+#include "GPU_uniformbuffer.h"
+#include "GPU_viewport.h"
+#include "bmesh.h"
+
+extern struct LANPR_SharedResource lanpr_share;
+
+int _TNS_colOffsets[] = { -1, 0, 1, 1, 1, 0, -1, -1 };
+int _TNS_rowOffsets[] = { -1, -1, -1, 0, 1, 1, 1, 0 };
+
+int _TNS_Deviates[8][8] = {
+	{ 0, 1, 2, 3, 4, 3, 2, 1 },
+	{ 1, 0, 1, 2, 3, 4, 3, 2 },
+	{ 2, 1, 0, 1, 2, 3, 4, 3 },
+	{ 3, 2, 1, 0, 1, 2, 3, 4 },
+	{ 4, 3, 2, 1, 0, 1, 2, 3 },
+	{ 3, 4, 3, 2, 1, 0, 1, 2 },
+	{ 2, 3, 4, 3, 2, 1, 0, 1 },
+	{ 1, 2, 3, 4, 3, 2, 1, 0 }
+};
+
+#define TNS_CLAMP_TEXTURE_W(t, col) \
+	{if (col >= t->width) col = t->width - 1; if (col < 0) col = 0; }
+
+#define TNS_CLAMP_TEXTURE_H(t, row) \
+	{if (row >= t->height) row = t->height - 1; if (row < 0) row = 0; }
+
+#define TNS_CLAMP_TEXTURE_CONTINUE(t, col, row) \
+	{if (col >= t->width) continue; if (col < 0) continue; \
+	 if (row >= t->height) continue; if (row < 0) continue; }
+
+
+static LANPR_TextureSample *lanpr_any_uncovered_samples(LANPR_PrivateData *pd){
+	return BLI_pophead(&pd->pending_samples);
+}
+
+int lanpr_direction_deviate(int From, int To) {
+	return _TNS_Deviates[From - 1][To - 1];
+}
+
+int lanpr_detect_direction(LANPR_PrivateData *pd, int col, int row, int LastDirection) {
+	int Deviate[9] = {100};
+	int MinDeviate = 0;
+	int i;
+	LANPR_TextureSample *ts;
+
+	for (i = 0; i < 8; i++) {
+		TNS_CLAMP_TEXTURE_CONTINUE(pd, (_TNS_colOffsets[i] + col), (_TNS_rowOffsets[i] + row));
+		if (ts = pd->sample_table[(_TNS_colOffsets[i] + col) + (_TNS_rowOffsets[i] + row) * pd->width]) {
+			if (!LastDirection) return i + 1;
+			Deviate[i + 1] = lanpr_direction_deviate(i, LastDirection);
+			if (!MinDeviate || Deviate[MinDeviate] > Deviate[i + 1]) MinDeviate = i + 1;
+		}
+	}
+
+	return MinDeviate;
+}
+
+LANPR_LineStrip *lanpr_create_line_strip(LANPR_PrivateData *pd) {
+	LANPR_LineStrip *ls = BLI_mempool_calloc(pd->mp_line_strip);
+	return ls;
+}
+LANPR_LineStripPoint *lanpr_append_point(LANPR_PrivateData *pd, LANPR_LineStrip *ls, real X, real Y, real Z) {
+	LANPR_LineStripPoint *lsp = BLI_mempool_calloc(pd->mp_line_strip_point);
+
+	lsp->P[0] = X;
+	lsp->P[1] = Y;
+	lsp->P[2] = Z;
+
+	BLI_addtail(&ls->points, lsp);
+
+	ls->point_count++;
+
+	return lsp;
+}
+LANPR_LineStripPoint *lanpr_push_point(LANPR_PrivateData *pd, LANPR_LineStrip *ls, real X, real Y, real Z) {
+	LANPR_LineStripPoint *lsp = BLI_mempool_calloc(pd->mp_line_strip_point);
+
+	lsp->P[0] = X;
+	lsp->P[1] = Y;
+	lsp->P[2] = Z;
+
+	BLI_addhead(&ls->points, lsp);
+
+	ls->point_count++;
+
+	return lsp;
+}
+
+void lanpr_destroy_line_strip(LANPR_PrivateData *pd, LANPR_LineStrip *ls) {
+	LANPR_LineStripPoint *lsp;
+	while (lsp = BLI_pophead(&ls->points)) {
+		BLI_mempool_free(pd->mp_line_strip_point, lsp);
+	}
+	BLI_mempool_free(pd->mp_line_strip, ls);
+}
+
+void lanpr_remove_sample(LANPR_PrivateData *pd, int row, int col) {
+	LANPR_TextureSample *ts;
+	ts = pd->sample_table[row * pd->width + col];
+	pd->sample_table[row * pd->width + col] = NULL;
+
+	BLI_remlink(&pd->pending_samples, ts);
+	ts->Item.prev = NULL; ts->Item.next = NULL;
+	BLI_addtail(&pd->erased_samples, ts);
+}
+
+void lanpr_grow_snake_r(LANPR_PrivateData *pd, LANPR_LineStrip *ls, LANPR_LineStripPoint *ThisP, int Direction) {
+	LANPR_LineStripPoint *NewP = ThisP, *p2;
+	int Length = 5;
+	int l = 0;
+	int Deviate, Dir = Direction, NewDir;
+	int AddPoint;
+	int TX = NewP->P[0], TY = NewP->P[1];
+
+	while (NewDir = lanpr_detect_direction(pd, TX, TY, Dir)) {
+		AddPoint = 0;
+		Deviate = lanpr_direction_deviate(NewDir, Dir);
+		Dir = NewDir;
+
+		l++;
+		TX += _TNS_colOffsets[NewDir - 1];
+		TY += _TNS_rowOffsets[NewDir - 1];
+
+		if (Deviate < 2) {
+			lanpr_remove_sample(pd, TY, TX);
+		} elif(Deviate < 3)
+		{
+			lanpr_remove_sample(pd, TY, TX);
+			AddPoint = 1;
+		}
+		else {
+			lanpr_remove_sample(pd, TY, TX);
+			return;
+		}
+
+		if (AddPoint || l == Length) {
+			p2 = lanpr_append_point(pd, ls, TX, TY, 0);
+			NewP = p2;
+			l = 0;
+		}
+	}
+	if (TX != ThisP->P[0] || TY != ThisP->P[1])
+		lanpr_append_point(pd, ls, TX, TY, 0);
+}
+
+void lanpr_grow_snake_l(LANPR_PrivateData *pd, LANPR_LineStrip *ls, LANPR_LineStripPoint *ThisP, int Direction) {
+	LANPR_LineStripPoint *NewP = ThisP, *p2;
+	int Length = 5;
+	int l = 0;
+	int Deviate, Dir = Direction, NewDir;
+	int AddPoint;
+	int TX = NewP->P[0], TY = NewP->P[1];
+
+	while (NewDir = lanpr_detect_direction(pd, TX, TY, Dir)) {
+		AddPoint = 0;
+		Deviate = lanpr_direction_deviate(NewDir, Dir);
+		Dir = NewDir;
+
+		l++;
+		TX += _TNS_colOffsets[NewDir - 1];
+		TY += _TNS_rowOffsets[NewDir - 1];
+
+		if (Deviate < 2) {
+			lanpr_remove_sample(pd, TY, TX);
+		} elif(Deviate < 4)
+		{
+			lanpr_remove_sample(pd, TY, TX);
+			AddPoint = 1;
+		}
+		else {
+			lanpr_remove_sample(pd, TY, TX);
+			return;
+		}
+
+		if (AddPoint || l == Length) {
+			p2 = lanpr_push_point(pd, ls, TX, TY, 0);
+			NewP = p2;
+			l = 0;
+		}
+	}
+	if (TX != ThisP->P[0] || TY != ThisP->P[1])
+		lanpr_push_point(pd, ls, TX, TY, 0);
+}
+
+int lanpr_reverse_direction(int From) {
+	From -= 4;
+	if (From <= 0) From += 8;
+	return From;
+}
+
+
+
+void lanpr_texture_to_ndc(int x, int y, int w, int h, float *x_ndc, float *y_ndc){
+	*x_ndc = tnsLinearItp(-1, 1, (float)x / (float)w);
+	*y_ndc = tnsLinearItp(-1, 1, (float)y / (float)h);
+}
+
+void lanpr_count_drawing_elements(LANPR_PrivateData *pd, int *vert_count, int *index_adjacent_count){
+	int v_count = 0;
+	int e_count = 0;
+	LANPR_LineStrip *ls;
+	for (ls = (LANPR_LineStrip *)(pd->line_strips.first); ls; ls = (LANPR_LineStrip *)(ls->Item.next)) {
+		v_count += (ls->point_count);
+		e_count += ((ls->point_count - 1) * 4);
+	}
+	*vert_count = v_count;
+	*index_adjacent_count = e_count;
+}
+
+GPUBatch *lanpr_get_snake_batch(LANPR_PrivateData *pd){
+	LANPR_LineStrip *ls;
+	LANPR_LineStripPoint *lsp, *plsp;
+	int i;
+	float *Verts;
+	float *Lengths;
+	float TotalLength = 0;
+	int v_count, e_count;
+
+	lanpr_count_drawing_elements(pd, &v_count, &e_count);
+
+	Verts = MEM_callocN(sizeof(float) * v_count * 2, "Verts buffer pre alloc");
+	Lengths = MEM_callocN(sizeof(float) * v_count * 2, "Length buffer pre alloc");
+
+	GPUIndexBufBuilder elb;
+	GPU_indexbuf_init_ex(&elb, GPU_PRIM_LINES_ADJ, e_count, v_count, true);
+
+	int vert_offset = 0;
+
+	for (ls = (LANPR_LineStrip *)(pd->line_strips.first); ls; ls = (LANPR_LineStrip *)(ls->Item.next)) {
+		for (i = 0; i < ls->point_count - 1; i++) {
+			int v1 = i + vert_offset - 1;
+			int v2 = i + vert_offset;
+			int v3 = i + vert_offset + 1;
+			int v4 = i + vert_offset + 2;
+			if (v1 < 0) v1 = 0;
+			if (v4 >= v_count) v4 = v_count - 1;
+			GPU_indexbuf_add_line_adj_verts(&elb, v1, v2, v3, v4);
+		}
+
+		i = 0;
+		float xf, yf;
+		TotalLength = 0;
+		for (lsp = (LANPR_LineStripPoint *)(ls->points.first); lsp; lsp = (LANPR_LineStripPoint *)(lsp->Item.next)) {
+			lanpr_texture_to_ndc(lsp->P[0], lsp->P[1], pd->width, pd->height, &xf, &yf);
+			Verts[vert_offset * 2 + i * 2 + 0] = xf;
+			Verts[vert_offset * 2 + i * 2 + 1] = yf;
+			if (plsp = (LANPR_LineStripPoint *)(lsp->Item.prev)) {
+				TotalLength += tMatDist2v(plsp->P, lsp->P);
+				Lengths[(vert_offset + i) * 2] = TotalLength;
+			}
+			i++;
+		}
+
+		ls->total_length = TotalLength;
+		i = 0;
+		for (lsp = (LANPR_LineStripPoint *)(ls->points.first); lsp; lsp = (LANPR_LineStripPoint *)(lsp->Item.next)) {
+			if (plsp = (LANPR_LineStripPoint *)(lsp->Item.prev)) {
+				Lengths[(vert_offset + i) * 2 + 1] = ls->total_length - Lengths[(vert_offset + i) * 2];
+			}
+			i++;
+		}
+
+		vert_offset += (ls->point_count);
+	}
+
+	static GPUVertFormat format = { 0 };
+	static struct { uint pos, uvs; } attr_id;
+	if (format.attr_len == 0) {
+		attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
+		attr_id.uvs = GPU_vertformat_attr_add(&format, "uvs", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
+	}
+
+	GPUVertBuf *vbo = GPU_vertbuf_create_with_format(&format);
+	GPU_vertbuf_data_alloc(vbo, v_count);
+
+	for (int i = 0; i < v_count; ++i) {
+		GPU_vertbuf_attr_set(vbo, attr_id.pos, i, &Verts[i * 2]);
+		GPU_vertbuf_attr_set(vbo, attr_id.uvs, i, &Lengths[i * 2]);
+	}
+
+	MEM_freeN(Verts);
+	MEM_freeN(Lengths);
+
+	return GPU_batch_create_ex(GPU_PRIM_LINES_ADJ, vbo, GPU_indexbuf_build(&elb), GPU_USAGE_STATIC | GPU_BATCH_OWNS_VBO);
+}
+
+void lanpr_snake_free_pool_data(LANPR_PrivateData *pd) {
+	if (pd->line_result_8bit) MEM_freeN(pd->line_result_8bit);
+	pd->line_result_8bit = 0;
+	if (pd->line_result) MEM_freeN(pd->line_result);
+	pd->line_result = 0;
+	BLI_mempool_clear(pd->mp_line_strip);
+	BLI_mempool_clear(pd->mp_line_strip_point);
+	BLI_mempool_clear(pd->mp_sample);
+	BLI_mempool_clear(pd->mp_batch_list);
+}
+void lanpr_snake_free_readback_data(LANPR_PrivateData *pd) {
+	if (pd->line_result_8bit) MEM_freeN(pd->line_result_8bit);
+	pd->line_result_8bit = 0;
+	if (pd->line_result) MEM_freeN(pd->line_result);
+	pd->line_result = 0;
+}
+
+void lanpr_snake_draw_scene(LANPR_TextureList *txl, LANPR_FramebufferList *fbl, LANPR_PassList *psl, LANPR_PrivateData *pd, SceneLANPR *lanpr, GPUFrameBuffer *DefaultFB, int is_render){
+	eGPUFrameBufferBits clear_bits = GPU_COLOR_BIT | GPU_DEPTH_BIT;
+	float clear_col[4] = {0.0f, 0.0f, 0.0f, 0.0f};
+	float clear_depth = 1.0f;
+	uint clear_stencil = 0xFF;
+
+	const DRWContextState *draw_ctx = DRW_context_state_get();
+	Scene *scene = DEG_get_evaluated_scene(draw_ctx->depsgraph);
+	View3D *v3d = draw_ctx->v3d;
+	Object *camera;
+	if (v3d) {
+		RegionView3D *rv3d = draw_ctx->rv3d;
+		camera = (rv3d->persp == RV3D_CAMOB) ? v3d->camera : NULL;
+	}
+	else {
+		camera = scene->camera;
+	}
+
+	pd->znear = camera ? ((Camera *)camera->data)->clip_start : 0.1;
+	pd->zfar = camera ? ((Camera *)camera->data)->clip_end : 100;
+	pd->normal_clamp =    lanpr->normal_clamp;
+	pd->normal_strength = lanpr->normal_strength;
+	pd->depth_clamp =     lanpr->depth_clamp;
+	pd->depth_strength =  lanpr->depth_strength;
+
+	GPU_framebuffer_bind(fbl->edge_intermediate);
+	DRW_draw_pass(psl->edge_intermediate);
+
+	if ((!lanpr->enable_vector_trace) && (!lanpr->display_thinning_result)) {
+		GPU_framebuffer_bind(DefaultFB);
+		DRW_multisamples_resolve(txl->depth, txl->edge_intermediate, 1);
+		return;
+	}
+
+	if (lanpr->display_thinning_result || lanpr->enable_vector_trace) {
+		pd->stage = 0;
+
+		GPU_framebuffer_bind(DefaultFB);
+		DRW_multisamples_resolve(txl->depth, txl->edge_intermediate, 1);
+
+		GPU_framebuffer_bind(fbl->edge_thinning);
+		DRW_draw_pass(psl->edge_thinning);
+		GPU_framebuffer_bind(DefaultFB);
+		DRW_multisamples_resolve(txl->depth, txl->color, 1);
+
+		pd->stage = 1;
+		GPU_framebuffer_bind(fbl->edge_thinning);
+		DRW_draw_pass(psl->edge_thinning);
+		GPU_framebuffer_bind(DefaultFB);
+		DRW_multisamples_resolve(txl->depth, txl->color, 1);
+
+		pd->stage = 0;
+		GPU_framebuffer_bind(fbl->edge_thinning);
+		DRW_draw_pass(psl->edge_thinning);
+		GPU_framebuffer_bind(DefaultFB);
+		DRW_multisamples_resolve(txl->depth, txl->color, 1);
+
+		pd->stage = 1;
+		GPU_framebuffer_bind(fbl->edge_thinning);
+		DRW_draw_pass(psl->edge_thinning);
+		GPU_framebuffer_bind(DefaultFB);
+		DRW_multisamples_resolve(txl->depth, txl->color, 1);
+
+		if (!lanpr->enable_vector_trace) return;
+	}
+
+	int texw = GPU_texture_width(txl->edge_intermediate), texh = GPU_texture_height(txl->edge_intermediate);;
+	int tsize = texw * texh;
+	int recreate = 0;
+	if (tsize != pd->width * pd->height) recreate = 1;
+
+	if (recreate || !pd->line_result) {
+		if (pd->line_result) MEM_freeN(pd->line_result);
+		pd->line_result = MEM_callocN(sizeof(float) * tsize, "Texture readback buffer");
+
+		if (pd->line_result_8bit) MEM_freeN(pd->line_result_8bit);
+		pd->line_result_8bit = MEM_callocN(sizeof(unsigned char) * tsize, "Texture readback buffer 8bit");
+
+		if (pd->sample_table) MEM_freeN(pd->sample_table);
+		pd->sample_table = MEM_callocN(sizeof(void *) * tsize, "Texture readback buffer 8bit");
+
+		pd->width = texw;
+		pd->height = texh;
+	}
+
+	GPU_framebuffer_bind(DefaultFB);
+	GPU_framebuffer_read_color(DefaultFB, 0, 0, texw, texh, 1, 0, pd->line_result);
+
+	float sample;
+	int h, w;
+	for (h = 0; h < texh; h++) {
+		for (w = 0; w < texw; w++) {
+			int index = h * texw + w;
+			if ((sample = pd->line_result[index]) > 0.9) {
+				pd->line_result_8bit[index] = 255;
+				LANPR_TextureSample *ts = BLI_mempool_calloc(pd->mp_sample);
+				BLI_addtail(&pd->pending_samples, ts);
+				pd->sample_table[index] = ts;
+				ts->X = w;
+				ts->Y = h;
+			}
+			else {
+				pd->sample_table[index] = 0;
+			}
+		}
+	}
+
+	LANPR_TextureSample *ts;
+	LANPR_LineStrip *ls;
+	LANPR_LineStripPoint *lsp;
+	while (ts = lanpr_any_uncovered_samples(pd)) {
+		int Direction = 0;
+		LANPR_LineStripPoint tlsp = { 0 };
+
+		tlsp.P[0] = ts->X;
+		tlsp.P[1] = ts->Y;
+
+		if (Direction = lanpr_detect_direction(pd, ts->X, ts->Y, Direction)) {
+			BLI_addtail(&pd->line_strips, (ls = lanpr_create_line_strip(pd)));
+			lsp = lanpr_append_point(pd, ls, ts->X, ts->Y, 0);
+			lanpr_remove_sample(pd, ts->Y, ts->X);
+
+			lanpr_grow_snake_r(pd, ls, lsp, Direction);
+
+			lanpr_grow_snake_l(pd, ls, lsp, lanpr_reverse_direction(Direction));
+		}
+	}
+
+	GPU_framebuffer_bind(DefaultFB);
+	GPU_framebuffer_clear(DefaultFB, clear_bits, lanpr->background_color, clear_depth, clear_stencil);
+
+	GPU_framebuffer_bind(fbl->edge_intermediate);
+	clear_bits = GPU_COLOR_BIT;
+	GPU_framebuffer_clear(fbl->edge_intermediate, clear_bits, lanpr->background_color, clear_depth, clear_stencil);
+
+	float *tld = &lanpr->taper_left_distance, *tls = &lanpr->taper_left_strength,
+	      *trd = &lanpr->taper_right_distance, *trs = &lanpr->taper_right_strength;
+
+	GPUBatch *snake_batch = lanpr_get_snake_batch(pd);
+
+	lanpr_snake_free_pool_data(pd);
+
+	psl->snake_pass = DRW_pass_create("Snake Visualization Pass", DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_ALWAYS);
+	pd->snake_shgrp = DRW_shgroup_create(lanpr_share.snake_connection_shader, psl->snake_pass);
+	DRW_shgroup_uniform_float(pd->snake_shgrp, "line_width", &lanpr->line_thickness, 1);
+	DRW_shgroup_uniform_float(pd->snake_shgrp, "taper_l_dist", tld, 1);
+	DRW_shgroup_uniform_float(pd->snake_shgrp, "taper_r_dist", tls, 1);
+	DRW_shgroup_uniform_float(pd->snake_shgrp, "taper_l_strength", lanpr->use_same_taper ? tld : trd, 1);
+	DRW_shgroup_uniform_float(pd->snake_shgrp, "taper_r_strength", lanpr->use_same_taper ? tls : trs, 1);
+	DRW_shgroup_uniform_vec4(pd->snake_shgrp, "line_color", lanpr->line_color, 1);
+
+	DRW_shgroup_call(pd->snake_shgrp, snake_batch, NULL);
+	GPU_framebuffer_bind(fbl->edge_intermediate);
+
+	DRW_draw_pass(psl->snake_pass);
+	GPU_batch_discard(snake_batch);
+
+	BLI_mempool_clear(pd->mp_sample);
+	BLI_mempool_clear(pd->mp_line_strip);
+	BLI_mempool_clear(pd->mp_line_strip_point);
+
+	pd->pending_samples.first = pd->pending_samples.last = 0;
+	pd->erased_samples.first = pd->erased_samples.last = 0;
+	pd->line_strips.first = pd->line_strips.last = 0;
+
+	GPU_framebuffer_bind(DefaultFB);
+	DRW_multisamples_resolve(txl->depth, txl->edge_intermediate, 1);
+}
+

source/blender/draw/engines/lanpr/lanpr_util.c

@@ -0,0 +1,992 @@
+/*
+
+   Ported from NUL4.0
+
+   Author(s):WuYiming - xp8110@outlook.com
+
+ */
+#define _CRT_SEQURE_NO_WARNINGS
+#include <stdlib.h>
+#include <stdio.h>
+//#include <time.h>
+#include "lanpr_util.h"
+#include "lanpr_all.h"
+#include <math.h>
+
+
+//===================================================================[slt]
+
+
+void list_handle_empty(ListBase *h) {
+	h->first = h->last = 0;
+}
+
+void *lst_get_top(ListBase *Handle){
+	return Handle->first;
+};
+
+int list_remove_segment(ListBase *Handle, nListItem *Begin, nListItem *End) {
+	if (!Begin->pPrev)
+		Handle->first = End->pNext;
+	else
+		((nListItem *)Begin->pPrev)->pNext = End->pNext;
+
+	if (!End->pNext)
+		Handle->last = Begin->pPrev;
+	else
+		((nListItem *)End->pNext)->pPrev = Begin->pPrev;
+
+	End->pNext = Begin->pPrev = 0;
+
+	return 1;
+};
+void list_insert_item_before(ListBase *Handle, nListItem *toIns, nListItem *pivot){
+	if (!pivot) { BLI_addhead(Handle, toIns); return; }
+
+	if (pivot->pPrev) {
+		((nListItem *)pivot->pPrev)->pNext = toIns;
+		toIns->pPrev = pivot->pPrev;
+	}
+	else {
+		Handle->first = toIns;
+	}
+
+	toIns->pNext = pivot;
+	pivot->pPrev = toIns;
+};
+void list_insert_item_after(ListBase *Handle, nListItem *toIns, nListItem *pivot) {
+	if (!pivot) { BLI_addtail(Handle, toIns); return; }
+
+	if (pivot->pNext) {
+		((nListItem *)pivot->pNext)->pPrev = toIns;
+		toIns->pNext = pivot->pNext;
+	}
+	else {
+		Handle->last = toIns;
+	}
+
+	toIns->pPrev = pivot;
+	pivot->pNext = toIns;
+}
+
+void *list_append_pointer_only(ListBase *h, void *p) {
+	nListItemPointer *lip;
+	if (!h) return 0;
+	lip = CreateNew(nListItemPointer);
+	lip->p = p;
+	BLI_addtail(h, lip);
+	return lip;
+}
+void *list_append_pointer_sized_only(ListBase *h, void *p, int size) {
+	nListItemPointer *lip;
+	if (!h) return 0;
+	lip = calloc(1, size);
+	lip->p = p;
+	BLI_addtail(h, lip);
+	return lip;
+}
+void *list_push_pointer_only(ListBase *h, void *p) {
+	nListItemPointer *lip = 0;
+	if (!h) return 0;
+	lip = CreateNew(nListItemPointer);
+	lip->p = p;
+	BLI_addhead(h, lip);
+	return lip;
+}
+void *list_push_pointer_sized_only(ListBase *h, void *p, int size) {
+	nListItemPointer *lip = 0;
+	if (!h) return 0;
+	lip = calloc(1, size);
+	lip->p = p;
+	BLI_addhead(h, lip);
+	return lip;
+}
+
+void *list_append_pointer(ListBase *h, void *p) {
+	nListItemPointer *lip;
+	if (!h) return 0;
+	lip = memAquireOnly(sizeof(nListItemPointer));
+	lip->p = p;
+	BLI_addtail(h, lip);
+	return lip;
+}
+void *list_append_pointer_sized(ListBase *h, void *p, int size) {
+	nListItemPointer *lip;
+	if (!h) return 0;
+	lip = memAquireOnly(size);
+	lip->p = p;
+	BLI_addtail(h, lip);
+	return lip;
+}
+void *list_push_pointer(ListBase *h, void *p) {
+	nListItemPointer *lip = 0;
+	if (!h) return 0;
+	lip = memAquireOnly(sizeof(nListItemPointer));
+	lip->p = p;
+	BLI_addhead(h, lip);
+	return lip;
+}
+void *list_push_pointer_sized(ListBase *h, void *p, int size) {
+	nListItemPointer *lip = 0;
+	if (!h) return 0;
+	lip = memAquireOnly(size);
+	lip->p = p;
+	BLI_addhead(h, lip);
+	return lip;
+}
+
+void *list_append_pointer_static(ListBase *h, nStaticMemoryPool *smp, void *p) {
+	nListItemPointer *lip;
+	if (!h) return 0;
+	lip = mem_static_aquire(smp, sizeof(nListItemPointer));
+	lip->p = p;
+	BLI_addtail(h, lip);
+	return lip;
+}
+void *list_append_pointer_static_sized(ListBase *h, nStaticMemoryPool *smp, void *p, int size) {
+	nListItemPointer *lip;
+	if (!h) return 0;
+	lip = mem_static_aquire(smp, size);
+	lip->p = p;
+	BLI_addtail(h, lip);
+	return lip;
+}
+void *list_push_pointer_static(ListBase *h, nStaticMemoryPool *smp, void *p) {
+	nListItemPointer *lip = 0;
+	if (!h) return 0;
+	lip = mem_static_aquire(smp, sizeof(nListItemPointer));
+	lip->p = p;
+	BLI_addhead(h, lip);
+	return lip;
+}
+void *list_push_pointer_static_sized(ListBase *h, nStaticMemoryPool *smp, void *p, int size) {
+	nListItemPointer *lip = 0;
+	if (!h) return 0;
+	lip = mem_static_aquire(smp, size);
+	lip->p = p;
+	BLI_addhead(h, lip);
+	return lip;
+}
+
+void *list_pop_pointer_only(ListBase *h) {
+	nListItemPointer *lip;
+	void *rev = 0;
+	if (!h) return 0;
+	lip = BLI_pophead(h); BLI_remlink(h, h->first);
+	rev = lip ? lip->p : 0;
+	FreeMem(lip);
+	return rev;
+}
+void list_remove_pointer_item_only(ListBase *h, nListItemPointer *lip) {
+	BLI_remlink(h, (void *)lip);
+	FreeMem(lip);
+}
+void list_remove_pointer_only(ListBase *h, void *p) {
+	nListItemPointer *i;
+	for (i = h->first; i; i = i->pNext) {
+		if (i->p == p) {
+			list_remove_pointer_item(h, i);
+			break;
+		}
+	}
+}
+void list_clear_pointer_only(ListBase *h) {
+	while (h && h->first) {
+		list_pop_pointer(h);
+	}
+}
+void list_generate_pointer_list_only(ListBase *from1, ListBase *from2, ListBase *to) {
+	nListItemPointer *lip = from2 ? from2->last : 0;
+
+	while (lip) {
+		list_push_pointer(to, lip->p);
+		lip = lip->pPrev;
+	}
+
+	lip = from1 ? from1->last : 0;
+
+	while (lip) {
+		list_push_pointer(to, lip->p);
+		lip = lip->pPrev;
+	}
+}
+
+void *list_pop_pointer(ListBase *h) {
+	nListItemPointer *lip;
+	void *rev = 0;
+	if (!h) return 0;
+	lip = BLI_pophead(h);
+	rev = lip ? lip->p : 0;
+	mem_free(lip);
+	return rev;
+}
+void list_remove_pointer_item(ListBase *h, nListItemPointer *lip) {
+	BLI_remlink(h, (void *)lip);
+	mem_free(lip);
+}
+void list_remove_pointer(ListBase *h, void *p) {
+	nListItemPointer *i;
+	for (i = h->first; i; i = i->pNext) {
+		if (i->p == p) {
+			list_remove_pointer_item(h, i);
+			break;
+		}
+	}
+}
+void list_clear_pointer(ListBase *h) {
+	nListItemPointer *i;
+	while (h && h->first) {
+		list_pop_pointer(h);
+	}
+}
+void list_generate_pointer_list(ListBase *from1, ListBase *from2, ListBase *to) {
+	nListItemPointer *lip = from2 ? from2->last : 0;
+
+	while (lip) {
+		list_push_pointer(to, lip->p);
+		lip = lip->pPrev;
+	}
+
+	lip = from1 ? from1->last : 0;
+
+	while (lip) {
+		list_push_pointer(to, lip->p);
+		lip = lip->pPrev;
+	}
+}
+
+
+void *list_append_pointer_static_pool(nStaticMemoryPool *mph, ListBase *h, void *p) {
+	nListItemPointer *lip;
+	if (!h) return 0;
+	lip = mem_static_aquire(mph, sizeof(nListItemPointer));
+	lip->p = p;
+	BLI_addtail(h, lip);
+	return lip;
+}
+void *list_pop_pointer_no_free(ListBase *h) {
+	nListItemPointer *lip;
+	void *rev = 0;
+	if (!h) return 0;
+	lip = BLI_pophead(h);
+	rev = lip ? lip->p : 0;
+	return rev;
+}
+void list_remove_pointer_item_no_free(ListBase *h, nListItemPointer *lip) {
+	BLI_remlink(h, (void *)lip);
+}
+
+
+void list_copy_handle(ListBase *target, ListBase *src){
+	target->first = src->first;
+	target->last = src->last;
+};
+void list_clear_handle(ListBase *h){
+	h->first = 0;
+	h->last = 0;
+}
+void list_clear_prev_next(nListItem *li){
+	li->pNext = 0;
+	li->pPrev = 0;
+}
+
+void list_move_up(ListBase *h, nListItem *li) {
+	void *pprev = li->pPrev ? ((nListItem *)li->pPrev)->pPrev : 0;
+	if (!h || !li)
+		return;
+	if (li == h->first) return;
+	else {
+		if (li == h->last) h->last = li->pPrev;
+		((nListItem *)li->pPrev)->pNext = li->pNext;
+		((nListItem *)li->pPrev)->pPrev = li;
+		if (li->pNext) ((nListItem *)li->pNext)->pPrev = li->pPrev;
+		li->pNext = li->pPrev;
+		li->pPrev = pprev;
+		if (pprev) ((nListItem *)pprev)->pNext = li;
+	}
+	if (!li->pPrev) h->first = li;
+}
+void list_move_down(ListBase *h, nListItem *li) {
+	void *ppnext = li->pNext ? ((nListItem *)li->pNext)->pNext : 0;
+	if (!h || !li)
+		return;
+	if (li == h->last) return;
+	else {
+		if (li == h->first) h->first = li->pNext;
+		((nListItem *)li->pNext)->pPrev = li->pPrev;
+		((nListItem *)li->pNext)->pNext = li;
+		if (li->pPrev) ((nListItem *)li->pPrev)->pNext = li->pNext;
+		li->pPrev = li->pNext;
+		li->pNext = ppnext;
+		if (ppnext) ((nListItem *)ppnext)->pPrev = li;
+	}
+	if (!li->pNext) h->last = li;
+}
+
+void mem_init_pool(nMemoryPool *mph, int NodeSize) {
+	int Count = 4096;
+
+	if (mph->NodeSize) return;
+
+	mph->NodeSize = NodeSize;
+	mph->CountPerPool = Count;
+
+	return;
+}
+void mem_init_pool_small(nMemoryPool *mph, int NodeSize) {
+	int Count = 16;
+
+	if (mph->NodeSize) return;
+
+	mph->NodeSize = NodeSize;
+	mph->CountPerPool = Count;
+
+	return;
+}
+inline nMemoryPoolPart *mem_new_pool_part(nMemoryPool *mph) {
+
+	if (!mph->NodeSize) return 0;
+
+	int RealNodeSize = mph->NodeSize + sizeof(nMemoryPoolNode);
+	int NodeCount = mph->CountPerPool;
+	int TotalSize = sizeof(nMemoryPoolPart) + NodeCount * RealNodeSize;
+	int i;
+	nMemoryPoolPart *mp = calloc(1, TotalSize);
+
+	void *BeginMem = ((BYTE *)mp) + sizeof(nMemoryPoolPart);
+
+	mp->PoolRoot = mph;
+
+	nMemoryPoolNode *mpn;
+
+	mp->FreeMemoryNodes.first = mp->FreeMemoryNodes.last = BeginMem;
+
+	mpn = (void *)((BYTE *)BeginMem);
+	mpn->InPool = mp;
+
+	for (i = 1; i < NodeCount; i++) {
+		mpn = (void *)(((BYTE *)BeginMem) + RealNodeSize * i);
+		mpn->InPool = mp;
+		BLI_addtail(&mp->FreeMemoryNodes, mpn);
+	}
+	BLI_addhead(&mph->Pools, mp);
+
+	return mp;
+}
+void mem_free(void *Data) {
+	if (!Data) return;
+	nMemoryPoolNode *mpn = (void *)(((BYTE *)Data) - sizeof(nMemoryPoolNode));
+	nMemoryPoolPart *mp = mpn->InPool;
+	nMemoryPool *mph = mp->PoolRoot;
+	BLI_remlink(&mp->MemoryNodes, (void *)mpn);
+	BLI_addtail(&mp->FreeMemoryNodes, (void *)mpn);
+	memset(Data, 0, mph->NodeSize);
+	if (!mp->MemoryNodes.first) {
+		BLI_remlink(&mph->Pools, (void *)mp);
+		FreeMem(mp);
+	}
+	//if (!mph->Pools.first) {
+	//	mph->CountPerPool = 0;
+	//	mph->NodeSize = 0;
+	//}
+}
+void mem_destroy_pool(nMemoryPool *Handle) {
+	nMemoryPool *mp;
+	while ((mp = BLI_pophead(&Handle->Pools))) {
+		FreeMem(mp);
+	}
+}
+
+nStaticMemoryPoolNode *mem_new_static_pool(nStaticMemoryPool *smp) {
+	nStaticMemoryPoolNode *smpn = MEM_callocN(NUL_MEMORY_POOL_128MB, "mempool");
+	smpn->UsedByte = sizeof(nStaticMemoryPoolNode);
+	BLI_addhead(&smp->Pools, smpn);
+	return smpn;
+}
+void *mem_static_aquire(nStaticMemoryPool *smp, int size) {
+	nStaticMemoryPoolNode *smpn = smp->Pools.first;
+	void *ret;
+
+	if (!smpn || (smpn->UsedByte + size) > NUL_MEMORY_POOL_128MB)
+		smpn = mem_new_static_pool(smp);
+
+	ret = ((BYTE *)smpn) + smpn->UsedByte;
+
+	smpn->UsedByte += size;
+
+	return ret;
+}
+void *mem_static_aquire_thread(nStaticMemoryPool *smp, int size) {
+	nStaticMemoryPoolNode *smpn = smp->Pools.first;
+	void *ret;
+
+	BLI_spin_lock(&smp->csMem);
+
+	if (!smpn || (smpn->UsedByte + size) > NUL_MEMORY_POOL_128MB)
+		smpn = mem_new_static_pool(smp);
+
+	ret = ((BYTE *)smpn) + smpn->UsedByte;
+
+	smpn->UsedByte += size;
+
+	BLI_spin_unlock(&smp->csMem);
+
+	return ret;
+}
+void *mem_static_destroy(nStaticMemoryPool *smp) {
+	nStaticMemoryPoolNode *smpn;
+	void *ret = 0;
+
+	while (smpn = BLI_pophead(&smp->Pools)) {
+		FreeMem(smpn);
+	}
+
+	smp->EachSize = 0;
+
+	return ret;
+}
+
+//=======================================================================[str]
+
+
+void tmat_load_identity_44d(tnsMatrix44d m) {
+	memset(m, 0, sizeof(tnsMatrix44d));
+	m[0] = 1.0f;
+	m[5] = 1.0f;
+	m[10] = 1.0f;
+	m[15] = 1.0f;
+};
+
+real tmat_dist_idv2(real x1, real y1, real x2, real y2) {
+	real x = x2 - x1, y = y2 - y1;
+	return sqrt((x * x + y * y));
+}
+real tmat_dist_3dv(tnsVector3d l, tnsVector3d r) {
+	real x = r[0] - l[0];
+	real y = r[1] - l[1];
+	real z = r[2] - l[2];
+	return sqrt(x * x + y * y + z * z);
+}
+real tmat_dist_2dv(tnsVector2d l, tnsVector2d r) {
+	real x = r[0] - l[0];
+	real y = r[1] - l[1];
+	return sqrt(x * x + y * y);
+}
+
+real tmat_length_3d(tnsVector3d l) {
+	return (sqrt(l[0] * l[0] + l[1] * l[1] + l[2] * l[2]));
+}
+real tmat_length_2d(tnsVector3d l) {
+	return (sqrt(l[0] * l[0] + l[1] * l[1]));
+}
+void tmat_normalize_3d(tnsVector3d result, tnsVector3d l) {
+	real r = sqrt(l[0] * l[0] + l[1] * l[1] + l[2] * l[2]);
+	result[0] = l[0] / r;
+	result[1] = l[1] / r;
+	result[2] = l[2] / r;
+}
+void tmat_normalize_3f(tnsVector3f result, tnsVector3f l) {
+	float r = sqrt(l[0] * l[0] + l[1] * l[1] + l[2] * l[2]);
+	result[0] = l[0] / r;
+	result[1] = l[1] / r;
+	result[2] = l[2] / r;
+}
+void tmat_normalize_2d(tnsVector2d result, tnsVector2d l) {
+	real r = sqrt(l[0] * l[0] + l[1] * l[1]);
+	result[0] = l[0] / r;
+	result[1] = l[1] / r;
+}
+void tmat_normalize_self_3d(tnsVector3d result) {
+	real r = sqrt(result[0] * result[0] + result[1] * result[1] + result[2] * result[2]);
+	result[0] /= r;
+	result[1] /= r;
+	result[2] /= r;
+}
+real tmat_dot_3d(tnsVector3d l, tnsVector3d r, int normalize) {
+	tnsVector3d ln, rn;
+	if (normalize) {
+		tmat_normalize_3d(ln, l); tmat_normalize_3d(rn, r);
+		return (ln[0] * rn[0] + ln[1] * rn[1] + ln[2] * rn[2]);
+	}
+	return (l[0] * r[0] + l[1] * r[1] + l[2] * r[2]);
+}
+real tmat_dot_3df(tnsVector3d l, tnsVector3f r, int normalize) {
+	tnsVector3d ln; tnsVector3f rn;
+	if (normalize) {
+		tmat_normalize_3d(ln, l); tmat_normalize_3f(rn, r);
+		return (ln[0] * rn[0] + ln[1] * rn[1] + ln[2] * rn[2]);
+	}
+	return (l[0] * r[0] + l[1] * r[1] + l[2] * r[2]);
+}
+real tmat_dot_2d(tnsVector2d l, tnsVector2d r, int normalize) {
+	tnsVector3d ln, rn;
+	if (normalize) {
+		tmat_normalize_2d(ln, l); tmat_normalize_2d(rn, r);
+		return (ln[0] * rn[0] + ln[1] * rn[1]);
+	}
+	return (l[0] * r[0] + l[1] * r[1]);
+}
+real tmat_vector_cross_3d(tnsVector3d result, tnsVector3d l, tnsVector3d r) {
+	result[0] = l[1] * r[2] - l[2] * r[1];
+	result[1] = l[2] * r[0] - l[0] * r[2];
+	result[2] = l[0] * r[1] - l[1] * r[0];
+	return tmat_length_3d(result);
+}
+void tmat_vector_cross_only_3d(tnsVector3d result, tnsVector3d l, tnsVector3d r) {
+	result[0] = l[1] * r[2] - l[2] * r[1];
+	result[1] = l[2] * r[0] - l[0] * r[2];
+	result[2] = l[0] * r[1] - l[1] * r[0];
+}
+real tmat_angle_rad_3d(tnsVector3d from, tnsVector3d to, tnsVector3d PositiveReference) {
+	if (PositiveReference) {
+		tnsVector3d res;
+		tmat_vector_cross_3d(res, from, to);
+		if (tmat_dot_3d(res, PositiveReference, 1) > 0)
+			return acosf(tmat_dot_3d(from, to, 1));
+		else
+			return -acosf(tmat_dot_3d(from, to, 1));
+	}
+	return acosf(tmat_dot_3d(from, to, 1));
+}
+void tmat_apply_rotation_33d(tnsVector3d result, tnsMatrix44d mat, tnsVector3d v) {
+	result[0] = mat[0] * v[0] + mat[1] * v[1] + mat[2] * v[2];
+	result[1] = mat[3] * v[0] + mat[4] * v[1] + mat[5] * v[2];
+	result[2] = mat[6] * v[0] + mat[7] * v[1] + mat[8] * v[2];
+}
+void tmat_apply_rotation_43d(tnsVector3d result, tnsMatrix44d mat, tnsVector3d v) {
+	result[0] = mat[0] * v[0] + mat[1] * v[1] + mat[2] * v[2];
+	result[1] = mat[4] * v[0] + mat[5] * v[1] + mat[6] * v[2];
+	result[2] = mat[8] * v[0] + mat[9] * v[1] + mat[10] * v[2];
+}
+void tmat_apply_transform_43d(tnsVector3d result, tnsMatrix44d mat, tnsVector3d v) {
+	real w;
+	result[0] = mat[0] * v[0] + mat[4] * v[1] + mat[8] * v[2] + mat[12] * 1;
+	result[1] = mat[1] * v[0] + mat[5] * v[1] + mat[9] * v[2] + mat[13] * 1;
+	result[2] = mat[2] * v[0] + mat[6] * v[1] + mat[10] * v[2] + mat[14] * 1;
+	w = mat[3] * v[0] + mat[7] * v[1] + mat[11] * v[2] + mat[15] * 1;
+	result[0] /= w;
+	result[1] /= w;
+	result[2] /= w;
+}
+void tmat_apply_normal_transform_43d(tnsVector3d result, tnsMatrix44d mat, tnsVector3d v) {
+	real w;
+	result[0] = mat[0] * v[0] + mat[4] * v[1] + mat[8] * v[2] + mat[12] * 1;
+	result[1] = mat[1] * v[0] + mat[5] * v[1] + mat[9] * v[2] + mat[13] * 1;
+	result[2] = mat[2] * v[0] + mat[6] * v[1] + mat[10] * v[2] + mat[14] * 1;
+}
+void tmat_apply_normal_transform_43df(tnsVector3d result, tnsMatrix44d mat, tnsVector3f v) {
+	real w;
+	result[0] = mat[0] * v[0] + mat[4] * v[1] + mat[8] * v[2] + mat[12] * 1;
+	result[1] = mat[1] * v[0] + mat[5] * v[1] + mat[9] * v[2] + mat[13] * 1;
+	result[2] = mat[2] * v[0] + mat[6] * v[1] + mat[10] * v[2] + mat[14] * 1;
+}
+void tmat_apply_transform_44d(tnsVector4d result, tnsMatrix44d mat, tnsVector4d v) {
+	result[0] = mat[0] * v[0] + mat[4] * v[1] + mat[8] * v[2] + mat[12] * 1;
+	result[1] = mat[1] * v[0] + mat[5] * v[1] + mat[9] * v[2] + mat[13] * 1;
+	result[2] = mat[2] * v[0] + mat[6] * v[1] + mat[10] * v[2] + mat[14] * 1;
+	result[3] = mat[3] * v[0] + mat[7] * v[1] + mat[11] * v[2] + mat[15] * 1;
+}
+void tmat_apply_transform_43dfND(tnsVector4d result, tnsMatrix44d mat, tnsVector3f v) {
+	real w;
+	result[0] = mat[0] * v[0] + mat[4] * v[1] + mat[8] * v[2] + mat[12] * 1;
+	result[1] = mat[1] * v[0] + mat[5] * v[1] + mat[9] * v[2] + mat[13] * 1;
+	result[2] = mat[2] * v[0] + mat[6] * v[1] + mat[10] * v[2] + mat[14] * 1;
+	result[3] = mat[3] * v[0] + mat[7] * v[1] + mat[11] * v[2] + mat[15] * 1;
+}
+void tmat_apply_transform_43df(tnsVector4d result, tnsMatrix44d mat, tnsVector3f v) {
+	result[0] = mat[0] * v[0] + mat[4] * v[1] + mat[8] * v[2] + mat[12] * 1;
+	result[1] = mat[1] * v[0] + mat[5] * v[1] + mat[9] * v[2] + mat[13] * 1;
+	result[2] = mat[2] * v[0] + mat[6] * v[1] + mat[10] * v[2] + mat[14] * 1;
+	real w = mat[3] * v[0] + mat[7] * v[1] + mat[11] * v[2] + mat[15] * 1;
+	//result[0] /= w;
+	//result[1] /= w;
+	//result[2] /= w;
+}
+void tmat_apply_transform_44dTrue(tnsVector4d result, tnsMatrix44d mat, tnsVector4d v) {
+	result[0] = mat[0] * v[0] + mat[4] * v[1] + mat[8] * v[2] + mat[12] * v[3];
+	result[1] = mat[1] * v[0] + mat[5] * v[1] + mat[9] * v[2] + mat[13] * v[3];
+	result[2] = mat[2] * v[0] + mat[6] * v[1] + mat[10] * v[2] + mat[14] * v[3];
+	result[3] = mat[3] * v[0] + mat[7] * v[1] + mat[11] * v[2] + mat[15] * v[3];
+}
+
+void tmat_remove_translation_44d(tnsMatrix44d result, tnsMatrix44d mat) {
+	tmat_load_identity_44d(result);
+	result[0] = mat[0];
+	result[1] = mat[1];
+	result[2] = mat[2];
+	result[4] = mat[4];
+	result[5] = mat[5];
+	result[6] = mat[6];
+	result[8] = mat[8];
+	result[9] = mat[9];
+	result[10] = mat[10];
+}
+void tmat_clear_translation_44d(tnsMatrix44d mat) {
+	mat[3] = 0;
+	mat[7] = 0;
+	mat[11] = 0;
+}
+
+
+void tmat_extract_xyz_euler_44d(tnsMatrix44d mat, real *x_result, real *y_result, real *z_result) {
+	real xRot, yRot, zRot;
+
+	if (mat[2] < 1) {
+		if (mat[2] > -1) {
+			yRot = asin(mat[2]);
+			xRot = atan2(-mat[6], mat[10]);
+			zRot = atan2(-mat[1], mat[0]);
+		}
+		else {
+			yRot = -TNS_PI / 2;
+			xRot = -atan2(-mat[4], mat[5]);
+			zRot = 0;
+		}
+	}
+	else {
+		yRot = TNS_PI / 2;
+		xRot = atan2(-mat[4], mat[5]);
+		zRot = 0;
+	}
+
+	(*x_result) = -xRot;
+	(*y_result) = -yRot;
+	(*z_result) = -zRot;
+}
+void tmat_extract_location_44d(tnsMatrix44d mat, real *x_result, real *y_result, real *z_result) {
+	*x_result = mat[12];
+	*y_result = mat[13];
+	*z_result = mat[14];
+}
+void tmat_extract_uniform_scale_44d(tnsMatrix44d mat, real *result) {
+	tnsVector3d v = { mat[0], mat[1], mat[2] };
+	*result = tmat_length_3d(v);
+}
+
+
+
+#define L(row, col)  l[(col << 2) + row]
+#define R(row, col)  r[(col << 2) + row]
+#define P(row, col)  result[(col << 2) + row]
+
+void tmat_print_matrix_44d(tnsMatrix44d l) {
+	int i, j;
+	for (i = 0; i < 4; i++) {
+		for (j = 0; j < 4; j++) {
+			printf("%.5f ", L(i, j));
+		}
+		printf("\n");
+	}
+}
+
+void tmat_obmat_to_16d(float obmat[4][4], tnsMatrix44d out) {
+	out[0] = obmat[0][0];
+	out[1] = obmat[0][1];
+	out[2] = obmat[0][2];
+	out[3] = obmat[0][3];
+	out[4] = obmat[1][0];
+	out[5] = obmat[1][1];
+	out[6] = obmat[1][2];
+	out[7] = obmat[1][3];
+	out[8]  = obmat[2][0];
+	out[9]  = obmat[2][1];
+	out[10] = obmat[2][2];
+	out[11] = obmat[2][3];
+	out[12] = obmat[3][0];
+	out[13] = obmat[3][1];
+	out[14] = obmat[3][2];
+	out[15] = obmat[3][3];
+}
+
+void tmat_copy_matrix_44d(tnsMatrix44d from, tnsMatrix44d to) {
+	memcpy(to, from, sizeof(tnsMatrix44d));
+}
+void tmat_multiply_44d(tnsMatrix44d result, tnsMatrix44d l, tnsMatrix44d r) {
+	int i;
+	for (i = 0; i < 4; i++) {
+		real ai0 = L(i, 0), ai1 = L(i, 1), ai2 = L(i, 2), ai3 = L(i, 3);
+		P(i, 0) = ai0 * R(0, 0) + ai1 * R(1, 0) + ai2 * R(2, 0) + ai3 * R(3, 0);
+		P(i, 1) = ai0 * R(0, 1) + ai1 * R(1, 1) + ai2 * R(2, 1) + ai3 * R(3, 1);
+		P(i, 2) = ai0 * R(0, 2) + ai1 * R(1, 2) + ai2 * R(2, 2) + ai3 * R(3, 2);
+		P(i, 3) = ai0 * R(0, 3) + ai1 * R(1, 3) + ai2 * R(2, 3) + ai3 * R(3, 3);
+	}
+};
+void tmat_inverse_44d(tnsMatrix44d inverse, tnsMatrix44d mat) {
+	int i, j, k;
+	double temp;
+	tnsMatrix44d tempmat;
+	real max;
+	int maxj;
+
+	tmat_load_identity_44d(inverse);
+
+	tmat_copy_matrix_44d(mat, tempmat);
+
+	for (i = 0; i < 4; i++) {
+		/* Look for row with max pivot */
+		max = fabsf(tempmat[i * 5]);
+		maxj = i;
+		for (j = i + 1; j < 4; j++) {
+			if (fabsf(tempmat[j * 4 + i]) > max) {
+				max = fabsf(tempmat[j * 4 + i]);
+				maxj = j;
+			}
+		}
+
+		/* Swap rows if necessary */
+		if (maxj != i) {
+			for (k = 0; k < 4; k++) {
+				real t;
+				t = tempmat[i * 4 + k];
+				tempmat[i * 4 + k] = tempmat[maxj * 4 + k];
+				tempmat[maxj * 4 + k] = t;
+
+				t = inverse[i * 4 + k];
+				inverse[i * 4 + k] = inverse[maxj * 4 + k];
+				inverse[maxj * 4 + k] = t;
+			}
+		}
+
+		//if (UNLIKELY(tempmat[i][i] == 0.0f)) {
+		//	return false;  /* No non-zero pivot */
+		//}
+
+		temp = (double)tempmat[i * 5];
+		for (k = 0; k < 4; k++) {
+			tempmat[i * 4 + k] = (real)((double)tempmat[i * 4 + k] / temp);
+			inverse[i * 4 + k] = (real)((double)inverse[i * 4 + k] / temp);
+		}
+		for (j = 0; j < 4; j++) {
+			if (j != i) {
+				temp = tempmat[j * 4 + i];
+				for (k = 0; k < 4; k++) {
+					tempmat[j * 4 + k] -= (real)((double)tempmat[i * 4 + k] * temp);
+					inverse[j * 4 + k] -= (real)((double)inverse[i * 4 + k] * temp);
+				}
+			}
+		}
+	}
+}
+void tmat_make_translation_matrix_44d(tnsMatrix44d mTrans, real x, real y, real z) {
+	tmat_load_identity_44d(mTrans);
+	mTrans[12] = x;
+	mTrans[13] = y;
+	mTrans[14] = z;
+}
+void tmat_make_perspective_matrix_44d(tnsMatrix44d mProjection, real fFov_rad, real fAspect, real zMin, real zMax) {
+	real yMax;
+	real yMin;
+	real xMin;
+	real xMax;
+
+	if (fAspect < 1) {
+		yMax = zMin * tanf(fFov_rad * 0.5f);
+		yMin = -yMax;
+		xMin = yMin * fAspect;
+		xMax = -xMin;
+	}else {
+		xMax = zMin * tanf(fFov_rad * 0.5f);
+		xMin = -xMax;
+		yMin = xMin / fAspect;
+		yMax = -yMin;
+	}
+
+	tmat_load_identity_44d(mProjection);
+
+	mProjection[0] = (2.0f * zMin) / (xMax - xMin);
+	mProjection[5] = (2.0f * zMin) / (yMax - yMin);
+	mProjection[8] = (xMax + xMin) / (xMax - xMin);
+	mProjection[9] = (yMax + yMin) / (yMax - yMin);
+	mProjection[10] = -((zMax + zMin) / (zMax - zMin));
+	mProjection[11] = -1.0f;
+	mProjection[14] = -((2.0f * (zMax * zMin)) / (zMax - zMin));
+	mProjection[15] = 0.0f;
+}
+void tmat_make_z_tracking_matrix_44d(tnsMatrix44d mat, tnsVector3d this, tnsVector3d that, tnsVector3d up) {
+	tnsVector4d fwd, l, t, rt;
+	fwd[3] = l[3] = t[3] = rt[3] = 1;
+	t[0] = up[0];
+	t[1] = up[1];
+	t[2] = up[2];
+	fwd[0] = that[0] - this[0];
+	fwd[1] = that[1] - this[1];
+	fwd[2] = that[2] - this[2];
+
+	tmat_load_identity_44d(mat);
+
+	tmat_vector_cross_3d(l, t, fwd);
+	tmat_vector_cross_3d(rt, fwd, l);
+
+	tmat_normalize_self_3d(l);
+	tmat_normalize_self_3d(rt);
+	tmat_normalize_self_3d(fwd);
+
+	mat[0] = l[0];
+	mat[1] = l[1];
+	mat[2] = l[2];
+
+	mat[4] = rt[0];
+	mat[5] = rt[1];
+	mat[6] = rt[2];
+
+	mat[8] = fwd[0];
+	mat[9] = fwd[1];
+	mat[10] = fwd[2];
+}
+void tmat_make_z_tracking_delta_matrix_44d(tnsMatrix44d mat, tnsVector3d delta, tnsVector3d up) {
+	tnsVector4d fwd, l, t, rt;
+	fwd[3] = l[3] = t[3] = rt[3] = 1;
+	t[0] = up[0];
+	t[1] = up[1];
+	t[2] = up[2];
+	fwd[0] = delta[0];
+	fwd[1] = delta[1];
+	fwd[2] = delta[2];
+
+	tmat_load_identity_44d(mat);
+
+	tmat_vector_cross_3d(l, t, fwd);
+	tmat_vector_cross_3d(rt, fwd, l);
+
+	tmat_normalize_self_3d(l);
+	tmat_normalize_self_3d(rt);
+	tmat_normalize_self_3d(fwd);
+
+	mat[0] = l[0];
+	mat[1] = l[1];
+	mat[2] = l[2];
+
+	mat[4] = rt[0];
+	mat[5] = rt[1];
+	mat[6] = rt[2];
+
+	mat[8] = fwd[0];
+	mat[9] = fwd[1];
+	mat[10] = fwd[2];
+}
+void tmat_make_ortho_matrix_44d(tnsMatrix44d mProjection, real xMin, real xMax, real yMin, real yMax, real zMin, real zMax) {
+	tmat_load_identity_44d(mProjection);
+
+	mProjection[0] = 2.0f / (xMax - xMin);
+	mProjection[5] = 2.0f / (yMax - yMin);
+	mProjection[10] = -2.0f / (zMax - zMin);
+	mProjection[12] = -((xMax + xMin) / (xMax - xMin));
+	mProjection[13] = -((yMax + yMin) / (yMax - yMin));
+	mProjection[14] = -((zMax + zMin) / (zMax - zMin));
+	mProjection[15] = 1.0f;
+}
+void tmat_make_rotation_matrix_44d(tnsMatrix44d m, real angle_rad, real x, real y, real z)
+{
+	real mag, s, c;
+	real xx, yy, zz, xy, yz, zx, xs, ys, zs, one_c;
+
+	s = (real)sin(angle_rad);
+	c = (real)cos(angle_rad);
+
+	mag = (real)sqrt(x * x + y * y + z * z);
+
+	// Identity matrix
+	if (mag == 0.0f) {
+		tmat_load_identity_44d(m);
+		return;
+	}
+
+	// Rotation matrix is normalized
+	x /= mag;
+	y /= mag;
+	z /= mag;
+
+#define M(row, col)  m[col * 4 + row]
+
+	xx = x * x;
+	yy = y * y;
+	zz = z * z;
+	xy = x * y;
+	yz = y * z;
+	zx = z * x;
+	xs = x * s;
+	ys = y * s;
+	zs = z * s;
+	one_c = 1.0f - c;
+
+	M(0, 0) = (one_c * xx) + c;
+	M(0, 1) = (one_c * xy) + zs;
+	M(0, 2) = (one_c * zx) + ys;
+	M(0, 3) = 0.0f;
+
+	M(1, 0) = (one_c * xy) - zs;
+	M(1, 1) = (one_c * yy) + c;
+	M(1, 2) = (one_c * yz) + xs;
+	M(1, 3) = 0.0f;
+
+	M(2, 0) = (one_c * zx) + ys;
+	M(2, 1) = (one_c * yz) - xs;
+	M(2, 2) = (one_c * zz) + c;
+	M(2, 3) = 0.0f;
+
+	M(3, 0) = 0.0f;
+	M(3, 1) = 0.0f;
+	M(3, 2) = 0.0f;
+	M(3, 3) = 1.0f;
+
+#undef M
+}
+void tmat_make_rotation_x_matrix_44d(tnsMatrix44d m, real angle_rad) {
+	tmat_load_identity_44d(m);
+	m[5] = cos(angle_rad);
+	m[6] = sin(angle_rad);
+	m[9] = -sin(angle_rad);
+	m[10] = cos(angle_rad);
+}
+void tmat_make_rotation_y_matrix_44d(tnsMatrix44d m, real angle_rad) {
+	tmat_load_identity_44d(m);
+	m[0] = cos(angle_rad);
+	m[2] = -sin(angle_rad);
+	m[8] = sin(angle_rad);
+	m[10] = cos(angle_rad);
+}
+void tmat_make_rotation_z_matrix_44d(tnsMatrix44d m, real angle_rad) {
+	tmat_load_identity_44d(m);
+	m[0] = cos(angle_rad);
+	m[1] = sin(angle_rad);
+	m[4] = -sin(angle_rad);
+	m[5] = cos(angle_rad);
+}
+void tmat_make_scale_matrix_44d(tnsMatrix44d m, real x, real y, real z) {
+	tmat_load_identity_44d(m);
+	m[0] = x;
+	m[5] = y;
+	m[10] = z;
+}
+void tmat_make_viewport_matrix_44d(tnsMatrix44d m, real w, real h, real Far, real Near) {
+	tmat_load_identity_44d(m);
+	m[0] = w / 2;
+	m[5] = h / 2;
+	m[10] = (Far - Near) / 2;
+	m[12] = w / 2;
+	m[13] = h / 2;
+	m[14] = (Far + Near) / 2;
+	m[15] = 1;
+	//m[0] = 2/w;
+	//m[5] = 2/h;
+	//m[10] = 1;
+	//m[12] = 2/w;
+	//m[13] = 2/h;
+	//m[14] = 1;
+	//m[15] = 1;
+}
+
+
+real lanpr_LinearInterpolate(real L, real R, real T) {
+	return tnsLinearItp(L, R, T);
+}
+void lanpr_LinearInterpolate2dv(real *L, real *R, real T, real *Result) {
+	Result[0] = tnsLinearItp(L[0], R[0], T);
+	Result[1] = tnsLinearItp(L[1], R[1], T);
+}
+void lanpr_LinearInterpolate3dv(real *L, real *R, real T, real *Result) {
+	Result[0] = tnsLinearItp(L[0], R[0], T);
+	Result[1] = tnsLinearItp(L[1], R[1], T);
+	Result[2] = tnsLinearItp(L[2], R[2], T);
+}
+

source/blender/draw/engines/lanpr/lanpr_util.h

@@ -0,0 +1,321 @@
+#pragma once
+
+#include <string.h>
+//#include "lanpr_all.h"
+#include "BLI_listbase.h"
+#include "BLI_linklist.h"
+#include "BLI_threads.h"
+
+/*
+
+   Ported from NUL4.0
+
+   Author(s):WuYiming - xp8110@outlook.com
+
+ */
+
+#define _CRT_SECURE_NO_WARNINGS
+#define BYTE unsigned char
+
+typedef double real;
+typedef unsigned long long u64bit;
+typedef unsigned int u32bit;
+typedef unsigned short u16bit;
+typedef unsigned short ushort;
+typedef unsigned char u8bit;
+typedef char nShortBuf[16];
+
+typedef float tnsMatrix44f[16];
+
+typedef real tnsMatrix44d[16];
+typedef real tnsVector2d[2];
+typedef real tnsVector3d[3];
+typedef real tnsVector4d[4];
+typedef float tnsVector3f[3];
+typedef float tnsVector4f[4];
+typedef int tnsVector2i[2];
+
+#define TNS_PI 3.1415926535897932384626433832795
+#define deg(r) r / TNS_PI * 180.0
+#define rad(d) d *TNS_PI / 180.0
+
+#define NEED_STRUCTURE(a) \
+	typedef struct _##a a;
+
+#define STRUCTURE(a) \
+	typedef struct _##a a; \
+	struct _##a
+
+#define DBL_TRIANGLE_LIM 1e-8
+#define DBL_EDGE_LIM 1e-9
+
+
+typedef struct _nListItem nListItem;
+struct _nListItem {
+	void *pNext;
+	void *pPrev;
+};
+
+typedef struct _nListItem2 nListItem2;
+struct _nListItem2 {
+	void *O1;
+	void *O2;
+	void *pNext;
+	void *pPrev;
+};
+
+typedef struct _nListItemPointer nListItemPointer;
+struct _nListItemPointer {
+	void *pNext;
+	void *pPrev;
+	void *p;
+};
+
+typedef struct _nHash256 nHash256;
+struct _nHash256 {
+	ListBase Entries[256];
+};
+
+typedef struct _nHash65536 nHash65536;
+struct _nHash65536 {
+	ListBase Entries[65536];
+	//nHash256 HashHandles[256];
+};
+
+typedef struct _nHash16M nHash16M;
+struct _nHash16M {
+	ListBase Entries[16777216];
+};
+
+typedef struct _nSafeString nSafeString;
+struct _nSafeString {
+	nListItem Item;
+	char *Ptr;
+};
+
+typedef struct _nSafeStringCollection nSafeStringCollection;
+struct _nSafeStringCollection {
+	ListBase SafeStrings;
+};
+
+typedef struct _nStringSplitor nStringSplitor;
+struct _nStringSplitor {
+	int NumberParts;
+	ListBase parts;
+};
+
+typedef struct _nStringPart nStringPart;
+struct _nStringPart {
+	nListItem Item;
+	char *Content;
+	int IntValue;
+	real FloatValue;
+	char Type;
+};
+
+STRUCTURE(nStringLine)
+{
+	nListItem Item;
+	char Buf[1024];
+};
+
+STRUCTURE(nStringEdit)
+{
+	ListBase Lines;
+	int CusorLine, CusorBefore;
+	int BeginLine, BeginBefore;
+	int EndLine, EndBefore;
+};
+
+
+#define NUL_MEMORY_POOL_1MB   1048576
+#define NUL_MEMORY_POOL_128MB 134217728
+#define NUL_MEMORY_POOL_256MB 268435456
+#define NUL_MEMORY_POOL_512MB 536870912
+
+STRUCTURE(nMemoryPool)
+{
+	nListItem Item;
+	int NodeSize;
+	int CountPerPool;
+	ListBase Pools;
+};
+
+STRUCTURE(nMemoryPoolPart)
+{
+	nListItem Item;
+	ListBase MemoryNodes;
+	ListBase FreeMemoryNodes;
+	nMemoryPool *PoolRoot;
+	//  <------Mem Begin Here.
+};
+
+NEED_STRUCTURE(nDBInst);
+
+STRUCTURE(nMemoryPoolNode)
+{
+	nListItem Item;
+	nMemoryPoolPart *InPool;
+	nDBInst *DBInst;
+	//  <------User Mem Begin Here
+};
+
+STRUCTURE(nStaticMemoryPoolNode)
+{
+	nListItem Item;
+	int UsedByte;
+	//  <----------- User Mem Start Here
+};
+
+STRUCTURE(nStaticMemoryPool)
+{
+	int EachSize;
+	ListBase Pools;
+	SpinLock csMem;
+};
+
+#define CreateNew(Type) \
+	MEM_callocN(sizeof(Type), "VOID")//nutCalloc(sizeof(Type),1)
+
+#define CreateNew_Size(size) \
+	nutCalloc(size, 1)
+
+#define CreateNewBuffer(Type, Num) \
+	MEM_callocN(sizeof(Type) *Num, "VOID BUFFER")//nutCalloc(sizeof(Type),Num);
+
+#define FreeMem(ptr) \
+	MEM_freeN(ptr)//nutFreeMem((&ptr))
+
+#ifndef elif
+#define elif \
+	else if
+#endif
+
+
+void *nutCalloc(int size, int num);
+
+void *nutCallocHyper(int size, int num);
+void nutFreeMem(void **ptr);
+int nutFloatCompare(real l, real r);
+
+int nutSameAddress(void *l, void *r);
+
+
+void list_handle_empty(ListBase *h);
+
+void list_clear_prev_next(nListItem *li);
+
+void list_insert_item_before(ListBase *Handle, nListItem *toIns, nListItem *pivot);
+void list_insert_item_after(ListBase *Handle, nListItem *toIns, nListItem *pivot);
+void list_insert_segment_before(ListBase *Handle, nListItem *Begin, nListItem *End, nListItem *pivot);
+void lstInsertSegmentAfter(ListBase *Handle, nListItem *Begin, nListItem *End, nListItem *pivot);
+int   lstHaveItemInList(ListBase *Handle);
+void *lst_get_top(ListBase *Handle);
+
+
+void *list_append_pointer_only(ListBase *h, void *p);
+void *list_append_pointer_sized_only(ListBase *h, void *p, int size);
+void *list_push_pointer_only(ListBase *h, void *p);
+void *list_push_pointer_sized_only(ListBase *h, void *p, int size);
+
+void *list_append_pointer(ListBase *h, void *p);
+void *list_append_pointer_sized(ListBase *h, void *p, int size);
+void *list_push_pointer(ListBase *h, void *p);
+void *list_push_pointer_sized(ListBase *h, void *p, int size);
+
+void *list_append_pointer_static(ListBase *h, nStaticMemoryPool *smp, void *p);
+void *list_append_pointer_static_sized(ListBase *h, nStaticMemoryPool *smp, void *p, int size);
+void *list_push_pointer_static(ListBase *h, nStaticMemoryPool *smp, void *p);
+void *list_push_pointer_static_sized(ListBase *h, nStaticMemoryPool *smp, void *p, int size);
+
+void *list_pop_pointer_only(ListBase *h);
+void list_remove_pointer_item_only(ListBase *h, nListItemPointer *lip);
+void list_remove_pointer_only(ListBase *h, void *p);
+void list_clear_pointer_only(ListBase *h);
+void list_generate_pointer_list_only(ListBase *from1, ListBase *from2, ListBase *to);
+
+void *list_pop_pointer(ListBase *h);
+void list_remove_pointer_item(ListBase *h, nListItemPointer *lip);
+void list_remove_pointer(ListBase *h, void *p);
+void list_clear_pointer(ListBase *h);
+void list_generate_pointer_list(ListBase *from1, ListBase *from2, ListBase *to);
+
+void list_copy_handle(ListBase *target, ListBase *src);
+
+void *list_append_pointer_static_pool(nStaticMemoryPool *mph, ListBase *h, void *p);
+void *list_pop_pointer_no_free(ListBase *h);
+void list_remove_pointer_item_no_free(ListBase *h, nListItemPointer *lip);
+
+void list_move_up(ListBase *h, nListItem *li);
+void list_move_down(ListBase *h, nListItem *li);
+
+void lstAddElement(ListBase *hlst, void *ext);
+void lstDestroyElementList(ListBase *hlst);
+
+void mem_init_pool(nMemoryPool *mph, int NodeSize);
+void mem_init_pool_small(nMemoryPool *mph, int NodeSize);
+nMemoryPoolPart *mem_new_pool_part(nMemoryPool *mph);
+
+#define memAquireOnly(a) \
+	MEM_callocN(a, "NONE")
+
+#define memAquire  memAquireOnly
+
+void mem_free(void *Data);
+void mem_destroy_pool(nMemoryPool *Handle);
+
+nStaticMemoryPoolNode *mem_new_static_pool(nStaticMemoryPool *smp);
+void *mem_static_aquire(nStaticMemoryPool *smp, int size);
+void *mem_static_aquire_thread(nStaticMemoryPool *smp, int size);
+void *mem_static_destroy(nStaticMemoryPool *smp);
+
+void tmat_obmat_to_16d(float obmat[4][4], tnsMatrix44d out);
+
+real tmat_dist_idv2(real x1, real y1, real x2, real y2);
+real tmat_dist_3dv(tnsVector3d l, tnsVector3d r);
+real tmat_dist_2dv(tnsVector2d l, tnsVector2d r);
+
+real tmat_length_3d(tnsVector3d l); real tmat_length_2d(tnsVector3d l);
+void tmat_normalize_3d(tnsVector3d result, tnsVector3d l);
+void tmat_normalize_3f(tnsVector3f result, tnsVector3f l);
+void tmat_normalize_self_3d(tnsVector3d result);
+real tmat_dot_3d(tnsVector3d l, tnsVector3d r, int normalize);
+real tmat_dot_3df(tnsVector3d l, tnsVector3f r, int normalize);
+real tmat_dot_2d(tnsVector2d l, tnsVector2d r, int normalize);
+real tmat_vector_cross_3d(tnsVector3d result, tnsVector3d l, tnsVector3d r);
+real tmat_angle_rad_3d(tnsVector3d from, tnsVector3d to, tnsVector3d PositiveReference);
+void tmat_apply_rotation_33d(tnsVector3d result, tnsMatrix44d mat, tnsVector3d v);
+void tmat_apply_rotation_43d(tnsVector3d result, tnsMatrix44d mat, tnsVector3d v);
+void tmat_apply_transform_43d(tnsVector3d result, tnsMatrix44d mat, tnsVector3d v);
+void tmat_apply_transform_43dfND(tnsVector4d result, tnsMatrix44d mat, tnsVector3f v);
+void tmat_apply_normal_transform_43d(tnsVector3d result, tnsMatrix44d mat, tnsVector3d v);
+void tmat_apply_normal_transform_43df(tnsVector3d result, tnsMatrix44d mat, tnsVector3f v);
+void tmat_apply_transform_44d(tnsVector4d result, tnsMatrix44d mat, tnsVector4d v);
+void tmat_apply_transform_43df(tnsVector4d result, tnsMatrix44d mat, tnsVector3f v);
+void tmat_apply_transform_44dTrue(tnsVector4d result, tnsMatrix44d mat, tnsVector4d v);
+
+
+void tmat_load_identity_44d(tnsMatrix44d m);
+void tmat_make_ortho_matrix_44d(tnsMatrix44d mProjection, real xMin, real xMax, real yMin, real yMax, real zMin, real zMax);
+void tmat_make_perspective_matrix_44d(tnsMatrix44d mProjection, real fFov_rad, real fAspect, real zMin, real zMax);
+void tmat_make_translation_matrix_44d(tnsMatrix44d mTrans, real x, real y, real z);
+void tmat_make_rotation_matrix_44d(tnsMatrix44d m, real angle_rad, real x, real y, real z);
+void tmat_make_scale_matrix_44d(tnsMatrix44d m, real x, real y, real z);
+void tmat_make_viewport_matrix_44d(tnsMatrix44d m, real w, real h, real Far, real Near);
+void tmat_multiply_44d(tnsMatrix44d result, tnsMatrix44d l, tnsMatrix44d r);
+void tmat_inverse_44d(tnsMatrix44d inverse, tnsMatrix44d mat);
+void tmat_make_rotation_x_matrix_44d(tnsMatrix44d m, real angle_rad);
+void tmat_make_rotation_y_matrix_44d(tnsMatrix44d m, real angle_rad);
+void tmat_make_rotation_z_matrix_44d(tnsMatrix44d m, real angle_rad);
+void tmat_remove_translation_44d(tnsMatrix44d result, tnsMatrix44d mat);
+void tmat_clear_translation_44d(tnsMatrix44d mat);
+
+real tmat_angle_rad_3d(tnsVector3d from, tnsVector3d to, tnsVector3d PositiveReference);
+real tmat_length_3d(tnsVector3d l);
+void tmat_normalize_2d(tnsVector2d result, tnsVector2d l);
+void tmat_normalize_3d(tnsVector3d result, tnsVector3d l);
+void tmat_normalize_self_3d(tnsVector3d result);
+real tmat_dot_3d(tnsVector3d l, tnsVector3d r, int normalize);
+real tmat_vector_cross_3d(tnsVector3d result, tnsVector3d l, tnsVector3d r);
+void tmat_vector_cross_only_3d(tnsVector3d result, tnsVector3d l, tnsVector3d r);
+

source/blender/draw/engines/lanpr/shaders/lanpr_dpix_preview_frag.glsl

@@ -0,0 +1,5 @@
+in vec4 out_color;
+
+void main(){
+	gl_FragData[0] = vec4(out_color.rgb, 1);
+}

source/blender/draw/engines/lanpr/shaders/lanpr_dpix_preview_geom.glsl

@@ -0,0 +1,154 @@
+layout(points) in;
+layout(triangle_strip, max_vertices = 6) out;
+
+uniform sampler2D vert0_tex;//L
+uniform sampler2D vert1_tex;//R
+uniform sampler2D face_normal0_tex;
+uniform sampler2D face_normal1_tex;// caution: these are face normals!
+uniform sampler2D edge_mask_tex;
+
+//uniform float uValue0; // buffer_w
+uniform vec4 viewport; // viewport
+uniform float depth_offset;
+
+// these are for depth related thickness control;
+uniform float line_thickness;
+uniform float depth_width_influence;
+uniform float depth_width_curve;
+uniform float depth_alpha_influence;
+uniform float depth_alpha_curve;
+uniform float z_near;
+uniform float z_far;
+
+uniform vec4 color;
+uniform vec4 background_color;
+
+uniform vec4 crease_color;
+uniform vec4 material_color;
+uniform vec4 edge_mark_color;
+uniform vec4 intersection_color;
+
+uniform float line_thickness_crease;
+uniform float line_thickness_material;
+uniform float line_thickness_edge_mark;
+uniform float line_thickness_intersection;
+
+// the same as software mode
+uniform int normal_mode;
+uniform int normal_effect_inverse;
+uniform vec3 normal_direction; // also used as point position
+uniform float normal_ramp_begin;
+uniform float normal_ramp_end;
+uniform float normal_thickness_begin;
+uniform float normal_thickness_end;
+
+float use_thickness;
+
+out vec4 out_color;
+
+vec4 use_color;
+
+float get_linear_depth(float z){
+	float ze = 2.0 * z_near * z_far / (z_far + z_near - z * (z_far - z_near));
+	return (ze - z_near) / (z_far - z_near);
+}
+
+float curve_01(float z, float factor){
+	return pow(z, 1 - factor); // factor is -inf~1-eps
+}
+
+vec4 apply_scale(vec4 center, vec4 a){
+	float lz = get_linear_depth(center.z);
+	float depth_factor = mix(0, curve_01(lz, depth_width_curve), depth_width_influence);
+
+	return mix(a, center, depth_factor);
+}
+
+void emit_alpha_pre_mul(vec4 a, int is_crease, float crease_fading){
+	float lz = get_linear_depth(a.z);
+	float alpha_factor = mix(0, curve_01(lz, depth_alpha_curve), depth_alpha_influence);
+	float alpha_crease_fading = alpha_factor;
+	if (is_crease > 0) alpha_crease_fading = mix(alpha_factor, 1, crease_fading * 2); // fading=0.5 -> fade all
+	out_color = mix(use_color, background_color, alpha_crease_fading);
+}
+
+void draw_line(vec4 p1, vec4 p2, int is_crease){
+
+	vec4 Line = p2 - p1;
+	vec4 Normal = normalize(vec4(-Line.y, Line.x, 0, 0));
+
+	vec4 a, b, c, d;
+
+	vec4 offset = Normal * use_thickness * 0.001;
+
+	//correct thickness
+	offset.x *= viewport.w/viewport.z;
+
+	a = p1 + offset;
+	b = p1 - offset;
+	c = p2 + offset;
+	d = p2 - offset;
+
+	a = apply_scale(p1, a);
+	b = apply_scale(p1, b);
+	c = apply_scale(p2, c);
+	d = apply_scale(p2, d);
+
+	gl_Position = vec4(a.xy, a.z - depth_offset, 1); emit_alpha_pre_mul(a, is_crease, p2.w); EmitVertex();
+	gl_Position = vec4(b.xy, b.z - depth_offset, 1); emit_alpha_pre_mul(b, is_crease, p2.w); EmitVertex();
+	gl_Position = vec4(c.xy, c.z - depth_offset, 1); emit_alpha_pre_mul(c, is_crease, p2.w); EmitVertex();
+
+	gl_Position = vec4(b.xy, b.z - depth_offset, 1); emit_alpha_pre_mul(b, is_crease, p2.w); EmitVertex();
+	gl_Position = vec4(c.xy, c.z - depth_offset, 1); emit_alpha_pre_mul(c, is_crease, p2.w); EmitVertex();
+	gl_Position = vec4(d.xy, d.z - depth_offset, 1); emit_alpha_pre_mul(d, is_crease, p2.w); EmitVertex();
+
+	EndPrimitive();
+}
+
+float factor_to_thickness(float factor){
+	float r = (factor - normal_ramp_begin)/(normal_ramp_end - normal_ramp_begin);
+	if(r>1) r=1;
+	if(r<0) r=0;
+	float thickness = normal_effect_inverse==1 ?
+					  mix(normal_thickness_begin,normal_thickness_end,r) :
+					  mix(normal_thickness_end,normal_thickness_begin,r);
+	return thickness;
+}
+
+void main() {
+	vec4 p1 = texelFetch(vert0_tex, ivec2(gl_in[0].gl_Position.xy), 0);
+	vec4 p2 = texelFetch(vert1_tex, ivec2(gl_in[0].gl_Position.xy), 0);
+
+	vec4 n1 = texelFetch(face_normal0_tex, ivec2(gl_in[0].gl_Position.xy), 0);
+	vec4 n2 = texelFetch(face_normal1_tex, ivec2(gl_in[0].gl_Position.xy), 0);
+
+	vec3 use_normal = normalize(mix(n1,n2,0.5).xyz);
+
+	if (p1.w == 0 && p2.w == 0) return;
+
+	vec4 edge_mask = texelFetch(edge_mask_tex, ivec2(gl_in[0].gl_Position.xy), 0);
+
+	int is_crease = 0;
+
+	use_color = color;
+
+	float th=line_thickness;
+	if(normal_mode == 0){
+		th=line_thickness;
+	}else if(normal_mode == 1){
+		float factor = dot(use_normal,normal_direction);
+		th = factor_to_thickness(factor);
+	}else if(normal_mode == 2){
+		float factor = dot(use_normal,normal_direction);
+		th = factor_to_thickness(factor);
+	}
+
+    use_thickness = th;
+	
+	if (edge_mask.g > 0)      { use_color = edge_mark_color;     use_thickness = th * line_thickness_edge_mark; }
+	else if (edge_mask.r > 0) { use_color = material_color;      use_thickness = th * line_thickness_material;  }
+	else if (edge_mask.b > 0) { use_color = intersection_color;  use_thickness = th * line_thickness_intersection;  }
+	else if (p2.w != p1.w)    { use_color = crease_color;        use_thickness = th * line_thickness_crease; is_crease = 1; }
+
+	draw_line(p1, p2, is_crease);
+}

source/blender/draw/engines/lanpr/shaders/lanpr_dpix_project_clip_frag.glsl

@@ -0,0 +1,521 @@
+uniform mat4 ModelMatrix;
+uniform mat4 ViewMatrix;
+uniform mat4 ViewMatrixInverse;
+uniform mat4 ProjectionMatrix;
+uniform mat4 ProjectionMatrixInverse;
+
+
+uniform int enable_crease;
+uniform int enable_material;
+uniform int enable_edge_mark;
+uniform int enable_intersection;
+
+uniform float crease_threshold;
+uniform float crease_fade_threshold;
+
+uniform int is_perspective; // persp and orth use different crease line determin method
+
+//uniform float sample_step; // length calculation unused now.
+//uniform int buffer_width;
+
+uniform vec4 viewport;
+
+uniform sampler2D vert0_tex;
+uniform sampler2D vert1_tex;
+uniform sampler2D face_normal0_tex;
+uniform sampler2D face_normal1_tex;
+uniform sampler2D edge_mask_tex;
+
+//uniform sampler2D TexSample4;
+//#define path_start_end_ptrs TexSample4 // edge adjacent data
+
+//calculate in shader
+
+vec3 view_pos;
+vec3 view_dir;
+
+int is_crease; // we calculate crease in GPU because it's faster and we have normal data anyway.
+               // and we need to indicate crease test success result using p1.w==1 && p2.w==0
+
+float crease_strength;
+
+// these are for adapting argument names...
+#define modelview (ViewMatrix * ModelMatrix)
+#define projection ProjectionMatrix
+#define inverse_projection ProjectionMatrixInverse
+
+
+//ivec2 getTexturePix(vec2 fb_coord){
+//    vec2 n = ((fb_coord+vec2(1,1))/2).xy;
+//    return ivec2(n.x*buffer_width,n.y*buffer_width);
+//}
+
+
+
+// Amount of padding around a segment in the segment atlas.
+// The amount of padding rolls off to zero for short segments,
+// and is zero for segments in the middle of paths.
+
+vec2 segmentPadding(float num_samples, float index,
+                    float start_index, float end_index)
+{
+	const float MAX_PADDING = 10.0;
+
+	float amount = floor(clamp((num_samples - 2.0) * 0.5, 0.0, MAX_PADDING));
+
+	float left = amount * max(1.0 + start_index - index, 0.0);
+	float right = amount * max(1.0 + index - end_index, 0.0);
+
+	return vec2(left, right);
+}
+
+// Converting from linear indices to 2D coordinates and back:
+
+float coordinateToIndex(vec2 coord, float buf_size)
+{
+	vec2 floor_coord = floor(coord);
+	return floor_coord.x + floor_coord.y * buf_size;
+}
+
+vec2 indexToCoordinate(float index, float buf_size)
+{
+	return vec2(mod(index, buf_size), floor(index / buf_size) );
+}
+
+// Packing and unpacking values in the segment atlas offset texture:
+
+float unpackNumSamples(vec4 offset_texel)
+{
+	return offset_texel.b;
+}
+
+float unpackArcLength(vec4 offset_texel)
+{
+	return offset_texel.a;
+}
+
+float unpackSampleOffset(vec4 offset_texel)
+{
+	return offset_texel.r;
+}
+
+float unpackArcLengthOffset(vec4 offset_texel)
+{
+	return offset_texel.g;
+}
+
+vec4 packOffsetTexel(float num_samples, float arc_length)
+{
+	return vec4(num_samples, arc_length, num_samples, arc_length);
+}
+
+vec4 packOffsetTexel(float num_samples, float arc_length,
+                     float num_samples_offset, float arc_length_offset)
+{
+	return vec4(num_samples_offset, arc_length_offset, num_samples, arc_length);
+}
+
+// Packing and unpacking values in the 3D vertex positions:
+
+float unpackPathStart(vec4 texel)
+{
+	return texel.r;
+}
+
+float unpackPathEnd(vec4 texel)
+{
+	return texel.g;
+}
+
+float unpackPathLength(vec4 texel)
+{
+	return texel.b;
+}
+
+// Projecting and unprojecting:
+
+vec2 clipToWindow(sampler2D clip_positions, vec4 viewport, ivec2 coordinate)
+{
+	vec4 clip = texelFetch(clip_positions, coordinate, 0);
+	vec3 post_div = clip.xyz / clip.w;
+	return (post_div.xy + vec2(1.0, 1.0)) * 0.5 * viewport.zw;
+}
+
+vec2 clipToWindow(vec4 clip, vec4 viewport)
+{
+	vec3 post_div = clip.xyz / clip.w;
+	return (post_div.xy + vec2(1.0, 1.0)) * 0.5 * viewport.zw;
+}
+
+// Path id encoding and decoding.
+
+bool idEqualGreaterThan(vec3 a, vec3 b)
+{
+	float ida = a.b * 256.0 * 256.0 + a.g * 256.0 + a.r;
+	float idb = b.b * 256.0 * 256.0 + b.g * 256.0 + b.r;
+	const float small = 0.001;
+	return ida - idb > -small;
+}
+
+bool idsEqual(vec3 a, vec3 b)
+{
+	float ida = a.b * 256.0 * 256.0 + a.g * 256.0 + a.r;
+	float idb = b.b * 256.0 * 256.0 + b.g * 256.0 + b.r;
+	const float small = 0.001;
+	return abs(ida - idb) < small;
+}
+
+vec3 idToColor(float id)
+{
+	id = id + 1.0;
+	float blue = floor(id / (256.0 * 256.0));
+	float green = floor(id / 256.0) - blue * 256.0;
+	float red = id - green * 256.0 - blue * 256.0 * 256.0;
+	return vec3(red, green, blue) / 255.0;
+}
+
+
+
+struct segment {
+	vec3 p1;
+	vec3 p2;
+	bool on_screen;
+};
+
+float epsilon = 0.00001;
+float xmin = -1.1;
+float xmax = 1.1;
+float ymin = -1.1;
+float ymax = 1.1;
+
+// this is a conservative offscreen rejection test ... catches most cases
+bool segmentOffScreen(vec3 p0, vec3 p1)
+{
+	return ( (p0[0] < xmin && p1[0] < xmin) ||
+	         (p0[0] > xmax && p1[0] > xmax) ||
+	         (p0[1] < ymin && p1[1] < ymin) ||
+	         (p0[1] > ymax && p1[1] > ymax) );
+}
+
+bool pointOffScreen(vec3 p)
+{
+	return  (p[0] < xmin ||
+	         p[0] > xmax ||
+	         p[1] < ymin ||
+	         p[1] > ymax);
+}
+
+
+vec3 clipMinMaxX(vec3 outv, vec3 inv)
+{
+	vec3 ret = outv;
+	if (outv.x < xmin)
+	{
+		float t = (xmin - outv.x) / (inv.x - outv.x);
+		ret = t * inv + (1.0 - t) * outv;
+	}
+	else if (outv.x > xmax)
+	{
+		float t = (xmax - inv.x) / (outv.x - inv.x);
+		ret = t * outv + (1.0 - t) * inv;
+	}
+	return ret;
+}
+
+vec3 clipMinMaxY(vec3 outv, vec3 inv)
+{
+	vec3 ret = outv;
+	if (outv.y < ymin)
+	{
+		float t = (ymin - outv.y) / (inv.y - outv.y);
+		ret = t * inv + (1.0 - t) * outv;
+	}
+	else if (outv.y > ymax)
+	{
+		float t = (ymax - inv.y) / (outv.y - inv.y);
+		ret = t * outv + (1.0 - t) * inv;
+	}
+	return ret;
+}
+
+vec3 clipSegmentOneOut(vec3 off_screen, vec3 on_screen)
+{
+	vec3 outv = off_screen;
+
+	// first clip against the x coords
+	outv = clipMinMaxX(outv, on_screen);
+
+	// now clip against the y coords using the newly clipped point
+	outv = clipMinMaxY(outv, on_screen);
+
+	return outv;
+}
+
+
+segment clipToMin(float min, segment inseg, float p1val, float p2val)
+{
+	float minPos = min + epsilon;
+	float minNeg = min - epsilon;
+	segment outseg = segment(inseg.p1, inseg.p2, inseg.on_screen);
+
+	// trivial reject
+	if ((p1val < minPos && p2val < minPos) || inseg.on_screen == false)
+	{
+		outseg.on_screen = false;
+	}
+
+	// cut at min
+	if (p1val < minPos)
+	{
+		float t = (min - p1val) / (p2val - p1val);
+		outseg.p1 = t * inseg.p2 + (1.0 - t) * inseg.p1;
+	}
+	else if (p2val < minPos)
+	{
+		float t = (min - p2val) / (p1val - p2val);
+		outseg.p2 = t * inseg.p1 + (1.0 - t) * inseg.p2;
+	}
+	return outseg;
+}
+
+segment clipToMax(float max, segment inseg, float p1val, float p2val)
+{
+	float maxPos = max + epsilon;
+	float maxNeg = max - epsilon;
+	segment outseg = segment(inseg.p1, inseg.p2, inseg.on_screen);
+
+	// trivial reject
+	if ((p1val > maxNeg && p2val > maxNeg) || inseg.on_screen == false)
+	{
+		outseg.on_screen = false;
+	}
+
+	// cut at max
+	if (p1val > maxNeg)
+	{
+		float t = (max - p2val) / (p1val - p2val);
+		outseg.p1 = t * inseg.p1 + (1.0 - t) * inseg.p2;
+	}
+	else if (p2val > maxNeg)
+	{
+		float t = (max - p1val) / (p2val - p1val);
+		outseg.p2 = t * inseg.p2 + (1.0 - t) * inseg.p1;
+	}
+	return outseg;
+}
+
+segment clipSegmentBothOut(vec3 p1, vec3 p2)
+{
+	segment seg = segment(p1, p2, true);
+
+	seg = clipToMin(xmin, seg, seg.p1.x, seg.p2.x);
+	seg = clipToMax(xmax, seg, seg.p1.x, seg.p2.x);
+	seg = clipToMin(ymin, seg, seg.p1.y, seg.p2.y);
+	seg = clipToMax(ymax, seg, seg.p1.y, seg.p2.y);
+
+	return seg;
+}
+
+vec3 clipSegmentToNear(vec3 off_screen, vec3 on_screen)
+{
+	// see http://members.tripod.com/~Paul_Kirby/vector/Vplanelineint.html
+
+	vec3 a = off_screen;
+	vec3 b = on_screen;
+	vec3 c = view_pos + view_dir;
+	vec3 n = view_dir;
+	float t = dot((c - a), n) / dot((b - a), n);
+
+	vec3 clipped = a + (b - a) * t;
+	return clipped;
+}
+
+bool pointBeyondNear(vec3 p)
+{
+	vec3 offset = p - view_pos;
+	bool beyond = dot(offset, view_dir) > 0.0;
+	return beyond;
+}
+
+// 1 for contour 2 for others
+int testProfileEdge(ivec2 texcoord, vec3 world_position)
+{
+	// This should really be the inverse transpose of the modelview matrix, but
+	// that only matters if the camera has a weird anisotropic scale or skew.
+
+	mat3 nm = mat3(transpose(inverse(ModelMatrix)));
+	vec3 face_normal_0 = mat3(nm) * texelFetch(face_normal0_tex, texcoord, 0).xyz;
+	vec3 face_normal_1 = mat3(nm) * texelFetch(face_normal1_tex, texcoord, 0).xyz;
+	vec3 camera_to_line = is_perspective == 1 ?
+	                      world_position - view_pos :
+						  view_dir;//modelview * vec4(world_position, 1.0);
+
+	vec4 edge_mask = texelFetch(edge_mask_tex, texcoord, 0);
+
+	float dot0 = dot(camera_to_line.xyz, vec3(face_normal_0.xyz));
+	float dot1 = dot(camera_to_line.xyz, vec3(face_normal_1.xyz));
+	float dot2 = dot(normalize(vec3(face_normal_0.xyz)), normalize(vec3(face_normal_1.xyz)));
+
+	bool contour = (dot0 >= 0.0 && dot1 <= 0.0) || (dot0 <= 0.0 && dot1 >= 0.0);
+	is_crease = ((!contour) && ((dot2 < crease_threshold) || (dot2 < crease_fade_threshold))) ? 1 : 0;
+
+	crease_strength = (is_crease > 0 && dot2 > crease_threshold) ?
+	                  ((dot2 - crease_threshold) / (crease_fade_threshold - crease_threshold) / 2) : 0;
+	// use 0 to 0.5 to repesent the range, because 1 will represent another meaning
+
+	if(contour) return 1;
+	else if(((enable_crease > 0) && (is_crease > 0)) ||
+	       ((enable_material > 0) && (edge_mask.r > 0)) ||
+	       ((enable_edge_mark > 0) && (edge_mask.g > 0)) ||
+	       ((enable_intersection > 0) && (edge_mask.b > 0)) ||
+	       false) return 2;
+	return 0;
+}
+
+void main(){
+
+	view_dir = -mat3(ViewMatrixInverse) * vec3(0, 0, 1);
+	view_pos = (ViewMatrixInverse)[3].xyz;
+
+	xmin *= viewport.z / viewport.w;
+	xmax *= viewport.z / viewport.w;
+
+	// look up the world positions of the segment vertices
+	ivec2 texcoord = ivec2(gl_FragCoord.xy);
+
+	vec4 v0_world_pos = texelFetch(vert0_tex, texcoord, 0);
+	vec4 v1_world_pos = texelFetch(vert1_tex, texcoord, 0);
+	v0_world_pos = ModelMatrix * vec4(v0_world_pos.xyz, 1);
+	v1_world_pos = ModelMatrix * vec4(v1_world_pos.xyz, 1);
+
+	// early exit if there are no vertices here to process
+	if (v0_world_pos.w < 0.5)
+	{
+		// no vertex data to process
+		gl_FragData[0] = vec4(0.5, 0.0, 0.0, 0.0);
+		gl_FragData[1] = vec4(0.5, 0.5, 0.0, 0.0);
+		// must write something into fragdata[2] to prevent
+		// buffer 2 from getting filled with garbage? (very weird)
+		gl_FragData[2] = vec4(0.0, 1.0, 0.0, 0.0);
+		return;
+	}
+
+	vec3 v0_clipped_near = v0_world_pos.xyz;
+	vec3 v1_clipped_near = v1_world_pos.xyz;
+
+	if(is_perspective==1){
+		// clip to the near plane
+		bool v0_beyond_near = pointBeyondNear(v0_world_pos.xyz);
+		bool v1_beyond_near = pointBeyondNear(v1_world_pos.xyz);
+
+		if (!v0_beyond_near && !v1_beyond_near)
+		{
+			// segment entirely behind the camera
+			gl_FragData[0] = vec4(0.0, 1.0, 0.0, 0.0);
+			gl_FragData[1] = vec4(0.0, 0.0, 1.0, 0.0);
+			gl_FragData[2] = vec4(0.0, 1.0, 0.0, 0.0);
+			return;
+		}
+		else if (!v0_beyond_near)
+		{
+			v0_clipped_near = clipSegmentToNear(v0_world_pos.xyz, v1_clipped_near);
+		}
+		else if (!v1_beyond_near)
+		{
+			v1_clipped_near = clipSegmentToNear(v1_world_pos.xyz, v0_clipped_near);
+		}
+	}
+
+	// If this segment is a profile edge, test to see if it should be turned on.
+	//if (v1_world_pos.w > 0.5)
+	//{
+	int profile_on = testProfileEdge(texcoord, v0_clipped_near);
+	if (profile_on==0)
+	{
+		// Profile edge should be off.
+		gl_FragData[0] = vec4(0.0, 1.0, 0.5, 0.0);
+		gl_FragData[1] = vec4(0.0, 0.5, 1.0, 0.0);
+		gl_FragData[2] = vec4(0.0, 1.0, 0.0, 0.0);
+		return;
+	}
+	//}
+
+	// project
+	vec4 v0_pre_div = projection * ViewMatrix * vec4(v0_clipped_near, 1.0);
+	vec4 v1_pre_div = projection * ViewMatrix * vec4(v1_clipped_near, 1.0);
+
+	// perspective divide
+	vec3 v0_clip_pos = v0_pre_div.xyz;
+	vec3 v1_clip_pos = v1_pre_div.xyz;
+	if(is_perspective==1){
+		v0_clip_pos /= v0_pre_div.w;
+		v1_clip_pos /= v1_pre_div.w;
+	}
+	// clip to frustum
+	bool v0_on_screen = !pointOffScreen(v0_clip_pos);
+	bool v1_on_screen = !pointOffScreen(v1_clip_pos);
+
+	if (!v0_on_screen && !v1_on_screen)
+	{
+		segment ret = clipSegmentBothOut(v0_clip_pos, v1_clip_pos);
+		if (ret.on_screen == false)
+		{
+			// segment entirely off screen: BLUE / MAGENTA / BLACK
+			gl_FragData[0] = vec4(0.0, 0.0, 1.0, 0.0);
+			gl_FragData[1] = vec4(1.0, 0.0, 1.0, 0.0);
+			gl_FragData[2] = vec4(0.0, 0.0, 0.0, 0.0);
+			return;
+		}
+		v0_clip_pos = ret.p1;
+		v1_clip_pos = ret.p2;
+	}
+	else if (!v0_on_screen)
+	{
+		v0_clip_pos = clipSegmentOneOut(v0_clip_pos, v1_clip_pos);
+	}
+	else if (!v1_on_screen)
+	{
+		v1_clip_pos = clipSegmentOneOut(v1_clip_pos, v0_clip_pos);
+	}
+
+
+	// convert to window coordinates
+	vec2 v0_screen = (v0_clip_pos.xy + vec2(1.0, 1.0)) * 0.5 * viewport.zw;
+	vec2 v1_screen = (v1_clip_pos.xy + vec2(1.0, 1.0)) * 0.5 * viewport.zw;
+
+	//if(v1_screen == v0_screen){ gl_FragData[0] = vec4(1,0,0,1); return; }
+
+
+	float segment_screen_length = length(v0_screen - v1_screen);
+
+	// scale the length by sample_step to get the number of samples
+	//float num_samples = segment_screen_length / sample_step;
+	//num_samples = ceil(num_samples);
+
+	// Unproject and reproject the final clipped positions
+	// so that interpolation is perspective correct later on.
+	vec4 v0_world = inverse_projection * vec4(v0_clip_pos, 1.0);
+	vec4 v1_world = inverse_projection * vec4(v1_clip_pos, 1.0);
+	vec4 v0_clipped_pre_div = projection * v0_world;
+	vec4 v1_clipped_pre_div = projection * v1_world;
+
+	// Add some padding to the number of samples so that filters
+	// that work along the segment length (such as overshoot)
+	// have some room to work with at the end of each segment.
+	//vec4 path_texel = texelFetch(path_start_end_ptrs, texcoord,0);
+	//vec2 padding = segmentPadding(num_samples,
+	//    coordinateToIndex(texcoord, buffer_width),
+	//    unpackPathStart(path_texel),
+	//    unpackPathEnd(path_texel));
+	//float total_padding = padding.x + padding.y;
+
+	//if(v0_clipped_pre_div == v1_clipped_pre_div)gl_FragData[0] =vec4(1);
+	//else gl_FragData[0] = vec4(v0_clipped_pre_div.xyz,1);
+
+	gl_FragData[0] = vec4(v0_clipped_pre_div.xyz, 1);//contour has priority, modification cause trouble
+	gl_FragData[1] = vec4(v1_clipped_pre_div.xyz, is_crease > 0 ? crease_strength : 1);
+	//gl_FragData[2] = packOffsetTexel(num_samples, segment_screen_length,
+	//num_samples, segment_screen_length);
+	//num_samples + total_padding, segment_screen_length);
+}
+

source/blender/draw/engines/lanpr/shaders/lanpr_dpix_project_passthrough_vert.glsl

@@ -0,0 +1,6 @@
+in vec4 pos;
+
+
+void main(){
+	gl_Position = pos;
+}

source/blender/draw/engines/lanpr/shaders/lanpr_snake_edge_frag.glsl

@@ -0,0 +1,94 @@
+in vec4 uvcoordsvar;
+uniform sampler2DMS tex_sampe_0;//depth
+uniform sampler2DMS tex_sample_1;//color
+uniform sampler2DMS tex_sample_2;//normal
+uniform float normal_clamp;//normal clamp
+uniform float normal_strength;//normal strength
+uniform float depth_clamp;//depth clamp
+uniform float depth_strength;//depth strength
+uniform float z_near;//z_near
+uniform float z_far;//z_far
+
+mat3 sx = mat3(
+	1.0, 2.0, 1.0,
+	0.0, 0.0, 0.0,
+	-1.0, -2.0, -1.0
+	);
+mat3 sy = mat3(
+	1.0, 0.0, -1.0,
+	2.0, 0.0, -2.0,
+	1.0, 0.0, -1.0
+	);
+vec3 rgb2hsv(vec3 c)
+{
+	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+	vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
+	vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
+	float d = q.x - min(q.w, q.y);
+	float e = 1.0e-10;
+	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+}
+float linearDepth(float depthSample){
+	float d = 2.0 * depthSample - 1.0;
+	float zLinear = 2.0 * z_near * z_far / (z_far + z_near - d * (z_far - z_near));
+	return zLinear;
+}
+
+vec4 DetectEdge(sampler2DMS tex, float clamp, float strength){
+	mat3 I = mat3(0);
+	mat3 J = mat3(0);
+	mat3 K = mat3(0);
+
+	ivec2 texSize = textureSize(tex);
+	ivec2 sp = ivec2(uvcoordsvar.xy * texSize);
+	vec4 cs = vec4(0);
+
+	//sample hardcoded (8) now
+	for (int s = 0; s < 8; s++) {
+		for (int i = 0; i < 3; i++) {
+			for (int j = 0; j < 3; j++) {
+				vec4 col = texelFetch(tex, sp + ivec2(i - 1, j - 1), s);
+				vec3 sample1 = vec3((col.r));
+				vec3 sample2 = vec3((col.g));
+				vec3 sample3 = vec3((col.b));
+				I[i][j] += length(sample1) / 8;
+				J[i][j] += length(sample2) / 8;
+				K[i][j] += length(sample3) / 8;
+			}
+		}
+		cs += texelFetch(tex_sample_1, sp, s) / 8;
+	}
+
+	float gx1 = dot(sx[0], I[0]) + dot(sx[1], I[1]) + dot(sx[2], I[2]);
+	float gy1 = dot(sy[0], I[0]) + dot(sy[1], I[1]) + dot(sy[2], I[2]);
+	float g1 = sqrt(pow(gx1, 2.0) + pow(gy1, 2.0));
+
+	float gx2 = dot(sx[0], J[0]) + dot(sx[1], J[1]) + dot(sx[2], J[2]);
+	float gy2 = dot(sy[0], J[0]) + dot(sy[1], J[1]) + dot(sy[2], J[2]);
+	float g2 = sqrt(pow(gx2, 2.0) + pow(gy2, 2.0));
+
+	float gx3 = dot(sx[0], K[0]) + dot(sx[1], K[1]) + dot(sx[2], K[2]);
+	float gy3 = dot(sy[0], K[0]) + dot(sy[1], K[1]) + dot(sy[2], K[2]);
+	float g3 = sqrt(pow(gx3, 2.0) + pow(gy3, 2.0));
+
+	float value = max(max(g1, g2), g3);
+
+	value = value > clamp ? value : 0;
+	return vec4(vec3(value * strength), 1);
+
+	//if(value<clamp) value=0;
+
+	//return vec4(pow(value,strength));
+}
+
+void main()
+{
+	float nc = normal_clamp;//(normal_clamp==0? 0.01:normal_clamp);
+	float ns = normal_strength;//(normal_strength==0? 5:   normal_strength);
+	float dc = depth_clamp;//(depth_clamp==0? 0.2: depth_clamp);
+	float ds = depth_strength;//(depth_strength==0? 2.5: depth_strength);
+
+	vec4 diffuse = vec4(1, 1, 1, 1);
+	vec4 color = (DetectEdge(tex_sampe_0, dc, ds) + DetectEdge(tex_sample_2, nc, ns));
+	gl_FragColor = color;
+};

source/blender/draw/engines/lanpr/shaders/lanpr_snake_image_peel_frag.glsl

@@ -0,0 +1,91 @@
+
+in vec4 uvcoordsvar;
+uniform sampler2D tex_sample_0;
+uniform int stage;
+
+int decisions[256] = int[] (0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1,
+                            1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1,
+                            0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1,
+                            1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1,
+                            1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                            1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1,
+                            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                            0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1,
+                            1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1,
+                            0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1,
+                            1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+                            1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                            1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+                            1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0,
+                            1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0);
+
+int PickPixel(ivec2 sp){
+	vec4 accum = vec4(0);
+	//for(int i=0;i<4;i++){
+	accum += texelFetch(tex_sample_0, sp, 0);
+	//}
+	return (accum.r > 0.9) ? 1 : 0;
+
+}
+
+//MZS Thinning method, implemented by YimingWu
+
+void main(){
+
+	ivec2 texSize = textureSize(tex_sample_0, 0);
+	ivec2 sp = ivec2(uvcoordsvar.xy * texSize);
+	vec4 OriginalColor = texelFetch(tex_sample_0, sp, 0);
+
+	int p2 = PickPixel(sp + ivec2(0, +1));
+	int p3 = PickPixel(sp + ivec2(+1, +1));
+	int p4 = PickPixel(sp + ivec2(+1, 0));
+	int p5 = PickPixel(sp + ivec2(+1, -1));
+	int p6 = PickPixel(sp + ivec2(0, -1));
+	int p7 = PickPixel(sp + ivec2(-1, -1));
+	int p8 = PickPixel(sp + ivec2(-1, 0));
+	int p9 = PickPixel(sp + ivec2(-1, +1));
+
+	int Bp1  = p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9;
+
+	bool bp2 = bool(p2);
+	bool bp3 = bool(p3);
+	bool bp4 = bool(p4);
+	bool bp5 = bool(p5);
+	bool bp6 = bool(p6);
+	bool bp7 = bool(p7);
+	bool bp8 = bool(p8);
+	bool bp9 = bool(p9);
+
+	int Cp1 = int(!bp2 && (bp3 || bp4)) + int(!bp4 && (bp5 || bp6)) + int(!bp6 && (bp7 || bp8)) + int(!bp8 && (bp9 || bp2));
+
+	if (stage == 0) {
+		if (((sp.x + sp.y) % 2 == 0) &&
+		    (Cp1 == 1)           &&
+		    (Bp1 >= 2 && Bp1 <= 7) &&
+		    (p2 * p4 * p6 == 0)      &&
+		    (p4 * p6 * p8 == 0)) {
+			gl_FragColor = vec4(0, 0, 0, 1);
+			return;
+		}
+		gl_FragColor = OriginalColor;
+	}
+	else {
+		if (((sp.x + sp.y) % 2 != 0) &&
+		    (Cp1 == 1)           &&
+		    (Bp1 >= 1 && Bp1 <= 7) &&
+		    (p2 * p4 * p8 == 0)      &&
+		    (p2 * p6 * p8 == 0)) {
+			gl_FragColor = vec4(0, 0, 0, 1);
+			return;
+		}
+		gl_FragColor = OriginalColor;
+	}
+
+	//int test = PickPixel(sp+ivec2(-1,-1))*1 + PickPixel(sp+ivec2(0 ,-1))*2 + PickPixel(sp+ivec2(+1,-1))*4
+	//         + PickPixel(sp+ivec2(-1, 0))*8 + PickPixel(sp+ivec2(+1, 0))*16
+	//		 + PickPixel(sp+ivec2(-1,+1))*32 + PickPixel(sp+ivec2( 0,+1))*64 + PickPixel(sp+ivec2(+1,+1))*128;
+
+	//if(decisions[test]==1) gl_FragColor=vec4(1,0,0,1);
+	//else gl_FragColor=texelFetch(tex_sample_0, sp, 0);//vec4(1,1,1,1);
+}

source/blender/draw/engines/lanpr/shaders/lanpr_snake_line_connection_frag.glsl

@@ -0,0 +1,5 @@
+uniform vec4 line_color;
+
+void main(){
+	gl_FragColor = line_color;
+}

source/blender/draw/engines/lanpr/shaders/lanpr_snake_line_connection_geom.glsl

@@ -0,0 +1,105 @@
+layout(lines_adjacency) in;
+layout(triangle_strip, max_vertices = 6) out;
+
+in vec2 gOffset[];
+
+uniform float line_width;
+uniform float taper_l_dist;
+uniform float taper_r_dist;
+uniform float taper_l_strength;
+uniform float taper_r_strength;
+
+
+#define M_PI 3.1415926535897932384626433832795
+
+vec4 MakeLeftTaperLinear(vec4 L, vec4 a, float offset){
+	if (offset >= taper_l_dist) return a;
+	a = mix(mix(a, L, taper_l_strength), a, offset / taper_l_dist);
+	return a;
+}
+
+vec4 MakeRightTaperLinear(vec4 R, vec4 c, float offset){
+	if (offset >= taper_r_dist) return c;
+	c = mix(mix(c, R, taper_r_strength), c, offset / taper_r_dist);
+	return c;
+}
+
+void main() {
+
+	float LAngle, RAngle;
+
+	vec4 LL = gl_in[0].gl_Position,
+	     L  = gl_in[1].gl_Position,
+	     R  = gl_in[2].gl_Position,
+	     RR = gl_in[3].gl_Position;
+
+	float OffsetL = gOffset[1].x;
+	float OffsetR = gOffset[2].x;
+	float OffsetL2 = gOffset[1].y;
+	float OffsetR2 = gOffset[2].y;
+
+	if (L == R || L == LL || R == RR || LL == RR || L == RR || R == LL) return;
+
+	vec4 a;
+	vec4 b;
+	vec4 c;
+	vec4 d;
+	vec4 Line = R - L;
+	vec4 Normal = normalize(vec4(-Line.y, Line.x, 0, 0));
+
+	a = L - line_width * Normal * 0.001;
+	b = L + line_width * Normal * 0.001;
+	c = R - line_width * Normal * 0.001;
+	d = R + line_width * Normal * 0.001;
+
+	float lim = line_width * 0.002;
+
+	{
+		vec4 Tangent = normalize(normalize(L - LL) + normalize(R - L));
+		vec4 Minter = normalize(vec4(-Tangent.y, Tangent.x, 0, 0));
+		float length = line_width / (dot(Minter, Normal)) * 0.001;
+		a = L - length * Minter;
+		b = L + length * Minter;
+		if (distance(a, b) > 2 * lim) { a =  L - lim * Minter; b = L + lim * Minter;}
+	}
+
+	{
+		vec4 Tangent = normalize(normalize(RR - R) + normalize(R - L));
+		vec4 Minter = normalize(vec4(-Tangent.y, Tangent.x, 0, 0));
+		float length = line_width / (dot(Minter, Normal)) * 0.001;
+		c = R - length * Minter;
+		d = R + length * Minter;
+		if (distance(c, d) > 2 * lim) { c =  R - lim * Minter; d = R + lim * Minter;}
+	}
+
+	a = MakeLeftTaperLinear(L, a, OffsetL);
+	b = MakeLeftTaperLinear(L, b, OffsetL);
+	c = MakeLeftTaperLinear(R, c, OffsetR);
+	d = MakeLeftTaperLinear(R, d, OffsetR);
+
+	a = MakeRightTaperLinear(L, a, OffsetL2);
+	b = MakeRightTaperLinear(L, b, OffsetL2);
+	c = MakeRightTaperLinear(R, c, OffsetR2);
+	d = MakeRightTaperLinear(R, d, OffsetR2);
+
+	a.w = 1;
+	b.w = 1;
+	c.w = 1;
+	d.w = 1;
+
+	gl_Position = a;
+	EmitVertex();
+	gl_Position = b;
+	EmitVertex();
+	gl_Position = c;
+	EmitVertex();
+	EndPrimitive();
+
+	gl_Position = c;
+	EmitVertex();
+	gl_Position = d;
+	EmitVertex();
+	gl_Position = b;
+	EmitVertex();
+	EndPrimitive();
+}

source/blender/draw/engines/lanpr/shaders/lanpr_snake_line_connection_vert.glsl

@@ -0,0 +1,9 @@
+in vec2 pos;
+in vec2 uvs;
+
+out vec2 gOffset;
+
+void main(){
+	gl_Position = vec4(pos, 0.0, 1.0);
+	gOffset = uvs;
+};

source/blender/draw/engines/lanpr/shaders/lanpr_snake_multichannel_frag.glsl

@@ -0,0 +1,17 @@
+in vec3 normal;
+in vec4 finalColor;
+
+float Interpolate(float between1, float between2, float value1, float value2, float key){
+	float i = (key - between1) / (between2 - between1);
+	return value1 * (1 - i) + value2 * i;
+}
+
+void main(){
+	float value = dot(vec3(0, 0, 1), normal);
+	//if(value<0.65) value=0.15;
+	//else if(value>=0.65 && value<0.85) value=Interpolate(0.65,0.85,0.15,0.75,value);
+	//else if(value>=0.85 && value<0.95) value=0.75;
+	//else if(value>=0.95) value=0.9;
+	gl_FragData[0] = vec4(finalColor.rgb * value, 1);
+	gl_FragData[1] = vec4(normal, 1);//vec4((normal+vec3(1))*0.5,1);
+}

source/blender/draw/engines/lanpr/shaders/lanpr_software_chain_geom.glsl

@@ -0,0 +1,219 @@
+layout(lines_adjacency) in;
+layout(triangle_strip, max_vertices = 6) out;
+
+in vec2 gOffset[];
+in int gType[];
+in int gLevel[];
+
+in vec3 gNormal[];
+uniform int normal_mode;
+uniform int normal_effect_inverse;
+uniform vec3 normal_direction; // also used as point position
+uniform float normal_ramp_begin;
+uniform float normal_ramp_end;
+uniform float normal_thickness_begin;
+uniform float normal_thickness_end;
+
+uniform float thickness;
+uniform float thickness_crease;
+uniform float thickness_material;
+uniform float thickness_edge_mark;
+uniform float thickness_intersection;
+
+uniform int enable_contour;
+uniform int enable_crease;
+uniform int enable_material;
+uniform int enable_edge_mark;
+uniform int enable_intersection;
+
+uniform int occlusion_level_begin;
+uniform int occlusion_level_end;
+
+// implement these later.
+//uniform float depth_width_influence;
+//uniform float depth_width_curve;
+//uniform float depth_alpha_influence;
+//uniform float depth_alpha_curve;
+//uniform float zNear;
+//uniform float zFar;
+
+uniform vec4 color;
+uniform vec4 crease_color;
+uniform vec4 material_color;
+uniform vec4 edge_mark_color;
+uniform vec4 intersection_color;
+
+uniform float taper_l_dist;
+uniform float taper_r_dist;
+uniform float taper_l_strength;
+uniform float taper_r_strength;
+
+// for line width correction
+uniform vec4 output_viewport;
+uniform vec4 preview_viewport;
+
+out vec4 out_color;
+
+float use_thickness;
+
+#define M_PI 3.1415926535897932384626433832795
+
+vec4 END_POINT = vec4(vec2(3e30f), 0, 1);// end point flag
+
+vec4 MakeLeftTaperLinear(vec4 L, vec4 a, float offset){
+	if (offset >= taper_l_dist) return a;
+	a = mix(mix(a, L, taper_l_strength), a, offset / taper_l_dist);
+	return a;
+}
+
+vec4 MakeRightTaperLinear(vec4 R, vec4 c, float offset){
+	if (offset >= taper_r_dist) return c;
+	c = mix(mix(c, R, taper_r_strength), c, offset / taper_r_dist);
+	return c;
+}
+
+void draw_line(vec4 LL, vec4 L, vec4 R, vec4 RR){
+
+	float LAngle, RAngle;
+
+
+	float OffsetL = gOffset[1].x;
+	float OffsetR = gOffset[2].x;
+	float OffsetL2 = gOffset[1].y;
+	float OffsetR2 = gOffset[2].y;
+
+
+
+	if (L == R) return;
+
+	vec4 a;
+	vec4 b;
+	vec4 c;
+	vec4 d;
+	vec4 Line = R - L;
+	vec4 Normal = normalize(vec4(-Line.y, Line.x, 0, 0));
+
+	a = L - use_thickness * Normal * 0.001;
+	b = L + use_thickness * Normal * 0.001;
+	c = R - use_thickness * Normal * 0.001;
+	d = R + use_thickness * Normal * 0.001;
+
+	float lim = use_thickness * 0.002;
+
+	float x_scale = preview_viewport.w / preview_viewport.z;
+
+	if (LL.x < 3e20) {
+		vec4 avg = normalize(L - LL) + normalize(R - L);
+		if (length(avg) > 0.001) {
+			vec4 Tangent = normalize(avg);
+			vec4 Minter = normalize(vec4(-Tangent.y, Tangent.x, 0, 0));
+			float length = use_thickness / (dot(Minter, Normal)) * 0.001;
+			if (length < 4 * lim) {
+				Minter.x *= x_scale;
+				a = L - length * Minter;
+				b = L + length * Minter;
+			}
+		}
+	}
+
+	if (RR.x < 3e20) {
+		vec4 avg = normalize(RR - R) + normalize(R - L);
+		if (length(avg) > 0.001) {
+			vec4 Tangent = normalize(avg);
+			vec4 Minter = normalize(vec4(-Tangent.y, Tangent.x, 0, 0));
+			float length = use_thickness / (dot(Minter, Normal)) * 0.001;
+			if (length < 4 * lim) {
+				Minter.x *= x_scale;
+				c = R - length * Minter;
+				d = R + length * Minter;
+			}
+		}
+	}
+
+	a = MakeLeftTaperLinear(L, a, OffsetL);
+	b = MakeLeftTaperLinear(L, b, OffsetL);
+	c = MakeLeftTaperLinear(R, c, OffsetR);
+	d = MakeLeftTaperLinear(R, d, OffsetR);
+
+	a = MakeRightTaperLinear(L, a, OffsetL2);
+	b = MakeRightTaperLinear(L, b, OffsetL2);
+	c = MakeRightTaperLinear(R, c, OffsetR2);
+	d = MakeRightTaperLinear(R, d, OffsetR2);
+
+	a.w = 1;
+	b.w = 1;
+	c.w = 1;
+	d.w = 1;	
+
+	gl_Position = a;
+	EmitVertex();
+	gl_Position = b;
+	EmitVertex();
+	gl_Position = c;
+	EmitVertex();
+	EndPrimitive();
+
+	gl_Position = c;
+	EmitVertex();
+	gl_Position = d;
+	EmitVertex();
+	gl_Position = b;
+	EmitVertex();
+	EndPrimitive();
+}
+
+float factor_to_thickness(float factor){
+	float r = (factor - normal_ramp_begin)/(normal_ramp_end - normal_ramp_begin);
+	if(r>1) r=1;
+	if(r<0) r=0;
+	float thickness = normal_effect_inverse==1 ?
+					  mix(normal_thickness_begin,normal_thickness_end,r) :
+					  mix(normal_thickness_end,normal_thickness_begin,r);
+	return thickness;
+}
+
+void decide_line_style(int component_id){
+	float th=thickness;
+	if(normal_mode == 0){
+		th=thickness;
+	}else if(normal_mode == 1){
+		float factor = dot(gNormal[0],normal_direction);
+		th = factor_to_thickness(factor);
+	}else if(normal_mode == 2){
+		float factor = dot(gNormal[0],normal_direction);
+		th = factor_to_thickness(factor);
+	}
+
+	if (component_id == 0) { out_color = color;              use_thickness = th * enable_contour;                               return; }
+	if (component_id == 1) { out_color = crease_color;       use_thickness = th * thickness_crease * enable_crease;             return; }
+	if (component_id == 2) { out_color = material_color;     use_thickness = th * thickness_material * enable_material;         return; }
+	if (component_id == 3) { out_color = edge_mark_color;    use_thickness = th * thickness_edge_mark * enable_edge_mark;       return; }
+	if (component_id == 4) { out_color = intersection_color; use_thickness = th * thickness_intersection * enable_intersection; return; }
+}
+
+void main() {
+	int level = gLevel[1];
+
+	if (occlusion_level_begin > level || occlusion_level_end < level) return;
+
+	float asp1 = output_viewport.z / output_viewport.w;
+	float asp2 = preview_viewport.z / preview_viewport.w;
+	float x_scale = asp1 / asp2;
+	
+	vec4 LL = vec4(gl_in[0].gl_Position.xy, 0, 1),
+	     L  = vec4(gl_in[1].gl_Position.xy, 0, 1),
+	     R  = vec4(gl_in[2].gl_Position.xy, 0, 1),
+	     RR = vec4(gl_in[3].gl_Position.xy, 0, 1);
+	
+	LL.x *= x_scale;
+	L.x  *= x_scale;
+	R.x  *= x_scale;
+	RR.x *= x_scale;
+
+	int type = gType[1];
+
+	decide_line_style(type);
+
+	draw_line(LL, L, R, RR);
+}
+

source/blender/draw/engines/lanpr/shaders/lanpr_software_line_chain_geom.glsl

@@ -0,0 +1,112 @@
+layout(lines) in;
+layout(triangle_strip, max_vertices = 6) out;
+
+in vec3 gNormal[];
+uniform int normal_mode;
+uniform int normal_effect_inverse;
+uniform vec3 normal_direction; // also used as point position
+uniform float normal_ramp_begin;
+uniform float normal_ramp_end;
+uniform float normal_thickness_begin;
+uniform float normal_thickness_end;
+
+uniform float thickness;
+uniform float thickness_crease;
+uniform float thickness_material;
+uniform float thickness_edge_mark;
+uniform float thickness_intersection;
+
+// implement these later.
+//uniform float depth_width_influence;
+//uniform float depth_width_curve;
+//uniform float depth_alpha_influence;
+//uniform float depth_alpha_curve;
+//uniform float zNear;
+//uniform float zFar;
+
+uniform vec4 color;
+uniform vec4 crease_color;
+uniform vec4 material_color;
+uniform vec4 edge_mark_color;
+uniform vec4 intersection_color;
+
+// for line width correction
+uniform vec4 output_viewport;
+uniform vec4 preview_viewport;
+
+out vec4 out_color;
+
+float use_thickness;
+
+void draw_line(vec4 p1, vec4 p2){
+
+	vec4 Line = p2 - p1;
+	vec4 Normal = normalize(vec4(-Line.y, Line.x, 0, 0));
+
+	vec4 a, b, c, d;
+
+	float x_scale = preview_viewport.w / preview_viewport.z;
+	Normal.x *= x_scale;
+	vec4 offset = Normal * use_thickness * 0.001;
+
+	a = p1 + offset;
+	b = p1 - offset;
+	c = p2 + offset;
+	d = p2 - offset;
+
+	gl_Position = vec4(a.xy, 0, 1); EmitVertex();
+	gl_Position = vec4(b.xy, 0, 1); EmitVertex();
+	gl_Position = vec4(c.xy, 0, 1); EmitVertex();
+
+	gl_Position = vec4(b.xy, 0, 1); EmitVertex();
+	gl_Position = vec4(c.xy, 0, 1); EmitVertex();
+	gl_Position = vec4(d.xy, 0, 1); EmitVertex();
+
+	EndPrimitive();
+}
+
+float factor_to_thickness(float factor){
+	float r = (factor - normal_ramp_begin)/(normal_ramp_end - normal_ramp_begin);
+	if(r>1) r=1;
+	if(r<0) r=0;
+	float thickness = normal_effect_inverse==1 ?
+					  mix(normal_thickness_begin,normal_thickness_end,r) :
+					  mix(normal_thickness_end,normal_thickness_begin,r);
+	return thickness;
+}
+
+void decide_color_and_thickness(float component_id){
+	float th=thickness;
+	if(normal_mode == 0){
+		th=thickness;
+	}else if(normal_mode == 1){
+		float factor = dot(gNormal[0],normal_direction);
+		th = factor_to_thickness(factor);
+	}else if(normal_mode == 2){
+		float factor = dot(gNormal[0],normal_direction);
+		th = factor_to_thickness(factor);
+	}
+
+	if (component_id < 1.5) { out_color = color;              use_thickness = th;                          return; }
+	if (component_id < 2.5) { out_color = crease_color;       use_thickness = th * thickness_crease;       return; }
+	if (component_id < 3.5) { out_color = material_color;     use_thickness = th * thickness_material;     return; }
+	if (component_id < 4.5) { out_color = edge_mark_color;    use_thickness = th * thickness_edge_mark;    return; }
+	if (component_id < 5.5) { out_color = intersection_color; use_thickness = th * thickness_intersection; return; }
+}
+
+void main() {
+
+	float asp1 = output_viewport.z / output_viewport.w;
+	float asp2 = preview_viewport.z / preview_viewport.w;
+	float x_scale = asp1 / asp2;
+
+	vec4 p1 = vec4(gl_in[0].gl_Position.xy, 0, 1);
+	vec4 p2 = vec4(gl_in[1].gl_Position.xy, 0, 1);
+
+	p1.x *= x_scale;
+	p2.x *= x_scale;
+
+	decide_color_and_thickness(gl_in[0].gl_Position.z);
+
+	draw_line(p1, p2);
+}

source/blender/draw/engines/lanpr/shaders/lanpr_software_passthrough_vert.glsl

@@ -0,0 +1,27 @@
+in vec4 pos;
+in vec2 uvs;
+in vec3 normal;
+in int type;
+in int level;
+
+uniform vec4 output_viewport;
+uniform vec4 preview_viewport;
+
+out vec2 gOffset;
+out int gType;
+out int gLevel;
+out vec3 gNormal;
+
+void main(){
+	vec4 p = pos;
+	// move to geo shader
+	//float asp1 = output_viewport.z / output_viewport.w;
+	//float asp2 = preview_viewport.z / preview_viewport.w;
+	//p.x = pos.x / asp2 * asp1;
+
+	gOffset = uvs;
+	gType = type;
+	gLevel = level;
+	gNormal = normal;
+	gl_Position = vec4(vec3(p), 1);
+}

source/blender/draw/intern/DRW_render.h

@@ -228,6 +228,11 @@ void DRW_texture_ensure_fullscreen_2d(struct GPUTexture **tex,
 void DRW_texture_ensure_2d(
     struct GPUTexture **tex, int w, int h, eGPUTextureFormat format, DRWTextureFlag flags);
 
+void DRW_texture_ensure_fullscreen_2D_multisample(
+        struct GPUTexture **tex, eGPUTextureFormat format, int samples, DRWTextureFlag flags);
+void DRW_texture_ensure_2D_multisample(
+        struct GPUTexture **tex, int w, int h, eGPUTextureFormat format, int samples, DRWTextureFlag flags);
+
 void DRW_texture_generate_mipmaps(struct GPUTexture *tex);
 void DRW_texture_free(struct GPUTexture *tex);
 #define DRW_TEXTURE_FREE_SAFE(tex) \

source/blender/draw/intern/draw_manager.c

@@ -87,6 +87,7 @@
 #include "engines/basic/basic_engine.h"
 #include "engines/workbench/workbench_engine.h"
 #include "engines/external/external_engine.h"
+#include "engines/lanpr/lanpr_all.h"
 
 #include "GPU_context.h"
 
@@ -3078,8 +3079,9 @@ void DRW_engine_register(DrawEngineType *draw_engine_type)
 
 void DRW_engines_register(void)
 {
-  RE_engines_register(&DRW_engine_viewport_eevee_type);
-  RE_engines_register(&DRW_engine_viewport_workbench_type);
+	RE_engines_register(&DRW_engine_viewport_eevee_type);
+	RE_engines_register(&DRW_engine_viewport_workbench_type);
+	RE_engines_register(&DRW_engine_viewport_lanpr_type);
 
   DRW_engine_register(&draw_engine_workbench_solid);
   DRW_engine_register(&draw_engine_workbench_transparent);

source/blender/draw/intern/draw_manager_texture.c

@@ -102,6 +102,14 @@ GPUTexture *DRW_texture_create_2d_array(
   return tex;
 }
 
+GPUTexture *DRW_texture_create_2d_multisample(int w, int h, eGPUTextureFormat format, int samples, DRWTextureFlag flags, const float *fpixels)
+{
+	GPUTexture *tex = GPU_texture_create_2d_multisample(w, h, format, fpixels, samples, NULL);
+	drw_texture_set_parameters(tex, flags);
+
+	return tex;
+}
+
 GPUTexture *DRW_texture_create_3d(
     int w, int h, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels)
 {
@@ -151,6 +159,21 @@ void DRW_texture_ensure_2d(
   }
 }
 
+void DRW_texture_ensure_fullscreen_2D_multisample(GPUTexture **tex, eGPUTextureFormat format, int samples, DRWTextureFlag flags)
+{
+	if (*(tex) == NULL) {
+		const float *size = DRW_viewport_size_get();
+		*(tex) = DRW_texture_create_2d_multisample((int)size[0], (int)size[1], format, samples, flags, NULL);
+	}
+}
+
+void DRW_texture_ensure_2D_multisample(GPUTexture **tex, int w, int h, eGPUTextureFormat format, int samples, DRWTextureFlag flags)
+{
+	if (*(tex) == NULL) {
+		*(tex) = DRW_texture_create_2d_multisample(w, h, format, samples, flags, NULL);
+	}
+}
+
 void DRW_texture_generate_mipmaps(GPUTexture *tex)
 {
   GPU_texture_bind(tex, 0);

source/blender/draw/modes/object_mode.c

@@ -3612,6 +3612,9 @@ static void OBJECT_draw_scene(void *vedata)
 
 static const DrawEngineDataSize OBJECT_data_size = DRW_VIEWPORT_DATA_SIZE(OBJECT_Data);
 
+struct LANPR_Data;
+void lanpr_id_update(struct LANPR_Data *vedata, ID *id);
+
 DrawEngineType draw_engine_object_type = {
     NULL,
     NULL,

source/blender/editors/mesh/editmesh_tools.c

@@ -7412,7 +7412,8 @@ void MESH_OT_symmetry_snap(struct wmOperatorType *ot)
 
 /** \} */
 
-#ifdef WITH_FREESTYLE
+/* preserve the edge marking capability */
+//#ifdef WITH_FREESTYLE
 
 /* -------------------------------------------------------------------- */
 /** \name Mark Edge (FreeStyle) Operator
@@ -7572,7 +7573,7 @@ void MESH_OT_mark_freestyle_face(wmOperatorType *ot)
 
 /** \} */
 
-#endif /* WITH_FREESTYLE */
+//#endif  /* WITH_FREESTYLE */
 
 /********************** Loop normals editing tools modal map. **********************/
 

source/blender/editors/mesh/mesh_intern.h

@@ -246,10 +246,10 @@ void MESH_OT_mod_weighted_strength(struct wmOperatorType *ot);
 
 struct wmKeyMap *point_normals_modal_keymap(wmKeyConfig *keyconf);
 
-#ifdef WITH_FREESTYLE
+//#ifdef WITH_FREESTYLE
 void MESH_OT_mark_freestyle_edge(struct wmOperatorType *ot);
 void MESH_OT_mark_freestyle_face(struct wmOperatorType *ot);
-#endif
+//#endif
 
 /* *** mesh_data.c *** */
 void MESH_OT_uv_texture_add(struct wmOperatorType *ot);

source/blender/editors/mesh/mesh_ops.c

@@ -40,149 +40,149 @@
 
 void ED_operatortypes_mesh(void)
 {
-  WM_operatortype_append(MESH_OT_select_all);
-  WM_operatortype_append(MESH_OT_select_interior_faces);
-  WM_operatortype_append(MESH_OT_select_more);
-  WM_operatortype_append(MESH_OT_select_less);
-  WM_operatortype_append(MESH_OT_select_non_manifold);
-  WM_operatortype_append(MESH_OT_select_linked);
-  WM_operatortype_append(MESH_OT_select_linked_pick);
-  WM_operatortype_append(MESH_OT_select_random);
-  WM_operatortype_append(MESH_OT_select_ungrouped);
-  WM_operatortype_append(MESH_OT_hide);
-  WM_operatortype_append(MESH_OT_reveal);
-  WM_operatortype_append(MESH_OT_select_face_by_sides);
-  WM_operatortype_append(MESH_OT_select_loose);
-  WM_operatortype_append(MESH_OT_select_mirror);
-  WM_operatortype_append(MESH_OT_normals_make_consistent);
-  WM_operatortype_append(MESH_OT_merge);
-  WM_operatortype_append(MESH_OT_subdivide);
-  WM_operatortype_append(MESH_OT_subdivide_edgering);
-  WM_operatortype_append(MESH_OT_unsubdivide);
-  WM_operatortype_append(MESH_OT_faces_select_linked_flat);
-  WM_operatortype_append(MESH_OT_edges_select_sharp);
-  WM_operatortype_append(MESH_OT_primitive_plane_add);
-  WM_operatortype_append(MESH_OT_primitive_cube_add);
-  WM_operatortype_append(MESH_OT_primitive_circle_add);
-  WM_operatortype_append(MESH_OT_primitive_cylinder_add);
-  WM_operatortype_append(MESH_OT_primitive_cone_add);
-  WM_operatortype_append(MESH_OT_primitive_grid_add);
-  WM_operatortype_append(MESH_OT_primitive_monkey_add);
-  WM_operatortype_append(MESH_OT_primitive_uv_sphere_add);
-  WM_operatortype_append(MESH_OT_primitive_ico_sphere_add);
+	WM_operatortype_append(MESH_OT_select_all);
+	WM_operatortype_append(MESH_OT_select_interior_faces);
+	WM_operatortype_append(MESH_OT_select_more);
+	WM_operatortype_append(MESH_OT_select_less);
+	WM_operatortype_append(MESH_OT_select_non_manifold);
+	WM_operatortype_append(MESH_OT_select_linked);
+	WM_operatortype_append(MESH_OT_select_linked_pick);
+	WM_operatortype_append(MESH_OT_select_random);
+	WM_operatortype_append(MESH_OT_select_ungrouped);
+	WM_operatortype_append(MESH_OT_hide);
+	WM_operatortype_append(MESH_OT_reveal);
+	WM_operatortype_append(MESH_OT_select_face_by_sides);
+	WM_operatortype_append(MESH_OT_select_loose);
+	WM_operatortype_append(MESH_OT_select_mirror);
+	WM_operatortype_append(MESH_OT_normals_make_consistent);
+	WM_operatortype_append(MESH_OT_merge);
+	WM_operatortype_append(MESH_OT_subdivide);
+	WM_operatortype_append(MESH_OT_subdivide_edgering);
+	WM_operatortype_append(MESH_OT_unsubdivide);
+	WM_operatortype_append(MESH_OT_faces_select_linked_flat);
+	WM_operatortype_append(MESH_OT_edges_select_sharp);
+	WM_operatortype_append(MESH_OT_primitive_plane_add);
+	WM_operatortype_append(MESH_OT_primitive_cube_add);
+	WM_operatortype_append(MESH_OT_primitive_circle_add);
+	WM_operatortype_append(MESH_OT_primitive_cylinder_add);
+	WM_operatortype_append(MESH_OT_primitive_cone_add);
+	WM_operatortype_append(MESH_OT_primitive_grid_add);
+	WM_operatortype_append(MESH_OT_primitive_monkey_add);
+	WM_operatortype_append(MESH_OT_primitive_uv_sphere_add);
+	WM_operatortype_append(MESH_OT_primitive_ico_sphere_add);
 
-  WM_operatortype_append(MESH_OT_primitive_cube_add_gizmo);
+	WM_operatortype_append(MESH_OT_primitive_cube_add_gizmo);
 
-  WM_operatortype_append(MESH_OT_duplicate);
-  WM_operatortype_append(MESH_OT_remove_doubles);
-  WM_operatortype_append(MESH_OT_spin);
-  WM_operatortype_append(MESH_OT_screw);
+	WM_operatortype_append(MESH_OT_duplicate);
+	WM_operatortype_append(MESH_OT_remove_doubles);
+	WM_operatortype_append(MESH_OT_spin);
+	WM_operatortype_append(MESH_OT_screw);
 
-  WM_operatortype_append(MESH_OT_extrude_region);
-  WM_operatortype_append(MESH_OT_extrude_context);
-  WM_operatortype_append(MESH_OT_extrude_faces_indiv);
-  WM_operatortype_append(MESH_OT_extrude_edges_indiv);
-  WM_operatortype_append(MESH_OT_extrude_verts_indiv);
+	WM_operatortype_append(MESH_OT_extrude_region);
+	WM_operatortype_append(MESH_OT_extrude_context);
+	WM_operatortype_append(MESH_OT_extrude_faces_indiv);
+	WM_operatortype_append(MESH_OT_extrude_edges_indiv);
+	WM_operatortype_append(MESH_OT_extrude_verts_indiv);
 
-  WM_operatortype_append(MESH_OT_split);
-  WM_operatortype_append(MESH_OT_extrude_repeat);
-  WM_operatortype_append(MESH_OT_edge_rotate);
-  WM_operatortype_append(MESH_OT_shortest_path_select);
-  WM_operatortype_append(MESH_OT_loop_to_region);
-  WM_operatortype_append(MESH_OT_region_to_loop);
-  WM_operatortype_append(MESH_OT_select_axis);
+	WM_operatortype_append(MESH_OT_split);
+	WM_operatortype_append(MESH_OT_extrude_repeat);
+	WM_operatortype_append(MESH_OT_edge_rotate);
+	WM_operatortype_append(MESH_OT_shortest_path_select);
+	WM_operatortype_append(MESH_OT_loop_to_region);
+	WM_operatortype_append(MESH_OT_region_to_loop);
+	WM_operatortype_append(MESH_OT_select_axis);
 
-  WM_operatortype_append(MESH_OT_uvs_rotate);
-  WM_operatortype_append(MESH_OT_uvs_reverse);
-  WM_operatortype_append(MESH_OT_colors_rotate);
-  WM_operatortype_append(MESH_OT_colors_reverse);
+	WM_operatortype_append(MESH_OT_uvs_rotate);
+	WM_operatortype_append(MESH_OT_uvs_reverse);
+	WM_operatortype_append(MESH_OT_colors_rotate);
+	WM_operatortype_append(MESH_OT_colors_reverse);
 
-  WM_operatortype_append(MESH_OT_fill);
-  WM_operatortype_append(MESH_OT_fill_grid);
-  WM_operatortype_append(MESH_OT_fill_holes);
-  WM_operatortype_append(MESH_OT_beautify_fill);
-  WM_operatortype_append(MESH_OT_quads_convert_to_tris);
-  WM_operatortype_append(MESH_OT_tris_convert_to_quads);
-  WM_operatortype_append(MESH_OT_decimate);
-  WM_operatortype_append(MESH_OT_dissolve_verts);
-  WM_operatortype_append(MESH_OT_dissolve_edges);
-  WM_operatortype_append(MESH_OT_dissolve_faces);
-  WM_operatortype_append(MESH_OT_dissolve_mode);
-  WM_operatortype_append(MESH_OT_dissolve_limited);
-  WM_operatortype_append(MESH_OT_dissolve_degenerate);
-  WM_operatortype_append(MESH_OT_delete_edgeloop);
-  WM_operatortype_append(MESH_OT_faces_shade_smooth);
-  WM_operatortype_append(MESH_OT_faces_shade_flat);
-  WM_operatortype_append(MESH_OT_sort_elements);
-#ifdef WITH_FREESTYLE
-  WM_operatortype_append(MESH_OT_mark_freestyle_face);
-#endif
+	WM_operatortype_append(MESH_OT_fill);
+	WM_operatortype_append(MESH_OT_fill_grid);
+	WM_operatortype_append(MESH_OT_fill_holes);
+	WM_operatortype_append(MESH_OT_beautify_fill);
+	WM_operatortype_append(MESH_OT_quads_convert_to_tris);
+	WM_operatortype_append(MESH_OT_tris_convert_to_quads);
+	WM_operatortype_append(MESH_OT_decimate);
+	WM_operatortype_append(MESH_OT_dissolve_verts);
+	WM_operatortype_append(MESH_OT_dissolve_edges);
+	WM_operatortype_append(MESH_OT_dissolve_faces);
+	WM_operatortype_append(MESH_OT_dissolve_mode);
+	WM_operatortype_append(MESH_OT_dissolve_limited);
+	WM_operatortype_append(MESH_OT_dissolve_degenerate);
+	WM_operatortype_append(MESH_OT_delete_edgeloop);
+	WM_operatortype_append(MESH_OT_faces_shade_smooth);
+	WM_operatortype_append(MESH_OT_faces_shade_flat);
+	WM_operatortype_append(MESH_OT_sort_elements);
+//#ifdef WITH_FREESTYLE
+	WM_operatortype_append(MESH_OT_mark_freestyle_face);
+//#endif
 
-  WM_operatortype_append(MESH_OT_delete);
-  WM_operatortype_append(MESH_OT_delete_loose);
-  WM_operatortype_append(MESH_OT_edge_collapse);
+	WM_operatortype_append(MESH_OT_delete);
+	WM_operatortype_append(MESH_OT_delete_loose);
+	WM_operatortype_append(MESH_OT_edge_collapse);
 
-  WM_operatortype_append(MESH_OT_separate);
-  WM_operatortype_append(MESH_OT_dupli_extrude_cursor);
-  WM_operatortype_append(MESH_OT_loop_select);
-  WM_operatortype_append(MESH_OT_edge_face_add);
-  WM_operatortype_append(MESH_OT_shortest_path_pick);
-  WM_operatortype_append(MESH_OT_select_similar);
-  WM_operatortype_append(MESH_OT_select_similar_region);
-  WM_operatortype_append(MESH_OT_select_mode);
-  WM_operatortype_append(MESH_OT_loop_multi_select);
-  WM_operatortype_append(MESH_OT_mark_seam);
-  WM_operatortype_append(MESH_OT_mark_sharp);
-#ifdef WITH_FREESTYLE
-  WM_operatortype_append(MESH_OT_mark_freestyle_edge);
-#endif
-  WM_operatortype_append(MESH_OT_vertices_smooth);
-  WM_operatortype_append(MESH_OT_vertices_smooth_laplacian);
-  WM_operatortype_append(MESH_OT_flip_normals);
-  WM_operatortype_append(MESH_OT_rip);
-  WM_operatortype_append(MESH_OT_rip_edge);
-  WM_operatortype_append(MESH_OT_blend_from_shape);
-  WM_operatortype_append(MESH_OT_shape_propagate_to_all);
+	WM_operatortype_append(MESH_OT_separate);
+	WM_operatortype_append(MESH_OT_dupli_extrude_cursor);
+	WM_operatortype_append(MESH_OT_loop_select);
+	WM_operatortype_append(MESH_OT_edge_face_add);
+	WM_operatortype_append(MESH_OT_shortest_path_pick);
+	WM_operatortype_append(MESH_OT_select_similar);
+	WM_operatortype_append(MESH_OT_select_similar_region);
+	WM_operatortype_append(MESH_OT_select_mode);
+	WM_operatortype_append(MESH_OT_loop_multi_select);
+	WM_operatortype_append(MESH_OT_mark_seam);
+	WM_operatortype_append(MESH_OT_mark_sharp);
+//#ifdef WITH_FREESTYLE
+	WM_operatortype_append(MESH_OT_mark_freestyle_edge);
+//#endif
+	WM_operatortype_append(MESH_OT_vertices_smooth);
+	WM_operatortype_append(MESH_OT_vertices_smooth_laplacian);
+	WM_operatortype_append(MESH_OT_flip_normals);
+	WM_operatortype_append(MESH_OT_rip);
+	WM_operatortype_append(MESH_OT_rip_edge);
+	WM_operatortype_append(MESH_OT_blend_from_shape);
+	WM_operatortype_append(MESH_OT_shape_propagate_to_all);
 
-  /* editmesh_polybuild */
-  WM_operatortype_append(MESH_OT_polybuild_face_at_cursor);
-  WM_operatortype_append(MESH_OT_polybuild_split_at_cursor);
-  WM_operatortype_append(MESH_OT_polybuild_dissolve_at_cursor);
+	/* editmesh_polybuild */
+	WM_operatortype_append(MESH_OT_polybuild_face_at_cursor);
+	WM_operatortype_append(MESH_OT_polybuild_split_at_cursor);
+	WM_operatortype_append(MESH_OT_polybuild_dissolve_at_cursor);
 
-  WM_operatortype_append(MESH_OT_uv_texture_add);
-  WM_operatortype_append(MESH_OT_uv_texture_remove);
-  WM_operatortype_append(MESH_OT_vertex_color_add);
-  WM_operatortype_append(MESH_OT_vertex_color_remove);
-  WM_operatortype_append(MESH_OT_customdata_mask_clear);
-  WM_operatortype_append(MESH_OT_customdata_skin_add);
-  WM_operatortype_append(MESH_OT_customdata_skin_clear);
-  WM_operatortype_append(MESH_OT_customdata_custom_splitnormals_add);
-  WM_operatortype_append(MESH_OT_customdata_custom_splitnormals_clear);
+	WM_operatortype_append(MESH_OT_uv_texture_add);
+	WM_operatortype_append(MESH_OT_uv_texture_remove);
+	WM_operatortype_append(MESH_OT_vertex_color_add);
+	WM_operatortype_append(MESH_OT_vertex_color_remove);
+	WM_operatortype_append(MESH_OT_customdata_mask_clear);
+	WM_operatortype_append(MESH_OT_customdata_skin_add);
+	WM_operatortype_append(MESH_OT_customdata_skin_clear);
+	WM_operatortype_append(MESH_OT_customdata_custom_splitnormals_add);
+	WM_operatortype_append(MESH_OT_customdata_custom_splitnormals_clear);
 
-  WM_operatortype_append(MESH_OT_edgering_select);
-  WM_operatortype_append(MESH_OT_loopcut);
+	WM_operatortype_append(MESH_OT_edgering_select);
+	WM_operatortype_append(MESH_OT_loopcut);
 
-  WM_operatortype_append(MESH_OT_solidify);
-  WM_operatortype_append(MESH_OT_select_nth);
-  WM_operatortype_append(MESH_OT_vert_connect);
-  WM_operatortype_append(MESH_OT_vert_connect_path);
-  WM_operatortype_append(MESH_OT_vert_connect_concave);
-  WM_operatortype_append(MESH_OT_vert_connect_nonplanar);
-  WM_operatortype_append(MESH_OT_face_make_planar);
-  WM_operatortype_append(MESH_OT_knife_tool);
-  WM_operatortype_append(MESH_OT_knife_project);
+	WM_operatortype_append(MESH_OT_solidify);
+	WM_operatortype_append(MESH_OT_select_nth);
+	WM_operatortype_append(MESH_OT_vert_connect);
+	WM_operatortype_append(MESH_OT_vert_connect_path);
+	WM_operatortype_append(MESH_OT_vert_connect_concave);
+	WM_operatortype_append(MESH_OT_vert_connect_nonplanar);
+	WM_operatortype_append(MESH_OT_face_make_planar);
+	WM_operatortype_append(MESH_OT_knife_tool);
+	WM_operatortype_append(MESH_OT_knife_project);
 
-  WM_operatortype_append(MESH_OT_bevel);
+	WM_operatortype_append(MESH_OT_bevel);
 
-  WM_operatortype_append(MESH_OT_bridge_edge_loops);
-  WM_operatortype_append(MESH_OT_inset);
-  WM_operatortype_append(MESH_OT_offset_edge_loops);
-  WM_operatortype_append(MESH_OT_intersect);
-  WM_operatortype_append(MESH_OT_intersect_boolean);
-  WM_operatortype_append(MESH_OT_face_split_by_edges);
-  WM_operatortype_append(MESH_OT_poke);
-  WM_operatortype_append(MESH_OT_wireframe);
-  WM_operatortype_append(MESH_OT_edge_split);
+	WM_operatortype_append(MESH_OT_bridge_edge_loops);
+	WM_operatortype_append(MESH_OT_inset);
+	WM_operatortype_append(MESH_OT_offset_edge_loops);
+	WM_operatortype_append(MESH_OT_intersect);
+	WM_operatortype_append(MESH_OT_intersect_boolean);
+	WM_operatortype_append(MESH_OT_face_split_by_edges);
+	WM_operatortype_append(MESH_OT_poke);
+	WM_operatortype_append(MESH_OT_wireframe);
+	WM_operatortype_append(MESH_OT_edge_split);
 
 #ifdef WITH_BULLET
   WM_operatortype_append(MESH_OT_convex_hull);

source/blender/editors/render/render_intern.h

@@ -74,6 +74,18 @@ void SCENE_OT_freestyle_modifier_copy(struct wmOperatorType *ot);
 void SCENE_OT_freestyle_stroke_material_create(struct wmOperatorType *ot);
 #endif
 
+/* lanpr: lanpr_software_render.c */
+void SCENE_OT_lanpr_calculate_feature_lines(struct wmOperatorType* ot);
+void SCENE_OT_lanpr_add_line_layer(struct wmOperatorType* ot);
+void SCENE_OT_lanpr_delete_line_layer(struct wmOperatorType* ot);
+void SCENE_OT_lanpr_rebuild_all_commands(struct wmOperatorType *ot);
+void SCENE_OT_lanpr_auto_create_line_layer(struct wmOperatorType *ot);
+void SCENE_OT_lanpr_move_line_layer(struct wmOperatorType *ot);
+void SCENE_OT_lanpr_add_line_component(struct wmOperatorType *ot);
+void SCENE_OT_lanpr_delete_line_component(struct wmOperatorType *ot);
+void SCENE_OT_lanpr_enable_all_line_types(struct wmOperatorType *ot);
+
+
 void TEXTURE_OT_slot_copy(struct wmOperatorType *ot);
 void TEXTURE_OT_slot_paste(struct wmOperatorType *ot);
 void TEXTURE_OT_slot_move(struct wmOperatorType *ot);

source/blender/editors/render/render_ops.c

@@ -79,9 +79,21 @@ void ED_operatortypes_render(void)
   WM_operatortype_append(SCENE_OT_freestyle_stroke_material_create);
 #endif
 
-  WM_operatortype_append(TEXTURE_OT_slot_copy);
-  WM_operatortype_append(TEXTURE_OT_slot_paste);
-  WM_operatortype_append(TEXTURE_OT_slot_move);
+    /* lanpr:  */
+    WM_operatortype_append(SCENE_OT_lanpr_calculate_feature_lines);
+    WM_operatortype_append(SCENE_OT_lanpr_add_line_layer);
+    WM_operatortype_append(SCENE_OT_lanpr_delete_line_layer);
+	WM_operatortype_append(SCENE_OT_lanpr_rebuild_all_commands);
+	WM_operatortype_append(SCENE_OT_lanpr_auto_create_line_layer);
+	WM_operatortype_append(SCENE_OT_lanpr_move_line_layer);
+	WM_operatortype_append(SCENE_OT_lanpr_add_line_component);
+	WM_operatortype_append(SCENE_OT_lanpr_delete_line_component);
+	WM_operatortype_append(SCENE_OT_lanpr_enable_all_line_types);
+
+
+	WM_operatortype_append(TEXTURE_OT_slot_copy);
+	WM_operatortype_append(TEXTURE_OT_slot_paste);
+	WM_operatortype_append(TEXTURE_OT_slot_move);
 
   /* render_internal.c */
   WM_operatortype_append(RENDER_OT_view_show);

source/blender/editors/space_view3d/space_view3d.c

@@ -1040,6 +1040,7 @@ static void view3d_main_region_message_subscribe(const struct bContext *C,
   }
 
   WM_msg_subscribe_rna_anon_type(mbus, SceneEEVEE, &msg_sub_value_region_tag_redraw);
+  WM_msg_subscribe_rna_anon_type(mbus, SceneLANPR, &msg_sub_value_region_tag_redraw);
   WM_msg_subscribe_rna_anon_type(mbus, SceneDisplay, &msg_sub_value_region_tag_redraw);
   WM_msg_subscribe_rna_anon_type(mbus, ObjectDisplay, &msg_sub_value_region_tag_redraw);
 

source/blender/makesdna/DNA_lanpr_types.h

@@ -0,0 +1,136 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * 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) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef __DNA_LANPR_TYPES_H__
+#define __DNA_LANPR_TYPES_H__
+
+/** \file DNA_lanpr_types.h
+ *  \ingroup DNA
+ */
+
+#include "DNA_listBase.h"
+#include "DNA_ID.h"
+#include "DNA_collection_types.h"
+
+struct Object;
+struct Material;
+struct Collection;
+
+#define LANPR_MASTER_MODE_SOFTWARE     0
+#define LANPR_MASTER_MODE_DPIX         1
+#define LANPR_MASTER_MODE_SNAKE        2
+
+#define LANPR_POST_PROCESSING_DISABLED 0
+#define LANPR_POST_PROCESSING_ENABLED  1
+
+#define LANPR_USE_DIFFERENT_TAPER      0
+#define LANPR_USE_SAME_TAPER           1
+
+#define LANPR_DISABLE_TIP_EXTEND       0
+#define LANPR_ENABLE_TIP_EXTEND        1
+
+#define LANPR_NORMAL_DONT_CARE         0
+#define LANPR_NORMAL_DIRECTIONAL       1
+#define LANPR_NORMAL_POINT             2
+#define LANPR_NORMAL_2D                3
+
+#define LANPR_COMPONENT_MODE_ALL          0
+#define LANPR_COMPONENT_MODE_OBJECT       1
+#define LANPR_COMPONENT_MODE_MATERIAL     2
+#define LANPR_COMPONENT_MODE_COLLECTION   3
+//#define LANPR_COMPONENT_MODE_REST         4 // use _ALL
+
+#define LANPR_COMPONENT_INCLUSIVE         0
+#define LANPR_COMPONENT_EXCLUSIVE         1
+
+#define LANPR_COMPONENT_LOGIG_OR          0
+#define LANPR_COMPONENT_LOGIC_AND         1
+
+struct DRWShadingGroup;
+
+typedef struct LANPR_LineLayerComponent {
+	struct LANPR_LineLayerComponent *next, *prev;
+
+	struct Object     *object_select;
+	struct Material   *material_select;
+	struct Collection *collection_select;
+
+	int component_mode;
+	int what;
+
+}LANPR_LineLayerComponent;
+
+typedef struct LANPR_LineLayer {
+	struct LANPR_LineLayer *next, *prev;
+
+	int type;
+
+	int use_qi_range;
+
+	int qi_begin;
+	int qi_end;        /* these are for QI Range thing... just occlusion levels */
+
+	int enable_contour;
+	int enable_crease;
+	int enable_edge_mark;
+	int enable_material_seperate;
+	int enable_intersection;
+
+	float thickness;    /* default is for contour */
+	float thickness_crease;
+	float thickness_material;
+	float thickness_edge_mark;
+	float thickness_intersection;
+
+	float color[4];    /* default is for contour */
+	float crease_color[4];
+	float material_color[4];
+	float edge_mark_color[4];
+	float intersection_color[4];
+
+	int normal_mode;
+	int normal_effect_inverse;
+    float normal_ramp_begin;
+    float normal_ramp_end;
+    float normal_thickness_begin;
+    float normal_thickness_end;
+	struct Object *normal_control_object;
+
+	int logic_mode;      /* for component evaluation */
+
+	int a;
+
+	ListBase components;
+
+	// still need legacy mode
+	// should use runtime pointer
+	struct DRWShadingGroup *shgrp;
+	struct GPUBatch  *batch;
+
+}LANPR_LineLayer;
+
+#endif

source/blender/makesdna/DNA_modifier_types.h

@@ -88,6 +88,7 @@ typedef enum ModifierType {
   eModifierType_MeshSequenceCache = 52,
   eModifierType_SurfaceDeform = 53,
   eModifierType_WeightedNormal = 54,
+	eModifierType_MyBMesh           = 55,
   NUM_MODIFIER_TYPES,
 } ModifierType;
 
@@ -1763,6 +1764,15 @@ enum {
   MOD_WIREFRAME_CREASE = (1 << 5),
 };
 
+/* Modifier data stored in the blend file */
+typedef struct MyBMeshModifierData {
+	ModifierData modifier;
+	struct Object *camera_ob;
+	void *osd_eval;
+	int flag;  /* options stored here */
+	short _pad[2];
+} MyBMeshModifierData;
+
 typedef struct DataTransferModifierData {
   ModifierData modifier;
 
@@ -1944,6 +1954,17 @@ enum {
 };
 
 #define MOD_MESHSEQ_READ_ALL \
-  (MOD_MESHSEQ_READ_VERT | MOD_MESHSEQ_READ_POLY | MOD_MESHSEQ_READ_UV | MOD_MESHSEQ_READ_COLOR)
+	(MOD_MESHSEQ_READ_VERT | MOD_MESHSEQ_READ_POLY | MOD_MESHSEQ_READ_UV | MOD_MESHSEQ_READ_COLOR)
 
-#endif /* __DNA_MODIFIER_TYPES_H__ */
+enum {
+	MOD_MYBMESH_TRIANG = (1 << 0),
+	MOD_MYBMESH_FF_SPLIT = (1 << 1),
+	MOD_MYBMESH_CUSP_D = (1 << 2),
+	MOD_MYBMESH_CUSP_I = (1 << 3),
+	MOD_MYBMESH_FB_SPLIT = (1 << 4),
+	MOD_MYBMESH_RAD_I = (1 << 5),
+	MOD_MYBMESH_RAD_FLIP = (1 << 6),
+	MOD_MYBMESH_OPTI = (1 << 7),
+};
+
+#endif  /* __DNA_MODIFIER_TYPES_H__ */

source/blender/makesdna/DNA_scene_types.h

@@ -33,8 +33,8 @@
 extern "C" {
 #endif
 
-#include "DNA_color_types.h"      /* color management */
-#include "DNA_customdata_types.h" /* Scene's runtime cddata masks. */
+#include "DNA_color_types.h"  /* color management */
+#include "DNA_customdata_types.h"  /* Scene's runtime cddata masks. */
 #include "DNA_vec_types.h"
 #include "DNA_listBase.h"
 #include "DNA_ID.h"
@@ -395,8 +395,8 @@ typedef enum eStereo3dInterlaceType {
  * this is used for NodeImageFile and IMAGE_OT_save_as operator too.
  *
  * note: its a bit strange that even though this is an image format struct
- * the imtype can still be used to select video formats.
- * RNA ensures these enum's are only selectable for render output.
+ *  the imtype can still be used to select video formats.
+ *  RNA ensures these enum's are only selectable for render output.
  */
 typedef struct ImageFormatData {
   /**
@@ -1631,6 +1631,72 @@ typedef struct SceneEEVEE {
   float light_threshold;
 } SceneEEVEE;
 
+
+/* LANPR Global Config */
+
+struct LANPR_RenderBuffer;
+struct LANPR_LineLayer;
+
+typedef struct SceneLANPR {
+
+	int master_mode;
+
+	int enable_vector_trace;
+	int display_thinning_result;
+
+	//int SizeCompensate;
+
+	float depth_clamp;
+	float depth_strength;
+	float normal_clamp;
+	float normal_strength;
+
+	float line_thickness;
+
+	int use_same_taper;
+	float taper_left_distance;
+	float taper_left_strength;
+	float taper_right_distance;
+	float taper_right_strength;
+
+	int enable_tip_extend;
+	float extend_length;
+
+	int snake_sensitivity;
+
+	/* shared */
+
+	float contour_fade;          /* for dpix contour fading,reserved for future usage */
+	float crease_threshold;      /* 0-1 range for cosine angle */
+	float crease_fade_threshold; /* for dpix crease fading */
+
+	float line_color[4];
+	float background_color[4];
+
+	float depth_width_influence;
+	float depth_width_curve;
+	float depth_alpha_influence;
+	float depth_alpha_curve;
+
+	/* states (needs optimization) */
+
+	int reloaded;
+
+	/* offline render */
+
+	struct LANPR_RenderBuffer *render_buffer;      /* created when needed. for offline rendering */
+	ListBase line_layers;                    /* now here!!! */
+	struct LANPR_LineLayer    *active_layer;
+
+	int enable_intersections;
+	int enable_chaining;
+
+	/* composite utility */
+	int composite_render_animation;
+	int what;
+
+} SceneLANPR;
+
 /* *************************************************************** */
 /* Scene ID-Block */
 
@@ -1761,6 +1827,9 @@ typedef struct Scene {
 
   struct SceneDisplay display;
   struct SceneEEVEE eevee;
+
+	/* LANPR stuff */
+	struct SceneLANPR lanpr;
 } Scene;
 
 /* **************** RENDERDATA ********************* */

source/blender/makesdna/intern/makesdna.c

@@ -82,6 +82,7 @@ static const char *includefiles[] = {
     "DNA_mesh_types.h",
     "DNA_meshdata_types.h",
     "DNA_modifier_types.h",
+    "DNA_lanpr_types.h",
     "DNA_lattice_types.h",
     "DNA_object_types.h",
     "DNA_object_force_types.h",
@@ -1538,6 +1539,7 @@ int main(int argc, char **argv)
 #include "DNA_mesh_types.h"
 #include "DNA_meshdata_types.h"
 #include "DNA_modifier_types.h"
+#include "DNA_lanpr_types.h"
 #include "DNA_lattice_types.h"
 #include "DNA_object_types.h"
 #include "DNA_object_force_types.h"

source/blender/makesrna/RNA_access.h

@@ -431,6 +431,7 @@ extern StructRNA RNA_MovieTrackingTrack;
 extern StructRNA RNA_MulticamSequence;
 extern StructRNA RNA_MultiresModifier;
 extern StructRNA RNA_MusgraveTexture;
+extern StructRNA RNA_MyBMeshModifier;
 extern StructRNA RNA_NandController;
 extern StructRNA RNA_NearSensor;
 extern StructRNA RNA_NlaStrip;
@@ -522,6 +523,7 @@ extern StructRNA RNA_SPHFluidSettings;
 extern StructRNA RNA_Scene;
 extern StructRNA RNA_SceneDisplay;
 extern StructRNA RNA_SceneEEVEE;
+extern StructRNA RNA_SceneLANPR;
 extern StructRNA RNA_SceneObjects;
 extern StructRNA RNA_SceneRenderLayer;
 extern StructRNA RNA_SceneSequence;

source/blender/makesrna/intern/CMakeLists.txt

@@ -25,73 +25,74 @@ endif()
 
 # files rna_access.c rna_define.c makesrna.c intentionally excluded.
 set(DEFSRC
-  rna_ID.c
-  rna_action.c
-  rna_animation.c
-  rna_animviz.c
-  rna_armature.c
-  rna_boid.c
-  rna_brush.c
-  rna_cachefile.c
-  rna_camera.c
-  rna_cloth.c
-  rna_collection.c
-  rna_color.c
-  rna_constraint.c
-  rna_context.c
-  rna_curve.c
-  rna_depsgraph.c
-  rna_dynamicpaint.c
-  rna_fcurve.c
-  rna_fluidsim.c
-  rna_gpencil.c
-  rna_gpencil_modifier.c
-  rna_image.c
-  rna_key.c
-  rna_lattice.c
-  rna_layer.c
-  rna_light.c
-  rna_lightprobe.c
-  rna_linestyle.c
-  rna_main.c
-  rna_mask.c
-  rna_material.c
-  rna_mesh.c
-  rna_meta.c
-  rna_modifier.c
-  rna_movieclip.c
-  rna_nla.c
-  rna_nodetree.c
-  rna_object.c
-  rna_object_force.c
-  rna_packedfile.c
-  rna_palette.c
-  rna_particle.c
-  rna_pose.c
-  rna_render.c
-  rna_rigidbody.c
-  rna_rna.c
-  rna_scene.c
-  rna_screen.c
-  rna_sculpt_paint.c
-  rna_sequencer.c
-  rna_shader_fx.c
-  rna_smoke.c
-  rna_sound.c
-  rna_space.c
-  rna_speaker.c
-  rna_test.c
-  rna_text.c
-  rna_texture.c
-  rna_timeline.c
-  rna_tracking.c
-  rna_ui.c
-  rna_userdef.c
-  rna_vfont.c
-  rna_wm.c
-  rna_wm_gizmo.c
-  rna_workspace.c
-  rna_world.c
+	rna_ID.c
+	rna_action.c
+	rna_animation.c
+	rna_animviz.c
+	rna_armature.c
+	rna_boid.c
+	rna_brush.c
+	rna_cachefile.c
+	rna_camera.c
+	rna_cloth.c
+	rna_collection.c
+	rna_color.c
+	rna_constraint.c
+	rna_context.c
+	rna_curve.c
+	rna_depsgraph.c
+	rna_dynamicpaint.c
+	rna_fcurve.c
+	rna_fluidsim.c
+	rna_gpencil.c
+	rna_gpencil_modifier.c
+	rna_image.c
+	rna_key.c
+	rna_lattice.c
+	rna_layer.c
+	rna_light.c
+	rna_lightprobe.c
+	rna_linestyle.c
+	rna_lanpr.c
+	rna_main.c
+	rna_mask.c
+	rna_material.c
+	rna_mesh.c
+	rna_meta.c
+	rna_modifier.c
+	rna_movieclip.c
+	rna_nla.c
+	rna_nodetree.c
+	rna_object.c
+	rna_object_force.c
+	rna_packedfile.c
+	rna_palette.c
+	rna_particle.c
+	rna_pose.c
+	rna_render.c
+	rna_rigidbody.c
+	rna_rna.c
+	rna_scene.c
+	rna_screen.c
+	rna_sculpt_paint.c
+	rna_sequencer.c
+	rna_shader_fx.c
+	rna_smoke.c
+	rna_sound.c
+	rna_space.c
+	rna_speaker.c
+	rna_test.c
+	rna_text.c
+	rna_texture.c
+	rna_timeline.c
+	rna_tracking.c
+	rna_ui.c
+	rna_userdef.c
+	rna_vfont.c
+	rna_wm.c
+	rna_wm_gizmo.c
+	rna_workspace.c
+	rna_world.c
 )
 
 set(APISRC

source/blender/makesrna/intern/makesrna.c

@@ -4207,6 +4207,7 @@ static RNAProcessItem PROCESS_ITEMS[] = {
     {"rna_lattice.c", "rna_lattice_api.c", RNA_def_lattice},
     {"rna_layer.c", NULL, RNA_def_view_layer},
     {"rna_linestyle.c", NULL, RNA_def_linestyle},
+    {"rna_lanpr.c", NULL, RNA_def_lanpr},
     {"rna_main.c", "rna_main_api.c", RNA_def_main},
     {"rna_material.c", "rna_material_api.c", RNA_def_material},
     {"rna_mesh.c", "rna_mesh_api.c", RNA_def_mesh},

source/blender/makesrna/intern/rna_internal.h

@@ -153,6 +153,7 @@ void RNA_def_key(struct BlenderRNA *brna);
 void RNA_def_light(struct BlenderRNA *brna);
 void RNA_def_lattice(struct BlenderRNA *brna);
 void RNA_def_linestyle(struct BlenderRNA *brna);
+void RNA_def_lanpr(struct BlenderRNA *brna);
 void RNA_def_main(struct BlenderRNA *brna);
 void RNA_def_material(struct BlenderRNA *brna);
 void RNA_def_mesh(struct BlenderRNA *brna);

source/blender/makesrna/intern/rna_lanpr.c

@@ -0,0 +1,231 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * 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.
+ *
+ * Contributor(s): Blender Foundation (2008).
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/makesrna/intern/rna_lanpr.c
+ *  \ingroup RNA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "BLI_utildefines.h"
+#include "BLI_string_utils.h"
+
+#include "RNA_define.h"
+#include "RNA_enum_types.h"
+
+#include "rna_internal.h"
+
+#include "DNA_lanpr_types.h"
+#include "DNA_material_types.h"
+#include "DNA_texture_types.h"
+
+#include "WM_types.h"
+#include "WM_api.h"
+
+#ifdef RNA_RUNTIME
+
+
+
+#else
+
+void RNA_def_lanpr(BlenderRNA *brna){
+
+	StructRNA *srna;
+	PropertyRNA *prop;
+
+	/* line style layer */
+
+	static const EnumPropertyItem lanpr_line_component_modes[] = {
+		{0, "ALL", 0, "All", "Select All lines, lines are already selected are not affected"},
+		{1, "OBJECT", 0, "Object", "Display lines for selected object"},
+		{2, "MATERIAL", 0, "Material", "Display lines that touches specific material"},
+		{3, "COLLECTION", 0, "Collection", "Display lines in specific collections"},
+		{0, NULL, 0, NULL, NULL}
+	};
+
+	static const EnumPropertyItem rna_enum_lanpr_normal_mode[] = {
+		{LANPR_NORMAL_DONT_CARE, "DISABLED", 0, "Disabled", "Normal value does not affect line style"},
+		{LANPR_NORMAL_DIRECTIONAL, "DIRECTIONAL", 0, "Directional", "Use directional vector to control line width"},
+		{LANPR_NORMAL_POINT, "POINT", 0, "Point", "Use Point Light Style"},
+		{0, NULL, 0, NULL, NULL}
+	};
+
+	srna = RNA_def_struct(brna, "LANPR_LineLayerComponent", NULL);
+	RNA_def_struct_sdna(srna, "LANPR_LineLayerComponent");
+	RNA_def_struct_ui_text(srna, "Line Layer Component", "LANPR_LineLayerComponent");
+
+	prop = RNA_def_property(srna, "component_mode", PROP_ENUM, PROP_NONE);
+	RNA_def_property_enum_items(prop, lanpr_line_component_modes);
+	RNA_def_property_enum_default(prop, 0);
+	RNA_def_property_ui_text(prop, "Mode", "Limit the range of displayed lines");
+
+	prop = RNA_def_property(srna, "object_select", PROP_POINTER, PROP_NONE);
+	RNA_def_property_struct_type(prop, "Object");
+	RNA_def_property_flag(prop, PROP_EDITABLE);
+	RNA_def_property_ui_text(prop, "Object", "Display lines for selected object");
+
+	prop = RNA_def_property(srna, "material_select", PROP_POINTER, PROP_NONE);
+	RNA_def_property_struct_type(prop, "Material");
+	RNA_def_property_flag(prop, PROP_EDITABLE);
+	RNA_def_property_ui_text(prop, "Material", "Display lines that touches specific material");
+
+	prop = RNA_def_property(srna, "collection_select", PROP_POINTER, PROP_NONE);
+	RNA_def_property_struct_type(prop, "Collection");
+	RNA_def_property_flag(prop, PROP_EDITABLE);
+	RNA_def_property_ui_text(prop, "Collection", "Display lines in specific collections");
+
+
+
+	srna = RNA_def_struct(brna, "LANPR_LineLayer", NULL);
+	RNA_def_struct_sdna(srna, "LANPR_LineLayer");
+	RNA_def_struct_ui_text(srna, "Line Layer", "LANPR_LineLayer");
+
+	// removed for mow
+	//prop = RNA_def_property(srna, "use_differnt_style", PROP_BOOLEAN, PROP_NONE);
+	//RNA_def_property_ui_text(prop, "Different Style", "Use different line styles for differnt line types");
+
+	prop = RNA_def_property(srna, "normal_mode", PROP_ENUM, PROP_NONE);
+	RNA_def_property_enum_items(prop, rna_enum_lanpr_normal_mode);
+	RNA_def_property_enum_default(prop, LANPR_NORMAL_DONT_CARE);
+	RNA_def_property_ui_text(prop, "Normal", "Normal Controlled Style");
+
+	prop = RNA_def_property(srna, "normal_effect_inverse", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_ui_text(prop, "Inverse", "Inverse Normal Thickness");
+
+	prop = RNA_def_property(srna, "normal_ramp_begin", PROP_FLOAT, PROP_FACTOR); // begin is least strength
+	RNA_def_property_float_default(prop, 0.0f);
+	RNA_def_property_ui_text(prop, "Ramp Begin", "Normal Ramp Begin Value");
+	RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.05, 2);
+
+	prop = RNA_def_property(srna, "normal_ramp_end", PROP_FLOAT, PROP_FACTOR);
+	RNA_def_property_float_default(prop, 1.0f);
+	RNA_def_property_ui_text(prop, "Ramp End", "Normal Ramp End Value");
+	RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.05, 2);
+
+	prop = RNA_def_property(srna, "normal_thickness_begin", PROP_FLOAT, PROP_NONE); // begin is least strength
+	RNA_def_property_float_default(prop, 0.2f);
+	RNA_def_property_ui_text(prop, "Thickness Begin", "Normal Thickness Begin Value");
+	RNA_def_property_ui_range(prop, 0.0f, 5.0f, 0.05, 2);
+
+	prop = RNA_def_property(srna, "normal_thickness_end", PROP_FLOAT, PROP_NONE);
+	RNA_def_property_float_default(prop, 1.5f);
+	RNA_def_property_ui_text(prop, "Thickness End", "Normal Thickness End Value");
+	RNA_def_property_ui_range(prop, 0.0f, 5.0f, 0.05, 2);
+
+	prop = RNA_def_property(srna, "normal_control_object", PROP_POINTER, PROP_NONE);
+	RNA_def_property_struct_type(prop, "Object");
+	RNA_def_property_flag(prop, PROP_EDITABLE);
+	RNA_def_property_ui_text(prop, "Object", "Normal Style Control Object");
+
+	prop = RNA_def_property(srna, "use_qi_range", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_ui_text(prop, "QI Range", "Use QI Range (occlusion levels) to select lines");
+
+	prop = RNA_def_property(srna, "enable_contour", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_ui_text(prop, "Enable Contour", "Draw contour lines");
+
+	prop = RNA_def_property(srna, "enable_crease", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_ui_text(prop, "Enable Crease", "Draw crease lines");
+
+	prop = RNA_def_property(srna, "enable_edge_mark", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_ui_text(prop, "Enable Edge Mark", "Draw edge marks");
+
+	prop = RNA_def_property(srna, "enable_material_seperate", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_ui_text(prop, "Enable Material Lines", "Draw material seperators");
+
+	prop = RNA_def_property(srna, "enable_intersection", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_ui_text(prop, "Enable intersection Lines", "Draw intersection lines");
+
+	prop = RNA_def_property(srna, "qi_begin", PROP_INT, PROP_NONE);
+	RNA_def_property_int_default(prop, 0);
+	RNA_def_property_ui_text(prop, "QI Begin", "QI Begin");
+	RNA_def_property_range(prop, 0, 128);
+
+	prop = RNA_def_property(srna, "qi_end", PROP_INT, PROP_NONE);
+	RNA_def_property_int_default(prop, 0);
+	RNA_def_property_ui_text(prop, "QI End", "QI End");
+	RNA_def_property_range(prop, 0, 128);
+
+
+	prop = RNA_def_property(srna, "thickness", PROP_FLOAT, PROP_NONE);
+	RNA_def_property_float_default(prop, 1.0f);
+	RNA_def_property_ui_text(prop, "Thickness", "Master Thickness");
+	RNA_def_property_ui_range(prop, 0.0f, 30.0f, 0.01, 2);
+
+	prop = RNA_def_property(srna, "thickness_crease", PROP_FLOAT, PROP_FACTOR);
+	RNA_def_property_float_default(prop, 1.0f);
+	RNA_def_property_ui_text(prop, "Thickness", "Crease Thickness");
+	RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.01, 2);
+
+	prop = RNA_def_property(srna, "thickness_material", PROP_FLOAT, PROP_FACTOR);
+	RNA_def_property_float_default(prop, 1.0f);
+	RNA_def_property_ui_text(prop, "Thickness", "Material Thickness");
+	RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.01, 2);
+
+	prop = RNA_def_property(srna, "thickness_edge_mark", PROP_FLOAT, PROP_FACTOR);
+	RNA_def_property_float_default(prop, 1.0f);
+	RNA_def_property_ui_text(prop, "Thickness", "Edge Mark Thickness");
+	RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.01, 2);
+
+	prop = RNA_def_property(srna, "thickness_intersection", PROP_FLOAT, PROP_FACTOR);
+	RNA_def_property_float_default(prop, 1.0f);
+	RNA_def_property_ui_text(prop, "Thickness", "Edge Mark Thickness");
+	RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.01, 2);
+
+	prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
+	RNA_def_property_float_default(prop, 1.0f);
+	RNA_def_property_array(prop, 3);
+	RNA_def_property_ui_text(prop, "Color", "Master Color");
+	RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 2);
+
+	prop = RNA_def_property(srna, "crease_color", PROP_FLOAT, PROP_COLOR);
+	RNA_def_property_float_default(prop, 1.0f);
+	RNA_def_property_array(prop, 3);
+	RNA_def_property_ui_text(prop, "Crease Color", "Drawing crease lines using this color");
+	RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 2);
+
+	prop = RNA_def_property(srna, "material_color", PROP_FLOAT, PROP_COLOR);
+	RNA_def_property_float_default(prop, 1.0f);
+	RNA_def_property_array(prop, 3);
+	RNA_def_property_ui_text(prop, "Material Line Color", "Drawing material seperate lines using this color");
+	RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 2);
+
+	prop = RNA_def_property(srna, "edge_mark_color", PROP_FLOAT, PROP_COLOR);
+	RNA_def_property_float_default(prop, 1.0f);
+	RNA_def_property_array(prop, 3);
+	RNA_def_property_ui_text(prop, "Edge Mark Color", "Drawing edge marks using this color");
+	RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 2);
+
+	prop = RNA_def_property(srna, "intersection_color", PROP_FLOAT, PROP_COLOR);
+	RNA_def_property_float_default(prop, 1.0f);
+	RNA_def_property_array(prop, 3);
+	RNA_def_property_ui_text(prop, "Edge Mark Color", "Drawing edge marks using this color");
+	RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 2);
+
+	prop = RNA_def_property(srna, "components", PROP_COLLECTION, PROP_NONE);
+	RNA_def_property_collection_sdna(prop, NULL, "components", NULL);
+	RNA_def_property_struct_type(prop, "LANPR_LineLayerComponent");
+	RNA_def_property_ui_text(prop, "Components", "Line Layer Components");
+
+}
+
+#endif

source/blender/makesrna/intern/rna_modifier.c

@@ -573,6 +573,8 @@ static StructRNA *rna_Modifier_refine(struct PointerRNA *ptr)
       return &RNA_SurfaceDeformModifier;
     case eModifierType_WeightedNormal:
       return &RNA_WeightedNormalModifier;
+		case eModifierType_MyBMesh:
+			return &RNA_MyBMeshModifier;
     /* Default */
     case eModifierType_None:
     case eModifierType_ShapeKey:
@@ -5827,6 +5829,63 @@ static void rna_def_modifier_surfacedeform(BlenderRNA *brna)
   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 }
 
+static void rna_def_modifier_mybmesh(BlenderRNA *brna)
+{
+	StructRNA *srna;
+	PropertyRNA *prop;
+
+	srna = RNA_def_struct(brna, "MyBMeshModifier", "Modifier");
+	RNA_def_struct_ui_text(srna, "Wireframe Modifier", "Wireframe effect modifier");
+	RNA_def_struct_sdna(srna, "MyBMeshModifierData");
+	RNA_def_struct_ui_icon(srna, ICON_MOD_MESHDEFORM);
+
+	prop = RNA_def_property(srna, "do_tri", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MYBMESH_TRIANG);
+	RNA_def_property_ui_text(prop, "b)", "Triangulate the mesh");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "do_ff_bb_split", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MYBMESH_FF_SPLIT);
+	RNA_def_property_ui_text(prop, "Split", "Split inconsitent FF/BB edges");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "do_cusp_dect", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MYBMESH_CUSP_D);
+	RNA_def_property_ui_text(prop, "Cusp detetion", "Detect cusps and insert new edges");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "do_insert", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MYBMESH_FB_SPLIT);
+	RNA_def_property_ui_text(prop, "FB split", "Split FB edges");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "do_cusp_insert", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MYBMESH_CUSP_I);
+	RNA_def_property_ui_text(prop, "Cusp insertion", "Insert cusps from detection stage");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "do_rad_insert", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MYBMESH_RAD_I);
+	RNA_def_property_ui_text(prop, "Radial edge insert", "Insert radial edges");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "do_rad_flip", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MYBMESH_RAD_FLIP);
+	RNA_def_property_ui_text(prop, "Radial edge flip", "Do radial edge flipping");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "do_opti", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MYBMESH_OPTI);
+	RNA_def_property_ui_text(prop, "Mesh optimization", "Try to eliminate inconsistent faces");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
+	prop = RNA_def_property(srna, "camera_object", PROP_POINTER, PROP_NONE);
+	RNA_def_property_pointer_sdna(prop, NULL, "camera_ob");
+	RNA_def_property_ui_text(prop, "Camera Object", "Object to use as camera location");
+	RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
+	RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
+}
+
 static void rna_def_modifier_weightednormal(BlenderRNA *brna)
 {
   StructRNA *srna;
@@ -5906,129 +5965,128 @@ static void rna_def_modifier_weightednormal(BlenderRNA *brna)
 
 void RNA_def_modifier(BlenderRNA *brna)
 {
-  StructRNA *srna;
-  PropertyRNA *prop;
+	StructRNA *srna;
+	PropertyRNA *prop;
 
-  /* data */
-  srna = RNA_def_struct(brna, "Modifier", NULL);
-  RNA_def_struct_ui_text(srna, "Modifier", "Modifier affecting the geometry data of an object");
-  RNA_def_struct_refine_func(srna, "rna_Modifier_refine");
-  RNA_def_struct_path_func(srna, "rna_Modifier_path");
-  RNA_def_struct_sdna(srna, "ModifierData");
+	/* data */
+	srna = RNA_def_struct(brna, "Modifier", NULL);
+	RNA_def_struct_ui_text(srna, "Modifier", "Modifier affecting the geometry data of an object");
+	RNA_def_struct_refine_func(srna, "rna_Modifier_refine");
+	RNA_def_struct_path_func(srna, "rna_Modifier_path");
+	RNA_def_struct_sdna(srna, "ModifierData");
 
-  /* strings */
-  prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
-  RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Modifier_name_set");
-  RNA_def_property_ui_text(prop, "Name", "Modifier name");
-  RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER | NA_RENAME, NULL);
-  RNA_def_struct_name_property(srna, prop);
+	/* strings */
+	prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
+	RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Modifier_name_set");
+	RNA_def_property_ui_text(prop, "Name", "Modifier name");
+	RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER | NA_RENAME, NULL);
+	RNA_def_struct_name_property(srna, prop);
 
-  /* enums */
-  prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
-  RNA_def_property_clear_flag(prop, PROP_EDITABLE);
-  RNA_def_property_enum_sdna(prop, NULL, "type");
-  RNA_def_property_enum_items(prop, rna_enum_object_modifier_type_items);
-  RNA_def_property_ui_text(prop, "Type", "");
+	/* enums */
+	prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
+	RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+	RNA_def_property_enum_sdna(prop, NULL, "type");
+	RNA_def_property_enum_items(prop, rna_enum_object_modifier_type_items);
+	RNA_def_property_ui_text(prop, "Type", "");
 
-  /* flags */
-  prop = RNA_def_property(srna, "show_viewport", PROP_BOOLEAN, PROP_NONE);
-  RNA_def_property_boolean_sdna(prop, NULL, "mode", eModifierMode_Realtime);
-  RNA_def_property_ui_text(prop, "Realtime", "Display modifier in viewport");
-  RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
-  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
-  RNA_def_property_update(prop, 0, "rna_Modifier_update");
-  RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_ON, 1);
+	/* flags */
+	prop = RNA_def_property(srna, "show_viewport", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "mode", eModifierMode_Realtime);
+	RNA_def_property_ui_text(prop, "Realtime", "Display modifier in viewport");
+	RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
+	RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+	RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_ON, 1);
 
-  prop = RNA_def_property(srna, "show_render", PROP_BOOLEAN, PROP_NONE);
-  RNA_def_property_boolean_sdna(prop, NULL, "mode", eModifierMode_Render);
-  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
-  RNA_def_property_ui_text(prop, "Render", "Use modifier during render");
-  RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_ON, 1);
-  RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, NULL);
+	prop = RNA_def_property(srna, "show_render", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "mode", eModifierMode_Render);
+	RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
+	RNA_def_property_ui_text(prop, "Render", "Use modifier during render");
+	RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_ON, 1);
+	RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, NULL);
 
-  prop = RNA_def_property(srna, "show_in_editmode", PROP_BOOLEAN, PROP_NONE);
-  RNA_def_property_boolean_sdna(prop, NULL, "mode", eModifierMode_Editmode);
-  RNA_def_property_ui_text(prop, "Edit Mode", "Display modifier in Edit mode");
-  RNA_def_property_update(prop, 0, "rna_Modifier_update");
-  RNA_def_property_ui_icon(prop, ICON_EDITMODE_HLT, 0);
+	prop = RNA_def_property(srna, "show_in_editmode", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "mode", eModifierMode_Editmode);
+	RNA_def_property_ui_text(prop, "Edit Mode", "Display modifier in Edit mode");
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
+	RNA_def_property_ui_icon(prop, ICON_EDITMODE_HLT, 0);
 
-  prop = RNA_def_property(srna, "show_on_cage", PROP_BOOLEAN, PROP_NONE);
-  RNA_def_property_boolean_sdna(prop, NULL, "mode", eModifierMode_OnCage);
-  RNA_def_property_ui_text(prop, "On Cage", "Adjust edit cage to modifier result");
-  RNA_def_property_ui_icon(prop, ICON_MESH_DATA, 0);
-  RNA_def_property_update(prop, 0, "rna_Modifier_update");
+	prop = RNA_def_property(srna, "show_on_cage", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "mode", eModifierMode_OnCage);
+	RNA_def_property_ui_text(prop, "On Cage", "Adjust edit cage to modifier result");
+	RNA_def_property_ui_icon(prop, ICON_MESH_DATA, 0);
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-  prop = RNA_def_property(srna, "show_expanded", PROP_BOOLEAN, PROP_NONE);
-  RNA_def_property_flag(prop, PROP_NO_DEG_UPDATE);
-  RNA_def_property_boolean_sdna(prop, NULL, "mode", eModifierMode_Expanded);
-  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
-  RNA_def_property_ui_text(prop, "Expanded", "Set modifier expanded in the user interface");
-  RNA_def_property_ui_icon(prop, ICON_DISCLOSURE_TRI_RIGHT, 1);
+	prop = RNA_def_property(srna, "show_expanded", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_flag(prop, PROP_NO_DEG_UPDATE);
+	RNA_def_property_boolean_sdna(prop, NULL, "mode", eModifierMode_Expanded);
+	RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
+	RNA_def_property_ui_text(prop, "Expanded", "Set modifier expanded in the user interface");
+	RNA_def_property_ui_icon(prop, ICON_DISCLOSURE_TRI_RIGHT, 1);
 
-  prop = RNA_def_property(srna, "use_apply_on_spline", PROP_BOOLEAN, PROP_NONE);
-  RNA_def_property_boolean_sdna(prop, NULL, "mode", eModifierMode_ApplyOnSpline);
-  RNA_def_property_ui_text(
-      prop,
-      "Apply on spline",
-      "Apply this and all preceding deformation modifiers on splines' points rather than "
-      "on filled curve/surface");
-  RNA_def_property_ui_icon(prop, ICON_SURFACE_DATA, 0);
-  RNA_def_property_update(prop, 0, "rna_Modifier_update");
+	prop = RNA_def_property(srna, "use_apply_on_spline", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "mode", eModifierMode_ApplyOnSpline);
+	RNA_def_property_ui_text(prop, "Apply on spline",
+	                         "Apply this and all preceding deformation modifiers on splines' points rather than "
+	                         "on filled curve/surface");
+	RNA_def_property_ui_icon(prop, ICON_SURFACE_DATA, 0);
+	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-  /* types */
-  rna_def_modifier_subsurf(brna);
-  rna_def_modifier_lattice(brna);
-  rna_def_modifier_curve(brna);
-  rna_def_modifier_build(brna);
-  rna_def_modifier_mirror(brna);
-  rna_def_modifier_decimate(brna);
-  rna_def_modifier_wave(brna);
-  rna_def_modifier_armature(brna);
-  rna_def_modifier_hook(brna);
-  rna_def_modifier_softbody(brna);
-  rna_def_modifier_boolean(brna);
-  rna_def_modifier_array(brna);
-  rna_def_modifier_edgesplit(brna);
-  rna_def_modifier_displace(brna);
-  rna_def_modifier_uvproject(brna);
-  rna_def_modifier_smooth(brna);
-  rna_def_modifier_correctivesmooth(brna);
-  rna_def_modifier_cast(brna);
-  rna_def_modifier_meshdeform(brna);
-  rna_def_modifier_particlesystem(brna);
-  rna_def_modifier_particleinstance(brna);
-  rna_def_modifier_explode(brna);
-  rna_def_modifier_cloth(brna);
-  rna_def_modifier_collision(brna);
-  rna_def_modifier_bevel(brna);
-  rna_def_modifier_shrinkwrap(brna);
-  rna_def_modifier_fluidsim(brna);
-  rna_def_modifier_mask(brna);
-  rna_def_modifier_simpledeform(brna);
-  rna_def_modifier_warp(brna);
-  rna_def_modifier_multires(brna);
-  rna_def_modifier_surface(brna);
-  rna_def_modifier_smoke(brna);
-  rna_def_modifier_solidify(brna);
-  rna_def_modifier_screw(brna);
-  rna_def_modifier_uvwarp(brna);
-  rna_def_modifier_weightvgedit(brna);
-  rna_def_modifier_weightvgmix(brna);
-  rna_def_modifier_weightvgproximity(brna);
-  rna_def_modifier_dynamic_paint(brna);
-  rna_def_modifier_ocean(brna);
-  rna_def_modifier_remesh(brna);
-  rna_def_modifier_skin(brna);
-  rna_def_modifier_laplaciansmooth(brna);
-  rna_def_modifier_triangulate(brna);
-  rna_def_modifier_meshcache(brna);
-  rna_def_modifier_laplaciandeform(brna);
-  rna_def_modifier_wireframe(brna);
-  rna_def_modifier_datatransfer(brna);
-  rna_def_modifier_normaledit(brna);
-  rna_def_modifier_meshseqcache(brna);
-  rna_def_modifier_surfacedeform(brna);
-  rna_def_modifier_weightednormal(brna);
+	/* types */
+	rna_def_modifier_subsurf(brna);
+	rna_def_modifier_lattice(brna);
+	rna_def_modifier_curve(brna);
+	rna_def_modifier_build(brna);
+	rna_def_modifier_mirror(brna);
+	rna_def_modifier_decimate(brna);
+	rna_def_modifier_wave(brna);
+	rna_def_modifier_armature(brna);
+	rna_def_modifier_hook(brna);
+	rna_def_modifier_softbody(brna);
+	rna_def_modifier_boolean(brna);
+	rna_def_modifier_array(brna);
+	rna_def_modifier_edgesplit(brna);
+	rna_def_modifier_displace(brna);
+	rna_def_modifier_uvproject(brna);
+	rna_def_modifier_smooth(brna);
+	rna_def_modifier_correctivesmooth(brna);
+	rna_def_modifier_cast(brna);
+	rna_def_modifier_meshdeform(brna);
+	rna_def_modifier_particlesystem(brna);
+	rna_def_modifier_particleinstance(brna);
+	rna_def_modifier_explode(brna);
+	rna_def_modifier_cloth(brna);
+	rna_def_modifier_collision(brna);
+	rna_def_modifier_bevel(brna);
+	rna_def_modifier_shrinkwrap(brna);
+	rna_def_modifier_fluidsim(brna);
+	rna_def_modifier_mask(brna);
+	rna_def_modifier_simpledeform(brna);
+	rna_def_modifier_warp(brna);
+	rna_def_modifier_multires(brna);
+	rna_def_modifier_surface(brna);
+	rna_def_modifier_smoke(brna);
+	rna_def_modifier_solidify(brna);
+	rna_def_modifier_screw(brna);
+	rna_def_modifier_uvwarp(brna);
+	rna_def_modifier_weightvgedit(brna);
+	rna_def_modifier_weightvgmix(brna);
+	rna_def_modifier_weightvgproximity(brna);
+	rna_def_modifier_dynamic_paint(brna);
+	rna_def_modifier_ocean(brna);
+	rna_def_modifier_remesh(brna);
+	rna_def_modifier_skin(brna);
+	rna_def_modifier_laplaciansmooth(brna);
+	rna_def_modifier_triangulate(brna);
+	rna_def_modifier_meshcache(brna);
+	rna_def_modifier_laplaciandeform(brna);
+	rna_def_modifier_wireframe(brna);
+	rna_def_modifier_datatransfer(brna);
+	rna_def_modifier_normaledit(brna);
+	rna_def_modifier_meshseqcache(brna);
+	rna_def_modifier_surfacedeform(brna);
+	rna_def_modifier_mybmesh(brna);
+	rna_def_modifier_weightednormal(brna);
 }
 
 #endif

source/blender/modifiers/CMakeLists.txt

@@ -39,73 +39,74 @@ set(INC_SYS
 )
 
 set(SRC
-  intern/MOD_armature.c
-  intern/MOD_array.c
-  intern/MOD_bevel.c
-  intern/MOD_boolean.c
-  intern/MOD_build.c
-  intern/MOD_cast.c
-  intern/MOD_cloth.c
-  intern/MOD_collision.c
-  intern/MOD_correctivesmooth.c
-  intern/MOD_curve.c
-  intern/MOD_datatransfer.c
-  intern/MOD_decimate.c
-  intern/MOD_displace.c
-  intern/MOD_dynamicpaint.c
-  intern/MOD_edgesplit.c
-  intern/MOD_explode.c
-  intern/MOD_fluidsim.c
-  intern/MOD_fluidsim_util.c
-  intern/MOD_hook.c
-  intern/MOD_laplaciandeform.c
-  intern/MOD_laplaciansmooth.c
-  intern/MOD_lattice.c
-  intern/MOD_mask.c
-  intern/MOD_meshcache.c
-  intern/MOD_meshcache_mdd.c
-  intern/MOD_meshcache_pc2.c
-  intern/MOD_meshcache_util.c
-  intern/MOD_meshdeform.c
-  intern/MOD_meshsequencecache.c
-  intern/MOD_mirror.c
-  intern/MOD_multires.c
-  intern/MOD_none.c
-  intern/MOD_normal_edit.c
-  intern/MOD_ocean.c
-  intern/MOD_particleinstance.c
-  intern/MOD_particlesystem.c
-  intern/MOD_remesh.c
-  intern/MOD_screw.c
-  intern/MOD_shapekey.c
-  intern/MOD_shrinkwrap.c
-  intern/MOD_simpledeform.c
-  intern/MOD_skin.c
-  intern/MOD_smoke.c
-  intern/MOD_smooth.c
-  intern/MOD_softbody.c
-  intern/MOD_solidify.c
-  intern/MOD_subsurf.c
-  intern/MOD_surface.c
-  intern/MOD_surfacedeform.c
-  intern/MOD_triangulate.c
-  intern/MOD_util.c
-  intern/MOD_uvproject.c
-  intern/MOD_uvwarp.c
-  intern/MOD_warp.c
-  intern/MOD_wave.c
-  intern/MOD_weighted_normal.c
-  intern/MOD_weightvg_util.c
-  intern/MOD_weightvgedit.c
-  intern/MOD_weightvgmix.c
-  intern/MOD_weightvgproximity.c
-  intern/MOD_wireframe.c
+	intern/MOD_armature.c
+	intern/MOD_array.c
+	intern/MOD_bevel.c
+	intern/MOD_boolean.c
+	intern/MOD_build.c
+	intern/MOD_cast.c
+	intern/MOD_cloth.c
+	intern/MOD_collision.c
+	intern/MOD_correctivesmooth.c
+	intern/MOD_curve.c
+	intern/MOD_datatransfer.c
+	intern/MOD_decimate.c
+	intern/MOD_displace.c
+	intern/MOD_dynamicpaint.c
+	intern/MOD_edgesplit.c
+	intern/MOD_explode.c
+	intern/MOD_fluidsim.c
+	intern/MOD_fluidsim_util.c
+	intern/MOD_hook.c
+	intern/MOD_laplaciandeform.c
+	intern/MOD_laplaciansmooth.c
+	intern/MOD_lattice.c
+	intern/MOD_mask.c
+	intern/MOD_meshcache.c
+	intern/MOD_meshcache_mdd.c
+	intern/MOD_meshcache_pc2.c
+	intern/MOD_meshcache_util.c
+	intern/MOD_meshdeform.c
+	intern/MOD_meshsequencecache.c
+	intern/MOD_mirror.c
+	intern/MOD_multires.c
+	intern/MOD_mybmesh.c
+	intern/MOD_none.c
+	intern/MOD_normal_edit.c
+	intern/MOD_ocean.c
+	intern/MOD_particleinstance.c
+	intern/MOD_particlesystem.c
+	intern/MOD_remesh.c
+	intern/MOD_screw.c
+	intern/MOD_shapekey.c
+	intern/MOD_shrinkwrap.c
+	intern/MOD_simpledeform.c
+	intern/MOD_skin.c
+	intern/MOD_smoke.c
+	intern/MOD_smooth.c
+	intern/MOD_softbody.c
+	intern/MOD_solidify.c
+	intern/MOD_subsurf.c
+	intern/MOD_surface.c
+	intern/MOD_surfacedeform.c
+	intern/MOD_triangulate.c
+	intern/MOD_util.c
+	intern/MOD_uvproject.c
+	intern/MOD_uvwarp.c
+	intern/MOD_warp.c
+	intern/MOD_wave.c
+	intern/MOD_weighted_normal.c
+	intern/MOD_weightvg_util.c
+	intern/MOD_weightvgedit.c
+	intern/MOD_weightvgmix.c
+	intern/MOD_weightvgproximity.c
+	intern/MOD_wireframe.c
 
-  MOD_modifiertypes.h
-  intern/MOD_fluidsim_util.h
-  intern/MOD_meshcache_util.h
-  intern/MOD_util.h
-  intern/MOD_weightvg_util.h
+	MOD_modifiertypes.h
+	intern/MOD_fluidsim_util.h
+	intern/MOD_meshcache_util.h
+	intern/MOD_util.h
+	intern/MOD_weightvg_util.h
 )
 
 set(LIB

source/blender/modifiers/MOD_modifiertypes.h

@@ -80,6 +80,7 @@ extern ModifierTypeInfo modifierType_NormalEdit;
 extern ModifierTypeInfo modifierType_CorrectiveSmooth;
 extern ModifierTypeInfo modifierType_MeshSequenceCache;
 extern ModifierTypeInfo modifierType_SurfaceDeform;
+extern ModifierTypeInfo modifierType_MyBMesh;
 extern ModifierTypeInfo modifierType_WeightedNormal;
 
 /* MOD_util.c */

source/blender/modifiers/intern/MOD_util.c

@@ -306,6 +306,7 @@ void modifier_type_init(ModifierTypeInfo *types[])
   INIT_TYPE(CorrectiveSmooth);
   INIT_TYPE(MeshSequenceCache);
   INIT_TYPE(SurfaceDeform);
+  INIT_TYPE(MyBMesh);
   INIT_TYPE(WeightedNormal);
 #undef INIT_TYPE
 }