Merge pull request #378 from GPUOpen-LibrariesAndSDKs/Release_October_2021

Release october 2021

Author: bsavery

RadeonProRenderSDK

@@ -23,7 +23,8 @@
     int rprsExport(char const * rprsFileName, void * context, void * scene,
                     int extraCustomParam_int_number, char const * * extraCustomParam_int_names,
                     int const * extraCustomParam_int_values, int extraCustomParam_float_number,
-                    char const * * extraCustomParam_float_names, float const * extraCustomParam_float_values, unsigned int exportFlags);""")
+                    char const * * extraCustomParam_float_names, float const * extraCustomParam_float_values,
+                    unsigned int exportFlags, void * rprsCtx);""")
 
 if __name__ == "__main__":
 

src/bindings/pyrpr/rpr_load_store.py

@@ -657,9 +657,38 @@ def __init__(self, context, vertices, normals, uvs: List[np.array],
                  vertex_indices, normal_indices, uv_indices: List[np.array],
                  num_face_vertices, mesh_info):
         super().__init__(context)
-        self.poly_count = len(num_face_vertices)
 
-        if len(uvs) > 1 or mesh_info:
+        self.poly_count = 0 if vertices is None else len(num_face_vertices) 
+
+        mesh_info_ptr = ffi.NULL
+        if mesh_info:
+            mesh_info_ptr = ffi.new(f"rpr_mesh_info[{2 * len(mesh_info) + 1}]")
+            i = 0
+            for key, val in mesh_info.items():
+                mesh_info_ptr[i] = key
+                mesh_info_ptr[i + 1] = val
+                i += 2
+            mesh_info_ptr[i] = 0
+
+        if vertices is None:
+            ContextCreateMeshEx2(
+                self.context,
+                ffi.NULL, 0, 0,
+                ffi.NULL, 0, 0,
+                ffi.NULL, 0, 0,
+                0,
+                ffi.NULL, ffi.NULL,
+                ffi.NULL,
+                ffi.NULL, 0,
+                ffi.NULL, 0,
+                ffi.NULL, ffi.NULL,
+                ffi.NULL, 0,
+                mesh_info_ptr,
+                self
+            )
+            return
+
+        if len(uvs) > 1 or mesh_info_ptr:
             # several UVs set present
             texcoords_layers_num = len(uvs)
             texcoords_uvs = ffi.new("float *[]", texcoords_layers_num)
@@ -675,14 +704,6 @@ def __init__(self, context, vertices, normals, uvs: List[np.array],
                 texcoords_ind[i] = ffi.cast('rpr_int *', uv_indices[i].ctypes.data)
                 texcoords_ind_nbytes[i] = uv_indices[i][0].nbytes
 
-            mesh_info_ptr = ffi.new(f"rpr_mesh_info[{2 * len(mesh_info) + 1}]")
-            i = 0
-            for key, val in mesh_info.items():
-                mesh_info_ptr[i] = key
-                mesh_info_ptr[i + 1] = val
-                i += 2
-            mesh_info_ptr[i] = 0
-
             ContextCreateMeshEx2(
                 self.context,
                 ffi.cast("float *", vertices.ctypes.data), len(vertices), vertices[0].nbytes,
@@ -1119,6 +1140,8 @@ def delete(self):
                 MaterialNodeSetInputImageDataByKey(self, name, None)
             elif isinstance(value, Buffer):
                 MaterialNodeSetInputBufferDataByKey(self, name, None)
+            elif isinstance(value, Grid):
+                MaterialNodeSetInputGridDataByKey(self, name, None)
         self.inputs.clear()
 
         super().delete()
@@ -1140,6 +1163,8 @@ def set_input(self, name, value):
             MaterialNodeSetInputImageDataByKey(self, name, value)
         elif isinstance(value, Buffer):
             MaterialNodeSetInputBufferDataByKey(self, name, value)
+        elif isinstance(value, Grid):
+            MaterialNodeSetInputGridDataByKey(self, name, value)
         else:
             raise TypeError("Incorrect type for MaterialNodeSetInput*", self, name, value)
 

src/bindings/pyrpr/src/pyrpr.py

@@ -39,4 +39,4 @@ def export(name, context, scene, flags):
     # RPRLOADSTORE_EXPORTFLAG_COMPRESS_IMAGE_LEVEL_2 (1 << 2) - image data will be lossy compressed during export
     #  note: without any of above flags images will not be exported.
     return lib.rprsExport(pyrpr.encode(name), context._get_handle(), scene._get_handle(),
-                          0, ffi.NULL, ffi.NULL, 0, ffi.NULL, ffi.NULL, flags)
+                          0, ffi.NULL, ffi.NULL, 0, ffi.NULL, ffi.NULL, flags, ffi.NULL)

src/bindings/pyrpr/src/pyrpr_load_store.py

@@ -675,7 +675,8 @@ def get_rif_sdk(base=Path()):
                  'RPR_UV_CAMERA_SET_CHART_INDEX_FUNC_NAME',
                  'RPR_CONTEXT_CREATE_FRAMEBUFFER_TYPED_FUNC_NAME',
                  'RPR_MATERIAL_SET_INPUT_BY_S_KEY_FUNC_NAME',
-                 'RPR_MATERIALX_SET_ADDRESS_FUNC_NAME',]
+                 'RPR_MATERIALX_SET_FILE_FUNC_NAME',
+                 'RPR_MATERIALX_SET_FILE_AS_BUFFER_FUNC_NAME',]
     )
 
     export(

src/bindings/pyrpr/src/pyrprapi.py

@@ -20,7 +20,7 @@
 bl_info = {
     "name": "Radeon ProRender",
     "author": "AMD",
-    "version": (3, 2, 2),
+    "version": (3, 3, 0),
     "blender": (2, 80, 0),
     "location": "Info header, render engine menu",
     "description": "Radeon ProRender rendering plugin for Blender 2.8x",
@@ -211,7 +211,7 @@ def do_register_pass(aov):
             for i in range(3,6):
                 do_register_pass(cryptomatte_aovs[i])
 
-        if layer.rpr.use_contour_render:
+        if layer.rpr.use_contour_render and scene.rpr.render_quality == "FULL2":
             do_register_pass(layer.rpr.contour_info)
 
 

src/rprblender/__init__.py

@@ -29,7 +29,7 @@
 from rprblender.export import object, instance
 from . import image_filter
 
-from rprblender.utils import logging
+from rprblender.utils import logging, IS_LINUX
 log = logging.Log(tag='Engine')
 
 
@@ -83,28 +83,25 @@ def cache_blur_data(self, depsgraph: bpy.types.Depsgraph):
         position = scene.cycles.motion_blur_position
 
         if position == 'END':  # shutter closes at the current frame, so [N-1 .. N]
-            start_frame = scene.frame_current - 1
-            subframe = 0.0
+            from_frame = (scene.frame_current, 0.0)
+            to_frame = (scene.frame_current - 1, 0.0)
         elif position == 'START':  # shutter opens at the current frame, [N .. N+1]
-            start_frame = scene.frame_current
-            subframe = 0.0
+            from_frame = (scene.frame_current, 0.0)
+            to_frame = (scene.frame_current + 1, 0.0)
         else:  # 'CENTER'  # shutter is opened during current frame, [N-0.5 .. N+0.5]
-            start_frame = scene.frame_current - 1
-            subframe = 0.5
-        end_frame = start_frame + 1
+            from_frame = (scene.frame_current - 1, 0.5)
+            to_frame = (scene.frame_current, 0.5)
 
-        # set to next frame and cache blur data
-        self._set_scene_frame(scene, end_frame, subframe)
+        # set to to_frame and cache blur data
+        self._set_scene_frame(scene, *to_frame)
 
-        try:
-            for obj in self.depsgraph_objects(depsgraph, with_camera=True):
-                object.cache_blur_data(self.rpr_context, obj)
+        for obj in self.depsgraph_objects(depsgraph, with_camera=True):
+            object.cache_blur_data(self.rpr_context, obj)
 
-            for inst in self.depsgraph_instances(depsgraph):
-                instance.cache_blur_data(self.rpr_context, inst)
+        for inst in self.depsgraph_instances(depsgraph):
+            instance.cache_blur_data(self.rpr_context, inst)
 
-        finally:
-            self._set_scene_frame(scene, start_frame, subframe)
+        self._set_scene_frame(scene, *from_frame)
 
     def _set_scene_frame(self, scene, frame, subframe=0.0):
         self.rpr_engine.frame_set(frame, subframe)
@@ -401,12 +398,16 @@ def setup_upscale_filter(self, settings):
         return True
 
     def _enable_upscale_filter(self, settings):
+        import pyrprimagefilters as rif
         width, height = settings['resolution']
 
         self.rpr_context.enable_aov(pyrpr.AOV_COLOR)
 
+        # freeze on Ubuntu with rif.COMPUTE_TYPE_FLOAT16
         self.upscale_filter = image_filter.ImageFilterUpscale(
-            self.rpr_context.context, {'color'}, {}, {}, width, height)
+            self.rpr_context.context, {'color'}, {},
+            {'compute_type': rif.COMPUTE_TYPE_FLOAT if IS_LINUX else rif.COMPUTE_TYPE_FLOAT16},
+            width, height)
 
         self.upscale_filter.settings = settings
 

src/rprblender/engine/engine.py

@@ -48,6 +48,7 @@ def sync(self, context):
         depsgraph = context.evaluated_depsgraph_get()
         self.rpr_context.blender_data['depsgraph'] = depsgraph
         scene = depsgraph.scene
+        material_override = depsgraph.view_layer.material_override
 
         scene.rpr.init_rpr_context(self.rpr_context)
 
@@ -60,43 +61,53 @@ def sync(self, context):
         # cache blur data
         self.rpr_context.do_motion_blur = scene.render.use_motion_blur and \
             not math.isclose(scene.camera.data.rpr.motion_blur_exposure, 0.0)
-        if self.rpr_context.do_motion_blur:
-            self.cache_blur_data(depsgraph)
-            self.set_motion_blur_mode(scene)
-
-        # camera, objects, particles
-        for obj in self.depsgraph_objects(depsgraph, with_camera=True):
-            indirect_only = obj.original.indirect_only_get(view_layer=depsgraph.view_layer)
-            object.sync(self.rpr_context, obj, indirect_only=indirect_only,
-                        frame_current=scene.frame_current)
-
-        # instances
-        for inst in self.depsgraph_instances(depsgraph):
-            indirect_only = inst.parent.original.indirect_only_get(view_layer=depsgraph.view_layer)
-            instance.sync(self.rpr_context, inst, indirect_only=indirect_only,
-                          frame_current=scene.frame_current)
-
-        # rpr_context parameters
-        self.rpr_context.set_parameter(pyrpr.CONTEXT_PREVIEW, False)
-        scene.rpr.export_ray_depth(self.rpr_context)
-        self.rpr_context.texture_compression = scene.rpr.texture_compression
-
-        # EXPORT CAMERA
-        camera_key = object.key(scene.camera)   # current camera key
-        rpr_camera = self.rpr_context.create_camera(camera_key)
-        self.rpr_context.scene.set_camera(rpr_camera)
-        camera_obj = depsgraph.objects.get(camera_key, None)
-        if not camera_obj:
-            camera_obj = scene.camera
-
-        camera_data = camera.CameraData.init_from_camera(camera_obj.data, camera_obj.matrix_world,
-                                                         self.rpr_context.width / self.rpr_context.height)
-        camera_data.export(rpr_camera)
-
-        if self.rpr_context.do_motion_blur:
-            rpr_camera.set_exposure(scene.camera.data.rpr.motion_blur_exposure)
-            object.export_motion_blur(self.rpr_context, camera_key,
-                                      object.get_transform(camera_obj))
+
+        # with enabled motion blur, cache_blur_data() can change frame,
+        # therefore we store current frame and set it back after export process
+        cur_frame = (scene.frame_current, 0.0)
+
+        try:
+            if self.rpr_context.do_motion_blur:
+                self.cache_blur_data(depsgraph)
+                self.set_motion_blur_mode(scene)
+
+            # camera, objects, particles
+            for obj in self.depsgraph_objects(depsgraph, with_camera=True):
+                indirect_only = obj.original.indirect_only_get(view_layer=depsgraph.view_layer)
+                object.sync(self.rpr_context, obj, indirect_only=indirect_only, material_override=material_override,
+                            frame_current=scene.frame_current)
+
+            # instances
+            for inst in self.depsgraph_instances(depsgraph):
+                indirect_only = inst.parent.original.indirect_only_get(view_layer=depsgraph.view_layer)
+                instance.sync(self.rpr_context, inst, indirect_only=indirect_only, material_override=material_override,
+                              frame_current=scene.frame_current)
+
+            # rpr_context parameters
+            self.rpr_context.set_parameter(pyrpr.CONTEXT_PREVIEW, False)
+            scene.rpr.export_ray_depth(self.rpr_context)
+            self.rpr_context.texture_compression = scene.rpr.texture_compression
+
+            # EXPORT CAMERA
+            camera_key = object.key(scene.camera)   # current camera key
+            rpr_camera = self.rpr_context.create_camera(camera_key)
+            self.rpr_context.scene.set_camera(rpr_camera)
+            camera_obj = depsgraph.objects.get(camera_key, None)
+            if not camera_obj:
+                camera_obj = scene.camera
+
+            camera_data = camera.CameraData.init_from_camera(camera_obj.data, camera_obj.matrix_world,
+                                                             self.rpr_context.width / self.rpr_context.height)
+            camera_data.export(rpr_camera)
+
+            if self.rpr_context.do_motion_blur:
+                rpr_camera.set_exposure(scene.camera.data.rpr.motion_blur_exposure)
+                object.export_motion_blur(self.rpr_context, camera_key,
+                                          object.get_transform(camera_obj))
+
+        finally:
+            if self.rpr_context.do_motion_blur:
+                self._set_scene_frame(scene, *cur_frame)
 
         # adaptive subdivision will be limited to the current scene render size
         self.rpr_context.enable_aov(pyrpr.AOV_COLOR)

src/rprblender/engine/export_engine.py

@@ -110,9 +110,10 @@ def sync(self, depsgraph):
         camera.sync(self.rpr_context, depsgraph.objects[depsgraph.scene.camera.name])
 
         # export world only if active_material.use_preview_world is enabled
-        preview_obj = next(obj for obj in self.depsgraph_objects(depsgraph)
-                               if obj.name.startswith('preview_'))
-        if preview_obj.active_material and preview_obj.active_material.use_preview_world:
+        preview_obj = next((obj for obj in self.depsgraph_objects(depsgraph)
+                            if obj.name.startswith('preview_')), None)
+        if preview_obj and settings_scene.world and preview_obj.active_material \
+                and preview_obj.active_material.use_preview_world:
             world.sync(self.rpr_context, settings_scene.world)
 
         self.rpr_context.enable_aov(pyrpr.AOV_COLOR)