# {py:mod}`simvx.core.csg`

```{py:module} simvx.core.csg
```

```{autodoc2-docstring} simvx.core.csg
:allowtitles:
```

## Module Contents

### Classes

````{list-table}
:class: autosummary longtable
:align: left

* - {py:obj}`CSGOperation <simvx.core.csg.CSGOperation>`
  - ```{autodoc2-docstring} simvx.core.csg.CSGOperation
    :summary:
    ```
* - {py:obj}`CSGShape3D <simvx.core.csg.CSGShape3D>`
  - ```{autodoc2-docstring} simvx.core.csg.CSGShape3D
    :summary:
    ```
* - {py:obj}`CSGBox3D <simvx.core.csg.CSGBox3D>`
  - ```{autodoc2-docstring} simvx.core.csg.CSGBox3D
    :summary:
    ```
* - {py:obj}`CSGSphere3D <simvx.core.csg.CSGSphere3D>`
  - ```{autodoc2-docstring} simvx.core.csg.CSGSphere3D
    :summary:
    ```
* - {py:obj}`CSGCylinder3D <simvx.core.csg.CSGCylinder3D>`
  - ```{autodoc2-docstring} simvx.core.csg.CSGCylinder3D
    :summary:
    ```
* - {py:obj}`CSGCombiner3D <simvx.core.csg.CSGCombiner3D>`
  - ```{autodoc2-docstring} simvx.core.csg.CSGCombiner3D
    :summary:
    ```
````

### Functions

````{list-table}
:class: autosummary longtable
:align: left

* - {py:obj}`csg_combine <simvx.core.csg.csg_combine>`
  - ```{autodoc2-docstring} simvx.core.csg.csg_combine
    :summary:
    ```
````

### Data

````{list-table}
:class: autosummary longtable
:align: left

* - {py:obj}`log <simvx.core.csg.log>`
  - ```{autodoc2-docstring} simvx.core.csg.log
    :summary:
    ```
* - {py:obj}`__all__ <simvx.core.csg.__all__>`
  - ```{autodoc2-docstring} simvx.core.csg.__all__
    :summary:
    ```
````

### API

````{py:data} log
:canonical: simvx.core.csg.log
:value: >
   'getLogger(...)'

```{autodoc2-docstring} simvx.core.csg.log
```

````

````{py:data} __all__
:canonical: simvx.core.csg.__all__
:value: >
   ['CSGOperation', 'CSGShape3D', 'CSGBox3D', 'CSGSphere3D', 'CSGCylinder3D', 'CSGCombiner3D']

```{autodoc2-docstring} simvx.core.csg.__all__
```

````

`````{py:class} CSGOperation()
:canonical: simvx.core.csg.CSGOperation

Bases: {py:obj}`enum.IntEnum`

```{autodoc2-docstring} simvx.core.csg.CSGOperation
```

```{rubric} Initialization
```

```{autodoc2-docstring} simvx.core.csg.CSGOperation.__init__
```

````{py:attribute} UNION
:canonical: simvx.core.csg.CSGOperation.UNION
:value: >
   0

```{autodoc2-docstring} simvx.core.csg.CSGOperation.UNION
```

````

````{py:attribute} SUBTRACT
:canonical: simvx.core.csg.CSGOperation.SUBTRACT
:value: >
   1

```{autodoc2-docstring} simvx.core.csg.CSGOperation.SUBTRACT
```

````

````{py:attribute} INTERSECT
:canonical: simvx.core.csg.CSGOperation.INTERSECT
:value: >
   2

```{autodoc2-docstring} simvx.core.csg.CSGOperation.INTERSECT
```

````

````{py:method} __abs__()
:canonical: simvx.core.csg.CSGOperation.__abs__

````

````{py:method} __add__()
:canonical: simvx.core.csg.CSGOperation.__add__

````

````{py:method} __and__()
:canonical: simvx.core.csg.CSGOperation.__and__

````

````{py:method} __bool__()
:canonical: simvx.core.csg.CSGOperation.__bool__

````

````{py:method} __ceil__()
:canonical: simvx.core.csg.CSGOperation.__ceil__

````

````{py:method} __delattr__()
:canonical: simvx.core.csg.CSGOperation.__delattr__

````

````{py:method} __dir__()
:canonical: simvx.core.csg.CSGOperation.__dir__

````

````{py:method} __divmod__()
:canonical: simvx.core.csg.CSGOperation.__divmod__

````

````{py:method} __eq__()
:canonical: simvx.core.csg.CSGOperation.__eq__

````

````{py:method} __float__()
:canonical: simvx.core.csg.CSGOperation.__float__

````

````{py:method} __floor__()
:canonical: simvx.core.csg.CSGOperation.__floor__

````

````{py:method} __floordiv__()
:canonical: simvx.core.csg.CSGOperation.__floordiv__

````

````{py:method} __format__()
:canonical: simvx.core.csg.CSGOperation.__format__

````

````{py:method} __ge__()
:canonical: simvx.core.csg.CSGOperation.__ge__

````

````{py:method} __getattribute__()
:canonical: simvx.core.csg.CSGOperation.__getattribute__

````

````{py:method} __getnewargs__()
:canonical: simvx.core.csg.CSGOperation.__getnewargs__

````

````{py:method} __getstate__()
:canonical: simvx.core.csg.CSGOperation.__getstate__

````

````{py:method} __gt__()
:canonical: simvx.core.csg.CSGOperation.__gt__

````

````{py:method} __hash__()
:canonical: simvx.core.csg.CSGOperation.__hash__

````

````{py:method} __index__()
:canonical: simvx.core.csg.CSGOperation.__index__

````

````{py:method} __int__()
:canonical: simvx.core.csg.CSGOperation.__int__

````

````{py:method} __invert__()
:canonical: simvx.core.csg.CSGOperation.__invert__

````

````{py:method} __le__()
:canonical: simvx.core.csg.CSGOperation.__le__

````

````{py:method} __lshift__()
:canonical: simvx.core.csg.CSGOperation.__lshift__

````

````{py:method} __lt__()
:canonical: simvx.core.csg.CSGOperation.__lt__

````

````{py:method} __mod__()
:canonical: simvx.core.csg.CSGOperation.__mod__

````

````{py:method} __mul__()
:canonical: simvx.core.csg.CSGOperation.__mul__

````

````{py:method} __ne__()
:canonical: simvx.core.csg.CSGOperation.__ne__

````

````{py:method} __neg__()
:canonical: simvx.core.csg.CSGOperation.__neg__

````

````{py:method} __new__()
:canonical: simvx.core.csg.CSGOperation.__new__

````

````{py:method} __or__()
:canonical: simvx.core.csg.CSGOperation.__or__

````

````{py:method} __pos__()
:canonical: simvx.core.csg.CSGOperation.__pos__

````

````{py:method} __pow__()
:canonical: simvx.core.csg.CSGOperation.__pow__

````

````{py:method} __radd__()
:canonical: simvx.core.csg.CSGOperation.__radd__

````

````{py:method} __rand__()
:canonical: simvx.core.csg.CSGOperation.__rand__

````

````{py:method} __rdivmod__()
:canonical: simvx.core.csg.CSGOperation.__rdivmod__

````

````{py:method} __reduce__()
:canonical: simvx.core.csg.CSGOperation.__reduce__

````

````{py:method} __reduce_ex__()
:canonical: simvx.core.csg.CSGOperation.__reduce_ex__

````

````{py:method} __repr__()
:canonical: simvx.core.csg.CSGOperation.__repr__

````

````{py:method} __rfloordiv__()
:canonical: simvx.core.csg.CSGOperation.__rfloordiv__

````

````{py:method} __rlshift__()
:canonical: simvx.core.csg.CSGOperation.__rlshift__

````

````{py:method} __rmod__()
:canonical: simvx.core.csg.CSGOperation.__rmod__

````

````{py:method} __rmul__()
:canonical: simvx.core.csg.CSGOperation.__rmul__

````

````{py:method} __ror__()
:canonical: simvx.core.csg.CSGOperation.__ror__

````

````{py:method} __round__()
:canonical: simvx.core.csg.CSGOperation.__round__

````

````{py:method} __rpow__()
:canonical: simvx.core.csg.CSGOperation.__rpow__

````

````{py:method} __rrshift__()
:canonical: simvx.core.csg.CSGOperation.__rrshift__

````

````{py:method} __rshift__()
:canonical: simvx.core.csg.CSGOperation.__rshift__

````

````{py:method} __rsub__()
:canonical: simvx.core.csg.CSGOperation.__rsub__

````

````{py:method} __rtruediv__()
:canonical: simvx.core.csg.CSGOperation.__rtruediv__

````

````{py:method} __rxor__()
:canonical: simvx.core.csg.CSGOperation.__rxor__

````

````{py:method} __setattr__()
:canonical: simvx.core.csg.CSGOperation.__setattr__

````

````{py:method} __sizeof__()
:canonical: simvx.core.csg.CSGOperation.__sizeof__

````

````{py:method} __str__()
:canonical: simvx.core.csg.CSGOperation.__str__

````

````{py:method} __sub__()
:canonical: simvx.core.csg.CSGOperation.__sub__

````

````{py:method} __subclasshook__()
:canonical: simvx.core.csg.CSGOperation.__subclasshook__

````

````{py:method} __truediv__()
:canonical: simvx.core.csg.CSGOperation.__truediv__

````

````{py:method} __trunc__()
:canonical: simvx.core.csg.CSGOperation.__trunc__

````

````{py:method} __xor__()
:canonical: simvx.core.csg.CSGOperation.__xor__

````

````{py:method} as_integer_ratio()
:canonical: simvx.core.csg.CSGOperation.as_integer_ratio

````

````{py:method} bit_count()
:canonical: simvx.core.csg.CSGOperation.bit_count

````

````{py:method} bit_length()
:canonical: simvx.core.csg.CSGOperation.bit_length

````

````{py:method} conjugate()
:canonical: simvx.core.csg.CSGOperation.conjugate

````

```{py:class} denominator
:canonical: simvx.core.csg.CSGOperation.denominator

```

```{py:class} imag
:canonical: simvx.core.csg.CSGOperation.imag

```

````{py:method} is_integer()
:canonical: simvx.core.csg.CSGOperation.is_integer

````

```{py:class} numerator
:canonical: simvx.core.csg.CSGOperation.numerator

```

```{py:class} real
:canonical: simvx.core.csg.CSGOperation.real

```

````{py:method} to_bytes()
:canonical: simvx.core.csg.CSGOperation.to_bytes

````

````{py:method} __deepcopy__(memo)
:canonical: simvx.core.csg.CSGOperation.__deepcopy__

````

````{py:method} __copy__()
:canonical: simvx.core.csg.CSGOperation.__copy__

````

````{py:method} name()
:canonical: simvx.core.csg.CSGOperation.name

````

````{py:method} value()
:canonical: simvx.core.csg.CSGOperation.value

````

`````

````{py:function} csg_combine(mesh_a: simvx.core.graphics.mesh.Mesh, mesh_b: simvx.core.graphics.mesh.Mesh, operation: simvx.core.csg.CSGOperation) -> simvx.core.graphics.mesh.Mesh
:canonical: simvx.core.csg.csg_combine

```{autodoc2-docstring} simvx.core.csg.csg_combine
```
````

`````{py:class} CSGShape3D(operation: simvx.core.csg.CSGOperation = CSGOperation.UNION, **kwargs)
:canonical: simvx.core.csg.CSGShape3D

Bases: {py:obj}`simvx.core.nodes_3d.node3d.Node3D`

```{autodoc2-docstring} simvx.core.csg.CSGShape3D
```

```{rubric} Initialization
```

```{autodoc2-docstring} simvx.core.csg.CSGShape3D.__init__
```

````{py:attribute} operation
:canonical: simvx.core.csg.CSGShape3D.operation
:value: >
   'Property(...)'

```{autodoc2-docstring} simvx.core.csg.CSGShape3D.operation
```

````

````{py:method} get_mesh() -> simvx.core.graphics.mesh.Mesh
:canonical: simvx.core.csg.CSGShape3D.get_mesh

```{autodoc2-docstring} simvx.core.csg.CSGShape3D.get_mesh
```

````

````{py:attribute} render_layer
:canonical: simvx.core.csg.CSGShape3D.render_layer
:value: >
   'Property(...)'

````

````{py:property} position
:canonical: simvx.core.csg.CSGShape3D.position

````

````{py:property} rotation
:canonical: simvx.core.csg.CSGShape3D.rotation
:type: simvx.core.math.types.Quat

````

````{py:property} scale
:canonical: simvx.core.csg.CSGShape3D.scale

````

````{py:property} rotation_degrees
:canonical: simvx.core.csg.CSGShape3D.rotation_degrees
:type: simvx.core.math.types.Vec3

````

````{py:property} world_position
:canonical: simvx.core.csg.CSGShape3D.world_position
:type: simvx.core.math.types.Vec3

````

````{py:property} world_rotation
:canonical: simvx.core.csg.CSGShape3D.world_rotation
:type: simvx.core.math.types.Quat

````

````{py:property} world_scale
:canonical: simvx.core.csg.CSGShape3D.world_scale
:type: simvx.core.math.types.Vec3

````

````{py:property} forward
:canonical: simvx.core.csg.CSGShape3D.forward
:type: simvx.core.math.types.Vec3

````

````{py:property} right
:canonical: simvx.core.csg.CSGShape3D.right
:type: simvx.core.math.types.Vec3

````

````{py:property} up
:canonical: simvx.core.csg.CSGShape3D.up
:type: simvx.core.math.types.Vec3

````

````{py:method} translate(offset: tuple[float, float, float] | numpy.ndarray)
:canonical: simvx.core.csg.CSGShape3D.translate

````

````{py:method} translate_global(offset: tuple[float, float, float] | numpy.ndarray)
:canonical: simvx.core.csg.CSGShape3D.translate_global

````

````{py:method} rotate(axis: tuple[float, float, float] | numpy.ndarray, angle: float)
:canonical: simvx.core.csg.CSGShape3D.rotate

````

````{py:method} rotate_x(angle: float)
:canonical: simvx.core.csg.CSGShape3D.rotate_x

````

````{py:method} rotate_y(angle: float)
:canonical: simvx.core.csg.CSGShape3D.rotate_y

````

````{py:method} rotate_z(angle: float)
:canonical: simvx.core.csg.CSGShape3D.rotate_z

````

````{py:method} look_at(target: tuple[float, float, float] | numpy.ndarray, up=None)
:canonical: simvx.core.csg.CSGShape3D.look_at

````

````{py:method} set_render_layer(index: int, enabled: bool = True) -> None
:canonical: simvx.core.csg.CSGShape3D.set_render_layer

````

````{py:method} is_on_render_layer(index: int) -> bool
:canonical: simvx.core.csg.CSGShape3D.is_on_render_layer

````

````{py:method} wrap_bounds(bounds: tuple[float, float, float] | numpy.ndarray, margin: float = 1.0)
:canonical: simvx.core.csg.CSGShape3D.wrap_bounds

````

````{py:attribute} strict_errors
:canonical: simvx.core.csg.CSGShape3D.strict_errors
:type: typing.ClassVar[bool]
:value: >
   True

````

````{py:attribute} script_error_raised
:canonical: simvx.core.csg.CSGShape3D.script_error_raised
:value: >
   'Signal(...)'

````

````{py:method} __init_subclass__(**kwargs)
:canonical: simvx.core.csg.CSGShape3D.__init_subclass__
:classmethod:

````

````{py:property} name
:canonical: simvx.core.csg.CSGShape3D.name
:type: str

````

````{py:property} process_mode
:canonical: simvx.core.csg.CSGShape3D.process_mode
:type: simvx.core.descriptors.ProcessMode

````

````{py:method} reset_error() -> None
:canonical: simvx.core.csg.CSGShape3D.reset_error

````

````{py:method} add_child(node: simvx.core.node.Node) -> simvx.core.node.Node
:canonical: simvx.core.csg.CSGShape3D.add_child

````

````{py:method} remove_child(node: simvx.core.node.Node)
:canonical: simvx.core.csg.CSGShape3D.remove_child

````

````{py:method} reparent(new_parent: simvx.core.node.Node)
:canonical: simvx.core.csg.CSGShape3D.reparent

````

````{py:method} get_node(path: str) -> simvx.core.node.Node
:canonical: simvx.core.csg.CSGShape3D.get_node

````

````{py:method} find_child(name: str, recursive: bool = False) -> simvx.core.node.Node | None
:canonical: simvx.core.csg.CSGShape3D.find_child

````

````{py:method} find(node_type: type, recursive: bool = True) -> simvx.core.node.Node | None
:canonical: simvx.core.csg.CSGShape3D.find

````

````{py:method} find_all(node_type: type, recursive: bool = True) -> list
:canonical: simvx.core.csg.CSGShape3D.find_all

````

````{py:property} path
:canonical: simvx.core.csg.CSGShape3D.path
:type: str

````

````{py:method} add_to_group(group: str)
:canonical: simvx.core.csg.CSGShape3D.add_to_group

````

````{py:method} remove_from_group(group: str)
:canonical: simvx.core.csg.CSGShape3D.remove_from_group

````

````{py:method} is_in_group(group: str) -> bool
:canonical: simvx.core.csg.CSGShape3D.is_in_group

````

````{py:method} ready() -> None
:canonical: simvx.core.csg.CSGShape3D.ready

````

````{py:method} enter_tree() -> None
:canonical: simvx.core.csg.CSGShape3D.enter_tree

````

````{py:method} exit_tree() -> None
:canonical: simvx.core.csg.CSGShape3D.exit_tree

````

````{py:method} process(dt: float) -> None
:canonical: simvx.core.csg.CSGShape3D.process

````

````{py:method} physics_process(dt: float) -> None
:canonical: simvx.core.csg.CSGShape3D.physics_process

````

````{py:method} draw(renderer) -> None
:canonical: simvx.core.csg.CSGShape3D.draw

````

````{py:method} input_event(event: simvx.core.events.InputEvent) -> None
:canonical: simvx.core.csg.CSGShape3D.input_event

````

````{py:method} input(event: simvx.core.events.TreeInputEvent) -> None
:canonical: simvx.core.csg.CSGShape3D.input

````

````{py:method} unhandled_input(event: simvx.core.events.TreeInputEvent) -> None
:canonical: simvx.core.csg.CSGShape3D.unhandled_input

````

````{py:method} start_coroutine(gen: simvx.core.descriptors.Coroutine) -> simvx.core.descriptors.CoroutineHandle
:canonical: simvx.core.csg.CSGShape3D.start_coroutine

````

````{py:method} stop_coroutine(gen_or_handle)
:canonical: simvx.core.csg.CSGShape3D.stop_coroutine

````

````{py:method} clear_children()
:canonical: simvx.core.csg.CSGShape3D.clear_children

````

````{py:method} destroy()
:canonical: simvx.core.csg.CSGShape3D.destroy

````

````{py:property} app
:canonical: simvx.core.csg.CSGShape3D.app

````

````{py:property} tree
:canonical: simvx.core.csg.CSGShape3D.tree
:type: simvx.core.scene_tree.SceneTree

````

````{py:method} get_tree() -> simvx.core.scene_tree.SceneTree
:canonical: simvx.core.csg.CSGShape3D.get_tree

````

````{py:method} __getitem__(key: str)
:canonical: simvx.core.csg.CSGShape3D.__getitem__

````

````{py:method} get_properties() -> dict[str, simvx.core.descriptors.Property]
:canonical: simvx.core.csg.CSGShape3D.get_properties
:classmethod:

````

````{py:method} __repr__()
:canonical: simvx.core.csg.CSGShape3D.__repr__

````

`````

`````{py:class} CSGBox3D(size: simvx.core.math.types.Vec3 | collections.abc.Sequence[float] | None = None, **kwargs)
:canonical: simvx.core.csg.CSGBox3D

Bases: {py:obj}`simvx.core.csg.CSGShape3D`

```{autodoc2-docstring} simvx.core.csg.CSGBox3D
```

```{rubric} Initialization
```

```{autodoc2-docstring} simvx.core.csg.CSGBox3D.__init__
```

````{py:attribute} size
:canonical: simvx.core.csg.CSGBox3D.size
:value: >
   'Property(...)'

```{autodoc2-docstring} simvx.core.csg.CSGBox3D.size
```

````

````{py:attribute} operation
:canonical: simvx.core.csg.CSGBox3D.operation
:value: >
   'Property(...)'

````

````{py:method} get_mesh() -> simvx.core.graphics.mesh.Mesh
:canonical: simvx.core.csg.CSGBox3D.get_mesh

````

````{py:attribute} render_layer
:canonical: simvx.core.csg.CSGBox3D.render_layer
:value: >
   'Property(...)'

````

````{py:property} position
:canonical: simvx.core.csg.CSGBox3D.position

````

````{py:property} rotation
:canonical: simvx.core.csg.CSGBox3D.rotation
:type: simvx.core.math.types.Quat

````

````{py:property} scale
:canonical: simvx.core.csg.CSGBox3D.scale

````

````{py:property} rotation_degrees
:canonical: simvx.core.csg.CSGBox3D.rotation_degrees
:type: simvx.core.math.types.Vec3

````

````{py:property} world_position
:canonical: simvx.core.csg.CSGBox3D.world_position
:type: simvx.core.math.types.Vec3

````

````{py:property} world_rotation
:canonical: simvx.core.csg.CSGBox3D.world_rotation
:type: simvx.core.math.types.Quat

````

````{py:property} world_scale
:canonical: simvx.core.csg.CSGBox3D.world_scale
:type: simvx.core.math.types.Vec3

````

````{py:property} forward
:canonical: simvx.core.csg.CSGBox3D.forward
:type: simvx.core.math.types.Vec3

````

````{py:property} right
:canonical: simvx.core.csg.CSGBox3D.right
:type: simvx.core.math.types.Vec3

````

````{py:property} up
:canonical: simvx.core.csg.CSGBox3D.up
:type: simvx.core.math.types.Vec3

````

````{py:method} translate(offset: tuple[float, float, float] | numpy.ndarray)
:canonical: simvx.core.csg.CSGBox3D.translate

````

````{py:method} translate_global(offset: tuple[float, float, float] | numpy.ndarray)
:canonical: simvx.core.csg.CSGBox3D.translate_global

````

````{py:method} rotate(axis: tuple[float, float, float] | numpy.ndarray, angle: float)
:canonical: simvx.core.csg.CSGBox3D.rotate

````

````{py:method} rotate_x(angle: float)
:canonical: simvx.core.csg.CSGBox3D.rotate_x

````

````{py:method} rotate_y(angle: float)
:canonical: simvx.core.csg.CSGBox3D.rotate_y

````

````{py:method} rotate_z(angle: float)
:canonical: simvx.core.csg.CSGBox3D.rotate_z

````

````{py:method} look_at(target: tuple[float, float, float] | numpy.ndarray, up=None)
:canonical: simvx.core.csg.CSGBox3D.look_at

````

````{py:method} set_render_layer(index: int, enabled: bool = True) -> None
:canonical: simvx.core.csg.CSGBox3D.set_render_layer

````

````{py:method} is_on_render_layer(index: int) -> bool
:canonical: simvx.core.csg.CSGBox3D.is_on_render_layer

````

````{py:method} wrap_bounds(bounds: tuple[float, float, float] | numpy.ndarray, margin: float = 1.0)
:canonical: simvx.core.csg.CSGBox3D.wrap_bounds

````

````{py:attribute} strict_errors
:canonical: simvx.core.csg.CSGBox3D.strict_errors
:type: typing.ClassVar[bool]
:value: >
   True

````

````{py:attribute} script_error_raised
:canonical: simvx.core.csg.CSGBox3D.script_error_raised
:value: >
   'Signal(...)'

````

````{py:method} __init_subclass__(**kwargs)
:canonical: simvx.core.csg.CSGBox3D.__init_subclass__
:classmethod:

````

````{py:property} name
:canonical: simvx.core.csg.CSGBox3D.name
:type: str

````

````{py:property} process_mode
:canonical: simvx.core.csg.CSGBox3D.process_mode
:type: simvx.core.descriptors.ProcessMode

````

````{py:method} reset_error() -> None
:canonical: simvx.core.csg.CSGBox3D.reset_error

````

````{py:method} add_child(node: simvx.core.node.Node) -> simvx.core.node.Node
:canonical: simvx.core.csg.CSGBox3D.add_child

````

````{py:method} remove_child(node: simvx.core.node.Node)
:canonical: simvx.core.csg.CSGBox3D.remove_child

````

````{py:method} reparent(new_parent: simvx.core.node.Node)
:canonical: simvx.core.csg.CSGBox3D.reparent

````

````{py:method} get_node(path: str) -> simvx.core.node.Node
:canonical: simvx.core.csg.CSGBox3D.get_node

````

````{py:method} find_child(name: str, recursive: bool = False) -> simvx.core.node.Node | None
:canonical: simvx.core.csg.CSGBox3D.find_child

````

````{py:method} find(node_type: type, recursive: bool = True) -> simvx.core.node.Node | None
:canonical: simvx.core.csg.CSGBox3D.find

````

````{py:method} find_all(node_type: type, recursive: bool = True) -> list
:canonical: simvx.core.csg.CSGBox3D.find_all

````

````{py:property} path
:canonical: simvx.core.csg.CSGBox3D.path
:type: str

````

````{py:method} add_to_group(group: str)
:canonical: simvx.core.csg.CSGBox3D.add_to_group

````

````{py:method} remove_from_group(group: str)
:canonical: simvx.core.csg.CSGBox3D.remove_from_group

````

````{py:method} is_in_group(group: str) -> bool
:canonical: simvx.core.csg.CSGBox3D.is_in_group

````

````{py:method} ready() -> None
:canonical: simvx.core.csg.CSGBox3D.ready

````

````{py:method} enter_tree() -> None
:canonical: simvx.core.csg.CSGBox3D.enter_tree

````

````{py:method} exit_tree() -> None
:canonical: simvx.core.csg.CSGBox3D.exit_tree

````

````{py:method} process(dt: float) -> None
:canonical: simvx.core.csg.CSGBox3D.process

````

````{py:method} physics_process(dt: float) -> None
:canonical: simvx.core.csg.CSGBox3D.physics_process

````

````{py:method} draw(renderer) -> None
:canonical: simvx.core.csg.CSGBox3D.draw

````

````{py:method} input_event(event: simvx.core.events.InputEvent) -> None
:canonical: simvx.core.csg.CSGBox3D.input_event

````

````{py:method} input(event: simvx.core.events.TreeInputEvent) -> None
:canonical: simvx.core.csg.CSGBox3D.input

````

````{py:method} unhandled_input(event: simvx.core.events.TreeInputEvent) -> None
:canonical: simvx.core.csg.CSGBox3D.unhandled_input

````

````{py:method} start_coroutine(gen: simvx.core.descriptors.Coroutine) -> simvx.core.descriptors.CoroutineHandle
:canonical: simvx.core.csg.CSGBox3D.start_coroutine

````

````{py:method} stop_coroutine(gen_or_handle)
:canonical: simvx.core.csg.CSGBox3D.stop_coroutine

````

````{py:method} clear_children()
:canonical: simvx.core.csg.CSGBox3D.clear_children

````

````{py:method} destroy()
:canonical: simvx.core.csg.CSGBox3D.destroy

````

````{py:property} app
:canonical: simvx.core.csg.CSGBox3D.app

````

````{py:property} tree
:canonical: simvx.core.csg.CSGBox3D.tree
:type: simvx.core.scene_tree.SceneTree

````

````{py:method} get_tree() -> simvx.core.scene_tree.SceneTree
:canonical: simvx.core.csg.CSGBox3D.get_tree

````

````{py:method} __getitem__(key: str)
:canonical: simvx.core.csg.CSGBox3D.__getitem__

````

````{py:method} get_properties() -> dict[str, simvx.core.descriptors.Property]
:canonical: simvx.core.csg.CSGBox3D.get_properties
:classmethod:

````

````{py:method} __repr__()
:canonical: simvx.core.csg.CSGBox3D.__repr__

````

`````

`````{py:class} CSGSphere3D(radius: float = 1.0, rings: int = 16, sectors: int = 16, **kwargs)
:canonical: simvx.core.csg.CSGSphere3D

Bases: {py:obj}`simvx.core.csg.CSGShape3D`

```{autodoc2-docstring} simvx.core.csg.CSGSphere3D
```

```{rubric} Initialization
```

```{autodoc2-docstring} simvx.core.csg.CSGSphere3D.__init__
```

````{py:attribute} radius
:canonical: simvx.core.csg.CSGSphere3D.radius
:value: >
   'Property(...)'

```{autodoc2-docstring} simvx.core.csg.CSGSphere3D.radius
```

````

````{py:attribute} rings
:canonical: simvx.core.csg.CSGSphere3D.rings
:value: >
   'Property(...)'

```{autodoc2-docstring} simvx.core.csg.CSGSphere3D.rings
```

````

````{py:attribute} sectors
:canonical: simvx.core.csg.CSGSphere3D.sectors
:value: >
   'Property(...)'

```{autodoc2-docstring} simvx.core.csg.CSGSphere3D.sectors
```

````

````{py:attribute} operation
:canonical: simvx.core.csg.CSGSphere3D.operation
:value: >
   'Property(...)'

````

````{py:method} get_mesh() -> simvx.core.graphics.mesh.Mesh
:canonical: simvx.core.csg.CSGSphere3D.get_mesh

````

````{py:attribute} render_layer
:canonical: simvx.core.csg.CSGSphere3D.render_layer
:value: >
   'Property(...)'

````

````{py:property} position
:canonical: simvx.core.csg.CSGSphere3D.position

````

````{py:property} rotation
:canonical: simvx.core.csg.CSGSphere3D.rotation
:type: simvx.core.math.types.Quat

````

````{py:property} scale
:canonical: simvx.core.csg.CSGSphere3D.scale

````

````{py:property} rotation_degrees
:canonical: simvx.core.csg.CSGSphere3D.rotation_degrees
:type: simvx.core.math.types.Vec3

````

````{py:property} world_position
:canonical: simvx.core.csg.CSGSphere3D.world_position
:type: simvx.core.math.types.Vec3

````

````{py:property} world_rotation
:canonical: simvx.core.csg.CSGSphere3D.world_rotation
:type: simvx.core.math.types.Quat

````

````{py:property} world_scale
:canonical: simvx.core.csg.CSGSphere3D.world_scale
:type: simvx.core.math.types.Vec3

````

````{py:property} forward
:canonical: simvx.core.csg.CSGSphere3D.forward
:type: simvx.core.math.types.Vec3

````

````{py:property} right
:canonical: simvx.core.csg.CSGSphere3D.right
:type: simvx.core.math.types.Vec3

````

````{py:property} up
:canonical: simvx.core.csg.CSGSphere3D.up
:type: simvx.core.math.types.Vec3

````

````{py:method} translate(offset: tuple[float, float, float] | numpy.ndarray)
:canonical: simvx.core.csg.CSGSphere3D.translate

````

````{py:method} translate_global(offset: tuple[float, float, float] | numpy.ndarray)
:canonical: simvx.core.csg.CSGSphere3D.translate_global

````

````{py:method} rotate(axis: tuple[float, float, float] | numpy.ndarray, angle: float)
:canonical: simvx.core.csg.CSGSphere3D.rotate

````

````{py:method} rotate_x(angle: float)
:canonical: simvx.core.csg.CSGSphere3D.rotate_x

````

````{py:method} rotate_y(angle: float)
:canonical: simvx.core.csg.CSGSphere3D.rotate_y

````

````{py:method} rotate_z(angle: float)
:canonical: simvx.core.csg.CSGSphere3D.rotate_z

````

````{py:method} look_at(target: tuple[float, float, float] | numpy.ndarray, up=None)
:canonical: simvx.core.csg.CSGSphere3D.look_at

````

````{py:method} set_render_layer(index: int, enabled: bool = True) -> None
:canonical: simvx.core.csg.CSGSphere3D.set_render_layer

````

````{py:method} is_on_render_layer(index: int) -> bool
:canonical: simvx.core.csg.CSGSphere3D.is_on_render_layer

````

````{py:method} wrap_bounds(bounds: tuple[float, float, float] | numpy.ndarray, margin: float = 1.0)
:canonical: simvx.core.csg.CSGSphere3D.wrap_bounds

````

````{py:attribute} strict_errors
:canonical: simvx.core.csg.CSGSphere3D.strict_errors
:type: typing.ClassVar[bool]
:value: >
   True

````

````{py:attribute} script_error_raised
:canonical: simvx.core.csg.CSGSphere3D.script_error_raised
:value: >
   'Signal(...)'

````

````{py:method} __init_subclass__(**kwargs)
:canonical: simvx.core.csg.CSGSphere3D.__init_subclass__
:classmethod:

````

````{py:property} name
:canonical: simvx.core.csg.CSGSphere3D.name
:type: str

````

````{py:property} process_mode
:canonical: simvx.core.csg.CSGSphere3D.process_mode
:type: simvx.core.descriptors.ProcessMode

````

````{py:method} reset_error() -> None
:canonical: simvx.core.csg.CSGSphere3D.reset_error

````

````{py:method} add_child(node: simvx.core.node.Node) -> simvx.core.node.Node
:canonical: simvx.core.csg.CSGSphere3D.add_child

````

````{py:method} remove_child(node: simvx.core.node.Node)
:canonical: simvx.core.csg.CSGSphere3D.remove_child

````

````{py:method} reparent(new_parent: simvx.core.node.Node)
:canonical: simvx.core.csg.CSGSphere3D.reparent

````

````{py:method} get_node(path: str) -> simvx.core.node.Node
:canonical: simvx.core.csg.CSGSphere3D.get_node

````

````{py:method} find_child(name: str, recursive: bool = False) -> simvx.core.node.Node | None
:canonical: simvx.core.csg.CSGSphere3D.find_child

````

````{py:method} find(node_type: type, recursive: bool = True) -> simvx.core.node.Node | None
:canonical: simvx.core.csg.CSGSphere3D.find

````

````{py:method} find_all(node_type: type, recursive: bool = True) -> list
:canonical: simvx.core.csg.CSGSphere3D.find_all

````

````{py:property} path
:canonical: simvx.core.csg.CSGSphere3D.path
:type: str

````

````{py:method} add_to_group(group: str)
:canonical: simvx.core.csg.CSGSphere3D.add_to_group

````

````{py:method} remove_from_group(group: str)
:canonical: simvx.core.csg.CSGSphere3D.remove_from_group

````

````{py:method} is_in_group(group: str) -> bool
:canonical: simvx.core.csg.CSGSphere3D.is_in_group

````

````{py:method} ready() -> None
:canonical: simvx.core.csg.CSGSphere3D.ready

````

````{py:method} enter_tree() -> None
:canonical: simvx.core.csg.CSGSphere3D.enter_tree

````

````{py:method} exit_tree() -> None
:canonical: simvx.core.csg.CSGSphere3D.exit_tree

````

````{py:method} process(dt: float) -> None
:canonical: simvx.core.csg.CSGSphere3D.process

````

````{py:method} physics_process(dt: float) -> None
:canonical: simvx.core.csg.CSGSphere3D.physics_process

````

````{py:method} draw(renderer) -> None
:canonical: simvx.core.csg.CSGSphere3D.draw

````

````{py:method} input_event(event: simvx.core.events.InputEvent) -> None
:canonical: simvx.core.csg.CSGSphere3D.input_event

````

````{py:method} input(event: simvx.core.events.TreeInputEvent) -> None
:canonical: simvx.core.csg.CSGSphere3D.input

````

````{py:method} unhandled_input(event: simvx.core.events.TreeInputEvent) -> None
:canonical: simvx.core.csg.CSGSphere3D.unhandled_input

````

````{py:method} start_coroutine(gen: simvx.core.descriptors.Coroutine) -> simvx.core.descriptors.CoroutineHandle
:canonical: simvx.core.csg.CSGSphere3D.start_coroutine

````

````{py:method} stop_coroutine(gen_or_handle)
:canonical: simvx.core.csg.CSGSphere3D.stop_coroutine

````

````{py:method} clear_children()
:canonical: simvx.core.csg.CSGSphere3D.clear_children

````

````{py:method} destroy()
:canonical: simvx.core.csg.CSGSphere3D.destroy

````

````{py:property} app
:canonical: simvx.core.csg.CSGSphere3D.app

````

````{py:property} tree
:canonical: simvx.core.csg.CSGSphere3D.tree
:type: simvx.core.scene_tree.SceneTree

````

````{py:method} get_tree() -> simvx.core.scene_tree.SceneTree
:canonical: simvx.core.csg.CSGSphere3D.get_tree

````

````{py:method} __getitem__(key: str)
:canonical: simvx.core.csg.CSGSphere3D.__getitem__

````

````{py:method} get_properties() -> dict[str, simvx.core.descriptors.Property]
:canonical: simvx.core.csg.CSGSphere3D.get_properties
:classmethod:

````

````{py:method} __repr__()
:canonical: simvx.core.csg.CSGSphere3D.__repr__

````

`````

`````{py:class} CSGCylinder3D(radius: float = 0.5, height: float = 1.0, segments: int = 16, **kwargs)
:canonical: simvx.core.csg.CSGCylinder3D

Bases: {py:obj}`simvx.core.csg.CSGShape3D`

```{autodoc2-docstring} simvx.core.csg.CSGCylinder3D
```

```{rubric} Initialization
```

```{autodoc2-docstring} simvx.core.csg.CSGCylinder3D.__init__
```

````{py:attribute} radius
:canonical: simvx.core.csg.CSGCylinder3D.radius
:value: >
   'Property(...)'

```{autodoc2-docstring} simvx.core.csg.CSGCylinder3D.radius
```

````

````{py:attribute} height
:canonical: simvx.core.csg.CSGCylinder3D.height
:value: >
   'Property(...)'

```{autodoc2-docstring} simvx.core.csg.CSGCylinder3D.height
```

````

````{py:attribute} segments
:canonical: simvx.core.csg.CSGCylinder3D.segments
:value: >
   'Property(...)'

```{autodoc2-docstring} simvx.core.csg.CSGCylinder3D.segments
```

````

````{py:attribute} operation
:canonical: simvx.core.csg.CSGCylinder3D.operation
:value: >
   'Property(...)'

````

````{py:method} get_mesh() -> simvx.core.graphics.mesh.Mesh
:canonical: simvx.core.csg.CSGCylinder3D.get_mesh

````

````{py:attribute} render_layer
:canonical: simvx.core.csg.CSGCylinder3D.render_layer
:value: >
   'Property(...)'

````

````{py:property} position
:canonical: simvx.core.csg.CSGCylinder3D.position

````

````{py:property} rotation
:canonical: simvx.core.csg.CSGCylinder3D.rotation
:type: simvx.core.math.types.Quat

````

````{py:property} scale
:canonical: simvx.core.csg.CSGCylinder3D.scale

````

````{py:property} rotation_degrees
:canonical: simvx.core.csg.CSGCylinder3D.rotation_degrees
:type: simvx.core.math.types.Vec3

````

````{py:property} world_position
:canonical: simvx.core.csg.CSGCylinder3D.world_position
:type: simvx.core.math.types.Vec3

````

````{py:property} world_rotation
:canonical: simvx.core.csg.CSGCylinder3D.world_rotation
:type: simvx.core.math.types.Quat

````

````{py:property} world_scale
:canonical: simvx.core.csg.CSGCylinder3D.world_scale
:type: simvx.core.math.types.Vec3

````

````{py:property} forward
:canonical: simvx.core.csg.CSGCylinder3D.forward
:type: simvx.core.math.types.Vec3

````

````{py:property} right
:canonical: simvx.core.csg.CSGCylinder3D.right
:type: simvx.core.math.types.Vec3

````

````{py:property} up
:canonical: simvx.core.csg.CSGCylinder3D.up
:type: simvx.core.math.types.Vec3

````

````{py:method} translate(offset: tuple[float, float, float] | numpy.ndarray)
:canonical: simvx.core.csg.CSGCylinder3D.translate

````

````{py:method} translate_global(offset: tuple[float, float, float] | numpy.ndarray)
:canonical: simvx.core.csg.CSGCylinder3D.translate_global

````

````{py:method} rotate(axis: tuple[float, float, float] | numpy.ndarray, angle: float)
:canonical: simvx.core.csg.CSGCylinder3D.rotate

````

````{py:method} rotate_x(angle: float)
:canonical: simvx.core.csg.CSGCylinder3D.rotate_x

````

````{py:method} rotate_y(angle: float)
:canonical: simvx.core.csg.CSGCylinder3D.rotate_y

````

````{py:method} rotate_z(angle: float)
:canonical: simvx.core.csg.CSGCylinder3D.rotate_z

````

````{py:method} look_at(target: tuple[float, float, float] | numpy.ndarray, up=None)
:canonical: simvx.core.csg.CSGCylinder3D.look_at

````

````{py:method} set_render_layer(index: int, enabled: bool = True) -> None
:canonical: simvx.core.csg.CSGCylinder3D.set_render_layer

````

````{py:method} is_on_render_layer(index: int) -> bool
:canonical: simvx.core.csg.CSGCylinder3D.is_on_render_layer

````

````{py:method} wrap_bounds(bounds: tuple[float, float, float] | numpy.ndarray, margin: float = 1.0)
:canonical: simvx.core.csg.CSGCylinder3D.wrap_bounds

````

````{py:attribute} strict_errors
:canonical: simvx.core.csg.CSGCylinder3D.strict_errors
:type: typing.ClassVar[bool]
:value: >
   True

````

````{py:attribute} script_error_raised
:canonical: simvx.core.csg.CSGCylinder3D.script_error_raised
:value: >
   'Signal(...)'

````

````{py:method} __init_subclass__(**kwargs)
:canonical: simvx.core.csg.CSGCylinder3D.__init_subclass__
:classmethod:

````

````{py:property} name
:canonical: simvx.core.csg.CSGCylinder3D.name
:type: str

````

````{py:property} process_mode
:canonical: simvx.core.csg.CSGCylinder3D.process_mode
:type: simvx.core.descriptors.ProcessMode

````

````{py:method} reset_error() -> None
:canonical: simvx.core.csg.CSGCylinder3D.reset_error

````

````{py:method} add_child(node: simvx.core.node.Node) -> simvx.core.node.Node
:canonical: simvx.core.csg.CSGCylinder3D.add_child

````

````{py:method} remove_child(node: simvx.core.node.Node)
:canonical: simvx.core.csg.CSGCylinder3D.remove_child

````

````{py:method} reparent(new_parent: simvx.core.node.Node)
:canonical: simvx.core.csg.CSGCylinder3D.reparent

````

````{py:method} get_node(path: str) -> simvx.core.node.Node
:canonical: simvx.core.csg.CSGCylinder3D.get_node

````

````{py:method} find_child(name: str, recursive: bool = False) -> simvx.core.node.Node | None
:canonical: simvx.core.csg.CSGCylinder3D.find_child

````

````{py:method} find(node_type: type, recursive: bool = True) -> simvx.core.node.Node | None
:canonical: simvx.core.csg.CSGCylinder3D.find

````

````{py:method} find_all(node_type: type, recursive: bool = True) -> list
:canonical: simvx.core.csg.CSGCylinder3D.find_all

````

````{py:property} path
:canonical: simvx.core.csg.CSGCylinder3D.path
:type: str

````

````{py:method} add_to_group(group: str)
:canonical: simvx.core.csg.CSGCylinder3D.add_to_group

````

````{py:method} remove_from_group(group: str)
:canonical: simvx.core.csg.CSGCylinder3D.remove_from_group

````

````{py:method} is_in_group(group: str) -> bool
:canonical: simvx.core.csg.CSGCylinder3D.is_in_group

````

````{py:method} ready() -> None
:canonical: simvx.core.csg.CSGCylinder3D.ready

````

````{py:method} enter_tree() -> None
:canonical: simvx.core.csg.CSGCylinder3D.enter_tree

````

````{py:method} exit_tree() -> None
:canonical: simvx.core.csg.CSGCylinder3D.exit_tree

````

````{py:method} process(dt: float) -> None
:canonical: simvx.core.csg.CSGCylinder3D.process

````

````{py:method} physics_process(dt: float) -> None
:canonical: simvx.core.csg.CSGCylinder3D.physics_process

````

````{py:method} draw(renderer) -> None
:canonical: simvx.core.csg.CSGCylinder3D.draw

````

````{py:method} input_event(event: simvx.core.events.InputEvent) -> None
:canonical: simvx.core.csg.CSGCylinder3D.input_event

````

````{py:method} input(event: simvx.core.events.TreeInputEvent) -> None
:canonical: simvx.core.csg.CSGCylinder3D.input

````

````{py:method} unhandled_input(event: simvx.core.events.TreeInputEvent) -> None
:canonical: simvx.core.csg.CSGCylinder3D.unhandled_input

````

````{py:method} start_coroutine(gen: simvx.core.descriptors.Coroutine) -> simvx.core.descriptors.CoroutineHandle
:canonical: simvx.core.csg.CSGCylinder3D.start_coroutine

````

````{py:method} stop_coroutine(gen_or_handle)
:canonical: simvx.core.csg.CSGCylinder3D.stop_coroutine

````

````{py:method} clear_children()
:canonical: simvx.core.csg.CSGCylinder3D.clear_children

````

````{py:method} destroy()
:canonical: simvx.core.csg.CSGCylinder3D.destroy

````

````{py:property} app
:canonical: simvx.core.csg.CSGCylinder3D.app

````

````{py:property} tree
:canonical: simvx.core.csg.CSGCylinder3D.tree
:type: simvx.core.scene_tree.SceneTree

````

````{py:method} get_tree() -> simvx.core.scene_tree.SceneTree
:canonical: simvx.core.csg.CSGCylinder3D.get_tree

````

````{py:method} __getitem__(key: str)
:canonical: simvx.core.csg.CSGCylinder3D.__getitem__

````

````{py:method} get_properties() -> dict[str, simvx.core.descriptors.Property]
:canonical: simvx.core.csg.CSGCylinder3D.get_properties
:classmethod:

````

````{py:method} __repr__()
:canonical: simvx.core.csg.CSGCylinder3D.__repr__

````

`````

`````{py:class} CSGCombiner3D(**kwargs)
:canonical: simvx.core.csg.CSGCombiner3D

Bases: {py:obj}`simvx.core.csg.CSGShape3D`

```{autodoc2-docstring} simvx.core.csg.CSGCombiner3D
```

```{rubric} Initialization
```

```{autodoc2-docstring} simvx.core.csg.CSGCombiner3D.__init__
```

````{py:method} get_mesh() -> simvx.core.graphics.mesh.Mesh
:canonical: simvx.core.csg.CSGCombiner3D.get_mesh

```{autodoc2-docstring} simvx.core.csg.CSGCombiner3D.get_mesh
```

````

````{py:attribute} operation
:canonical: simvx.core.csg.CSGCombiner3D.operation
:value: >
   'Property(...)'

````

````{py:attribute} render_layer
:canonical: simvx.core.csg.CSGCombiner3D.render_layer
:value: >
   'Property(...)'

````

````{py:property} position
:canonical: simvx.core.csg.CSGCombiner3D.position

````

````{py:property} rotation
:canonical: simvx.core.csg.CSGCombiner3D.rotation
:type: simvx.core.math.types.Quat

````

````{py:property} scale
:canonical: simvx.core.csg.CSGCombiner3D.scale

````

````{py:property} rotation_degrees
:canonical: simvx.core.csg.CSGCombiner3D.rotation_degrees
:type: simvx.core.math.types.Vec3

````

````{py:property} world_position
:canonical: simvx.core.csg.CSGCombiner3D.world_position
:type: simvx.core.math.types.Vec3

````

````{py:property} world_rotation
:canonical: simvx.core.csg.CSGCombiner3D.world_rotation
:type: simvx.core.math.types.Quat

````

````{py:property} world_scale
:canonical: simvx.core.csg.CSGCombiner3D.world_scale
:type: simvx.core.math.types.Vec3

````

````{py:property} forward
:canonical: simvx.core.csg.CSGCombiner3D.forward
:type: simvx.core.math.types.Vec3

````

````{py:property} right
:canonical: simvx.core.csg.CSGCombiner3D.right
:type: simvx.core.math.types.Vec3

````

````{py:property} up
:canonical: simvx.core.csg.CSGCombiner3D.up
:type: simvx.core.math.types.Vec3

````

````{py:method} translate(offset: tuple[float, float, float] | numpy.ndarray)
:canonical: simvx.core.csg.CSGCombiner3D.translate

````

````{py:method} translate_global(offset: tuple[float, float, float] | numpy.ndarray)
:canonical: simvx.core.csg.CSGCombiner3D.translate_global

````

````{py:method} rotate(axis: tuple[float, float, float] | numpy.ndarray, angle: float)
:canonical: simvx.core.csg.CSGCombiner3D.rotate

````

````{py:method} rotate_x(angle: float)
:canonical: simvx.core.csg.CSGCombiner3D.rotate_x

````

````{py:method} rotate_y(angle: float)
:canonical: simvx.core.csg.CSGCombiner3D.rotate_y

````

````{py:method} rotate_z(angle: float)
:canonical: simvx.core.csg.CSGCombiner3D.rotate_z

````

````{py:method} look_at(target: tuple[float, float, float] | numpy.ndarray, up=None)
:canonical: simvx.core.csg.CSGCombiner3D.look_at

````

````{py:method} set_render_layer(index: int, enabled: bool = True) -> None
:canonical: simvx.core.csg.CSGCombiner3D.set_render_layer

````

````{py:method} is_on_render_layer(index: int) -> bool
:canonical: simvx.core.csg.CSGCombiner3D.is_on_render_layer

````

````{py:method} wrap_bounds(bounds: tuple[float, float, float] | numpy.ndarray, margin: float = 1.0)
:canonical: simvx.core.csg.CSGCombiner3D.wrap_bounds

````

````{py:attribute} strict_errors
:canonical: simvx.core.csg.CSGCombiner3D.strict_errors
:type: typing.ClassVar[bool]
:value: >
   True

````

````{py:attribute} script_error_raised
:canonical: simvx.core.csg.CSGCombiner3D.script_error_raised
:value: >
   'Signal(...)'

````

````{py:method} __init_subclass__(**kwargs)
:canonical: simvx.core.csg.CSGCombiner3D.__init_subclass__
:classmethod:

````

````{py:property} name
:canonical: simvx.core.csg.CSGCombiner3D.name
:type: str

````

````{py:property} process_mode
:canonical: simvx.core.csg.CSGCombiner3D.process_mode
:type: simvx.core.descriptors.ProcessMode

````

````{py:method} reset_error() -> None
:canonical: simvx.core.csg.CSGCombiner3D.reset_error

````

````{py:method} add_child(node: simvx.core.node.Node) -> simvx.core.node.Node
:canonical: simvx.core.csg.CSGCombiner3D.add_child

````

````{py:method} remove_child(node: simvx.core.node.Node)
:canonical: simvx.core.csg.CSGCombiner3D.remove_child

````

````{py:method} reparent(new_parent: simvx.core.node.Node)
:canonical: simvx.core.csg.CSGCombiner3D.reparent

````

````{py:method} get_node(path: str) -> simvx.core.node.Node
:canonical: simvx.core.csg.CSGCombiner3D.get_node

````

````{py:method} find_child(name: str, recursive: bool = False) -> simvx.core.node.Node | None
:canonical: simvx.core.csg.CSGCombiner3D.find_child

````

````{py:method} find(node_type: type, recursive: bool = True) -> simvx.core.node.Node | None
:canonical: simvx.core.csg.CSGCombiner3D.find

````

````{py:method} find_all(node_type: type, recursive: bool = True) -> list
:canonical: simvx.core.csg.CSGCombiner3D.find_all

````

````{py:property} path
:canonical: simvx.core.csg.CSGCombiner3D.path
:type: str

````

````{py:method} add_to_group(group: str)
:canonical: simvx.core.csg.CSGCombiner3D.add_to_group

````

````{py:method} remove_from_group(group: str)
:canonical: simvx.core.csg.CSGCombiner3D.remove_from_group

````

````{py:method} is_in_group(group: str) -> bool
:canonical: simvx.core.csg.CSGCombiner3D.is_in_group

````

````{py:method} ready() -> None
:canonical: simvx.core.csg.CSGCombiner3D.ready

````

````{py:method} enter_tree() -> None
:canonical: simvx.core.csg.CSGCombiner3D.enter_tree

````

````{py:method} exit_tree() -> None
:canonical: simvx.core.csg.CSGCombiner3D.exit_tree

````

````{py:method} process(dt: float) -> None
:canonical: simvx.core.csg.CSGCombiner3D.process

````

````{py:method} physics_process(dt: float) -> None
:canonical: simvx.core.csg.CSGCombiner3D.physics_process

````

````{py:method} draw(renderer) -> None
:canonical: simvx.core.csg.CSGCombiner3D.draw

````

````{py:method} input_event(event: simvx.core.events.InputEvent) -> None
:canonical: simvx.core.csg.CSGCombiner3D.input_event

````

````{py:method} input(event: simvx.core.events.TreeInputEvent) -> None
:canonical: simvx.core.csg.CSGCombiner3D.input

````

````{py:method} unhandled_input(event: simvx.core.events.TreeInputEvent) -> None
:canonical: simvx.core.csg.CSGCombiner3D.unhandled_input

````

````{py:method} start_coroutine(gen: simvx.core.descriptors.Coroutine) -> simvx.core.descriptors.CoroutineHandle
:canonical: simvx.core.csg.CSGCombiner3D.start_coroutine

````

````{py:method} stop_coroutine(gen_or_handle)
:canonical: simvx.core.csg.CSGCombiner3D.stop_coroutine

````

````{py:method} clear_children()
:canonical: simvx.core.csg.CSGCombiner3D.clear_children

````

````{py:method} destroy()
:canonical: simvx.core.csg.CSGCombiner3D.destroy

````

````{py:property} app
:canonical: simvx.core.csg.CSGCombiner3D.app

````

````{py:property} tree
:canonical: simvx.core.csg.CSGCombiner3D.tree
:type: simvx.core.scene_tree.SceneTree

````

````{py:method} get_tree() -> simvx.core.scene_tree.SceneTree
:canonical: simvx.core.csg.CSGCombiner3D.get_tree

````

````{py:method} __getitem__(key: str)
:canonical: simvx.core.csg.CSGCombiner3D.__getitem__

````

````{py:method} get_properties() -> dict[str, simvx.core.descriptors.Property]
:canonical: simvx.core.csg.CSGCombiner3D.get_properties
:classmethod:

````

````{py:method} __repr__()
:canonical: simvx.core.csg.CSGCombiner3D.__repr__

````

`````