Cinema 4D MCP

Source of Truth

This skill targets Vlad's fork of Cinema 4D MCP: vladmdgolam/cinema4d-mcp.

Relevant fork additions:

• inspect_redshift_materials - read-only Redshift inspector for assignments, preview-derived colors, readable description/container fields, and best-effort graph probing. Note: this tool may skip RS materials as not_redshift_like (type 5703) — use execute_python_script with the maxon API for full RS node graph extraction instead (see Redshift Material Extraction section).
• Duplicate-safe material targeting - the inspector accepts material_index and returns stable scene indices plus duplicate-name hints when names collide.
• Redshift GraphView fallback - when node-space access fails but import redshift works, the inspector falls back to redshift.GetRSMaterialNodeMaster(...) and reports GraphView nodes plus resolved connections.
• The loaded C4D plugin may lag behind the repo copy. After plugin edits, restart Cinema 4D before trusting new tool behavior.

Tool Selection

Use structured MCP tools (get_scene_info, list_objects, add_primitive, etc.) for simple operations.

Use execute_python_script as the primary path for non-trivial extraction. It avoids wrapper/schema mismatches, gives full c4d + maxon API access, and allows proper frame stepping control. This is especially important for Redshift material extraction — the maxon node-space API gives full access to RS node graphs, which other tools may miss.

Use inspect_redshift_materials as a quick overview of material assignments and preview colors, but be aware it may skip RS materials as not_redshift_like if they use type 5703 wrappers. For full RS node graph data, use execute_python_script with the maxon API pattern documented in the Redshift section.

Health Check (Always First)

1. get_scene_info - verify connection
2. execute_python_script with print("ok") - verify Python works
3. If both work, extraction is possible even when other tools are broken

Critical Rules

1. World vs Local Coordinates

GeGetMoData() returns cloner-local positions. Always apply global matrix:

mg = cloner.GetMg()
world_pos = mg * m.off  # LOCAL -> WORLD

Missing this shifts everything by the cloner's global offset.

2. Visibility Constants Are Swapped

• MODE_OFF = 1 (not 0!)
• MODE_ON = 0 (not 1!)
• MODE_UNDEF = 2 (default/inherit)

Always use c4d.MODE_OFF / c4d.MODE_ON, never raw integers.

3. Sequential Frame Stepping

MoGraph effectors accumulate state. Iterate 0->N sequentially:

for frame in range(start, end + 1):
    doc.SetTime(c4d.BaseTime(frame, fps))
    doc.ExecutePasses(None, True, True, True, c4d.BUILDFLAGS_NONE)
    # NOW read data

Never jump to arbitrary frames. Never skip ExecutePasses.

4. Split Heavy Bakes

MCP scripts timeout on large frame ranges (~20-30s default, some forks 60s). Bake in chunks (e.g., frames 0-200, then 200-400), combine afterward. Log progress with print().

5. Iterative Traversal Only

Use stack-based traversal. Recursive traversal hits Python recursion limits:

def find_obj(name):
    stack = [doc.GetFirstObject()]
    while stack:
        obj = stack.pop()
        while obj:
            if obj.GetName() == name:
                return obj
            if obj.GetDown():
                stack.append(obj.GetDown())
            obj = obj.GetNext()
    return None

6. API Version Compatibility

Constants differ between C4D versions. Use defensive checks:

if hasattr(c4d, "SCENEFILTER_ANIMATION"):
    ...

7. Check Render Visibility

Objects can be disabled via traffic lights (GetRenderMode()), RS Object tags, parent hierarchy inheritance, or Takes system.

Complete Animation Bake Workflow

This is the authoritative end-to-end procedure. Follow it in order — each step gates the next.

Step 1: Health Check

# Tool call: get_scene_info
# Then:
import c4d
print(doc.GetDocumentName(), doc.GetFps(), doc.GetMaxTime().GetFrame(doc.GetFps()))

Confirm: scene name resolves, fps is correct (typically 24/25/30), max frame is the expected end frame.

Step 2: Discover Animation Tracks

Before baking, confirm the cloner actually has animated effectors:

import c4d

def find_obj(name):
    stack = [doc.GetFirstObject()]
    while stack:
        obj = stack.pop()
        while obj:
            if obj.GetName() == name:
                return obj
            if obj.GetDown():
                stack.append(obj.GetDown())
            obj = obj.GetNext()
    return None

fps = doc.GetFps()
cloner = find_obj("MyClonerName")  # replace with actual name

# Check direct tracks on cloner
for t in cloner.GetCTracks():
    did = t.GetDescriptionID()
    ids = [int(did[i].id) for i in range(did.GetDepth())]
    curve = t.GetCurve()
    key_count = curve.GetKeyCount() if curve else 0
    print(f"Track IDs: {ids}, keys: {key_count}")

# Check effector children for their own tracks
child = cloner.GetDown()
while child:
    for t in child.GetCTracks():
        did = t.GetDescriptionID()
        ids = [int(did[i].id) for i in range(did.GetDepth())]
        print(f"  Effector '{child.GetName()}' track IDs: {ids}")
    child = child.GetNext()

If no tracks appear, the animation may be driven by fields or expressions — proceed to bake anyway; ExecutePasses will resolve those.

Step 3: Bake MoGraph (Sequential Frame Stepping)

import c4d
from c4d.modules import mograph as mo
import json

def find_obj(name):
    stack = [doc.GetFirstObject()]
    while stack:
        obj = stack.pop()
        while obj:
            if obj.GetName() == name:
                return obj
            if obj.GetDown():
                stack.append(obj.GetDown())
            obj = obj.GetNext()
    return None

def vec(v):
    return [float(v.x), float(v.y), float(v.z)]

fps = doc.GetFps()
start = 0
end = int(doc.GetMaxTime().GetFrame(fps))
cloner = find_obj("MyClonerName")
mg = cloner.GetMg()  # global matrix for LOCAL->WORLD

frames_data = {}

for frame in range(start, end + 1):
    doc.SetTime(c4d.BaseTime(frame, fps))
    doc.ExecutePasses(None, True, True, True, c4d.BUILDFLAGS_NONE)

    md = mo.GeGetMoData(cloner)
    if md is None:
        print(f"Frame {frame}: no MoData")
        continue

    matrices = md.GetArray(c4d.MODATA_MATRIX)
    clone_indices = md.GetArray(c4d.MODATA_CLONE)

    frame_clones = []
    for i, m in enumerate(matrices):
        world_pos = mg * m.off
        scale = (m.v1.GetLength() + m.v2.GetLength() + m.v3.GetLength()) / 3.0
        frame_clones.append({
            "index": i,
            "position": vec(world_pos),
            "scale": float(scale),
            "clone_index": float(clone_indices[i]) if clone_indices else None
        })

    frames_data[frame] = frame_clones
    if frame % 50 == 0:
        print(f"Baked frame {frame}/{end}")

print(f"Done. Total frames baked: {len(frames_data)}")

Step 4: Extract Keyframes (Optional — for sparse data)

If you need keyframe-only data rather than every-frame bake:

import c4d

fps = doc.GetFps()
obj = find_obj("MyObject")

keyframe_data = {}
for t in obj.GetCTracks():
    did = t.GetDescriptionID()
    ids = [int(did[i].id) for i in range(did.GetDepth())]
    curve = t.GetCurve()
    if not curve:
        continue
    keys = []
    for k in range(curve.GetKeyCount()):
        key = curve.GetKey(k)
        keys.append({
            "frame": key.GetTime().GetFrame(fps),
            "value": float(key.GetValue())
        })
    keyframe_data[str(ids)] = keys

print(json.dumps(keyframe_data))

Step 5: Export JSON

import json

output = {
    "scene": doc.GetDocumentName(),
    "fps": fps,
    "start_frame": start,
    "end_frame": end,
    "clone_count": len(frames_data.get(start, [])),
    "frames": frames_data
}

import tempfile, os
export_path = os.path.join(tempfile.gettempdir(), "mograph_export.json")
with open(export_path, "w") as f:
    json.dump(output, f)

print(f"Exported {len(frames_data)} frames to {export_path}")

Step 6: Validate

Run this after export to catch silent errors before handing data downstream:

import json, math

with open(export_path) as f:
    data = json.load(f)

fps = data["fps"]
start = data["start_frame"]
end = data["end_frame"]
expected_frames = end - start + 1
actual_frames = len(data["frames"])

errors = []

if actual_frames != expected_frames:
    errors.append(f"Frame count mismatch: expected {expected_frames}, got {actual_frames}")

nan_count = 0
for frame_key, clones in data["frames"].items():
    for clone in clones:
        for coord in clone["position"]:
            if math.isnan(coord) or math.isinf(coord):
                nan_count += 1
        if clone.get("clone_index") is not None:
            if not (0.0 <= clone["clone_index"] <= 1.0):
                errors.append(f"Frame {frame_key} clone {clone['index']}: clone_index out of range: {clone['clone_index']}")

if nan_count > 0:
    errors.append(f"NaN/Inf found in {nan_count} position coordinates")

if errors:
    for e in errors:
        print("ERROR:", e)
else:
    print("Validation passed.")
    print(f"  Frames: {actual_frames}, Clones per frame: {data['clone_count']}")

Validation Checklist

Before Baking

• Frame range set in scene (doc.GetMaxTime() returns expected end frame)
• All effectors active (check visibility traffic lights and Tags)
• No interfering Takes (doc.GetTakeData().GetCurrentTake() is the correct take)
• Test on small range (frames 0-10) first — confirm clone count and positions look right before running full bake

After Baking

• Total frame count equals end - start + 1 (no off-by-one, no gaps)
• No NaN or Inf values in position coordinates
• Clone indices are in range 0.0–1.0 (if using MODATA_CLONE)
• World positions make sense — spot-check frame 0 and last frame against viewport

MoGraph Extraction Pattern

import c4d
from c4d.modules import mograph as mo

def vec(v):
    return [float(v.x), float(v.y), float(v.z)]

cloner = find_obj("ClonerName")
mg = cloner.GetMg()

for frame in range(start, end + 1, step):
    doc.SetTime(c4d.BaseTime(frame, fps))
    doc.ExecutePasses(None, True, True, True, c4d.BUILDFLAGS_NONE)
    md = mo.GeGetMoData(cloner)
    matrices = md.GetArray(c4d.MODATA_MATRIX)
    for i, m in enumerate(matrices):
        world_pos = mg * m.off
        scale = (m.v1.GetLength() + m.v2.GetLength() + m.v3.GetLength()) / 3.0

Animation Track Discovery

for t in obj.GetCTracks():
    did = t.GetDescriptionID()
    ids = [int(did[i].id) for i in range(did.GetDepth())]
    curve = t.GetCurve()
    keys = []
    if curve:
        for k in range(curve.GetKeyCount()):
            key = curve.GetKey(k)
            keys.append({"frame": key.GetTime().GetFrame(fps), "value": float(key.GetValue())})

Cloner Mode Constants

c4d.ID_MG_MOTIONGENERATOR_MODE: 0=Grid, 1=Linear, 2=Radial, 3=Object, 4=Honeycomb
c4d.MG_GRID_MODE: 0=Endpoint (total span), 1=Per Step (spacing)

Redshift Material Extraction

RS node graphs ARE accessible via the maxon Python API when Redshift is installed. The inspect_redshift_materials MCP tool may report materials as not_redshift_like (type 5703), but the node graph is still readable through the maxon node-space API.

Primary Path: maxon Node-Space API (Proven Working)

RS materials use node space com.redshift3d.redshift4c4d.class.nodespace. Access via:

import c4d
import maxon

RS_NODESPACE = "com.redshift3d.redshift4c4d.class.nodespace"

mat = doc.GetMaterials()[0]
nm = mat.GetNodeMaterialReference()
graph = nm.GetGraph(RS_NODESPACE)  # returns NodesGraphModelRef

# Traverse ALL nodes and ports:
root = graph.GetRoot()
inner = root.GetInnerNodes(maxon.NODE_KIND.ALL_MASK, False)

for n in inner:
    kind = n.GetKind()
    nid = str(n.GetId())

    if kind == 1:  # NODE — e.g. standardmaterial, incandescent, texturesampler
        print(f"Node: {nid}")
    elif kind == 8:  # INPORT — readable port with value
        short_name = nid.split('.')[-1]
        try:
            val = n.GetDefaultValue()
            if val is not None:
                print(f"  {short_name} = {val}")
        except:
            pass

What this gives you:

• All shader nodes (RS Standard Material, Incandescent, MaxonNoise, TextureSampler, RSRamp, RSColorCorrection, etc.)
• All input port values (colors, intensities, roughness, refraction weight, texture paths, noise params, ramp stops, etc.)
• GetDefaultValue() and GetEffectivePortValue() both work

⚠ API drift (observed C4D 2024.2, 2026-08): on some builds GetDefaultValue() returns None for every port (customized or not) and GetEffectivePortValue() does not exist on the GraphNode wrapper; the graph STRUCTURE still enumerates fine via GetInnerNodes(ALL_MASK). Also dir(port) can raise "expected generic datatype capsule". When values are unreadable, fall back to empirical extraction: render one small frame (batch queue, e.g. 295x640 single frame ≈ 7 min RS) and measure colors from pixels, or use the emission-probe pattern for field values. That answered "which node carries the preset color" faster than fighting the API.

Instead: try binary extraction first. The values ARE in the .c4d binary and ARE readable via direct parsing — see ~/cinema4d-mcp/scripts/extract_rs_binary.py (standalone Python, no C4D/RS license needed). Handles float64 and int32 scalar port values in both C4D serialization formats (10_1c and 10_1f). This is faster, cheaper, and more reliable than the API.

python3 ~/cinema4d-mcp/scripts/extract_rs_binary.py scene.c4d

Binary format decoded

Two serialization formats exist in .c4d files:

Type bytes: 0x11 = float64 (IEEE 754 LE, 8 bytes), 0x12 = int32 (LE, 4 bytes). After the value: 2-byte big-endian uint16 = next port path length (used as alignment validation). For vec3/color values: type byte 0x22 → 3 × float64 RGB.

A third format (10 20 10 20, 16-byte header + 10 28 value marker) encodes node graph connections (wiring between ports), not port values — still being RE'd.

What can be extracted

Extracted values across all 4 scene files

See docs/c4d-binary-reverse-engineering.md in music-shader for the full table. Key shared values:

• brightness: 0.054 (all scenes)
• contrast: 0.428 or 0.238 (per noise node)
• animation_speed: 2.85 or 1.1 (two noise nodes in Skriptonit)
• coord_scale_global: ~26-27 (all scenes)
• refr_weight: 0.581, refl_roughness: 0.336
• level (color correction): 1.0-1.5

For color/vec3/ramp types the binary reader doesn't handle yet, use the emission-probe method or GetPreview(0) (cached thumbnail) for coarse color data.

To find specific node types, use:

result = maxon.GraphModelHelper.FindNodesByAssetId(
    graph, "com.redshift3d.redshift4c4d.nodes.core.standardmaterial", True
)

Secondary Path: Legacy GraphView (Older RS Materials)

For older RS shader-network materials where GetGraph() returns None:

import redshift
gv = redshift.GetRSMaterialNodeMaster(mat)
if gv:
    root = gv.GetRoot()
    child = root.GetDown()
    while child:
        print(f"Node: {child.GetName()} op={child.GetOperatorID()}")
        child = child.GetNext()

Fallback: Preview Bitmap Sampling

When neither path works (RS not installed), sample preview bitmaps for approximate colors:

bmp = mat.GetPreview(0)
if bmp:
    r, g, b = bmp.GetPixel(bmp.GetBw() // 2, bmp.GetBh() // 2)

⚠ Also works when the Redshift LICENSE HAS LAPSED, not just when RS is absent. GetPreview() returns a bitmap C4D already cached from the last render/interactive preview — it does not trigger a new render, so it is unaffected by a license check that blocks RenderDocument() / batch / PV rendering outright. Confirmed live (2026-08): with the license lapsed, CallCommand(12099) (PV render) hung indefinitely with CHECKISRUNNING_EXTERNALRENDERING stuck at 1, while mat.GetPreview(0) on the same document returned instantly with real (non-placeholder) pixel data. The near-instant response itself is the tell that you're reading a cache, not paying for a render — if a "preview" call takes seconds, that's a different code path. When a license lapses mid-project, this is the fastest way to keep pulling some per-material data (coarse average color via a 3x3 or denser pixel-grid sample) without needing the license back — see the OOM/hang troubleshooting row below for the render-side symptoms this pairs with.

Node Kind Constants

Duplicate Names

If the scene contains multiple materials with the same visible name, use material_index instead of material_name with the MCP inspector.

Clone-to-Material Mapping

Use MODATA_CLONE array from GeGetMoData() to get normalized clone indices (0.0–1.0 mapped to child objects):

md = mo.GeGetMoData(cloner)
clone_indices = md.GetArray(c4d.MODATA_CLONE)  # float array, 0.0–1.0

These values map to the cloner's child object cycle. Verify visually — don't assume the cycle matches hierarchy order.

Examples

Example 1: Extract MoGraph Cloner Animation to JSON for Three.js

Scenario: A cloner with 50 spheres driven by a Random effector needs to be exported as per-frame position data for playback in Three.js.

Step-by-step:

1. Health check — confirm get_scene_info returns scene name and doc.GetFps() returns 30.

2. Identify the cloner name from list_objects or get_scene_info. Assume it is "SphereCloner".

3. Run a small test bake (frames 0-10) to confirm data shape:

import c4d
from c4d.modules import mograph as mo

def find_obj(name):
    stack = [doc.GetFirstObject()]
    while stack:
        obj = stack.pop()
        while obj:
            if obj.GetName() == name:
                return obj
            if obj.GetDown():
                stack.append(obj.GetDown())
            obj = obj.GetNext()
    return None

fps = doc.GetFps()
cloner = find_obj("SphereCloner")
mg = cloner.GetMg()

for frame in range(0, 11):
    doc.SetTime(c4d.BaseTime(frame, fps))
    doc.ExecutePasses(None, True, True, True, c4d.BUILDFLAGS_NONE)
    md = mo.GeGetMoData(cloner)
    matrices = md.GetArray(c4d.MODATA_MATRIX)
    world_positions = [list(mg * m.off) for m in matrices]
    print(f"Frame {frame}: {len(world_positions)} clones, first pos: {world_positions[0]}")

4. Confirm output: 50 clones per frame, positions changing frame to frame, no NaN values.

5. Run full bake using the Complete Animation Bake Workflow (Steps 3-5 above). The export JSON is saved to the system temp directory.

6. Convert to Three.js-compatible format — the JSON structure frames[frame][clone_index].position maps directly to BufferAttribute update per frame in an AnimationMixer-driven loop.

Three.js consumption pattern:

// Load the exported JSON
const data = await fetch('/data/spherecloner_export.json').then(r => r.json());
const fps = data.fps;

// On each animation frame:
function updateClones(currentTime) {
    const frame = Math.floor(currentTime * fps);
    const frameData = data.frames[frame];
    if (!frameData) return;
    frameData.forEach((clone, i) => {
        meshes[i].position.set(...clone.position);
    });
}

Example 2: Debug Missing Redshift Colors Using Preview Bitmap Workaround

Scenario: A scene uses Redshift materials. You need to identify which material is which color for a clone-to-material mapping, but mat[c4d.MATERIAL_COLOR_COLOR] returns black or zero for all RS materials.

Why it fails: Redshift materials store color in the RS node graph, not in the standard C4D material container. mat[c4d.MATERIAL_COLOR_COLOR] reads the legacy C4D channel, which is empty for RS materials.

Workaround — preview bitmap sampling:

import c4d

doc_mats = doc.GetMaterials()
material_colors = []

for mat in doc_mats:
    name = mat.GetName()
    bmp = mat.GetPreview(0)  # 0 = default preview size
    if bmp is None:
        material_colors.append({"name": name, "color": None, "error": "no preview"})
        continue

    w = bmp.GetBw()
    h = bmp.GetBh()

    # Sample a 3x3 grid of pixels from the center region to get a representative color
    samples = []
    for sx in [w // 3, w // 2, 2 * w // 3]:
        for sy in [h // 3, h // 2, 2 * h // 3]:
            r, g, b = bmp.GetPixel(sx, sy)
            samples.append((r, g, b))

    avg_r = sum(s[0] for s in samples) // len(samples)
    avg_g = sum(s[1] for s in samples) // len(samples)
    avg_b = sum(s[2] for s in samples) // len(samples)

    material_colors.append({
        "name": name,
        "color_rgb_0_255": [avg_r, avg_g, avg_b],
        "color_hex": f"#{avg_r:02x}{avg_g:02x}{avg_b:02x}"
    })

import json
print(json.dumps(material_colors, indent=2))

Caveats:

• Preview bitmaps are generated from the last render or interactive preview. If C4D hasn't rendered a preview for a material, GetPreview() may return None or a gray placeholder.
• Force a preview render by opening the Material Manager and letting thumbnails regenerate before running this script.
• For multi-layer or metallic RS materials, the sampled color is an approximation — use it for identification (which material is roughly red vs. blue) rather than precise color matching.
• Cross-reference with MODATA_CLONE indices to build a clone -> material -> color lookup table.
• This also survives a lapsed RS license (it reads a cache, doesn't render) — see the note under "Fallback: Preview Bitmap Sampling" above.

Zero-click backend workflow

The MCP plugin auto-starts its socket server when Cinema boots (headless MessageData pump — no dialog needed; commit 94f9cbb in the plugin repo). To (re)start Cinema as a backend from a shell, music-shader has the pattern:

./scripts/c4d-backend.sh --restart [scene.c4d]   # kill -> open -> wait for port 5555 -> READY

Deadlock warning: do NOT call c4d.documents.InsertBaseDocument / SetActiveDocument from MCP scripts — they hang Cinema from the plugin dispatch thread (same class as the RenderDocument deadlock). Build probe objects INSIDE the already-active document instead, hide originals, and clean up after.

The emission-probe method: sampling a renderer's procedural field

When you need a renderer's EXACT procedural field (noise, gradient, any shader node) and CPU reimplementation fails, use the renderer as an oracle:

1. Clone the material; rewire <node>.outcolor -> standardmaterial .emission_color (weight 1); zero base/refl/refr weights. Undo any node colorization when decoding (e.g. black->green ramp: value = G channel, sRGB-linearized).
2. Put it on a plane at known world coordinates; a long-lens perspective camera is fine — the projection of a PLANE at fixed depth is exactly affine, no ortho needed (RS + parallel cameras can be flaky anyway).
3. Every rendered pixel is a field sample at a known coordinate. Sweep the plane's z for volume slices; scene time for the temporal axis.
4. Emission-only renders converge in seconds even under a heavy render preset.

Verified findings that motivated this (YM shader project): Redshift's "Maxon noise" is NOT lattice-compatible with c4d.utils.noise.C4DNoise (max field correlation 0.23 across scale/octave/orientation sweeps) — CPU bakes can only ever be statistical cousins. Camera gotcha: a camera at -z looking toward +z renders the plane X-MIRRORED relative to world axes — verify orientation against a known-asymmetric reference before trusting the decode.

Batch-render the sweep: single-frame Picture Viewer autosave is unreliable, but the Batch Render queue (c4d.documents.GetBatchRender()) saves every frame of a MANUAL frame-range job dependably. Save one .c4d variant per configuration (SaveDocument creates no directories — mkdir first), AddFile them all, SetRendering(BR_START). 360 emission renders took ~25 min.

Rendering ground truth via Picture Viewer (Redshift)

Scripted c4d.documents.RenderDocument() may return RENDERRESULT_OK with an all-black bitmap on some Redshift builds (every variant: main thread, clone, autosave, BatchRender). The reliable path is the async Picture Viewer render:

import c4d
doc = c4d.documents.GetActiveDocument()
rd = doc.GetActiveRenderData()
# CRITICAL: default frame sequence may be "All Frames" — firing PV then
# renders the entire timeline (an accidental 148-frame overnight job).
rd.GetDataInstance()[c4d.RDATA_FRAMESEQUENCE] = c4d.RDATA_FRAMESEQUENCE_CURRENTFRAME
doc.SetTime(c4d.BaseTime(FRAME, doc.GetFps()))
doc.ExecutePasses(None, True, True, True, c4d.BUILDFLAGS_NONE)
c4d.CallCommand(12099)   # Render to Picture Viewer — ASYNC, returns immediately

• Poll completion with c4d.CheckIsRunning(c4d.CHECKISRUNNING_EXTERNALRENDERING) (1 while rendering, 0 when done).
• Stop a running PV render programmatically: c4d.CallCommand(430000731).
• No manual save needed: if the render settings have a save path, Picture Viewer AUTOSAVES each finished frame to <save-path>/<scene-name>/<scene-name>_NNNN.png — check there before asking a human to File→Save As. (Discovered after two sessions of manual saving.)
• Never call RenderDocument() from code already on C4D's main thread (the plugin dispatch queue) — it deadlocks: rendering needs the event loop the blocked call is holding.

Troubleshooting Quick Reference

Known Errors & Workarounds

See references/errors.md for complete Python API and MCP tool error tables.

Advanced Debugging

Raw Socket Fallback

If MCP tools fail entirely but the C4D socket server is alive at 127.0.0.1:5555, you can bypass the MCP layer and send commands directly. This is a last-resort diagnostic tool, not a normal workflow path.

When to use:

• All MCP tool calls return connection errors
• execute_python_script fails at the transport level (not a Python error)
• You need to confirm the C4D server process is alive at all

Working example:

import json
import socket

def c4d_raw(command_dict, host="127.0.0.1", port=5555, timeout=10):
    """
    Send a raw command to the C4D socket server and return the parsed response.
    Commands mirror the MCP tool names: get_scene_info, list_objects, execute_python_script, etc.
    """
    payload = json.dumps(command_dict) + "\n"
    s = socket.create_connection((host, port), timeout=timeout)
    try:
        s.sendall(payload.encode("utf-8"))
        # Read until newline (server responds with a single JSON line)
        response = b""
        while True:
            chunk = s.recv(4096)
            if not chunk:
                break
            response += chunk
            if b"\n" in response:
                break
    finally:
        s.close()
    return json.loads(response.decode("utf-8").strip())

# Example: check connection
result = c4d_raw({"command": "get_scene_info"})
print(result)

# Example: run a Python expression
result = c4d_raw({
    "command": "execute_python_script",
    "params": {"script": "print(doc.GetDocumentName())"}
})
print(result)

Notes:

• The socket server may not be running if you started C4D without the MCP plugin loaded.
• Port 5555 is the default. Some forks or configurations may use different ports.
• Responses are newline-delimited JSON. Large responses (e.g., full scene data) will be chunked — loop on recv until you have a complete JSON object.

Data Output

• Save to JSON with metadata (scene name, fps, frame range, sampling step)
• json.dumps() + print() for small results, tempfile.gettempdir() for large data
• Keep both raw extraction and derived model

Additional References

• references/errors.md — Python API and MCP tool error tables, security restrictions, key parameter IDs
• references/mograph-baking-guide.md — Detailed sequential frame stepping examples, chunked baking strategy, memory management
• references/redshift-workarounds.md — Redshift color sampling, material verification patterns, node graph limitations