Class ParShapes


  • public class ParShapes
    extends java.lang.Object
    Bindings to par_shapes.h, a simple C library for creation and manipulation of triangle meshes.

    The par_shapes API is divided into three sections:

    • Generators - Create parametric surfaces, platonic solids, etc.
    • Queries - Ask a mesh for its axis-aligned bounding box, etc.
    • Transforms - Rotate a mesh, merge it with another, add normals, etc.

    For our purposes, a "mesh" is a list of points and a list of triangles; the former is a flattened list of three-tuples (32-bit floats) and the latter is also a flattened list of three-tuples (16-bit uints). Triangles are always oriented such that their front face winds counter-clockwise.

    Depending on which generator function is used, meshes may or may not contain normals and texture coordinates (one per vertex).

    • Method Detail

      • npar_shapes_free_mesh

        public static void npar_shapes_free_mesh​(long mesh)
        Unsafe version of: free_mesh
      • par_shapes_free_mesh

        public static void par_shapes_free_mesh​(ParShapesMesh mesh)
        Frees the specified ParShapesMesh structure.
        Parameters:
        mesh - the mesh to free
      • npar_shapes_create_cylinder

        public static long npar_shapes_create_cylinder​(int slices,
                                                       int stacks)
        Unsafe version of: create_cylinder
      • par_shapes_create_cylinder

        @Nullable
        public static ParShapesMesh par_shapes_create_cylinder​(int slices,
                                                               int stacks)
        Creates a cylinder that sits on the Z=0 plane using the given tessellation levels across the UV domain. Think of "slices" like a number of pizza slices, and "stacks" like a number of stacked rings. Height and radius are both 1.0, but they can easily be changed with scale.
        Parameters:
        slices - the number of slices
        stacks - the number of stacks
      • npar_shapes_create_cone

        public static long npar_shapes_create_cone​(int slices,
                                                   int stacks)
        Unsafe version of: create_cone
      • par_shapes_create_cone

        @Nullable
        public static ParShapesMesh par_shapes_create_cone​(int slices,
                                                           int stacks)
        Creates a cone similar to create_cylinder but the radius diminishes to zero as Z increases. Again, height and radius are 1.0, but can be changed with scale.
        Parameters:
        slices - the number of slices
        stacks - the number of stacks
      • npar_shapes_create_parametric_disk

        public static long npar_shapes_create_parametric_disk​(int slices,
                                                              int stacks)
        Unsafe version of: create_parametric_disk
      • par_shapes_create_parametric_disk

        @Nullable
        public static ParShapesMesh par_shapes_create_parametric_disk​(int slices,
                                                                      int stacks)
        Creates a disk of radius 1.0 with texture coordinates and normals by squashing a cone flat on the Z=0 plane.
        Parameters:
        slices - the number of slices
        stacks - the number of stacks
      • npar_shapes_create_torus

        public static long npar_shapes_create_torus​(int slices,
                                                    int stacks,
                                                    float radius)
        Unsafe version of: create_torus
      • par_shapes_create_torus

        @Nullable
        public static ParShapesMesh par_shapes_create_torus​(int slices,
                                                            int stacks,
                                                            float radius)
        Creates a donut that sits on the Z=0 plane with the specified inner radius. The outer radius can be controlled with scale.
        Parameters:
        slices - the number of slices
        stacks - the number of stacks
        radius - the torus radius
      • npar_shapes_create_parametric_sphere

        public static long npar_shapes_create_parametric_sphere​(int slices,
                                                                int stacks)
        Unsafe version of: create_parametric_sphere
      • par_shapes_create_parametric_sphere

        @Nullable
        public static ParShapesMesh par_shapes_create_parametric_sphere​(int slices,
                                                                        int stacks)
        Creates a sphere with texture coordinates and small triangles near the poles.
        Parameters:
        slices - the number of slices
        stacks - the number of stacks
      • npar_shapes_create_subdivided_sphere

        public static long npar_shapes_create_subdivided_sphere​(int nsubdivisions)
        Unsafe version of: create_subdivided_sphere
      • par_shapes_create_subdivided_sphere

        @Nullable
        public static ParShapesMesh par_shapes_create_subdivided_sphere​(int nsubdivisions)
        Approximates a sphere with a subdivided icosahedron, which produces a nice distribution of triangles, but no texture coordinates. Each subdivision level scales the number of triangles by four, so use a very low number.
        Parameters:
        nsubdivisions - the number of subdivisions
      • npar_shapes_create_klein_bottle

        public static long npar_shapes_create_klein_bottle​(int slices,
                                                           int stacks)
        Unsafe version of: create_klein_bottle
      • par_shapes_create_klein_bottle

        @Nullable
        public static ParShapesMesh par_shapes_create_klein_bottle​(int slices,
                                                                   int stacks)
        Creates a klein bottle mesh.
        Parameters:
        slices - the number of slices
        stacks - the number of stacks
      • npar_shapes_create_trefoil_knot

        public static long npar_shapes_create_trefoil_knot​(int slices,
                                                           int stacks,
                                                           float radius)
        Unsafe version of: create_trefoil_knot
      • par_shapes_create_trefoil_knot

        @Nullable
        public static ParShapesMesh par_shapes_create_trefoil_knot​(int slices,
                                                                   int stacks,
                                                                   float radius)
        Creates a trefoil knot mesh.
        Parameters:
        slices - the number of slices
        stacks - the number of stacks
      • npar_shapes_create_hemisphere

        public static long npar_shapes_create_hemisphere​(int slices,
                                                         int stacks)
        Unsafe version of: create_hemisphere
      • par_shapes_create_hemisphere

        @Nullable
        public static ParShapesMesh par_shapes_create_hemisphere​(int slices,
                                                                 int stacks)
        Creates a hemisphere mesh.
        Parameters:
        slices - the number of slices
        stacks - the number of stacks
      • npar_shapes_create_plane

        public static long npar_shapes_create_plane​(int slices,
                                                    int stacks)
        Unsafe version of: create_plane
      • par_shapes_create_plane

        @Nullable
        public static ParShapesMesh par_shapes_create_plane​(int slices,
                                                            int stacks)
        Creates a plane mesh.
        Parameters:
        slices - the number of slices
        stacks - the number of stacks
      • npar_shapes_create_icosahedron

        public static long npar_shapes_create_icosahedron()
        Unsafe version of: create_icosahedron
      • par_shapes_create_icosahedron

        @Nullable
        public static ParShapesMesh par_shapes_create_icosahedron()
        Generates points for a 20-sided polyhedron that fits in the unit sphere. Texture coordinates and normals are not generated.
      • npar_shapes_create_dodecahedron

        public static long npar_shapes_create_dodecahedron()
        Unsafe version of: create_dodecahedron
      • par_shapes_create_dodecahedron

        @Nullable
        public static ParShapesMesh par_shapes_create_dodecahedron()
        Generates points for a 12-sided polyhedron that fits in the unit sphere. Texture coordinates and normals are not generated.
      • npar_shapes_create_octahedron

        public static long npar_shapes_create_octahedron()
        Unsafe version of: create_octahedron
      • par_shapes_create_octahedron

        @Nullable
        public static ParShapesMesh par_shapes_create_octahedron()
        Generates points for an 8-sided polyhedron that fits in the unit sphere. Texture coordinates and normals are not generated.
      • npar_shapes_create_tetrahedron

        public static long npar_shapes_create_tetrahedron()
        Unsafe version of: create_tetrahedron
      • par_shapes_create_tetrahedron

        @Nullable
        public static ParShapesMesh par_shapes_create_tetrahedron()
        Generates points for a 4-sided polyhedron that fits in the unit sphere. Texture coordinates and normals are not generated.
      • npar_shapes_create_cube

        public static long npar_shapes_create_cube()
        Unsafe version of: create_cube
      • par_shapes_create_cube

        @Nullable
        public static ParShapesMesh par_shapes_create_cube()
        Generates points for a cube that fits in the unit sphere. Texture coordinates and normals are not generated.
      • npar_shapes_create_disk

        public static long npar_shapes_create_disk​(float radius,
                                                   int slices,
                                                   long center,
                                                   long normal)
        Unsafe version of: create_disk
      • par_shapes_create_disk

        @Nullable
        public static ParShapesMesh par_shapes_create_disk​(float radius,
                                                           int slices,
                                                           java.nio.FloatBuffer center,
                                                           java.nio.FloatBuffer normal)
        Generates an orientable disk shape in 3-space. Does not include normals or texture coordinates.
        Parameters:
        radius - the disk radius
        slices - the number of slices
        center - the disk center
        normal - the disk normal
      • npar_shapes_create_empty

        public static long npar_shapes_create_empty()
        Unsafe version of: create_empty
      • par_shapes_create_empty

        @Nullable
        public static ParShapesMesh par_shapes_create_empty()
        Creates an empty shape. Useful for building scenes with merge_and_free.
      • npar_shapes_create_rock

        public static long npar_shapes_create_rock​(int seed,
                                                   int nsubdivisions)
        Unsafe version of: create_rock
      • par_shapes_create_rock

        @Nullable
        public static ParShapesMesh par_shapes_create_rock​(int seed,
                                                           int nsubdivisions)
        Generates a rock shape that sits on the Y=0 plane, and sinks into it a bit. This includes smooth normals but no texture coordinates. Each subdivision level scales the number of triangles by four, so use a very low number.
        Parameters:
        seed - a seed value
        nsubdivisions - the number of subdivisions
      • npar_shapes_create_lsystem

        public static long npar_shapes_create_lsystem​(long program,
                                                      int slices,
                                                      int maxdepth,
                                                      long rand_fn,
                                                      long context)
        Unsafe version of: create_lsystem
      • par_shapes_create_lsystem

        @Nullable
        public static ParShapesMesh par_shapes_create_lsystem​(java.nio.ByteBuffer program,
                                                              int slices,
                                                              int maxdepth,
                                                              @Nullable
                                                              ParShapesRandFnI rand_fn,
                                                              long context)
        
        @Nullable
        public static ParShapesMesh par_shapes_create_lsystem​(java.lang.CharSequence program,
                                                              int slices,
                                                              int maxdepth,
                                                              @Nullable
                                                              ParShapesRandFnI rand_fn,
                                                              long context)
        
        Creates trees or vegetation by executing a recursive turtle graphics program.

        The program is a list of command-argument pairs. See the unit test for an example. Texture coordinates and normals are not generated.

        Parameters:
        program - the list of command-argument pairs
        slices - the number of slices
        maxdepth - the maximum depth
        rand_fn - is expected to return a value between 0 and 1, or can be NULL (in which case (float) rand() / RAND_MAX will be used)
        context - passed unmodified to rand_fn
      • npar_shapes_export

        public static void npar_shapes_export​(long mesh,
                                              long objfile)
        Unsafe version of: export
      • par_shapes_export

        public static void par_shapes_export​(ParShapesMesh mesh,
                                             java.nio.ByteBuffer objfile)
        
        public static void par_shapes_export​(ParShapesMesh mesh,
                                             java.lang.CharSequence objfile)
        
        Dumps out a text file conforming to the venerable OBJ format.
        Parameters:
        mesh - the mesh to export
        objfile - the OBJ file path
      • npar_shapes_compute_aabb

        public static void npar_shapes_compute_aabb​(long mesh,
                                                    long aabb)
        Unsafe version of: compute_aabb
      • par_shapes_compute_aabb

        public static void par_shapes_compute_aabb​(ParShapesMesh mesh,
                                                   java.nio.FloatBuffer aabb)
        Takes a pointer to 6 floats and sets them to min xyz, max xyz.
        Parameters:
        mesh - the mesh to query
        aabb - a pointer to an array of 6 floats in which the AABB will be written
      • npar_shapes_clone

        public static long npar_shapes_clone​(long mesh,
                                             long target)
        Unsafe version of: clone
      • par_shapes_clone

        @Nullable
        public static ParShapesMesh par_shapes_clone​(ParShapesMesh mesh,
                                                     @Nullable
                                                     ParShapesMesh target)
        Makes a deep copy of a mesh. To make a brand new copy, pass NULL to target. To avoid memory churn, pass an existing mesh to target.
        Parameters:
        mesh - the mesh to copy
        target - the target mesh
      • npar_shapes_merge

        public static void npar_shapes_merge​(long dst,
                                             long src)
        Unsafe version of: merge
      • par_shapes_merge

        public static void par_shapes_merge​(ParShapesMesh dst,
                                            ParShapesMesh src)
        Merges two shapes.
        Parameters:
        dst - the destination mesh
        src - the source mesh
      • npar_shapes_translate

        public static void npar_shapes_translate​(long mesh,
                                                 float x,
                                                 float y,
                                                 float z)
        Unsafe version of: translate
      • par_shapes_translate

        public static void par_shapes_translate​(ParShapesMesh mesh,
                                                float x,
                                                float y,
                                                float z)
        Translates the specified mesh.
        Parameters:
        mesh - the mesh to translate
        x - the X axis translation amount
        y - the Y axis translation amount
        z - the Z axis translation amount
      • npar_shapes_rotate

        public static void npar_shapes_rotate​(long mesh,
                                              float radians,
                                              long axis)
        Unsafe version of: rotate
      • par_shapes_rotate

        public static void par_shapes_rotate​(ParShapesMesh mesh,
                                             float radians,
                                             java.nio.FloatBuffer axis)
        Rotates the specified mesh.
        Parameters:
        mesh - the mesh to rotate
        radians - the rotation angle, in radians
        axis - the rotation axis
      • npar_shapes_scale

        public static void npar_shapes_scale​(long mesh,
                                             float x,
                                             float y,
                                             float z)
        Unsafe version of: scale
      • par_shapes_scale

        public static void par_shapes_scale​(ParShapesMesh mesh,
                                            float x,
                                            float y,
                                            float z)
        Scales the specified mesh.
        Parameters:
        mesh - the mesh to scale
        x - the X axis scale factor
        y - the Y axis scale factor
        z - the Z axis scale factor
      • npar_shapes_merge_and_free

        public static void npar_shapes_merge_and_free​(long dst,
                                                      long src)
        Unsafe version of: merge_and_free
      • par_shapes_merge_and_free

        public static void par_shapes_merge_and_free​(ParShapesMesh dst,
                                                     ParShapesMesh src)
        Merges two shapes and frees the source shape.
        Parameters:
        dst - the destination mesh
        src - the source mesh
      • npar_shapes_invert

        public static void npar_shapes_invert​(long mesh,
                                              int startface,
                                              int nfaces)
        Unsafe version of: invert
      • par_shapes_invert

        public static void par_shapes_invert​(ParShapesMesh mesh,
                                             int startface,
                                             int nfaces)
        Reverses the winding of a run of faces. Useful when drawing the inside of a Cornell Box. Pass 0 for nfaces to reverse every face in the mesh.
        Parameters:
        mesh - the mesh to reverse
        startface - the index of the first face to reverse
        nfaces - the number of faces to reverse
      • npar_shapes_remove_degenerate

        public static void npar_shapes_remove_degenerate​(long mesh,
                                                         float minarea)
        Unsafe version of: remove_degenerate
      • par_shapes_remove_degenerate

        public static void par_shapes_remove_degenerate​(ParShapesMesh mesh,
                                                        float minarea)
        Removes all triangles whose area is less than minarea.
        Parameters:
        mesh - the mesh to cleanup
        minarea - triangles with an area below this value will be removed
      • npar_shapes_unweld

        public static void npar_shapes_unweld​(long mesh,
                                              boolean create_indices)
        Unsafe version of: unweld
      • par_shapes_unweld

        public static void par_shapes_unweld​(ParShapesMesh mesh,
                                             boolean create_indices)
        Dereferences the entire index buffer and replaces the point list.

        This creates an inefficient structure, but is useful for drawing facets. If create_indices is true, a trivial "0 1 2 3..." index buffer is generated.

        Parameters:
        mesh - the mesh to unweld
        create_indices - if an index buffer should be generated
      • npar_shapes_weld

        public static long npar_shapes_weld​(long mesh,
                                            float epsilon,
                                            long mapping)
        Unsafe version of: weld
      • par_shapes_weld

        @Nullable
        public static ParShapesMesh par_shapes_weld​(ParShapesMesh mesh,
                                                    float epsilon,
                                                    @Nullable
                                                    java.nio.IntBuffer mapping)
        Merges colocated verts, builds a new index buffer, and returns the optimized mesh.
        Parameters:
        mesh - the mesh to weld
        epsilon - the maximum distance to consider when welding vertices
        mapping - null, or a pointer to npoints 32-bit integers, which gets filled with the mapping from old vertex indices to new indices
      • npar_shapes_compute_normals

        public static void npar_shapes_compute_normals​(long mesh)
        Unsafe version of: compute_normals
      • par_shapes_compute_normals

        public static void par_shapes_compute_normals​(ParShapesMesh mesh)
        Computes smooth normals by averaging adjacent facet normals.
        Parameters:
        mesh - the mesh
      • par_shapes_set_epsilon_welded_normals

        public static void par_shapes_set_epsilon_welded_normals​(float epsilon)
      • par_shapes_set_epsilon_degenerate_sphere

        public static void par_shapes_set_epsilon_degenerate_sphere​(float epsilon)
      • npar_shapes__compute_welded_normals

        public static void npar_shapes__compute_welded_normals​(long m)
      • par_shapes__compute_welded_normals

        public static void par_shapes__compute_welded_normals​(ParShapesMesh m)
      • npar_shapes__connect

        public static void npar_shapes__connect​(long scene,
                                                long cylinder,
                                                int slices)
      • par_shapes_create_disk

        @Nullable
        public static ParShapesMesh par_shapes_create_disk​(float radius,
                                                           int slices,
                                                           float[] center,
                                                           float[] normal)
        Array version of: create_disk
      • par_shapes_compute_aabb

        public static void par_shapes_compute_aabb​(ParShapesMesh mesh,
                                                   float[] aabb)
        Array version of: compute_aabb
      • par_shapes_rotate

        public static void par_shapes_rotate​(ParShapesMesh mesh,
                                             float radians,
                                             float[] axis)
        Array version of: rotate
      • par_shapes_weld

        @Nullable
        public static ParShapesMesh par_shapes_weld​(ParShapesMesh mesh,
                                                    float epsilon,
                                                    @Nullable
                                                    int[] mapping)
        Array version of: weld