fix: Fix the color tone for tile rendering.

Signed-off-by: Karthik Bekal Pattathana <133984042+karthikbekalp@users.noreply.github.com>

Author: karthikbekalp

src/deadline/cinema4d_adaptor/Cinema4DClient/tile_rendering.py

@@ -228,13 +228,16 @@ def finalize_tile_render(
         render_data: The render data object (to restore output paths).
         frame: The current frame number.
     """
-    # Restore the OCIO bake flag to its original value
-    if ctx.orig_bake_flag is not None:
-        rd[c4d.RDATA_BAKE_OCIO_VIEW_TRANSFORM_RENDER] = ctx.orig_bake_flag
-
-    if ctx.requires_baking:
-        baked = c4d.documents.BakeOcioViewToBitmap(bm, rd, c4d.SAVEBIT_NONE)
-        bm = baked or bm
+    try:
+        if ctx.requires_baking:
+            # setup_tile_render disabled the render-time bake. It must remain
+            # disabled here or BakeOcioViewToBitmap assumes the bitmap was
+            # already baked and returns None.
+            baked = c4d.documents.BakeOcioViewToBitmap(bm, rd, c4d.SAVEBIT_NONE)
+            bm = baked or bm
+    finally:
+        if ctx.orig_bake_flag is not None:
+            rd[c4d.RDATA_BAKE_OCIO_VIEW_TRANSFORM_RENDER] = ctx.orig_bake_flag
 
     if c4d.GetC4DVersion() >= C4D_VERSION_2025_2:
         bm.SetColorProfile(c4d.bitmaps.ColorProfile(), c4d.COLORPROFILE_INDEX_DISPLAYSPACE)

test/integ/fixtures/auto_open_submitter/AutoOpenSubmitter.pyp

@@ -32,6 +32,7 @@ Where the submitter's AWS calls go depends on the test mode:
 
 The test then drives the resulting Qt dialog with xa11y.
 """
+
 import os
 import traceback
 
@@ -201,6 +202,11 @@ def _load_active_scene(scene_path):
             c4d.documents.InsertBaseDocument(doc)
             c4d.documents.SetActiveDocument(doc)
             c4d.EventAdd()
+            if doc.GetChanged():
+                # The fixture was just generated and saved. Older C4D versions
+                # can mark Redshift node materials changed while loading them.
+                doc[c4d.DOCUMENT_USERCHANGE] = False
+                _diag("cleared generated scene changed state after load")
             _diag("scene loaded and set as active")
         else:
             _diag(f"LoadDocument returned None for {scene_path}")

test/integ/ocio_scene.py

@@ -0,0 +1,354 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+"""Shared Physical OCIO studio scene for Cinema 4D integration tests."""
+
+from __future__ import annotations
+
+import math
+import os
+from typing import Any
+
+import c4d
+
+WIDTH = 384
+HEIGHT = 216
+ACES_DEFAULT_VIEW_TRANSFORM = 0
+ACES_UNTONE_MAPPED_VIEW_TRANSFORM = 3
+PHYSICAL_RENDERER_ID = 1023342
+
+
+def _configure_physical_renderer(render_data: Any) -> None:
+    """Use fixed sampling so repeated renders produce stable image baselines."""
+    render_data[c4d.RDATA_RENDERENGINE] = PHYSICAL_RENDERER_ID
+
+    physical_settings = render_data.GetFirstVideoPost()
+    while physical_settings is not None:
+        if physical_settings.GetType() == PHYSICAL_RENDERER_ID:
+            break
+        physical_settings = physical_settings.GetNext()
+
+    if physical_settings is None:
+        physical_settings = c4d.documents.BaseVideoPost(PHYSICAL_RENDERER_ID)
+        if physical_settings is None:
+            raise RuntimeError("Failed to create Physical renderer settings")
+        render_data.InsertVideoPostLast(physical_settings)
+
+    physical_settings[c4d.VP_XMB_RAYTRACING_SAMPLER] = c4d.VP_XMB_RAYTRACING_SAMPLER_FIXED
+    physical_settings[c4d.VP_XMB_RAYTRACING_QUALITY] = c4d.VP_XMB_RAYTRACING_QUALITY_CUSTOM
+    physical_settings[c4d.VP_XMB_RAYTRACING_SAMPLES] = 4.0
+
+
+def _physical_material(
+    doc: Any,
+    name: str,
+    color: tuple[float, float, float],
+    *,
+    roughness: float = 0.35,
+    metalness: float = 0.0,
+    emission: tuple[float, float, float] | None = None,
+) -> Any:
+    material = c4d.BaseMaterial(c4d.Mmaterial)
+    material.SetName(name)
+
+    material[c4d.MATERIAL_USE_COLOR] = emission is None
+    material[c4d.MATERIAL_USE_LUMINANCE] = emission is not None
+    material[c4d.MATERIAL_USE_REFLECTION] = False
+
+    if emission is not None:
+        peak = max(emission)
+        if peak <= 0.0:
+            raise ValueError("emission must contain at least one positive channel")
+        material[c4d.MATERIAL_LUMINANCE_COLOR] = c4d.Vector(
+            *(channel / peak for channel in emission)
+        )
+        material[c4d.MATERIAL_LUMINANCE_BRIGHTNESS] = peak
+        material[c4d.MATERIAL_USE_SPECULAR] = False
+    else:
+        material[c4d.MATERIAL_COLOR_COLOR] = c4d.Vector(*color)
+        material[c4d.MATERIAL_COLOR_BRIGHTNESS] = 1.0
+        material[c4d.MATERIAL_COLOR_MODEL] = c4d.MATERIAL_COLOR_MODEL_ORENNAYAR
+        material[c4d.MATERIAL_COLOR_ROUGHNESS] = roughness
+        material[c4d.MATERIAL_USE_SPECULAR] = True
+        material[c4d.MATERIAL_SPECULAR_MODE] = (
+            c4d.MATERIAL_SPECULAR_MODE_METAL
+            if metalness >= 0.5
+            else c4d.MATERIAL_SPECULAR_MODE_PLASTIC
+        )
+        material[c4d.MATERIAL_SPECULAR_COLOR] = (
+            c4d.Vector(*color) if metalness >= 0.5 else c4d.Vector(1.0)
+        )
+        material[c4d.MATERIAL_SPECULAR_BRIGHTNESS] = 0.2 + (0.6 * metalness)
+        material[c4d.MATERIAL_SPECULAR_WIDTH] = max(0.05, min(1.0, roughness))
+
+    doc.InsertMaterial(material)
+    return material
+
+
+def _attach_material(obj: Any, material: Any) -> None:
+    tag = c4d.TextureTag()
+    tag.SetMaterial(material)
+    obj.InsertTag(tag)
+
+
+def _add_cube(
+    doc: Any,
+    name: str,
+    size: tuple[float, float, float],
+    position: tuple[float, float, float],
+    material: Any,
+    *,
+    rotation: tuple[float, float, float] = (0.0, 0.0, 0.0),
+    fillet: float = 0.0,
+) -> Any:
+    cube = c4d.BaseObject(c4d.Ocube)
+    cube.SetName(name)
+    cube[c4d.PRIM_CUBE_LEN] = c4d.Vector(*size)
+    if fillet > 0.0:
+        cube[c4d.PRIM_CUBE_DOFILLET] = True
+        cube[c4d.PRIM_CUBE_FRAD] = fillet
+        cube[c4d.PRIM_CUBE_SUBF] = 4
+    cube.SetAbsPos(c4d.Vector(*position))
+    cube.SetAbsRot(c4d.Vector(*(math.radians(value) for value in rotation)))
+    _attach_material(cube, material)
+    doc.InsertObject(cube)
+    return cube
+
+
+def _point_at(obj: Any, target: tuple[float, float, float]) -> None:
+    direction = c4d.Vector(*target) - obj.GetAbsPos()
+    obj.SetAbsRot(c4d.utils.VectorToHPB(direction))
+
+
+def _add_area_light(
+    doc: Any,
+    name: str,
+    position: tuple[float, float, float],
+    target: tuple[float, float, float],
+    color: tuple[float, float, float],
+    intensity: float,
+    size: tuple[float, float],
+) -> None:
+    light = c4d.BaseObject(c4d.Olight)
+    light.SetName(name)
+    light[c4d.LIGHT_TYPE] = c4d.LIGHT_TYPE_AREA
+    light[c4d.LIGHT_COLOR] = c4d.Vector(*color)
+    light[c4d.LIGHT_BRIGHTNESS] = intensity
+    light[c4d.LIGHT_SHADOWTYPE] = c4d.LIGHT_SHADOWTYPE_AREA
+    light[c4d.LIGHT_AREADETAILS_SHAPE] = c4d.LIGHT_AREADETAILS_SHAPE_RECTANGLE
+    light[c4d.LIGHT_AREADETAILS_SIZEX] = size[0]
+    light[c4d.LIGHT_AREADETAILS_SIZEY] = size[1]
+    light[c4d.LIGHT_AREADETAILS_SHOWINRENDER] = False
+    light[c4d.LIGHT_AREADETAILS_SHOWINREFLECTION] = False
+    light.SetAbsPos(c4d.Vector(*position))
+    _point_at(light, target)
+    doc.InsertObject(light)
+
+
+def _build_geometry(doc: Any) -> None:
+    backdrop = _physical_material(
+        doc,
+        "Charcoal backdrop",
+        (0.028, 0.035, 0.05),
+        roughness=0.62,
+    )
+    floor = _physical_material(
+        doc,
+        "Neutral floor",
+        (0.12, 0.13, 0.15),
+        roughness=0.28,
+        metalness=0.15,
+    )
+    orange = _physical_material(
+        doc,
+        "Burnished orange",
+        (0.95, 0.09, 0.015),
+        roughness=0.2,
+        metalness=0.25,
+    )
+    cyan = _physical_material(
+        doc,
+        "Glossy cyan",
+        (0.015, 0.42, 0.72),
+        roughness=0.14,
+        metalness=0.05,
+    )
+    magenta = _physical_material(
+        doc,
+        "Matte magenta",
+        (0.72, 0.025, 0.2),
+        roughness=0.48,
+    )
+    green = _physical_material(
+        doc,
+        "Metallic green",
+        (0.025, 0.52, 0.13),
+        roughness=0.24,
+        metalness=0.7,
+    )
+    blue_emission = _physical_material(
+        doc,
+        "HDR blue strip",
+        (0.0, 0.0, 0.0),
+        emission=(0.02, 0.65, 6.0),
+    )
+
+    _add_cube(
+        doc,
+        "Backdrop",
+        (1300, 760, 30),
+        (0, 90, 430),
+        backdrop,
+    )
+    _add_cube(
+        doc,
+        "Floor",
+        (1300, 30, 1050),
+        (0, -210, 50),
+        floor,
+        fillet=8,
+    )
+    _add_cube(
+        doc,
+        "Diagonal HDR strip",
+        (980, 24, 18),
+        (0, 115, 395),
+        blue_emission,
+        rotation=(0, 0, -8),
+        fillet=6,
+    )
+
+    sphere = c4d.BaseObject(c4d.Osphere)
+    sphere.SetName("Orange sphere")
+    sphere[c4d.PRIM_SPHERE_RAD] = 150
+    sphere[c4d.PRIM_SPHERE_SUB] = 48
+    sphere.SetAbsPos(c4d.Vector(-285, -55, 45))
+    _attach_material(sphere, orange)
+    doc.InsertObject(sphere)
+
+    _add_cube(
+        doc,
+        "Cyan beveled cube",
+        (225, 225, 225),
+        (-35, -50, 60),
+        cyan,
+        rotation=(12, -24, 8),
+        fillet=24,
+    )
+
+    torus = c4d.BaseObject(c4d.Otorus)
+    torus.SetName("Green torus")
+    torus[c4d.PRIM_TORUS_OUTERRAD] = 150
+    torus[c4d.PRIM_TORUS_INNERRAD] = 48
+    torus[c4d.PRIM_TORUS_SEG] = 64
+    torus[c4d.PRIM_TORUS_CSUB] = 24
+    torus.SetAbsPos(c4d.Vector(285, -45, 75))
+    torus.SetAbsRot(c4d.Vector(math.radians(78), math.radians(-10), math.radians(16)))
+    _attach_material(torus, green)
+    doc.InsertObject(torus)
+
+    pyramid = c4d.BaseObject(c4d.Opyramid)
+    pyramid.SetName("Magenta pyramid")
+    pyramid[c4d.PRIM_PYRAMID_LEN] = c4d.Vector(230, 285, 230)
+    pyramid.SetAbsPos(c4d.Vector(115, 85, 205))
+    pyramid.SetAbsRot(c4d.Vector(0, math.radians(24), math.radians(-5)))
+    _attach_material(pyramid, magenta)
+    doc.InsertObject(pyramid)
+
+    exposure_values = (0.18, 1.0, 4.0, 16.0)
+    exposure_positions = (-300, -100, 100, 300)
+    for value, x_position in zip(exposure_values, exposure_positions):
+        swatch_material = _physical_material(
+            doc,
+            f"Exposure {value:g}",
+            (0.0, 0.0, 0.0),
+            emission=(value, value, value),
+        )
+        _add_cube(
+            doc,
+            f"Exposure swatch {value:g}",
+            (118, 42, 18),
+            (x_position, 285, 395),
+            swatch_material,
+            fillet=5,
+        )
+
+    target = (0, 10, 80)
+    _add_area_light(
+        doc,
+        "Warm key",
+        (-430, 430, -360),
+        target,
+        (1.0, 0.68, 0.48),
+        1.35,
+        (430, 430),
+    )
+    _add_area_light(
+        doc,
+        "Cool fill",
+        (470, 160, -220),
+        target,
+        (0.3, 0.62, 1.0),
+        0.8,
+        (340, 340),
+    )
+    _add_area_light(
+        doc,
+        "Magenta rim",
+        (60, 440, 360),
+        target,
+        (1.0, 0.18, 0.45),
+        0.6,
+        (280, 280),
+    )
+
+    camera = c4d.BaseObject(c4d.Ocamera)
+    camera.SetName("OCIO studio camera")
+    camera.SetAbsPos(c4d.Vector(0, 70, -1320))
+    _point_at(camera, (0, 35, 90))
+    camera[c4d.CAMERA_FOCUS] = 52.0
+    doc.InsertObject(camera)
+    doc.GetRenderBaseDraw().SetSceneCamera(camera)
+
+
+def build_ocio_scene(
+    output_dir: str,
+    scene_name: str,
+    view_transform: int,
+) -> None:
+    """Build and save the shared Physical OCIO scene."""
+    output_dir = os.path.abspath(output_dir)
+    os.makedirs(output_dir, exist_ok=True)
+
+    doc = c4d.documents.GetActiveDocument()
+    doc.Flush()
+    doc[c4d.DOCUMENT_COLOR_MANAGEMENT] = c4d.DOCUMENT_COLOR_MANAGEMENT_OCIO
+    doc[c4d.DOCUMENT_OCIO_PRESET] = c4d.DOCUMENT_OCIO_PRESET_ACES
+    doc[c4d.DOCUMENT_OCIO_VIEW_TRANSFORM] = view_transform
+
+    _build_geometry(doc)
+
+    render_data = doc.GetActiveRenderData()
+    _configure_physical_renderer(render_data)
+    render_data[c4d.RDATA_XRES] = WIDTH
+    render_data[c4d.RDATA_YRES] = HEIGHT
+    render_data[c4d.RDATA_FRAMEFROM] = c4d.BaseTime(1, doc.GetFps())
+    render_data[c4d.RDATA_FRAMETO] = c4d.BaseTime(1, doc.GetFps())
+    render_data[c4d.RDATA_FORMAT] = c4d.FILTER_PNG
+    render_data[c4d.RDATA_FORMATDEPTH] = c4d.RDATA_FORMATDEPTH_8
+    render_data[c4d.RDATA_ALPHACHANNEL] = False
+    render_data[c4d.RDATA_MULTIPASS_SAVEIMAGE] = False
+    if hasattr(c4d, "RDATA_BAKE_OCIO_VIEW_TRANSFORM_RENDER"):
+        render_data.GetDataInstance()[c4d.RDATA_BAKE_OCIO_VIEW_TRANSFORM_RENDER] = True
+
+    render_data[c4d.RDATA_PATH] = "renders/$prj"
+
+    scene_path = os.path.join(output_dir, scene_name)
+    doc.SetDocumentPath(output_dir)
+    doc.SetDocumentName(scene_name)
+    if not c4d.documents.SaveDocument(
+        doc,
+        scene_path,
+        c4d.SAVEDOCUMENTFLAGS_0,
+        c4d.FORMAT_C4DEXPORT,
+    ):
+        raise RuntimeError(f"Failed to save integration scene: {scene_path}")
+    c4d.EventAdd()