Merge branch 'develop'

Author: bsavery

RadeonProRenderSDK

@@ -663,7 +663,8 @@ def get_rif_sdk(base=Path()):
                  'RPR_SHAPE_SET_LIGHTMAP_CHART_INDEX_FUNC_NAME',
                  'RPR_MESH_UPDATE_FUNC_NAME',
                  'RPR_SHAPE_SET_TRANSFORM_BATCH_FUNC_NAME',
-                 'rprDirectionalLightSetRasterShadowSplits']
+                 'rprDirectionalLightSetRasterShadowSplits',
+                 'RPR_CONTEXT_CREATE_MESH_EDITABLE_FUNC_NAME',]
     )
 
     export(

src/bindings/pyrpr/src/pyrprapi.py

@@ -20,7 +20,7 @@
 bl_info = {
     "name": "Radeon ProRender",
     "author": "AMD",
-    "version": (3, 0, 2),
+    "version": (3, 0, 8),
     "blender": (2, 80, 0),
     "location": "Info header, render engine menu",
     "description": "Radeon ProRender rendering plugin for Blender 2.8x",

src/rprblender/__init__.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/engine/export_engine.py

@@ -62,6 +62,8 @@ def __init__(self, rpr_engine):
         self.camera_data: camera.CameraData = None
         self.tile_order = None
 
+        self.use_contour = False
+
         self.world_backplate = None
 
         self.render_stamp_text = ""
@@ -145,7 +147,7 @@ def _render(self):
                 break
 
             render_iteration += 1
-            if render_iteration > 1 and self.render_update_samples < MAX_RENDER_ITERATIONS:
+            if render_iteration > 1 and self.render_update_samples < MAX_RENDER_ITERATIONS and not self.use_contour:
                 # progressively increase update samples up to 32
                 self.render_update_samples *= 2
 
@@ -248,7 +250,7 @@ def _render_tiles(self):
                     break
 
                 render_iteration += 1
-                if render_iteration > 1 and self.render_update_samples < MAX_RENDER_ITERATIONS:
+                if render_iteration > 1 and self.render_update_samples < MAX_RENDER_ITERATIONS and not self.use_contour:
                     # progressively increase update samples up to 32
                     self.render_update_samples *= 2
 
@@ -318,7 +320,7 @@ def render(self):
         log('Finish render')
 
     def _init_rpr_context(self, scene):
-        scene.rpr.init_rpr_context(self.rpr_context, use_contour_integrator=scene.rpr.is_contour_used)
+        scene.rpr.init_rpr_context(self.rpr_context, use_contour_integrator=self.use_contour)
 
         self.rpr_context.scene.set_name(scene.name)
 
@@ -339,6 +341,7 @@ def sync(self, depsgraph):
 
         self.notify_status(0, "Start syncing")
 
+        self.use_contour = scene.rpr.is_contour_used
         self._init_rpr_context(scene)
 
         border = ((0, 0), (1, 1)) if not scene.render.use_border else \
@@ -353,8 +356,7 @@ def sync(self, depsgraph):
 
         self.rpr_context.resize(self.width, self.height)
 
-        use_contour = scene.rpr.is_contour_used
-        if use_contour:
+        if self.use_contour:
             scene.rpr.export_contour_mode(self.rpr_context)
 
         self.rpr_context.blender_data['depsgraph'] = depsgraph
@@ -368,7 +370,7 @@ def sync(self, depsgraph):
             indirect_only = obj.original.indirect_only_get(view_layer=view_layer)
             object.sync(self.rpr_context, obj,
                         indirect_only=indirect_only, material_override=material_override,
-                        frame_current=scene.frame_current, use_contour=use_contour)
+                        frame_current=scene.frame_current, use_contour=self.use_contour)
 
             if self.rpr_engine.test_break():
                 log.warn("Syncing stopped by user termination")
@@ -388,7 +390,7 @@ def sync(self, depsgraph):
             indirect_only = inst.parent.original.indirect_only_get(view_layer=view_layer)
             instance.sync(self.rpr_context, inst,
                           indirect_only=indirect_only, material_override=material_override,
-                          frame_current=scene.frame_current, use_contour=use_contour)
+                          frame_current=scene.frame_current, use_contour=self.use_contour)
 
             if self.rpr_engine.test_break():
                 log.warn("Syncing stopped by user termination")
@@ -480,8 +482,11 @@ def sync(self, depsgraph):
 
         self.render_samples, self.render_time = (scene.rpr.limits.max_samples, scene.rpr.limits.seconds)
 
-        if scene.rpr.render_quality == 'FULL2' and not scene.rpr.use_contour_render:
-            self.render_update_samples = scene.rpr.limits.update_samples_rpr2
+        if scene.rpr.render_quality == 'FULL2':
+            if self.use_contour:
+                self.render_update_samples = 1
+            else:
+                self.render_update_samples = scene.rpr.limits.update_samples_rpr2
         else:
             self.render_update_samples = scene.rpr.limits.update_samples
 

src/rprblender/engine/render_engine.py

@@ -15,7 +15,7 @@
 import numpy as np
 import bpy
 
-from . import object, light
+from . import object, light, mesh
 from rprblender.utils import logging
 log = logging.Log(tag='export.instance')
 
@@ -56,7 +56,7 @@ def sync(rpr_context, instance: bpy.types.DepsgraphObjectInstance, **kwargs):
 
         # exporting visibility from parent object
         indirect_only = kwargs.get("indirect_only", False)
-        instance.parent.rpr.export_visibility(rpr_shape, indirect_only)
+        mesh.export_visibility(instance.parent, rpr_shape, indirect_only)
 
         rpr_context.scene.attach(rpr_shape)
 

src/rprblender/export/instance.py

@@ -45,7 +45,7 @@ def get_radiant_power(light: bpy.types.Light, area=0.0):
     if light.type in ('POINT', 'SPOT'):
         units = rpr.intensity_units_point
         if units == 'DEFAULT':
-            return default_intensity / (4*math.pi)  # dividing by 4*pi to be more convenient with cycles point light
+            return color * math.sqrt(light.energy)  # to match cycles
 
         # converting to lumen
         if units == 'LUMEN':
@@ -60,7 +60,7 @@ def get_radiant_power(light: bpy.types.Light, area=0.0):
     elif light.type == 'SUN':
         units = rpr.intensity_units_dir
         if units == 'DEFAULT':
-            return default_intensity * 0.01         # multiplying by 0.01 to be more convenient with point light
+            return default_intensity
 
         # converting to luminance
         if units == 'LUMINANCE':
@@ -134,7 +134,7 @@ def sync(rpr_context: RPRContext, obj: bpy.types.Object, instance_key=None):
 
     elif light.type in ('SUN', 'HEMI'):  # just in case old scenes will have outdated Hemi
         rpr_light = rpr_context.create_light(light_key, 'directional')
-        rpr_light.set_shadow_softness_angle(light.rpr.shadow_softness_angle)
+        rpr_light.set_shadow_softness_angle(light.angle / 2.0) # to match cycles
 
     elif light.type == 'SPOT':
         rpr_light = rpr_context.create_light(light_key, 'disk')

src/rprblender/export/light.py

@@ -257,6 +257,23 @@ def assign_override_material(rpr_context, rpr_shape, obj, material_override) ->
     return bool(rpr_material or rpr_displacement)
 
 
+def export_visibility(obj, rpr_shape, indirect_only):
+    """ Exports visibility settings """
+    cycles_visibility = obj.cycles_visibility
+
+    camera_visibility = cycles_visibility.camera and not indirect_only
+
+    rpr_shape.set_visibility_primary_only(camera_visibility)
+    rpr_shape.set_visibility_ex("visible.reflection", cycles_visibility.glossy)
+    rpr_shape.set_visibility_ex("visible.reflection.glossy", cycles_visibility.glossy)
+    rpr_shape.set_visibility_ex("visible.refraction", cycles_visibility.transmission)
+    rpr_shape.set_visibility_ex("visible.refraction.glossy", cycles_visibility.transmission)
+    rpr_shape.set_visibility_ex("visible.diffuse", cycles_visibility.diffuse)
+    rpr_shape.set_shadow(cycles_visibility.shadow)
+
+    obj.rpr.set_catchers(rpr_shape)
+
+
 def sync_visibility(rpr_context, obj: bpy.types.Object, rpr_shape: pyrpr.Shape, indirect_only: bool = False, use_contour: bool = False):
     from rprblender.engine.viewport_engine import ViewportEngine
 
@@ -267,7 +284,7 @@ def sync_visibility(rpr_context, obj: bpy.types.Object, rpr_shape: pyrpr.Shape,
     if not rpr_shape.is_visible:
         return
 
-    obj.rpr.export_visibility(rpr_shape, indirect_only)
+    export_visibility(obj, rpr_shape, indirect_only)
     obj.rpr.export_subdivision(rpr_shape)
 
     if use_contour:

src/rprblender/export/mesh.py

@@ -410,20 +410,28 @@ class ShaderNodeBsdfVelvet(RuleNodeParser):
     # inputs: Color, Sigma
 
     nodes = {
+        "ONE_MINUS_SIGMA": {
+            "type": "-",
+            "params": {
+                pyrpr.MATERIAL_INPUT_COLOR0: 1.0,
+                pyrpr.MATERIAL_INPUT_COLOR1: "inputs.Sigma",
+            }
+        },
+
         "BSDF": {
             "type": pyrpr.MATERIAL_NODE_UBERV2,
             "params": {
                 pyrpr.MATERIAL_INPUT_UBER_DIFFUSE_COLOR: "inputs.Color",
-                pyrpr.MATERIAL_INPUT_UBER_DIFFUSE_WEIGHT: "inputs.Sigma",
+                pyrpr.MATERIAL_INPUT_UBER_DIFFUSE_WEIGHT: "nodes.ONE_MINUS_SIGMA",
                 pyrpr.MATERIAL_INPUT_UBER_DIFFUSE_NORMAL: "normal:inputs.Normal",
+                pyrpr.MATERIAL_INPUT_UBER_DIFFUSE_ROUGHNESS: 1.0,
                 pyrpr.MATERIAL_INPUT_UBER_REFLECTION_WEIGHT: 0.0,
-                pyrpr.MATERIAL_INPUT_UBER_SHEEN_WEIGHT: 1.0,
-                pyrpr.MATERIAL_INPUT_UBER_SHEEN_TINT: "inputs.Sigma",
+                pyrpr.MATERIAL_INPUT_UBER_SHEEN_WEIGHT: "inputs.Sigma",
+                pyrpr.MATERIAL_INPUT_UBER_SHEEN_TINT: 1.0,
                 pyrpr.MATERIAL_INPUT_UBER_SHEEN: "inputs.Color"
             }
         }
     }
-    # TODO: Has to be fixed, probably diffuse is not needed here
 
 
 class ShaderNodeEmission(RuleNodeParser):
@@ -861,28 +869,37 @@ def export(self):
         base_color = self.get_input_value('Color')
 
         rotation_angle = self.get_input_value('Offset')
-        roughness_u = self.get_input_value('RoughnessU')
-        roughness_v = self.get_input_value('RoughnessV')
+        roughness_u = self.get_input_value('RoughnessU').clamp(0.001, 1.0)
+        roughness_v = self.get_input_value('RoughnessV').clamp(0.001, 1.0)
 
         # TODO: use Tangent input
 
         # Treat reflection as WARD shader 
         if component == 'Reflection':
-            rpr_node = self.create_node(pyrpr.MATERIAL_NODE_WARD)
-            rpr_node.set_input(pyrpr.MATERIAL_INPUT_ROUGHNESS_X, roughness_u)
-            rpr_node.set_input(pyrpr.MATERIAL_INPUT_ROUGHNESS_Y, roughness_v)
-            rpr_node.set_input(pyrpr.MATERIAL_INPUT_ROTATION, rotation_angle)
-            rpr_node.set_input(pyrpr.MATERIAL_INPUT_COLOR, base_color)
+            rpr_node = self._create_ward_node(base_color, roughness_u, roughness_v, rotation_angle)
+        else:
+            roughness = (roughness_u + roughness_v) * 0.5
+            rpr_node = self._create_transmission_node(base_color, roughness)
+
+        return rpr_node
+
+    def export_rpr2(self):
+        component = self.node.component
+        base_color = self.get_input_value('Color')
+
+        rotation_angle = self.get_input_value('Offset')
+        roughness_u = self.get_input_value('RoughnessU').clamp(0.001, 1.0)
+        roughness_v = self.get_input_value('RoughnessV').clamp(0.001, 1.0)
+
+        # Treat reflection as and Uber shader with anisotropic reflection
+        if component == 'Reflection':
+            rotation_angle = 0.5 - rotation_angle % math.pi  # fit angle to the range [-0.5..+0.5]
 
+            rpr_node = self._create_aniso_reflection_node(base_color, roughness_u, roughness_v,
+                                                          rotation_angle)
         else:
-            rpr_node = self.create_node(pyrpr.MATERIAL_NODE_UBERV2, {
-                pyrpr.MATERIAL_INPUT_UBER_DIFFUSE_WEIGHT: 0.0,
-                pyrpr.MATERIAL_INPUT_UBER_DIFFUSE_COLOR: base_color,
-                pyrpr.MATERIAL_INPUT_UBER_DIFFUSE_ROUGHNESS: 1.0,
-                pyrpr.MATERIAL_INPUT_UBER_REFLECTION_WEIGHT: 0.0,
-                pyrpr.MATERIAL_INPUT_UBER_BACKSCATTER_WEIGHT: 1.0,
-                pyrpr.MATERIAL_INPUT_UBER_BACKSCATTER_COLOR: base_color,
-            })
+            roughness = (roughness_u + roughness_v) * 0.5
+            rpr_node = self._create_transmission_node(base_color, roughness)
 
         return rpr_node
 
@@ -894,7 +911,7 @@ def export_hybrid(self):
 
         rpr_node = self.create_node(pyrpr.MATERIAL_NODE_UBERV2)
         rpr_node.set_input(pyrpr.MATERIAL_INPUT_UBER_DIFFUSE_WEIGHT, 0.0)
-            
+
         if component == 'Reflection':
             rpr_node.set_input(pyrpr.MATERIAL_INPUT_UBER_REFLECTION_WEIGHT, 1.0)
             rpr_node.set_input(pyrpr.MATERIAL_INPUT_UBER_REFLECTION_COLOR, color)
@@ -904,6 +921,53 @@ def export_hybrid(self):
 
         return rpr_node
 
+    def _create_ward_node(self, base_color, roughness_u, roughness_v, rotation_angle):
+        rpr_node = self.create_node(pyrpr.MATERIAL_NODE_WARD)
+        rpr_node.set_input(pyrpr.MATERIAL_INPUT_ROUGHNESS_X, roughness_u)
+        rpr_node.set_input(pyrpr.MATERIAL_INPUT_ROUGHNESS_Y, roughness_v)
+        rpr_node.set_input(pyrpr.MATERIAL_INPUT_ROTATION, rotation_angle)
+        rpr_node.set_input(pyrpr.MATERIAL_INPUT_COLOR, base_color)
+        return rpr_node
+
+    def _create_aniso_reflection_node(self, base_color, roughness_u, roughness_v, rotation_angle):
+        rotation_angle = 0.5 - rotation_angle % math.pi  # fit angle to the range [-0.5..+0.5]
+
+        rough_max = roughness_v.max(roughness_u)
+        rough_min = roughness_v.min(roughness_u)
+
+        anisotropy = 0
+        if not roughness_u.data == roughness_v.data:
+            anisotropy = (rough_max - rough_min).clamp(0.001, 1.0)  # limit anisotropy amount
+
+        # a rough approximation of reflection roughness
+        rough_med = (roughness_u + roughness_v) * 0.5
+        rough_aniso = (rough_min + rough_med) * 0.5
+
+        rpr_node = self.create_node(pyrpr.MATERIAL_NODE_UBERV2)
+        rpr_node.set_input(pyrpr.MATERIAL_INPUT_UBER_DIFFUSE_WEIGHT, 0.0)
+
+        rpr_node.set_input(pyrpr.MATERIAL_INPUT_UBER_REFLECTION_WEIGHT, 1.0)
+        rpr_node.set_input(pyrpr.MATERIAL_INPUT_UBER_REFLECTION_COLOR, base_color)
+        rpr_node.set_input(pyrpr.MATERIAL_INPUT_UBER_REFLECTION_ROUGHNESS, rough_aniso)
+        rpr_node.set_input(pyrpr.MATERIAL_INPUT_UBER_REFLECTION_ANISOTROPY, anisotropy)
+        rpr_node.set_input(pyrpr.MATERIAL_INPUT_UBER_REFLECTION_ANISOTROPY_ROTATION, rotation_angle)
+        rpr_node.set_input(pyrpr.MATERIAL_INPUT_UBER_REFLECTION_MODE,
+                           pyrpr.UBER_MATERIAL_IOR_MODE_METALNESS)
+        rpr_node.set_input(pyrpr.MATERIAL_INPUT_UBER_REFLECTION_METALNESS, 1.0)
+
+        return rpr_node
+
+    def _create_transmission_node(self, base_color, roughness):
+        rpr_node = self.create_node(pyrpr.MATERIAL_NODE_UBERV2, {
+            pyrpr.MATERIAL_INPUT_UBER_DIFFUSE_WEIGHT: 0.0,
+            pyrpr.MATERIAL_INPUT_UBER_DIFFUSE_COLOR: base_color,
+            pyrpr.MATERIAL_INPUT_UBER_DIFFUSE_ROUGHNESS: roughness,
+            pyrpr.MATERIAL_INPUT_UBER_REFLECTION_WEIGHT: 0.0,
+            pyrpr.MATERIAL_INPUT_UBER_BACKSCATTER_WEIGHT: 1.0,
+            pyrpr.MATERIAL_INPUT_UBER_BACKSCATTER_COLOR: base_color,
+        })
+        return rpr_node
+
 
 class ShaderNodeNewGeometry(RuleNodeParser):
     # outputs: Position, Normal, Tangent, True Normal, Incoming, Parametric, Backfacing, Pointiness

src/rprblender/nodes/blender_nodes.py

@@ -17,7 +17,7 @@
 import bpy
 import pyrpr
 
-from rprblender.engine.context import RPRContext
+from rprblender.engine.context import RPRContext, RPRContext2
 from rprblender.engine.context_hybrid import RPRContext as RPRContextHybrid
 from .node_item import NodeItem
 
@@ -292,6 +292,8 @@ def final_export(self):
             node_item = self.export_muted()
         elif isinstance(self.rpr_context, RPRContextHybrid):
             node_item = self.export_hybrid()
+        elif isinstance(self.rpr_context, RPRContext2):
+            node_item = self.export_rpr2()
         else:
             node_item = self.export()
         rpr_node = node_item.data if node_item else None
@@ -310,6 +312,9 @@ def export(self) -> [NodeItem, None]:
     def export_hybrid(self) -> [NodeItem, None]:
         return self.export()
 
+    def export_rpr2(self) -> [NodeItem, None]:
+        return self.export()
+
     def export_muted(self) -> [NodeItem, None]:
         rpr_node = super().export_muted()
         return self.node_item(rpr_node) if rpr_node is not None else None