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`
`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.

Parameters:: value (csc.DirectionValue) –

__annotations__ = {}¶

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

__module__ = 'csc'¶

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

to_string(self: csc.Direction) → str¶

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

class csc.DirectionValue¶

DirectionValue enumeration In, Out, Unknown

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__()¶: name(self: handle) -> 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.SystemVariables¶

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc'¶

static git_count() → str¶

static git_date() → str¶

static git_sha() → str¶

static git_version() → str¶

class csc.Version¶

Version class

Implements Version.

Variables:

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

__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¶

property major¶

property minor¶

property patch¶

to_string(self: csc.Version) → 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`
`csc.tools.ObjectKey`
`csc.tools.DataKey`
`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`
`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.CollisionInfoForPoint`	Structure with which the point collides.
`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_fixed_points – all points need to fix with collision get_not_interpolated_points – if in map, no interpolation in apply get_local_fixed_points – points that should keep local coordinates after apply get_collision_normal_points – collision points with normal type get_collision_pin_points – collision points with pin type get_collision_fixed_points – collision points with fulcrum groups get_fulcrum_floor_points – points collide with only floor get_fixed_floor_points – points collide with only floor and fulcrum groups get_frame_collision_info_points – collision info about points

__annotations__ = {}¶

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

__module__ = 'csc.tools'¶

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

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

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

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

get_fixed_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::CollisionInfoForPoint]]¶: Dict[frame number, Dict[csc.model.ObjectId, CollisionInfoForPoint]]

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

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

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

get_not_interpolated_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¶

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

class csc.tools.AutoPhysicTool¶

Auto physics tool class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools'¶

turn_off(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.CollisionInfoForPoint¶

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.DataKey¶

__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.JointData¶

__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

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.tools'¶

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

class csc.tools.ObjectKey¶

__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¶

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

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

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

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

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

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

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

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

get_preserved_data(self: csc.tools.RiggingModeTool) → Dict[csc.tools.DataKey, List[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_preserved_object_ids(self: csc.tools.RiggingModeTool) → Dict[csc.model.PathName, csc.model.ObjectId]¶

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

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

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

set_preserved_data(self: csc.tools.RiggingModeTool, arg0: csc.domain.Session, arg1: Dict[csc.tools.DataKey, List[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_preserved_object_ids(self: csc.tools.RiggingModeTool, arg0: csc.domain.Session, arg1: Dict[csc.model.PathName, csc.model.ObjectId]) → None¶

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

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

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¶

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'¶

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__()¶: name(self: handle) -> 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_interval(self: csc.tools.mirror.Core, arg0: Set[csc.model.ObjectId | csc.domain.Tool_object_id]) → None¶

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

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

class csc.tools.attractor.Args¶

__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__()¶: name(self: handle) -> 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 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__()¶: name(self: handle) -> 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__()¶: name(self: handle) -> 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__()¶: name(self: handle) -> 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__()¶: name(self: handle) -> 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__()¶: name(self: handle) -> 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`	Domain Spherical camera class
`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¶

Domain Spherical camera class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.view'¶

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

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

class csc.view.CameraType¶

CameraType enumerable

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__()¶: name(self: handle) -> 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: function, 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: function, force_active_focus: bool = False, accent: bool = False) -> None

__module__ = 'csc.view'¶

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

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

class csc.view.DialogManager¶

DialogManager class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.view'¶

static instance() → object¶

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

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

show_input_dialog(*args, **kwargs)¶

Overloaded function.

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

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

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

class csc.view.FileDialogManager¶

FileDialogManager class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.view'¶

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

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

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

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

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

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

event_log(self: csc.view.Scene) → object¶: -> csc.app.EventLog

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

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

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

viewports(self: csc.view.Scene) → List[object]¶: Provides all of csc.view.Viewport objects

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

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__()¶: name(self: handle) -> str

property name¶

property value¶

class csc.view.Viewport¶

Viewport class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.view'¶

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

class csc.view.ViewportDomain¶

Domain Viewport class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.view'¶

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

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

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

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

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

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

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

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__()¶: name(self: handle) -> 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.Analytics`	Analytics class
`csc.app.ActionManager`	ActionManager class
`csc.app.DataSourceManager`	DataSourceManager class
`csc.app.EventLog`	EventLog class
`csc.app.SettingsManager`	SettingsManager class
`csc.app.SceneManager`	SceneManager class
`csc.app.SceneTool`	SceneTool class
`csc.app.CascadeurTool`	CascadeurTool class
`csc.app.ToolsManager`	ToolsManager class
`csc.app.Application`	Application class
`csc.app.ProjectLoader`	ProjectLoader class

class csc.app.ActionManager¶

ActionManager class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

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

class csc.app.Analytics¶

Analytics class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

static send_action(type: str, key: str = '', label: str = '') → None¶

class csc.app.Application¶

Application class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

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

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

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

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

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

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

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

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

class csc.app.CascadeurTool¶

CascadeurTool class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

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

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

class csc.app.DataSourceManager¶

DataSourceManager class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

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

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

save_current_scene(*args, **kwargs)¶

Overloaded function.

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

save_scene(*args, **kwargs)¶

Overloaded function.

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

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

class csc.app.EventLog¶

EventLog class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

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¶

class csc.app.SceneManager¶

SceneManager class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

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

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

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

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

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

class csc.app.SceneTool¶

SceneTool class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

class csc.app.SettingsManager¶

SettingsManager class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

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

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

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

class csc.app.ToolsManager¶

ToolsManager class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.app'¶

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

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

csc.app.get_application() → object¶

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
`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(source_dir: str = '') → object¶

get_parts_info_by_id(self: csc.parts.Buffer) → List[csc.parts.Info]¶

get_src_dir(self: csc.parts.Buffer) → str¶

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¶

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

take_elementary_to_parts(self: csc.parts.Buffer, part_name: str, from: csc.domain.Scene, object_id: csc.model.ObjectId, parent_group: csc.update.GroupId, elementary: csc.parts.GroupInfo, path_to_scene_parts: str) → csc.parts.Info¶

take_object_to_parts(self: csc.parts.Buffer, part_name: str, from: csc.domain.Scene, object_id: csc.model.ObjectId, path_to_scene_parts: str) → csc.parts.Info¶

take_objects_to_parts(self: csc.parts.Buffer, part_name: str, from: csc.domain.Scene, objects: List[csc.model.ObjectId], objects_grs: List[csc.update.GroupId], path_to_scene_parts: str) → csc.parts.Info¶

take_selected_objects_to_parts(self: csc.parts.Buffer, part_name: str, from: csc.domain.Scene, selected_objects: List[csc.model.ObjectId], path_to_scene_parts: str) → csc.parts.Info¶

take_update_group_to_parts(self: csc.parts.Buffer, part_name: str, from: csc.domain.Scene, object_id: csc.model.ObjectId, parent_group: csc.update.GroupId, elementary: csc.parts.GroupInfo, sub_groups: List[csc.update.GroupId], path_to_scene_parts: str) → csc.parts.Info¶

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__()¶: name(self: handle) -> str

property name¶

property value¶

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

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

class csc.external.fbx.ExtraDatas¶

ExtraDatas class

__annotations__ = {}¶

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

__module__ = 'csc.external.fbx'¶

property look¶

property node_index¶

property post_rotation¶

property pre_rotation¶

property size¶

class csc.external.fbx.FbxDatas¶

FbxDatas class

__annotations__ = {}¶

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

__module__ = 'csc.external.fbx'¶

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

__annotations__ = {}¶

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

__module__ = 'csc.fbx'¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class csc.fbx.FbxSceneLoader¶

FbxSceneLoader class

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.fbx'¶

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

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

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

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

class csc.fbx.FbxSettings¶

FbxSettings class

__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__()¶: name(self: handle) -> str

property name¶

property value¶

class csc.fbx.FbxSettingsMode¶

FbxSettingsMode enumeration

Binary, Ascii

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__()¶: name(self: handle) -> str

property name¶

property value¶

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

`csc.rig.AddElementData`
`csc.rig.BoneProperty`
`csc.rig.TwistProperty`
`csc.rig.TwistBoneProperty`
`csc.rig.QrtData`

class csc.rig.AddElementData¶

__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 is_align_pelvis¶

property is_create_layers¶

property is_replace_existing¶

property left_hand¶

property right_hand¶

property twists¶

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 joint_path_name¶

property object_id¶

property twist_axis¶

property twist_strength¶

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

__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¶: -> bool

property last_active_frame_index¶

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

property left_inactive_frame_index¶

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

property right_inactive_frame_index¶

class csc.layers.CyclesEditor¶

Cycle editor class

__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¶

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

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

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

class csc.layers.CyclesViewer¶

Cycle viewer class

__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¶

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

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

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

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

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

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

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

is_pos_in_inactive_cycle_zone(self: csc.layers.CyclesViewer, arg0: int) → 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: function) → 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.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.DataModifyToView`	DataModifyToView enumerable
`csc.model.LerpMode`	LerpMode enumerable
`csc.model.DescriptionTerm`
`csc.model.CustomSelectionPolicy`	CustomSelectionPolicy enumerable
`csc.model.PropertyType`	PropertyType enumerable
`csc.model.PathName`

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_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_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_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_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_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

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

cluster_by_data(self: csc.model.ClusterEditor, data_id: csc.model.DataId) → int¶: data_id : csc.model.DataId | -> 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.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__()¶: name(self: handle) -> 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
enum_name – Get Set string

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'csc.model'¶

property enum_name¶

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_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

clusters_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) → None¶

delete_setting(self: csc.model.DataEditor, id: csc.model.SettingId) → None¶

set_animation_size(self: csc.model.DataEditor, size: int) → None¶

set_data_enum_name(self: csc.model.DataEditor, id: csc.model.DataId, enum_name: str) → None¶

set_data_only_key(self: csc.model.DataEditor, id: csc.model.DataId, only_key: bool) → None¶: id : csc.model.DataId | only_key : bool

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_data_view_state(self: csc.model.DataEditor, id: csc.model.DataId, view_state: csc.model.DataModifyToView) → None¶: id : csc.model.DataId | viewState : DataModifyToView

set_setting_enum_name(self: csc.model.DataEditor, id: csc.model.SettingId, enum_name: 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__()¶: name(self: handle) -> str

property name¶

property value¶

class csc.model.DataModifyToView¶

DataModifyToView enumerable

Empty, Degrees, Color

Members:

Empty

Degrees

Color

Color = <DataModifyToView.Color: 2>¶

Degrees = <DataModifyToView.Degrees: 1>¶

Empty = <DataModifyToView.Empty: 0>¶

__annotations__ = {}¶

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

__getstate__(self: object) → int¶

__hash__(self: object) → int¶

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

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

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

__members__ = {'Color': <DataModifyToView.Color: 2>, 'Degrees': <DataModifyToView.Degrees: 1>, 'Empty': <DataModifyToView.Empty: 0>}¶

__module__ = 'csc.model'¶

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

__repr__(self: object) → str¶

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

__str__()¶: name(self: handle) -> 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'¶

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_behaviour_default_data_value(self: csc.model.DataViewer, id: csc.model.BehaviourId, name: str) → 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¶: id : csc.model.Beh id | name : string | -> csc.model.DataValue

get_behaviour_property(*args, **kwargs)¶

Overloaded function.

get_behaviour_property(self: csc.model.DataViewer, id: csc.model.BehaviourId, name: str, 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]]]
get_behaviour_property(self: csc.model.DataViewer, id: csc.model.BehaviourId, name: str) -> Union[bool, 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_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_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_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

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__()¶: name(self: handle) -> 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¶

get_viewer(self: csc.model.ModelEditor) → csc.model.ModelViewer¶

increase_animation_size_by_setting_key(self: csc.model.ModelEditor, animation_size: int) → None¶: animationSize : int

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_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__()¶: name(self: handle) -> 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__()¶: name(self: handle) -> 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.FigureVertex`	FigureVertex class
`csc.domain.assets.Triangle`	Triangle class
`csc.domain.assets.MeshRaw`	MeshRaw class
`csc.domain.assets.Mesh`	Mesh class
`csc.domain.assets.MeshDependency`	MeshDependency 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__()¶: name(self: handle) -> 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__()¶: name(self: handle) -> 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: function) → bool¶: -> bool

modify_update(self: csc.domain.Scene, arg0: str, arg1: function) → bool¶: -> bool

modify_update_with_session(self: csc.domain.Scene, arg0: str, arg1: function) → bool¶: -> bool

modify_with_session(self: csc.domain.Scene, arg0: str, arg1: function) → 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¶

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 0x7f4735d4b9f0>, 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 0x7f4735d4aff0>, 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, OnlySingle = 0x08, Standart = Selectable | ObjectType | Layer, Full = 0xFF,

Members:

Free

Selectable

ObjectType

Layer

OnlySingle

Standart

Full

Free = <SelectorFilter.Free: 0>¶

Full = <SelectorFilter.Full: 255>¶

Layer = <SelectorFilter.Layer: 4>¶

ObjectType = <SelectorFilter.ObjectType: 2>¶

OnlySingle = <SelectorFilter.OnlySingle: 8>¶

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__ = {'Free': <SelectorFilter.Free: 0>, 'Full': <SelectorFilter.Full: 255>, 'Layer': <SelectorFilter.Layer: 4>, 'ObjectType': <SelectorFilter.ObjectType: 2>, 'OnlySingle': <SelectorFilter.OnlySingle: 8>, '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__()¶: name(self: handle) -> 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__()¶: name(self: handle) -> 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__()¶: name(self: handle) -> 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¶

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'¶

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¶

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_2(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

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

Members:

Fixation

IsForwardKinematics

KinematicsType

InterpolationType

IsInterpolation

AfterPhysics

IsKey

AfterPhysics = <ExternalProperty.AfterPhysics: 5>¶

Fixation = <ExternalProperty.Fixation: 0>¶

InterpolationType = <ExternalProperty.InterpolationType: 3>¶

IsForwardKinematics = <ExternalProperty.IsForwardKinematics: 1>¶

IsInterpolation = <ExternalProperty.IsInterpolation: 4>¶

IsKey = <ExternalProperty.IsKey: 6>¶

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>, '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__()¶: name(self: handle) -> 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__()¶: name(self: handle) -> 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

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_view_state(self: csc.update.RegularData) → csc.model.DataModifyToView¶: get view state

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_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

set_view_state(self: csc.update.RegularData, view_state: csc.model.DataModifyToView) → None¶: for float values - whether it should be displayed in degrees (as an angle)

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

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

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{}