# Auto-generated by `python -m gen` — do not edit manually.

from typing import TYPE_CHECKING, Literal

import bpy

from ...builder import BaseNode, SocketAccessor

from ...types import (
    InputColor,
    InputFloat,
    InputVector,
)

from ...builder.socket import (
    ColorSocket,
    FloatSocket,
    VectorSocket,
)


class AmbientOcclusion(BaseNode):
    """
        Compute how much the hemisphere above the shading point is occluded, for example to add weathering effects to corners.
    Note: For Cycles, this may slow down renders significantly

        Parameters
        ----------
        color : InputColor
            Color
        distance : InputFloat
            Distance
        normal : InputVector
            Normal

        Inputs
        ------
        i.color : ColorSocket
            Color
        i.distance : FloatSocket
            Distance
        i.normal : VectorSocket
            Normal

        Outputs
        -------
        o.color : ColorSocket
            Color
        o.ao : FloatSocket
            AO
    """

    _bl_idname = "ShaderNodeAmbientOcclusion"
    node: bpy.types.ShaderNodeAmbientOcclusion

    class _Inputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        distance: FloatSocket
        """Distance"""
        normal: VectorSocket
        """Normal"""

    class _Outputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        ao: FloatSocket
        """AO"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        color: InputColor = None,
        distance: InputFloat = 1.0,
        normal: InputVector = None,
        *,
        samples: int = 0,
        inside: bool = False,
        only_local: bool = False,
    ):
        super().__init__()
        key_args = {"Color": color, "Distance": distance, "Normal": normal}
        self.samples = samples
        self.inside = inside
        self.only_local = only_local
        self._establish_links(**key_args)

    @property
    def samples(self) -> int:
        return self.node.samples

    @samples.setter
    def samples(self, value: int):
        self.node.samples = value

    @property
    def inside(self) -> bool:
        return self.node.inside

    @inside.setter
    def inside(self, value: bool):
        self.node.inside = value

    @property
    def only_local(self) -> bool:
        return self.node.only_local

    @only_local.setter
    def only_local(self, value: bool):
        self.node.only_local = value


class Bevel(BaseNode):
    """
        Generates normals with round corners.
    Note: only supported in Cycles, and may slow down renders

        Parameters
        ----------
        radius : InputFloat
            Radius
        normal : InputVector
            Normal

        Inputs
        ------
        i.radius : FloatSocket
            Radius
        i.normal : VectorSocket
            Normal

        Outputs
        -------
        o.normal : VectorSocket
            Normal
    """

    _bl_idname = "ShaderNodeBevel"
    node: bpy.types.ShaderNodeBevel

    class _Inputs(SocketAccessor):
        radius: FloatSocket
        """Radius"""
        normal: VectorSocket
        """Normal"""

    class _Outputs(SocketAccessor):
        normal: VectorSocket
        """Normal"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        radius: InputFloat = 0.05,
        normal: InputVector = None,
        *,
        samples: int = 0,
    ):
        super().__init__()
        key_args = {"Radius": radius, "Normal": normal}
        self.samples = samples
        self._establish_links(**key_args)

    @property
    def samples(self) -> int:
        return self.node.samples

    @samples.setter
    def samples(self, value: int):
        self.node.samples = value


class CameraData(BaseNode):
    """
    Retrieve information about the camera and how it relates to the current shading point's position

    Outputs
    -------
    o.view_vector : VectorSocket
        View Vector
    o.view_z_depth : FloatSocket
        View Z Depth
    o.view_distance : FloatSocket
        View Distance
    """

    _bl_idname = "ShaderNodeCameraData"
    node: bpy.types.ShaderNodeCameraData

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        view_vector: VectorSocket
        """View Vector"""
        view_z_depth: FloatSocket
        """View Z Depth"""
        view_distance: FloatSocket
        """View Distance"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class Color(BaseNode):
    """
    A color picker

    Outputs
    -------
    o.color : ColorSocket
        Color
    """

    _bl_idname = "ShaderNodeRGB"
    node: bpy.types.ShaderNodeRGB

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        color: ColorSocket
        """Color"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class ColorAttribute(BaseNode):
    """
    Retrieve a color attribute, or the default fallback if none is specified

    Outputs
    -------
    o.color : ColorSocket
        Color
    o.alpha : FloatSocket
        Alpha
    """

    _bl_idname = "ShaderNodeVertexColor"
    node: bpy.types.ShaderNodeVertexColor

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        alpha: FloatSocket
        """Alpha"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(self, layer_name: str = ""):
        super().__init__()
        key_args = {}
        self.layer_name = layer_name
        self._establish_links(**key_args)

    @property
    def layer_name(self) -> str:
        return self.node.layer_name

    @layer_name.setter
    def layer_name(self, value: str):
        self.node.layer_name = value


class CurvesInfo(BaseNode):
    """
    Retrieve hair curve information

    Outputs
    -------
    o.is_strand : FloatSocket
        Is Strand
    o.intercept : FloatSocket
        Intercept
    o.length : FloatSocket
        Length
    o.thickness : FloatSocket
        Thickness
    o.tangent_normal : VectorSocket
        Tangent Normal
    o.random : FloatSocket
        Random
    """

    _bl_idname = "ShaderNodeHairInfo"
    node: bpy.types.ShaderNodeHairInfo

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        is_strand: FloatSocket
        """Is Strand"""
        intercept: FloatSocket
        """Intercept"""
        length: FloatSocket
        """Length"""
        thickness: FloatSocket
        """Thickness"""
        tangent_normal: VectorSocket
        """Tangent Normal"""
        random: FloatSocket
        """Random"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class Fresnel(BaseNode):
    """
        Produce a blending factor depending on the angle between the surface normal and the view direction using Fresnel equations.
    Typically used for mixing reflections at grazing angles

        Parameters
        ----------
        ior : InputFloat
            IOR
        normal : InputVector
            Normal

        Inputs
        ------
        i.ior : FloatSocket
            IOR
        i.normal : VectorSocket
            Normal

        Outputs
        -------
        o.fac : FloatSocket
            Factor
    """

    _bl_idname = "ShaderNodeFresnel"
    node: bpy.types.ShaderNodeFresnel

    class _Inputs(SocketAccessor):
        ior: FloatSocket
        """IOR"""
        normal: VectorSocket
        """Normal"""

    class _Outputs(SocketAccessor):
        fac: FloatSocket
        """Factor"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        ior: InputFloat = 1.5,
        normal: InputVector = None,
    ):
        super().__init__()
        key_args = {"IOR": ior, "Normal": normal}

        self._establish_links(**key_args)


class Geometry(BaseNode):
    """
    Retrieve geometric information about the current shading point

    Outputs
    -------
    o.position : VectorSocket
        Position
    o.normal : VectorSocket
        Normal
    o.tangent : VectorSocket
        Tangent
    o.true_normal : VectorSocket
        True Normal
    o.incoming : VectorSocket
        Incoming
    o.parametric : VectorSocket
        Parametric
    o.backfacing : FloatSocket
        Backfacing
    o.pointiness : FloatSocket
        Pointiness
    o.random_per_island : FloatSocket
        Random Per Island
    """

    _bl_idname = "ShaderNodeNewGeometry"
    node: bpy.types.ShaderNodeNewGeometry

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        position: VectorSocket
        """Position"""
        normal: VectorSocket
        """Normal"""
        tangent: VectorSocket
        """Tangent"""
        true_normal: VectorSocket
        """True Normal"""
        incoming: VectorSocket
        """Incoming"""
        parametric: VectorSocket
        """Parametric"""
        backfacing: FloatSocket
        """Backfacing"""
        pointiness: FloatSocket
        """Pointiness"""
        random_per_island: FloatSocket
        """Random Per Island"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class LayerWeight(BaseNode):
    """
        Produce a blending factor depending on the angle between the surface normal and the view direction.
    Typically used for layering shaders with the Mix Shader node

        Parameters
        ----------
        blend : InputFloat
            Blend
        normal : InputVector
            Normal

        Inputs
        ------
        i.blend : FloatSocket
            Blend
        i.normal : VectorSocket
            Normal

        Outputs
        -------
        o.fresnel : FloatSocket
            Fresnel
        o.facing : FloatSocket
            Facing
    """

    _bl_idname = "ShaderNodeLayerWeight"
    node: bpy.types.ShaderNodeLayerWeight

    class _Inputs(SocketAccessor):
        blend: FloatSocket
        """Blend"""
        normal: VectorSocket
        """Normal"""

    class _Outputs(SocketAccessor):
        fresnel: FloatSocket
        """Fresnel"""
        facing: FloatSocket
        """Facing"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        blend: InputFloat = 0.5,
        normal: InputVector = None,
    ):
        super().__init__()
        key_args = {"Blend": blend, "Normal": normal}

        self._establish_links(**key_args)


class LightPath(BaseNode):
    """
        Retrieve the type of incoming ray for which the shader is being executed.
    Typically used for non-physically-based tricks

        Outputs
        -------
        o.is_camera_ray : FloatSocket
            Is Camera Ray
        o.is_shadow_ray : FloatSocket
            Is Shadow Ray
        o.is_diffuse_ray : FloatSocket
            Is Diffuse Ray
        o.is_glossy_ray : FloatSocket
            Is Glossy Ray
        o.is_singular_ray : FloatSocket
            Is Singular Ray
        o.is_reflection_ray : FloatSocket
            Is Reflection Ray
        o.is_transmission_ray : FloatSocket
            Is Transmission Ray
        o.is_volume_scatter_ray : FloatSocket
            Is Volume Scatter Ray
        o.ray_length : FloatSocket
            Ray Length
        o.ray_depth : FloatSocket
            Ray Depth
        o.diffuse_depth : FloatSocket
            Diffuse Depth
        o.glossy_depth : FloatSocket
            Glossy Depth
        o.transparent_depth : FloatSocket
            Transparent Depth
        o.transmission_depth : FloatSocket
            Transmission Depth
        o.portal_depth : FloatSocket
            Portal Depth
    """

    _bl_idname = "ShaderNodeLightPath"
    node: bpy.types.ShaderNodeLightPath

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        is_camera_ray: FloatSocket
        """Is Camera Ray"""
        is_shadow_ray: FloatSocket
        """Is Shadow Ray"""
        is_diffuse_ray: FloatSocket
        """Is Diffuse Ray"""
        is_glossy_ray: FloatSocket
        """Is Glossy Ray"""
        is_singular_ray: FloatSocket
        """Is Singular Ray"""
        is_reflection_ray: FloatSocket
        """Is Reflection Ray"""
        is_transmission_ray: FloatSocket
        """Is Transmission Ray"""
        is_volume_scatter_ray: FloatSocket
        """Is Volume Scatter Ray"""
        ray_length: FloatSocket
        """Ray Length"""
        ray_depth: FloatSocket
        """Ray Depth"""
        diffuse_depth: FloatSocket
        """Diffuse Depth"""
        glossy_depth: FloatSocket
        """Glossy Depth"""
        transparent_depth: FloatSocket
        """Transparent Depth"""
        transmission_depth: FloatSocket
        """Transmission Depth"""
        portal_depth: FloatSocket
        """Portal Depth"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class ObjectInfo(BaseNode):
    """
    Retrieve information about the object instance

    Outputs
    -------
    o.location : VectorSocket
        Location
    o.color : ColorSocket
        Color
    o.alpha : FloatSocket
        Alpha
    o.object_index : FloatSocket
        Object Index
    o.material_index : FloatSocket
        Material Index
    o.random : FloatSocket
        Random
    """

    _bl_idname = "ShaderNodeObjectInfo"
    node: bpy.types.ShaderNodeObjectInfo

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        location: VectorSocket
        """Location"""
        color: ColorSocket
        """Color"""
        alpha: FloatSocket
        """Alpha"""
        object_index: FloatSocket
        """Object Index"""
        material_index: FloatSocket
        """Material Index"""
        random: FloatSocket
        """Random"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class ParticleInfo(BaseNode):
    """
    Retrieve the data of the particle that spawned the object instance, for example to give variation to multiple instances of an object

    Outputs
    -------
    o.index : FloatSocket
        Index
    o.random : FloatSocket
        Random
    o.age : FloatSocket
        Age
    o.lifetime : FloatSocket
        Lifetime
    o.location : VectorSocket
        Location
    o.size : FloatSocket
        Size
    o.velocity : VectorSocket
        Velocity
    o.angular_velocity : VectorSocket
        Angular Velocity
    """

    _bl_idname = "ShaderNodeParticleInfo"
    node: bpy.types.ShaderNodeParticleInfo

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        index: FloatSocket
        """Index"""
        random: FloatSocket
        """Random"""
        age: FloatSocket
        """Age"""
        lifetime: FloatSocket
        """Lifetime"""
        location: VectorSocket
        """Location"""
        size: FloatSocket
        """Size"""
        velocity: VectorSocket
        """Velocity"""
        angular_velocity: VectorSocket
        """Angular Velocity"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class PointInfo(BaseNode):
    """
    Retrieve information about points in a point cloud

    Outputs
    -------
    o.position : VectorSocket
        Position
    o.radius : FloatSocket
        Radius
    o.random : FloatSocket
        Random
    """

    _bl_idname = "ShaderNodePointInfo"
    node: bpy.types.ShaderNodePointInfo

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        position: VectorSocket
        """Position"""
        radius: FloatSocket
        """Radius"""
        random: FloatSocket
        """Random"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class Raycast(BaseNode):
    """
    Cast rays and retrieve information from the hit point

    Parameters
    ----------
    position : InputVector
        Position
    direction : InputVector
        Direction
    length : InputFloat
        Length

    Inputs
    ------
    i.position : VectorSocket
        Position
    i.direction : VectorSocket
        Direction
    i.length : FloatSocket
        Length

    Outputs
    -------
    o.is_hit : FloatSocket
        Is Hit
    o.self_hit : FloatSocket
        Self Hit
    o.hit_distance : FloatSocket
        Hit Distance
    o.hit_position : VectorSocket
        Hit Position
    o.hit_normal : VectorSocket
        Hit Normal
    """

    _bl_idname = "ShaderNodeRaycast"
    node: bpy.types.ShaderNodeRaycast

    class _Inputs(SocketAccessor):
        position: VectorSocket
        """Position"""
        direction: VectorSocket
        """Direction"""
        length: FloatSocket
        """Length"""

    class _Outputs(SocketAccessor):
        is_hit: FloatSocket
        """Is Hit"""
        self_hit: FloatSocket
        """Self Hit"""
        hit_distance: FloatSocket
        """Hit Distance"""
        hit_position: VectorSocket
        """Hit Position"""
        hit_normal: VectorSocket
        """Hit Normal"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        position: InputVector = None,
        direction: InputVector = None,
        length: InputFloat = 1.0,
        *,
        only_local: bool = False,
    ):
        super().__init__()
        key_args = {"Position": position, "Direction": direction, "Length": length}
        self.only_local = only_local
        self._establish_links(**key_args)

    @property
    def only_local(self) -> bool:
        return self.node.only_local

    @only_local.setter
    def only_local(self, value: bool):
        self.node.only_local = value


class Tangent(BaseNode):
    """
    Generate a tangent direction for the Anisotropic BSDF

    Outputs
    -------
    o.tangent : VectorSocket
        Tangent
    """

    _bl_idname = "ShaderNodeTangent"
    node: bpy.types.ShaderNodeTangent

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        tangent: VectorSocket
        """Tangent"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        direction_type: Literal["RADIAL", "UV_MAP"] = "RADIAL",
        axis: Literal["X", "Y", "Z"] = "Z",
        uv_map: str = "",
    ):
        super().__init__()
        key_args = {}
        self.direction_type = direction_type
        self.axis = axis
        self.uv_map = uv_map
        self._establish_links(**key_args)

    @property
    def direction_type(self) -> Literal["RADIAL", "UV_MAP"]:
        return self.node.direction_type

    @direction_type.setter
    def direction_type(self, value: Literal["RADIAL", "UV_MAP"]):
        self.node.direction_type = value

    @property
    def axis(self) -> Literal["X", "Y", "Z"]:
        return self.node.axis

    @axis.setter
    def axis(self, value: Literal["X", "Y", "Z"]):
        self.node.axis = value

    @property
    def uv_map(self) -> str:
        return self.node.uv_map

    @uv_map.setter
    def uv_map(self, value: str):
        self.node.uv_map = value


class TextureCoordinate(BaseNode):
    """
        Retrieve multiple types of texture coordinates.
    Typically used as inputs for texture nodes

        Outputs
        -------
        o.generated : VectorSocket
            Generated
        o.normal : VectorSocket
            Normal
        o.uv : VectorSocket
            UV
        o.object : VectorSocket
            Object
        o.camera : VectorSocket
            Camera
        o.window : VectorSocket
            Window
        o.reflection : VectorSocket
            Reflection
    """

    _bl_idname = "ShaderNodeTexCoord"
    node: bpy.types.ShaderNodeTexCoord

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        generated: VectorSocket
        """Generated"""
        normal: VectorSocket
        """Normal"""
        uv: VectorSocket
        """UV"""
        object: VectorSocket
        """Object"""
        camera: VectorSocket
        """Camera"""
        window: VectorSocket
        """Window"""
        reflection: VectorSocket
        """Reflection"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(self, from_instancer: bool = False):
        super().__init__()
        key_args = {}
        self.from_instancer = from_instancer
        self._establish_links(**key_args)

    @property
    def from_instancer(self) -> bool:
        return self.node.from_instancer

    @from_instancer.setter
    def from_instancer(self, value: bool):
        self.node.from_instancer = value


class UVAlongStroke(BaseNode):
    """
    UV coordinates that map a texture along the stroke length

    Outputs
    -------
    o.uv : VectorSocket
        UV
    """

    _bl_idname = "ShaderNodeUVAlongStroke"
    node: bpy.types.ShaderNodeUVAlongStroke

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        uv: VectorSocket
        """UV"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(self, use_tips: bool = False):
        super().__init__()
        key_args = {}
        self.use_tips = use_tips
        self._establish_links(**key_args)

    @property
    def use_tips(self) -> bool:
        return self.node.use_tips

    @use_tips.setter
    def use_tips(self, value: bool):
        self.node.use_tips = value


class UVMap(BaseNode):
    """
    Retrieve a UV map from the geometry, or the default fallback if none is specified

    Outputs
    -------
    o.uv : VectorSocket
        UV
    """

    _bl_idname = "ShaderNodeUVMap"
    node: bpy.types.ShaderNodeUVMap

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        uv: VectorSocket
        """UV"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        from_instancer: bool = False,
        uv_map: str = "",
    ):
        super().__init__()
        key_args = {}
        self.from_instancer = from_instancer
        self.uv_map = uv_map
        self._establish_links(**key_args)

    @property
    def from_instancer(self) -> bool:
        return self.node.from_instancer

    @from_instancer.setter
    def from_instancer(self, value: bool):
        self.node.from_instancer = value

    @property
    def uv_map(self) -> str:
        return self.node.uv_map

    @uv_map.setter
    def uv_map(self, value: str):
        self.node.uv_map = value


class Wireframe(BaseNode):
    """
        Retrieve the edges of an object as it appears to Cycles.
    Note: as meshes are triangulated before being processed by Cycles, topology will always appear triangulated

        Parameters
        ----------
        size : InputFloat
            Size

        Inputs
        ------
        i.size : FloatSocket
            Size

        Outputs
        -------
        o.fac : FloatSocket
            Factor
    """

    _bl_idname = "ShaderNodeWireframe"
    node: bpy.types.ShaderNodeWireframe

    class _Inputs(SocketAccessor):
        size: FloatSocket
        """Size"""

    class _Outputs(SocketAccessor):
        fac: FloatSocket
        """Factor"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        size: InputFloat = 0.01,
        *,
        use_pixel_size: bool = False,
    ):
        super().__init__()
        key_args = {"Size": size}
        self.use_pixel_size = use_pixel_size
        self._establish_links(**key_args)

    @property
    def use_pixel_size(self) -> bool:
        return self.node.use_pixel_size

    @use_pixel_size.setter
    def use_pixel_size(self, value: bool):
        self.node.use_pixel_size = value
