procfunc 0.30.0__py3-none-any.whl

procfunc/ops/object.py

@@ -0,0 +1,258 @@
+from typing import Literal
+
+import bpy
+import numpy as np
+
+import procfunc as pf
+from procfunc import types as t
+from procfunc.ops.attr import read_attribute, write_attribute
+from procfunc.util.bpy_info import bpy_nocollide_data_name
+
+from ._util import execute_object_op
+
+
+@pf.tracer.primitive(mutates=["mutates_obj"])
+def set_transform(
+    mutates_obj: t.MeshObject,
+    location: t.Vector | tuple[float, float, float] | None = None,
+    rotation_euler: t.Vector | tuple[float, float, float] | None = None,
+    scale: t.Vector | tuple[float, float, float] | None = None,
+):
+    obj = mutates_obj.item()
+    if location is not None:
+        obj.location = location
+    if rotation_euler is not None:
+        obj.rotation_euler = rotation_euler
+    if scale is not None:
+        obj.scale = scale
+
+    # Update view layer so transform affects matrix_world
+    bpy.context.view_layer.update()
+
+
+@pf.tracer.primitive(mutates=["mutates_obj"])
+def set_material(
+    mutates_obj: t.MeshObject,
+    material: "pf.Material | None" = None,
+    surface: "pf.ProcNode[pf.Shader] | None" = None,
+    displacement: "pf.ProcNode[pf.Vector] | None" = None,
+    volume: "pf.ProcNode[pf.Shader] | None" = None,
+    selection: np.ndarray | None = None,
+):
+    """Assign a material to an object.
+
+    Args:
+        mutates_obj: Blender object to assign material to
+        material: Material to assign. If None, constructs one from surface/displacement/volume.
+        surface: Shader to assign to the surface.
+        displacement: Vector to assign to the displacement.
+        volume: Shader to assign to the volume.
+        selection: Boolean array with length equal to number of faces.
+                  If provided, assigns material only to selected faces.
+    """
+
+    if material is None:
+        if all(x is None for x in [surface, displacement, volume]):
+            raise ValueError(
+                "at least one of material, surface, displacement, or volume must be provided"
+            )
+        material = pf.Material(
+            surface=surface, displacement=displacement, volume=volume
+        )
+
+    # mutates_obj.add_dependency(material)
+
+    obj_bpy = mutates_obj.item()
+
+    if selection is None:
+        while len(obj_bpy.material_slots) > 0:
+            execute_object_op(
+                operator=bpy.ops.object.material_slot_remove,
+                objs=mutates_obj,
+            )
+            # TODO remove mutates_obj.dependencies
+
+    orig_slots = len(obj_bpy.material_slots)
+    execute_object_op(
+        operator=bpy.ops.object.material_slot_add,
+        objs=mutates_obj,
+    )
+    new_slots = len(obj_bpy.material_slots)
+    assert new_slots == orig_slots + 1
+    target_slot = obj_bpy.material_slots[-1]
+    target_slot.material = material.item()
+
+    if selection is None:
+        return mutates_obj
+
+    assert isinstance(selection, np.ndarray)
+    assert len(selection) == len(obj_bpy.data.polygons)
+
+    if "material_index" in obj_bpy.data.attributes:
+        index_arr = read_attribute(mutates_obj, "material_index", domain="FACE")
+    else:
+        index_arr = np.full(len(obj_bpy.data.polygons), 0, dtype=np.int32)
+
+    index_arr[selection] = target_slot.slot_index
+    write_attribute(
+        mutates_obj, index_arr, "material_index", domain="FACE", overwrite=True
+    )
+
+    return mutates_obj
+
+
+def alias(obj: t.Object) -> t.Object:
+    """Create a linked duplicate that shares the same mesh data."""
+
+    # TODO need to store meshes as dependencies to avoid double free from alias
+
+    new_obj = bpy.data.objects.new(
+        bpy_nocollide_data_name(obj.item(), bpy.data.objects), obj.item().data
+    )
+    bpy.context.collection.objects.link(new_obj)
+    return t.MeshObject(new_obj)
+
+
+@pf.tracer.primitive(mutates=["mutates_obj"])
+def shade_flat(
+    mutates_obj: t.MeshObject,
+    keep_sharp_edges: bool = True,
+) -> None:
+    """
+    Render faces of object with flat shading
+
+    Based on bpy.ops.object.shade_flat
+    """
+    execute_object_op(
+        bpy.ops.object.shade_flat,
+        objs=mutates_obj,
+        keep_sharp_edges=keep_sharp_edges,
+        description=shade_flat.__name__,
+    )
+
+
+@pf.tracer.primitive
+def joined(**objects: t.Object) -> t.MeshObject:
+    """
+    Copies the objects and creates a new object with them merged together
+    """
+
+    if len(objects) < 2:
+        raise ValueError(
+            f"{joined.__name__} requires at least two objects, got {len(objects)}"
+        )
+
+    clones = [v.clone() for v in objects.values()]
+
+    execute_object_op(
+        bpy.ops.object.join,
+        objs=clones,
+        description=joined.__name__,
+    )
+    return t.MeshObject(bpy.context.active_object)
+
+
+@pf.tracer.primitive(mutates=["mutates_obj_1", "mutates_obj_2"])
+def join(
+    mutates_obj_1: t.MeshObject,
+    mutates_obj_2: t.MeshObject,
+) -> None:
+    """
+    Modifies mutates_obj_1 to point to a joined object of the two, without any copying.
+
+    mutates_obj_2 is invalidated. TODO: make it safely point to the joined object
+    """
+
+    execute_object_op(
+        bpy.ops.object.join,
+        active=mutates_obj_1,
+        objs=[mutates_obj_2],
+        description=join.__name__,
+    )
+
+    # mutates_obj_1.extend_dependencies(mutates_obj_2)
+    # mutates_obj_2.invalidate()
+
+
+def duplicate(
+    obj: t.Object,
+    linked: bool = False,
+    mode: Literal["TRANSLATION", "ROTATION", "RESIZE"] = "TRANSLATION",
+) -> None:
+    """
+    Duplicate selected objects
+
+    Based on bpy.ops.object.duplicate
+    """
+    bpy.context.view_layer.objects.active = obj.item()
+    execute_object_op(
+        bpy.ops.object.duplicate,
+        objs=[obj],
+        linked=linked,
+        mode=mode,
+        description=duplicate.__name__,
+    )
+    return t.Object(bpy.context.active_object)
+
+
+@pf.tracer.primitive(mutates=["mutates_obj"])
+def shade_smooth(
+    mutates_obj: t.MeshObject,
+    keep_sharp_edges: bool = True,
+) -> None:
+    """
+    Render faces of object with smooth shading
+
+    Based on bpy.ops.object.shade_smooth
+    """
+    execute_object_op(
+        bpy.ops.object.shade_smooth,
+        objs=mutates_obj,
+        keep_sharp_edges=keep_sharp_edges,
+        description=shade_smooth.__name__,
+    )
+
+
+# TODO: convert() for POINTCLOUD, CURVES, GREASEPENCIL ?
+
+
+@pf.tracer.primitive
+def curve_to_mesh(
+    curve: t.CurveObject,
+    merge_customdata: bool = True,
+) -> t.MeshObject:
+    """
+    Convert curve to mesh
+    """
+    execute_object_op(
+        bpy.ops.object.convert,
+        active=curve,
+        target="MESH",
+        keep_original=True,
+        merge_customdata=merge_customdata,
+        description=curve_to_mesh.__name__,
+    )
+    return t.MeshObject(bpy.context.active_object)
+
+
+@pf.tracer.primitive()
+def mesh_to_curve(
+    mesh: t.MeshObject,
+) -> t.CurveObject:
+    """
+    Convert mesh to curve
+    """
+    execute_object_op(
+        bpy.ops.object.convert,
+        active=mesh,
+        target="CURVE",
+        keep_original=True,
+        description=mesh_to_curve.__name__,
+    )
+    return t.CurveObject(bpy.context.active_object)
+
+
+def clear_scene():
+    for dstruct in [bpy.data.objects, bpy.data.meshes, bpy.data.materials]:
+        for o in dstruct:
+            dstruct.remove(o)

procfunc/ops/primitives/__init__.py

@@ -0,0 +1,31 @@
+from .camera import (
+    orthographic_camera,
+    perspective_camera,
+)
+from .curve import (
+    curve_bezier,
+    curve_circle,
+    curve_line,
+    curve_splines,
+)
+from .light import (
+    area_lamp,
+    point_lamp,
+    spot_lamp,
+    sun_lamp,
+)
+from .mesh import (
+    empty,
+    mesh_circle,
+    mesh_cone,
+    mesh_cube,
+    mesh_cylinder,
+    mesh_grid,
+    mesh_icosphere,
+    mesh_line,
+    mesh_monkey,
+    mesh_plane,
+    mesh_single_vertex,
+    mesh_torus,
+    mesh_uv_sphere,
+)

procfunc/ops/primitives/camera.py

@@ -0,0 +1,45 @@
+import bpy
+
+from procfunc import types as t
+
+
+def perspective_camera(
+    focal_length_mm: float = 50.0,
+    clip_start: float = 0.1,
+    clip_end: float = 1000.0,
+    sensor_width_mm: float = 36.0,
+    sensor_height_mm: float | None = None,
+) -> t.CameraObject:
+    bpy.ops.object.camera_add()
+    camera = bpy.context.object
+
+    camera.data.lens = focal_length_mm
+    camera.data.clip_start = clip_start
+    camera.data.clip_end = clip_end
+    camera.data.sensor_width = sensor_width_mm
+    if sensor_height_mm is None:
+        resx = bpy.context.scene.render.resolution_x
+        resy = bpy.context.scene.render.resolution_y
+        ratio = resx / resy
+        # assert ratio.is_integer(), (ratio, resx, resy)
+        camera.data.sensor_height = sensor_width_mm * ratio
+    else:
+        camera.data.sensor_height = sensor_height_mm
+
+    return t.CameraObject(camera)
+
+
+def orthographic_camera(
+    scale: float = 1.0,
+    clip_start: float = 0.1,
+    clip_end: float = 1000.0,
+) -> t.CameraObject:
+    bpy.ops.object.camera_add()
+    camera = bpy.context.object
+
+    camera.data.type = "ORTHO"
+    camera.data.ortho_scale = scale
+    camera.data.clip_start = clip_start
+    camera.data.clip_end = clip_end
+
+    return t.CameraObject(camera)

procfunc/ops/primitives/curve.py

@@ -0,0 +1,71 @@
+from typing import Literal
+
+import bpy
+import numpy as np
+
+from procfunc import types as t
+
+SplineType = Literal["POLY", "BEZIER", "NURBS"]
+
+
+def curve_circle(radius: float = 1.0):
+    bpy.ops.curve.primitive_bezier_circle_add(radius=radius)
+    return t.CurveObject(bpy.context.active_object)
+
+
+def curve_bezier():
+    bpy.ops.curve.primitive_bezier_curve_add()
+    return t.CurveObject(bpy.context.active_object)
+
+
+def _add_spline(
+    curve_data: bpy.types.Curve,
+    points: list[t.Vector] | np.ndarray,
+    spline_type: SplineType = "POLY",
+) -> None:
+    """Add a single spline with the given points to *curve_data*."""
+    spline = curve_data.splines.new(spline_type)
+    assert len(points) > 0, "There should be at least one point"
+    spline.points.add(len(points) - 1)
+    for i, coord in enumerate(points):
+        spline.points[i].co = (*coord, 1)
+
+
+def curve_line(
+    points: list[t.Vector] | np.ndarray,
+    dimensions="3D",
+    resolution_u=12,
+    spline_type: SplineType = "POLY",
+) -> t.CurveObject:
+    """Create a curve object containing a single spline through *points*."""
+    if dimensions != "3D":
+        raise NotImplementedError(
+            f"dimensions={dimensions!r} is not yet supported, only '3D' is implemented"
+        )
+    if resolution_u != 12:
+        raise NotImplementedError(
+            f"resolution_u={resolution_u!r} is not yet supported, only 12 is implemented"
+        )
+    curve = bpy.data.curves.new(curve_line.__name__, type="CURVE")
+    _add_spline(curve, points, spline_type)
+    obj = bpy.data.objects.new(curve_line.__name__, curve)
+    bpy.context.scene.collection.objects.link(obj)
+    return t.CurveObject(obj)
+
+
+def curve_splines(
+    splines: list[list[t.Vector] | np.ndarray],
+    spline_type: SplineType = "POLY",
+) -> t.CurveObject:
+    """Create a curve object containing multiple splines.
+
+    Args:
+        splines: List of point lists, one per spline.
+        spline_type: Spline interpolation type for all splines.
+    """
+    curve = bpy.data.curves.new(curve_splines.__name__, type="CURVE")
+    for points in splines:
+        _add_spline(curve, points, spline_type)
+    obj = bpy.data.objects.new(curve_splines.__name__, curve)
+    bpy.context.scene.collection.objects.link(obj)
+    return t.CurveObject(obj)

procfunc/ops/primitives/light.py

@@ -0,0 +1,114 @@
+from typing import Literal
+
+import bpy
+import numpy as np
+
+from procfunc import types as t
+from procfunc.tracer import primitive as tracer_primitive
+
+
+@tracer_primitive
+def point_lamp(
+    energy: float = 10.0,
+    color: tuple = (1.0, 1.0, 1.0),
+    shadow_soft_size: float = 0.0,
+    use_contact_shadow: bool = False,
+    contact_shadow_distance: float = 0.2,
+    contact_shadow_bias: float = 0.03,
+    contact_shadow_thickness: float = 0.2,
+) -> t.LightObject:
+    bpy.ops.object.light_add(type="POINT")
+    lamp = bpy.context.object
+
+    lamp.data.energy = energy
+    lamp.data.color = color
+    lamp.data.shadow_soft_size = shadow_soft_size
+    lamp.data.use_contact_shadow = use_contact_shadow
+    lamp.data.contact_shadow_distance = contact_shadow_distance
+    lamp.data.contact_shadow_bias = contact_shadow_bias
+    lamp.data.contact_shadow_thickness = contact_shadow_thickness
+
+    return t.LightObject(lamp)
+
+
+@tracer_primitive
+def sun_lamp(
+    intensity: float = 1.0,
+    color: tuple = (1.0, 1.0, 1.0),
+    angle_deg: float = 0.526,
+    use_contact_shadow: bool = False,
+    contact_shadow_distance: float = 0.2,
+    contact_shadow_bias: float = 0.03,
+    contact_shadow_thickness: float = 0.2,
+) -> t.LightObject:
+    bpy.ops.object.light_add(type="SUN")
+    lamp = bpy.context.object
+
+    lamp.data.energy = intensity  # intentional - blender uses energy for this case
+    lamp.data.color = color
+    lamp.data.angle = np.deg2rad(angle_deg)
+    lamp.data.use_contact_shadow = use_contact_shadow
+    lamp.data.contact_shadow_distance = contact_shadow_distance
+    lamp.data.contact_shadow_bias = contact_shadow_bias
+    lamp.data.contact_shadow_thickness = contact_shadow_thickness
+
+    return t.LightObject(lamp)
+
+
+@tracer_primitive
+def spot_lamp(
+    energy: float = 10.0,
+    color: tuple = (1.0, 1.0, 1.0),
+    spot_size_deg: float = 45.0,
+    spot_blend: float = 0.15,
+    shadow_soft_size: float = 0.0,
+    use_contact_shadow: bool = False,
+    contact_shadow_distance: float = 0.2,
+    contact_shadow_bias: float = 0.03,
+    contact_shadow_thickness: float = 0.2,
+) -> t.LightObject:
+    bpy.ops.object.light_add(type="SPOT")
+    lamp = bpy.context.object
+
+    lamp.data.energy = energy
+    lamp.data.color = color
+    lamp.data.spot_size = np.deg2rad(spot_size_deg)
+    lamp.data.spot_blend = spot_blend
+    lamp.data.shadow_soft_size = shadow_soft_size
+    lamp.data.use_contact_shadow = use_contact_shadow
+    lamp.data.contact_shadow_distance = contact_shadow_distance
+    lamp.data.contact_shadow_bias = contact_shadow_bias
+    lamp.data.contact_shadow_thickness = contact_shadow_thickness
+
+    return t.LightObject(lamp)
+
+
+@tracer_primitive
+def area_lamp(
+    energy: float = 10.0,
+    color: tuple = (1.0, 1.0, 1.0),
+    shape: Literal["SQUARE", "RECTANGLE", "ELLIPSE", "DISK"] = "SQUARE",
+    size_x: float = 1.0,
+    size_y: float = 1.0,
+    portal: bool = False,
+    use_contact_shadow: bool = False,
+    contact_shadow_distance: float = 0.2,
+    contact_shadow_bias: float = 0.03,
+    contact_shadow_thickness: float = 0.2,
+) -> t.LightObject:
+    bpy.ops.object.light_add(type="AREA")
+    lamp = bpy.context.object
+
+    lamp.data.energy = energy
+    lamp.data.color = color
+    lamp.data.shape = shape
+    lamp.data.size = size_x
+    if shape in ["RECTANGLE", "ELLIPSE"]:
+        lamp.data.size_y = size_y
+    lamp.data.cycles.is_portal = portal
+    lamp.data.use_contact_shadow = use_contact_shadow
+    lamp.data.contact_shadow_distance = contact_shadow_distance
+    lamp.data.contact_shadow_bias = contact_shadow_bias
+    lamp.data.contact_shadow_thickness = contact_shadow_thickness
+
+    return t.LightObject(lamp)