Extruder.h

/*--------------------------------------------------------------------------------------------
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
    {
    public:

        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.get<NDPG::thickness>();
            lib_assert(IsValid(thickness) && thickness > 0.0, "Thickness must be > 0.0");
            Polyline<3, fltp08> geo_line;
            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);
        }

        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.get<Vector<3, fltp08>>(NDPG::plane_normal);
 
 
 
            bool is_closed = linework.get<NDPG::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.get<NDPO::transform>()).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();
        }

        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());
            Buffer<Vector<3, t_type>> current(shape_to_extrude.vertexCount());
            //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);
                bool greater_than_90_turn = false;
                if (IsValid(offset))
                {
                    Ray<3, t_type> dir;
                    Ray<3, t_type> original_dir;
                    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;
                        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;
            }
        }
    };
}