[RPRBLND-1556] export Contour settings to json (#152)

PURPOSE
Export Contour settings to RPR json when Export to rpr is used.

EFFECT OF CHANGE
added Contour settings to the "Export to rpr". In GPU mode only.

Author: ardraeiss

src/rprblender/engine/export_engine.py

@@ -25,7 +25,7 @@
     world,
     camera
 )
-from .context import RPRContext
+from .context import RPRContext, RPRContext2
 from .engine import Engine
 import pyrpr
 
@@ -48,7 +48,9 @@ def sync(self, context):
         self.rpr_context.blender_data['depsgraph'] = depsgraph
         scene = depsgraph.scene
 
-        scene.rpr.init_rpr_context(self.rpr_context)
+        use_contour = scene.rpr.is_contour_used
+
+        scene.rpr.init_rpr_context(self.rpr_context, use_contour_integrator=use_contour)
 
         self.rpr_context.scene.set_name(scene.name)
         self.rpr_context.width = int(scene.render.resolution_x * scene.render.resolution_percentage / 100)
@@ -102,3 +104,11 @@ def export_to_rpr(self, filepath: str, flags):
         """
         log('export_to_rpr')
         pyrpr_load_store.export(filepath, self.rpr_context.context, self.rpr_context.scene, flags)
+
+
+class ExportEngine2(ExportEngine):
+    TYPE = 'EXPORT'
+
+    def __init__(self):
+        self.rpr_context = RPRContext2()
+        self.rpr_context.engine_type = self.TYPE

src/rprblender/operators/export_scene.py

@@ -21,7 +21,7 @@
 
 import bpy
 from bpy_extras.io_utils import ExportHelper
-from rprblender.engine.export_engine import ExportEngine
+from rprblender.engine.export_engine import ExportEngine, ExportEngine2
 import os.path
 import json
 from rprblender.utils.user_settings import get_user_settings
@@ -34,6 +34,9 @@
 log = Log(tag='operators.export_scene')
 
 
+CONTOUR_AOVS = (pyrpr.AOV_GEOMETRIC_NORMAL, pyrpr.AOV_MATERIAL_ID, pyrpr.AOV_OBJECT_ID)
+
+
 class RPR_EXPORT_OP_export_rpr_scene(RPR_Operator, ExportHelper):
     bl_idname = "rpr.export_scene_rpr"
     bl_label = "RPR (.rpr)"
@@ -118,10 +121,7 @@ def execute(self, context):
                 filepath_json = os.path.splitext(filepath_frame)[0] + '.json'
                 scene.frame_set(i)
 
-                exporter = ExportEngine()
-                exporter.sync(context)
-                exporter.export_to_rpr(filepath_frame, flags)
-                self.save_json(filepath_json, scene, context.view_layer)
+                self.export_scene_to_file(context, scene, filepath_frame, filepath_json, flags)
                 log.info(f"Finished frame {i} export to '{filepath_frame}'")
 
             scene.frame_set(orig_frame)
@@ -131,19 +131,28 @@ def execute(self, context):
             time_started = time.time()
 
             filepath_json = os.path.splitext(self.filepath)[0] + '.json'
-            exporter = ExportEngine()
-            exporter.sync(context)
-            exporter.export_to_rpr(self.filepath, flags)
-            self.save_json(filepath_json, scene, context.view_layer)
+            self.export_scene_to_file(context, scene, self.filepath, filepath_json, flags)
 
         log.info(f"Finished RPR export in {time.time() - time_started} s")
 
         return {'FINISHED'}
 
+    def export_scene_to_file(self, context, scene, filepath, filepath_json, flags):
+        if scene.rpr.render_quality == 'FULL':
+            exporter = ExportEngine()
+        else:
+            exporter = ExportEngine2()
+        exporter.sync(context)
+        exporter.export_to_rpr(filepath, flags)
+        self.save_json(filepath_json, scene, context.view_layer)
+
     def save_json(self, filepath, scene, view_layer):
         ''' save scene settings to json at filepath '''
         output_base = os.path.splitext(filepath)[0]
 
+        devices = get_user_settings().final_devices
+        use_contour = scene.rpr.is_contour_used and not devices.cpu_state
+
         data = {
             'width': int(scene.render.resolution_x * scene.render.resolution_percentage / 100),
             'height': int(scene.render.resolution_y * scene.render.resolution_percentage / 100),
@@ -189,22 +198,35 @@ def save_json(self, filepath, scene, view_layer):
 
         aovs = {}
         for i, enable_aov in enumerate(view_layer.rpr.enable_aovs):
-            if enable_aov:
-                aov = view_layer.rpr.aovs_info[i]
-                aov_name = aov_map[aov['rpr']]
+            aov = view_layer.rpr.aovs_info[i]
+            aov_type = aov['rpr']
+            if enable_aov or (use_contour and aov_type in CONTOUR_AOVS):
+                aov_name = aov_map[aov_type]
                 aovs[aov_name] = output_base + '.' + aov_name + '.png'
+
         data['aovs'] = aovs
 
         # set devices based on final render
         device_settings = {}
-        devices = get_user_settings().final_devices
-        
         device_settings['cpu'] = int(devices.cpu_state)
         device_settings['threads'] = devices.cpu_threads
 
         for i, gpu_state in enumerate(devices.available_gpu_states):
             device_settings[f'gpu{i}'] = int(gpu_state)
 
+        if use_contour:
+            data['contour'] = {
+                "object.id": int(scene.rpr.contour_use_object_id),
+                "material.id": int(scene.rpr.contour_use_material_id),
+                "normal": int(scene.rpr.contour_use_shading_normal),
+                "threshold.normal": scene.rpr.contour_normal_threshold,
+                "linewidth.objid": scene.rpr.contour_object_id_line_width,
+                "linewidth.matid": scene.rpr.contour_material_id_line_width,
+                "linewidth.normal": scene.rpr.contour_shading_normal_line_width,
+                "antialiasing": scene.rpr.contour_antialiasing,
+                "debug": int(scene.rpr.contour_use_shading_normal)
+            }
+
         data['context'] = device_settings
 
         with open(filepath, 'w') as outfile: