points = mesh.create_points() point_selection = mesh.create_point_selection() Cs = mesh.writable_vertex_data().create_array("Cs", "k3d::color") width = mesh.writable_vertex_data().create_array("width", "k3d::double_t") groups = mesh.create_linear_curve_groups() first_curves = groups.create_first_curves() curve_counts = groups.create_curve_counts() periodic_curves = groups.create_periodic_curves() materials = groups.create_materials() curve_first_points = groups.create_curve_first_points() curve_point_counts = groups.create_curve_point_counts() curve_selection = groups.create_curve_selection() curve_points = groups.create_curve_points() positions = [ k3d.point3(-5, 0, -5), k3d.point3(5, 0, -5), k3d.point3(-5, 0, 5), k3d.point3(5, 0, 5) ] colors = [ k3d.color(1, 0, 0), k3d.color(0, 1, 0), k3d.color(0, 0, 1), k3d.color(1, 1, 1) ] widths = [0.1, 0.8, 0.8, 0.1] for position in positions: points.append(position) point_selection.append(0.0)
test_ri_texture.name = "test_ri_texture" test_node = k3d.plugin.create("Axes", document) test_node.name = "test_node" create_property(test_container, "k3d::bool_t", True) create_property(test_container, "k3d::color", k3d.color(1, 2, 3)) create_property(test_container, "k3d::double_t", 3.1415) create_property(test_container, "k3d::filesystem::path", k3d.filesystem.generic_path("/foo/bar/baz")) create_property(test_container, "k3d::gl::imesh_painter*", test_gl_mesh_painter) create_property(test_container, "k3d::imaterial*", test_material) create_property(test_container, "k3d::inode*", test_node) create_property(test_container, "k3d::int32_t", 19700827) create_property(test_container, "k3d::matrix4", k3d.scale3(1, 2, 3)) create_property(test_container, "k3d::normal3", k3d.normal3(1, 2, 3)) create_property(test_container, "k3d::point3", k3d.point3(1, 2, 3)) create_property(test_container, "k3d::point4", k3d.point4(1, 2, 3, 4)) create_property(test_container, "k3d::ri::imesh_painter*", test_ri_mesh_painter) create_property(test_container, "k3d::ri::itexture*", test_ri_texture) create_property(test_container, "k3d::string_t", "K-3D Rocks!") create_property(test_container, "k3d::vector3", k3d.vector3(1, 2, 3)) path = testing.binary_path() + "/document.serialization.properties.output.k3d" document.save(path) def test_property(value, expected_value): if value != expected_value: raise "property value doesn't match: ", value, expected_value document2 = k3d.open_document(k3d.filesystem.native_path(path)) test_container2 = k3d.node.lookup_one(document, "test_container")
context.document.start_change_set() try: floor = context.document.new_node("PolyCube") floor.name = "Floor" floor.width = 10 floor.height = 10 floor.depth = 2 floor_instance = context.document.new_node("MeshInstance") floor_instance.name = "Floor Instance" floor_instance.gl_painter = k3d.node.lookup_one(context.document, "GL Default Painter") floor_instance.ri_painter = k3d.node.lookup_one(context.document, "RenderMan Default Painter") k3d.property.connect(context.document, floor.get_property("output_mesh"), floor_instance.get_property("input_mesh")) k3d.dynamic_cast(floor_instance, "isnappable").add_snap_target("-x", k3d.point3(-5, 0, 0)) k3d.dynamic_cast(floor_instance, "isnappable").add_snap_target("+x", k3d.point3(5, 0, 0)) k3d.dynamic_cast(floor_instance, "isnappable").add_snap_target("-y", k3d.point3(0, -5, 0)) k3d.dynamic_cast(floor_instance, "isnappable").add_snap_target("+y", k3d.point3(0, 5, 0)) k3d.dynamic_cast(floor_instance, "isnappable").add_snap_target("-z", k3d.point3(0, 0, -1)) k3d.dynamic_cast(floor_instance, "isnappable").add_snap_target("+z", k3d.point3(0, 0, 1)) chair = context.document.new_node("PolyCube") chair.name = "Chair" chair_instance = context.document.new_node("MeshInstance") chair_instance.name = "Chair Instance" chair_instance.gl_painter = k3d.node.lookup_one(context.document, "GL Default Painter") chair_instance.ri_painter = k3d.node.lookup_one(context.document, "RenderMan Default Painter") k3d.property.connect(context.document, chair.get_property("output_mesh"), chair_instance.get_property("input_mesh"))
import k3d import testing setup = testing.setup_mesh_modifier_test("FrozenMesh", "TriangulateFaces") mesh = setup.source.create_mesh() points = mesh.create_points() point_selection = mesh.create_point_selection() polyhedron = k3d.polyhedron.create(mesh) Cs = polyhedron.vertex_attributes().create("Cs", "k3d::color") positions = [(0, 0, 1), (1, 0, 1), (2, 0, 0), (2, 0, 1), (1, 0, 0), (0, 0, 0)] for position in positions: points.append(k3d.point3(position[0], position[1], position[2])) point_selection.append(0) polyhedron.shell_types().append(k3d.polyhedron.shell_type.POLYGONS) polyhedron.face_shells().append(0) polyhedron.face_first_loops().append(len(polyhedron.loop_first_edges())) polyhedron.face_loop_counts().append(1) polyhedron.face_materials().append(None) polyhedron.face_selections().append(0) polyhedron.loop_first_edges().append(len(polyhedron.clockwise_edges())) polyhedron.clockwise_edges().append(1) polyhedron.edge_selections().append(0) polyhedron.vertex_points().append(0)
#python import k3d document = k3d.new_document() pointToVector = k3d.plugin.create("PointToVector", document) vector = k3d.vector3(1, 2, 3) point = k3d.point3(1, 2, 3) pointToVector.point = point if pointToVector.vector != vector: raise Exception("Incorrect convertion: pointToVector.vector = " + str(pointToVector.vector) + "; point = " + str(point))
first_primitives = blobbies.create_first_primitives() primitive_counts = blobbies.create_primitive_counts() first_operators = blobbies.create_first_operators() operator_counts = blobbies.create_operator_counts() materials = blobbies.create_materials() primitives = blobbies.create_primitives() primitive_first_floats = blobbies.create_primitive_first_floats() primitive_float_counts = blobbies.create_primitive_float_counts() floats = blobbies.create_floats() Cs = blobbies.writable_varying_data().create_array("Cs", "k3d::color") operators = blobbies.create_operators() operator_first_operands = blobbies.create_operator_first_operands() operator_operand_counts = blobbies.create_operator_operand_counts() operands = blobbies.create_operands() ellipsoids = [k3d.point3(-1, 0, 1), k3d.point3(1, 0, 1), k3d.point3(1, 0, -1), k3d.point3(-1, 0, -1)] first_primitives.append(len(primitives)) primitive_counts.append(len(ellipsoids) + 1) first_operators.append(len(operators)) operator_counts.append(1) materials.append(k3d.dynamic_cast(Document.get_node("Material"), "imaterial")) for center in ellipsoids: primitives.append(k3d.primitive_type.ellipsoid) primitive_first_floats.append(len(floats)) primitive_float_counts.append(16) for i in (k3d.translate3(center) * k3d.scale3(1, 1, 1)).column_major_list(): floats.append(i) primitives.append(k3d.primitive_type.segment)
# python from math import radians import k3d k3d.check_node_environment(context, "MeshSourceScript") # Construct a sphere mesh primitive ... hyperboloid = k3d.hyperboloid.create(context.output) color = hyperboloid.parameter_attributes().create("Cs", "k3d::color") # Add two hyperboloids ... hyperboloid.matrices().append(k3d.translate3(k3d.vector3(-5, 0, 0))) hyperboloid.materials().append(None) hyperboloid.start_points().append(k3d.point3(-2, 2, 2)) hyperboloid.end_points().append(k3d.point3(2, 2, -2)) hyperboloid.sweep_angles().append(radians(360)) hyperboloid.selections().append(0) color.append(k3d.color(1, 0, 0)) color.append(k3d.color(1, 0, 0)) color.append(k3d.color(1, 1, 0)) color.append(k3d.color(1, 1, 0)) hyperboloid.matrices().append(k3d.translate3(k3d.vector3(5, 0, 0))) hyperboloid.materials().append(None) hyperboloid.start_points().append(k3d.point3(-2, 2, 2)) hyperboloid.end_points().append(k3d.point3(2, 2, -2)) hyperboloid.sweep_angles().append(radians(360)) hyperboloid.selections().append(0) color.append(k3d.color(1, 0, 0))
#python import k3d k3d.check_node_environment(locals(), "MeshSourceScript") # Create two triangles, arranged to form a square ... vertices = [ k3d.point3(-3, -3, 0), k3d.point3(3, -3, 0), k3d.point3(3, 3, 0), k3d.point3(-3, 3, 0) ] vertex_counts = [3, 3] vertex_indices = [0, 1, 3, 1, 2, 3] material = None polyhedron = k3d.polyhedron.create(Output, vertices, vertex_counts, vertex_indices, material)
frozen_mesh = k3d.plugin.create("FrozenMesh", context.document) frozen_mesh.name = function # Create a mesh ... mesh = frozen_mesh.create_mesh() # Add geometric points to the mesh ... points = mesh.create_points() point_selection = mesh.create_point_selection() for xi in range(0, xcount): for yi in range(0, ycount): x = mix(x1, x2, float(xi) / (xcount - 1)) y = mix(y1, y2, float(yi) / (ycount - 1)) z = eval(function) points.append(k3d.point3(x, y, z)) point_selection.append(0.0) # Create a particle primitive ... particles = k3d.particle.create(mesh) # Create a custom attribute array to control the widths of particles ... constantwidth = particles.constant_attributes().create("constantwidth", "k3d::double_t") particles.material().append(None) constantwidth.append(0.2) for i in range(len(points)): particles.points().append(i) # Connect the FrozenMesh to a MeshInstance to place it in the scene ...
points = mesh.create_points() point_selection = mesh.create_point_selection() point_groups = mesh.create_point_groups() first_points = point_groups.create_first_points() point_counts = point_groups.create_point_counts() materials = point_groups.create_materials() constantwidth = point_groups.writable_constant_data().create_array("constantwidth", "k3d::double_t") group_points = point_groups.create_points() for xi in range(0, xcount): for yi in range(0, ycount): x = mix(x1, x2, float(xi) / (xcount - 1)) y = mix(y1, y2, float(yi) / (ycount - 1)) z = eval(function) point = k3d.point3(x, y, z) points.append(point) point_selection.append(0.0) first_points.append(len(group_points)) point_counts.append(len(points)) materials.append(None) constantwidth.append(0.2) for i in range(len(points)): group_points.append(i) mesh_instance = doc.new_node("MeshInstance") mesh_instance.name = function + " Instance" mesh_instance.gl_painter = doc.get_node("GL Default Painter") mesh_instance.ri_painter = doc.get_node("RenderMan Default Painter")
#python import k3d doc = Document doc.start_change_set() try: frozen_mesh = doc.new_node("FrozenMesh") frozen_mesh.name = "Simple Polyhedron" mesh = k3d.dynamic_cast(frozen_mesh, "imesh_storage").reset_mesh() vertices = [k3d.point3(-3, -3, 0), k3d.point3(3, -3, 0), k3d.point3(3, 3, 0), k3d.point3(-3, 3, 0)] vertex_counts = [3, 3] vertex_indices = [0, 1, 3, 1, 2, 3] material = None polyhedron = k3d.polyhedron.create(mesh, vertices, vertex_counts, vertex_indices, material) mesh_instance = doc.new_node("MeshInstance") mesh_instance.name = "Simple Polyhedron Instance" mesh_instance.gl_painter = doc.get_node("GL Default Painter") mesh_instance.ri_painter = doc.get_node("RenderMan Default Painter") doc.set_dependency(mesh_instance.get_property("input_mesh"), frozen_mesh.get_property("output_mesh")) doc.finish_change_set("Create Simple Polyhedron") except: doc.cancel_change_set() raise
#python import k3d import testing doc = k3d.new_document() source = k3d.plugin.create("PolyGrid", doc) centroid = k3d.plugin.create("PointsCentroid", doc) source.rows = 1 source.columns = 1 selection = k3d.geometry.selection.create(0) point_selection = k3d.geometry.point_selection.create(selection) k3d.geometry.point_selection.append(point_selection, 0, 2, 1) centroid.mesh_selection = selection k3d.property.connect(doc, source.get_property("output_mesh"), centroid.get_property("input_mesh")) if centroid.centroid != k3d.point3(0, 5, 0): raise "unexpected output_vector: " + str(centroid.centroid)
import k3d context.document.start_change_set() try: # Create a FrozenMesh node to act as a mesh source ... frozen_mesh = k3d.plugin.create("FrozenMesh", context.document) frozen_mesh.name = "Cubic Curve" # Create a mesh ... mesh = frozen_mesh.create_mesh() # Add geometric points to the mesh ... points = mesh.create_points() point_selection = mesh.create_point_selection() positions = [k3d.point3(-5, 0, -5), k3d.point3(5, 0, -5), k3d.point3(-5, 0, 5), k3d.point3(5, 0, 5)] for position in positions: points.append(position) point_selection.append(0.0) # Create a cubic curve primitive ... curves = k3d.cubic_curve.create(mesh) # Create a custom attribute array to control the width of the curve ... width = curves.constant_attributes().create("constantwidth", "k3d::double_t") # Create a custom attribute array to store color values at each curve vertex ... Cs = curves.vertex_attributes().create("Cs", "k3d::color") # Add a single curve to the primitive ... curves.periodic().append(False)
try: # Create a FrozenMesh node to act as a mesh source ... frozen_mesh = k3d.plugin.create("FrozenMesh", context.document) frozen_mesh.name = "Particles" # Create a mesh ... mesh = frozen_mesh.create_mesh() particle_count = 100 size = 10 # Add geometric points to the mesh ... points = mesh.create_points() point_selection = mesh.create_point_selection() for i in range(particle_count): points.append(k3d.point3(uniform(-size, size), uniform(-size, size), uniform(-size, size))) point_selection.append(0.0) # Create a particle primitive ... particles = k3d.particle.create(mesh) # Create a custom attribute array to control the widths of particles ... constantwidth = particles.constant_attributes().create("constantwidth", "k3d::double_t") # Create a custom attribute array to store color values for each particle ... Cs = particles.vertex_attributes().create("Cs", "k3d::color") # Add particles to the primitive ... particles.material().append(None) for i in range(particle_count): particles.points().append(i)
#python import k3d k3d.check_node_environment(context, "MeshSourceScript") # Create two triangles, arranged to form a square ... vertices = [k3d.point3(-3, -3, 0), k3d.point3(3, -3, 0), k3d.point3(3, 3, 0), k3d.point3(-3, 3, 0)] vertex_counts = [3, 3] vertex_indices = [0, 1, 3, 1, 2, 3] material = None polyhedron = k3d.polyhedron.create(context.output, vertices, vertex_counts, vertex_indices, material)
#python import k3d import testing document = k3d.new_document() instance = k3d.plugin.create("MeshInstance", document) transform = k3d.plugin.create("FrozenMatrix", document) transform.matrix = k3d.translate3(1, 0, 0) k3d.property.connect(document, transform.get_property("output_matrix"), instance.get_property("input_matrix")) position = k3d.world_position(instance) reference = k3d.point3(1, 0, 0) if position != reference: raise Exception("Position differs from expected value, expected: " + str(reference) + ", result: " + str(position))
patches.patch_point_weights().append(0.5) patches.patch_point_weights().append(1) patches.patch_u_knots().append(1) patches.patch_u_knots().append(1) patches.patch_u_knots().append(1) patches.patch_u_knots().append(2) patches.patch_u_knots().append(2) patches.patch_u_knots().append(2) patches.patch_v_knots().append(1) patches.patch_v_knots().append(1) patches.patch_v_knots().append(2) patches.patch_v_knots().append(2) patches.patch_first_trim_loops().append(0) patches.patch_trim_loop_counts().append(0) # Cs.append(k3d.color(1, 0, 0)) # Cs.append(k3d.color(0, 1, 0)) # Cs.append(k3d.color(0, 0, 1)) # Cs.append(k3d.color(1, 1, 1)) positions = [(-5, 5, 5), (5, 5, 5), (5, 5, 10), (-5, -5, 5), (5, -5, 5), (5, -5, 10)] for position in positions: points.append(k3d.point3(position[0], position[1], position[2] + (i * -10))) point_selection.append(0.0)
#python import k3d k3d.check_node_environment(locals(), "MeshSourceScript") blobby = k3d.blobby.create(Output) Cs = blobby.varying_data().create("Cs", "k3d::color") # Add four ellipsoids to the blobby ... ellipsoids = [ k3d.point3(-1, 0, 1), k3d.point3(1, 0, 1), k3d.point3(1, 0, -1), k3d.point3(-1, 0, -1) ] blobby.first_primitives().append(len(blobby.primitives())) blobby.primitive_counts().append(len(ellipsoids) + 1) blobby.first_operators().append(len(blobby.operators())) blobby.operator_counts().append(1) blobby.materials().append(Document.get_node("Material")) for center in ellipsoids: blobby.primitives().append(k3d.blobby.primitive_type.ELLIPSOID) blobby.primitive_first_floats().append(len(blobby.floats())) blobby.primitive_float_counts().append(16) for i in (k3d.translate3(center[0], center[1], center[2]) * k3d.scale3(1)).column_major_list(): blobby.floats().append(i) # Add a segment to the blobby ...
import k3d context.document.start_change_set() try: # Create a FrozenMesh node to act as a mesh source ... frozen_mesh = k3d.plugin.create("FrozenMesh", context.document) frozen_mesh.name = "Linear Curve" # Create a mesh ... mesh = frozen_mesh.create_mesh() # Add geometric points to the mesh ... points = mesh.create_points() point_selection = mesh.create_point_selection() positions = [k3d.point3(-5, 0, -5), k3d.point3(5, 0, -5), k3d.point3(-5, 0, 5), k3d.point3(5, 0, 5)] for position in positions: points.append(position) point_selection.append(0.0) # Create a linear curve primitive ... curves = k3d.linear_curve.create(mesh) # Create a custom attribute array to control the width of the curve ... width = curves.vertex_attributes().create("width", "k3d::double_t") # Create a custom attribute array to store color values at each curve vertex ... Cs = curves.vertex_attributes().create("Cs", "k3d::color") # Add a single curve to the primitive ... curves.periodic().append(False)
#python import k3d positions = [(-5, -5, 0), (5, -5, 0), (5, 5, 0), (-5, 5, 0)] points = context.output.create_points() point_selection = context.output.create_point_selection() for position in positions: points.append(k3d.point3(position[0], position[1], position[2])) point_selection.append(0.0) polyhedron = k3d.polyhedron.create(context.output) polyhedron.shell_types().append(k3d.polyhedron.shell_type.POLYGONS) polyhedron.face_shells().append(0) polyhedron.face_first_loops().append(0) polyhedron.face_loop_counts().append(1) polyhedron.face_materials().append(None) polyhedron.face_selections().append(0.0) polyhedron.loop_first_edges().append(0) polyhedron.clockwise_edges().assign([1, 2, 3, 0]) polyhedron.edge_selections().assign([0, 0, 0, 0]) polyhedron.vertex_points().assign([0, 1, 2, 3]) polyhedron.vertex_selections().assign([0, 0, 0, 0])
#python import k3d k3d.check_node_environment(locals(), "MeshSourceScript") from random import uniform count = 200 size = 10 points = Output.create_points() point_selection = Output.create_point_selection() for i in range(count): points.append(k3d.point3(uniform(-size, size), uniform(-size, size), uniform(-size, size))) point_selection.append(0.0) point_groups = Output.create_point_groups() first_points = point_groups.create_first_points() first_points.append(0) point_counts = point_groups.create_point_counts() point_counts.append(len(points)) materials = point_groups.create_materials() materials.append(None) constantwidth = point_groups.writable_constant_data().create("constantwidth", "double") constantwidth.append(0.2)
# Perform required one-time setup to store bicubic patches in the mesh ... patches = k3d.bicubic_patch.create(Output) # Create an (optional) array to hold color values at the parametric # corners of each patch ... Cs = patches.varying_data().create("Cs", "k3d::color") # We will create two identical bicubic patches ... for i in range(2): patches.patch_selections().append(0) patches.patch_materials().append(None) for j in range(16): patches.patch_points().append(len(points) + j) positions = [(-5, -5, 0), (-2, -5, 2), (2, -5, -2), (5, -5, 0), (-5, -2, 2), (-2, -2, 5), (2, -2, -5), (5, -2, -2), (-5, 2, 2), (-2, 2, 5), (2, 2, -5), (5, 2, -2), (-5, 5, 0), (-2, 5, 2), (2, 5, -2), (5, 5, 0)] for position in positions: points.append( k3d.point3(position[0] + (12 * i), position[2], -position[1])) point_selection.append(0.0) Cs.append(k3d.color(1, 0, 0)) Cs.append(k3d.color(0, 1, 0)) Cs.append(k3d.color(0, 0, 1)) Cs.append(k3d.color(1, 1, 1))
test_node = document.new_node("Axes") test_node.name = "test_node" create_property(test_container, "k3d::bool_t", True) create_property(test_container, "k3d::color", k3d.color(1, 2, 3)) create_property(test_container, "k3d::double_t", 3.1415) create_property(test_container, "k3d::filesystem::path", k3d.filesystem.generic_path("/foo/bar/baz")) create_property(test_container, "k3d::gl::imesh_painter*", test_gl_mesh_painter) create_property(test_container, "k3d::imaterial*", test_material) create_property(test_container, "k3d::inode*", test_node) create_property(test_container, "k3d::int32_t", 19700827) create_property(test_container, "k3d::matrix4", k3d.scale3(1, 2, 3)) create_property(test_container, "k3d::normal3", k3d.normal3(1, 2, 3)) create_property(test_container, "k3d::point3", k3d.point3(1, 2, 3)) create_property(test_container, "k3d::point4", k3d.point4(1, 2, 3, 4)) create_property(test_container, "k3d::ri::imesh_painter*", test_ri_mesh_painter) create_property(test_container, "k3d::ri::itexture*", test_ri_texture) create_property(test_container, "k3d::string_t", "K-3D Rocks!") create_property(test_container, "k3d::vector3", k3d.vector3(1, 2, 3)) path = testing.binary_path() + "/document.serialization.properties.output.k3d" document.save(path) def test_property(value, expected_value): if value != expected_value: raise "property value doesn't match: ", value, expected_value
source_a = document.new_node("FrozenMesh") source_b = document.new_node("FrozenMesh") mesh_a = source_a.create_mesh() mesh_b = source_b.create_mesh() test_equal(mesh_a, mesh_b, "empty meshes") points_a = mesh_a.create_points() test_unequal(mesh_a, mesh_b, "mesh without point array") points_b = mesh_b.create_points() test_equal(mesh_a, mesh_b, "meshes with empty point arrays") points_a.append(k3d.point3(1, 2, 3)) test_unequal(mesh_a, mesh_b, "mismatched point arrays") points_b.append(k3d.point3(1, 2, 3)) test_equal(mesh_a, mesh_b, "matched point arrays") primitive_a = mesh_a.primitives().create("foo") test_unequal(mesh_a, mesh_b, "mesh without primitive") primitive_b = mesh_b.primitives().create("foo") test_equal(mesh_a, mesh_b, "matched primitives") structure_a = primitive_a.structure().create("indices", "k3d::uint_t") test_unequal(mesh_a, mesh_b, "structure with missing array") structure_b = primitive_b.structure().create("indices", "k3d::uint_t")
patches = k3d.bezier_triangle_patch.create(context.output) # We will create two identical bezier triangle patches ... for i in range(2): patches.patch_first_points().append(len(points)) patches.patch_orders().append(4) patches.patch_selections().append(0) patches.patch_materials().append(None) # from The Platonic Spheroids at http://www.cise.ufl.edu/research/SurfLab/pre99-papers/97.spheroids.ps.gz # The tetroid: # (3,-3,-3) (1,-1,-7) (-1,1,-7) (-3,3,-3) # (1,-7,-1) (-11,-11,-11) (-7,1,-1) # (-1,-7,1) (-7,-1,1) # (-3,-3,3) positions = [ (3,-3,-3), (1,-7,-1), (1,-1,-7), (-1,-7,1), (-11,-11,-11), (-1,1,-7), (-3,-3,3), (-7,-1,1), (-7,1,-1), (-3,3,-3) ] # Assign patch_points and patch_weights here ... for j in range(0,len(positions)): patches.patch_points().append(len(points) + j) patches.patch_point_weights().append(1) for position in positions: points.append(k3d.point3(position[0] + (12 * i), position[2], -position[1])) point_selection.append(0.0)
#python import k3d import sys import testing setup = testing.setup_mesh_writer_test(["FrozenMesh", "K3DMeshWriter"], "K3DMeshReader", "mesh.serialization.k3d") mesh = setup.source.create_mesh() primitive = mesh.primitives().create("test") array_types = [ "k3d::bool_t", "k3d::color", "k3d::double_t", "k3d::imaterial*", "k3d::inode*", "k3d::int16_t", "k3d::int32_t", "k3d::int64_t", "k3d::int8_t", "k3d::matrix4", "k3d::normal3", "k3d::point2", "k3d::point3", "k3d::point4", "k3d::string_t", "k3d::texture3", "k3d::uint16_t", "k3d::uint32_t", "k3d::uint64_t", "k3d::uint8_t", "k3d::vector2", "k3d::vector3", "k3d::uint_t" ] array_values = [ True, k3d.color(1, 2, 3), 1.0, None, None, 1, 2, 3, 4, k3d.identity3(), k3d.normal3(1, 2, 3), k3d.point2(1, 2), k3d.point3(1, 2, 3), k3d.point4(1, 2, 3, 4), "A String", k3d.texture3(1, 2, 3), 1, 2, 3, 4, k3d.vector2(1, 2), k3d.vector3(1, 2, 3), 7 ] structure = primitive.structure().create("generic") attributes = primitive.attributes().create("generic") for i in range(len(array_types)): type = array_types[i] value = array_values[i] structure_array = structure.create(type, type) structure_array.append(value) structure_array.append(value) structure_array.append(value) attribute_array = attributes.create(type, type) attribute_array.append(value) attribute_array.append(value) attribute_array.append(value)
polyhedron.face_selections().append(0.0) Cs.append(k3d.color(1, j / 2.0, i / 1.0)) polyhedron.loop_first_edges().append(len(polyhedron.edge_points())) # Each loop has four edges, each of which points to the next edge in clockwise-order ... polyhedron.clockwise_edges().append(len(polyhedron.edge_points()) + 1) polyhedron.clockwise_edges().append(len(polyhedron.edge_points()) + 2) polyhedron.clockwise_edges().append(len(polyhedron.edge_points()) + 3) polyhedron.clockwise_edges().append(len(polyhedron.edge_points()) + 0) # Each edge refers to its starting-point ... polyhedron.edge_points().append(len(points) + 0) polyhedron.edge_points().append(len(points) + 1) polyhedron.edge_points().append(len(points) + 2) polyhedron.edge_points().append(len(points) + 3) polyhedron.edge_selections().append(0.0) polyhedron.edge_selections().append(0.0) polyhedron.edge_selections().append(0.0) polyhedron.edge_selections().append(0.0) positions = [(-5, 0, 5), (5, 0, 5), (5, 0, -5), (-5, 0, -5)] for position in positions: points.append( k3d.point3(position[0] + (j * 11.0), position[1] + (i * -11.0), position[2])) point_selection.append(0.0)
# Create a FrozenMesh node to act as a mesh source ... frozen_mesh = k3d.plugin.create("FrozenMesh", context.document) frozen_mesh.name = "Particles" # Create a mesh ... mesh = frozen_mesh.create_mesh() particle_count = 100 size = 10 # Add geometric points to the mesh ... points = mesh.create_points() point_selection = mesh.create_point_selection() for i in range(particle_count): points.append( k3d.point3(uniform(-size, size), uniform(-size, size), uniform(-size, size))) point_selection.append(0.0) # Create a particle primitive ... particles = k3d.particle.create(mesh) # Create a custom attribute array to control the widths of particles ... constantwidth = particles.constant_attributes().create( "constantwidth", "k3d::double_t") # Create a custom attribute array to store color values for each particle ... Cs = particles.vertex_attributes().create("Cs", "k3d::color") # Add particles to the primitive ... particles.material().append(None) for i in range(particle_count):
polyhedron.loop_first_edges().append(len(polyhedron.clockwise_edges())) # Each loop has four edges, each of which points to the next edge in clockwise-order ... polyhedron.clockwise_edges().append(len(polyhedron.clockwise_edges()) + 1) polyhedron.clockwise_edges().append(len(polyhedron.clockwise_edges()) + 1) polyhedron.clockwise_edges().append(len(polyhedron.clockwise_edges()) + 1) polyhedron.clockwise_edges().append(len(polyhedron.clockwise_edges()) - 3) polyhedron.edge_selections().append(0.0) polyhedron.edge_selections().append(0.0) polyhedron.edge_selections().append(0.0) polyhedron.edge_selections().append(0.0) # Each edge has a vertex that references a mesh point ... polyhedron.vertex_points().append(len(points) + 0) polyhedron.vertex_points().append(len(points) + 1) polyhedron.vertex_points().append(len(points) + 2) polyhedron.vertex_points().append(len(points) + 3) polyhedron.vertex_selections().append(0.0) polyhedron.vertex_selections().append(0.0) polyhedron.vertex_selections().append(0.0) polyhedron.vertex_selections().append(0.0) positions = [(-5, 0, 5), (5, 0, 5), (5, 0, -5), (-5, 0, -5)] for position in positions: points.append(k3d.point3(position[0] + (j * 11.0), position[1] + (i * -11.0), position[2])) point_selection.append(0.0)
polyhedron = k3d.polyhedron.create(mesh) primitive = mesh.primitives()[0] if k3d.polyhedron.validate(mesh, primitive): raise Exception("validate() should fail on polyhedron with missing points.") mesh.create_points() if k3d.polyhedron.validate(mesh, primitive): raise Exception("validate() should fail on polyhedron with missing point_selections.") mesh.create_point_selection() if not k3d.polyhedron.validate(mesh, primitive): raise Exception("validate() should succeed.") polyhedron.clockwise_edges().append(0) polyhedron.edge_selections().append(0) polyhedron.vertex_points().append(0) polyhedron.vertex_selections().append(0) if k3d.polyhedron.validate(mesh, primitive): raise Exception("validate() should fail on polyhedron with out-of-bound point indices.") mesh.points().append(k3d.point3(0, 0, 0)) mesh.point_selection().append(0) if not k3d.polyhedron.validate(mesh, primitive): raise Exception("validate() should succeed.")
#python from math import radians import k3d k3d.check_node_environment(context, "MeshSourceScript") # Construct a sphere mesh primitive ... hyperboloid = k3d.hyperboloid.create(context.output) color = hyperboloid.parameter_attributes().create("Cs", "k3d::color") # Add two hyperboloids ... hyperboloid.matrices().append(k3d.translate3(k3d.vector3(-5, 0, 0))) hyperboloid.materials().append(None) hyperboloid.start_points().append(k3d.point3(-2, 2, 2)) hyperboloid.end_points().append(k3d.point3(2, 2, -2)) hyperboloid.sweep_angles().append(radians(360)) hyperboloid.selections().append(0) color.append(k3d.color(1, 0, 0)) color.append(k3d.color(1, 0, 0)) color.append(k3d.color(1, 1, 0)) color.append(k3d.color(1, 1, 0)) hyperboloid.matrices().append(k3d.translate3(k3d.vector3(5, 0, 0))) hyperboloid.materials().append(None) hyperboloid.start_points().append(k3d.point3(-2, 2, 2)) hyperboloid.end_points().append(k3d.point3(2, 2, -2)) hyperboloid.sweep_angles().append(radians(360)) hyperboloid.selections().append(0) color.append(k3d.color(1, 0, 0)) color.append(k3d.color(1, 0, 0))
#python import k3d document = k3d.new_document() pointSubtraction = k3d.plugin.create("PointSubtraction", document) pointSubtraction.a = k3d.point3(1, 2, 3) pointSubtraction.b = k3d.point3(3, 2, 1) if pointSubtraction.a_minus_b != k3d.vector3(-2, 0, 2): raise Exception("(1, 2, 3) - (3, 2, 1) != (-2, 0, 2)")
#python import k3d import sys import testing document = k3d.new_document() source = document.new_node("FrozenMesh") mesh = source.create_mesh() primitive = mesh.primitives().create("test") array_types = [ "k3d::bool_t", "k3d::color", "k3d::double_t", "k3d::imaterial*", "k3d::inode*", "k3d::int16_t", "k3d::int32_t", "k3d::int64_t", "k3d::int8_t", "k3d::matrix4", "k3d::normal3", "k3d::point2", "k3d::point3", "k3d::point4", "k3d::string_t", "k3d::texture3", "k3d::uint16_t", "k3d::uint32_t", "k3d::uint64_t", "k3d::uint8_t", "k3d::vector2", "k3d::vector3", "k3d::uint_t" ] array_values = [ True, k3d.color(1, 2, 3), 1.0, None, None, 1, 2, 3, 4, k3d.identity3(), k3d.normal3(1, 2, 3), k3d.point2(1, 2), k3d.point3(1, 2, 3), k3d.point4(1, 2, 3, 4), "A String", k3d.texture3(1, 2, 3), 1, 2, 3, 4, k3d.vector2(1, 2), k3d.vector3(1, 2, 3), 7 ] attributes = primitive.attributes().create("uniform") for i in range(len(array_types)): type = array_types[i] value = array_values[i] named_array = primitive.structure().create(type, type) named_array.append(value) named_array.append(value) attribute_array = attributes.create(type, type) attribute_array.append(value) attribute_array.append(value) attribute_array.append(value) print repr(mesh) sys.stdout.flush()
trim_curve_knots.append(0) for i in range(1, segments): trim_curve_knots.append(i) trim_curve_knots.append(i) for i in range(0, 3): trim_curve_knots.append(segments) #weights trim_curve_point_weights.append(1) for i in range(segments): trim_curve_point_weights.append(weight) trim_curve_point_weights.append(1) #trim_curve_point_weights.append(weight) #control points X = k3d.point3(1, 0, 0) Y = k3d.point3(0, 1, 0) trim_points.append( math.cos(start_angle) * k3d.point2(0.75, 0.5) + math.sin(start_angle) * k3d.point2(0.5, 0.75)) for i in range(segments): a0 = start_angle + (theta * (i)) a2 = start_angle + (theta * (i + 1)) p0 = k3d.point3(math.cos(a0) * X + math.sin(a0) * Y) p2 = k3d.point3(math.cos(a2) * X + math.sin(a2) * Y) t0 = k3d.point3(-math.sin(a0) * X + math.cos(a0) * Y) t2 = k3d.point3(-math.sin(a2) * X + math.cos(a2) * Y)
#python import k3d document = k3d.new_document() planeCreation = k3d.plugin.create("PlaneCreation", document) normal = k3d.vector3(0, 0, 1) point = k3d.point3(0, 1, 0) planeCreation.normal = normal planeCreation.point = point if planeCreation.plane != k3d.plane(normal, point): raise Exception("Incorrect plane: " + str(planeCreation.plane))
# Create an array to store per-curve curve colors ... Cs = curves.curve_attributes().create("Cs", "k3d::color") # Add some curves ... curves.periodic().append(False) curves.material().append(None) constantwidth.append(0.5) for j in range(5): curves.curve_first_points().append(len(curves.curve_points())) curves.curve_point_counts().append(7) curves.curve_selections().append(0.0) curves.curve_points().append(len(points) + 0) curves.curve_points().append(len(points) + 1) curves.curve_points().append(len(points) + 2) curves.curve_points().append(len(points) + 3) curves.curve_points().append(len(points) + 4) curves.curve_points().append(len(points) + 5) curves.curve_points().append(len(points) + 6) positions = [(0, 0, 5), (-5, 0, 5), (-5, 0, 0), (0, 0, 0), (5, 0, 0), (5, 0, -5), (0, 0, -5)] for position in positions: points.append( k3d.point3(position[0] + (j * 5), position[1], position[2])) point_selection.append(0.0) Cs.append(k3d.color(1, 1, j * 0.2))
#python import k3d k3d.check_node_environment(context, "MeshSourceScript") blobby = k3d.blobby.create(context.output) Cs = blobby.parameter_attributes().create("Cs", "k3d::color") # Add four ellipsoids to the blobby ... ellipsoids = [k3d.point3(-1, 0, 1), k3d.point3(1, 0, 1), k3d.point3(1, 0, -1), k3d.point3(-1, 0, -1)] blobby.first_primitives().append(len(blobby.primitives())) blobby.primitive_counts().append(len(ellipsoids) + 1) blobby.first_operators().append(len(blobby.operators())) blobby.operator_counts().append(1) blobby.materials().append(k3d.node.lookup_one(context.document, "Material")) for center in ellipsoids: blobby.primitives().append(k3d.blobby.primitive_type.ELLIPSOID) blobby.primitive_first_floats().append(len(blobby.floats())) blobby.primitive_float_counts().append(16) for i in (k3d.translate3(center[0], center[1], center[2]) * k3d.scale3(1)).column_major_values(): blobby.floats().append(i) # Add a segment to the blobby ... blobby.primitives().append(k3d.blobby.primitive_type.SEGMENT) blobby.primitive_first_floats().append(len(blobby.floats())) blobby.primitive_float_counts().append(23) blobby.floats().append(-1) blobby.floats().append(0) blobby.floats().append(0)
array_types = [ "k3d::bool_t", "k3d::color", "k3d::double_t", "k3d::imaterial*", "k3d::inode*", "k3d::int16_t", "k3d::int32_t", "k3d::int64_t", "k3d::int8_t", "k3d::matrix4", "k3d::normal3", "k3d::point2", "k3d::point3", "k3d::point4", "k3d::string_t", "k3d::texture3", "k3d::uint16_t", "k3d::uint32_t", "k3d::uint64_t", "k3d::uint8_t", "k3d::vector2", "k3d::vector3", "k3d::uint_t" ] array_values = [ True, k3d.color(1, 2, 3), 1.0, None, None, 1, 2, 3, 4, k3d.identity3(), k3d.normal3(1, 2, 3), k3d.point2(1, 2), k3d.point3(1, 2, 3), k3d.point4(1, 2, 3, 4), "A String", k3d.texture3(1, 2, 3), 1, 2, 3, 4, k3d.vector2(1, 2), k3d.vector3(1, 2, 3), 7 ] structure = primitive.structure().create("generic") attributes = primitive.attributes().create("generic") for i in range(len(array_types)): type = array_types[i] value = array_values[i] structure_array = structure.create(type, type) structure_array.append(value)
patches.patch_point_weights().append(0.5) patches.patch_point_weights().append(1) patches.patch_u_knots().append(1) patches.patch_u_knots().append(1) patches.patch_u_knots().append(1) patches.patch_u_knots().append(2) patches.patch_u_knots().append(2) patches.patch_u_knots().append(2) patches.patch_v_knots().append(1) patches.patch_v_knots().append(1) patches.patch_v_knots().append(2) patches.patch_v_knots().append(2) patches.patch_first_trim_loops().append(0) patches.patch_trim_loop_counts().append(0) # Cs.append(k3d.color(1, 0, 0)) # Cs.append(k3d.color(0, 1, 0)) # Cs.append(k3d.color(0, 0, 1)) # Cs.append(k3d.color(1, 1, 1)) positions = [(-5, 5, 5), (5, 5, 5), (5, 5, 10), (-5, -5, 5), (5, -5, 5), (5, -5, 10)] for position in positions: points.append( k3d.point3(position[0], position[1], position[2] + (i * -10))) point_selection.append(0.0)
frozen_mesh = k3d.plugin.create("FrozenMesh", context.document) frozen_mesh.name = function # Create a mesh ... mesh = frozen_mesh.create_mesh() # Add geometric points to the mesh ... points = mesh.create_points() point_selection = mesh.create_point_selection() for xi in range(0, xcount): for yi in range(0, ycount): x = mix(x1, x2, float(xi) / (xcount - 1)) y = mix(y1, y2, float(yi) / (ycount - 1)) z = eval(function) points.append(k3d.point3(x, y, z)) point_selection.append(0.0) # Create a particle primitive ... particles = k3d.particle.create(mesh) # Create a custom attribute array to control the widths of particles ... constantwidth = particles.constant_attributes().create( "constantwidth", "k3d::double_t") particles.material().append(None) constantwidth.append(0.2) for i in range(len(points)): particles.points().append(i)
source_a = k3d.plugin.create("FrozenMesh", document) source_b = k3d.plugin.create("FrozenMesh", document) mesh_a = source_a.create_mesh() mesh_b = source_b.create_mesh() test_equal(mesh_a, mesh_b, "empty meshes") points_a = mesh_a.create_points() test_unequal(mesh_a, mesh_b, "mesh without point array") points_b = mesh_b.create_points() test_equal(mesh_a, mesh_b, "meshes with empty point arrays") points_a.append(k3d.point3(1, 2, 3)) test_unequal(mesh_a, mesh_b, "mismatched point arrays") points_b.append(k3d.point3(1, 2, 3)) test_equal(mesh_a, mesh_b, "matched point arrays") primitive_a = mesh_a.primitives().create("foo") test_unequal(mesh_a, mesh_b, "mesh without primitive") primitive_b = mesh_b.primitives().create("foo") test_equal(mesh_a, mesh_b, "matched primitives") structure_a = primitive_a.structure().create("uniform") test_unequal(mesh_a, mesh_b, "primitive with missing structure") structure_b = primitive_b.structure().create("uniform")