Extruder.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Design
File: Extruder
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/Geometry.h>
#include <NDEVR/Plane.h>
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    Class: Extruder
 
    \brief Class containing static functions that define logic to extrude shapes along some given polyline
 
    Author: Tyler Parke
 
    Date: 2019-01-14
    **/
    class Extruder
    {
    public:
 
        /**--------------------------------------------------------------------------------------------------
                Given a linework geometry, extrudes a flat line alog the path in order to create a "ribbon" with a
        flat apperence and a thickness defined by geometryproperty Geometry::e_thickness
 
        Author: Tyler Parke
 
        Date: 2019-01-14
 
        Parameters:
        linework -  The linework whos geometrytype must be of type linework, and must have some valid > 0.0 real
        thickness. Upon completion of this function, the Solid index channel of this object will be filled with
        vertices and indices relating to the object's real thickness.
        **/
        static void ExtrudeRealThickness(Geometry& linework, const Matrix<fltp08>& transform = Matrix<fltp08>(1.0))
        {
            lib_assert(linework.getGeometryType() == GeometryType::e_linework, "Can only extrude thickness along geometry of type linework");
            fltp08 thickness = linework.getGeometryProperty<fltp08>(Geometry::e_thickness);
            lib_assert(!IsInvalid(thickness) && thickness > 0.0, "Thickness must be > 0.0");
            Polyline<3, fltp08> geo_line;//Stores the line we want to extrude along the path
            switch (linework.thicknessMode())
            {
            case Geometry::ThicknessMode::e_none:
            case Geometry::ThicknessMode::e_pixel:
                linework.setSolidVertexCountValue(0);
                linework.setPrimitiveMode(PrimitiveProperty::Solid, linework.mode(PrimitiveProperty::Outline));
                linework.setPrimitiveRange(PrimitiveProperty::Solid, linework.indexOffset(PrimitiveProperty::Outline), linework.primitiveCount(PrimitiveProperty::Outline));
                return;
            case Geometry::ThicknessMode::e_flat_per_vertex:
            case Geometry::ThicknessMode::e_flat_single:
                geo_line.add({ -thickness / 2.0, 0, 0 });
                geo_line.add({ thickness / 2.0, 0, 0 });
                break;
            case Geometry::ThicknessMode::e_circle_per_vertex:
            case Geometry::ThicknessMode::e_circle:
            {
                uint04 width_segments = 128;
                for (uint04 x = 0; x <= width_segments; x++)
                {
                    fltp08 u = cast<fltp08>(x) / cast<fltp08>(width_segments);
                    const Angle angle = u * Angle<fltp08>(DEGREES, 360.0f);
                    Vertex<3, fltp08> position(-thickness * cos(angle), thickness * sin(angle), 0.0);
                    geo_line.add(position);
 
                }
            } break;
            }
            
            
            ExtrudePolylineAlongGeo(linework, geo_line, transform);
        }
 
        /**--------------------------------------------------------------------------------------------------
                Given a linework geometry, extrudes the given polyline along that linework
 
        Author: Tyler Parke
 
        Date: 2019-01-14
 
        Parameters:
        linework -  The linework whos geometrytype must be of type linework and will store the extrusion.
        Upon completion of this function, the Solid index channel of this object will be filled with
        vertices and indices of the polyline extruded across the linework
        **/
        static void ExtrudePolylineAlongGeo(Geometry& linework, const Polyline<3, fltp08>& geo_line, const Matrix<fltp08>& transform = Matrix<fltp08>(1.0))
        {
            lib_assert(linework.getGeometryType() == GeometryType::e_linework, "Can only extrude thickness along geometry of type linework");
            
            Vector<3, fltp08> plane_normal = linework.getGeometryProperty<Vector<3, fltp08>>(Geometry::e_plane_normal);
            
                
 
            bool is_closed = linework.getGeometryProperty<bool>(Geometry::e_has_closed_primitive);
            Buffer<Polyline<3, fltp08>> polylines = linework.polylines<3, fltp08>(PrimitiveProperty::Outline, VertexProperty::Position);
            
            Buffer<Vector<3, uint04>> indices;
            Buffer<Vertex<3, fltp08>> vertices;
            Matrix<fltp08> poly_transform = (transform * linework.getTransform()).invert();
            //Extrude Shape
            for (uint04 i = 0; i < polylines.size(); i++)
            {
                polylines[i].simplify();
                Vector<3, fltp08> poly_normal = plane_normal;
                if (IsInvalid(poly_normal))
                {
                    Vector<3, fltp08> bounds = polylines[i].bounds().span();
                    if (bounds[X] * bounds[X] + bounds[Y] * bounds[Y] > bounds[Z] * bounds[Z])
                        poly_normal = { 0.0, 0.0, 1.0 };
                    else if (bounds[X] * bounds[X] > bounds[Y] * bounds[Y])
                        poly_normal = { 0.0, 1.0, 0.0 };
                    else
                        poly_normal = { 1.0, 0.0, 0.0 };
                }
                Extrude(indices, vertices, geo_line, polylines[i], poly_normal, is_closed, poly_transform);
            }
 
            //Add shape to Geometry
            uint04 solid_vertex_offset = linework.solidVertexOffset();
            if (IsInvalid(solid_vertex_offset))
            {
                solid_vertex_offset = linework.vertexCount();
                linework.setSolidVertexOffsetValue(solid_vertex_offset);
            }
            uint04 solid_vertex_size = linework.solidVertexReservedCount();
            if (solid_vertex_size < vertices.size())
            {
                linework.addVertices(solid_vertex_offset, vertices.size() - solid_vertex_size);
                linework.setSolidVertexReservedValue(vertices.size());
            }
            linework.setSolidVertexCountValue(vertices.size());
            for (uint04 i = 0; i < vertices.size(); i++)
            {
                linework.setVertex(VertexProperty::Position, solid_vertex_offset + i, vertices[i]);
            }
            uint04 index_offset = linework.primitiveIndexCount(PrimitiveProperty::Outline) + linework.indexOffset(PrimitiveProperty::Outline);
            linework.setPrimitiveMode(PrimitiveProperty::Solid, PrimitiveMode::e_triangle);
            linework.setPrimitiveRange(PrimitiveProperty::Solid, index_offset, indices.size());
            for (uint04 i = 0; i < indices.size(); i++)
            {
                linework.setPrimitive(PrimitiveProperty::Solid, i, solid_vertex_offset + indices[i]);
            }
            linework.updateVertexColumns();
            linework.updateSolidVertexColumns();
            linework.updatePrimitiveColumns();
            linework.updateModifiedTime();
        }
 
        /**--------------------------------------------------------------------------------------------------
        
        Given a linework geometry, extrudes a shape along the provided path to create a triangulated solid. 
        Note that the winding of the final shape will be the same as the given shape to extrude. Reversing 
        the vertices of this shape will reverse the winding order of the final solid. Note that passing a path
        which fully lies in plane whos normal is perpendicular to the given plane normal will result in undefined
        behavior
 
        Author: Tyler Parke
 
        Date: 2019-01-14
 
        Parameters:
        mesh -  The geometry which will store, in its solid index, the extruded shape.
        shape_to_extrude - The shape (Be it closed or not) to extrude.
        extrude_path - The path the shape will be extruded along. It is expected this path is 
        simplified (no 2 neighbor vertices are the same)
        plane_normal - The 'up' dirrection used to relate the path with the given shape to extrude. Generally 
        this vector is (0,0,1)
        is_path_closed - If the extrude path is closed (ie the last vertex in path should be connected to the
        first vertex in path)
        **/
        template<class t_type>
        static void Extrude(Buffer<Vector<3, uint04>>& indices
            , Buffer<Vertex<3, t_type>>& vertices
            , const Polyline<3, t_type>& shape_to_extrude
            , const Polyline<3, t_type>& extrude_path
            , const Vector<3, t_type>& plane_normal
            , bool is_path_closed
            , const Matrix<fltp08>& transform = Matrix<fltp08>(1.0))
        {
            if (extrude_path.vertexCount() <= 1)
                return;
            Buffer<Vector<3, t_type>> last(shape_to_extrude.vertexCount());//Stores the last vertices of the shape_to_extrude along the path
            Buffer<Vector<3, t_type>> current(shape_to_extrude.vertexCount());//Stores most recently calculated vertices of the shape_to_extrude along the path
            //Loop over each segment in the extrusion path, projecting the shape at each vertex and connecting the neighboring projections
            Ray<3, fltp08> last_right = Constant<Vector<3, fltp08>>::Invalid;
 
            for (uint04 i = 0; i < extrude_path.vertexCount(); i++)
            {
                current.clear();
                Vertex<3, t_type> offset = extrude_path.vertex(i);//This is the vertex we will draw our extrusion about
                bool greater_than_90_turn = false;
                if (!IsInvalid(offset))
                {
                    Ray<3, t_type> dir;//The direction vector of our proected shape
                    Ray<3, t_type> original_dir;//The original direction of the shape (Used to determine how curved something is)
                    if (is_path_closed && (i == 0 || i == extrude_path.segmentCount()))
                    {
                        //Since our path is closed, we will use the last segment as our -1 index segment in order to have 
                        // a properly curved solid
                        original_dir = extrude_path.segment(extrude_path.segmentCount() - 1).ray().template normalized<t_type>();
                        Vector<3, t_type> dir_2 = extrude_path.segment(0).ray().template normalized<t_type>();
                        dir = (dir_2 + original_dir).template normalized<t_type>();
                        greater_than_90_turn = dot(dir_2, original_dir) < 0;
                    }
                    else if (last.size() == 0)
                    {
                        //We have no last reference, meaning our path should be totally based on this line segment 
                        original_dir = extrude_path.segment(i).ray().template normalized<t_type>();
                        dir = original_dir;
                        
                    }
                    else if (i == extrude_path.segmentCount())
                    {
                        //We have no future reference, meaning our path should be totally based on the last line segment
                        original_dir = extrude_path.segment(i - 1).ray().template normalized<t_type>();
                        dir = original_dir;
                    }
                    else
                    {
                        //Normal case: We are at some center section, our path will be influenced by 3 vertices
                        original_dir = extrude_path.segment(i - 1).ray().template normalized<t_type>();
                        Vector<3, t_type> dir_2 = extrude_path.segment(i).ray().template normalized<t_type>();
                        dir = (dir_2 + original_dir).template normalized<t_type>();
                        greater_than_90_turn = dot(dir_2, original_dir) < 0;
                        
                    }
                    //If the segment has 0 length, then we will either be undefined or have a 0 magnitude. 
 
                    if (dir.template magnitude<fltp08>() == 0.0 || IsInvalid(dir))
                    {
                        //lib_assert(false, "Encountered a zero length polyline. Please call simplify on the extrusion path prior to pass it to this function");
                        continue;
                    }
                    //This vector points to the right of the extrusion path segment
                    Ray<3, t_type> right = cross(dir, plane_normal).template normalized<t_type>();
                    
                    if (IsInvalid(right))//Handle Vertical segments
                    {
                        if (IsInvalid(last_right))
                        {
                            right = Ray<3, fltp08>(plane_normal[Y], plane_normal[Z], plane_normal[X]);
                        }
                        else
                        {
                            right = last_right;
                        }
                        //TODO: right may be undefined if dir is along the plane normal, in which case we need to do 
                        //a look ahead, and look behind to determine a suitable interpolated right vector.
                    }
                    last_right = right;
 
                    //This vector points 'up' from the extrusion path segment
                    //const Vertex<3, t_type> up = cross(dir, right).normalized<t_type>();
                    const Ray<3, fltp08> up = cross(dir, right).template normalized<fltp08>();
                    
                    //Depending on how much our line curves, we need to project outward further. For example, a 90 degree turn requires
                    // our projected point to go out sqrt(orginal_distance^2+orginal_distance^2) in distance in addition to the original distance
                    const t_type p_off_original = cast<t_type>(1.0) - dot(dir, original_dir) * dot(dir, original_dir);
 
                    t_type extra_distance = sqrt(4 * p_off_original * p_off_original + 1.0);
                    if (greater_than_90_turn)
                        extra_distance = 2.0 / extra_distance;
                    
                    //loop over our shape to extrude, marking the points
                    for (const auto& vertex : shape_to_extrude)
                    {
                        Ray<3, t_type> projection;//This is the vertex on the shape to extrude, projected out via line direction
                        projection += vertex[X] * right;
                        projection += vertex[Y] * up;
                        projection += vertex[Z] * dir;
                        projection = projection.template normalized<fltp08>();
                        projection = (transform * projection) * vertex.template magnitude<fltp08>();
                        current.add((extra_distance * projection) + offset);
                    }
                    //Ensure that we have added vertices to this path before
                    if (last.size() > 0)
                    {
                        for (uint04 n = 0; n < shape_to_extrude.vertexCount() - 1; n++)
                        {
                            //Create a quad in the shape that connects the corrosponding segments. Note that this
                            //function also handles degenerate quads which may occur given sharp corners in the extrusion path.
                            indices.add(vertices.size() + Vector<3, uint04>(0, 1, 2));
                            indices.add(vertices.size() + Vector<3, uint04>(0, 2, 3));
                            vertices.add(last[n]);
                            vertices.add(current[n]);
                            vertices.add(current[n + 1]);
                            vertices.add(last[n + 1]);
                        }
                    }
                }
                last = current;
            }
        }
    };
}