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,294 @@
+# 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,
+    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_PLASTIC
+        material[c4d.MATERIAL_SPECULAR_COLOR] = c4d.Vector(1.0)
+        material[c4d.MATERIAL_SPECULAR_BRIGHTNESS] = 0.25
+        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_omni_light(
+    doc: Any,
+    name: str,
+    position: tuple[float, float, float],
+    color: tuple[float, float, float],
+    intensity: float,
+) -> None:
+    light = c4d.BaseObject(c4d.Olight)
+    light.SetName(name)
+    light[c4d.LIGHT_TYPE] = c4d.LIGHT_TYPE_OMNI
+    light[c4d.LIGHT_COLOR] = c4d.Vector(*color)
+    light[c4d.LIGHT_BRIGHTNESS] = intensity
+    light.SetAbsPos(c4d.Vector(*position))
+    doc.InsertObject(light)
+
+
+def _build_geometry(doc: Any) -> None:
+    backdrop = _physical_material(
+        doc,
+        "Light studio backdrop",
+        (0.24, 0.27, 0.32),
+        roughness=0.55,
+    )
+    floor = _physical_material(
+        doc,
+        "Neutral floor",
+        (0.13, 0.15, 0.18),
+        roughness=0.4,
+    )
+    orange = _physical_material(
+        doc,
+        "Orange",
+        (0.95, 0.12, 0.025),
+        roughness=0.24,
+    )
+    blue = _physical_material(
+        doc,
+        "Blue",
+        (0.025, 0.34, 0.9),
+        roughness=0.2,
+    )
+    green = _physical_material(
+        doc,
+        "Green",
+        (0.035, 0.62, 0.18),
+        roughness=0.32,
+    )
+    hdr_reference = _physical_material(
+        doc,
+        "HDR reference",
+        (0.0, 0.0, 0.0),
+        emission=(4.0, 3.2, 2.2),
+    )
+
+    _add_cube(
+        doc,
+        "Backdrop",
+        (1100, 620, 30),
+        (0, 75, 390),
+        backdrop,
+    )
+    _add_cube(
+        doc,
+        "Floor",
+        (1100, 30, 800),
+        (0, -155, 40),
+        floor,
+        fillet=6,
+    )
+    _add_cube(
+        doc,
+        "HDR reference bar",
+        (420, 48, 18),
+        (0, 225, 365),
+        hdr_reference,
+        fillet=5,
+    )
+
+    sphere = c4d.BaseObject(c4d.Osphere)
+    sphere.SetName("Orange sphere")
+    sphere[c4d.PRIM_SPHERE_RAD] = 120
+    sphere[c4d.PRIM_SPHERE_SUB] = 36
+    sphere.SetAbsPos(c4d.Vector(-245, -20, 40))
+    _attach_material(sphere, orange)
+    doc.InsertObject(sphere)
+
+    _add_cube(
+        doc,
+        "Blue beveled cube",
+        (205, 205, 205),
+        (0, -35, 45),
+        blue,
+        rotation=(8, -20, 6),
+        fillet=22,
+    )
+
+    torus = c4d.BaseObject(c4d.Otorus)
+    torus.SetName("Green torus")
+    torus[c4d.PRIM_TORUS_OUTERRAD] = 125
+    torus[c4d.PRIM_TORUS_INNERRAD] = 42
+    torus[c4d.PRIM_TORUS_SEG] = 64
+    torus[c4d.PRIM_TORUS_CSUB] = 24
+    torus.SetAbsPos(c4d.Vector(245, -15, 55))
+    torus.SetAbsRot(c4d.Vector(math.radians(72), math.radians(-8), math.radians(14)))
+    _attach_material(torus, green)
+    doc.InsertObject(torus)
+
+    _add_omni_light(
+        doc,
+        "Warm key light",
+        (-340, 360, -360),
+        (1.0, 0.92, 0.82),
+        1.25,
+    )
+    _add_omni_light(
+        doc,
+        "Cool fill light",
+        (380, 130, -220),
+        (0.62, 0.78, 1.0),
+        0.7,
+    )
+    _add_omni_light(
+        doc,
+        "Front fill light",
+        (0, 25, -520),
+        (1.0, 1.0, 1.0),
+        0.3,
+    )
+
+    camera = c4d.BaseObject(c4d.Ocamera)
+    camera.SetName("OCIO studio camera")
+    camera.SetAbsPos(c4d.Vector(0, 55, -1080))
+    _point_at(camera, (0, 5, 70))
+    camera[c4d.CAMERA_FOCUS] = 50.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()