CSC¶

csc The main Cascadeur python module.¶

`csc.Guid`
`csc.math.Quaternion`	Quaternion class
`csc.math.Rotation`	Rotation class
`csc.math.transform_point`(args, *kwargs)	Overloaded function.
`csc.math.inverse_transform_point`(transform, ...)	-> Vector3f
`csc.math.basic_transform_from_triangle`(triangle)	-> csc.math.OrthogonalTransform
`csc.math.project_point_on_basic_line`(...)	-> Vector3f
`csc.math.euler_angles_to_quaternion_x_y_z`(...)	-> Quaternionf
`csc.math.modify_position_by_matrix`(matrix, ...)	-> Vector3f
`csc.math.transforms_difference`(...)	-> csc.math.OrthogonalTransform
`csc.math.transform_point`(args, *kwargs)	Overloaded function.
`csc.math.get_m3f_diag`(matrix)	-> Vector3f
`csc.physics.PosMass`	PosMass class
`csc.physics.inertia_tensor`(mass_and_poses, ...)	-> Matrix3f
`csc.DirectionValue`	DirectionValue enumeration.
`csc.Direction`	Direction class Implements direction.
`csc.Version`	Version class
`csc.SystemVariables`	Contains static methods related to system variables of Cascadeur.
`csc.math.ScaledTransform`	ScaledTransform class
`csc.math.OrthogonalTransform`	OrthogonalTransform class
`csc.math.Triangle`	Triangle class
`csc.math.SizesInterval`	SizesInterval class
`csc.parts.Type`	Type of the parts, enum
`csc.parts.Info`	Info class
`csc.parts.GroupInfo`	GroupInfo class
`csc.parts.Buffer`	Buffer class

class csc.Direction¶

Direction class Implements direction.

__annotations__ = {}¶

__init__(self: csc.Direction, value: csc.DirectionValue = <DirectionValue.Unknown: 2>) → None¶

__module__ = 'csc'¶

inverse(self: csc.Direction) → csc.DirectionValue¶

Get the inverse direction.

Returns:: The inverse direction.
Return type:: csc.Direction

import csc
d = csc.Direction(csc.DirectionValue.In)
print(d.inverse())

to_string(self: csc.Direction) → str¶

Get the string representation of the direction.

Returns:: The string representation of the direction.
Return type:: str

value(self: csc.Direction) → csc.DirectionValue¶

Get the value of the direction.

Returns:: The value of the direction.
Return type:: csc.DirectionValue

import csc
d = csc.Direction(csc.DirectionValue.In)
print(d.value())

class csc.DirectionValue¶

DirectionValue enumeration. Represents a DirectionValue enumeration for defining In, Out, and Unknown directions.

In : <DirectionValue.In: 0>

Out : <DirectionValue.Out: 1>

Unknown : <DirectionValue.Unknown: 2>
1import csc
2print(csc.DirectionValue.In)
3print(csc.DirectionValue.In.value)

Members:

In

Out

Unknown

In = <DirectionValue.In: 0>¶

Out = <DirectionValue.Out: 1>¶

Unknown = <DirectionValue.Unknown: 2>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.DirectionValue) → int¶

__init__(self: csc.DirectionValue, value: int) → None¶

__int__(self: csc.DirectionValue) → int¶

__members__ = {'In': <DirectionValue.In: 0>, 'Out': <DirectionValue.Out: 1>, 'Unknown': <DirectionValue.Unknown: 2>}¶

__module__ = 'csc'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.DirectionValue, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.Guid¶

__annotations__ = {}¶

__cmp__(self: csc.Guid, arg0: csc.Guid) → int¶

__eq__(self: csc.Guid, arg0: csc.Guid) → bool¶

__hash__(self: csc.Guid) → int¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.Guid, arg0: str) -> None
__init__(self: csc.Guid) -> None

__module__ = 'csc'¶

__ne__(self: csc.Guid, arg0: csc.Guid) → bool¶

__str__(self: csc.Guid) → str¶

is_null(self: csc.Guid) → bool¶

static null() → csc.Guid¶

to_string(self: csc.Guid) → str¶

class csc.Path¶

__annotations__ = {}¶

__init__(self: csc.Path, arg0: str) → None¶

__module__ = 'csc'¶

class csc.SystemVariables¶

Contains static methods related to system variables of Cascadeur.

import csc
print(csc.SystemVariables.git_sha())
print(csc.SystemVariables.git_date())
print(csc.SystemVariables.git_count())
print(csc.SystemVariables.git_version())

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc'¶

static git_count() → str¶

Returns the git count of the current repository.

Returns:: The git count of the current repository.
Return type:: str

static git_date() → str¶

Returns the git date of the current repository.

Returns:: The git date of the current repository.
Return type:: str

static git_sha() → str¶

Returns the git SHA hash of the current repository.

Returns:: The git SHA hash of the current repository.
Return type:: str

static git_version() → str¶

Returns the git version of the current repository.

Returns:: The git version of the current repository.
Return type:: str

class csc.Version¶

Version class

Implements Version.

Variables:

major – Get set int
minor – Get set int
patch – Get set int

import csc
version = csc.Version.from_string("4.2.1")
print(version.major)
print(version.minor)
print(version.patch)
print(version.to_string())

__annotations__ = {}¶

__cmp__(self: csc.Version, arg0: csc.Version) → int¶

__eq__(self: csc.Version, arg0: csc.Version) → bool¶

__hash__ = None¶

__init__(self: csc.Version, major: int, minor: int, patch: int) → None¶

__lt__(self: csc.Version, arg0: csc.Version) → bool¶

__module__ = 'csc'¶

__ne__(self: csc.Version, arg0: csc.Version) → bool¶

static from_string(arg0: str) → csc.Version¶

Create a Version object from a string.

Parameters:: version (str) – The version string.
Returns:: The Version object.
Return type:: csc.Version

property major¶

property minor¶

property patch¶

to_string(self: csc.Version) → str¶

Get the string representation of the version.

Returns:: The string representation of the version.
Return type:: str

csc.get_meaningful_list() → list[tuple[str, str]]¶

csc.tools The Cascadeur python module provides tools.¶

`csc.tools.ActivateDeactivate`	ActivateDeactivate class
`csc.tools.selection.Mode`	Mode enumeration
`csc.tools.selection.Group`	Group class
`csc.tools.selection.Core`	Core class
`csc.tools.SelectionGroups`	SelectionGroups class
`csc.tools.mirror.Core`	Mirror tool core class
`csc.tools.MirrorTool`	Mirror tool class.
`csc.tools.JointData`	Represents joint data used in Cascadeur to manage local position, rotation, and scale of joints.
`csc.tools.ObjectKey`	Represents an object key used in Cascadeur to manage behaviour and path names.
`csc.tools.DataKey`	Represents a data key used in Cascadeur to manage object key and data name.
`csc.tools.RiggingModeTool`	Rigging mode tool class
`csc.tools.attractor.SpaceMode`	attractor::Mode enum
`csc.tools.attractor.ArgsMode`	attractor::Mode enum
`csc.tools.attractor.GSRotationAxis`	GeneralSettings::RotationAxis enum
`csc.tools.attractor.GSAxisFlag`	GeneralSettings::RotationAxis enum
`csc.tools.attractor.GSAxisIndex`	GeneralSettings::RotationAxis enum
`csc.tools.attractor.GSPhysicsType`	GeneralSettings::RotationAxis enum
`csc.tools.attractor.AttractorGeneralSettings`
`csc.tools.attractor.Args`	Arguments for configuring attractor operations.
`csc.tools.attractor.attract`(args)
`csc.tools.AttractorTool`	Attractor tool class
`csc.tools.AutoPhysicTool`	Auto physics tool class
`csc.tools.AnimationPointsTypes`	Class of basic types of points which physics tools and change through animation for target center of mass it contains
`csc.tools.CollisionInfoForObject`	Structure with which the point collides.
`csc.tools.FulcrumCollisionInfo`	Class of basic types of points change through animation for target center of mass it contains get_fulcrum_points -- all fulcrum point with collision get_collision_points -- all collision points get_fulcrum_floor_points -- all fulcrum points that are on the floor get_frame_collision_info_points -- all collision points with collision info
`csc.tools.BallisticTrajectory`	BallisticTrajectory class
`csc.tools.Trajectory`	Trajectory class
`csc.tools.AutoPosingTool`	AutoPosingTool class
`csc.tools.AnimationUnbakingTool`	AnimationUnbakingTool class
`csc.tools.RenderParameters`	Parameters for rendering
`csc.tools.RenderToFile`	Render to file tool class

class csc.tools.ActivateDeactivate¶

ActivateDeactivate class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools'¶

activate(self: csc.tools.ActivateDeactivate, arg0: csc.domain.Session, arg1: dict[csc.model.ObjectId, csc.model.ObjectId]) → bool¶

deactivate(self: csc.tools.ActivateDeactivate, arg0: csc.domain.Session, arg1: set[csc.model.ObjectId]) → None¶

class csc.tools.AnimationPointsTypes¶

Class of basic types of points which physics tools and change through animation for target center of mass it contains

get_fulcrum_points – all fulcrum point with collision get_collision_points – all collision points get_fulcrum_floor_points – all fulcrum points that are on the floor get_fulcrum_points_with_group – all fulcrum points with group get_frame_collision_info_points – all collision points with collision info

__annotations__ = {}¶

__init__(self: csc.tools.AnimationPointsTypes, arg0: int, arg1: int, arg2: csc.domain.Scene, arg3: csc.tools.StaticPointsTypes) → None¶

__module__ = 'csc.tools'¶

get_collision_points(self: csc.tools.AnimationPointsTypes) → dict[int, set[csc.model.ObjectId]]¶: Dict[frame number, set of points]

get_frame_collision_info_points(self: csc.tools.AnimationPointsTypes) → dict[int, dict[csc.model.ObjectId, domain::scene::collision::CollisionInfoForObject]]¶: Dict[frame number, Dict[csc.model.ObjectId, CollisionInfoForObject]]

get_fulcrum_points(self: csc.tools.AnimationPointsTypes) → dict[int, set[csc.model.ObjectId]]¶: Dict[frame number, set of points]

get_fulcrum_points_with_group(self: csc.tools.AnimationPointsTypes) → dict[int, set[csc.model.ObjectId]]¶: Dict[frame number, set of points]

get_touch_points(self: csc.tools.AnimationPointsTypes) → dict[int, set[csc.model.ObjectId]]¶: Dict[frame number, set of points]

class csc.tools.AnimationUnbakingTool¶

AnimationUnbakingTool class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools'¶

get_interpolation_difference(self: csc.tools.AnimationUnbakingTool) → float¶

class csc.tools.AttractorTool¶

Attractor tool class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools'¶

get_general_settings(self: csc.tools.AttractorTool) → csc.tools.attractor.AttractorGeneralSettings¶

Retrieves the general settings of the attractor tool

Returns: csc.tools.attractor.AttractorGeneralSettings : General settings

is_only_key_frames(self: csc.tools.AttractorTool) → bool¶

Checks if the attractor tool is only operating on key frames

Returns:¶

bool: True if the attractor tool is only operating on key frames, False otherwise

import csc
scene_manager:csc.view.Scene = csc.app.get_application().get_scene_manager()
app_scene = scene_manager.current_scene()
attractor_tool = csc.app.get_application().get_tools_manager().get_tool('AttractorTool').editor(app_scene)
print(attractor_tool.is_only_key_frames())

class csc.tools.AutoPhysicTool¶

Auto physics tool class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools'¶

turn_off(self: csc.tools.AutoPhysicTool) → None¶

turn_off_all_fulcrum_points(self: csc.tools.AutoPhysicTool) → None¶

class csc.tools.AutoPosingTool¶

AutoPosingTool class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools'¶

add(self: csc.tools.AutoPosingTool, arg0: csc.domain.Session) → None¶

update(self: csc.tools.AutoPosingTool, arg0: csc.domain.Session) → None¶

class csc.tools.BallisticTrajectory¶

BallisticTrajectory class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools'¶

class csc.tools.CollisionInfoForObject¶

Structure with which the point collides. When used, it is assumed that the normal goes from other to point.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools'¶

property normal¶: Vector3d

property other¶: csc.model.ObjectId

property penetration_depth¶: double

property pos¶: Vector3d

class csc.tools.CollisionShapeStorage¶

__annotations__ = {}¶

__init__(self: csc.tools.CollisionShapeStorage) → None¶

__module__ = 'csc.tools'¶

class csc.tools.ControlPicker¶

ControlPicker class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools'¶

class csc.tools.DataKey¶

Represents a data key used in Cascadeur to manage object key and data name.

Parameters:

object_key (csc.tools.rigging_mode.ObjectKey) – Object key
data_name (str) – Data name

__annotations__ = {}¶

__eq__(self: csc.tools.DataKey, arg0: csc.tools.DataKey) → bool¶

__hash__(self: csc.tools.DataKey) → int¶

__init__(self: csc.tools.DataKey) → None¶

__module__ = 'csc.tools'¶

__ne__(self: csc.tools.DataKey, arg0: csc.tools.DataKey) → bool¶

property data_name¶

property object_key¶

class csc.tools.FulcrumCollisionInfo¶

Class of basic types of points change through animation for target center of mass it contains get_fulcrum_points – all fulcrum point with collision get_collision_points – all collision points get_fulcrum_floor_points – all fulcrum points that are on the floor get_frame_collision_info_points – all collision points with collision info

__annotations__ = {}¶

__init__(self: csc.tools.FulcrumCollisionInfo, arg0: int, arg1: int, arg2: csc.domain.Scene, arg3: csc.tools.StaticPointsTypes) → None¶

__module__ = 'csc.tools'¶

get_collision_points(self: csc.tools.FulcrumCollisionInfo) → dict[int, set[csc.model.ObjectId]]¶: Dict[frame number, set of points]

get_frame_collision_info_points(self: csc.tools.FulcrumCollisionInfo) → dict[int, dict[csc.model.ObjectId, csc.tools.CollisionInfoForObject]]¶: Dict[frame number, Dict[csc.model.ObjectId, CollisionInfoForObject]]

get_fulcrum_points(self: csc.tools.FulcrumCollisionInfo) → dict[int, set[csc.model.ObjectId]]¶: Dict[frame number, set of points]

get_touch_points(self: csc.tools.FulcrumCollisionInfo) → dict[int, set[csc.model.ObjectId]]¶: Dict[frame number, set of points]

class csc.tools.JointData¶

Represents joint data used in Cascadeur to manage local position, rotation, and scale of joints.

Parameters:

local_position (numpy.ndarray) – Local position
local_rotation (csc.math.Rotation) – Local rotation
local_scale (numpy.ndarray) – Local scale
visibility (int) – Visibility

__annotations__ = {}¶

__init__(self: csc.tools.JointData) → None¶

__module__ = 'csc.tools'¶

property local_position¶

property local_rotation¶

property local_scale¶

property visibility¶

class csc.tools.MirrorTool¶

Mirror tool class. Represents the mirror tool class used to handle symmetry operations in Cascadeur.

import csc
scene_manager = csc.app.get_application().get_scene_manager()
app_scene::csc.view.Scene = scene_manager.current_scene()
mirror_tool = csc.app.get_application().get_tools_manager().get_tool('MirrorTool').editor(app_scene)
core = mirror_tool.core()
core.set_plane(csc.math.Plane([1.0, 0.0, 0.0], [0.0,0.0,0.0]))

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools'¶

core(self: csc.tools.MirrorTool) → object¶

Retrieves the core of the mirror tool.

Returns:: The core of the mirror tool
Return type:: csc.tools.mirror.Core

class csc.tools.ObjectKey¶

Represents an object key used in Cascadeur to manage behaviour and path names.

Parameters:

behaviour_name (str) – Behaviour name
path_name (csc.model.PathName) – Path name

__annotations__ = {}¶

__eq__(self: csc.tools.ObjectKey, arg0: csc.tools.ObjectKey) → bool¶

__hash__(self: csc.tools.ObjectKey) → int¶

__init__(self: csc.tools.ObjectKey) → None¶

__module__ = 'csc.tools'¶

__ne__(self: csc.tools.ObjectKey, arg0: csc.tools.ObjectKey) → bool¶

property behaviour_name¶

property path_name¶

class csc.tools.RenderParameters¶

Parameters for rendering

__annotations__ = {}¶

__init__(self: csc.tools.RenderParameters) → None¶

__module__ = 'csc.tools'¶

property height¶

property samples¶

property width¶

class csc.tools.RenderToFile¶

Render to file tool class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools'¶

play_to_images_sequence(self: csc.tools.RenderToFile, scene_view: csc.view.Scene, render_parameters: csc.tools.RenderParameters, folder_name: str) → None¶

play_to_video_file(self: csc.tools.RenderToFile, scene_view: csc.view.Scene, render_parameters: csc.tools.RenderParameters, file_name: str) → None¶

take_image(self: csc.tools.RenderToFile, scene_view: csc.view.Scene, render_parameters: csc.tools.RenderParameters, file_name: str) → None¶

class csc.tools.RiggingModeTool¶

Rigging mode tool class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools'¶

erase_joints_data(self: csc.tools.RiggingModeTool, arg0: csc.domain.Session) → None¶

Erases joint data for the specified session.

Parameters:: arg0 (csc.domain.Session) – Session

erase_layer_id_by_object_ids(self: csc.tools.RiggingModeTool, arg0: csc.domain.Session) → None¶

Erases layer ID mapped by object IDs for the specified session.

Parameters:: arg0 (csc.domain.Session) – Session

erase_layers_ids(self: csc.tools.RiggingModeTool, arg0: csc.domain.Session) → None¶

Erases layer IDs for the specified session.

Parameters:: session (csc.domain.Session) – Session

erase_preserved_data(self: csc.tools.RiggingModeTool, arg0: csc.domain.Session) → None¶

Erases preserved data for the specified session.

Parameters:: arg0 (csc.domain.Session) – Session

erase_preserved_object_ids(self: csc.tools.RiggingModeTool, arg0: csc.domain.Session) → None¶

Erases preserved object IDs for the specified session.

Parameters:: arg0 (csc.domain.Session) – Session

erase_preserved_setting(self: csc.tools.RiggingModeTool, arg0: csc.domain.Session) → None¶

Erases preserved setting for the specified session.

Parameters:: arg0 (csc.domain.Session) – Session

get_joints_data(self: csc.tools.RiggingModeTool) → dict[csc.model.ObjectId, list[csc.tools.JointData]]¶

Retrieves joint data mapped by object ID.

Returns:: Joint data
Return type:: Dict[csc.tools.rigging_mode.ObjectKey, csc.tools.rigging_mode.JointData]

get_layer_id_by_object_ids(self: csc.tools.RiggingModeTool) → dict[csc.Guid, list[csc.model.ObjectId]]¶

Retrieves layer ID mapped by object IDs.

Returns:: Layer ID mapped by object IDs
Return type:: Set[csc.model.LayerId]

get_layers_ids(self: csc.tools.RiggingModeTool) → set[csc.Guid]¶

Retrieves layer IDs as a set of GUIDs.

Returns:: Layer IDs
Return type:: Set[csc.Guid]

Retrieves preserved data stored in a dictionary structure.

Returns:: Preserved data
Return type:: Dict[csc.tools.DataKey, List[Union[bool, int, float, numpy.ndarray, csc.math.Rotation, csc.math.Quaternion, str]]]

get_preserved_object_ids(self: csc.tools.RiggingModeTool) → dict[csc.model.PathName, csc.model.ObjectId]¶

Retrieves preserved object IDs stored in a set.

Returns:: Preserved object IDs
Return type:: Dict[PathName,csc.model.ObjectId]

get_preserved_setting(self: csc.tools.RiggingModeTool) → dict[csc.tools.DataKey, list[bool | int]]¶

Retrieves preserved setting stored in a dictionary structure.

Returns:: Preserved setting
Return type:: Dict[csc.tools.DataKey, List[Union[bool, int]]]

set_joints_data(self: csc.tools.RiggingModeTool, arg0: csc.domain.Session, arg1: dict[csc.model.ObjectId, list[csc.tools.JointData]]) → None¶

Sets joint data for the specified session.

Parameters:

arg0 (csc.domain.Session) – Session
arg1 (Dict[csc.model.ObjectId, List[csc.tools.JointData]]) – Joint data

set_layers_ids(self: csc.tools.RiggingModeTool, arg0: csc.domain.Session, arg1: set[csc.Guid]) → None¶

Sets layer IDs for the specified session.

Parameters:

session (csc.domain.Session) – Session
ids (set[csc.Guid]) – Layer IDs

Sets preserved data for the specified session.

Parameters:

arg0 (csc.domain.Session) – Session
arg1 (Dict[csc.tools.DataKey, List[Union[bool, int, float, numpy.ndarray, csc.math.Rotation, csc.math.Quaternion, str]]]) – Preserved data

set_preserved_object_ids(self: csc.tools.RiggingModeTool, arg0: csc.domain.Session, arg1: dict[csc.model.PathName, csc.model.ObjectId]) → None¶

Sets preserved object IDs for the specified session.

Parameters:

arg0 (csc.domain.Session) – Session
arg1 (Dict[PathName,csc.model.ObjectId]) – Preserved object IDs

set_preserved_setting(self: csc.tools.RiggingModeTool, arg0: csc.domain.Session, arg1: dict[csc.tools.DataKey, list[bool | int]]) → None¶

Sets preserved setting for the specified session.

Parameters:

arg0 (csc.domain.Session) – Session
arg1 (Dict[csc.tools.DataKey, List[Union[bool, int]]]) – Preserved setting

set_undo_redo_context(self: csc.tools.RiggingModeTool, arg0: csc.domain.Session, arg1: Callable, arg2: object, arg3: object) → None¶

Sets undo and redo context for the specified session.

Parameters:

arg0 (csc.domain.Session) – Session
arg1 (function) – reactor
arg2 (object) – undo context
arg3 (object) – redo context

class csc.tools.RiggingWindow¶

SelectionGroups class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools'¶

create_from_qrt_by_content(self: csc.tools.RiggingWindow, arg0: str) → None¶

create_from_qrt_by_fileName(self: csc.tools.RiggingWindow, arg0: str) → None¶

generate_rig_elements(self: csc.tools.RiggingWindow) → None¶

get_character_mirror_plane(self: csc.tools.RiggingWindow) → int¶

get_is_create_autoposing(self: csc.tools.RiggingWindow) → bool¶

get_template_from_qrt(self: csc.tools.RiggingWindow) → str¶

is_create_qrt(self: csc.tools.RiggingWindow) → bool¶

load_template_by_content(self: csc.tools.RiggingWindow, arg0: str) → None¶

load_template_by_fileName(self: csc.tools.RiggingWindow, arg0: str) → None¶

open_quick_rigging_tool(self: csc.tools.RiggingWindow) → None¶

set_axis_after_qrt(self: csc.tools.RiggingWindow, axis: int) → None¶

set_character_mirror_plane(self: csc.tools.RiggingWindow, plane: int) → None¶

set_is_create_autoposing(self: csc.tools.RiggingWindow, on: bool) → None¶

class csc.tools.SelectionGroups¶

SelectionGroups class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools'¶

core(self: csc.tools.SelectionGroups) → object¶

A core class used within selection tools to manage groups and processing modes.

Returns:: Core class
Return type:: csc.tools.selection.Core

import_file(self: csc.tools.SelectionGroups, path: str) → None¶

class csc.tools.StaticPointsTypes¶

Class of basic types of points which physics tools use and dont change through animation for target center of mass it contains

get_main_points – all points that can be associated with center of mass get_direction_controllers – all direction controller associated with center of mass get_interpolation_group – all points that should be interpolated and use instead direction controller in apply

__annotations__ = {}¶

__init__(self: csc.tools.StaticPointsTypes, arg0: csc.domain.Scene, arg1: list[csc.model.BehaviourId]) → None¶

__module__ = 'csc.tools'¶

get_direction_controllers(self: csc.tools.StaticPointsTypes) → set[csc.model.ObjectId]¶: set[ModelId]

get_interpolation_group(self: csc.tools.StaticPointsTypes) → set[csc.model.ObjectId]¶: set[ModelId]

get_main_points(self: csc.tools.StaticPointsTypes) → set[csc.model.ObjectId]¶: set[ModelId]

class csc.tools.Trajectory¶

Trajectory class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools'¶

csc.tools.generate_acd_meshes(scene: csc.domain.Scene, mesh_object: csc.model.ObjectId, max_convex_hulls: int = 64, resolution: int = 400000, minimum_volume_percent_error_allowed: float = 1, max_recursion_depth: int = 10, fill_mode: int = 0) → list[csc.domain.assets.Mesh]¶: generate_acd_meshes Generate ACD meshes for object. :param scene: Scene :param mesh_object: csc.model.ObjectId :param max_convex_hulls: int :param resolution: int :param minimum_volume_percent_error_allowed: double :param max_recursion_depth: int :param fill_mode: int :return: void

csc.tools.generate_convex_hull_mesh(scene: csc.domain.Scene, mesh_object: csc.model.ObjectId) → csc.domain.assets.Mesh¶: generate_convex_hull_mesh Generate convex hull mesh for object. :param scene: Scene :param mesh_object: csc.model.ObjectId :return: List[csc.assets.Mesh]

csc.tools.generate_convex_hull_mesh_from_rb(scene: csc.domain.Scene, rb_object: csc.model.ObjectId, weight_threshold: float = 0.009999999776482582, hull_tolerance: float = 1.0) → csc.domain.assets.Mesh¶: generate_convex_hull_mesh_from_rb Generate convex hull mesh for rigid body object. :param scene: Scene :param rb_object: csc.model.ObjectId :param weight_threshold: float :param hull_tolerance: float :return: csc.assets.Mesh

csc.tools.get_all_collision_for_object(shape_storage: csc.tools.CollisionShapeStorage, object_id: csc.model.ObjectId, others: list[csc.model.ObjectId], scene: csc.domain.Scene, n_frame: int) → list[csc.tools.CollisionInfoForObject]¶: get_all_collision_for_object Get all collision info for object with others. :param shape_storage: CollisionShapeStorage :param object_id: csc.model.ObjectId :param others: List[csc.model.ObjectId] :param scene: csc.Scene :param n_frame: int :return: List[CollisionInfoForObject]

csc.tools.get_collision_shape_storage(scene: csc.domain.Scene, scale_system: float = 0.05000000074505806) → csc.tools.CollisionShapeStorage¶: get_collision_shape_storage Get collision shape storage for scene. :param scene: Scene :param scale_system: float :return: CollisionShapeStorage

class csc.tools.selection.Core¶

Core class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools.selection'¶

get_group(self: csc.tools.selection.Core, idx: int) → csc.tools.selection.Group¶: pbdoc( -> Group )pbdoc

get_groups(self: csc.tools.selection.Core) → dict[int, csc.tools.selection.Group]¶: pbdoc( -> std::map<GroupIndex, Group> )pbdoc

process(self: csc.tools.selection.Core, index: int, mode: csc.tools.selection.Mode) → None¶

set_group(self: csc.tools.selection.Core, index: int, group: csc.tools.selection.Group) → None¶

set_groups(self: csc.tools.selection.Core, groups: dict[int, csc.tools.selection.Group]) → None¶

class csc.tools.selection.Group¶

Group class

Variables:

objects – std::set<ModelObjectId>
pivot – ModelObjectId

__annotations__ = {}¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.tools.selection.Group) -> None
__init__(self: csc.tools.selection.Group, arg0: set[Union[csc.model.ObjectId, csc.domain.Tool_object_id]], arg1: Union[csc.model.ObjectId, csc.domain.Tool_object_id]) -> None

__module__ = 'csc.tools.selection'¶

property objects¶

property pivot¶

class csc.tools.selection.Mode¶

Mode enumeration

SetGroup, SingleSelect, MultiSelect

Members:

SetGroup

SingleSelect

MultiSelect

MultiSelect = <Mode.MultiSelect: 2>¶

SetGroup = <Mode.SetGroup: 0>¶

SingleSelect = <Mode.SingleSelect: 1>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.tools.selection.Mode) → int¶

__init__(self: csc.tools.selection.Mode, value: int) → None¶

__int__(self: csc.tools.selection.Mode) → int¶

__members__ = {'MultiSelect': <Mode.MultiSelect: 2>, 'SetGroup': <Mode.SetGroup: 0>, 'SingleSelect': <Mode.SingleSelect: 1>}¶

__module__ = 'csc.tools.selection'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.tools.selection.Mode, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.tools.mirror.Core¶

Mirror tool core class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools.mirror'¶

mirror_frame(self: csc.tools.mirror.Core, arg0: set[csc.model.ObjectId | csc.domain.Tool_object_id]) → None¶

Mirror the frame of the mirror tool. Mirrors a frame based on the specified set of object IDs.

Parameters:: ids (Set[Union[csc.model.ObjectId, csc.domain.Tool_object_id]]) – Set of object IDs to mirror.

mirror_interval(self: csc.tools.mirror.Core, arg0: set[csc.model.ObjectId | csc.domain.Tool_object_id]) → None¶

Mirror the interval of the mirror tool. Mirrors an interval based on the specified set of object IDs.

Parameters:: ids (Set[Union[csc.model.ObjectId, csc.domain.Tool_object_id]]) – Set of object IDs to mirror.
Returns:: None

plane(self: csc.tools.mirror.Core) → csc.math.Plane¶

Get the plane of the mirror tool.

Returns:: Plane of the mirror tool
Return type:: csc.math.Plane

set_plane(self: csc.tools.mirror.Core, plane: csc.math.Plane) → None¶

Set the plane of the mirror tool.

Parameters:: plane (csc.math.Plane) – Plane to set as mirror tool plane.
Returns:: None

class csc.tools.attractor.Args¶

Arguments for configuring attractor operations.

Parameters:

general_settings (csc.tools.attractor.AttractorGeneralSettings) – General settings
mode (csc.tools.attractor.ArgsMode) – Mode
for_interval (bool) – For interval
only_key_frames (bool) – Only key frames
frame_action_on_change (csc.domain.FrameActionOnChange) – Frame action on change
interval_action_on_change (csc.domain.IntervalActionOnChange) – Interval action on change

__annotations__ = {}¶

__init__(self: csc.tools.attractor.Args, scene: csc.domain.Scene, gravity: float, general_settings: csc.tools.attractor.AttractorGeneralSettings, only_key_frames: bool, mode: csc.tools.attractor.ArgsMode, for_interval: bool = False, hard: bool = False, frame_action_on_change: csc.domain.FrameActionOnChange = <FrameActionOnChange.DoNothing: 2>, interval_action_on_change: csc.domain.IntervalActionOnChange = <IntervalActionOnChange.Fixing: 0>) → None¶

__module__ = 'csc.tools.attractor'¶

property for_interval¶

property frame_action_on_change¶

property general_settings¶

property interval_action_on_change¶

property mode¶

property only_key_frames¶

class csc.tools.attractor.ArgsMode¶

attractor::Mode enum

Previous, Next, Inertial, InverseInertial, Average, Interpolation

Members:

Previous

Next

Inertial

InverseInertial

Average

Interpolation

Average = <ArgsMode.Average: 4>¶

Inertial = <ArgsMode.Inertial: 2>¶

Interpolation = <ArgsMode.Interpolation: 5>¶

InverseInertial = <ArgsMode.InverseInertial: 3>¶

Next = <ArgsMode.Next: 1>¶

Previous = <ArgsMode.Previous: 0>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.tools.attractor.ArgsMode) → int¶

__init__(self: csc.tools.attractor.ArgsMode, value: int) → None¶

__int__(self: csc.tools.attractor.ArgsMode) → int¶

__members__ = {'Average': <ArgsMode.Average: 4>, 'Inertial': <ArgsMode.Inertial: 2>, 'Interpolation': <ArgsMode.Interpolation: 5>, 'InverseInertial': <ArgsMode.InverseInertial: 3>, 'Next': <ArgsMode.Next: 1>, 'Previous': <ArgsMode.Previous: 0>}¶

__module__ = 'csc.tools.attractor'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.tools.attractor.ArgsMode, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.tools.attractor.AttractorGeneralSettings¶

__annotations__ = {}¶

__init__(self: csc.tools.attractor.AttractorGeneralSettings) → None¶

__module__ = 'csc.tools.attractor'¶

property factor¶

property mode¶

property mode_relative_to_pivot¶

property physic_type¶

property pivot¶

property position_axis¶

property rotation_axis¶

property scale_axis¶

class csc.tools.attractor.GSAxisFlag¶

GeneralSettings::RotationAxis enum

X, Y, Z, XYZ, Empty

Members:

X

Y

Z

XYZ

Empty

Empty = <GSAxisFlag.Empty: 0>¶

X = <GSAxisFlag.X: 1>¶

XYZ = <GSAxisFlag.XYZ: 7>¶

Y = <GSAxisFlag.Y: 2>¶

Z = <GSAxisFlag.Z: 4>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.tools.attractor.GSAxisFlag) → int¶

__init__(self: csc.tools.attractor.GSAxisFlag, value: int) → None¶

__int__(self: csc.tools.attractor.GSAxisFlag) → int¶

__members__ = {'Empty': <GSAxisFlag.Empty: 0>, 'X': <GSAxisFlag.X: 1>, 'XYZ': <GSAxisFlag.XYZ: 7>, 'Y': <GSAxisFlag.Y: 2>, 'Z': <GSAxisFlag.Z: 4>}¶

__module__ = 'csc.tools.attractor'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.tools.attractor.GSAxisFlag, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.tools.attractor.GSAxisIndex¶

GeneralSettings::RotationAxis enum

X, Y, Z

Members:

X

Y

Z

X = <GSAxisIndex.X: 0>¶

Y = <GSAxisIndex.Y: 1>¶

Z = <GSAxisIndex.Z: 2>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.tools.attractor.GSAxisIndex) → int¶

__init__(self: csc.tools.attractor.GSAxisIndex, value: int) → None¶

__int__(self: csc.tools.attractor.GSAxisIndex) → int¶

__members__ = {'X': <GSAxisIndex.X: 0>, 'Y': <GSAxisIndex.Y: 1>, 'Z': <GSAxisIndex.Z: 2>}¶

__module__ = 'csc.tools.attractor'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.tools.attractor.GSAxisIndex, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.tools.attractor.GSPhysicsType¶

GeneralSettings::RotationAxis enum

FrameRelax, InterpolationRelax

Members:

FrameRelax

InterpolationRelax

FrameRelax = <GSPhysicsType.FrameRelax: 0>¶

InterpolationRelax = <GSPhysicsType.InterpolationRelax: 1>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.tools.attractor.GSPhysicsType) → int¶

__init__(self: csc.tools.attractor.GSPhysicsType, value: int) → None¶

__int__(self: csc.tools.attractor.GSPhysicsType) → int¶

__members__ = {'FrameRelax': <GSPhysicsType.FrameRelax: 0>, 'InterpolationRelax': <GSPhysicsType.InterpolationRelax: 1>}¶

__module__ = 'csc.tools.attractor'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.tools.attractor.GSPhysicsType, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.tools.attractor.GSRotationAxis¶

GeneralSettings::RotationAxis enum

X, Y, Z, Whole, Empty

Members:

X

Y

Z

Whole

Empty

Empty = <GSRotationAxis.Empty: 4>¶

Whole = <GSRotationAxis.Whole: 3>¶

X = <GSRotationAxis.X: 0>¶

Y = <GSRotationAxis.Y: 1>¶

Z = <GSRotationAxis.Z: 2>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.tools.attractor.GSRotationAxis) → int¶

__init__(self: csc.tools.attractor.GSRotationAxis, value: int) → None¶

__int__(self: csc.tools.attractor.GSRotationAxis) → int¶

__members__ = {'Empty': <GSRotationAxis.Empty: 4>, 'Whole': <GSRotationAxis.Whole: 3>, 'X': <GSRotationAxis.X: 0>, 'Y': <GSRotationAxis.Y: 1>, 'Z': <GSRotationAxis.Z: 2>}¶

__module__ = 'csc.tools.attractor'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.tools.attractor.GSRotationAxis, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.tools.attractor.SpaceMode¶

attractor::Mode enum

Global, Local

Members:

Global

Local

Global = <SpaceMode.Global: 0>¶

Local = <SpaceMode.Local: 1>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.tools.attractor.SpaceMode) → int¶

__init__(self: csc.tools.attractor.SpaceMode, value: int) → None¶

__int__(self: csc.tools.attractor.SpaceMode) → int¶

__members__ = {'Global': <SpaceMode.Global: 0>, 'Local': <SpaceMode.Local: 1>}¶

__module__ = 'csc.tools.attractor'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.tools.attractor.SpaceMode, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

csc.tools.attractor.attract(args: csc.tools.attractor.Args) → None¶

csc.view The Cascadeur python module provides basic methods to operate GUI.¶

`csc.view.StandardButton`	StandardButton enum
`csc.view.DialogButton`	DialogButton class
`csc.view.DialogManager`	DialogManager class
`csc.view.FileDialogManager`	FileDialogManager class
`csc.view.Scene`	SceneView class
`csc.view.AnimationBoundary`	AnimationBoundary class
`csc.view.CameraType`	CameraType enumerable
`csc.view.SphericalCameraStruct`	SphericalCameraStruct class
`csc.view.Camera`	Represents a spherical camera class in the view domain.
`csc.view.ViewportDomain`	Domain Viewport class.
`csc.view.Viewport`	Viewport class

class csc.view.AnimationBoundary¶

AnimationBoundary class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.view'¶

property first_frame¶: Set first frame of animation

property first_visible_frame¶: Set first visible frame of animation

property last_frame¶: Set last frame of animation

property last_visible_frame¶: Set last visible frame of animation

class csc.view.Camera¶

Represents a spherical camera class in the view domain.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.view'¶

set_target(self: csc.view.Camera, arg0: numpy.ndarray[numpy.float32[3, 1]]) → None¶

Sets the camera target to a specified point.

Parameters:: arg0 (numpy.ndarray[numpy.float32[3,1]]) – The target point to set the camera to.

zoom_to_points(self: csc.view.Camera, arg0: list[numpy.ndarray[numpy.float32[3, 1]]]) → None¶

Zooms the camera to a specified set of points.

Args: arg0 (numpy.ndarray[numpy.float32[3,1]]) : The set of points to zoom the camera to.

class csc.view.CameraType¶

CameraType enumerable

ISOMETRIC : <CameraType.ISOMETRIC: 0>

PERSPECTIVE : <CameraType.PERSPECTIVE: 1>

Members:

ISOMETRIC

PERSPECTIVE

ISOMETRIC = <CameraType.ISOMETRIC: 0>¶

PERSPECTIVE = <CameraType.PERSPECTIVE: 1>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.view.CameraType) → int¶

__init__(self: csc.view.CameraType, value: int) → None¶

__int__(self: csc.view.CameraType) → int¶

__members__ = {'ISOMETRIC': <CameraType.ISOMETRIC: 0>, 'PERSPECTIVE': <CameraType.PERSPECTIVE: 1>}¶

__module__ = 'csc.view'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.view.CameraType, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.view.DialogButton¶

DialogButton class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.view.DialogButton) -> None
__init__(self: csc.view.DialogButton, arg0: str) -> None
__init__(self: csc.view.DialogButton, text: str, handler: Callable, force_active_focus: bool = False, accent: bool = False) -> None
__init__(self: csc.view.DialogButton, arg0: csc.view.StandardButton) -> None
__init__(self: csc.view.DialogButton, button: csc.view.StandardButton, handler: Callable, force_active_focus: bool = False, accent: bool = False) -> None

__module__ = 'csc.view'¶

force_active_focus(self: csc.view.DialogButton) → bool¶

Returns whether the button should force active focus

Returns:: True if the button should force active focus, False otherwise
Return type:: bool

text(self: csc.view.DialogButton) → str¶

Returns the text of the button

Returns:: The text of the button
Return type:: str

class csc.view.DialogManager¶

DialogManager class

import csc
 def run(scene):
     def callback_button():
         def input_callback(input_values):
             values = ''.join(input_values)
             csc.view.DialogManager.instance().show_info("Input values", values)

         input_field_count = 5
         input_field_names = ["f1", "f2", "f3"]
         input_field_fills = ["v1", "v2", "v3", "v4"]
         csc.view.DialogManager.instance().show_inputs_dialog("Test1", input_field_names, input_field_fills,
                                                              input_field_count, input_callback)

     dialog_buttons = [csc.view.DialogButton('ButtonName', callback_button),
                       csc.view.DialogButton(csc.view.StandardButton.Cancel)]

     csc.view.DialogManager.instance().show_buttons_dialog("Test dialog window", "Press anything", dialog_buttons)

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.view'¶

static instance() → object¶

Returns the instance of the dialog manager

Returns:: The instance of the dialog manager
Return type:: csc.view.DialogManager

show_buttons_dialog(self: csc.view.DialogManager, arg0: str, arg1: str, arg2: list[csc.view.DialogButton]) → None¶

Shows a dialog with buttons

Parameters:

arg0 (str) – The title of the dialog
arg1 (str) – The text of the dialog
arg2 (List[csc.view.DialogButton]) – The list of buttons to show

show_info(self: csc.view.DialogManager, arg0: str, arg1: str) → None¶

Shows an info dialog

Parameters:

arg0 (str) – The title of the dialog
arg1 (str) – The text of the dialog

show_input_dialog(*args, **kwargs)¶

Overloaded function.

show_input_dialog(self: csc.view.DialogManager, arg0: str, arg1: str, arg2: str, arg3: Callable) -> None

Shows an input dialog

Args:
arg0 (str) : The title of the dialog arg1 (str) : The text of the dialog arg2 (str) : The hint of the dialog arg3 (Callable[List[str]]) : The handler of the dialog
show_input_dialog(self: csc.view.DialogManager, arg0: str, arg1: str, arg2: str, arg3: Callable, arg4: Callable) -> None

Shows an input dialog

Args:
arg0 (str) : The title of the dialog arg1 (str) : The text of the dialog arg2 (str) : The hint of the dialog arg3 (Callable[List[str]]) : The handler of the dialog arg4 (Callable[List[str]]) : The validator of the dialog

show_inputs_dialog(self: csc.view.DialogManager, arg0: str, arg1: list[str], arg2: list[str], arg3: int, arg4: Callable) → None¶

Shows an input dialog

Parameters:

arg0 (str) – The title of the dialog
arg1 (List[str]) – The list of texts of the dialog
arg2 (List[str]) – The list of hints of the dialog
arg3 (int) – The size of the dialog
arg4 (Callable[List[str]]) – The handler of the dialog

show_styled_buttons_dialog(self: csc.view.DialogManager, arg0: str, arg1: str, arg2: list[csc.view.DialogButton]) → None¶

Shows a dialog with styled buttons

Parameters:

arg0 (str) – The title of the dialog
arg1 (str) – The text of the dialog
arg2 (List[csc.view.DialogButton]) – The list of buttons to show

class csc.view.FileDialogManager¶

FileDialogManager class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.view'¶

show_folder_dialog(self: csc.view.FileDialogManager, arg0: str, arg1: Callable) → None¶

Shows a folder dialog

Parameters:

arg0 (str) – The title of the dialog
arg1 (Callable[List[str]]) – The handler of the dialog

show_open_file_dialog(self: csc.view.FileDialogManager, title: str, path: str, filters: list[str], handler: Callable) → None¶

Shows an open file dialog

Parameters:

arg0 (str) – The title of the dialog
arg1 (str) – The path of the dialog
arg2 (List[str]) – The list of filters of the dialog
arg3 (Callable[List[str]]) – The handler of the dialog

show_save_file_dialog(self: csc.view.FileDialogManager, title: str, path: str, filters: list[str], handler: Callable) → None¶

Shows a save file dialog

Parameters:

arg0 (str) – The title of the dialog
arg1 (str) – The path of the dialog
arg2 (List[str]) – The list of filters of the dialog
arg3 (Callable[List[str]]) – The handler of the dialog

class csc.view.Scene¶

SceneView class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.view'¶

active_viewport(self: csc.view.Scene) → object¶

Returns active csc.view.Viewport

Returns:: Active csc.view.Viewport
Return type:: csc.view.Viewport

animation_boundary(self: csc.view.Scene) → object¶: -> csc.view.AnimationBoundary

domain_scene(self: csc.view.Scene) → object¶

Return current csc.domain.Scene

Returns:: Current csc.domain.Scene
Return type:: csc.domain.Scene

get_setting_handler(self: csc.view.Scene) → object¶

gravity_per_frame(self: csc.view.Scene) → float¶

name(self: csc.view.Scene) → str¶

save(self: csc.view.Scene, path_name: str) → None¶

Save scene to file

Parameters:: path_name (str) – The path to save the scene

viewports(self: csc.view.Scene) → list[object]¶

Provides all of csc.view.Viewport objects

Returns:: List of csc.view.Viewport objects
Return type:: List[csc.view.Viewport]

class csc.view.SphericalCameraStruct¶

SphericalCameraStruct class

Variables:

target – Get set Vector3f
position – Get set Vector3f
type – Get set CameraType

__annotations__ = {}¶

__init__(self: csc.view.SphericalCameraStruct) → None¶

__module__ = 'csc.view'¶

property position¶

property target¶

property type¶

class csc.view.StandardButton¶

StandardButton enum

This enumerates the basic types of standard buttons. Ok, Cancel, Yes, No

#This script showcases the use of StandardButton in a dialog
import csc
def run(scene):
    dialog_buttons = [csc.view.DialogButton(csc.view.StandardButton.Ok, lambda: scene.success('Pressed Ok')),
                      csc.view.DialogButton(csc.view.StandardButton.Yes, lambda: scene.success('Pressed Yes')),
                      csc.view.DialogButton(csc.view.StandardButton.No, lambda: scene.success('Pressed No')),
                      csc.view.DialogButton(csc.view.StandardButton.Cancel, lambda: scene.success('Pressed Cancel'))]

    csc.view.DialogManager.instance().show_buttons_dialog("Test dialog window", "Press anything", dialog_buttons)

Members:

Ok

Cancel

No

Yes

Cancel = <StandardButton.Cancel: 1>¶

No = <StandardButton.No: 3>¶

Ok = <StandardButton.Ok: 0>¶

Yes = <StandardButton.Yes: 2>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.view.StandardButton) → int¶

__init__(self: csc.view.StandardButton, value: int) → None¶

__int__(self: csc.view.StandardButton) → int¶

__members__ = {'Cancel': <StandardButton.Cancel: 1>, 'No': <StandardButton.No: 3>, 'Ok': <StandardButton.Ok: 0>, 'Yes': <StandardButton.Yes: 2>}¶

__module__ = 'csc.view'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.view.StandardButton, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.view.Viewport¶

Viewport class

import csc
def run(scene):
    application = csc.app.get_application()
    cs = application.current_scene()
    active_viewport = cs.active_viewport().domain_viewport()
    print(f"Active viewport: {active_viewport.id}")

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.view'¶

domain_viewport(self: csc.view.Viewport) → object¶

Get the domain viewport.

Returns:: The domain viewport.
Return type:: csc.view.ViewportDomain

selectable_types(self: csc.view.Viewport) → set[str]¶

Get selectable types for current viewport mode.

Returns:: The selectable types.
Return type:: set(str)

class csc.view.ViewportDomain¶

Domain Viewport class. Represents the Domain ViewPort class that manages properties and functionalities of a viewport in the scene.

Args: camera_struct (csc.view.SphericalCameraStruct) : The camera structure associated with the viewport.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.view'¶

camera(self: csc.view.ViewportDomain) → object¶

Get the camera associated with the viewport.

Returns:: The camera associated with the viewport.
Return type:: csc.view.Camera

camera_struct(self: csc.view.ViewportDomain) → csc.view.SphericalCameraStruct¶

Get the camera structure associated with the viewport.

Returns:: The camera structure associated with the viewport.
Return type:: csc.view.SphericalCameraStruct

id(self: csc.view.ViewportDomain) → csc.Guid¶

Get the ID of the viewport.

Returns:: The ID of the viewport.
Return type:: csc.Guid

is_main(self: csc.view.ViewportDomain) → bool¶

mode_visualizers(self: csc.view.ViewportDomain) → csc.view.ViewportMode¶

Get the mode visualizers of the viewport.

Returns:: The mode visualizers of the viewport.
Return type:: csc.view.ViewportMode

set_camera_struct(self: csc.view.ViewportDomain, camera_struct: csc.view.SphericalCameraStruct) → None¶

Set the camera structure associated with the viewport.

Parameters:: arg0 (csc.view.SphericalCameraStruct) – The camera structure to set.

set_mode_visualizers(self: csc.view.ViewportDomain, mode: csc.view.ViewportMode) → None¶

Set the mode visualizers of the viewport.

Parameters:: arg0 (csc.view.ViewportMode) – The mode visualizers to set.

class csc.view.ViewportMode¶

ViewportMode enumerable

Members:

View

AutoPosing

PointController

Controller

Joint

Mesh

Rigging

ModeCount

AutoPosing = <ViewportMode.AutoPosing: 1>¶

Controller = <ViewportMode.Controller: 3>¶

Joint = <ViewportMode.Joint: 4>¶

Mesh = <ViewportMode.Mesh: 5>¶

ModeCount = <ViewportMode.ModeCount: 7>¶

PointController = <ViewportMode.PointController: 2>¶

Rigging = <ViewportMode.Rigging: 6>¶

View = <ViewportMode.View: 0>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.view.ViewportMode) → int¶

__init__(self: csc.view.ViewportMode, value: int) → None¶

__int__(self: csc.view.ViewportMode) → int¶

__members__ = {'AutoPosing': <ViewportMode.AutoPosing: 1>, 'Controller': <ViewportMode.Controller: 3>, 'Joint': <ViewportMode.Joint: 4>, 'Mesh': <ViewportMode.Mesh: 5>, 'ModeCount': <ViewportMode.ModeCount: 7>, 'PointController': <ViewportMode.PointController: 2>, 'Rigging': <ViewportMode.Rigging: 6>, 'View': <ViewportMode.View: 0>}¶

__module__ = 'csc.view'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.view.ViewportMode, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

csc.view.camera_utils The Cascadeur python module provides utulity methods to manage viewport cameras.¶

csc.view.camera_utils.CameraData

CameraData class

class csc.view.camera_utils.CameraData¶

CameraData class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.view.camera_utils'¶

id(self: csc.view.camera_utils.CameraData) → csc.model.ObjectId¶

isCustom(self: csc.view.camera_utils.CameraData) → bool¶

name(self: csc.view.camera_utils.CameraData) → str¶

csc.view.camera_utils.get_cameras(scene: cascadeur::Scene) → list[csc.view.camera_utils.CameraData]¶

csc.view.camera_utils.is_camera_active(viewport: csc.view.Viewport, camera: csc.view.camera_utils.CameraData) → bool¶

csc.view.camera_utils.reset_camera(scene: csc.view.Viewport) → None¶

csc.view.camera_utils.set_camera_active(viewport: csc.view.Viewport, camera: csc.view.camera_utils.CameraData) → None¶

csc.app The Cascadeur python module provides basic methods to operate GUI.¶

`csc.app.ActionManager`	ActionManager class Represents the ActionManager class that handles actions within the Cascadeur application.
`csc.app.DataSourceManager`	DataSourceManager class.
`csc.app.SettingsManager`	SettingsManager class provides methods to get various settings values.
`csc.app.SceneManager`	SceneManager class.
`csc.app.SceneTool`	SceneTool class provides utility methods and properties to work with scenes.
`csc.app.CascadeurTool`	CascadeurTool class.
`csc.app.ToolsManager`	ToolsManager class provides access to various tools within the application.
`csc.app.Application`	Application class.
`csc.app.ProjectLoader`	ProjectLoader class
`csc.app.StatusManager`	StatusManager class
`csc.app.SimpleStatusInformer`	SimpleStatusInformer class

class csc.app.ActionManager¶

ActionManager class Represents the ActionManager class that handles actions within the Cascadeur application.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

call_action(self: csc.app.ActionManager, arg0: str) → None¶

Call action by key.

Parameters:: key (str) – The key of the action to call.

#This script calls the specified action
import csc

def run(scene):
    mp = csc.app.get_application()
    mp.get_action_manager().call_action("Scene.Undo")

class csc.app.Application¶

Application class. Represents the Application class that serves as the central point for accessing various managers and scene-related operations.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

current_scene(self: csc.app.Application) → object¶

Get the current scene

Returns:: The current scene
Return type:: csc.view.Scene

get_action_manager(self: csc.app.Application) → object¶

Get the action manager

Returns:: The action manager
Return type:: csc.app.ActionManager

get_data_source_manager(self: csc.app.Application) → object¶

Get the data source manager

Returns:: The data source manager
Return type:: csc.app.DataSourceManager

get_file_dialog_manager(self: csc.app.Application) → object¶

get_scene_clipboard(self: csc.app.Application) → object¶

Get the scene clipboard

Returns:: The scene clipboard
Return type:: csc.view.SceneClipboard

get_scene_manager(self: csc.app.Application) → object¶

Get the scene manager

Returns:: The scene manager
Return type:: csc.app.SceneManager

get_setting_manager(self: csc.app.Application) → object¶

Get the settings manager

Returns:: The settings manager
Return type:: csc.app.SettingsManager

get_status_manager(self: csc.app.Application) → object¶

Get the status manager

Returns:: The status manager
Return type:: csc.app.StatusManager

get_tools_manager(self: csc.app.Application) → object¶

Get the tools manager

Returns:: The tools manager
Return type:: csc.app.ToolsManager

class csc.app.CascadeurTool¶

CascadeurTool class. Represents the CascadeurTool class for managing tools and editor functionality in Cascadeur.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

editor(self: csc.app.CascadeurTool, arg0: csc.view.Scene) → csc.app.SceneTool¶

Get the editor of the tool

Parameters:: arg0 (csc.view.Scene) – The scene to get the editor from
Returns:: The editor of the tool
Return type:: csc.view.SceneTool

name(self: csc.app.CascadeurTool) → str¶

Get the name of the tool

Returns:: The name of the tool
Return type:: str

class csc.app.DataSourceManager¶

DataSourceManager class. Represents the DataSourceManager class used for managing data sources and scenes within the application.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

close_scene(self: csc.app.DataSourceManager, scene: csc.view.Scene) → None¶

Close scene

Parameters:: scene (csc.view.Scene) – The scene to close

load_scene(self: csc.app.DataSourceManager, file_name: str) → bool¶

Load scene and all additional datas (selection groups etc) .. Example: .. code-block:: python

linenos:

import csc ds_m = csc.app.get_application().get_data_source_manager() ds_m.load_scene(file_path)

save_current_scene(*args, **kwargs)¶

Overloaded function.

save_current_scene(self: csc.app.DataSourceManager, handler: Callable[[bool], None]) -> None

Save current scene

Args:
handler (Callable[[bool], None]) : The handler
save_current_scene(self: csc.app.DataSourceManager) -> None

Save current scene

save_scene(*args, **kwargs)¶

Overloaded function.

save_scene(self: csc.app.DataSourceManager, scene_view: csc.view.Scene, handler: Callable[[bool], None]) -> None

Save scene and all additional datas (selection groups etc)

Args:
scene_view (csc.view.Scene) : The scene to save handler (Callable[[bool], None]) : The handler
save_scene(self: csc.app.DataSourceManager, scene_view: csc.view.Scene) -> None

Save scene and all additional datas (selection groups etc)

Args:
scene_view (csc.view.Scene) : The scene to save

save_scene_as(self: csc.app.DataSourceManager, scene_view: csc.view.Scene, full_file_name: str) → None¶

Save scene as

Parameters:

scene_view (csc.view.Scene) – The scene to save
full_file_name (str) – The full file name

class csc.app.ProjectLoader¶

ProjectLoader class

Provides methods to load domain scene.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

static load_from(arg0: str, arg1: csc.domain.Scene) → None¶

Minimal Load. This method doesn’t load selection groups, control picker and etc. Better use data_source_manager’s load_scene method.

Parameters:

file_path (str) – The path to the file to load
scene (csc.domain.Scene) – The scene to load the file into

import csc
csc.app.ProjectLoader.load_from(file_path, scene)

class csc.app.SceneManager¶

SceneManager class. SceneManager class provides functionalities to manage scenes within the application.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

create_application_scene(self: csc.app.SceneManager) → object¶

Create a new scene tab

Returns:: The new scene tab
Return type:: csc.view.Scene

current_scene(self: csc.app.SceneManager) → object¶

Get the current scene tab

Returns:: The current scene tab
Return type:: csc.view.Scene

remove_application_scene(self: csc.app.SceneManager, arg0: csc.view.Scene) → None¶

Close the specified scene tab

Parameters:: arg0 (csc.view.Scene) – The scene tab to close

scenes(self: csc.app.SceneManager) → list[object]¶

Get a list of all scene tabs

Returns:: The list of all scene tabs
Return type:: List[csc.view.Scene]

set_current_scene(self: csc.app.SceneManager, arg0: csc.view.Scene) → None¶

Set the specified scene tab as active

Parameters:: arg0 (csc.view.Scene) – The scene tab to set as active

class csc.app.SceneTool¶

SceneTool class provides utility methods and properties to work with scenes.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

class csc.app.SettingsHandler¶

SettingsHandler class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

get_bool_value(self: csc.app.SettingsHandler, arg0: str, arg1: str) → bool¶

get_float_value(self: csc.app.SettingsHandler, arg0: str, arg1: str) → float¶

get_int_value(self: csc.app.SettingsHandler, arg0: str, arg1: str) → int¶

get_string_value(self: csc.app.SettingsHandler, arg0: str, arg1: str) → str¶

class csc.app.SettingsManager¶

SettingsManager class provides methods to get various settings values.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

get_bool_value(self: csc.app.SettingsManager, arg0: str) → bool¶

Get the boolean value of the specified key

Parameters:: arg0 (str) – The key to get the boolean value from
Returns:: The boolean value of the specified key
Return type:: bool

get_color_value(self: csc.app.SettingsManager, arg0: str) → numpy.ndarray[numpy.float32[3, 1]]¶

Get the color value of the specified key

Parameters:: arg0 (str) – The key to get the color value from
Returns:: The color value of the specified key
Return type:: Tuple[float, float, float]

get_float_value(self: csc.app.SettingsManager, arg0: str) → float¶

Get the float value of the specified key

Parameters:: key (str) – The key to get the float value from
Returns:: The float value of the specified key
Return type:: float

class csc.app.SimpleStatusInformer¶

SimpleStatusInformer class

__annotations__ = {}¶

__init__(self: csc.app.SimpleStatusInformer, arg0: str) → None¶

__module__ = 'csc.app'¶

is_canceled(self: csc.app.SimpleStatusInformer) → bool¶

set_blocking(self: csc.app.SimpleStatusInformer, arg0: bool) → None¶

set_cancelable(self: csc.app.SimpleStatusInformer, arg0: bool) → None¶

set_text(self: csc.app.SimpleStatusInformer, arg0: str) → None¶

class csc.app.StatusInformer¶

StatusInformer class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

class csc.app.StatusManager¶

StatusManager class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

remove_status(self: csc.app.StatusManager, arg0: cascadeur::StatusInformer) → None¶

set_status(self: csc.app.StatusManager, arg0: cascadeur::StatusInformer) → None¶

class csc.app.ToolsManager¶

ToolsManager class provides access to various tools within the application.

# This script gets the FbxSceneLoader tool
import csc

def run(scene):
    app = csc.app.get_application()
    tools_manager = app.get_tools_manager()
    # Get specified tool object
    tools_manager.get_tool("FbxSceneLoader")

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

get_tool(self: csc.app.ToolsManager, arg0: str) → object¶

Returns the specified tool based on its name.

Parameters:: arg0 (str) – The name of the tool to get
Returns:: The specified tool object
Return type:: csc.app.CascadeurTool

tools(self: csc.app.ToolsManager) → list[object]¶

csc.app.get_application() → object¶

Get the application instance

Returns:: The application instance
Return type:: csc.app.Application

# Example usage:
# This script gets the current app instance
import csc

def run(scene):
    app = csc.app.get_application()

csc.parts The Cascadeur python module provides basic methods to operate scene parts.¶

`csc.parts.Type`	Type of the parts, enum
`csc.parts.Info`	Info class
`csc.parts.GroupInfo`	GroupInfo class
`csc.parts.SceneClipboard`	SceneClipboard class Provides methods to operate parts of the scene.
`csc.parts.Buffer`	Buffer class

class csc.parts.Buffer¶

Buffer class

Provides methods to operate parts of the scene.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.parts'¶

static get() → object¶

insert_elementary_by_id(self: csc.parts.Buffer, arg0: csc.model.ObjectId, arg1: csc.update.GroupId, arg2: csc.model.ModelEditor) → csc.parts.GroupInfo¶

insert_elementary_by_path(self: csc.parts.Buffer, arg0: str, arg1: csc.update.GroupId, arg2: csc.model.ModelEditor) → csc.parts.GroupInfo¶

insert_object_by_id(self: csc.parts.Buffer, arg0: csc.model.ObjectId, arg1: csc.update.GroupId, arg2: csc.model.ModelEditor, arg3: csc.domain.assets.AssetsManager) → csc.model.ObjectId¶

insert_object_by_path(self: csc.parts.Buffer, arg0: str, arg1: csc.update.GroupId, arg2: csc.model.ModelEditor, arg3: csc.domain.assets.AssetsManager) → csc.model.ObjectId¶

insert_objects_by_id(self: csc.parts.Buffer, arg0: csc.model.ObjectId, arg1: csc.update.GroupId, arg2: csc.model.ModelEditor, arg3: csc.domain.assets.AssetsManager) → tuple[set[csc.model.ObjectId], set[csc.update.GroupId]]¶

insert_objects_by_path(self: csc.parts.Buffer, arg0: str, arg1: csc.update.GroupId, arg2: csc.model.ModelEditor, arg3: csc.domain.assets.AssetsManager) → tuple[set[csc.model.ObjectId], set[csc.update.GroupId]]¶

insert_selected_objects_by_path(self: csc.parts.Buffer, arg0: str, arg1: csc.update.GroupId, arg2: csc.model.ModelEditor, arg3: csc.domain.assets.AssetsManager) → set[csc.model.ObjectId]¶

insert_update_group_by_id(self: csc.parts.Buffer, arg0: csc.model.ObjectId, arg1: csc.update.GroupId, arg2: csc.model.ModelEditor) → tuple[csc.parts.GroupInfo, dict[csc.update.GroupId, csc.parts.GroupInfo]]¶

insert_update_group_by_path(self: csc.parts.Buffer, arg0: str, arg1: csc.update.GroupId, arg2: csc.model.ModelEditor) → tuple[csc.parts.GroupInfo, dict[csc.update.GroupId, csc.parts.GroupInfo]]¶

refresh(self: csc.parts.Buffer) → None¶

class csc.parts.GroupInfo¶

GroupInfo class

Variables:

type – Get set Data::Id{}
name – Get set Setting::Id{}
path – Get set HyperedgeId{}
object_id – Get set SettingFunctionId{}

__annotations__ = {}¶

__init__(self: csc.parts.GroupInfo) → None¶

__module__ = 'csc.parts'¶

property datas¶

property regular_funcs¶

property settings¶

property settings_funcs¶

class csc.parts.Info¶

Info class

Variables:

type – Get csc.parts.Type
name – Get string
path – Get string
object_id – Get csc.model.ObjectId

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.parts'¶

property name¶

property object_id¶

property path¶

property type¶

class csc.parts.SceneClipboard¶

SceneClipboard class Provides methods to operate parts of the scene.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.parts'¶

copy(self: csc.parts.SceneClipboard, arg0: csc.view.Scene) → None¶

copy_image_to_clipboard(self: csc.parts.SceneClipboard, arg0: csc.view.Scene) → None¶

paste(self: csc.parts.SceneClipboard, arg0: csc.view.Scene) → None¶

paste_with_session(self: csc.parts.SceneClipboard, arg0: csc.view.Scene, arg1: csc.domain.Session) → None¶

class csc.parts.Type¶

Type of the parts, enum

Elementary: includes only regular and setting functions + regular and setting data + connections that link them UpdateGroup: sub update groups and their elementary entities + connections that link them Object: includes all related entities of some object ObjectGroup: includes all objects and sub object groups and all related entities SelectedObjects: selected objects from different groups

Members:

Elementary

UpdateGroup

Object

ObjectGroup

SelectedObjects

Elementary = <Type.Elementary: 0>¶

Object = <Type.Object: 2>¶

ObjectGroup = <Type.ObjectGroup: 3>¶

SelectedObjects = <Type.SelectedObjects: 4>¶

UpdateGroup = <Type.UpdateGroup: 1>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.parts.Type) → int¶

__init__(self: csc.parts.Type, value: int) → None¶

__int__(self: csc.parts.Type) → int¶

__members__ = {'Elementary': <Type.Elementary: 0>, 'Object': <Type.Object: 2>, 'ObjectGroup': <Type.ObjectGroup: 3>, 'SelectedObjects': <Type.SelectedObjects: 4>, 'UpdateGroup': <Type.UpdateGroup: 1>}¶

__module__ = 'csc.parts'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.parts.Type, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

csc.external The Cascadeur python module provides basic api to external data formats.¶

`csc.external.ExtraDatas`	ExtraDatas class
`csc.external.FbxDatas`	FbxDatas class

class csc.external.ExtraDatas¶

ExtraDatas class

__annotations__ = {}¶

__init__(self: csc.external.ExtraDatas) → None¶

__module__ = 'csc.external'¶

property look¶

property node_index¶

property post_rotation¶

property pre_rotation¶

property size¶

class csc.external.FbxDatas¶

FbxDatas class

__annotations__ = {}¶

__init__(self: csc.external.FbxDatas) → None¶

__module__ = 'csc.external'¶

property ignore_namespace¶

property order¶

property rotation¶

property scale¶

property translation¶

csc.fbx The Cascadeur python module provides basic methods to operate fbx.¶

`csc.fbx.FbxSettingsMode`	FbxSettingsMode enumeration
`csc.fbx.FbxSettingsAxis`	FbxSettingsAxis enumeration
`csc.fbx.FbxSettings`	FbxSettings class.
`csc.fbx.FbxLoader`	FbxLoader class.
`csc.fbx.FbxSceneLoader`	FbxSceneLoader class.

class csc.fbx.FbxLoader¶

FbxLoader class.

Provides methods to import and export FBX files.

# This script imports a specified FBX file into the current scene
import csc

def run(scene):
    app = csc.app.get_application()

    def import_scene(folder_path: str):
        file_ = folder_path.replace('\\', '/')
        scene_manager = app.get_scene_manager()
        tools_manager = app.get_tools_manager()
        # Get current scene tab
        current_scene = scene_manager.current_scene()
        # Get FbxSceneLoader tool
        fbx_scene_loader_tool = tools_manager.get_tool("FbxSceneLoader")
        # Get FbxLoader
        fbx_scene_loader = fbx_scene_loader_tool.get_fbx_loader(current_scene)
        # Import fbx file as a scene
        fbx_scene_loader.import_scene(file_)

    app.get_file_dialog_manager().show_open_file_dialog("Select .fbx file", "", ["*.fbx"], import_scene)

# This script imports animation data from the specified FBX file
import csc

def run(scene):
    app = csc.app.get_application()

    def import_animation(folder_path: str):
        file_ = folder_path.replace('\\', '/')
        scene_manager = app.get_scene_manager()
        tools_manager = app.get_tools_manager()
        # Get current scene tab
        current_scene = scene_manager.current_scene()
        # Get FbxSceneLoader tool
        fbx_scene_loader_tool = tools_manager.get_tool("FbxSceneLoader")
        # Get FbxLoader
        fbx_scene_loader = fbx_scene_loader_tool.get_fbx_loader(current_scene)
        # Import fbx file as a scene
        fbx_scene_loader.import_animation(file_)

    app.get_file_dialog_manager().show_open_file_dialog("Select .fbx file", "", ["*.fbx"], import_animation)

# This script imports animation data from the specified FBX file
import csc

def run(scene):
    app = csc.app.get_application()

    def import_animation(folder_path: str):
        file_ = folder_path.replace('\\', '/')
        scene_manager = app.get_scene_manager()
        tools_manager = app.get_tools_manager()
        # Get current scene tab
        current_scene = scene_manager.current_scene()
        # Get FbxSceneLoader tool
        fbx_scene_loader_tool = tools_manager.get_tool("FbxSceneLoader")
        # Get FbxLoader
        fbx_scene_loader = fbx_scene_loader_tool.get_fbx_loader(current_scene)
        # Import fbx file as a scene
        fbx_scene_loader.import_animation(file_)

    app.get_file_dialog_manager().show_open_file_dialog("Select .fbx file", "", ["*.fbx"], import_animation)

__annotations__ = {}¶

__init__(self: csc.fbx.FbxLoader, fps: float, handler: csc.domain.IMessageHandler, scene: csc.view.Scene) → None¶

__module__ = 'csc.fbx'¶

add_model(self: csc.fbx.FbxLoader, file_name: csc.Path) → None¶

Adds the model from the specified file.

Parameters:: file_name (str) – The name of the file to add the model from

add_model_to_selected(self: csc.fbx.FbxLoader, file_name: csc.Path) → None¶

Adds the model to the selected objects from the specified file.

Parameters:: file_name (str) – The name of the file to add the model from

export_all_objects(self: csc.fbx.FbxLoader, file_name: csc.Path) → None¶

Exports all objects to the specified file.

Parameters:: file_name (str) – The name of the file to export the objects to

export_joints(self: csc.fbx.FbxLoader, file_name: str) → None¶

Exports the joints to the specified file.

Parameters:: file_name (str) – The name of the file to export the joints to

export_joints_selected(self: csc.fbx.FbxLoader, file_name: str) → None¶

Exports the joints to the selected objects from the specified file.

Parameters:: file_name (str) – The name of the file to export the joints to

export_joints_selected_frames(self: csc.fbx.FbxLoader, file_name: str) → None¶

Exports the joints to the selected frames from the specified file.

Parameters:: file_name (str) – The name of the file to export the joints to

export_joints_selected_objects(self: csc.fbx.FbxLoader, file_name: str) → None¶

Exports the joints to the selected objects from the specified file.

Parameters:: file_name (str) – The name of the file to export the joints to

export_model(self: csc.fbx.FbxLoader, file_name: csc.Path) → None¶

Exports the model to the specified file.

Parameters:: file_name (str) – The name of the file to export the model to

export_scene_selected(self: csc.fbx.FbxLoader, file_name: str) → None¶

Exports the scene to the selected objects from the specified file.

Parameters:: file_name (str) – The name of the file to export the scene to

export_scene_selected_frames(self: csc.fbx.FbxLoader, file_name: str) → None¶

Exports the scene to the selected frames from the specified file.

Parameters:: file_name (str) – The name of the file to export the scene to

export_scene_selected_objects(self: csc.fbx.FbxLoader, file_name: str) → None¶

Exports the scene to the selected objects from the specified file.

Parameters:: file_name (str) – The name of the file to export the scene to

get_takes(self: csc.fbx.FbxLoader, file_name: csc.Path) → list[str]¶

Get animation takes the specified file.

Parameters:: file_name (str) – The name of the file to import the animation from

import_animation(self: csc.fbx.FbxLoader, file_name: csc.Path, num_take: int = -1) → None¶

Imports the animation from the specified file.

Parameters:

file_name (str) – The name of the file to import the animation from
num_take (int) – Take number from the list received from get_takes

import_animation_to_selected_frames(self: csc.fbx.FbxLoader, file_name: csc.Path, num_take: int = -1) → None¶

Imports the animation to the selected frames from the specified file.

Parameters:

file_name (str) – The name of the file to import the animation from
num_take (int) – Take number from the list received from get_takes

import_animation_to_selected_objects(self: csc.fbx.FbxLoader, file_name: csc.Path, num_take: int = -1) → None¶

Imports the animation to the selected objects from the specified file.

Parameters:

file_name (str) – The name of the file to import the animation from
num_take (int) – Take number from the list received from get_takes

import_model(self: csc.fbx.FbxLoader, file_name: csc.Path) → None¶

Imports the model from the specified file.

Parameters:: file_name (str) – The name of the file to import the model from

import_scene(self: csc.fbx.FbxLoader, file_name: csc.Path, num_take: int = -1, is_set_offset: bool = True) → None¶

Imports the scene from the specified file.

Parameters:

file_name (str) – The name of the file to import the scene from
num_take (int) – Take number from the list received from get_takes

set_settings(self: csc.fbx.FbxLoader, settings: csc.fbx.FbxSettings) → None¶

Sets the settings.

Parameters:: settings (csc.fbx.FbxSettings) – The settings

class csc.fbx.FbxSceneLoader¶

FbxSceneLoader class.

Provides methods to import and export FBX scenes.

# This script gets the FbxLoader in the specified scene
import csc

def run(scene):
    app = csc.app.get_application()
    scene_manager = app.get_scene_manager()
    tools_manager = app.get_tools_manager()
    # Get current scene tab
    current_scene = scene_manager.current_scene()
    # Get FbxSceneLoader tool
    fbx_scene_loader_tool = tools_manager.get_tool("FbxSceneLoader")
    # Get FbxLoader
    fbx_scene_loader = fbx_scene_loader_tool.get_fbx_loader(current_scene)

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.fbx'¶

export_fbx_scene(self: csc.fbx.FbxSceneLoader, scene: csc.view.Scene, file_name: str) → None¶

Exports the scene to the specified file.

Parameters:

scene (csc.view.Scene) – The scene
file_name (str) – The name of the file to export the scene to

get_fbx_loader(self: csc.fbx.FbxSceneLoader, scene: csc.view.Scene) → csc.fbx.FbxLoader¶

Gets the FbxLoader.

Parameters:: scene (csc.view.Scene) – The scene
Returns:: csc.fbx.FbxLoader

import_fbx_animation(self: csc.fbx.FbxSceneLoader, scene: csc.view.Scene, file_name: str) → None¶

Imports the animation from the specified file.

Parameters:

scene (csc.view.Scene) – The scene
file_name (str) – The name of the file to import the animation from

import_fbx_scene(self: csc.fbx.FbxSceneLoader, scene: csc.view.Scene, file_name: str) → None¶

Imports the scene from the specified file.

Parameters:

scene (csc.view.Scene) – The scene
file_name (str) – The name of the file to import the scene from

class csc.fbx.FbxSettings¶

FbxSettings class. For configuring FBX import/export options.

Parameters:

mode (csc.fbx.FbxSettingsMode) – The mode
up_axis (csc.fbx.FbxSettingsAxis) – The up axis
bake_animation (bool) – The bake animation flag
apply_euler_filter (bool) – The apply euler filter flag

# This script uses custom FBX settings for scene export
import csc
from csc import fbx

def run(scene):
    app = csc.app.get_application()
    fd_m = app.get_file_dialog_manager()

    def export_scene(file_name):
        # Initialize FbxSettings
        settings = fbx.FbxSettings()
        # Set the Fbx type - Ascii or Binary
        settings.mode = fbx.FbxSettingsMode.Ascii
        # Turn on or off the euler filter being applied on the exported animation
        settings.apply_euler_filter = False
        # Set up the up axis (X, Y or Z)
        settings.up_axis = fbx.FbxSettingsAxis.Y

        scene_manager = app.get_scene_manager()
        tools_manager = app.get_tools_manager()
        current_scene = scene_manager.current_scene()

        fbx_scene_loader_tool = tools_manager.get_tool("FbxSceneLoader")
        fbx_scene_loader = fbx_scene_loader_tool.get_fbx_loader(current_scene)
        fbx_scene_loader.set_settings(settings)
        fbx_scene_loader.export_all_objects(file_name)

        fd_m.show_save_file_dialog("Choose filename fbx", "", ["*.fbx"], export_scene)

__annotations__ = {}¶

__init__(self: csc.fbx.FbxSettings) → None¶

__module__ = 'csc.fbx'¶

property apply_euler_filter¶

property bake_animation¶

property mode¶

property up_axis¶

class csc.fbx.FbxSettingsAxis¶

FbxSettingsAxis enumeration

Binary, Ascii

Members:

X

Y

Z

X = <FbxSettingsAxis.X: 0>¶

Y = <FbxSettingsAxis.Y: 1>¶

Z = <FbxSettingsAxis.Z: 2>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.fbx.FbxSettingsAxis) → int¶

__init__(self: csc.fbx.FbxSettingsAxis, value: int) → None¶

__int__(self: csc.fbx.FbxSettingsAxis) → int¶

__members__ = {'X': <FbxSettingsAxis.X: 0>, 'Y': <FbxSettingsAxis.Y: 1>, 'Z': <FbxSettingsAxis.Z: 2>}¶

__module__ = 'csc.fbx'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.fbx.FbxSettingsAxis, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.fbx.FbxSettingsMode¶

FbxSettingsMode enumeration

Binary, Ascii

# This script exports FBX file with a custom FBX type
import csc
from csc import fbx

def run(scene):
    app = csc.app.get_application()
    fd_m = app.get_file_dialog_manager()

    def export_scene(file_name):
        # Initialize FbxSettings
        settings = fbx.FbxSettings()
        # Set the Fbx type - Ascii or Binary
        settings.mode = fbx.FbxSettingsMode.Binary

        scene_manager = app.get_scene_manager()
        tools_manager = app.get_tools_manager()
        current_scene = scene_manager.current_scene()

        fbx_scene_loader_tool = tools_manager.get_tool("FbxSceneLoader")
        fbx_scene_loader = fbx_scene_loader_tool.get_fbx_loader(current_scene)
        fbx_scene_loader.set_settings(settings)
        fbx_scene_loader.export_all_objects(file_name)

    fd_m.show_save_file_dialog("Choose filename fbx", "", ["*.fbx"], export_scene)

Members:

Binary

Ascii

Ascii = <FbxSettingsMode.Ascii: 1>¶

Binary = <FbxSettingsMode.Binary: 0>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.fbx.FbxSettingsMode) → int¶

__init__(self: csc.fbx.FbxSettingsMode, value: int) → None¶

__int__(self: csc.fbx.FbxSettingsMode) → int¶

__members__ = {'Ascii': <FbxSettingsMode.Ascii: 1>, 'Binary': <FbxSettingsMode.Binary: 0>}¶

__module__ = 'csc.fbx'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.fbx.FbxSettingsMode, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

csc.rig The Cascadeur python module that implements the basic functions for operating a rig.¶

`csc.rig.AddElementData`	AddElementData class for managing element additions in the rigging process.
`csc.rig.BoneProperty`
`csc.rig.TwistProperty`
`csc.rig.TwistBoneProperty`
`csc.rig.QrtData`

class csc.rig.AddElementData¶

AddElementData class for managing element additions in the rigging process.

Parameters:

only_box_controller (bool) – Only box controller
is_multiple (bool) – Is multiple
box_multiplier (int) – Box multiplier
axis_point_controller (int) – Axis point controller
use_global_axis (bool) – Use global axis
orthogonal_with_parent (bool) – Orthogonal with parent
offset_point_controller (int) – Offset point controller
joint_size_without_child (float) – Joint size without child
point_color (numpy.ndarray) – Point color

__annotations__ = {}¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.rig.AddElementData) -> None
__init__(self: csc.rig.AddElementData, arg0: bool, arg1: bool, arg2: int, arg3: int, arg4: bool, arg5: bool, arg6: int, arg7: float, arg8: numpy.ndarray[numpy.float32[3, 1]]) -> None

__module__ = 'csc.rig'¶

property axis_point_controller¶

property box_multiplier¶

property is_multiple¶

property joint_size_without_child¶

property offset_point_controller¶

property only_box_controller¶

property orthogonal_with_parent¶

property point_color¶

property use_global_axis¶

class csc.rig.BoneProperty¶

__annotations__ = {}¶

__init__(self: csc.rig.BoneProperty) → None¶

__module__ = 'csc.rig'¶

property bone_name¶

property joint_path_name¶

property object_id¶

property required_field¶

class csc.rig.QrtData¶

__annotations__ = {}¶

__init__(self: csc.rig.QrtData) → None¶

__module__ = 'csc.rig'¶

property body¶

property hinge_arm_direction¶

property hinge_leg_direction¶

property is_align_pelvis¶

property is_create_layers¶

property is_replace_existing¶

property is_spline_ik¶

property left_hand¶

property quadruped¶

property right_hand¶

property twists¶

property untwists¶

class csc.rig.QuadrupedBoneProperty¶

__annotations__ = {}¶

__init__(self: csc.rig.QuadrupedBoneProperty) → None¶

__module__ = 'csc.rig'¶

property left_fore_paw¶

property left_hind_paw¶

property right_fore_paw¶

property right_hind_paw¶

property trunk¶

class csc.rig.TwistBoneProperty¶

__annotations__ = {}¶

__init__(self: csc.rig.TwistBoneProperty) → None¶

__module__ = 'csc.rig'¶

property bone_name¶

property twist_properties¶

class csc.rig.TwistProperty¶

__annotations__ = {}¶

__init__(self: csc.rig.TwistProperty) → None¶

__module__ = 'csc.rig'¶

property autocompute_strength¶

property joint_path_name¶

property object_id¶

property twist_axis¶

property twist_strength¶

class csc.rig.UntwistBoneProperty¶

__annotations__ = {}¶

__init__(self: csc.rig.UntwistBoneProperty) → None¶

__module__ = 'csc.rig'¶

property bone_name¶

property joint_path¶

property object_id¶

property used¶

csc.layers The Cascadeur python module that implements scene layers functionality.¶

LayerId == FolderId == ItemId == Guid

`csc.layers.Header`	Header class
`csc.layers.ItemVariant`	ItemVariant class
`csc.layers.Folder`	Folder class
`csc.layers.Layer`	Layer class
`csc.layers.Viewer`	Viewer class
`csc.layers.Editor`	Editor class
`csc.layers.Selector`	Selector class
`csc.layers.LayersContainer`	LayersContainer class
`csc.layers.UserLabelData`	UserLabelData class
`csc.layers.Layers`	Layers class
`csc.layers.Cycle`	Cycle class.
`csc.layers.CyclesViewer`	Cycle viewer class.
`csc.layers.CyclesEditor`	Cycle editor class.
`csc.layers.LayersSelectionChanger`	Layer SelectionChanger class
`csc.layers.layer.Interpolation`	Interpolation enumerable
`csc.layers.layer.Tangents`	Layer Frame Tangents enumerable
`csc.layers.layer.IkFk`	Layer Frame IkFk enumerable
`csc.layers.layer.Fixation`	Layer Frame Fixation enumerable
`csc.layers.layer.Common`	Common class
`csc.layers.layer.Key`	Key class
`csc.layers.layer.Interval`	Interval class
`csc.layers.layer.Section`	Section class
`csc.layers.layer.Cell`	Cell class
`csc.layers.index.FramesInterval`	FramesInterval class
`csc.layers.index.FramesIndices`	FramesIndices class
`csc.layers.index.CellIndex`	CellIndex class
`csc.layers.index.RectIndicesContainer`	RectIndicesContainer class
`csc.layers.index.IndicesContainer`	IndicesContainer class

class csc.layers.Cycle¶

Cycle class. Represents a cycle within the layer structure, containing information about active and inactive frames.

left_inactive_frame_index¶

The index of the left inactive frame.

Type:: int

right_inactive_frame_index¶

The index of the right inactive frame.

Type:: int

first_active_frame_index¶

The index of the first active frame.

Type:: int

last_active_frame_index¶

The index of the last active frame.

Type:: int

following_interval¶

The following interval.

Type:: int

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.layers'¶

property first_active_frame_index¶

property following_interval¶

static get_no_pos() → int¶

is_the_same_frames_as(self: csc.layers.Cycle, other_cycle: csc.layers.Cycle) → bool¶

Checks if the current cycle has the same frames as another cycle.

Parameters:: other_cycle (csc.layers.Cycle) – The other cycle to compare with.
Returns:: True if the cycles have the same frames, False otherwise.
Return type:: bool

property last_active_frame_index¶

left_frame_index(self: csc.layers.Cycle) → int¶

Retrieves the index of the left frame in the cycle.

Returns:: The index of the left frame.
Return type:: int

property left_inactive_frame_index¶

right_frame_index(self: csc.layers.Cycle) → int¶

Retrieves the index of the right frame in the cycle.

Returns:: The index of the right frame.
Return type:: int

property right_inactive_frame_index¶

class csc.layers.CyclesEditor¶

Cycle editor class. Represents an editor for managing cycles within layers

__annotations__ = {}¶

__init__(self: csc.layers.CyclesEditor, layer: csc.layers.Layer) → None¶

__module__ = 'csc.layers'¶

change_inactive_parts(self: csc.layers.CyclesEditor, arg0: int, arg1: int, arg2: int) → None¶

create_cycle(self: csc.layers.CyclesEditor, arg0: int, arg1: int, arg2: bool) → csc.layers.Cycle¶

Creates a cycle within the layer structure.

Parameters:

left_inactive_frame_index (int) – The index of the left inactive frame.
right_inactive_frame_index (int) – The index of the right inactive frame.
first_active_frame_index (int) – The index of the first active frame.
last_active_frame_index (int) – The index of the last active frame.
following_interval (int) – The following interval.

Returns:

The created cycle.

Return type:

csc.layers.Cycle

delete_cycle(self: csc.layers.CyclesEditor, arg0: int) → None¶

Deletes a cycle from the layer structure.

Parameters:: cycle (csc.layers.Cycle) – The cycle to delete.

find_cycle(self: csc.layers.CyclesEditor, arg0: int) → object¶

Finds a cycle by the specified position.

Parameters:: pos (int) – The position to search for.
Returns:: The found cycle.
Return type:: csc.layers.Cycle

normalize(self: csc.layers.CyclesEditor) → None¶

class csc.layers.CyclesViewer¶

Cycle viewer class. Provides methods for viewing and interacting with cycles within a layer.

__annotations__ = {}¶

__init__(self: csc.layers.CyclesViewer, layer: csc.layers.Layer) → None¶

__module__ = 'csc.layers'¶

any_cycles_exist_in_frames(self: csc.layers.CyclesViewer, arg0: int, arg1: int) → bool¶

Checks if any cycles exist within the specified frames.

Parameters:

first_frame_index (int) – The index of the first frame.
last_frame_index (int) – The index of the last frame.

Returns:

True if any cycles exist within the frames, False otherwise.

Return type:

bool

cycle_contains_frame_index(self: csc.layers.CyclesViewer, arg0: csc.layers.Cycle, arg1: int) → bool¶

Checks if the cycle contains the specified frame index.

Parameters:: frame_index (int) – The frame index to check.
Returns:: True if the cycle contains the frame index, False otherwise.
Return type:: bool

find_cycle(self: csc.layers.CyclesViewer, arg0: int) → object¶

Finds a cycle by the specified position.

Parameters:: pos (int) – The position to search for.
Returns:: The found cycle.
Return type:: csc.layers.Cycle

get_active_pos(self: csc.layers.CyclesViewer, arg0: int) → int¶

Retrieves the active position of the cycle.

Returns:: The active position of the cycle.
Return type:: int

get_active_section_pos(self: csc.layers.CyclesViewer, arg0: int) → int¶

Retrieves the active section position of the cycle.

Returns:: The active section position of the cycle.
Return type:: int

get_cycles_in_frames(self: csc.layers.CyclesViewer, arg0: int, arg1: int) → list[csc.layers.Cycle]¶

Retrieves the cycles within the specified frames.

Parameters:

first_frame_index (int) – The index of the first frame.
last_frame_index (int) – The index of the last frame.

Returns:

The cycles within the frames.

Return type:

List[csc.layers.Cycle]

get_most_left_and_right_frame_indices_of_cycle(self: csc.layers.CyclesViewer, arg0: csc.layers.Cycle) → tuple[int, int]¶

Retrieves the most left and right frame indices of the cycle.

Returns:: The most left and right frame indices of the cycle.
Return type:: Tuple[int, int]

is_pos_in_active_cycle_zone(self: csc.layers.CyclesViewer, arg0: int) → bool¶

Checks if the specified position is within the active cycle zone.

Parameters:: pos (int) – The position to check.
Returns:: True if the position is within the active cycle zone, False otherwise.
Return type:: bool

is_pos_in_inactive_cycle_zone(self: csc.layers.CyclesViewer, arg0: int) → bool¶

Checks if the specified position is within the inactive cycle zone.

Parameters:: pos (int) – The position to check.
Returns:: True if the position is within the inactive cycle zone, False otherwise.
Return type:: bool

last_pos(self: csc.layers.CyclesViewer) → int¶

class csc.layers.Editor¶

Editor class

This class contains all methods and properties that need to edit the structure of scene objects’ interpolation properties. The structure is represented in the hierarchy of layers divided by folders.

Variables:

create_folder – name : string, parent : FolderId, withDefaultLayer : bool (true), pos : int or None, -> FolderId
create_layer – name : string, parent : FolderId, pos : int or None, -> FolderId
set_fixed_interpolation_if_need – overridden method by ItemId, int, int || LayerId, int (frame)
set_fixed_interpolation_or_key_if_need – overridden method by LayerId, int, bool

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.layers'¶

change_section(self: csc.layers.Editor, arg0: int, arg1: csc.Guid, arg2: Callable) → None¶

clear(self: csc.layers.Editor) → None¶

create_folder(self: csc.layers.Editor, name: str, parent: csc.Guid, with_default_layer: bool = True, pos: int | None = None) → csc.Guid¶: name : string | parent : FolderId | withDefaultLayer : bool (true) | pos : int or None | -> FolderId

create_layer(self: csc.layers.Editor, name: str, parent: csc.Guid, pos: int | None = None) → csc.Guid¶: name : string | parent : FolderId | pos : int or None | -> FolderId

delete_empty_folders(self: csc.layers.Editor) → None¶

delete_empty_layers(self: csc.layers.Editor) → None¶

delete_folder(self: csc.layers.Editor, id: csc.Guid) → None¶

delete_layer(self: csc.layers.Editor, id: csc.Guid) → None¶

find_header(self: csc.layers.Editor, arg0: csc.Guid) → object¶: -> Header

insert_layer(self: csc.layers.Editor, layer: csc.layers.Layer, pos: int | None) → None¶: layer : Layer | pos : int or None

move_item(self: csc.layers.Editor, item_id: csc.Guid, folder_id: csc.Guid, pos: int | None = None) → None¶: pos : int or None

normalize_sections(self: csc.layers.Editor, scene: domain::scene::Scene) → None¶

set_default(self: csc.layers.Editor) → None¶

set_fixed_interpolation_if_need(*args, **kwargs)¶

Overloaded function.

set_fixed_interpolation_if_need(self: csc.layers.Editor, id: csc.Guid, start: int, end: int) -> bool
set_fixed_interpolation_if_need(self: csc.layers.Editor, id: csc.Guid, frame: int) -> bool

set_fixed_interpolation_or_key_if_need(self: csc.layers.Editor, id: csc.Guid, frame: int, set_key: bool) → bool¶

set_locked_for_item(self: csc.layers.Editor, is_l: bool, id: csc.Guid) → None¶: isL : bool | id : ItemId

set_locked_for_layer(self: csc.layers.Editor, is_l: bool, id: csc.Guid) → None¶: isL : bool | id : LayerId

set_name(self: csc.layers.Editor, name: str, id: csc.Guid) → None¶

set_section(self: csc.layers.Editor, section: domain::scene::layers::layer::Section, pos: int, id: csc.Guid) → None¶: section : Section | pos : int | id : ItemId

set_sections(self: csc.layers.Editor, arg0: dict[int, domain::scene::layers::layer::Section], arg1: csc.Guid) → None¶: section : <Pos, Section>{} | id : LayerId

set_visible_for_item(self: csc.layers.Editor, is_v: bool, id: csc.Guid) → None¶: isV : bool | id : ItemId

set_visible_for_layer(self: csc.layers.Editor, is_v: bool, id: csc.Guid) → None¶: isV : bool | id : LayerId

unset_section(self: csc.layers.Editor, pos: int, id: csc.Guid) → None¶: pos : int | id : ItemId

class csc.layers.Folder¶

Folder class

Implements the parent folder properties of children layers and sub folders items

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.layers'¶

child_by_id(self: csc.layers.Folder, id: csc.Guid) → csc.Guid¶: -> ItemId

child_by_pos(self: csc.layers.Folder, pos: int) → csc.Guid¶: pos : int -> ItemId

child_pos(self: csc.layers.Folder, id: csc.Guid) → int¶: id : ItemId | -> int

children_cnt(self: csc.layers.Folder) → int¶: -> int

children_ids(self: csc.layers.Folder) → list[csc.Guid]¶: -> ItemId[]

children_ordered(self: csc.layers.Folder) → list[csc.Guid]¶: -> ItemId[]

has_child(self: csc.layers.Folder, id: csc.Guid) → bool¶

property header¶: -> Header

is_empty(self: csc.layers.Folder) → bool¶

class csc.layers.Header¶

Header class

Describes the header properties for a folder

Variables:

parent – Get set csc.Guid
id – Get set csc.Guid
name – Get set string

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.layers'¶

property id¶

property name¶

property parent¶

class csc.layers.ItemVariant¶

ItemVariant class

Can implement a folder or layer for a header

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.layers'¶

folder(self: csc.layers.ItemVariant) → domain::scene::layers::Folder¶: -> Folder (if it has folder otherwise none)

header(self: csc.layers.ItemVariant) → csc.layers.Header¶: -> Header

is_folder(self: csc.layers.ItemVariant) → bool¶

is_layer(self: csc.layers.ItemVariant) → bool¶

layer(self: csc.layers.ItemVariant) → domain::scene::layers::Layer¶: -> Layer (if it has layer otherwise none)

class csc.layers.Layer¶

Layer class

The Layer is the basic element that implements intervals and sections to set interpolation properties of scene objects

Variables:

header – Get Header
is_locked – Get bool
is_visible – Get bool
obj_ids – Get csc.Guid{}
sections – Get std::map<Pos, Section>

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.layers'¶

actual_key(self: csc.layers.Layer, pos: int) → domain::scene::layers::layer::Key¶: -> Key

actual_key_pos(self: csc.layers.Layer, pos: int) → int¶: -> int

actual_section(self: csc.layers.Layer, pos: int) → domain::scene::layers::layer::Section¶: -> Section

actual_section_pos(self: csc.layers.Layer, pos: int) → int¶: -> int

find_section(self: csc.layers.Layer, pos: int) → object¶: pos : int | -> Section

property header¶

interval(self: csc.layers.Layer, pos: int) → domain::scene::layers::layer::Interval¶: -> Interval

is_key(self: csc.layers.Layer, pos: int) → bool¶

is_key_or_fixed(self: csc.layers.Layer, pos: int) → bool¶

property is_locked¶

property is_visible¶

key(self: csc.layers.Layer, pos: int) → domain::scene::layers::layer::Key¶: -> Key

key_frame_indices(self: csc.layers.Layer) → domain::scene::layers::index::FramesIndices¶: -> FramesIndices

last_key_pos(self: csc.layers.Layer) → int¶: -> int

property obj_ids¶: -> csc.model.ObjectId{}

section(self: csc.layers.Layer, pos: int) → domain::scene::layers::layer::Section¶: -> Section

property sections¶: -> std::map<Pos, Section>

class csc.layers.Layers¶

Layers class

The root class describes the layers’ hierarchy of the scene. Each scene object can be placed on any layer to define its personal interpolation properties.

Variables:: root_id – Get csc.Guid

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.layers'¶

folders(self: csc.layers.Layers) → object¶: -> <FolderId, Folder>{}

layers(self: csc.layers.Layers) → object¶: -> LayersContainer

property root_id¶

userLabels(self: csc.layers.Layers) → object¶: -> UserLabels

class csc.layers.LayersContainer¶

LayersContainer class

It is the container of layers.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.layers'¶

at(self: csc.layers.LayersContainer, arg0: csc.Guid) → object¶: -> Layer

has_any_obj_ids(self: csc.layers.LayersContainer) → bool¶

has_obj_id(self: csc.layers.LayersContainer, id: common::GenericId<domain::scene::model::ModelObject>) → bool¶

layer_id_by_obj_id(self: csc.layers.LayersContainer, id: common::GenericId<domain::scene::model::ModelObject>) → csc.Guid¶: -> LayerId

layer_id_by_obj_id_or_null(self: csc.layers.LayersContainer, id: common::GenericId<domain::scene::model::ModelObject>) → csc.Guid¶: -> LayerId

map(self: csc.layers.LayersContainer) → object¶: -> <LayerId, Layer>{}

obj_ids(self: csc.layers.LayersContainer) → object¶: -> <csc.model.ObjectId, LayerId>{}

class csc.layers.LayersSelectionChanger¶

Layer SelectionChanger class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.layers'¶

refresh(self: csc.layers.LayersSelectionChanger) → bool¶

selectDefault(self: csc.layers.LayersSelectionChanger) → bool¶

set_full_selection_by_parts(*args, **kwargs)¶

Overloaded function.

set_full_selection_by_parts(self: csc.layers.LayersSelectionChanger, inds: domain::scene::layers::index::IndicesContainer) -> None

inds : IndicesContainer
set_full_selection_by_parts(self: csc.layers.LayersSelectionChanger, itms: list[csc.Guid], first: int, last: int) -> bool

class csc.layers.Selector¶

Selector class

This class contains methods to observe and to set selected layers and folders

Variables:: set_full_selection_by_parts – overridden method by ItemId[] (itms), int (first), int (last) || IndicesContainer (inds)

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.layers'¶

all_included_layer_ids(self: csc.layers.Selector, ignore_locked: bool = False) → list[csc.Guid]¶: ignoreLocked : bool (false) | -> LayerId[]

all_included_layer_indices(self: csc.layers.Selector, ignore_locked: bool = False) → domain::scene::layers::index::IndicesContainer¶: ignoreLocked : bool (false) | -> IndicesContainer

is_selected(self: csc.layers.Selector, id: csc.Guid) → bool¶

select_default(self: csc.layers.Selector) → None¶

selection(self: csc.layers.Selector) → domain::scene::layers::index::IndicesContainer¶: -> IndicesContainer

set_full_selection_by_parts(*args, **kwargs)¶

Overloaded function.

set_full_selection_by_parts(self: csc.layers.Selector, inds: domain::scene::layers::index::IndicesContainer) -> None

inds : IndicesContainer
set_full_selection_by_parts(self: csc.layers.Selector, itms: list[csc.Guid], first: int, last: int) -> None

set_uncheckable_folder_id(self: csc.layers.Selector, id: csc.Guid, uncheckable: bool) → None¶: id : ItemId | uncheckable : bool

top_layer_id(self: csc.layers.Selector) → csc.Guid¶

class csc.layers.UserLabelData¶

UserLabelData class

The data of user defined label.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.layers'¶

property color¶

property id¶

property name¶

class csc.layers.UserLabels¶

UserLabels class

It is the storage of user defined labels.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.layers'¶

add(self: csc.layers.UserLabels, label: csc.layers.UserLabelData) → None¶

find(self: csc.layers.UserLabels, id: csc.Guid) → int¶: -> index

remove(*args, **kwargs)¶

Overloaded function.

remove(self: csc.layers.UserLabels, index: int) -> None
remove(self: csc.layers.UserLabels, arg0: int) -> object

-> UserLabelData

storage(self: csc.layers.UserLabels) → object¶: -> UserLabelData[]

class csc.layers.Viewer¶

Viewer class

This class contains all methods and properties that describe the structure of scene objects’ interpolation properties. The structure is represented in the hierarchy of layers divided by folders.

Variables:

top_layer_id – overridden method by ItemId || ItemId[]
merged_layer – overridden method like static and member LayerId[]
last_key_pos – overridden method by LayerId[], -> Layer
frames_count – overridden method by LayerId[], -> int
significant_frames – overridden method by LayerId{}, -> int{}

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.layers'¶

actual_key_pos(self: csc.layers.Viewer, pos: int) → int¶

all_child_ids(self: csc.layers.Viewer, id: csc.Guid) → list[csc.Guid]¶: -> ItemId[]

all_included_layer_ids(self: csc.layers.Viewer, items: list[csc.Guid], ignore_locked: bool = False) → list[csc.Guid]¶: items : ItemId[] | ignoreLocked : bool (false) | -> LayerId[]

all_layer_ids(self: csc.layers.Viewer) → list[csc.Guid]¶: -> LayerId[]

all_parent_ids(self: csc.layers.Viewer, id: csc.Guid) → list[csc.Guid]¶: -> FolderId[]

default_layer_id(self: csc.layers.Viewer) → csc.Guid¶: -> LayerId

find_folder(self: csc.layers.Viewer, id: csc.Guid) → object¶: id : FolderId | -> Folder

find_layer(self: csc.layers.Viewer, id: csc.Guid) → object¶: id : LayerId | -> Layer

folder(self: csc.layers.Viewer, id: csc.Guid) → object¶: id : FolderId | -> Folder

folders_map(self: csc.layers.Viewer) → dict[csc.Guid, csc.layers.Folder]¶: -> <FolderId, Folder>{}

for_all_ordered_items(self: csc.layers.Viewer, arg0: Callable[[csc.Guid], bool]) → None¶

frames_count(*args, **kwargs)¶

Overloaded function.

frames_count(self: csc.layers.Viewer) -> int
frames_count(self: csc.layers.Viewer, id_arr: list[csc.Guid]) -> int

has_item(self: csc.layers.Viewer, id: csc.Guid) → bool¶: -> bool

header(self: csc.layers.Viewer, id: csc.Guid) → object¶: id : ItemId | -> Header

is_deep_child(self: csc.layers.Viewer, item_id: csc.Guid, folder_id: csc.Guid) → bool¶: -> bool

item(self: csc.layers.Viewer, id: csc.Guid) → csc.layers.ItemVariant¶: id : ItemId | -> ItemVariant

last_key_pos(*args, **kwargs)¶

Overloaded function.

last_key_pos(self: csc.layers.Viewer) -> int
last_key_pos(self: csc.layers.Viewer, id_arr: list[csc.Guid]) -> int

layer(self: csc.layers.Viewer, id: csc.Guid) → object¶: id : LayerId | -> Layer

layer_id_by_obj_id(self: csc.layers.Viewer, id: common::GenericId<domain::scene::model::ModelObject>) → csc.Guid¶: id : csc.model.ObjectId | -> LayerId

layer_id_by_obj_id_or_null(self: csc.layers.Viewer, id: common::GenericId<domain::scene::model::ModelObject>) → csc.Guid¶: id : csc.model.ObjectId | -> LayerId

layer_ids_by_obj_ids(self: csc.layers.Viewer, ids: list[common::GenericId<domain::scene::model::ModelObject>]) → set[csc.Guid]¶: ids : csc.model.ObjectId[] | -> LayerId{}

layers_indices(self: csc.layers.Viewer, id_arr: domain::scene::layers::index::IndicesContainer, ignore_locked: bool = False) → domain::scene::layers::index::IndicesContainer¶: -> IndicesContainer

layers_map(self: csc.layers.Viewer) → dict[csc.Guid, csc.layers.Layer]¶: -> <LayerId, Layer>{}

merged_layer(self: csc.layers.Viewer, scene: domain::scene::Scene, ids: list[csc.Guid], normalize: bool = True) → csc.layers.Layer¶

obj_ids_by_layer_ids(self: csc.layers.Viewer, id_arr: list[csc.Guid]) → list[common::GenericId<domain::scene::model::ModelObject>]¶: -> LayerId[]

pos_in_parent(self: csc.layers.Viewer, id: csc.Guid) → int¶: -> int

root_id(self: csc.layers.Viewer) → csc.Guid¶: -> FolderId

significant_frames(*args, **kwargs)¶

Overloaded function.

significant_frames(self: csc.layers.Viewer) -> domain::scene::layers::index::FramesIndices
significant_frames(self: csc.layers.Viewer, id_arr: set[csc.Guid]) -> domain::scene::layers::index::FramesIndices

top_layer_id(*args, **kwargs)¶

Overloaded function.

top_layer_id(self: csc.layers.Viewer, id: csc.Guid) -> csc.Guid
top_layer_id(self: csc.layers.Viewer, id_arr: list[csc.Guid]) -> csc.Guid

unlocked_layer_ids(self: csc.layers.Viewer, id_arr: list[csc.Guid]) → list[csc.Guid]¶: -> LayerId[]

csc.model The Cascadeur python module that implements model and behaviors scene editors methods.¶

Data.Value = std::variant<bool, int, float, Eigen::Vector3f, math::Rotation,: Eigen::Matrix3f, Eigen::Matrix4f, Eigen::Quaternionf, std::string, common::Vector3b>;

Setting.Value = std::variant<bool, int>;

ClusterId = int

`csc.model.Data`	Data class
`csc.model.Setting`	Setting class
`csc.model.ClusterViewer`	ClusterViewer class
`csc.model.ClusterEditor`	ClusterEditor class
`csc.model.DataViewer`	DataViewer class
`csc.model.DataEditor`	DataEditor class
`csc.model.BehaviourViewer`	BehaviourViewer class
`csc.model.BehaviourEditor`	BehaviourEditor class
`csc.model.ModelViewer`	ModelViewer class
`csc.model.ModelEditor`	ModelEditor class
`csc.model.DataMode`	Data::Mode enum
`csc.model.SettingMode`	Setting::Mode enum
`csc.model.ObjectId`
`csc.model.DataId`
`csc.model.BehaviourId`
`csc.model.SettingId`
`csc.model.HyperedgeId`
`csc.model.SettingFunctionId`
`csc.model.LerpMode`	LerpMode enumerable
`csc.model.DescriptionTerm`
`csc.model.CustomSelectionPolicy`	CustomSelectionPolicy enumerable
`csc.model.PropertyType`	PropertyType enumerable
`csc.model.PathName`
`csc.model.ClustersEdge`	ClustersEdge class

class csc.model.BehaviourEditor¶

BehaviourEditor class

This class allows editing of scene behaviours and their properties.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.model'¶

add_behaviour(*args, **kwargs)¶

Overloaded function.

add_behaviour(self: csc.model.BehaviourEditor, arg0: csc.model.ObjectId, arg1: str) -> csc.model.BehaviourId

object_id : csc.model.ObjectId | behaviour_type : string | -> csc.model.BehaviourId
add_behaviour(self: csc.model.BehaviourEditor, object_id: csc.model.ObjectId, behaviour_type: str, behaviour_id: csc.model.BehaviourId) -> csc.model.BehaviourId

object_id : csc.model.ObjectId | behaviour_type : string | behaviour_id : csc.model.BehaviourId | -> csc.model.BehaviourId

add_behaviour_asset_to_range(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, asset_id: common::GenericId<domain::scene::assets::Asset>) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | asset_id : csc.domain.AssetId

add_behaviour_data_to_range(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, data_id: csc.model.DataId) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | data_id : csc.model.DataId

add_behaviour_model_object_to_range(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, mo_id: csc.model.ObjectId) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | mo_id : csc.model.ObjectId

add_behaviour_reference_to_range(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, beh_id: csc.model.BehaviourId) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | beh_id : csc.model.BehaviourId

add_behaviour_setting_to_range(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, setting_id: csc.model.SettingId) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | setting_id : csc.model.SettingId

delete_behaviour(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId) → None¶: behaviour_id : csc.model.BehaviourId

delete_behaviours(self: csc.model.BehaviourEditor, objects_id: set[csc.model.ObjectId]) → None¶: objectsId : {csc.model.ObjectId}

erase_behaviour_data_from_range(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, data_id: csc.model.DataId) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | data_id : csc.model.DataId

erase_behaviour_model_object_from_range(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, mo_id: csc.model.ObjectId) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | mo_id : csc.model.ObjectId

erase_behaviour_reference_from_range(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, beh_id: csc.model.BehaviourId) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | beh_id : csc.model.BehaviourId

erase_behaviour_setting_from_range(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, setting_id: csc.model.SettingId) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | setting_id : csc.model.SettingId

get_viewer(self: csc.model.BehaviourEditor) → csc.model.BehaviourViewer¶

hide_behaviour(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, hidden: bool = True) → bool¶: behaviour_id : csc.model.BehaviourId | hidden : bool(true) -> bool

set_behaviour_asset(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, asset_id: common::GenericId<domain::scene::assets::Asset>) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | asset_id : csc.domain.AssetId

set_behaviour_data(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, data_id: csc.model.DataId) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | dataId : csc.model.DataId

set_behaviour_data_to_range(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, inserted_ids: list[csc.model.DataId]) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | inserted_ids : csc.model.DataId

set_behaviour_field_value(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, name_value: str) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | name_value : string

set_behaviour_model_object(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, mo_id: csc.model.ObjectId) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | mo_id : csc.model.ObjectId

set_behaviour_model_objects_to_range(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, inserted_ids: list[csc.model.ObjectId]) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | inserted_ids : csc.model.ObjectId[]

set_behaviour_reference(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, beh_id: csc.model.BehaviourId) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | beh_id : csc.model.BehaviourId

set_behaviour_references_to_range(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, inserted_ids: list[csc.model.BehaviourId]) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | inserted_ids : csc.model.BehaviourId[]

set_behaviour_setting(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, setting_id: csc.model.SettingId) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | setting_id : csc.model.SettingId

set_behaviour_settings_to_range(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, inserted_ids: list[csc.model.SettingId]) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | inserted_ids : csc.model.SettingId[]

set_behaviour_string(self: csc.model.BehaviourEditor, behaviour_id: csc.model.BehaviourId, name: str, str: str) → bool¶: behaviour_id : csc.model.BehaviourId | name : string | str : string

class csc.model.BehaviourId¶

__annotations__ = {}¶

__cmp__(self: csc.model.BehaviourId, arg0: csc.model.BehaviourId) → int¶

__eq__(self: csc.model.BehaviourId, arg0: csc.model.BehaviourId) → bool¶

__hash__(self: csc.model.BehaviourId) → int¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.model.BehaviourId, arg0: str) -> None
__init__(self: csc.model.BehaviourId) -> None

__module__ = 'csc.model'¶

__ne__(self: csc.model.BehaviourId, arg0: csc.model.BehaviourId) → bool¶

__str__(self: csc.model.BehaviourId) → str¶

is_null(self: csc.model.BehaviourId) → bool¶

static null() → csc.model.BehaviourId¶

to_string(self: csc.model.BehaviourId) → str¶

class csc.model.BehaviourViewer¶

BehaviourViewer class

This class allows viewing of scene behaviours and their properties.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.model'¶

behaviour_id(self: csc.model.BehaviourViewer, object_id: csc.model.ObjectId, behaviour_name: str) → csc.model.BehaviourId¶: objectId : csc.model.ObjectId | behaviour_name : string | -> csc.model.BehaviourId

get_behaviour_asset(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId, name: str) → common::GenericId<domain::scene::assets::Asset>¶: behaviour_id : csc.model.BehaviourId | name : string | -> csc.model.BehaviourId

get_behaviour_asset_range(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId, name: str) → list[common::GenericId<domain::scene::assets::Asset>]¶: behaviour_id : csc.model.BehaviourId | name : string | -> csc.model.BehaviourId[]

get_behaviour_by_name(self: csc.model.BehaviourViewer, object_id: csc.model.ObjectId, behaviour_name: str) → csc.model.BehaviourId¶: objectId : csc.model.ObjectId | behaviour_name : string | -> csc.model.BehaviourId

get_behaviour_data(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId, name: str) → csc.model.DataId¶: behaviour_id : csc.model.BehaviourId | name : string | -> csc.model.DataId

get_behaviour_data_range(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId, name: str) → list[csc.model.DataId]¶: behaviour_id : csc.model.BehaviourId | name : string | -> csc.model.DataId[]

get_behaviour_data_subtype(*args, **kwargs)¶

Overloaded function.

get_behaviour_data_subtype(self: csc.model.BehaviourViewer, behaviour_name: str, property_name: str) -> str
get_behaviour_data_subtype(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId, property_name: str) -> str

get_behaviour_default_data_value(*args, **kwargs)¶

Overloaded function.

get_behaviour_default_data_value(self: csc.model.BehaviourViewer, behaviour_name: str, property_name: str) -> Optional[Union[bool, int, float, numpy.ndarray[numpy.float32[3, 1]], numpy.ndarray[numpy.float32[4, 1]], csc.math.Rotation, numpy.ndarray[numpy.float32[3, 3]], numpy.ndarray[numpy.float32[4, 4]], csc.math.Quaternion, str, numpy.ndarray[bool[3, 1]]]]
get_behaviour_default_data_value(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId, property_name: str) -> Optional[Union[bool, int, float, numpy.ndarray[numpy.float32[3, 1]], numpy.ndarray[numpy.float32[4, 1]], csc.math.Rotation, numpy.ndarray[numpy.float32[3, 3]], numpy.ndarray[numpy.float32[4, 4]], csc.math.Quaternion, str, numpy.ndarray[bool[3, 1]]]]

get_behaviour_default_setting_value(*args, **kwargs)¶

Overloaded function.

get_behaviour_default_setting_value(self: csc.model.BehaviourViewer, behaviour_name: str, property_name: str) -> Optional[Union[bool, int]]
get_behaviour_default_setting_value(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId, property_name: str) -> Optional[Union[bool, int]]

get_behaviour_name(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId) → str¶: behaviour_id : csc.model.BehaviourId | -> string

get_behaviour_object(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId, name: str) → csc.model.ObjectId¶: behaviour_id : csc.model.BehaviourId | name : string | -> csc.model.ObjectId

get_behaviour_objects_range(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId, name: str) → list[csc.model.ObjectId]¶: behaviour_id : csc.model.BehaviourId | name : string | -> csc.model.ObjectId[]

get_behaviour_owner(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId) → csc.model.ObjectId¶: behaviour_id : csc.model.BehaviourId | -> csc.model.ObjectId

get_behaviour_property_names(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId) → list[str]¶: -> string[]

get_behaviour_reference(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId, name: str) → csc.model.BehaviourId¶: behaviour_id : csc.model.BehaviourId | name : string | -> csc.model.BehaviourId

get_behaviour_reference_range(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId, name: str) → list[csc.model.BehaviourId]¶: behaviour_id : csc.model.BehaviourId | name : string | -> csc.model.BehaviourId[]

get_behaviour_reference_subtype(*args, **kwargs)¶

Overloaded function.

get_behaviour_reference_subtype(self: csc.model.BehaviourViewer, behaviour_name: str, property_name: str) -> str
get_behaviour_reference_subtype(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId, property_name: str) -> str

get_behaviour_setting(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId, name: str) → csc.model.SettingId¶: behaviour_id : csc.model.BehaviourId | name : string | -> csc.model.SettingId

get_behaviour_setting_subtype(*args, **kwargs)¶

Overloaded function.

get_behaviour_setting_subtype(self: csc.model.BehaviourViewer, behaviour_name: str, property_name: str) -> str
get_behaviour_setting_subtype(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId, property_name: str) -> str

get_behaviour_settings_range(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId, name: str) → list[csc.model.SettingId]¶: behaviour_id : csc.model.BehaviourId | name : string | -> csc.model.SettingId[]

get_behaviour_string(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId, name: str) → str¶: behaviour_id : csc.model.BehaviourId | name : string | -> string

get_behaviours(*args, **kwargs)¶

Overloaded function.

get_behaviours(self: csc.model.BehaviourViewer, type_name: str) -> list[csc.model.BehaviourId]

typeName : string | -> csc.model.BehaviourId[]
get_behaviours(self: csc.model.BehaviourViewer, object_id: csc.model.ObjectId) -> list[csc.model.BehaviourId]

objectId : csc.model.ObjectId | -> csc.model.BehaviourId[]

get_behaviours_by_name(self: csc.model.BehaviourViewer, object_id: csc.model.ObjectId, behaviour_name: str) → list[csc.model.BehaviourId]¶: objectId : csc.model.ObjectId | behaviour_name : string | -> csc.model.BehaviourId[]

get_children(self: csc.model.BehaviourViewer, object_id: csc.model.ObjectId) → list[csc.model.BehaviourId]¶: -> Children behs ids

get_property_type(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId, name: str) → csc.model.PropertyType¶: behaviour_id : csc.model.BehaviourId | name : string | -> Type[]

is_hidden(self: csc.model.BehaviourViewer, behaviour_id: csc.model.BehaviourId) → bool¶: -> bool

is_valid_behaviour_type(self: csc.model.BehaviourViewer, behaviour_name: str) → bool¶: behaviour_name : string | -> bool

class csc.model.ClusterEditor¶

ClusterEditor class

This class lets edit scene data clusters.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.model'¶

add_cluster(self: csc.model.ClusterEditor, inserted_ids: list[csc.model.DataId], name: str) → int¶: insertedIds : csc.model.DataId[] | name : string (“”) | -> ClusterId

add_data_to_cluster(self: csc.model.ClusterEditor, cluster_index: int, inserted_ids: list[csc.model.DataId]) → None¶: cluster_index : ClusterId | insertedIds : csc.model.DataId[]

bind_clusters(self: csc.model.ClusterEditor, cluster_id_first: int, cluster_id_second: int) → None¶: cluster_id_first : ClusterId | cluster_id_second : ClusterId

remove_cluster(self: csc.model.ClusterEditor, cluster_id: int) → None¶: cluster_id : ClusterId

remove_data_from_cluster(self: csc.model.ClusterEditor, data_id: csc.model.DataId) → None¶: data_id : csc.model.DataId

set_cluster_name(self: csc.model.ClusterEditor, cluster_id: int, name: str) → None¶: cluster_id : ClusterId | name : string

unbind_cluster(self: csc.model.ClusterEditor, cluster_id: int) → None¶: cluster_id : ClusterId

unbind_clusters(self: csc.model.ClusterEditor, cluster_id_first: int, cluster_id_second: int) → None¶: cluster_id_first : ClusterId | cluster_id_second : ClusterId

class csc.model.ClusterViewer¶

ClusterViewer class

This class lets read scene data clusters.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.model'¶

cluster_by_data(self: csc.model.ClusterViewer, data_id: csc.model.DataId) → int¶: data_id : csc.model.DataId | -> ClusterId

cluster_datas(self: csc.model.ClusterViewer, cluster_id: int) → list[csc.model.DataId]¶: cluster_id : ClusterId | -> csc.model.DataId[]

cluster_name(self: csc.model.ClusterViewer, cluster_id: int) → str¶: cluster_id : ClusterId | -> string

clusters(self: csc.model.ClusterViewer) → list[int]¶: -> ClusterId[]

clusters_bindings(self: csc.model.ClusterViewer) → list[csc.model.ClustersEdge]¶: -> (ClusterId,ClusterId)[]

class csc.model.ClustersEdge¶

ClustersEdge class

This class contains link between clusters

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.model'¶

property a¶

property b¶

class csc.model.CustomSelectionPolicy¶

CustomSelectionPolicy enumerable

Default, // the entity is selected with other entities

Single, // the entity is selected only if the selection contains only from this entity

SingleType // the entity is selected only if the selection contains only entities of the same type

Members:

Default

Single

SingleType

Default = <CustomSelectionPolicy.Default: 0>¶

Single = <CustomSelectionPolicy.Single: 1>¶

SingleType = <CustomSelectionPolicy.SingleType: 2>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.model.CustomSelectionPolicy) → int¶

__init__(self: csc.model.CustomSelectionPolicy, value: int) → None¶

__int__(self: csc.model.CustomSelectionPolicy) → int¶

__members__ = {'Default': <CustomSelectionPolicy.Default: 0>, 'Single': <CustomSelectionPolicy.Single: 1>, 'SingleType': <CustomSelectionPolicy.SingleType: 2>}¶

__module__ = 'csc.model'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.model.CustomSelectionPolicy, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.model.Data¶

Data class

This class serves to represent any special type of data. These data can be used in the update calculation or as behaviors’ properties.

Variables:

id – Get Set csc.model.DataId
object_id – Get Set csc.model.ObjectId
name – Get Set string
mode – Get Set csc.model.DataMode

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.model'¶

property id¶

property mode¶

property name¶

property object_id¶

class csc.model.DataEditor¶

DataEditor class

This class has the possibility to edit scene data and their properties.

Variables:

add_data – overridden method by csc.model.ObjectId, string, DataMode, Data.Value, csc.model.DataId -> Data
add_setting – overridden method by string, Setting.Value || csc.model.ObjectId, string, Setting.Value, csc.model.SettingId -> Setting
add_constant_data – overridden method by string, Data.Value || string, Data.Value, csc.model.DataId -> Data
add_constant_setting – overridden method by string, Setting.Value || string, Setting.Value, csc.model.SettingId -> Setting
set_data_value – overridden method by csc.model.DataId&, Data.Value || csc.model.DataId, int{}, Data.Value || csc.model.DataId, int, Data.Value

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.model'¶

add_constant_data(*args, **kwargs)¶

Overloaded function.

add_constant_data(self: csc.model.DataEditor, arg0: str, arg1: Union[bool, int, float, numpy.ndarray[numpy.float32[3, 1]], numpy.ndarray[numpy.float32[4, 1]], csc.math.Rotation, numpy.ndarray[numpy.float32[3, 3]], numpy.ndarray[numpy.float32[4, 4]], csc.math.Quaternion, str, numpy.ndarray[bool[3, 1]]]) -> csc.model.Data
add_constant_data(self: csc.model.DataEditor, name: str, value: Union[bool, int, float, numpy.ndarray[numpy.float32[3, 1]], numpy.ndarray[numpy.float32[4, 1]], csc.math.Rotation, numpy.ndarray[numpy.float32[3, 3]], numpy.ndarray[numpy.float32[4, 4]], csc.math.Quaternion, str, numpy.ndarray[bool[3, 1]]], id: csc.model.DataId) -> csc.model.Data

add_constant_setting(*args, **kwargs)¶

Overloaded function.

add_constant_setting(self: csc.model.DataEditor, arg0: str, arg1: Union[bool, int]) -> csc.model.Setting
add_constant_setting(self: csc.model.DataEditor, name: str, value: Union[bool, int], id: csc.model.SettingId) -> csc.model.Setting

add_data(*args, **kwargs)¶

Overloaded function.

add_data(self: csc.model.DataEditor, object_id: csc.model.ObjectId, name: str, mode: csc.model.DataMode, value: Union[bool, int, float, numpy.ndarray[numpy.float32[3, 1]], numpy.ndarray[numpy.float32[4, 1]], csc.math.Rotation, numpy.ndarray[numpy.float32[3, 3]], numpy.ndarray[numpy.float32[4, 4]], csc.math.Quaternion, str, numpy.ndarray[bool[3, 1]]]) -> csc.model.Data

-> Data
add_data(self: csc.model.DataEditor, object_id: csc.model.ObjectId, name: str, mode: csc.model.DataMode, value: Union[bool, int, float, numpy.ndarray[numpy.float32[3, 1]], numpy.ndarray[numpy.float32[4, 1]], csc.math.Rotation, numpy.ndarray[numpy.float32[3, 3]], numpy.ndarray[numpy.float32[4, 4]], csc.math.Quaternion, str, numpy.ndarray[bool[3, 1]]], id: csc.model.DataId) -> csc.model.Data

-> Data

add_description(self: csc.model.DataEditor, name: str, description: str) → None¶

add_setting(*args, **kwargs)¶

Overloaded function.

add_setting(self: csc.model.DataEditor, object_id: csc.model.ObjectId, name: str, value: Union[bool, int], mode: csc.model.SettingMode = <SettingMode.Static: 0>) -> csc.model.Setting

-> Setting
add_setting(self: csc.model.DataEditor, object_id: csc.model.ObjectId, name: str, value: Union[bool, int], mode: csc.model.SettingMode, id: csc.model.SettingId) -> csc.model.Setting

-> Setting

change_description(self: csc.model.DataEditor, name: str, description: str) → None¶

cluster_editor(self: csc.model.DataEditor) → csc.model.ClusterEditor¶: -> ClusterEditor

copy_data(self: csc.model.DataEditor, from_to: list[tuple[csc.model.DataId, csc.model.DataId]]) → None¶

delete_data(self: csc.model.DataEditor, id: csc.model.DataId, clear_behaviour_fields: bool = True) → None¶

delete_setting(self: csc.model.DataEditor, id: csc.model.SettingId, clear_behaviour_fields: bool = True) → None¶

remove_description(self: csc.model.DataEditor, name: str) → None¶

reset_description_value(*args, **kwargs)¶

Overloaded function.

reset_description_value(self: csc.model.DataEditor, id: csc.model.DataId) -> None
reset_description_value(self: csc.model.DataEditor, id: csc.model.SettingId) -> None

set_data_name(self: csc.model.DataEditor, arg0: csc.model.DataId, arg1: str) → None¶

set_data_value(*args, **kwargs)¶

Overloaded function.

set_data_value(self: csc.model.DataEditor, id: csc.model.DataId, value: Union[bool, int, float, numpy.ndarray[numpy.float32[3, 1]], numpy.ndarray[numpy.float32[4, 1]], csc.math.Rotation, numpy.ndarray[numpy.float32[3, 3]], numpy.ndarray[numpy.float32[4, 4]], csc.math.Quaternion, str, numpy.ndarray[bool[3, 1]]]) -> None
set_data_value(self: csc.model.DataEditor, id: csc.model.DataId, frames: set[int], value: Union[bool, int, float, numpy.ndarray[numpy.float32[3, 1]], numpy.ndarray[numpy.float32[4, 1]], csc.math.Rotation, numpy.ndarray[numpy.float32[3, 3]], numpy.ndarray[numpy.float32[4, 4]], csc.math.Quaternion, str, numpy.ndarray[bool[3, 1]]]) -> None
set_data_value(self: csc.model.DataEditor, id: csc.model.DataId, frame: int, value: Union[bool, int, float, numpy.ndarray[numpy.float32[3, 1]], numpy.ndarray[numpy.float32[4, 1]], csc.math.Rotation, numpy.ndarray[numpy.float32[3, 3]], numpy.ndarray[numpy.float32[4, 4]], csc.math.Quaternion, str, numpy.ndarray[bool[3, 1]]]) -> None

set_description_value(*args, **kwargs)¶

Overloaded function.

set_description_value(self: csc.model.DataEditor, name: str, id: csc.model.DataId) -> None
set_description_value(self: csc.model.DataEditor, name: str, id: csc.model.SettingId) -> None

set_setting_name(self: csc.model.DataEditor, arg0: csc.model.SettingId, arg1: str) → None¶

set_setting_value(*args, **kwargs)¶

Overloaded function.

set_setting_value(self: csc.model.DataEditor, id: csc.model.SettingId, value: Union[bool, int]) -> None
set_setting_value(self: csc.model.DataEditor, id: csc.model.SettingId, frame: int, value: Union[bool, int]) -> None

class csc.model.DataId¶

__annotations__ = {}¶

__cmp__(self: csc.model.DataId, arg0: csc.model.DataId) → int¶

__eq__(self: csc.model.DataId, arg0: csc.model.DataId) → bool¶

__hash__(self: csc.model.DataId) → int¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.model.DataId, arg0: str) -> None
__init__(self: csc.model.DataId) -> None

__module__ = 'csc.model'¶

__ne__(self: csc.model.DataId, arg0: csc.model.DataId) → bool¶

__str__(self: csc.model.DataId) → str¶

is_null(self: csc.model.DataId) → bool¶

static null() → csc.model.DataId¶

to_string(self: csc.model.DataId) → str¶

class csc.model.DataMode¶

Data::Mode enum

This enumerates the basic types of data. Static, Animation

Members:

Static

Animation

Animation = <DataMode.Animation: 1>¶

Static = <DataMode.Static: 0>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.model.DataMode) → int¶

__init__(self: csc.model.DataMode, value: int) → None¶

__int__(self: csc.model.DataMode) → int¶

__members__ = {'Animation': <DataMode.Animation: 1>, 'Static': <DataMode.Static: 0>}¶

__module__ = 'csc.model'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.model.DataMode, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.model.DataViewer¶

DataViewer class

This class allows to view scene data and their properties.

Variables:

get_data_value – overridden method by id : csc.model.DataId || csc.model.DataId, int (frame) -> Data.Value
get_behaviour_property – overridden method by : csc.model.BehaviourId, string -> Data.Value || csc.model.BehaviourId, string, int (frame) -> Setiing.Value

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.model'¶

cluster_viewer(self: csc.model.DataViewer) → csc.model.ClusterViewer¶: -> ClusterViewer

get_all_data_id(self: csc.model.DataViewer, object_id: csc.model.ObjectId) → list[csc.model.DataId]¶: -> csc.model.DataId[]

get_all_settings_id(self: csc.model.DataViewer, object_id: csc.model.ObjectId) → list[csc.model.SettingId]¶: -> csc.model.SettingId[]

get_animation_size(self: csc.model.DataViewer) → int¶: -> int

get_data(self: csc.model.DataViewer, id: csc.model.DataId) → csc.model.Data¶: id : csc.model.DataId | -> Data

get_data_id(self: csc.model.DataViewer, id: csc.model.ObjectId, name: str) → csc.model.DataId¶: id : csc.model.ObjectId | name : string | -> csc.model.DataId

get_data_name(self: csc.model.DataViewer, arg0: csc.model.DataId) → str¶: id : csc.model.DataId | -> string

get_data_value(*args, **kwargs)¶

Overloaded function.

get_data_value(self: csc.model.DataViewer, id: csc.model.DataId) -> Union[bool, int, float, numpy.ndarray[numpy.float32[3, 1]], numpy.ndarray[numpy.float32[4, 1]], csc.math.Rotation, numpy.ndarray[numpy.float32[3, 3]], numpy.ndarray[numpy.float32[4, 4]], csc.math.Quaternion, str, numpy.ndarray[bool[3, 1]]]
get_data_value(self: csc.model.DataViewer, arg0: csc.model.DataId, arg1: int) -> Union[bool, int, float, numpy.ndarray[numpy.float32[3, 1]], numpy.ndarray[numpy.float32[4, 1]], csc.math.Rotation, numpy.ndarray[numpy.float32[3, 3]], numpy.ndarray[numpy.float32[4, 4]], csc.math.Quaternion, str, numpy.ndarray[bool[3, 1]]]

get_description_by_name(self: csc.model.DataViewer, arg0: str) → str¶: -> string

get_description_names(self: csc.model.DataViewer) → list[str]¶: -> string[]

get_description_value(*args, **kwargs)¶

Overloaded function.

get_description_value(self: csc.model.DataViewer, id: csc.model.DataId) -> str

id : csc.model.DataId -> string
get_description_value(self: csc.model.DataViewer, id: csc.model.SettingId) -> str

id : csc.model.SettingId -> string

get_setting(self: csc.model.DataViewer, id: csc.model.SettingId) → csc.model.Setting¶: id : csc.model.SettingId | -> Setting

get_setting_id(self: csc.model.DataViewer, id: csc.model.ObjectId, name: str) → csc.model.SettingId¶: id : csc.model.ObjectId | name : string | -> csc.model.DataId

get_setting_name(self: csc.model.DataViewer, arg0: csc.model.SettingId) → str¶: id : csc.model.SettingId | -> string

get_setting_value(*args, **kwargs)¶

Overloaded function.

get_setting_value(self: csc.model.DataViewer, id: csc.model.SettingId) -> Union[bool, int]

id : csc.model.SettingId | -> Setting.Value
get_setting_value(self: csc.model.DataViewer, setting_id: csc.model.SettingId, position: int) -> Union[bool, int]

id : csc.model.SettingId, position : int | -> Setting.Value

has_data(self: csc.model.DataViewer, arg0: csc.model.DataId) → bool¶: id : csc.model.DataId | -> bool

has_setting(self: csc.model.DataViewer, arg0: csc.model.SettingId) → bool¶: id : csc.model.SettingId | -> bool

union_get_data_value(self: csc.model.DataViewer, data_id: csc.model.DataId, frame: int = 0) → bool | int | float | numpy.ndarray[numpy.float32[3, 1]] | numpy.ndarray[numpy.float32[4, 1]] | csc.math.Rotation | numpy.ndarray[numpy.float32[3, 3]] | numpy.ndarray[numpy.float32[4, 4]] | csc.math.Quaternion | str | numpy.ndarray[bool[3, 1]]¶: id : csc.model.DataId | -> Data.Value

class csc.model.DescriptionTerm¶

__annotations__ = {}¶

__init__(self: csc.model.DescriptionTerm) → None¶

__module__ = 'csc.model'¶

class csc.model.HyperedgeId¶

__annotations__ = {}¶

__cmp__(self: csc.model.HyperedgeId, arg0: csc.model.HyperedgeId) → int¶

__eq__(self: csc.model.HyperedgeId, arg0: csc.model.HyperedgeId) → bool¶

__hash__(self: csc.model.HyperedgeId) → int¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.model.HyperedgeId, arg0: str) -> None
__init__(self: csc.model.HyperedgeId) -> None

__module__ = 'csc.model'¶

__ne__(self: csc.model.HyperedgeId, arg0: csc.model.HyperedgeId) → bool¶

__str__(self: csc.model.HyperedgeId) → str¶

is_null(self: csc.model.HyperedgeId) → bool¶

static null() → csc.model.HyperedgeId¶

to_string(self: csc.model.HyperedgeId) → str¶

class csc.model.LerpMode¶

LerpMode enumerable

Empty, Linear, Spherical

Members:

Empty

Linear

Spherical

Empty = <LerpMode.Empty: 0>¶

Linear = <LerpMode.Linear: 1>¶

Spherical = <LerpMode.Spherical: 2>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.model.LerpMode) → int¶

__init__(self: csc.model.LerpMode, value: int) → None¶

__int__(self: csc.model.LerpMode) → int¶

__members__ = {'Empty': <LerpMode.Empty: 0>, 'Linear': <LerpMode.Linear: 1>, 'Spherical': <LerpMode.Spherical: 2>}¶

__module__ = 'csc.model'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.model.LerpMode, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.model.ModelEditor¶

ModelEditor class

Represents basic methods to edit the scene model

Variables:: add_object – overridden method by GroupId -> csc.model.ObjectId

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.model'¶

add_object(*args, **kwargs)¶

Overloaded function.

add_object(self: csc.model.ModelEditor) -> csc.model.ObjectId
add_object(self: csc.model.ModelEditor, id: csc.model.ObjectId) -> csc.model.ObjectId

behaviour_editor(self: csc.model.ModelEditor) → csc.model.BehaviourEditor¶: -> BehaviourEditor

data_editor(self: csc.model.ModelEditor) → csc.model.DataEditor¶: -> DataEditor

delete_objects(self: csc.model.ModelEditor, ids: set[csc.model.ObjectId], close_connections: bool = True) → None¶

fit_animation_size_by_layers(self: csc.model.ModelEditor) → None¶

get_viewer(self: csc.model.ModelEditor) → csc.model.ModelViewer¶

init_default_constants(self: csc.model.ModelEditor) → None¶

layers(self: csc.model.ModelEditor) → object¶: -> csc.layers.Layers

layers_editor(self: csc.model.ModelEditor) → csc.layers.Editor¶: -> csc.layers.Editor

layers_selector(self: csc.model.ModelEditor) → object¶: -> csc.layers.Selector

move_obj_ids_in_layers(self: csc.model.ModelEditor, objIds = csc.model.ObjectId[]: list[csc.model.ObjectId], layer_id: csc.Guid) → None¶

move_objects_to_layer(self: csc.model.ModelEditor, ids: list[csc.model.ObjectId], target_layer_id: csc.Guid) → None¶

set_fixed_interpolation_if_need(self: csc.model.ModelEditor, actuals: set[csc.model.DataId], frame: int, ignore_locked: bool = False) → None¶

set_object_name(self: csc.model.ModelEditor, id: csc.model.ObjectId, name: str) → None¶

set_object_type_name(self: csc.model.ModelEditor, id: csc.model.ObjectId, name: str) → None¶

class csc.model.ModelViewer¶

ModelViewer class

Represents basic methods to view the scene model

Variables:: get_objects – overridden method by string -> csc.model.ObjectId[]

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.model'¶

behaviour_viewer(self: csc.model.ModelViewer) → csc.model.BehaviourViewer¶: -> BehaviourViewer

data_viewer(self: csc.model.ModelViewer) → csc.model.DataViewer¶: -> DataViewer

get_object_name(self: csc.model.ModelViewer, id: csc.model.ObjectId) → str¶

get_object_type_name(self: csc.model.ModelViewer, id: csc.model.ObjectId) → str¶

get_objects(*args, **kwargs)¶

Overloaded function.

get_objects(self: csc.model.ModelViewer) -> list[csc.model.ObjectId]
get_objects(self: csc.model.ModelViewer, name: str) -> list[csc.model.ObjectId]

class csc.model.ObjectId¶

__annotations__ = {}¶

__cmp__(self: csc.model.ObjectId, arg0: csc.model.ObjectId) → int¶

__eq__(self: csc.model.ObjectId, arg0: csc.model.ObjectId) → bool¶

__hash__(self: csc.model.ObjectId) → int¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.model.ObjectId, arg0: str) -> None
__init__(self: csc.model.ObjectId) -> None

__module__ = 'csc.model'¶

__ne__(self: csc.model.ObjectId, arg0: csc.model.ObjectId) → bool¶

__str__(self: csc.model.ObjectId) → str¶

is_null(self: csc.model.ObjectId) → bool¶

static null() → csc.model.ObjectId¶

to_string(self: csc.model.ObjectId) → str¶

class csc.model.PathName¶

__annotations__ = {}¶

__cmp__(self: csc.model.PathName, arg0: csc.model.PathName) → int¶

__copy__(self: csc.model.PathName) → csc.model.PathName¶

__deepcopy__(self: csc.model.PathName, arg0: dict) → csc.model.PathName¶

__eq__(self: csc.model.PathName, arg0: csc.model.PathName) → bool¶

__hash__(self: csc.model.PathName) → int¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.model.PathName) -> None

PathName class

Implements a hierarchical name
__init__(self: csc.model.PathName, arg0: str, arg1: list[str]) -> None

PathName class

Implements a hierarchical name

ivar name:

Get Set string

ivar path:

Get Set string[]

__module__ = 'csc.model'¶

__ne__(self: csc.model.PathName, arg0: csc.model.PathName) → bool¶

clear(self: csc.model.PathName) → None¶

empty(self: csc.model.PathName) → bool¶

full_path(self: csc.model.PathName) → list[str]¶

get_namespace(self: csc.model.PathName) → str¶

static get_object_path_name(obj_id: csc.model.ObjectId, mv: domain::scene::model::ModelViewer) → csc.model.PathName¶

static get_path_name(obj_id: csc.model.ObjectId, mv: domain::scene::model::ModelViewer, beh_name: str = 'Joint') → csc.model.PathName¶

static get_path_names(arg0: dict[str, str]) → dict[str, csc.model.PathName]¶

static get_path_names_by_behavior(arg0: str, arg1: domain::scene::model::ModelViewer) → dict[csc.model.PathName, csc.model.ObjectId]¶

static get_path_names_for_objects(arg0: set[csc.model.ObjectId], arg1: domain::scene::model::ModelViewer) → dict[csc.model.PathName, csc.model.ObjectId]¶

property name¶

property path¶

set_namespace(self: csc.model.PathName, namespace: str) → None¶

to_string(self: csc.model.PathName) → str¶

class csc.model.PropertyType¶

PropertyType enumerable

Undefined, DataType, DataRangeType, SettingType, SettingRangeType, ObjectType, ObjectRangeType, BehaviourType, BehaviourRangeType, AssetType, AssetRangeType, StringType

Members:

Undefined

DataType

DataRangeType

SettingType

SettingRangeType

ObjectType

ObjectRangeType

BehaviourType

BehaviourRangeType

AssetType

AssetRangeType

StringType

AssetRangeType = <PropertyType.AssetRangeType: 10>¶

AssetType = <PropertyType.AssetType: 9>¶

BehaviourRangeType = <PropertyType.BehaviourRangeType: 8>¶

BehaviourType = <PropertyType.BehaviourType: 7>¶

DataRangeType = <PropertyType.DataRangeType: 2>¶

DataType = <PropertyType.DataType: 1>¶

ObjectRangeType = <PropertyType.ObjectRangeType: 6>¶

ObjectType = <PropertyType.ObjectType: 5>¶

SettingRangeType = <PropertyType.SettingRangeType: 4>¶

SettingType = <PropertyType.SettingType: 3>¶

StringType = <PropertyType.StringType: 11>¶

Undefined = <PropertyType.Undefined: 0>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.model.PropertyType) → int¶

__init__(self: csc.model.PropertyType, value: int) → None¶

__int__(self: csc.model.PropertyType) → int¶

__members__ = {'AssetRangeType': <PropertyType.AssetRangeType: 10>, 'AssetType': <PropertyType.AssetType: 9>, 'BehaviourRangeType': <PropertyType.BehaviourRangeType: 8>, 'BehaviourType': <PropertyType.BehaviourType: 7>, 'DataRangeType': <PropertyType.DataRangeType: 2>, 'DataType': <PropertyType.DataType: 1>, 'ObjectRangeType': <PropertyType.ObjectRangeType: 6>, 'ObjectType': <PropertyType.ObjectType: 5>, 'SettingRangeType': <PropertyType.SettingRangeType: 4>, 'SettingType': <PropertyType.SettingType: 3>, 'StringType': <PropertyType.StringType: 11>, 'Undefined': <PropertyType.Undefined: 0>}¶

__module__ = 'csc.model'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.model.PropertyType, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.model.Setting¶

Setting class

This class serves to represent int or bool value that using in the update calculation.

Variables:

id – Get csc.model.DataId
object_id – Get csc.model.ObjectId
name – Get string
type – Get int
mode – Get csc.model.SettingMode

Parameters:

object_id (csc.model.ObjectId) – object_id

__annotations__ = {}¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.model.Setting, id: csc.model.SettingId, object_id: csc.model.ObjectId, name: str, type: int) -> None
__init__(self: csc.model.Setting, object_id: csc.model.ObjectId, name: str, type: int) -> None

__module__ = 'csc.model'¶

property id¶

property mode¶

property name¶

property object_id¶

property type¶

class csc.model.SettingFunctionId¶

__annotations__ = {}¶

__cmp__(self: csc.model.SettingFunctionId, arg0: csc.model.SettingFunctionId) → int¶

__eq__(self: csc.model.SettingFunctionId, arg0: csc.model.SettingFunctionId) → bool¶

__hash__(self: csc.model.SettingFunctionId) → int¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.model.SettingFunctionId, arg0: str) -> None
__init__(self: csc.model.SettingFunctionId) -> None

__module__ = 'csc.model'¶

__ne__(self: csc.model.SettingFunctionId, arg0: csc.model.SettingFunctionId) → bool¶

__str__(self: csc.model.SettingFunctionId) → str¶

is_null(self: csc.model.SettingFunctionId) → bool¶

static null() → csc.model.SettingFunctionId¶

to_string(self: csc.model.SettingFunctionId) → str¶

class csc.model.SettingId¶

__annotations__ = {}¶

__cmp__(self: csc.model.SettingId, arg0: csc.model.SettingId) → int¶

__eq__(self: csc.model.SettingId, arg0: csc.model.SettingId) → bool¶

__hash__(self: csc.model.SettingId) → int¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.model.SettingId, arg0: str) -> None
__init__(self: csc.model.SettingId) -> None

__module__ = 'csc.model'¶

__ne__(self: csc.model.SettingId, arg0: csc.model.SettingId) → bool¶

__str__(self: csc.model.SettingId) → str¶

is_null(self: csc.model.SettingId) → bool¶

static null() → csc.model.SettingId¶

to_string(self: csc.model.SettingId) → str¶

class csc.model.SettingMode¶

Setting::Mode enum

This enumerates the basic types of data. Static, Animation

Members:

Static

Animation

Animation = <SettingMode.Animation: 1>¶

Static = <SettingMode.Static: 0>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.model.SettingMode) → int¶

__init__(self: csc.model.SettingMode, value: int) → None¶

__int__(self: csc.model.SettingMode) → int¶

__members__ = {'Animation': <SettingMode.Animation: 1>, 'Static': <SettingMode.Static: 0>}¶

__module__ = 'csc.model'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.model.SettingMode, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

csc.model.get_path_without_namespace(path_name: csc.model.PathName) → csc.model.PathName¶: -> PathName

csc.domain The Cascadeur python module that implements basic scene properties and infrastructure.¶

Entity3d_id = std::variant<model::ModelObject::Id, Tool_object_id>

`csc.domain.Pivot`	Pivot class
`csc.domain.Selection`	Selection class
`csc.domain.Selector`	Selector class
`csc.domain.AssetId`
`csc.domain.Asset`	Asset class
`csc.domain.LocalInterpolator`	LocalInterpolator class
`csc.domain.SceneUpdater`	SceneUpdater class
`csc.domain.ProcessorsStorage`	ProcessorsStorage class
`csc.domain.IMessageHandler`	IMessageHandler interface
`csc.domain.Scene`	Scene class
`csc.domain.Session`	Session class
`csc.domain.Tool_object_id`
`csc.domain.StatePivot`	StatePivot enum
`csc.domain.FrameActionOnChange`	FrameActionOnChange enum
`csc.domain.IntervalActionOnChange`	IntervalActionOnChange enum
`csc.domain.SelectorMode`	SelectorMode enumerable
`csc.domain.SelectorFilter`	SelectorFilter enumerable
`csc.domain.Select`	Select class
`csc.domain.assets.Vertex`	Vertex class
`csc.domain.assets.Mesh`	Mesh class
`csc.domain.assets.MeshDependency`	MeshDependency class
`csc.domain.assets.MeshBlendshape`	MeshBlendshape class
`csc.domain.assets.AssetsManager`	AssetsManager class

class csc.domain.Asset¶

Asset class

Assets are objects resources that have content like meshes or textures.

Variables:: id – Get csc.Guid

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.domain'¶

property id¶

class csc.domain.AssetId¶

__annotations__ = {}¶

__cmp__(self: csc.domain.AssetId, arg0: csc.domain.AssetId) → int¶

__eq__(self: csc.domain.AssetId, arg0: csc.domain.AssetId) → bool¶

__hash__(self: csc.domain.AssetId) → int¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.domain.AssetId, arg0: str) -> None
__init__(self: csc.domain.AssetId) -> None

__module__ = 'csc.domain'¶

__ne__(self: csc.domain.AssetId, arg0: csc.domain.AssetId) → bool¶

__str__(self: csc.domain.AssetId) → str¶

is_null(self: csc.domain.AssetId) → bool¶

static null() → csc.domain.AssetId¶

to_string(self: csc.domain.AssetId) → str¶

class csc.domain.FrameActionOnChange¶

FrameActionOnChange enum

AutoKey = 0, Fixing = 1, DoNothing = 2

Members:

AutoKey

Fixing

DoNothing

AutoKey = <FrameActionOnChange.AutoKey: 0>¶

DoNothing = <FrameActionOnChange.DoNothing: 2>¶

Fixing = <FrameActionOnChange.Fixing: 1>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.domain.FrameActionOnChange) → int¶

__init__(self: csc.domain.FrameActionOnChange, value: int) → None¶

__int__(self: csc.domain.FrameActionOnChange) → int¶

__members__ = {'AutoKey': <FrameActionOnChange.AutoKey: 0>, 'DoNothing': <FrameActionOnChange.DoNothing: 2>, 'Fixing': <FrameActionOnChange.Fixing: 1>}¶

__module__ = 'csc.domain'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.domain.FrameActionOnChange, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.domain.IMessageHandler¶

IMessageHandler interface

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.domain'¶

class csc.domain.IntervalActionOnChange¶

IntervalActionOnChange enum

Fixing = 0, DoNothing = 1

Members:

Fixing

DoNothing

DoNothing = <IntervalActionOnChange.DoNothing: 1>¶

Fixing = <IntervalActionOnChange.Fixing: 0>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.domain.IntervalActionOnChange) → int¶

__init__(self: csc.domain.IntervalActionOnChange, value: int) → None¶

__int__(self: csc.domain.IntervalActionOnChange) → int¶

__members__ = {'DoNothing': <IntervalActionOnChange.DoNothing: 1>, 'Fixing': <IntervalActionOnChange.Fixing: 0>}¶

__module__ = 'csc.domain'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.domain.IntervalActionOnChange, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.domain.LocalInterpolator¶

LocalInterpolator class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.domain'¶

interpolate(self: csc.domain.LocalInterpolator) → None¶

reload(self: csc.domain.LocalInterpolator) → None¶

class csc.domain.Pivot¶

Pivot class

Represents basic Pivot methods.

Variables:

position – overridden method by … || int (frame) || int, StatePivot (pivot)
rotation – overridden method by … || int (frame) || int, StatePivot (pivot)

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.domain'¶

center_of_top_objects(self: csc.domain.Pivot, arg0: Callable[[csc.model.ObjectId | csc.domain.Tool_object_id], numpy.ndarray[numpy.float32[3, 1]]]) → numpy.ndarray[numpy.float32[3, 1]]¶

position(*args, **kwargs)¶

Overloaded function.

position(self: csc.domain.Pivot) -> numpy.ndarray[numpy.float32[3, 1]]
position(self: csc.domain.Pivot, frame: int) -> numpy.ndarray[numpy.float32[3, 1]]
position(self: csc.domain.Pivot, frame: int, pivot: csc.domain.StatePivot) -> numpy.ndarray[numpy.float32[3, 1]]

rotation(*args, **kwargs)¶

Overloaded function.

rotation(self: csc.domain.Pivot) -> csc.math.Quaternion
rotation(self: csc.domain.Pivot, frame: int) -> csc.math.Quaternion
rotation(self: csc.domain.Pivot, frame: int, pivot: csc.domain.StatePivot) -> csc.math.Quaternion

select(self: csc.domain.Pivot, entity_id: csc.model.ObjectId | csc.domain.Tool_object_id) → None¶

class csc.domain.ProcessorsStorage¶

ProcessorsStorage class

The class serves to contain entity 3d processors

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.domain'¶

class csc.domain.Scene¶

Scene class

Root class that represents a scene and its methods for modifying or observing it.

Modify scene by func modify:

Parameters:

name – Name of the modifier
func – Modify functor void(modelEditor, updateEditor, scene)

Modify scene by func modify_update:

Parameters:

name – Name of the modifier
func – Modify functor void(modelEditor, updateEditor, sceneUpdater)

__annotations__ = {}¶

__init__(self: csc.domain.Scene) → None¶

__module__ = 'csc.domain'¶

assets_manager(self: csc.domain.Scene) → domain::scene::AssetsManager¶: -> AssetsManager

behaviour_viewer(self: csc.domain.Scene) → csc.model.BehaviourViewer¶: -> csc.model.BehaviourViewer

data_viewer(self: csc.domain.Scene) → csc.model.DataViewer¶: -> csc.model.DataViewer

error(self: csc.domain.Scene, arg0: str) → None¶

get_current_frame(self: csc.domain.Scene, clamp_animation: bool = True) → int¶: -> int

get_event_log_or_null(self: csc.domain.Scene) → object¶

get_layers_selector(self: csc.domain.Scene) → object¶: -> csc.layers.Selector

info(self: csc.domain.Scene, arg0: str) → None¶

layers_viewer(self: csc.domain.Scene) → csc.layers.Viewer¶: -> csc.layers.Viewer

model_viewer(self: csc.domain.Scene) → csc.model.ModelViewer¶: -> csc.model.ModelViewer

modify(self: csc.domain.Scene, arg0: str, arg1: Callable) → bool¶: -> bool

modify_update(self: csc.domain.Scene, arg0: str, arg1: Callable) → bool¶: -> bool

modify_update_with_session(self: csc.domain.Scene, arg0: str, arg1: Callable) → bool¶: -> bool

modify_with_session(self: csc.domain.Scene, arg0: str, arg1: Callable) → bool¶: -> bool

selector(self: csc.domain.Scene) → object¶: -> Selector

set_current_frame(self: csc.domain.Scene, frame: int) → None¶

set_event_log(self: csc.domain.Scene, message_handler: csc.domain.IMessageHandler) → None¶

success(self: csc.domain.Scene, arg0: str) → None¶

warning(self: csc.domain.Scene, arg0: str) → None¶

class csc.domain.SceneUpdater¶

SceneUpdater class

The SceneUpdater serves to rule the scene modify. If we changed the update, we should regenerate it, also it has the possible to run the update with certain data.

Variables:: run_update – overridden method by csc.model.DataId{} (localIds), int (frame) || csc.model.DataId{}, int{} (frames)

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.domain'¶

generate_update(self: csc.domain.SceneUpdater) → None¶

get_interpolator(self: csc.domain.SceneUpdater) → csc.domain.LocalInterpolator¶

run_update(*args, **kwargs)¶

Overloaded function.

run_update(self: csc.domain.SceneUpdater, local_ids: set[csc.model.DataId], frame: int) -> None
run_update(self: csc.domain.SceneUpdater, local_ids: set[csc.model.DataId], frames: csc.layers.index.FramesIndices) -> None

scene(self: csc.domain.SceneUpdater) → object¶

class csc.domain.Select¶

Select class

Represents properties of the current selection state of the scene

Variables:

object_ids – Get Set (csc.model.ObjectId or csc.scene.Tool_object_id){}
pivot_id – Get Set (csc.model.ObjectId or csc.scene.Tool_object_id)
filter – Get Set csc.scene.SelectorFilter
mode – Get Set csc.scene.SelectorMode
types_filter – Get Set string{}

__annotations__ = {}¶

__init__(self: csc.domain.Select) → None¶

__module__ = 'csc.domain'¶

property filter¶

property mode¶

property object_ids¶

property pivot_id¶

property types_filter¶

class csc.domain.Selection¶

Selection class

Contains selected objects

Variables:: ids – Get (csc.model.ObjectId or csc.scene.Tool_object_id){}

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.domain'¶

property ids¶

property ordered_ids¶

class csc.domain.SelectionChanger¶

SelectionChanger class

Contains basic methods and properties to operate current selected scene objects

Variables:

ids – Get (csc.model.ObjectId or csc.scene.Tool_object_id){}
select – overridden method by Select || Entity3d_id{}, Entity3d_id, SelectorFilter (SelectorFilter.Free), SelectorMode (SelectorMode.NewSelection), string{} (typeFilter)

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.domain'¶

clear_selection(self: csc.domain.SelectionChanger) → None¶

refresh_selection(self: csc.domain.SelectionChanger) → None¶

select(*args, **kwargs)¶

Overloaded function.

select(self: csc.domain.SelectionChanger, select: csc.domain.Select) -> None
select(self: csc.domain.SelectionChanger, ids: set[Union[csc.model.ObjectId, csc.domain.Tool_object_id]], id: Union[csc.model.ObjectId, csc.domain.Tool_object_id] = <csc.model.ObjectId object at 0x7f6b38ce0f70>, filter: csc.domain.SelectorFilter = <SelectorFilter.Free: 0>, mode: csc.domain.SelectorMode = <SelectorMode.NewSelection: 2>, types_filter: set[str] = set(), auto_pivot: bool = False) -> None

class csc.domain.Selector¶

Selector class

Contains basic methods and properties to operate current selected scene objects

Variables:

ids – Get (csc.model.ObjectId or csc.scene.Tool_object_id){}
select – overridden method by Select || Entity3d_id{}, Entity3d_id, SelectorFilter (SelectorFilter.Free), SelectorMode (SelectorMode.NewSelection), string{} (typeFilter)

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.domain'¶

pivot(self: csc.domain.Selector) → object¶: -> Pivot

select(*args, **kwargs)¶

Overloaded function.

select(self: csc.domain.Selector, select: csc.domain.Select) -> None
select(self: csc.domain.Selector, ids: set[Union[csc.model.ObjectId, csc.domain.Tool_object_id]], id: Union[csc.model.ObjectId, csc.domain.Tool_object_id] = <csc.model.ObjectId object at 0x7f6b38d18b30>, filter: csc.domain.SelectorFilter = <SelectorFilter.Free: 0>, mode: csc.domain.SelectorMode = <SelectorMode.NewSelection: 2>, type_filter: set[str] = set(), auto_pivot: bool = False) -> None

selected(self: csc.domain.Selector) → object¶: -> Selection

class csc.domain.SelectorFilter¶

SelectorFilter enumerable

Free = 0x00, Selectable = 0x01, ObjectType = 0x02, Layer = 0x04, CustomSelectionPolicy = 0x08, Standart = Selectable | ObjectType | Layer, Full = 0xFF,

Members:

Free

Selectable

ObjectType

Layer

CustomSelectionPolicy

Standart

Full

CustomSelectionPolicy = <SelectorFilter.CustomSelectionPolicy: 8>¶

Free = <SelectorFilter.Free: 0>¶

Full = <SelectorFilter.Full: 255>¶

Layer = <SelectorFilter.Layer: 4>¶

ObjectType = <SelectorFilter.ObjectType: 2>¶

Selectable = <SelectorFilter.Selectable: 1>¶

Standart = <SelectorFilter.Standart: 7>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.domain.SelectorFilter) → int¶

__init__(self: csc.domain.SelectorFilter, value: int) → None¶

__int__(self: csc.domain.SelectorFilter) → int¶

__members__ = {'CustomSelectionPolicy': <SelectorFilter.CustomSelectionPolicy: 8>, 'Free': <SelectorFilter.Free: 0>, 'Full': <SelectorFilter.Full: 255>, 'Layer': <SelectorFilter.Layer: 4>, 'ObjectType': <SelectorFilter.ObjectType: 2>, 'Selectable': <SelectorFilter.Selectable: 1>, 'Standart': <SelectorFilter.Standart: 7>}¶

__module__ = 'csc.domain'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.domain.SelectorFilter, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.domain.SelectorMode¶

SelectorMode enumerable

SingleSelection, // Resets if new objects were selected, and nothing changes if already selected ones were selected

MultiSelection, // Multiple selections. If not all objects were selected, adds, otherwise subtracts

NewSelection, // Resets everything and highlights the selection

AdditionSelection, // Adds all selections to selections

SubtractionSelection // Subtracts highlighted entities from selections

Members:

SingleSelection

MultiSelection

NewSelection

AdditionSelection

SubtractionSelection

AdditionSelection = <SelectorMode.AdditionSelection: 3>¶

MultiSelection = <SelectorMode.MultiSelection: 1>¶

NewSelection = <SelectorMode.NewSelection: 2>¶

SingleSelection = <SelectorMode.SingleSelection: 0>¶

SubtractionSelection = <SelectorMode.SubtractionSelection: 4>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.domain.SelectorMode) → int¶

__init__(self: csc.domain.SelectorMode, value: int) → None¶

__int__(self: csc.domain.SelectorMode) → int¶

__members__ = {'AdditionSelection': <SelectorMode.AdditionSelection: 3>, 'MultiSelection': <SelectorMode.MultiSelection: 1>, 'NewSelection': <SelectorMode.NewSelection: 2>, 'SingleSelection': <SelectorMode.SingleSelection: 0>, 'SubtractionSelection': <SelectorMode.SubtractionSelection: 4>}¶

__module__ = 'csc.domain'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.domain.SelectorMode, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.domain.Session¶

Session class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.domain'¶

set_current_frame(self: csc.domain.Session, frame: int) → None¶

take_layers_selector(self: csc.domain.Session) → object¶

take_selector(self: csc.domain.Session) → object¶

class csc.domain.StatePivot¶

StatePivot enum

This enumerates the basic types of pivot states. Fixed = 0, Moving = 1

Members:

Fixed

Moving

Fixed = <StatePivot.Fixed: 0>¶

Moving = <StatePivot.Moving: 1>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.domain.StatePivot) → int¶

__init__(self: csc.domain.StatePivot, value: int) → None¶

__int__(self: csc.domain.StatePivot) → int¶

__members__ = {'Fixed': <StatePivot.Fixed: 0>, 'Moving': <StatePivot.Moving: 1>}¶

__module__ = 'csc.domain'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.domain.StatePivot, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.domain.Tool_object_id¶

__annotations__ = {}¶

__cmp__(self: csc.domain.Tool_object_id, arg0: csc.domain.Tool_object_id) → int¶

__eq__(self: csc.domain.Tool_object_id, arg0: csc.domain.Tool_object_id) → bool¶

__hash__(self: csc.domain.Tool_object_id) → int¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.domain.Tool_object_id, arg0: str) -> None
__init__(self: csc.domain.Tool_object_id) -> None

__module__ = 'csc.domain'¶

__ne__(self: csc.domain.Tool_object_id, arg0: csc.domain.Tool_object_id) → bool¶

__str__(self: csc.domain.Tool_object_id) → str¶

is_null(self: csc.domain.Tool_object_id) → bool¶

static null() → csc.domain.Tool_object_id¶

to_string(self: csc.domain.Tool_object_id) → str¶

csc.domain.delete_entity_3d_processor(scene: csc.domain.Scene, ids: set[csc.model.ObjectId | csc.domain.Tool_object_id]) → None¶

csc.domain.find_actual_rig_info_id(scene: csc.domain.Scene, ids: set[csc.model.ObjectId | csc.domain.Tool_object_id]) → csc.model.BehaviourId¶

csc.domain.get_all_visible_ids_by_proc(scene: csc.domain.Scene, ids: set[csc.model.ObjectId | csc.domain.Tool_object_id], frame_index: int) → list[set[csc.model.ObjectId | csc.domain.Tool_object_id]]¶

csc.domain.get_tool_name(scene: csc.domain.Scene, id: csc.model.ObjectId | csc.domain.Tool_object_id) → str¶

csc.domain.get_tool_names(scene: csc.domain.Scene, ids: set[csc.model.ObjectId | csc.domain.Tool_object_id]) → list[str]¶

class csc.math.Affine¶

__annotations__ = {}¶

__init__(self: csc.math.Affine, angle_axisf: csc.math.AngleAxis) → None¶

__module__ = 'csc.math'¶

linear(self: csc.math.Affine) → numpy.ndarray[numpy.float32[3, 3], flags.f_contiguous]¶

class csc.math.AngleAxis¶

AngleAxis class

__annotations__ = {}¶

__init__(self: csc.math.AngleAxis, angle: float, axis: numpy.ndarray[numpy.float32[3, 1]]) → None¶

__module__ = 'csc.math'¶

affine_linear(self: csc.math.AngleAxis) → numpy.ndarray[numpy.float32[3, 3], flags.writeable, flags.f_contiguous]¶

angle(self: csc.math.AngleAxis) → float¶

axis(self: csc.math.AngleAxis) → numpy.ndarray[numpy.float32[3, 1]]¶

class csc.math.Circle¶

Circle3d class

__annotations__ = {}¶

__init__(self: csc.math.Circle, radius: numpy.ndarray[numpy.float32[3, 1]], center: float, normal: numpy.ndarray[numpy.float32[3, 1]]) → None¶

__module__ = 'csc.math'¶

center(self: csc.math.Sphere) → numpy.ndarray[numpy.float32[3, 1]]¶

normal(self: csc.math.Circle) → numpy.ndarray[numpy.float32[3, 1]]¶

radius(self: csc.math.Sphere) → float¶

class csc.math.OrthogonalTransform¶

OrthogonalTransform class

Implements orthogonal transform

Variables:

position – Get set Vector3f
rotation – Get set Rotation

__annotations__ = {}¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.math.OrthogonalTransform, position: numpy.ndarray[numpy.float32[3, 1]], rotate: csc.math.Quaternion) -> None
__init__(self: csc.math.OrthogonalTransform) -> None

__module__ = 'csc.math'¶

property position¶

property rotation¶

class csc.math.ParametrizedLine¶

ParametrizedLine class

__annotations__ = {}¶

__init__(self: csc.math.ParametrizedLine, origin: numpy.ndarray[numpy.float32[3, 1]], direction: numpy.ndarray[numpy.float32[3, 1]]) → None¶

__module__ = 'csc.math'¶

projection(self: csc.math.ParametrizedLine, arg0: numpy.ndarray[numpy.float32[3, 1]]) → numpy.ndarray[numpy.float32[3, 1]]¶

class csc.math.Plane¶

Hyperplane class

__annotations__ = {}¶

__init__(self: csc.math.Plane, normal: numpy.ndarray[numpy.float32[3, 1]], point: numpy.ndarray[numpy.float32[3, 1]]) → None¶

__module__ = 'csc.math'¶

projection(self: csc.math.Plane, arg0: numpy.ndarray[numpy.float32[3, 1]]) → numpy.ndarray[numpy.float32[3, 1]]¶

class csc.math.Quaternion¶

Quaternion class

This class is useful to calculate rotation operations.

__annotations__ = {}¶

__init__(self: csc.math.Quaternion, w: float, x: float, y: float, z: float) → None¶

__module__ = 'csc.math'¶

__mul__(*args, **kwargs)¶

Overloaded function.

__mul__(self: csc.math.Quaternion, arg0: csc.math.Quaternion) -> csc.math.Quaternion
__mul__(self: csc.math.Quaternion, arg0: numpy.ndarray[numpy.float32[3, 1]]) -> numpy.ndarray[numpy.float32[3, 1]]

static from_two_vectors(arg0: numpy.ndarray[numpy.float32[3, 1]], arg1: numpy.ndarray[numpy.float32[3, 1]]) → csc.math.Quaternion¶

static identity() → csc.math.Quaternion¶

inverse(self: csc.math.Quaternion) → csc.math.Quaternion¶

w(self: csc.math.Quaternion) → float¶

x(self: csc.math.Quaternion) → float¶

y(self: csc.math.Quaternion) → float¶

z(self: csc.math.Quaternion) → float¶

class csc.math.Rotation¶

Rotation class

The Euler angles implementation.

__annotations__ = {}¶

__init__(self: csc.math.Rotation) → None¶

__module__ = 'csc.math'¶

__mul__(self: csc.math.Rotation, arg0: csc.math.Rotation) → csc.math.Rotation¶

static from_angle_axis(*args, **kwargs)¶

Overloaded function.

from_angle_axis(arg0: float, arg1: numpy.ndarray[numpy.float32[3, 1]]) -> csc.math.Rotation
from_angle_axis(arg0: csc.math.AngleAxis) -> csc.math.Rotation

static from_euler(*args, **kwargs)¶

Overloaded function.

from_euler(x: float, y: float, z: float) -> csc.math.Rotation
from_euler(vec3f: numpy.ndarray[numpy.float32[3, 1]]) -> csc.math.Rotation

static from_quaternion(*args, **kwargs)¶

Overloaded function.

from_quaternion(w: float, x: float, y: float, z: float) -> csc.math.Rotation
from_quaternion(quaternion: csc.math.Quaternion) -> csc.math.Rotation

static from_rotation_matrix(arg0: numpy.ndarray[numpy.float32[3, 3]]) → csc.math.Rotation¶

inverse(self: csc.math.Rotation) → csc.math.Rotation¶

to_angle_axis(self: csc.math.Rotation) → csc.math.AngleAxis¶

to_euler_angles(self: csc.math.Rotation) → numpy.ndarray[numpy.float32[3, 1]]¶

to_euler_angles_x_y_z(self: csc.math.Rotation) → numpy.ndarray[numpy.float32[3, 1]]¶

to_quaternion(self: csc.math.Rotation) → csc.math.Quaternion¶

to_rotation_matrix(self: csc.math.Rotation) → numpy.ndarray[numpy.float32[3, 3]]¶

class csc.math.ScaledTransform¶

ScaledTransform class

Implements transform with the scale possibility.

Variables:

position – Get set Vector3f
rotation – Get set Rotation
scale – Get set Vector3f

__annotations__ = {}¶

__copy__(self: csc.math.ScaledTransform) → csc.math.ScaledTransform¶

__deepcopy__(self: csc.math.ScaledTransform, arg0: dict) → csc.math.ScaledTransform¶

__init__(self: csc.math.ScaledTransform) → None¶

__module__ = 'csc.math'¶

property position¶

property rotation¶

property scale¶

class csc.math.SizesInterval¶

SizesInterval class

Implements the sizes interval basic methods

__annotations__ = {}¶

__eq__(self: csc.math.SizesInterval, arg0: csc.math.SizesInterval) → bool¶

__hash__ = None¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.math.SizesInterval) -> None
__init__(self: csc.math.SizesInterval, start: int, end: int) -> None

__lt__(self: csc.math.SizesInterval, arg0: csc.math.SizesInterval) → bool¶

__module__ = 'csc.math'¶

static construct_in_right_order(first: int, second: int) → csc.math.SizesInterval¶

contains(self: csc.math.SizesInterval, i: int) → bool¶

empty(self: csc.math.SizesInterval) → bool¶: -> bool

end(self: csc.math.SizesInterval) → int¶: -> int

inside_interval_inclusive(self: csc.math.SizesInterval, number: int) → bool¶

static intersect_intervals(first: csc.math.SizesInterval, second: csc.math.SizesInterval) → csc.math.SizesInterval¶

static safe_construct(first: int, second: int) → csc.math.SizesInterval¶

start(self: csc.math.SizesInterval) → int¶: -> int

static union_overlaping_intervals(first: csc.math.SizesInterval, second: csc.math.SizesInterval) → csc.math.SizesInterval¶

class csc.math.Sphere¶

Sphere class

__annotations__ = {}¶

__init__(self: csc.math.Sphere, radius: numpy.ndarray[numpy.float32[3, 1]], center: float) → None¶

__module__ = 'csc.math'¶

center(self: csc.math.Sphere) → numpy.ndarray[numpy.float32[3, 1]]¶

radius(self: csc.math.Sphere) → float¶

class csc.math.Triangle¶

Triangle class

Structure from three points

Variables:

point1 – Get set Vector3f
point2 – Get set Vector3f
point3 – Get set Vector3f

__annotations__ = {}¶

__init__(self: csc.math.Triangle, point1: numpy.ndarray[numpy.float32[3, 1]], point2: numpy.ndarray[numpy.float32[3, 1]], point3: numpy.ndarray[numpy.float32[3, 1]]) → None¶

__module__ = 'csc.math'¶

property point1¶

property point2¶

property point3¶

csc.math.basic_transform_from_triangle(triangle: math::Triangle) → math::OrthogonalTransform¶: -> csc.math.OrthogonalTransform

csc.math.combine_transforms(first orthogonal transform: math::OrthogonalTransform, second orthogonal transform: math::OrthogonalTransform) → math::OrthogonalTransform¶: -> csc.math.OrthogonalTransform

csc.math.decompose_matrix(arg0: numpy.ndarray[numpy.float32[4, 4]]) → domain::scene::model::data_struct::ScaledTransform¶

csc.math.euler_angles_to_quaternion_x_y_z(euler_angles: numpy.ndarray[numpy.float32[3, 1]]) → csc.math.Quaternion¶: -> Quaternionf

csc.math.euler_flip(arg0: numpy.ndarray[numpy.float32[3, 1]], arg1: numpy.ndarray[numpy.float32[3, 1]]) → csc.math.Rotation¶

csc.math.get_m3f_diag(matrix: numpy.ndarray[numpy.float32[3, 3]]) → numpy.ndarray[numpy.float32[3, 1]]¶: -> Vector3f

csc.math.ik_spline(arg0: numpy.ndarray[numpy.float32[3, 1]], arg1: list[numpy.ndarray[numpy.float32[3, 1]]], arg2: list[csc.math.Quaternion], arg3: list[float]) → tuple[list[numpy.ndarray[numpy.float32[3, 1]]], list[csc.math.Quaternion]]¶: -> Tuple<vector<Vector3f>, vector<Quaternion>>

csc.math.ik_spline_3(arg0: list[numpy.ndarray[numpy.float32[3, 1]]], arg1: list[csc.math.Quaternion], arg2: list[float]) → tuple[list[numpy.ndarray[numpy.float32[3, 1]]], list[csc.math.Quaternion]]¶: -> Tuple<vector<Vector3f>, vector<Quaternion>>

csc.math.inverse_transform_point(transform: math::OrthogonalTransform, point: numpy.ndarray[numpy.float32[3, 1]]) → numpy.ndarray[numpy.float32[3, 1]]¶: -> Vector3f

csc.math.line_on_intersection_planes(arg0: csc.math.Plane, arg1: csc.math.Plane) → csc.math.ParametrizedLine | None¶

csc.math.modify_position_by_matrix(matrix: numpy.ndarray[numpy.float32[3, 3]], position: numpy.ndarray[numpy.float32[3, 1]]) → numpy.ndarray[numpy.float32[3, 1]]¶: -> Vector3f

csc.math.point_on_intersection_planes(arg0: csc.math.Plane, arg1: csc.math.Plane) → numpy.ndarray[numpy.float32[3, 1]] | None¶

csc.math.project_point_on_basic_line(line_direction: numpy.ndarray[numpy.float32[3, 1]], point: numpy.ndarray[numpy.float32[3, 1]]) → numpy.ndarray[numpy.float32[3, 1]]¶: -> Vector3f

csc.math.quaternion_to_euler_angles_x_y_z(quaternion: csc.math.Quaternion) → numpy.ndarray[numpy.float32[3, 1]]¶: -> Vector3f

csc.math.spheres_intersection(arg0: csc.math.Sphere, arg1: csc.math.Sphere) → csc.math.Circle | None¶

csc.math.spheres_intersection_extended(arg0: csc.math.Sphere, arg1: csc.math.Sphere) → csc.math.Circle | None¶

csc.math.step_linear_func(arg0: float, arg1: float, arg2: float) → float¶

csc.math.transform_point(*args, **kwargs)¶

Overloaded function.

transform_point(transform: math::OrthogonalTransform, point: numpy.ndarray[numpy.float32[3, 1]]) -> numpy.ndarray[numpy.float32[3, 1]]

-> Vector3f
transform_point(matrix: numpy.ndarray[numpy.float32[4, 4]], point: numpy.ndarray[numpy.float32[3, 1]]) -> numpy.ndarray[numpy.float32[3, 1]]

-> Vector3f

csc.math.transforms_difference(first orthogonal transform: math::OrthogonalTransform, second orthogonal transform: math::OrthogonalTransform) → math::OrthogonalTransform¶: -> csc.math.OrthogonalTransform

csc.math.untwist(arg0: numpy.ndarray[numpy.float32[4, 4]], arg1: numpy.ndarray[numpy.float32[4, 4]], arg2: float, arg3: float, arg4: int, arg5: bool) → numpy.ndarray[numpy.float32[4, 4]]¶: (weight:float,roll:float,axis:int,negate:bool, parentMatrix:Matrix4f,objectMatrix:Matrix4f) -> Matrix4f

class csc.physics.PosMass¶

PosMass class

This structure contains the mass and the position

Variables:

mass – Get Set float.
position – Get Set Vector3f.

__annotations__ = {}¶

__init__(self: csc.physics.PosMass, mass: float, position: numpy.ndarray[numpy.float32[3, 1]]) → None¶

__module__ = 'csc.physics'¶

property mass¶

property position¶

csc.physics.inertia_tensor(mass_and_poses: list[csc.physics.PosMass], center: numpy.ndarray[numpy.float32[3, 1]]) → numpy.ndarray[numpy.float32[3, 3]]¶: -> Matrix3f

csc.update The Cascadeur python module that implements basic update editor methods and its infrastructure.¶

Update editor provides a node-like interface to edit data and setting graphs. Naming conventions: regular means the same as data. It differs stuff from settings.

Additional functionality. Update editor can be used to check what data functions will be active if you set some datas as actual.

AttributeId = std::variant<RegularFunctionAttributeId, ActivityAttributeId,: RegularDataAttributeId, ActualityAttributeId, SettingFunctionAttributeId, SettingDataAttributeId, GroupAttributeId, ExternalPropertyAttributeId, ConstantDataAttributeId, ConstantSettingAttributeId>;

`csc.update.NodeAttribute`	NodeAttribute represents a generic node attribute and the standard operations you can do with such an attribute.
`csc.update.RegularDataAttribute`	RegularDataAttribute represents an attribute of a regular data.
`csc.update.ActualityAttribute`	ActualityAttribute shows whether data is actual at the start of the graphs update.
`csc.update.ConstantDataAttribute`	ConstantDataAttribute represents an attribute of a constant regular data.
`csc.update.ConstantSettingAttribute`	ConstantSettingAttribute represents an attribute of a constant setting.
`csc.update.ExternalPropertyAttribute`	ExternalPropertyAttribute represents an attribute of the external properties of the update.
`csc.update.SettingFunctionAttribute`	SettingFunctionAttribute represents an attribute of a setting function.
`csc.update.InterfaceAttributeSide`	InterfaceAttributeSide enumerable
`csc.update.InterfaceAttribute`	InterfaceAttribute represents a group attribute.
`csc.update.RegularFunctionAttribute`	RegularFunctionAttribute represents an attribute of a data function.
`csc.update.ActivityAttribute`	ActivityAttribute represents the activity of the data function.
`csc.update.SettingDataAttribute`	SettingDataAttribute represents an attribute of a setting.
`csc.update.Node`	Node class represents a generic Node and implements methods that are common for all nodes
`csc.update.InterfaceNode`	InterfaceNode is a node inside the group that represents its connections with the ouside nodes.
`csc.update.ConstantDatas`	ConstantDatas represents a node of constant datas.
`csc.update.ConstantSettings`	ConstantSettings represents a node of constant settings.
`csc.update.ExternalProperties`	ExternalProperties represents a node of external properties.
`csc.update.RegularFunction`	RegularFunction class represents a node that calculates same operation, done with datas.
`csc.update.SettingData`	SettingData class represents a node that calculates same operation, done with settings.
`csc.update.SettingFunction`	SettingFunction class
`csc.update.Object`	Object class represents an object node.
`csc.update.RegularData`	RegularData class represents a node of a data.
`csc.update.Group`	Group class
`csc.update.ObjectGroup`	ObjectGroup class represents object group node
`csc.update.UpdateGroup`	UpdateGroup class represents update group node
`csc.update.HierarchyUpdate`	HierarchyUpdate class provides concrete operations with connections
`csc.update.Update`	Update class represents the whole update editor
`csc.update.RegularFunctionAttributeId`	RegularFunctionAttributeId is defined by the RegularFunctionId and the name of the attribute
`csc.update.RegularDataAttributeId`	RegularDataAttributeId is defined by the data id.
`csc.update.ActualityAttributeId`	ActualityAttributeId is defined by the data id.
`csc.update.SettingFunctionAttributeId`	SettingFunctionAttributeId is defined by the SettingFunctionId and the index of the attribute
`csc.update.GroupId`
`csc.update.GroupAttributeId`	GroupAttributeId is defined by the GroupId and the guid-based id of the attribute.
`csc.update.ExternalPropertiesId`	ExternalPropertiesId is a guid based id.
`csc.update.ExternalProperty`	ExternalProperty enum
`csc.update.ExternalPropertyAttributeId`	ExternalPropertyAttributeId is defined by the ExternalPropertiesId and the value of the ExternalProperty enum
`csc.update.ConstantDatasId`	ConstantDatasId is a guid based id.
`csc.update.ConstantDataAttributeId`	ConstantDataAttributeId is defined by the ConstantDatasId and the data id of the constant
`csc.update.ConstantSettingsId`	ConstantSettingsId is a guid based id.
`csc.update.ConstantSettingAttributeId`	ConstantSettingAttributeId is defined by the ConstantSettingId and the setting id of the constant
`csc.update.Connection`	Connection class
`csc.update.InterfaceId`	InterfaceId is defined by the GroupId and the direction type of the node - input or output connection node.

class csc.update.ActivityAttribute¶

ActivityAttribute represents the activity of the data function. It should be bool. If true - function is active, if false - inactive. If not set - always active. It is an input-only attribute.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

class csc.update.ActualityAttribute¶

ActualityAttribute shows whether data is actual at the start of the graphs update. It’s always an output attribute. It can be connected with setting functions.

!Connections directly with data functions activity are not supported, use copy setting function instead)

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

class csc.update.ActualityAttributeId¶

ActualityAttributeId is defined by the data id. It’s an output only attribute. Each data can be actual or non-actual at the start of the graphs update.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.update.ActualityAttributeId, arg0: str) -> None
__init__(self: csc.update.ActualityAttributeId, arg0: csc.model.DataId) -> None
__init__(self: csc.update.ActualityAttributeId) -> None

__module__ = 'csc.update'¶

class csc.update.Connection¶

Connection class

Implements the Connection between two attributes

Variables:

source – Get output AttributeId of the source
destination – Get input AttributeId of the destination

AttributeId = std::variant<RegularFunctionAttributeId, ActivityAttributeId,: RegularDataAttributeId, ActualityAttributeId, SettingFunctionAttributeId, SettingDataAttributeId, GroupAttributeId, ExternalPropertyAttributeId, ConstantDataAttributeId, ConstantSettingAttributeId>

__annotations__ = {}¶

__module__ = 'csc.update'¶

property destination¶

property source¶

class csc.update.ConstantDataAttribute¶

ConstantDataAttribute represents an attribute of a constant regular data. It’s always an output attribute. It can be connected with setting functions or data functions activity.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

class csc.update.ConstantDataAttributeId¶

ConstantDataAttributeId is defined by the ConstantDatasId and the data id of the constant

Implements the ConstantDataAttributeId.

Variables:

group_id – Get ConstantDatasId
attribute_id – Get the data id (csc.model.DataId)

__annotations__ = {}¶

__init__(self: csc.update.ConstantDataAttributeId, group_id: csc.update.ConstantDatasId, attribute_id: csc.model.DataId) → None¶

__module__ = 'csc.update'¶

property attribute_id¶

property group_id¶

class csc.update.ConstantDatas¶

ConstantDatas represents a node of constant datas. It is present in any place.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

add_data(self: csc.update.ConstantDatas, name: str, value: bool | int | float | numpy.ndarray[numpy.float32[3, 1]] | numpy.ndarray[numpy.float32[4, 1]] | csc.math.Rotation | numpy.ndarray[numpy.float32[3, 3]] | numpy.ndarray[numpy.float32[4, 4]] | csc.math.Quaternion | str | numpy.ndarray[bool[3, 1]]) → None¶: value: Data.Value

class csc.update.ConstantDatasId¶

ConstantDatasId is a guid based id. It is always equal to the group id, where the constant will be used.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.update.ConstantDatasId, arg0: csc.update.GroupId) -> None
__init__(self: csc.update.ConstantDatasId, arg0: str) -> None
__init__(self: csc.update.ConstantDatasId) -> None

__module__ = 'csc.update'¶

class csc.update.ConstantSettingAttribute¶

ConstantSettingAttribute represents an attribute of a constant setting. It’s always an output attribute. It can be connected with data functions.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

class csc.update.ConstantSettingAttributeId¶

ConstantSettingAttributeId is defined by the ConstantSettingId and the setting id of the constant

Implements the ConstantSettingAttributeId.

Variables:

group_id – Get ConstantSettingsId
attribute_id – Get csc.model.SettingId

__annotations__ = {}¶

__init__(self: csc.update.ConstantSettingAttributeId, group_id: csc.update.ConstantSettingsId, attribute_id: csc.model.SettingId) → None¶

__module__ = 'csc.update'¶

property attribute_id¶

property group_id¶

class csc.update.ConstantSettings¶

ConstantSettings represents a node of constant settings. It is present in any place.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

add_setting(self: csc.update.ConstantSettings, name: str, value: bool | int) → None¶: value: Setting.Value

class csc.update.ConstantSettingsId¶

ConstantSettingsId is a guid based id. It is always equal to the group id, where the constant will be used.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.update.ConstantSettingsId, arg0: csc.update.GroupId) -> None
__init__(self: csc.update.ConstantSettingsId, arg0: str) -> None
__init__(self: csc.update.ConstantSettingsId) -> None

__module__ = 'csc.update'¶

class csc.update.ExternalProperties¶

ExternalProperties represents a node of external properties. (E.g. is this update called during interpolation or not) It is represent in any place.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

property_outputs(self: csc.update.ExternalProperties) → list[csc.update.ExternalPropertyAttribute]¶

class csc.update.ExternalPropertiesId¶

ExternalPropertiesId is a guid based id. It is always equal to the group id, where the external property will be used.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.update.ExternalPropertiesId, arg0: csc.update.GroupId) -> None
__init__(self: csc.update.ExternalPropertiesId, arg0: str) -> None
__init__(self: csc.update.ExternalPropertiesId) -> None

__module__ = 'csc.update'¶

class csc.update.ExternalProperty¶

ExternalProperty enum

This enumerates the basic types of ExternalProperty states: Fixation, IsForwardKinematics, KinematicsType, InterpolationType, IsInterpolation, AfterPhysics, IsKey, IsStretching

Members:

Fixation

IsForwardKinematics

KinematicsType

InterpolationType

IsInterpolation

AfterPhysics

IsKey

IsStretching

AfterPhysics = <ExternalProperty.AfterPhysics: 5>¶

Fixation = <ExternalProperty.Fixation: 0>¶

InterpolationType = <ExternalProperty.InterpolationType: 3>¶

IsForwardKinematics = <ExternalProperty.IsForwardKinematics: 1>¶

IsInterpolation = <ExternalProperty.IsInterpolation: 4>¶

IsKey = <ExternalProperty.IsKey: 6>¶

IsStretching = <ExternalProperty.IsStretching: 7>¶

KinematicsType = <ExternalProperty.KinematicsType: 2>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.update.ExternalProperty) → int¶

__init__(self: csc.update.ExternalProperty, value: int) → None¶

__int__(self: csc.update.ExternalProperty) → int¶

__members__ = {'AfterPhysics': <ExternalProperty.AfterPhysics: 5>, 'Fixation': <ExternalProperty.Fixation: 0>, 'InterpolationType': <ExternalProperty.InterpolationType: 3>, 'IsForwardKinematics': <ExternalProperty.IsForwardKinematics: 1>, 'IsInterpolation': <ExternalProperty.IsInterpolation: 4>, 'IsKey': <ExternalProperty.IsKey: 6>, 'IsStretching': <ExternalProperty.IsStretching: 7>, 'KinematicsType': <ExternalProperty.KinematicsType: 2>}¶

__module__ = 'csc.update'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.update.ExternalProperty, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.update.ExternalPropertyAttribute¶

ExternalPropertyAttribute represents an attribute of the external properties of the update. It’s always an output attribute. It is settings based and thus can be connected with setting functions or data functions activity.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

class csc.update.ExternalPropertyAttributeId¶

ExternalPropertyAttributeId is defined by the ExternalPropertiesId and the value of the ExternalProperty enum

Implements the ExternalPropertyAttributeId.

Variables:

node_id – Get GroupId
property – Get ExternalProperty enum value

__annotations__ = {}¶

__init__(self: csc.update.ExternalPropertyAttributeId, node_id: csc.update.ExternalPropertiesId, property: csc.update.ExternalProperty) → None¶

__module__ = 'csc.update'¶

property node_id¶

property property¶

class csc.update.Group¶

Group class

Variables:: node – overridden by name || node, access node by name or id

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

add_input(self: csc.update.Group, name: str) → csc.update.InterfaceAttribute¶

add_output(self: csc.update.Group, name: str) → csc.update.InterfaceAttribute¶

constant_datas(self: csc.update.Group) → csc.update.ConstantDatas¶: get virtual node to access constant datas

constant_settings(self: csc.update.Group) → csc.update.ConstantSettings¶: get virtual node to access constant settings

create_group(self: csc.update.Group, name: str) → csc.update.Group¶

delete_node(self: csc.update.Group, node: csc.update.Node) → None¶

group(self: csc.update.Group, nodes: set[csc.update.Node], name: str) → csc.update.Group¶

group_id(self: csc.update.Group) → csc.update.GroupId¶: create sub group

has_node(self: csc.update.Group, name: str) → bool¶: check whether there is a child node with a given name

input_interface_node(self: csc.update.Group) → csc.update.InterfaceNode¶

interface_input(self: csc.update.Group, name: str) → csc.update.InterfaceAttribute¶

interface_inputs(self: csc.update.Group) → list[csc.update.InterfaceAttribute]¶: get group attributes as interface attributes

interface_node(self: csc.update.Group, direction: csc.Direction) → csc.update.InterfaceNode¶: access the interface node

interface_output(self: csc.update.Group, name: str) → csc.update.InterfaceAttribute¶

interface_outputs(self: csc.update.Group) → list[csc.update.InterfaceAttribute]¶

is_root(self: csc.update.Group) → csc.update.GroupId¶

leaf_children(self: csc.update.Group) → set[csc.update.Node]¶: get all leaf nodes (settings, datas, functions)

node(*args, **kwargs)¶

Overloaded function.

node(self: csc.update.Group, name: str) -> csc.update.Node
node(self: csc.update.Group, node: Union[csc.update.GroupId, csc.update.InterfaceId, csc.update.ExternalPropertiesId, csc.update.ConstantDatasId, csc.update.ConstantSettingsId, csc.model.ObjectId, csc.model.HyperedgeId, csc.model.DataId, csc.model.SettingFunctionId, csc.model.SettingId]) -> csc.update.Node

node_deep(self: csc.update.Group, name: str) → csc.update.Node¶: access node by name or id recursively

node_with_type(self: csc.update.Group, type_name: str, name: str) → csc.update.Node¶: find node with name and type

node_with_type_deep(self: csc.update.Group, type_name: str, name: str) → csc.update.Node¶: find node with name and type recursively

nodes(self: csc.update.Group) → set[csc.update.Node]¶: get all children (their children are not included)

output_interface_node(self: csc.update.Group) → csc.update.InterfaceNode¶

class csc.update.GroupAttributeId¶

GroupAttributeId is defined by the GroupId and the guid-based id of the attribute. Group attribute names and indeces can change, so they are provided with their own guid

Implements the GroupAttributeId.

Variables:

group_id – Get GroupId
attribute_id – Get csc.Guid - id of the attribute

__annotations__ = {}¶

__init__(self: csc.update.GroupAttributeId, group_id: csc.update.GroupId, attribute_id: csc.Guid) → None¶

__module__ = 'csc.update'¶

property attribute_id¶

property group_id¶

class csc.update.GroupId¶

__annotations__ = {}¶

__cmp__(self: csc.update.GroupId, arg0: csc.update.GroupId) → int¶

__eq__(self: csc.update.GroupId, arg0: csc.update.GroupId) → bool¶

__hash__(self: csc.update.GroupId) → int¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.update.GroupId, arg0: str) -> None
__init__(self: csc.update.GroupId) -> None

__module__ = 'csc.update'¶

__ne__(self: csc.update.GroupId, arg0: csc.update.GroupId) → bool¶

__str__(self: csc.update.GroupId) → str¶

is_null(self: csc.update.GroupId) → bool¶

static null() → csc.update.GroupId¶

to_string(self: csc.update.GroupId) → str¶

class csc.update.HierarchyUpdate¶

HierarchyUpdate class provides concrete operations with connections

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

add_connection(self: csc.update.HierarchyUpdate, connection: csc.update.Connection) → None¶

remove_connection(self: csc.update.HierarchyUpdate, connection: csc.update.Connection) → None¶

class csc.update.InterfaceAttribute¶

InterfaceAttribute represents a group attribute. Can be potentially connected to any attribute.

Interface attribute can be: 1. An attribute of input/output node inside the group 2. An attribute of the group node itself, in the parent group layout (outside the group) We will call this attributes “paired”. For each attribute there is a paired one. They have the same attribute ids and names. Sometimes it’s easier to think of them as of one attribute that has 2 sides. But in terms of this class this are two separate objects.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

group_attribute_id(self: csc.update.InterfaceAttribute) → csc.update.GroupAttributeId¶: get the group attribute id

other_side(self: csc.update.InterfaceAttribute) → csc.update.InterfaceAttribute¶: Get the paired attribute (e.g. the other side of the attribute)

set_name(self: csc.update.InterfaceAttribute, name: str) → None¶: Rename the attribute

class csc.update.InterfaceAttributeSide¶

InterfaceAttributeSide enumerable

InterfaceSide - inside the group, GroupSide - when the group is a node

Members:

InterfaceSide

GroupSide

GroupSide = <InterfaceAttributeSide.GroupSide: 1>¶

InterfaceSide = <InterfaceAttributeSide.InterfaceSide: 0>¶

__annotations__ = {}¶

__eq__(self: object, other: object) → bool¶

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

__index__(self: csc.update.InterfaceAttributeSide) → int¶

__init__(self: csc.update.InterfaceAttributeSide, value: int) → None¶

__int__(self: csc.update.InterfaceAttributeSide) → int¶

__members__ = {'GroupSide': <InterfaceAttributeSide.GroupSide: 1>, 'InterfaceSide': <InterfaceAttributeSide.InterfaceSide: 0>}¶

__module__ = 'csc.update'¶

__ne__(self: object, other: object) → bool¶

__repr__(self: object) → str¶

__setstate__(self: csc.update.InterfaceAttributeSide, state: int) → None¶

__str__(self: object) → str¶

property name¶

property value¶

class csc.update.InterfaceId¶

InterfaceId is defined by the GroupId and the direction type of the node - input or output connection node.

Implements the InterfaceId.

Variables:

group_id – Get GroupId
direction – Get direction type (csc.Direction)

__annotations__ = {}¶

__init__(self: csc.update.InterfaceId, group_id: csc.update.GroupId, direction: csc.Direction) → None¶

__module__ = 'csc.update'¶

property direction¶

property group_id¶

class csc.update.InterfaceNode¶

InterfaceNode is a node inside the group that represents its connections with the ouside nodes. Its attributes are csc.update.InterfaceAttributes

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

add_attribute(self: csc.update.InterfaceNode, name: str) → csc.update.InterfaceAttribute¶

direction(self: csc.update.InterfaceNode) → csc.Direction¶: -> csc.DirectionValue

interface_attributes(self: csc.update.InterfaceNode) → list[csc.update.InterfaceAttribute]¶: -> InterfaceAttribute[]

move_attribute(self: csc.update.InterfaceNode, attribute: csc.update.InterfaceAttribute, position: int) → None¶: attribute: InterfaceAttribute | position: int

remove_attribute(self: csc.update.InterfaceNode, attribute: csc.update.InterfaceAttribute) → None¶: attribute: InterfaceAttribute

class csc.update.Node¶

Node class represents a generic Node and implements methods that are common for all nodes

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

attributes(self: csc.update.Node, d: csc.Direction) → list[csc.update.NodeAttribute]¶: array of all input and output attributes

equal_to(self: csc.update.Node, arg0: csc.update.Node) → bool¶

full_name(self: csc.update.Node) → str¶: name with all the parent nodes

has_input(self: csc.update.Node, name: str) → bool¶: check if there is an input with such a name

has_output(self: csc.update.Node, name: str) → bool¶: check if there is an output with such a name

id(self: csc.update.Node) → csc.update.GroupId | csc.update.InterfaceId | csc.update.ExternalPropertiesId | csc.update.ConstantDatasId | csc.update.ConstantSettingsId | csc.model.ObjectId | csc.model.HyperedgeId | csc.model.DataId | csc.model.SettingFunctionId | csc.model.SettingId¶: get uniqui id

input(self: csc.update.Node, name: str) → csc.update.NodeAttribute¶: shortcut if node has only one input attribute

inputs(self: csc.update.Node) → list[csc.update.NodeAttribute]¶: array of all the inputes attributes

is_active(self: csc.update.Node) → bool¶: check whether it is active for current actualities states (see Additional functionality in csc.update.UpdateEditor)

is_fictive(self: csc.update.Node) → bool¶: whether it is a fictive node (constants, inputs, outputs of a group or external properties)

name(self: csc.update.Node) → str¶: get name

output(self: csc.update.Node, name: str) → csc.update.NodeAttribute¶: shortcut if node has only one output attribute

outputs(self: csc.update.Node) → list[csc.update.NodeAttribute]¶: array of all the outputs attributes

parent_group(self: csc.update.Node) → domain::update_editor::Group¶: return parent group (where this group node is located)

parent_object(self: csc.update.Node) → domain::update_editor::Object¶: return object of the node. Will return null if this is not an update group

set_name(self: csc.update.Node, name: str) → None¶: rename node

class csc.update.NodeAttribute¶

NodeAttribute represents a generic node attribute and the standard operations you can do with such an attribute.

Variables:: disconnect – overridden method with parameter attribute: NodeAttribute

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

connect(self: csc.update.NodeAttribute, attribute: csc.update.NodeAttribute) → None¶: attribute: NodeAttribute

connected_attributes(self: csc.update.NodeAttribute) → list[csc.update.NodeAttribute]¶: -> NodeAttribute[]

connected_leaves(self: csc.update.NodeAttribute, get_only_first: bool = False) → list[csc.update.NodeAttribute]¶: -> NodeAttribute[]

connected_leaves_in_undirected_graph(self: csc.update.NodeAttribute) → list[csc.update.NodeAttribute]¶

direction(self: csc.update.NodeAttribute) → csc.Direction¶: -> csc.DirectionValue

disconnect(*args, **kwargs)¶

Overloaded function.

disconnect(self: csc.update.NodeAttribute) -> None
disconnect(self: csc.update.NodeAttribute, attribute: csc.update.NodeAttribute) -> None

id(self: csc.update.NodeAttribute) → csc.update.RegularFunctionAttributeId | csc.model.HyperedgeId | csc.update.RegularDataAttributeId | csc.update.ActualityAttributeId | csc.update.SettingFunctionAttributeId | csc.model.SettingId | csc.update.GroupAttributeId | csc.update.ExternalPropertyAttributeId | csc.update.ConstantDataAttributeId | csc.update.ConstantSettingAttributeId¶: -> AttributeId

is_active(self: csc.update.NodeAttribute) → bool¶

name(self: csc.update.NodeAttribute) → str¶

node(self: csc.update.NodeAttribute) → domain::update_editor::Node¶: -> Node

class csc.update.Object¶

Object class represents an object node. Functionality is limited - it’s better to use update group node instead.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

add_input(self: csc.update.Object, name: str) → csc.update.InterfaceAttribute¶: -> InterfaceAttribute

add_output(self: csc.update.Object, name: str) → csc.update.InterfaceAttribute¶: -> InterfaceAttribute

object_id(self: csc.update.Object) → csc.model.ObjectId¶

root_group(self: csc.update.Object) → domain::update_editor::UpdateGroup¶: -> UpdateGroup

class csc.update.ObjectGroup¶

ObjectGroup class represents object group node

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

create_object(*args, **kwargs)¶

Overloaded function.

create_object(self: csc.update.ObjectGroup, name: str) -> csc.update.Object
create_object(self: csc.update.ObjectGroup, name: str, id: csc.model.ObjectId) -> csc.update.Object

create_sub_object_group(self: csc.update.ObjectGroup, name: str) → csc.update.ObjectGroup¶: -> ObjectGroup

object_groups(self: csc.update.ObjectGroup) → set[csc.update.ObjectGroup]¶: -> ObjectGroup{}

objects(self: csc.update.ObjectGroup) → set[csc.update.Object]¶: -> Object{}

class csc.update.RegularData¶

RegularData class represents a node of a data.

Variables:

value – overridden method by frame, get data value (requires frame if Animation data)
set_value – overridden method by frame, set data value (requires frame if Animation data)

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

actuality(self: csc.update.RegularData) → csc.update.ActualityAttribute¶: output attribute, that provides actuality status

attribute(self: csc.update.RegularData, d: csc.Direction) → csc.update.RegularDataAttribute¶: get attribute by direction

data_id(self: csc.update.RegularData) → csc.model.DataId¶

get_apply_euler_filter(self: csc.update.RegularData) → bool¶: get apply euler filter

get_explicit_linear(self: csc.update.RegularData) → bool¶: get explicit linear

get_lerp_mode(self: csc.update.RegularData) → csc.model.LerpMode¶: get lerp mode

get_period(self: csc.update.RegularData) → float | None¶: in interpolation, get period

input(self: csc.update.RegularData) → csc.update.RegularDataAttribute¶: input attribute

is_actual(self: csc.update.RegularData) → bool¶: check if this data is set to actual (see Additional functionality in csc.update.UpdateEditor)

mode(self: csc.update.RegularData) → csc.model.DataMode¶: Check if data is Animation or Static

output(self: csc.update.RegularData) → csc.update.RegularDataAttribute¶: output attribute

remove_period(self: csc.update.RegularData) → None¶: in interpolation, remove period

set_actual(self: csc.update.RegularData, act: bool) → None¶: set this data as actual (see Additional functionality in csc.update.UpdateEditor)

set_apply_euler_filter(self: csc.update.RegularData, apply_euler_filter: bool) → None¶: set apply euler filter

set_description_value(self: csc.update.RegularData, name: str) → None¶: setDescriptionValue

set_explicit_linear(self: csc.update.RegularData, explicit_linear: bool) → None¶: set explicit linear

set_lerp_mode(self: csc.update.RegularData, mode: csc.model.LerpMode) → None¶: can be slerp for Vector3 datas. Used in interpolation

set_period(self: csc.update.RegularData, period: float) → None¶: in interpolation, if perion is provided, the data will be “fixed” to provide smoothness

set_value(*args, **kwargs)¶

Overloaded function.

set_value(self: csc.update.RegularData, v: Union[bool, int, float, numpy.ndarray[numpy.float32[3, 1]], numpy.ndarray[numpy.float32[4, 1]], csc.math.Rotation, numpy.ndarray[numpy.float32[3, 3]], numpy.ndarray[numpy.float32[4, 4]], csc.math.Quaternion, str, numpy.ndarray[bool[3, 1]]]) -> None
set_value(self: csc.update.RegularData, v: Union[bool, int, float, numpy.ndarray[numpy.float32[3, 1]], numpy.ndarray[numpy.float32[4, 1]], csc.math.Rotation, numpy.ndarray[numpy.float32[3, 3]], numpy.ndarray[numpy.float32[4, 4]], csc.math.Quaternion, str, numpy.ndarray[bool[3, 1]]], frame: int) -> None

value(*args, **kwargs)¶

Overloaded function.

value(self: csc.update.RegularData) -> Union[bool, int, float, numpy.ndarray[numpy.float32[3, 1]], numpy.ndarray[numpy.float32[4, 1]], csc.math.Rotation, numpy.ndarray[numpy.float32[3, 3]], numpy.ndarray[numpy.float32[4, 4]], csc.math.Quaternion, str, numpy.ndarray[bool[3, 1]]]
value(self: csc.update.RegularData, frame: int) -> Union[bool, int, float, numpy.ndarray[numpy.float32[3, 1]], numpy.ndarray[numpy.float32[4, 1]], csc.math.Rotation, numpy.ndarray[numpy.float32[3, 3]], numpy.ndarray[numpy.float32[4, 4]], csc.math.Quaternion, str, numpy.ndarray[bool[3, 1]]]

class csc.update.RegularDataAttribute¶

RegularDataAttribute represents an attribute of a regular data. It can be connected with data functions.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

class csc.update.RegularDataAttributeId¶

RegularDataAttributeId is defined by the data id. Data only has one input and one output attributes.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: csc.update.RegularDataAttributeId, arg0: str) -> None
__init__(self: csc.update.RegularDataAttributeId, arg0: csc.model.DataId) -> None
__init__(self: csc.update.RegularDataAttributeId) -> None

__module__ = 'csc.update'¶

class csc.update.RegularFunction¶

RegularFunction class represents a node that calculates same operation, done with datas.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

activity(self: csc.update.RegularFunction) → csc.update.ActivityAttribute¶: activity attributes

arguments(self: csc.update.RegularFunction) → list[csc.update.RegularFunctionAttribute]¶: its input arguments

decrease_vector(self: csc.update.RegularFunction, path: str, direction: csc.Direction) → None¶: method that decreases vector attribute

func_id(self: csc.update.RegularFunction) → csc.model.HyperedgeId¶: its id

increase_vector(self: csc.update.RegularFunction, path: str, direction: csc.Direction) → csc.update.RegularFunctionAttribute¶: method that increases vector attribute

is_convertible(self: csc.update.RegularFunction) → bool¶: check whether this function will make it to the resulting data graph

remove_attribute(self: csc.update.RegularFunction, attribute: csc.update.RegularFunctionAttribute) → None¶: method that removes one in vector attribute

resize_vector_inputs(self: csc.update.RegularFunction, count: int, path: str) → None¶: method that resizes input vector attribute

resize_vector_outputs(self: csc.update.RegularFunction, count: int, path: str) → None¶: method that resizes output vector attribute

results(self: csc.update.RegularFunction) → list[csc.update.RegularFunctionAttribute]¶: its output arguments

set_convertible(self: csc.update.RegularFunction, convertible: bool) → None¶: set the state of the function, whether it will be used or not

type_name(self: csc.update.RegularFunction) → str¶: function name

class csc.update.RegularFunctionAttribute¶

RegularFunctionAttribute represents an attribute of a data function. It can be connected with data attributes.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

class csc.update.RegularFunctionAttributeId¶

RegularFunctionAttributeId is defined by the RegularFunctionId and the name of the attribute

Variables:

function_id – Get SettingFunctionId
attribute_id – Get name of the attribute

__annotations__ = {}¶

__init__(self: csc.update.RegularFunctionAttributeId, function_id: csc.model.HyperedgeId, attribute_id: str) → None¶

__module__ = 'csc.update'¶

property attribute_id¶

property function_id¶

class csc.update.SettingData¶

SettingData class represents a node that calculates same operation, done with settings. It can comprise bool or std::int8_t (Min: -128, Max: 127) value, please be carefull when you set this.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

data_id(self: csc.update.SettingData) → csc.model.SettingId¶: get setting unique id

output(self: csc.update.SettingData) → csc.update.SettingDataAttribute¶: output attribute

set_value(*args, **kwargs)¶

Overloaded function.

set_value(self: csc.update.SettingData, value: Union[bool, int]) -> None

set setting value
set_value(self: csc.update.SettingData, value: Union[bool, int], frame: int) -> None

set setting value

value(*args, **kwargs)¶

Overloaded function.

value(self: csc.update.SettingData) -> Union[bool, int]

get setting value
value(self: csc.update.SettingData, frame: int) -> Union[bool, int]

get setting value

class csc.update.SettingDataAttribute¶

SettingDataAttribute represents an attribute of a setting. It can be connected with setting functions.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

class csc.update.SettingFunction¶

SettingFunction class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

arguments(self: csc.update.SettingFunction) → list[csc.update.SettingFunctionAttribute]¶: input attributes

decrease_input_vector(self: csc.update.SettingFunction, index: int) → None¶: method that decreases input vector attribute

func_id(self: csc.update.SettingFunction) → csc.model.SettingFunctionId¶: its id

increase_input_vector(self: csc.update.SettingFunction, index: int) → csc.update.SettingFunctionAttribute¶: method that increases input vector attribute

is_convertible(self: csc.update.SettingFunction) → bool¶: check whether this function will make it to the resulting setting graph

remove_attribute(self: csc.update.SettingFunction, attribute: csc.update.SettingFunctionAttribute) → None¶: method that removes one in input vector attribute

resize_vector_inputs(self: csc.update.SettingFunction, index: int, count: int) → None¶: method that resizes input vector attribute

results(self: csc.update.SettingFunction) → list[csc.update.SettingFunctionAttribute]¶: output attributes

set_convertible(self: csc.update.SettingFunction, convertible: bool) → None¶: set the state of the function, whether it will be used or not

type_name(self: csc.update.SettingFunction) → str¶: function name

class csc.update.SettingFunctionAttribute¶

SettingFunctionAttribute represents an attribute of a setting function. It can be connected with setting functions or data function activeness attributes.

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

is_out_true(self: csc.update.SettingFunctionAttribute) → bool¶

output_id(self: csc.update.SettingFunctionAttribute) → csc.model.SettingId¶

class csc.update.SettingFunctionAttributeId¶

SettingFunctionAttributeId is defined by the SettingFunctionId and the index of the attribute

Implements the SettingFunctionAttributeId.

Variables:

function_id – Get SettingFunctionId
attribute_index – Get index of the attribute
attribute_sub_index – Get index of the attribute in array

__annotations__ = {}¶

__init__(self: csc.update.SettingFunctionAttributeId, function_id: csc.model.SettingFunctionId, attribute_index: int, attribute_sub_index: int = 0) → None¶

__module__ = 'csc.update'¶

property attribute_index¶

property attribute_sub_index¶

property function_id¶

class csc.update.Update¶

Update class represents the whole update editor

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

delete_node(self: csc.update.Update, id: csc.update.GroupId | csc.update.InterfaceId | csc.update.ExternalPropertiesId | csc.update.ConstantDatasId | csc.update.ConstantSettingsId | csc.model.ObjectId | csc.model.HyperedgeId | csc.model.DataId | csc.model.SettingFunctionId | csc.model.SettingId) → None¶

get_node_by_id(self: csc.update.Update, id: csc.update.GroupId | csc.update.InterfaceId | csc.update.ExternalPropertiesId | csc.update.ConstantDatasId | csc.update.ConstantSettingsId | csc.model.ObjectId | csc.model.HyperedgeId | csc.model.DataId | csc.model.SettingFunctionId | csc.model.SettingId) → csc.update.Node¶

get_object_by_id(self: csc.update.Update, arg0: csc.model.ObjectId) → csc.update.Object¶

root(self: csc.update.Update) → csc.update.ObjectGroup¶: -> ObjectGroup

ungroup(self: csc.update.Update, group: csc.update.Group) → None¶

class csc.update.UpdateGroup¶

UpdateGroup class represents update group node

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.update'¶

create_regular_data(self: csc.update.UpdateGroup, name: str, value: Union[bool, int, float, numpy.ndarray[numpy.float32[3, 1]], numpy.ndarray[numpy.float32[4, 1]], csc.math.Rotation, numpy.ndarray[numpy.float32[3, 3]], numpy.ndarray[numpy.float32[4, 4]], csc.math.Quaternion, str, numpy.ndarray[bool[3, 1]]], mode: csc.model.DataMode = <DataMode.Static: 0>) → csc.update.RegularData¶

create_regular_function(self: csc.update.UpdateGroup, name: str, function: str) → csc.update.RegularFunction¶

create_setting_data(self: csc.update.UpdateGroup, name: str, value: Union[bool, int], mode: csc.model.SettingMode = <SettingMode.Static: 0>) → csc.update.SettingData¶

create_setting_function(self: csc.update.UpdateGroup, name: str, function_name: str) → csc.update.SettingFunction¶

create_sub_update_group(self: csc.update.UpdateGroup, arg0: str) → csc.update.UpdateGroup¶

create_sub_update_group2(self: csc.update.UpdateGroup, name: str, group_id: csc.update.GroupId) → csc.update.UpdateGroup¶: -> UpdateGroup

external_properties(self: csc.update.UpdateGroup) → csc.update.ExternalProperties¶: -> ExternalProperties

groups(self: csc.update.UpdateGroup) → set[csc.update.UpdateGroup]¶: -> UpdateGroup{}

regular_datas(self: csc.update.UpdateGroup) → set[csc.update.RegularData]¶: -> RegularData{}

regular_functions(self: csc.update.UpdateGroup) → set[csc.update.RegularFunction]¶: -> RegularFunction{}

setting_functions(self: csc.update.UpdateGroup) → set[csc.update.SettingFunction]¶: -> SettingFunction{}

settings_datas(self: csc.update.UpdateGroup) → set[csc.update.SettingData]¶: -> SettingsData{}