Class ParShapes


  • public class ParShapes
    extends java.lang.Object
    Bindings to par_shapes.h, a single-file, zero-dependency, C99 library that can generate simple shapes and perform basic operations on them. These operations include:
    • Applying affine transformations
    • Computing surface normals
    • Welding colocated vertices

    The library provides a set of functions that populate fields of the ParShapesMesh structure.

    The normals and tcoords fields might be null, but every other field is guaranteed to have valid values. This mesh representation is very limited: indices must be unsigned 32-bit integers, points must be three-tuples, and there is no support for face-varying data.

    When you’re done extracting the data you need from the mesh, be sure to free it:

    
     par_shapes_mesh* m = par_shapes_create_subdivided_sphere(1);
     // ...
     par_shapes_free_mesh(m);
    • 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_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)
        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
        public static ParShapesMesh par_shapes_create_lsystem​(java.lang.CharSequence program,
                                                              int slices,
                                                              int maxdepth)
        
        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
      • 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_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