--- a/hostsupport/hostopenvg/src/src/riPath.cpp Wed Oct 06 17:59:01 2010 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,2779 +0,0 @@
-/*------------------------------------------------------------------------
- *
- * OpenVG 1.1 Reference Implementation
- * -----------------------------------
- *
- * Copyright (c) 2007 The Khronos Group Inc.
- * Portions copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and /or associated documentation files
- * (the "Materials "), to deal in the Materials without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Materials,
- * and to permit persons to whom the Materials are furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Materials.
- *
- * THE MATERIALS ARE 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 MATERIALS OR
- * THE USE OR OTHER DEALINGS IN THE MATERIALS.
- *
- *//**
- * \file
- * \brief Implementation of Path functions.
- * \note
- *//*-------------------------------------------------------------------*/
-
-#include "riPath.h"
-
-//==============================================================================================
-
-
-//==============================================================================================
-
-namespace OpenVGRI
-{
-
-RIfloat inputFloat(VGfloat f); //defined in riApi.cpp
-
-/*-------------------------------------------------------------------*//*!
-* \brief Form a reliable normalized average of the two unit input vectors.
-* The average always lies to the given direction from the first
-* vector.
-* \param u0, u1 Unit input vectors.
-* \param cw True if the average should be clockwise from u0, false if
-* counterclockwise.
-* \return Average of the two input vectors.
-* \note
-*//*-------------------------------------------------------------------*/
-
-static const Vector2 unitAverage(const Vector2& u0, const Vector2& u1, bool cw)
-{
- Vector2 u = 0.5f * (u0 + u1);
- Vector2 n0 = perpendicularCCW(u0);
-
- if( dot(u, u) > 0.25f )
- { //the average is long enough and thus reliable
- if( dot(n0, u1) < 0.0f )
- u = -u; //choose the larger angle
- }
- else
- { // the average is too short, use the average of the normals to the vectors instead
- Vector2 n1 = perpendicularCW(u1);
- u = 0.5f * (n0 + n1);
- }
- if( cw )
- u = -u;
-
- return normalize(u);
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Form a reliable normalized average of the two unit input vectors.
-* The average lies on the side where the angle between the input
-* vectors is less than 180 degrees.
-* \param u0, u1 Unit input vectors.
-* \return Average of the two input vectors.
-* \note
-*//*-------------------------------------------------------------------*/
-
-static const Vector2 unitAverage(const Vector2& u0, const Vector2& u1)
-{
- Vector2 u = 0.5f * (u0 + u1);
-
- if( dot(u, u) < 0.25f )
- { // the average is unreliable, use the average of the normals to the vectors instead
- Vector2 n0 = perpendicularCCW(u0);
- Vector2 n1 = perpendicularCW(u1);
- u = 0.5f * (n0 + n1);
- if( dot(n1, u0) < 0.0f )
- u = -u;
- }
-
- return normalize(u);
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Interpolate the given unit tangent vectors to the given
-* direction on a unit circle.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-static const Vector2 circularLerp(const Vector2& t0, const Vector2& t1, RIfloat ratio, bool cw)
-{
- Vector2 u0 = t0, u1 = t1;
- RIfloat l0 = 0.0f, l1 = 1.0f;
- for(int i=0;i<18;i++)
- {
- Vector2 n = unitAverage(u0, u1, cw);
- RIfloat l = 0.5f * (l0 + l1);
- if( ratio < l )
- {
- u1 = n;
- l1 = l;
- }
- else
- {
- u0 = n;
- l0 = l;
- }
- }
- return u0;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Interpolate the given unit tangent vectors on a unit circle.
-* Smaller angle between the vectors is used.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-static const Vector2 circularLerp(const Vector2& t0, const Vector2& t1, RIfloat ratio)
-{
- Vector2 u0 = t0, u1 = t1;
- RIfloat l0 = 0.0f, l1 = 1.0f;
- for(int i=0;i<18;i++)
- {
- Vector2 n = unitAverage(u0, u1);
- RIfloat l = 0.5f * (l0 + l1);
- if( ratio < l )
- {
- u1 = n;
- l1 = l;
- }
- else
- {
- u0 = n;
- l0 = l;
- }
- }
- return u0;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Path constructor.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-Path::Path(VGint format, VGPathDatatype datatype, RIfloat scale, RIfloat bias, int segmentCapacityHint, int coordCapacityHint, VGbitfield caps) :
- m_format(format),
- m_datatype(datatype),
- m_scale(scale),
- m_bias(bias),
- m_capabilities(caps),
- m_referenceCount(0),
- m_segments(),
- m_data(),
- m_vertices(),
- m_segmentToVertex(),
- m_userMinx(0.0f),
- m_userMiny(0.0f),
- m_userMaxx(0.0f),
- m_userMaxy(0.0f)
-{
- RI_ASSERT(format == VG_PATH_FORMAT_STANDARD);
- RI_ASSERT(datatype >= VG_PATH_DATATYPE_S_8 && datatype <= VG_PATH_DATATYPE_F);
- if(segmentCapacityHint > 0)
- m_segments.reserve(RI_INT_MIN(segmentCapacityHint, 65536));
- if(coordCapacityHint > 0)
- m_data.reserve(RI_INT_MIN(coordCapacityHint, 65536) * getBytesPerCoordinate(datatype));
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Path destructor.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-Path::~Path()
-{
- RI_ASSERT(m_referenceCount == 0);
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Reads a coordinate and applies scale and bias.
-* \param
-* \return
-*//*-------------------------------------------------------------------*/
-
-RIfloat Path::getCoordinate(int i) const
-{
- RI_ASSERT(i >= 0 && i < m_data.size() / getBytesPerCoordinate(m_datatype));
- RI_ASSERT(m_scale != 0.0f);
-
- const RIuint8* ptr = &m_data[0];
- switch(m_datatype)
- {
- case VG_PATH_DATATYPE_S_8:
- return (RIfloat)(((const RIint8*)ptr)[i]) * m_scale + m_bias;
-
- case VG_PATH_DATATYPE_S_16:
- return (RIfloat)(((const RIint16*)ptr)[i]) * m_scale + m_bias;
-
- case VG_PATH_DATATYPE_S_32:
- return (RIfloat)(((const RIint32*)ptr)[i]) * m_scale + m_bias;
-
- default:
- RI_ASSERT(m_datatype == VG_PATH_DATATYPE_F);
- return (RIfloat)(((const RIfloat32*)ptr)[i]) * m_scale + m_bias;
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Writes a coordinate, subtracting bias and dividing out scale.
-* \param
-* \return
-* \note If the coordinates do not fit into path datatype range, they
-* will overflow silently.
-*//*-------------------------------------------------------------------*/
-
-void Path::setCoordinate(Array<RIuint8>& data, VGPathDatatype datatype, RIfloat scale, RIfloat bias, int i, RIfloat c)
-{
- RI_ASSERT(i >= 0 && i < data.size()/getBytesPerCoordinate(datatype));
- RI_ASSERT(!RI_ISNAN(scale));
- RI_ASSERT(!RI_ISNAN(bias));
- RI_ASSERT(scale != 0.0f);
-
- c = inputFloat(c); // Revalidate: Can happen when a coordinate has been transformed.
- c -= bias;
- c /= scale;
-
- RI_ASSERT(!RI_ISNAN(c));
-
- RIuint8* ptr = &data[0];
- switch(datatype)
- {
- case VG_PATH_DATATYPE_S_8:
- ((RIint8*)ptr)[i] = (RIint8)floor(c + 0.5f); //add 0.5 for correct rounding
- break;
-
- case VG_PATH_DATATYPE_S_16:
- ((RIint16*)ptr)[i] = (RIint16)floor(c + 0.5f); //add 0.5 for correct rounding
- break;
-
- case VG_PATH_DATATYPE_S_32:
- ((RIint32*)ptr)[i] = (RIint32)floor(c + 0.5f); //add 0.5 for correct rounding
- break;
-
- default:
- RI_ASSERT(datatype == VG_PATH_DATATYPE_F);
- ((RIfloat32*)ptr)[i] = (RIfloat32)c;
- break;
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Given a datatype, returns the number of bytes per coordinate.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-int Path::getBytesPerCoordinate(VGPathDatatype datatype)
-{
- if(datatype == VG_PATH_DATATYPE_S_8)
- return 1;
- if(datatype == VG_PATH_DATATYPE_S_16)
- return 2;
- RI_ASSERT(datatype == VG_PATH_DATATYPE_S_32 || datatype == VG_PATH_DATATYPE_F);
- return 4;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Given a path segment type, returns the number of coordinates
-* it uses.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-int Path::segmentToNumCoordinates(VGPathSegment segment)
-{
- RI_ASSERT(((int)segment >> 1) >= 0 && ((int)segment >> 1) <= 12);
- static const int coords[13] = {0,2,2,1,1,4,6,2,4,5,5,5,5};
- return coords[(int)segment >> 1];
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Computes the number of coordinates a segment sequence uses.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-int Path::countNumCoordinates(const RIuint8* segments, int numSegments)
-{
- RI_ASSERT(segments);
- RI_ASSERT(numSegments >= 0);
-
- int coordinates = 0;
- for(int i=0;i<numSegments;i++)
- coordinates += segmentToNumCoordinates(getPathSegment(segments[i]));
- return coordinates;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Clears path segments and data, and resets capabilities.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Path::clear(VGbitfield capabilities)
-{
- m_segments.clear();
- m_data.clear();
- m_capabilities = capabilities;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Appends user segments and data.
-* \param
-* \return
-* \note if runs out of memory, throws bad_alloc and leaves the path as it was
-*//*-------------------------------------------------------------------*/
-
-void Path::appendData(const RIuint8* segments, int numSegments, const RIuint8* data)
-{
- RI_ASSERT(numSegments > 0);
- RI_ASSERT(segments && data);
- RI_ASSERT(m_referenceCount > 0);
-
- //allocate new arrays
- int oldSegmentsSize = m_segments.size();
- int newSegmentsSize = oldSegmentsSize + numSegments;
- Array<RIuint8> newSegments;
- newSegments.resize(newSegmentsSize); //throws bad_alloc
-
- int newCoords = countNumCoordinates(segments, numSegments);
- int bytesPerCoordinate = getBytesPerCoordinate(m_datatype);
- int newDataSize = m_data.size() + newCoords * bytesPerCoordinate;
- Array<RIuint8> newData;
- newData.resize(newDataSize); //throws bad_alloc
- //if we get here, the memory allocations have succeeded
-
- //copy old segments and append new ones
- if(m_segments.size())
- ri_memcpy(&newSegments[0], &m_segments[0], m_segments.size());
- ri_memcpy(&newSegments[0] + m_segments.size(), segments, numSegments);
-
- //copy old data and append new ones
- if(newData.size())
- {
- if(m_data.size())
- ri_memcpy(&newData[0], &m_data[0], m_data.size());
- if(m_datatype == VG_PATH_DATATYPE_F)
- {
- RIfloat32* d = (RIfloat32*)(&newData[0] + m_data.size());
- const RIfloat32* s = (const RIfloat32*)data;
- for(int i=0;i<newCoords;i++)
- *d++ = (RIfloat32)inputFloat(*s++);
- }
- else
- {
- ri_memcpy(&newData[0] + m_data.size(), data, newCoords * bytesPerCoordinate);
- }
- }
-
- RI_ASSERT(newData.size() == countNumCoordinates(&newSegments[0],newSegments.size()) * getBytesPerCoordinate(m_datatype));
-
- //replace old arrays
- m_segments.swap(newSegments);
- m_data.swap(newData);
-
- int c = 0;
- for(int i=0;i<m_segments.size();i++)
- {
- VGPathSegment segment = getPathSegment(m_segments[i]);
- int coords = segmentToNumCoordinates(segment);
- c += coords;
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Appends a path.
-* \param
-* \return
-* \note if runs out of memory, throws bad_alloc and leaves the path as it was
-*//*-------------------------------------------------------------------*/
-
-void Path::append(const Path* srcPath)
-{
- RI_ASSERT(srcPath);
- RI_ASSERT(m_referenceCount > 0 && srcPath->m_referenceCount > 0);
-
- if(srcPath->m_segments.size())
- {
- //allocate new arrays
- int newSegmentsSize = m_segments.size() + srcPath->m_segments.size();
- Array<RIuint8> newSegments;
- newSegments.resize(newSegmentsSize); //throws bad_alloc
-
- int newDataSize = m_data.size() + srcPath->getNumCoordinates() * getBytesPerCoordinate(m_datatype);
- Array<RIuint8> newData;
- newData.resize(newDataSize); //throws bad_alloc
- //if we get here, the memory allocations have succeeded
-
- //copy old segments and append new ones
- if(m_segments.size())
- ri_memcpy(&newSegments[0], &m_segments[0], m_segments.size());
- if(srcPath->m_segments.size())
- ri_memcpy(&newSegments[0] + m_segments.size(), &srcPath->m_segments[0], srcPath->m_segments.size());
-
- //copy old data and append new ones
- if(m_data.size())
- ri_memcpy(&newData[0], &m_data[0], m_data.size());
- for(int i=0;i<srcPath->getNumCoordinates();i++)
- setCoordinate(newData, m_datatype, m_scale, m_bias, i + getNumCoordinates(), srcPath->getCoordinate(i));
-
- RI_ASSERT(newData.size() == countNumCoordinates(&newSegments[0],newSegments.size()) * getBytesPerCoordinate(m_datatype));
-
- //replace old arrays
- m_segments.swap(newSegments);
- m_data.swap(newData);
- }
-}
-
-int Path::coordsSizeInBytes( int startIndex, int numSegments )
- {
- RI_ASSERT(numSegments > 0);
- RI_ASSERT(startIndex >= 0 && startIndex + numSegments <= m_segments.size());
- RI_ASSERT(m_referenceCount > 0);
-
- int numCoords = countNumCoordinates(&m_segments[startIndex], numSegments);
- if(!numCoords)
- return 0;
- int bytesPerCoordinate = getBytesPerCoordinate(m_datatype);
- return (numCoords * bytesPerCoordinate);
- }
-
-/*-------------------------------------------------------------------*//*!
-* \brief Modifies existing coordinate data.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Path::modifyCoords(int startIndex, int numSegments, const RIuint8* data)
-{
- RI_ASSERT(numSegments > 0);
- RI_ASSERT(startIndex >= 0 && startIndex + numSegments <= m_segments.size());
- RI_ASSERT(data);
- RI_ASSERT(m_referenceCount > 0);
-
- int startCoord = countNumCoordinates(&m_segments[0], startIndex);
- int numCoords = countNumCoordinates(&m_segments[startIndex], numSegments);
- if(!numCoords)
- return;
- int bytesPerCoordinate = getBytesPerCoordinate(m_datatype);
- RIuint8* dst = &m_data[startCoord * bytesPerCoordinate];
- if(m_datatype == VG_PATH_DATATYPE_F)
- {
- RIfloat32* d = (RIfloat32*)dst;
- const RIfloat32* s = (const RIfloat32*)data;
- for(int i=0;i<numCoords;i++)
- *d++ = (RIfloat32)inputFloat(*s++);
- }
- else
- {
- ri_memcpy(dst, data, numCoords*bytesPerCoordinate);
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Appends a transformed copy of the source path.
-* \param
-* \return
-* \note if runs out of memory, throws bad_alloc and leaves the path as it was
-*//*-------------------------------------------------------------------*/
-
-void Path::transform(const Path* srcPath, const Matrix3x3& matrix)
-{
- RI_ASSERT(srcPath);
- RI_ASSERT(m_referenceCount > 0 && srcPath->m_referenceCount > 0);
- RI_ASSERT(matrix.isAffine());
-
- if(!srcPath->m_segments.size())
- return;
-
- //count the number of resulting coordinates
- int numSrcCoords = 0;
- int numDstCoords = 0;
- for(int i=0;i<srcPath->m_segments.size();i++)
- {
- VGPathSegment segment = getPathSegment(srcPath->m_segments[i]);
- int coords = segmentToNumCoordinates(segment);
- numSrcCoords += coords;
- if(segment == VG_HLINE_TO || segment == VG_VLINE_TO)
- coords = 2; //convert hline and vline to lines
- numDstCoords += coords;
- }
-
- //allocate new arrays
- Array<RIuint8> newSegments;
- newSegments.resize(m_segments.size() + srcPath->m_segments.size()); //throws bad_alloc
- Array<RIuint8> newData;
- newData.resize(m_data.size() + numDstCoords * getBytesPerCoordinate(m_datatype)); //throws bad_alloc
- //if we get here, the memory allocations have succeeded
-
- //copy old segments
- if(m_segments.size())
- ri_memcpy(&newSegments[0], &m_segments[0], m_segments.size());
-
- //copy old data
- if(m_data.size())
- ri_memcpy(&newData[0], &m_data[0], m_data.size());
-
- int srcCoord = 0;
- int dstCoord = getNumCoordinates();
- Vector2 s(0,0); //the beginning of the current subpath
- Vector2 o(0,0); //the last point of the previous segment
- for(int i=0;i<srcPath->m_segments.size();i++)
- {
- VGPathSegment segment = getPathSegment(srcPath->m_segments[i]);
- VGPathAbsRel absRel = getPathAbsRel(srcPath->m_segments[i]);
- int coords = segmentToNumCoordinates(segment);
-
- switch(segment)
- {
- case VG_CLOSE_PATH:
- {
- RI_ASSERT(coords == 0);
- o = s;
- break;
- }
-
- case VG_MOVE_TO:
- {
- RI_ASSERT(coords == 2);
- Vector2 c(srcPath->getCoordinate(srcCoord+0), srcPath->getCoordinate(srcCoord+1));
- Vector2 tc;
-
- if (absRel == VG_ABSOLUTE)
- tc = affineTransform(matrix, c);
- else
- {
- tc = affineTangentTransform(matrix, c);
- c += o;
- }
-
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc.x);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc.y);
- s = c;
- o = c;
- break;
- }
-
- case VG_LINE_TO:
- {
- RI_ASSERT(coords == 2);
- Vector2 c(srcPath->getCoordinate(srcCoord+0), srcPath->getCoordinate(srcCoord+1));
- Vector2 tc;
-
- if (absRel == VG_ABSOLUTE)
- tc = affineTransform(matrix, c);
- else
- {
- tc = affineTangentTransform(matrix, c);
- c += o;
- }
-
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc.x);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc.y);
- o = c;
- break;
- }
-
- case VG_HLINE_TO:
- {
- RI_ASSERT(coords == 1);
- Vector2 c(srcPath->getCoordinate(srcCoord+0), 0);
- Vector2 tc;
-
- if (absRel == VG_ABSOLUTE)
- {
- c.y = o.y;
- tc = affineTransform(matrix, c);
- }
- else
- {
- tc = affineTangentTransform(matrix, c);
- c += o;
- }
-
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc.x);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc.y);
- o = c;
- segment = VG_LINE_TO;
- break;
- }
-
- case VG_VLINE_TO:
- {
- RI_ASSERT(coords == 1);
- Vector2 c(0, srcPath->getCoordinate(srcCoord+0));
- Vector2 tc;
-
- if (absRel == VG_ABSOLUTE)
- {
- c.x = o.x;
- tc = affineTransform(matrix, c);
- }
- else
- {
- tc = affineTangentTransform(matrix, c);
- c += o;
- }
-
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc.x);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc.y);
- o = c;
- segment = VG_LINE_TO;
- break;
- }
-
- case VG_QUAD_TO:
- {
- RI_ASSERT(coords == 4);
- Vector2 c0(srcPath->getCoordinate(srcCoord+0), srcPath->getCoordinate(srcCoord+1));
- Vector2 c1(srcPath->getCoordinate(srcCoord+2), srcPath->getCoordinate(srcCoord+3));
- Vector2 tc0, tc1;
-
- if (absRel == VG_ABSOLUTE)
- {
- tc0 = affineTransform(matrix, c0);
- tc1 = affineTransform(matrix, c1);
- }
- else
- {
- tc0 = affineTangentTransform(matrix, c0);
- tc1 = affineTangentTransform(matrix, c1);
- c1 += o;
- }
-
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc0.x);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc0.y);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc1.x);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc1.y);
- o = c1;
- break;
- }
-
- case VG_CUBIC_TO:
- {
- RI_ASSERT(coords == 6);
- Vector2 c0(srcPath->getCoordinate(srcCoord+0), srcPath->getCoordinate(srcCoord+1));
- Vector2 c1(srcPath->getCoordinate(srcCoord+2), srcPath->getCoordinate(srcCoord+3));
- Vector2 c2(srcPath->getCoordinate(srcCoord+4), srcPath->getCoordinate(srcCoord+5));
- Vector2 tc0, tc1, tc2;
-
- if (absRel == VG_ABSOLUTE)
- {
- tc0 = affineTransform(matrix, c0);
- tc1 = affineTransform(matrix, c1);
- tc2 = affineTransform(matrix, c2);
- }
- else
- {
- tc0 = affineTangentTransform(matrix, c0);
- tc1 = affineTangentTransform(matrix, c1);
- tc2 = affineTangentTransform(matrix, c2);
- c2 += o;
- }
-
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc0.x);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc0.y);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc1.x);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc1.y);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc2.x);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc2.y);
- o = c2;
- break;
- }
-
- case VG_SQUAD_TO:
- {
- RI_ASSERT(coords == 2);
- Vector2 c1(srcPath->getCoordinate(srcCoord+0), srcPath->getCoordinate(srcCoord+1));
- Vector2 tc1;
-
- if (absRel == VG_ABSOLUTE)
- tc1 = affineTransform(matrix, c1);
- else
- {
- tc1 = affineTangentTransform(matrix, c1);
- c1 += o;
- }
-
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc1.x);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc1.y);
- o = c1;
- break;
- }
-
- case VG_SCUBIC_TO:
- {
- RI_ASSERT(coords == 4);
- Vector2 c1(srcPath->getCoordinate(srcCoord+0), srcPath->getCoordinate(srcCoord+1));
- Vector2 c2(srcPath->getCoordinate(srcCoord+2), srcPath->getCoordinate(srcCoord+3));
- Vector2 tc1, tc2;
-
- if (absRel == VG_ABSOLUTE)
- {
- tc1 = affineTransform(matrix, c1);
- tc2 = affineTransform(matrix, c2);
- }
- else
- {
- tc1 = affineTangentTransform(matrix, c1);
- tc2 = affineTangentTransform(matrix, c2);
- c2 += o;
- }
-
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc1.x);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc1.y);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc2.x);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc2.y);
- o = c2;
- break;
- }
-
- default:
- {
- RI_ASSERT(segment == VG_SCCWARC_TO || segment == VG_SCWARC_TO ||
- segment == VG_LCCWARC_TO || segment == VG_LCWARC_TO);
- RI_ASSERT(coords == 5);
- RIfloat rh = srcPath->getCoordinate(srcCoord+0);
- RIfloat rv = srcPath->getCoordinate(srcCoord+1);
- RIfloat rot = srcPath->getCoordinate(srcCoord+2);
- Vector2 c(srcPath->getCoordinate(srcCoord+3), srcPath->getCoordinate(srcCoord+4));
-
- rot = RI_DEG_TO_RAD(rot);
- Matrix3x3 u((RIfloat)cos(rot)*rh, -(RIfloat)sin(rot)*rv, 0,
- (RIfloat)sin(rot)*rh, (RIfloat)cos(rot)*rv, 0,
- 0, 0, 1);
- u = matrix * u;
- u[2].set(0,0,1); //force affinity
- //u maps from the unit circle to transformed ellipse
-
- //compute new rh, rv and rot
- Vector2 p(u[0][0], u[1][0]);
- Vector2 q(u[1][1], -u[0][1]);
- bool swapped = false;
- if(dot(p,p) < dot(q,q))
- {
- RI_SWAP(p.x,q.x);
- RI_SWAP(p.y,q.y);
- swapped = true;
- }
- Vector2 h = (p+q) * 0.5f;
- Vector2 hp = (p-q) * 0.5f;
- RIfloat hlen = h.length();
- RIfloat hplen = hp.length();
- rh = hlen + hplen;
- rv = hlen - hplen;
-
- if (RI_ISNAN(rh)) rh = 0.0f;
- if (RI_ISNAN(rv)) rv = 0.0f;
-
- h = hplen * h + hlen * hp;
- hlen = dot(h,h);
- if(hlen == 0.0f)
- rot = 0.0f;
- else
- {
- h.normalize();
- rot = (RIfloat)acos(h.x);
- if(h.y < 0.0f)
- rot = 2.0f*RI_PI - rot;
- if (RI_ISNAN(rot))
- rot = 0.0f;
- }
- if(swapped)
- rot += RI_PI*0.5f;
-
- Vector2 tc;
- if (absRel == VG_ABSOLUTE)
- tc = affineTransform(matrix, c);
- else
- {
- tc = affineTangentTransform(matrix, c);
- c += o;
- }
-
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, rh);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, rv);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, RI_RAD_TO_DEG(rot));
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc.x);
- setCoordinate(newData, m_datatype, m_scale, m_bias, dstCoord++, tc.y);
- o = c;
-
- //flip winding if the determinant is negative
- if (matrix.det() < 0)
- {
- switch (segment)
- {
- case VG_SCCWARC_TO: segment = VG_SCWARC_TO; break;
- case VG_SCWARC_TO: segment = VG_SCCWARC_TO; break;
- case VG_LCCWARC_TO: segment = VG_LCWARC_TO; break;
- case VG_LCWARC_TO: segment = VG_LCCWARC_TO; break;
- default: break;
- }
- }
- break;
- }
- }
-
- newSegments[m_segments.size() + i] = (RIuint8)(segment | absRel);
- srcCoord += coords;
- }
- RI_ASSERT(srcCoord == numSrcCoords);
- RI_ASSERT(dstCoord == getNumCoordinates() + numDstCoords);
-
- RI_ASSERT(newData.size() == countNumCoordinates(&newSegments[0],newSegments.size()) * getBytesPerCoordinate(m_datatype));
-
- //replace old arrays
- m_segments.swap(newSegments);
- m_data.swap(newData);
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Normalizes a path for interpolation.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Path::normalizeForInterpolation(const Path* srcPath)
-{
- RI_ASSERT(srcPath);
- RI_ASSERT(srcPath != this);
- RI_ASSERT(srcPath->m_referenceCount > 0);
-
- //count the number of resulting coordinates
- int numSrcCoords = 0;
- int numDstCoords = 0;
- for(int i=0;i<srcPath->m_segments.size();i++)
- {
- VGPathSegment segment = getPathSegment(srcPath->m_segments[i]);
- int coords = segmentToNumCoordinates(segment);
- numSrcCoords += coords;
- switch(segment)
- {
- case VG_CLOSE_PATH:
- case VG_MOVE_TO:
- case VG_LINE_TO:
- break;
-
- case VG_HLINE_TO:
- case VG_VLINE_TO:
- coords = 2;
- break;
-
- case VG_QUAD_TO:
- case VG_CUBIC_TO:
- case VG_SQUAD_TO:
- case VG_SCUBIC_TO:
- coords = 6;
- break;
-
- default:
- RI_ASSERT(segment == VG_SCCWARC_TO || segment == VG_SCWARC_TO ||
- segment == VG_LCCWARC_TO || segment == VG_LCWARC_TO);
- break;
- }
- numDstCoords += coords;
- }
-
- m_segments.resize(srcPath->m_segments.size()); //throws bad_alloc
- m_data.resize(numDstCoords * getBytesPerCoordinate(VG_PATH_DATATYPE_F)); //throws bad_alloc
-
- int srcCoord = 0;
- int dstCoord = 0;
- Vector2 s(0,0); //the beginning of the current subpath
- Vector2 o(0,0); //the last point of the previous segment
-
- // the last internal control point of the previous segment, if the
- //segment was a (regular or smooth) quadratic or cubic
- //Bezier, or else the last point of the previous segment
- Vector2 p(0,0);
- for(int i=0;i<srcPath->m_segments.size();i++)
- {
- VGPathSegment segment = getPathSegment(srcPath->m_segments[i]);
- VGPathAbsRel absRel = getPathAbsRel(srcPath->m_segments[i]);
- int coords = segmentToNumCoordinates(segment);
-
- switch(segment)
- {
- case VG_CLOSE_PATH:
- {
- RI_ASSERT(coords == 0);
- p = s;
- o = s;
- break;
- }
-
- case VG_MOVE_TO:
- {
- RI_ASSERT(coords == 2);
- Vector2 c(srcPath->getCoordinate(srcCoord+0), srcPath->getCoordinate(srcCoord+1));
- if(absRel == VG_RELATIVE)
- c += o;
- setCoordinate(dstCoord++, c.x);
- setCoordinate(dstCoord++, c.y);
- s = c;
- p = c;
- o = c;
- break;
- }
-
- case VG_LINE_TO:
- {
- RI_ASSERT(coords == 2);
- Vector2 c(srcPath->getCoordinate(srcCoord+0), srcPath->getCoordinate(srcCoord+1));
- if(absRel == VG_RELATIVE)
- c += o;
- setCoordinate(dstCoord++, c.x);
- setCoordinate(dstCoord++, c.y);
- p = c;
- o = c;
- break;
- }
-
- case VG_HLINE_TO:
- {
- RI_ASSERT(coords == 1);
- Vector2 c(srcPath->getCoordinate(srcCoord+0), o.y);
- if(absRel == VG_RELATIVE)
- c.x += o.x;
- setCoordinate(dstCoord++, c.x);
- setCoordinate(dstCoord++, c.y);
- p = c;
- o = c;
- segment = VG_LINE_TO;
- break;
- }
-
- case VG_VLINE_TO:
- {
- RI_ASSERT(coords == 1);
- Vector2 c(o.x, srcPath->getCoordinate(srcCoord+0));
- if(absRel == VG_RELATIVE)
- c.y += o.y;
- setCoordinate(dstCoord++, c.x);
- setCoordinate(dstCoord++, c.y);
- p = c;
- o = c;
- segment = VG_LINE_TO;
- break;
- }
-
- case VG_QUAD_TO:
- {
- RI_ASSERT(coords == 4);
- Vector2 c0(srcPath->getCoordinate(srcCoord+0), srcPath->getCoordinate(srcCoord+1));
- Vector2 c1(srcPath->getCoordinate(srcCoord+2), srcPath->getCoordinate(srcCoord+3));
- if(absRel == VG_RELATIVE)
- {
- c0 += o;
- c1 += o;
- }
- Vector2 d0 = (1.0f/3.0f) * (o + 2.0f * c0);
- Vector2 d1 = (1.0f/3.0f) * (c1 + 2.0f * c0);
- setCoordinate(dstCoord++, d0.x);
- setCoordinate(dstCoord++, d0.y);
- setCoordinate(dstCoord++, d1.x);
- setCoordinate(dstCoord++, d1.y);
- setCoordinate(dstCoord++, c1.x);
- setCoordinate(dstCoord++, c1.y);
- p = c0;
- o = c1;
- segment = VG_CUBIC_TO;
- break;
- }
-
- case VG_CUBIC_TO:
- {
- RI_ASSERT(coords == 6);
- Vector2 c0(srcPath->getCoordinate(srcCoord+0), srcPath->getCoordinate(srcCoord+1));
- Vector2 c1(srcPath->getCoordinate(srcCoord+2), srcPath->getCoordinate(srcCoord+3));
- Vector2 c2(srcPath->getCoordinate(srcCoord+4), srcPath->getCoordinate(srcCoord+5));
- if(absRel == VG_RELATIVE)
- {
- c0 += o;
- c1 += o;
- c2 += o;
- }
- setCoordinate(dstCoord++, c0.x);
- setCoordinate(dstCoord++, c0.y);
- setCoordinate(dstCoord++, c1.x);
- setCoordinate(dstCoord++, c1.y);
- setCoordinate(dstCoord++, c2.x);
- setCoordinate(dstCoord++, c2.y);
- p = c1;
- o = c2;
- break;
- }
-
- case VG_SQUAD_TO:
- {
- RI_ASSERT(coords == 2);
- Vector2 c0 = 2.0f * o - p;
- Vector2 c1(srcPath->getCoordinate(srcCoord+0), srcPath->getCoordinate(srcCoord+1));
- if(absRel == VG_RELATIVE)
- c1 += o;
- Vector2 d0 = (1.0f/3.0f) * (o + 2.0f * c0);
- Vector2 d1 = (1.0f/3.0f) * (c1 + 2.0f * c0);
- setCoordinate(dstCoord++, d0.x);
- setCoordinate(dstCoord++, d0.y);
- setCoordinate(dstCoord++, d1.x);
- setCoordinate(dstCoord++, d1.y);
- setCoordinate(dstCoord++, c1.x);
- setCoordinate(dstCoord++, c1.y);
- p = c0;
- o = c1;
- segment = VG_CUBIC_TO;
- break;
- }
-
- case VG_SCUBIC_TO:
- {
- RI_ASSERT(coords == 4);
- Vector2 c0 = 2.0f * o - p;
- Vector2 c1(srcPath->getCoordinate(srcCoord+0), srcPath->getCoordinate(srcCoord+1));
- Vector2 c2(srcPath->getCoordinate(srcCoord+2), srcPath->getCoordinate(srcCoord+3));
- if(absRel == VG_RELATIVE)
- {
- c1 += o;
- c2 += o;
- }
- setCoordinate(dstCoord++, c0.x);
- setCoordinate(dstCoord++, c0.y);
- setCoordinate(dstCoord++, c1.x);
- setCoordinate(dstCoord++, c1.y);
- setCoordinate(dstCoord++, c2.x);
- setCoordinate(dstCoord++, c2.y);
- p = c1;
- o = c2;
- segment = VG_CUBIC_TO;
- break;
- }
-
- default:
- {
- RI_ASSERT(segment == VG_SCCWARC_TO || segment == VG_SCWARC_TO ||
- segment == VG_LCCWARC_TO || segment == VG_LCWARC_TO);
- RI_ASSERT(coords == 5);
- RIfloat rh = srcPath->getCoordinate(srcCoord+0);
- RIfloat rv = srcPath->getCoordinate(srcCoord+1);
- RIfloat rot = srcPath->getCoordinate(srcCoord+2);
- Vector2 c(srcPath->getCoordinate(srcCoord+3), srcPath->getCoordinate(srcCoord+4));
- if(absRel == VG_RELATIVE)
- c += o;
- setCoordinate(dstCoord++, rh);
- setCoordinate(dstCoord++, rv);
- setCoordinate(dstCoord++, rot);
- setCoordinate(dstCoord++, c.x);
- setCoordinate(dstCoord++, c.y);
- p = c;
- o = c;
- break;
- }
- }
-
- m_segments[i] = (RIuint8)(segment | VG_ABSOLUTE);
- srcCoord += coords;
- }
- RI_ASSERT(srcCoord == numSrcCoords);
- RI_ASSERT(dstCoord == numDstCoords);
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Appends a linearly interpolated copy of the two source paths.
-* \param
-* \return
-* \note if runs out of memory, throws bad_alloc and leaves the path as it was
-*//*-------------------------------------------------------------------*/
-
-bool Path::interpolate(const Path* startPath, const Path* endPath, RIfloat amount)
-{
- RI_ASSERT(startPath && endPath);
- RI_ASSERT(m_referenceCount > 0 && startPath->m_referenceCount > 0 && endPath->m_referenceCount > 0);
-
- if(!startPath->m_segments.size() || startPath->m_segments.size() != endPath->m_segments.size())
- return false; //start and end paths are incompatible or zero length
-
- Path start(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0, 0);
- start.normalizeForInterpolation(startPath); //throws bad_alloc
-
- Path end(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0, 0);
- end.normalizeForInterpolation(endPath); //throws bad_alloc
-
- //check that start and end paths are compatible
- if(start.m_data.size() != end.m_data.size() || start.m_segments.size() != end.m_segments.size())
- return false; //start and end paths are incompatible
-
- //allocate new arrays
- Array<RIuint8> newSegments;
- newSegments.resize(m_segments.size() + start.m_segments.size()); //throws bad_alloc
- Array<RIuint8> newData;
- newData.resize(m_data.size() + start.m_data.size() * getBytesPerCoordinate(m_datatype) / getBytesPerCoordinate(start.m_datatype)); //throws bad_alloc
- //if we get here, the memory allocations have succeeded
-
- //copy old segments
- if(m_segments.size())
- ri_memcpy(&newSegments[0], &m_segments[0], m_segments.size());
-
- //copy old data
- if(m_data.size())
- ri_memcpy(&newData[0], &m_data[0], m_data.size());
-
- //copy segments
- for(int i=0;i<start.m_segments.size();i++)
- {
- VGPathSegment s = getPathSegment(start.m_segments[i]);
- VGPathSegment e = getPathSegment(end.m_segments[i]);
-
- if(s == VG_SCCWARC_TO || s == VG_SCWARC_TO || s == VG_LCCWARC_TO || s == VG_LCWARC_TO)
- {
- if(e != VG_SCCWARC_TO && e != VG_SCWARC_TO && e != VG_LCCWARC_TO && e != VG_LCWARC_TO)
- return false; //start and end paths are incompatible
- if(amount < 0.5f)
- newSegments[m_segments.size() + i] = start.m_segments[i];
- else
- newSegments[m_segments.size() + i] = end.m_segments[i];
- }
- else
- {
- if(s != e)
- return false; //start and end paths are incompatible
- newSegments[m_segments.size() + i] = start.m_segments[i];
- }
- }
-
- //interpolate data
- int oldNumCoords = getNumCoordinates();
- for(int i=0;i<start.getNumCoordinates();i++)
- setCoordinate(newData, m_datatype, m_scale, m_bias, oldNumCoords + i, start.getCoordinate(i) * (1.0f - amount) + end.getCoordinate(i) * amount);
-
- RI_ASSERT(newData.size() == countNumCoordinates(&newSegments[0],newSegments.size()) * getBytesPerCoordinate(m_datatype));
-
- //replace old arrays
- m_segments.swap(newSegments);
- m_data.swap(newData);
-
- return true;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Tessellates a path for filling and appends resulting edges
-* to a rasterizer.
-* \param
-* \return
-* \note if runs out of memory, throws bad_alloc and leaves the path as it was
-*//*-------------------------------------------------------------------*/
-
-void Path::fill(const Matrix3x3& pathToSurface, Rasterizer& rasterizer)
-{
- RI_ASSERT(m_referenceCount > 0);
- RI_ASSERT(pathToSurface.isAffine());
-
- tessellate(pathToSurface, 0.0f); //throws bad_alloc
-
- try
- {
- Vector2 p0(0,0), p1(0,0);
- for(int i=0;i<m_vertices.size();i++)
- {
- p1 = affineTransform(pathToSurface, m_vertices[i].userPosition);
-
- if(!(m_vertices[i].flags & START_SEGMENT))
- { //in the middle of a segment
- rasterizer.addEdge(p0, p1); //throws bad_alloc
- }
-
- p0 = p1;
- }
- }
- catch(std::bad_alloc)
- {
- rasterizer.clear(); //remove the unfinished path
- throw;
- }
-}
-
-/**
- * \brief Intersection between lines (p0->p1) and (p2->p3)
- * \todo This must be done in the rasterizer to get correct results.
- */
-static void intersectLines(const Vector2& p0, const Vector2& p1, const Vector2& p2, const Vector2& p3, Vector2& pt)
-{
- RIfloat n = (p1.x-p0.x)*(p0.y-p2.y)-(p1.y-p0.y)*(p0.x-p2.x);
- RIfloat d = (p3.y-p2.y)*(p1.x-p0.x)-(p3.x-p2.x)*(p1.y-p0.y);
- if (d == 0)
- {
- pt = p0;
- return;
- }
- RIfloat t = n/d;
- Vector2 dir = p1-p0;
-
- pt = p0+t*dir;
-}
-
-static bool isCCW(const Vector2& a, const Vector2& b)
-{
- RIfloat c = a.x*b.y - a.y*b.x;
- return c >= 0;
-}
-
-/**
- * \brief Add a CCW stitch-triangle so that accw -> acw is the base of the triangle.
- * \param accw Counter-clockwise stroke end (for example).
- * \param acw Clockwise stroke end.
- * \param p Tip of the triangle to form.
- */
-static void addStitchTriangle(Rasterizer& rasterizer, const Vector2& accw, const Vector2& acw, const Vector2& p)
-{
- if (isCCW(p - accw, acw - accw))
- {
- // p "below"
- rasterizer.addEdge(accw, p);
- rasterizer.addEdge(p, acw);
- rasterizer.addEdge(acw, accw);
- }
- else
- {
- rasterizer.addEdge(accw, acw);
- rasterizer.addEdge(acw, p);
- rasterizer.addEdge(p, accw);
- }
-}
-
-/**
- * \brief Add a (ccw-closed) segment to path. See the naming of parameters for input order:
- * pp = previous, nn = next
- */
-static void addStrokeSegment(Rasterizer& rasterizer, const Vector2& ppccw, const Vector2& ppcw, const Vector2& nnccw, const Vector2& nncw)
-{
- RIfloat d = dot(nnccw-ppccw, nncw-ppcw);
- if(d < 0)
- {
- Vector2 ip;
- intersectLines(ppccw, ppcw, nnccw, nncw, ip);
-
- // Create two triangles from the self-intersecting part
- if (isCCW(ppccw - nnccw, ip - nnccw))
- {
- rasterizer.addEdge(nnccw, ppccw);
- rasterizer.addEdge(ppccw, ip);
- rasterizer.addEdge(ip, nnccw);
-
- rasterizer.addEdge(nncw, ppcw);
- rasterizer.addEdge(ppcw, ip);
- rasterizer.addEdge(ip, nncw);
- }
- else
- {
- rasterizer.addEdge(nnccw, ip);
- rasterizer.addEdge(ip, ppccw);
- rasterizer.addEdge(ppccw, nnccw);
-
- rasterizer.addEdge(nncw, ip);
- rasterizer.addEdge(ip, ppcw);
- rasterizer.addEdge(ppcw, nncw);
- }
- // Final stitch (not necessary if done in the rasterizer)
- addStitchTriangle(rasterizer, ppccw, ppcw, ip);
- addStitchTriangle(rasterizer, nnccw, nncw, ip);
- }
- else
- {
- rasterizer.addEdge(ppccw, ppcw); //throws bad_alloc
- rasterizer.addEdge(ppcw, nncw); //throws bad_alloc
- rasterizer.addEdge(nncw, nnccw); //throws bad_alloc
- rasterizer.addEdge(nnccw, ppccw); //throws bad_alloc
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Smoothly interpolates between two StrokeVertices. Positions
-* are interpolated linearly, while tangents are interpolated
-* on a unit circle. Stroking is implemented so that overlapping
-* geometry doesnt cancel itself when filled with nonzero rule.
-* The resulting polygons are closed.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Path::interpolateStroke(const Matrix3x3& pathToSurface, Rasterizer& rasterizer, const StrokeVertex& v0, const StrokeVertex& v1, RIfloat strokeWidth) const
-{
- Vector2 ppccw, endccw;
- Vector2 ppcw, endcw;
-
- if (m_mirror)
- {
- ppccw = affineTransform(pathToSurface, v0.cw);
- ppcw = affineTransform(pathToSurface, v0.ccw);
- endccw = affineTransform(pathToSurface, v1.cw);
- endcw = affineTransform(pathToSurface, v1.ccw);
- }
- else
- {
- ppccw = affineTransform(pathToSurface, v0.ccw);
- ppcw = affineTransform(pathToSurface, v0.cw);
- endccw = affineTransform(pathToSurface, v1.ccw);
- endcw = affineTransform(pathToSurface, v1.cw);
- }
-
- const RIfloat tessellationAngle = 5.0f;
-
- RIfloat angle = RI_RAD_TO_DEG((RIfloat)acos(RI_CLAMP(dot(v0.t, v1.t), -1.0f, 1.0f))) / tessellationAngle;
- int samples = RI_INT_MAX((int)ceil(angle), 1);
- Vector2 prev = v0.p;
- Vector2 prevt = v0.t;
- Vector2 position = v0.p;
- for(int j=0;j<samples-1;j++)
- {
- RIfloat t = (RIfloat)(j+1) / (RIfloat)samples;
- position = v0.p * (1.0f - t) + v1.p * t;
- Vector2 tangent = circularLerp(v0.t, v1.t, t);
- Vector2 n = normalize(perpendicularCCW(tangent)) * strokeWidth * 0.5f;
-
- Vector2 nnccw = affineTransform(pathToSurface, position + n);
- Vector2 nncw = affineTransform(pathToSurface, position - n);
-
- addStrokeSegment(rasterizer, ppccw, ppcw, nnccw, nncw);
-
- ppccw = nnccw;
- ppcw = nncw;
- prev = position;
- prevt = tangent;
- }
-
- //connect the last segment to the end coordinates
- //Vector2 n = affineTangentTransform(pathToSurface, perpendicularCCW(v1.t));
- Vector2 nncw = endcw;
- Vector2 nnccw = endccw;
-
- addStrokeSegment(rasterizer, ppccw, ppcw, nnccw, nncw);
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Generate edges for stroke caps. Resulting polygons are closed.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Path::doCap(const Matrix3x3& pathToSurface, Rasterizer& rasterizer, const StrokeVertex& v, RIfloat strokeWidth, VGCapStyle capStyle) const
-{
- const bool mirror = m_mirror;
- Vector2 ccwt, cwt, p;
- if (mirror)
- {
- ccwt = affineTransform(pathToSurface, v.cw);
- cwt = affineTransform(pathToSurface, v.ccw);
- p = affineTransform(pathToSurface, v.p);
- }
- else
- {
- ccwt = affineTransform(pathToSurface, v.ccw);
- cwt = affineTransform(pathToSurface, v.cw);
- p = affineTransform(pathToSurface, v.p);
- }
-
- //rasterizer.clear();
- switch(capStyle)
- {
- case VG_CAP_BUTT:
- break;
-
- case VG_CAP_ROUND:
- {
- const RIfloat tessellationAngle = 5.0f;
-
- RIfloat angle = 180.0f / tessellationAngle;
-
- int samples = (int)ceil(angle);
- RIfloat step = 1.0f / samples;
- RIfloat t = step;
- Vector2 u0, u1;
- if (!mirror)
- {
- u0 = normalize(v.cw - v.p);
- u1 = normalize(v.ccw - v.p);
- } else
- {
- u0 = normalize(v.ccw - v.p);
- u1 = normalize(v.cw - v.p);
- }
- Vector2 prev = cwt;
- rasterizer.addEdge(p, cwt); //throws bad_alloc
- for(int j=1;j<samples;j++)
- {
- Vector2 next = v.p + circularLerp(u0, u1, t, mirror) * strokeWidth * 0.5f;
- next = affineTransform(pathToSurface, next);
-
- rasterizer.addEdge(prev, next); //throws bad_alloc
- prev = next;
- t += step;
- }
- rasterizer.addEdge(prev, ccwt); //throws bad_alloc
- rasterizer.addEdge(ccwt, p); //throws bad_alloc
- break;
- }
-
- default:
- {
- RI_ASSERT(capStyle == VG_CAP_SQUARE);
- Vector2 t = v.t;
- t.normalize();
- Vector2 ccws, cws;
- if (!mirror)
- {
- ccws = affineTransform(pathToSurface, v.ccw + t * strokeWidth * 0.5f);
- cws = affineTransform(pathToSurface, v.cw + t * strokeWidth * 0.5f);
- }
- else
- {
- ccws = affineTransform(pathToSurface, v.cw + t * strokeWidth * 0.5f);
- cws = affineTransform(pathToSurface, v.ccw + t * strokeWidth * 0.5f);
- }
- rasterizer.addEdge(p, cwt); //throws bad_alloc
- rasterizer.addEdge(cwt, cws); //throws bad_alloc
- rasterizer.addEdge(cws, ccws); //throws bad_alloc
- rasterizer.addEdge(ccws, ccwt); //throws bad_alloc
- rasterizer.addEdge(ccwt, p); //throws bad_alloc
- break;
- }
- }
- //rasterizer.fill();
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Generate edges for stroke joins. Resulting polygons are closed.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Path::doJoin(const Matrix3x3& pathToSurface, Rasterizer& rasterizer, const StrokeVertex& v0, const StrokeVertex& v1, RIfloat strokeWidth, VGJoinStyle joinStyle, RIfloat miterLimit) const
-{
- const bool mirror = m_mirror;
- Vector2 ccw0t, ccw1t;
- Vector2 cw0t, cw1t;
- Vector2 m0t, m1t;
- Vector2 tt0, tt1;
-
- if(mirror)
- {
- ccw0t = affineTransform(pathToSurface, v0.cw);
- cw0t = affineTransform(pathToSurface, v0.ccw);
- m0t = affineTransform(pathToSurface, v0.p);
- tt0 = affineTangentTransform(pathToSurface, v0.t);
- ccw1t = affineTransform(pathToSurface, v1.cw);
- cw1t = affineTransform(pathToSurface, v1.ccw);
- m1t = affineTransform(pathToSurface, v1.p);
- tt1 = affineTangentTransform(pathToSurface, v1.t);
- } else
- {
- ccw0t = affineTransform(pathToSurface, v0.ccw);
- cw0t = affineTransform(pathToSurface, v0.cw);
- m0t = affineTransform(pathToSurface, v0.p);
- tt0 = affineTangentTransform(pathToSurface, v0.t);
- ccw1t = affineTransform(pathToSurface, v1.ccw);
- cw1t = affineTransform(pathToSurface, v1.cw);
- m1t = affineTransform(pathToSurface, v1.p);
- tt1 = affineTangentTransform(pathToSurface, v1.t);
- }
-
- Vector2 tccw = v1.ccw - v0.ccw;
- Vector2 s, e, m, st, et;
- bool cw = true;
-
- // \todo Uses addStrokeSegment, which is wasteful in several cases
- // (but should be pretty robust)
- // Round or miter to cw-side?
-
- if (dot(tt1, ccw0t - m0t) >= 0)
- cw = false;
-
- // Add the bevel (which is part of all the other joins also)
- // This would be a "consistent" way to handle joins (in addition
- // to creating rounding to _both_ side of the join). However,
- // the conformance test currently invalidates this case.
- // \note Causes some extra geometry.
- if (cw)
- addStrokeSegment(rasterizer, ccw0t, m0t, ccw1t, m1t);
- else
- addStrokeSegment(rasterizer, m0t, cw0t, m1t, cw1t);
-
- switch (joinStyle)
- {
- case VG_JOIN_BEVEL:
- break;
- case VG_JOIN_MITER:
- {
- RIfloat theta = (RIfloat)acos(RI_CLAMP(dot(v0.t, -v1.t), -1.0f, 1.0f));
- RIfloat miterLengthPerStrokeWidth = 1.0f / (RIfloat)sin(theta*0.5f);
- if (miterLengthPerStrokeWidth < miterLimit)
- {
- // Miter
- if (cw)
- {
- m = !mirror ? v0.ccw : v0.cw;
- s = ccw1t;
- e = ccw0t;
- } else
- {
- m = !mirror ? v0.cw : v0.ccw;
- s = cw0t;
- e = cw1t;
- }
-
- RIfloat l = (RIfloat)cos(theta*0.5f) * miterLengthPerStrokeWidth * (strokeWidth * 0.5f);
- l = RI_MIN(l, RI_FLOAT_MAX); //force finite
- Vector2 c = m + v0.t * l;
- c = affineTransform(pathToSurface, c);
-
- rasterizer.addEdge(s, c);
- rasterizer.addEdge(c, e);
- rasterizer.addEdge(e, s);
- }
- break;
- }
- default:
- {
- RI_ASSERT(joinStyle == VG_JOIN_ROUND);
-
- Vector2 sp, ep;
-
- const RIfloat tessellationAngle = 5.0f;
-
- if (cw)
- {
- s = ccw1t;
- st = -v1.t;
- e = ccw0t;
- et = -v0.t;
- sp = v1.p;
- ep = v0.p;
- } else
- {
- s = cw0t;
- st = v0.t;
- e = cw1t;
- et = v1.t;
- sp = v0.p;
- ep = v1.p;
- }
-
- Vector2 prev = s;
- RIfloat angle = RI_RAD_TO_DEG((RIfloat)acos(RI_CLAMP(dot(st, et), -1.0f, 1.0f))) / tessellationAngle;
- int samples = (int)ceil(angle);
- if( samples )
- {
- RIfloat step = 1.0f / samples;
- RIfloat t = step;
- for(int j=1;j<samples;j++)
- {
- Vector2 position = sp * (1.0f - t) + ep * t;
- Vector2 tangent = circularLerp(st, et, t, mirror);
-
- Vector2 next = position + normalize(perpendicular(tangent, !mirror)) * strokeWidth * 0.5f;
- next = affineTransform(pathToSurface, next);
-
- rasterizer.addEdge(prev, next); //throws bad_alloc
- prev = next;
- t += step;
- }
- }
- rasterizer.addEdge(prev, e); //throws bad_alloc
- rasterizer.addEdge(e, s);
- break;
- }
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Tessellate a path, apply stroking, dashing, caps and joins, and
-* append resulting edges to a rasterizer.
-* \param
-* \return
-* \note if runs out of memory, throws bad_alloc and leaves the path as it was
-*//*-------------------------------------------------------------------*/
-
-void Path::stroke(const Matrix3x3& pathToSurface, Rasterizer& rasterizer, const Array<RIfloat>& dashPattern, RIfloat dashPhase, bool dashPhaseReset, RIfloat strokeWidth, VGCapStyle capStyle, VGJoinStyle joinStyle, RIfloat miterLimit)
-{
- RI_ASSERT(pathToSurface.isAffine());
- RI_ASSERT(m_referenceCount > 0);
- RI_ASSERT(strokeWidth >= 0.0f);
- RI_ASSERT(miterLimit >= 1.0f);
-
- tessellate(pathToSurface, strokeWidth); //throws bad_alloc
-
- m_mirror = pathToSurface[0][0]*pathToSurface[1][1] < 0 ? true : false;
-
- if(!m_vertices.size())
- return;
-
- bool dashing = true;
- int dashPatternSize = dashPattern.size();
- if( dashPattern.size() & 1 )
- dashPatternSize--; //odd number of dash pattern entries, discard the last one
- RIfloat dashPatternLength = 0.0f;
- for(int i=0;i<dashPatternSize;i++)
- dashPatternLength += RI_MAX(dashPattern[i], 0.0f);
- if(!dashPatternSize || dashPatternLength == 0.0f )
- dashing = false;
- dashPatternLength = RI_MIN(dashPatternLength, RI_FLOAT_MAX);
-
- //walk along the path
- //stop at the next event which is either:
- //-path vertex
- //-dash stop
- //for robustness, decisions based on geometry are done only once.
- //inDash keeps track whether the last point was in dash or not
-
- //loop vertex events
- try
- {
- RIfloat nextDash = 0.0f;
- int d = 0;
- bool inDash = true;
- StrokeVertex v0, v1, vs;
- for(int i=0;i<m_vertices.size();i++)
- {
- //read the next vertex
- Vertex& v = m_vertices[i];
- v1.p = v.userPosition;
- v1.t = v.userTangent;
- RI_ASSERT(!isZero(v1.t)); //don't allow zero tangents
-
- v1.ccw = v1.p + normalize(perpendicularCCW(v1.t)) * strokeWidth * 0.5f;
- v1.cw = v1.p + normalize(perpendicularCW(v1.t)) * strokeWidth * 0.5f;
-
- v1.pathLength = v.pathLength;
- v1.flags = v.flags;
- v1.inDash = dashing ? inDash : true; //NOTE: for other than START_SEGMENT vertices inDash will be updated after dashing
-
- //process the vertex event
- if(v.flags & START_SEGMENT)
- {
- if(v.flags & START_SUBPATH)
- {
- if( dashing )
- { //initialize dashing by finding which dash or gap the first point of the path lies in
- if(dashPhaseReset || i == 0)
- {
- d = 0;
- inDash = true;
- nextDash = v1.pathLength - RI_MOD(dashPhase, dashPatternLength);
- for(;;)
- {
- RIfloat prevDash = nextDash;
- nextDash = prevDash + RI_MAX(dashPattern[d], 0.0f);
- if(nextDash >= v1.pathLength)
- break;
-
- if( d & 1 )
- inDash = true;
- else
- inDash = false;
- d = (d+1) % dashPatternSize;
- }
- v1.inDash = inDash;
- //the first point of the path lies between prevDash and nextDash
- //d in the index of the next dash stop
- //inDash is true if the first point is in a dash
- }
- }
- vs = v1; //save the subpath start point
- }
- else
- {
- if( v.flags & IMPLICIT_CLOSE_SUBPATH )
- { //do caps for the start and end of the current subpath
- if( v0.inDash )
- doCap(pathToSurface, rasterizer, v0, strokeWidth, capStyle); //end cap //throws bad_alloc
- if( vs.inDash )
- {
- StrokeVertex vi = vs;
- vi.t = -vi.t;
- RI_SWAP(vi.ccw.x, vi.cw.x);
- RI_SWAP(vi.ccw.y, vi.cw.y);
- doCap(pathToSurface, rasterizer, vi, strokeWidth, capStyle); //start cap //throws bad_alloc
- }
- }
- else
- { //join two segments
- RI_ASSERT(v0.inDash == v1.inDash);
- if( v0.inDash )
- doJoin(pathToSurface, rasterizer, v0, v1, strokeWidth, joinStyle, miterLimit); //throws bad_alloc
- }
- }
- }
- else
- { //in the middle of a segment
- if( !(v.flags & IMPLICIT_CLOSE_SUBPATH) )
- { //normal segment, do stroking
- if( dashing )
- {
- StrokeVertex prevDashVertex = v0; //dashing of the segment starts from the previous vertex
-
- if(nextDash + 10000.0f * dashPatternLength < v1.pathLength)
- throw std::bad_alloc(); //too many dashes, throw bad_alloc
-
- //loop dash events until the next vertex event
- //zero length dashes are handled as a special case since if they hit the vertex,
- //we want to include their starting point to this segment already in order to generate a join
- int numDashStops = 0;
- while(nextDash < v1.pathLength || (nextDash <= v1.pathLength && dashPattern[(d+1) % dashPatternSize] == 0.0f))
- {
- RIfloat edgeLength = v1.pathLength - v0.pathLength;
- RIfloat ratio = 0.0f;
- if(edgeLength > 0.0f)
- ratio = (nextDash - v0.pathLength) / edgeLength;
- StrokeVertex nextDashVertex;
- nextDashVertex.p = v0.p * (1.0f - ratio) + v1.p * ratio;
- nextDashVertex.t = circularLerp(v0.t, v1.t, ratio);
- nextDashVertex.ccw = nextDashVertex.p + normalize(perpendicularCCW(nextDashVertex.t)) * strokeWidth * 0.5f;
- nextDashVertex.cw = nextDashVertex.p + normalize(perpendicularCW(nextDashVertex.t)) * strokeWidth * 0.5f;
-
- if( inDash )
- { //stroke from prevDashVertex -> nextDashVertex
- if( numDashStops )
- { //prevDashVertex is not the start vertex of the segment, cap it (start vertex has already been joined or capped)
- StrokeVertex vi = prevDashVertex;
- vi.t = -vi.t;
- RI_SWAP(vi.ccw.x, vi.cw.x);
- RI_SWAP(vi.ccw.y, vi.cw.y);
- doCap(pathToSurface, rasterizer, vi, strokeWidth, capStyle); //throws bad_alloc
- }
- interpolateStroke(pathToSurface, rasterizer, prevDashVertex, nextDashVertex, strokeWidth); //throws bad_alloc
- doCap(pathToSurface, rasterizer, nextDashVertex, strokeWidth, capStyle); //end cap //throws bad_alloc
- }
- prevDashVertex = nextDashVertex;
-
- if( d & 1 )
- { //dash starts
- RI_ASSERT(!inDash);
- inDash = true;
- }
- else
- { //dash ends
- RI_ASSERT(inDash);
- inDash = false;
- }
- d = (d+1) % dashPatternSize;
- nextDash += RI_MAX(dashPattern[d], 0.0f);
- numDashStops++;
- }
-
- if( inDash )
- { //stroke prevDashVertex -> v1
- if( numDashStops )
- { //prevDashVertex is not the start vertex of the segment, cap it (start vertex has already been joined or capped)
- StrokeVertex vi = prevDashVertex;
- vi.t = -vi.t;
- RI_SWAP(vi.ccw.x, vi.cw.x);
- RI_SWAP(vi.ccw.y, vi.cw.y);
- doCap(pathToSurface, rasterizer, vi, strokeWidth, capStyle); //throws bad_alloc
- }
- interpolateStroke(pathToSurface, rasterizer, prevDashVertex, v1, strokeWidth); //throws bad_alloc
- //no cap, leave path open
- }
-
- v1.inDash = inDash; //update inDash status of the segment end point
- }
- else //no dashing, just interpolate segment end points
- interpolateStroke(pathToSurface, rasterizer, v0, v1, strokeWidth); //throws bad_alloc
- }
- }
-
- if((v.flags & END_SEGMENT) && (v.flags & CLOSE_SUBPATH))
- { //join start and end of the current subpath
- if( v1.inDash && vs.inDash )
- doJoin(pathToSurface, rasterizer, v1, vs, strokeWidth, joinStyle, miterLimit); //throws bad_alloc
- else
- { //both start and end are not in dash, cap them
- if( v1.inDash )
- doCap(pathToSurface, rasterizer, v1, strokeWidth, capStyle); //end cap //throws bad_alloc
- if( vs.inDash )
- {
- StrokeVertex vi = vs;
- vi.t = -vi.t;
- RI_SWAP(vi.ccw.x, vi.cw.x);
- RI_SWAP(vi.ccw.y, vi.cw.y);
- doCap(pathToSurface, rasterizer, vi, strokeWidth, capStyle); //start cap //throws bad_alloc
- }
- }
- }
-
- v0 = v1;
- }
- }
- catch(std::bad_alloc)
- {
- rasterizer.clear(); //remove the unfinished path
- throw;
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Tessellates a path, and returns a position and a tangent on the path
-* given a distance along the path.
-* \param
-* \return
-* \note if runs out of memory, throws bad_alloc and leaves the path as it was
-*//*-------------------------------------------------------------------*/
-
-void Path::getPointAlong(int startIndex, int numSegments, RIfloat distance, Vector2& p, Vector2& t)
-{
- RI_ASSERT(m_referenceCount > 0);
- RI_ASSERT(startIndex >= 0 && startIndex + numSegments <= m_segments.size() && numSegments > 0);
-
- Matrix3x3 identity;
- identity.identity();
- tessellate(identity, 0.0f); //throws bad_alloc
-
- RI_ASSERT(startIndex >= 0 && startIndex < m_segmentToVertex.size());
- RI_ASSERT(startIndex + numSegments >= 0 && startIndex + numSegments <= m_segmentToVertex.size());
-
- // ignore move segments at the start of the path
- while (numSegments && (m_segments[startIndex] & ~VG_RELATIVE) == VG_MOVE_TO)
- {
- startIndex++;
- numSegments--;
- }
-
- // ignore move segments at the end of the path
- while (numSegments && (m_segments[startIndex + numSegments - 1] & ~VG_RELATIVE) == VG_MOVE_TO)
- numSegments--;
-
- // empty path?
- if (!m_vertices.size() || !numSegments)
- {
- p.set(0,0);
- t.set(1,0);
- return;
- }
-
- int startVertex = m_segmentToVertex[startIndex].start;
- int endVertex = m_segmentToVertex[startIndex + numSegments - 1].end;
-
- if(startVertex == -1)
- startVertex = 0;
-
- // zero length?
- if (startVertex >= endVertex)
- {
- p = m_vertices[startVertex].userPosition;
- t.set(1,0);
- return;
- }
-
- RI_ASSERT(startVertex >= 0 && startVertex < m_vertices.size());
- RI_ASSERT(endVertex >= 0 && endVertex < m_vertices.size());
-
- distance += m_vertices[startVertex].pathLength; //map distance to the range of the whole path
-
- if(distance <= m_vertices[startVertex].pathLength)
- { //return the first point of the path
- p = m_vertices[startVertex].userPosition;
- t = m_vertices[startVertex].userTangent;
- return;
- }
-
- if(distance >= m_vertices[endVertex].pathLength)
- { //return the last point of the path
- p = m_vertices[endVertex].userPosition;
- t = m_vertices[endVertex].userTangent;
- return;
- }
-
- //search for the segment containing the distance
- for(int s=startIndex;s<startIndex+numSegments;s++)
- {
- int start = m_segmentToVertex[s].start;
- int end = m_segmentToVertex[s].end;
- if(start < 0)
- start = 0;
- if(end < 0)
- end = 0;
- RI_ASSERT(start >= 0 && start < m_vertices.size());
- RI_ASSERT(end >= 0 && end < m_vertices.size());
-
- if(distance >= m_vertices[start].pathLength && distance < m_vertices[end].pathLength)
- { //segment contains the queried distance
- for(int i=start;i<end;i++)
- {
- const Vertex& v0 = m_vertices[i];
- const Vertex& v1 = m_vertices[i+1];
- if(distance >= v0.pathLength && distance < v1.pathLength)
- { //segment found, interpolate linearly between its end points
- RIfloat edgeLength = v1.pathLength - v0.pathLength;
- RI_ASSERT(edgeLength > 0.0f);
- RIfloat r = (distance - v0.pathLength) / edgeLength;
- p = (1.0f - r) * v0.userPosition + r * v1.userPosition;
- t = (1.0f - r) * v0.userTangent + r * v1.userTangent;
- return;
- }
- }
- }
- }
-
- RI_ASSERT(0); //point not found (should never get here)
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Tessellates a path, and computes its length.
-* \param
-* \return
-* \note if runs out of memory, throws bad_alloc and leaves the path as it was
-*//*-------------------------------------------------------------------*/
-
-RIfloat Path::getPathLength(int startIndex, int numSegments)
-{
- RI_ASSERT(m_referenceCount > 0);
- RI_ASSERT(startIndex >= 0 && startIndex + numSegments <= m_segments.size() && numSegments > 0);
-
- Matrix3x3 identity;
- identity.identity();
- tessellate(identity, 0.0f); //throws bad_alloc
-
- RI_ASSERT(startIndex >= 0 && startIndex < m_segmentToVertex.size());
- RI_ASSERT(startIndex + numSegments >= 0 && startIndex + numSegments <= m_segmentToVertex.size());
-
- int startVertex = m_segmentToVertex[startIndex].start;
- int endVertex = m_segmentToVertex[startIndex + numSegments - 1].end;
-
- if(!m_vertices.size())
- return 0.0f;
-
- RIfloat startPathLength = 0.0f;
- if(startVertex >= 0)
- {
- RI_ASSERT(startVertex >= 0 && startVertex < m_vertices.size());
- startPathLength = m_vertices[startVertex].pathLength;
- }
- RIfloat endPathLength = 0.0f;
- if(endVertex >= 0)
- {
- RI_ASSERT(endVertex >= 0 && endVertex < m_vertices.size());
- endPathLength = m_vertices[endVertex].pathLength;
- }
-
- return endPathLength - startPathLength;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Tessellates a path, and computes its bounding box in user space.
-* \param
-* \return
-* \note if runs out of memory, throws bad_alloc and leaves the path as it was
-*//*-------------------------------------------------------------------*/
-
-void Path::getPathBounds(RIfloat& minx, RIfloat& miny, RIfloat& maxx, RIfloat& maxy)
-{
- RI_ASSERT(m_referenceCount > 0);
-
- Matrix3x3 identity;
- identity.identity();
- tessellate(identity, 0.0f); //throws bad_alloc
-
- if(m_vertices.size())
- {
- minx = m_userMinx;
- miny = m_userMiny;
- maxx = m_userMaxx;
- maxy = m_userMaxy;
- }
- else
- {
- minx = miny = 0;
- maxx = maxy = -1;
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Tessellates a path, and computes its bounding box in surface space.
-* \param
-* \return
-* \note if runs out of memory, throws bad_alloc and leaves the path as it was
-*//*-------------------------------------------------------------------*/
-
-void Path::getPathTransformedBounds(const Matrix3x3& pathToSurface, RIfloat& minx, RIfloat& miny, RIfloat& maxx, RIfloat& maxy)
-{
- RI_ASSERT(m_referenceCount > 0);
- RI_ASSERT(pathToSurface.isAffine());
-
- Matrix3x3 identity;
- identity.identity();
- tessellate(identity, 0.0f); //throws bad_alloc
-
- if(m_vertices.size())
- {
- Vector3 p0(m_userMinx, m_userMiny, 1.0f);
- Vector3 p1(m_userMinx, m_userMaxy, 1.0f);
- Vector3 p2(m_userMaxx, m_userMaxy, 1.0f);
- Vector3 p3(m_userMaxx, m_userMiny, 1.0f);
- p0 = pathToSurface * p0;
- p1 = pathToSurface * p1;
- p2 = pathToSurface * p2;
- p3 = pathToSurface * p3;
-
- minx = RI_MIN(RI_MIN(RI_MIN(p0.x, p1.x), p2.x), p3.x);
- miny = RI_MIN(RI_MIN(RI_MIN(p0.y, p1.y), p2.y), p3.y);
- maxx = RI_MAX(RI_MAX(RI_MAX(p0.x, p1.x), p2.x), p3.x);
- maxy = RI_MAX(RI_MAX(RI_MAX(p0.y, p1.y), p2.y), p3.y);
- }
- else
- {
- minx = miny = 0;
- maxx = maxy = -1;
- }
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Adds a vertex to a tessellated path.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Path::addVertex(const Vector2& p, const Vector2& t, RIfloat pathLength, unsigned int flags)
-{
- RI_ASSERT(!isZero(t));
-
- Vertex v;
- v.pathLength = pathLength;
- v.userPosition = p;
- v.userTangent = t;
- v.flags = flags;
- m_vertices.push_back(v); //throws bad_alloc
- m_numTessVertices++;
-
- m_userMinx = RI_MIN(m_userMinx, v.userPosition.x);
- m_userMiny = RI_MIN(m_userMiny, v.userPosition.y);
- m_userMaxx = RI_MAX(m_userMaxx, v.userPosition.x);
- m_userMaxy = RI_MAX(m_userMaxy, v.userPosition.y);
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Adds an edge to a tessellated path.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Path::addEdge(const Vector2& p0, const Vector2& p1, const Vector2& t0, const Vector2& t1, unsigned int startFlags, unsigned int endFlags)
-{
- Vertex v;
- RIfloat pathLength = 0.0f;
-
- RI_ASSERT(!isZero(t0) && !isZero(t1));
-
- //segment midpoints are shared between edges
- if(!m_numTessVertices)
- {
- if(m_vertices.size() > 0)
- pathLength = m_vertices[m_vertices.size()-1].pathLength;
-
- addVertex(p0, t0, pathLength, startFlags); //throws bad_alloc
- }
-
- //other than implicit close paths (caused by a MOVE_TO) add to path length
- if( !(endFlags & IMPLICIT_CLOSE_SUBPATH) )
- {
- //NOTE: with extremely large coordinates the floating point path length is infinite
- RIfloat l = (p1 - p0).length();
- pathLength = m_vertices[m_vertices.size()-1].pathLength + l;
- pathLength = RI_MIN(pathLength, RI_FLOAT_MAX);
- }
-
- addVertex(p1, t1, pathLength, endFlags); //throws bad_alloc
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Tessellates a close-path segment.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-void Path::addEndPath(const Matrix3x3& pathToSurface, const Vector2& p0, const Vector2& p1, bool subpathHasGeometry, unsigned int flags)
-{
- RI_UNREF(pathToSurface);
- m_numTessVertices = 0;
- if(!subpathHasGeometry)
- { //single vertex
- Vector2 t(1.0f,0.0f);
- addEdge(p0, p1, t, t, START_SEGMENT | START_SUBPATH, END_SEGMENT | END_SUBPATH); //throws bad_alloc
- m_numTessVertices = 0;
- addEdge(p0, p1, -t, -t, IMPLICIT_CLOSE_SUBPATH | START_SEGMENT, IMPLICIT_CLOSE_SUBPATH | END_SEGMENT); //throws bad_alloc
- return;
- }
- //the subpath contains segment commands that have generated geometry
-
- //add a close path segment to the start point of the subpath
- RI_ASSERT(m_vertices.size() > 0);
- m_vertices[m_vertices.size()-1].flags |= END_SUBPATH;
-
- Vector2 t = normalize(p1 - p0);
- if(isZero(t))
- t = m_vertices[m_vertices.size()-1].userTangent; //if the segment is zero-length, use the tangent of the last segment end point so that proper join will be generated
- RI_ASSERT(!isZero(t));
-
- addEdge(p0, p1, t, t, flags | START_SEGMENT, flags | END_SEGMENT); //throws bad_alloc
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Tessellates a line-to segment.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-bool Path::addLineTo(const Matrix3x3& pathToSurface, const Vector2& p0, const Vector2& p1, bool subpathHasGeometry)
-{
- RI_UNREF(pathToSurface);
- if(p0 == p1)
- return false; //discard zero-length segments
-
- //compute end point tangents
- Vector2 t = normalize(p1 - p0);
- RI_ASSERT(!isZero(t));
-
- m_numTessVertices = 0;
- unsigned int startFlags = START_SEGMENT;
- if(!subpathHasGeometry)
- startFlags |= START_SUBPATH;
- addEdge(p0, p1, t, t, startFlags, END_SEGMENT); //throws bad_alloc
- return true;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Tessellates a quad-to segment.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-bool Path::addQuadTo(const Matrix3x3& pathToSurface, const Vector2& p0, const Vector2& p1, const Vector2& p2, bool subpathHasGeometry, float strokeWidth)
-{
- RI_UNREF(pathToSurface);
- RI_UNREF(strokeWidth);
- if(p0 == p1 && p0 == p2)
- {
- RI_ASSERT(p1 == p2);
- return false; //discard zero-length segments
- }
-
- //compute end point tangents
-
- Vector2 incomingTangent = normalize(p1 - p0);
- Vector2 outgoingTangent = normalize(p2 - p1);
- if(p0 == p1)
- incomingTangent = normalize(p2 - p0);
- if(p1 == p2)
- outgoingTangent = normalize(p2 - p0);
- RI_ASSERT(!isZero(incomingTangent) && !isZero(outgoingTangent));
-
- m_numTessVertices = 0;
- unsigned int startFlags = START_SEGMENT;
- if(!subpathHasGeometry)
- startFlags |= START_SUBPATH;
-
- const int segments = RI_NUM_TESSELLATED_SEGMENTS_QUAD;
- Vector2 pp = p0;
- Vector2 tp = incomingTangent;
- unsigned int prevFlags = startFlags;
- for(int i=1;i<segments;i++)
- {
- RIfloat t = (RIfloat)i / (RIfloat)segments;
- RIfloat u = 1.0f-t;
- Vector2 pn = u*u * p0 + 2.0f*t*u * p1 + t*t * p2;
- Vector2 tn = (-1.0f+t) * p0 + (1.0f-2.0f*t) * p1 + t * p2;
- tn = normalize(tn);
- if(isZero(tn))
- tn = tp;
-
- addEdge(pp, pn, tp, tn, prevFlags, 0); //throws bad_alloc
-
- pp = pn;
- tp = tn;
- prevFlags = 0;
- }
- addEdge(pp, p2, tp, outgoingTangent, prevFlags, END_SEGMENT); //throws bad_alloc
- return true;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Tessellates a cubic-to segment.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-bool Path::addCubicTo(const Matrix3x3& pathToSurface, const Vector2& p0, const Vector2& p1, const Vector2& p2, const Vector2& p3, bool subpathHasGeometry, float strokeWidth)
-{
- RI_UNREF(pathToSurface);
- RI_UNREF(strokeWidth);
-
- if(p0 == p1 && p0 == p2 && p0 == p3)
- {
- RI_ASSERT(p1 == p2 && p1 == p3 && p2 == p3);
- return false; //discard zero-length segments
- }
-
- //compute end point tangents
- Vector2 incomingTangent = normalize(p1 - p0);
- Vector2 outgoingTangent = normalize(p3 - p2);
- if(p0 == p1)
- {
- incomingTangent = normalize(p2 - p0);
- if(p1 == p2)
- incomingTangent = normalize(p3 - p0);
- }
- if(p2 == p3)
- {
- outgoingTangent = normalize(p3 - p1);
- if(p1 == p2)
- outgoingTangent = normalize(p3 - p0);
- }
- RI_ASSERT(!isZero(incomingTangent) && !isZero(outgoingTangent));
-
- m_numTessVertices = 0;
- unsigned int startFlags = START_SEGMENT;
- if(!subpathHasGeometry)
- startFlags |= START_SUBPATH;
-
- const int segments = RI_NUM_TESSELLATED_SEGMENTS_CUBIC;
- Vector2 pp = p0;
- Vector2 tp = incomingTangent;
- unsigned int prevFlags = startFlags;
- for(int i=1;i<segments;i++)
- {
- RIfloat t = (RIfloat)i / (RIfloat)segments;
- Vector2 pn = (1.0f - 3.0f*t + 3.0f*t*t - t*t*t) * p0 + (3.0f*t - 6.0f*t*t + 3.0f*t*t*t) * p1 + (3.0f*t*t - 3.0f*t*t*t) * p2 + t*t*t * p3;
- Vector2 tn = (-3.0f + 6.0f*t - 3.0f*t*t) * p0 + (3.0f - 12.0f*t + 9.0f*t*t) * p1 + (6.0f*t - 9.0f*t*t) * p2 + 3.0f*t*t * p3;
-
- tn = normalize(tn);
- if(isZero(tn))
- tn = tp;
-
- addEdge(pp, pn, tp, tn, prevFlags, 0); //throws bad_alloc
-
- pp = pn;
- tp = tn;
- prevFlags = 0;
- }
- addEdge(pp, p3, tp, outgoingTangent, prevFlags, END_SEGMENT); //throws bad_alloc
- return true;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Finds an ellipse center and transformation from the unit circle to
-* that ellipse.
-* \param rh Length of the horizontal axis
-* rv Length of the vertical axis
-* rot Rotation angle
-* p0,p1 User space end points of the arc
-* c0,c1 (Return value) Unit circle space center points of the two ellipses
-* u0,u1 (Return value) Unit circle space end points of the arc
-* unitCircleToEllipse (Return value) A matrix mapping from unit circle space to user space
-* \return true if ellipse exists, false if doesn't
-* \note
-*//*-------------------------------------------------------------------*/
-
-static bool findEllipses(RIfloat rh, RIfloat rv, RIfloat rot, const Vector2& p0, const Vector2& p1, VGPathSegment segment, Vector2& c0, Vector2& c1, Vector2& u0, Vector2& u1, Matrix3x3& unitCircleToEllipse, bool& cw)
-{
- rh = RI_ABS(rh);
- rv = RI_ABS(rv);
- if(rh == 0.0f || rv == 0.0f || p0 == p1)
- return false; //degenerate ellipse
-
- rot = RI_DEG_TO_RAD(rot);
- unitCircleToEllipse.set((RIfloat)cos(rot)*rh, -(RIfloat)sin(rot)*rv, 0,
- (RIfloat)sin(rot)*rh, (RIfloat)cos(rot)*rv, 0,
- 0, 0, 1);
- Matrix3x3 ellipseToUnitCircle = invert(unitCircleToEllipse);
- //force affinity
- ellipseToUnitCircle[2][0] = 0.0f;
- ellipseToUnitCircle[2][1] = 0.0f;
- ellipseToUnitCircle[2][2] = 1.0f;
-
- // Transform p0 and p1 into unit space
- u0 = affineTransform(ellipseToUnitCircle, p0);
- u1 = affineTransform(ellipseToUnitCircle, p1);
-
- Vector2 m = 0.5f * (u0 + u1);
- Vector2 d = u0 - u1;
-
- RIfloat lsq = (RIfloat)dot(d,d);
- if(lsq <= 0.0f)
- return false; //the points are coincident
-
- RIfloat disc = (1.0f / lsq) - 0.25f;
- if(disc < 0.0f)
- { //the points are too far apart for a solution to exist, scale the axes so that there is a solution
- RIfloat l = (RIfloat)sqrt(lsq);
- rh *= 0.5f * l;
- rv *= 0.5f * l;
-
- //redo the computation with scaled axes
- unitCircleToEllipse.set((RIfloat)cos(rot)*rh, -(RIfloat)sin(rot)*rv, 0,
- (RIfloat)sin(rot)*rh, (RIfloat)cos(rot)*rv, 0,
- 0, 0, 1);
- ellipseToUnitCircle = invert(unitCircleToEllipse);
- //force affinity
- ellipseToUnitCircle[2][0] = 0.0f;
- ellipseToUnitCircle[2][1] = 0.0f;
- ellipseToUnitCircle[2][2] = 1.0f;
-
- // Transform p0 and p1 into unit space
- u0 = affineTransform(ellipseToUnitCircle, p0);
- u1 = affineTransform(ellipseToUnitCircle, p1);
-
- // Solve for intersecting unit circles
- d = u0 - u1;
- m = 0.5f * (u0 + u1);
-
- lsq = dot(d,d);
- if(lsq <= 0.0f)
- return false; //the points are coincident
-
- disc = RI_MAX(0.0f, 1.0f / lsq - 0.25f);
- }
-
- if(u0 == u1)
- return false;
-
- Vector2 sd = d * (RIfloat)sqrt(disc);
- Vector2 sp = perpendicularCW(sd);
- c0 = m + sp;
- c1 = m - sp;
-
- //choose the center point and direction
- Vector2 cp = c0;
- if(segment == VG_SCWARC_TO || segment == VG_LCCWARC_TO)
- cp = c1;
- cw = false;
- if(segment == VG_SCWARC_TO || segment == VG_LCWARC_TO)
- cw = true;
-
- //move the unit circle origin to the chosen center point
- u0 -= cp;
- u1 -= cp;
-
- if(u0 == u1 || isZero(u0) || isZero(u1))
- return false;
-
- //transform back to the original coordinate space
- cp = affineTransform(unitCircleToEllipse, cp);
- unitCircleToEllipse[0][2] = cp.x;
- unitCircleToEllipse[1][2] = cp.y;
- return true;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Tessellates an arc-to segment.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-bool Path::addArcTo(const Matrix3x3& pathToSurface, const Vector2& p0, RIfloat rh, RIfloat rv, RIfloat rot, const Vector2& p1, const Vector2& p1r, VGPathSegment segment, bool subpathHasGeometry, float strokeWidth)
-{
- RI_UNREF(pathToSurface);
- RI_UNREF(strokeWidth);
-
- if(p0 == p1)
- return false; //discard zero-length segments
-
- // Check NaNs
- // \todo Make a general vec2 function?
- if (RI_ISNAN(p0.x) || RI_ISNAN(p0.y))
- return false;
-
- if (RI_ISNAN(p1.x) || RI_ISNAN(p1.y))
- return false;
-
- Vector2 c0, c1, u0, u1;
- Matrix3x3 unitCircleToEllipse;
- bool cw;
-
- m_numTessVertices = 0;
- unsigned int startFlags = START_SEGMENT;
- if(!subpathHasGeometry)
- startFlags |= START_SUBPATH;
-
- if(!findEllipses(rh, rv, rot, Vector2(), p1r, segment, c0, c1, u0, u1, unitCircleToEllipse, cw))
- { //ellipses don't exist, add line instead
- Vector2 t = normalize(p1r);
- RI_ASSERT(!isZero(t));
- addEdge(p0, p1, t, t, startFlags, END_SEGMENT); //throws bad_alloc
- return true;
- }
-
- //compute end point tangents
- Vector2 incomingTangent = perpendicular(u0, cw);
- incomingTangent = affineTangentTransform(unitCircleToEllipse, incomingTangent);
- incomingTangent = normalize(incomingTangent);
- Vector2 outgoingTangent = perpendicular(u1, cw);
- outgoingTangent = affineTangentTransform(unitCircleToEllipse, outgoingTangent);
- outgoingTangent = normalize(outgoingTangent);
- RI_ASSERT(!isZero(incomingTangent) && !isZero(outgoingTangent));
-
- const int segments = RI_NUM_TESSELLATED_SEGMENTS_ARC;
- Vector2 pp = p0;
- Vector2 tp = incomingTangent;
- unsigned int prevFlags = startFlags;
- for(int i=1;i<segments;i++)
- {
- RIfloat t = (RIfloat)i / (RIfloat)segments;
- Vector2 pn = circularLerp(u0, u1, t, cw);
- Vector2 tn = perpendicular(pn, cw);
- tn = affineTangentTransform(unitCircleToEllipse, tn);
- pn = affineTransform(unitCircleToEllipse, pn) + p0;
- tn = normalize(tn);
- if(isZero(tn))
- tn = tp;
-
- addEdge(pp, pn, tp, tn, prevFlags, 0); //throws bad_alloc
-
- pp = pn;
- tp = tn;
- prevFlags = 0;
- }
- addEdge(pp, p1, tp, outgoingTangent, prevFlags, END_SEGMENT); //throws bad_alloc
- return true;
-}
-
-/*-------------------------------------------------------------------*//*!
-* \brief Tessellates a path.
-* \param
-* \return
-* \note tessellation output format: A list of vertices describing the
-* path tessellated into line segments and relevant aspects of the
-* input data. Each path segment has a start vertex, a number of
-* internal vertices (possibly zero), and an end vertex. The start
-* and end of segments and subpaths have been flagged, as well as
-* implicit and explicit close subpath segments.
-*//*-------------------------------------------------------------------*/
-
-void Path::tessellate(const Matrix3x3& pathToSurface, float strokeWidth)
-{
- m_vertices.clear();
-
- m_userMinx = RI_FLOAT_MAX;
- m_userMiny = RI_FLOAT_MAX;
- m_userMaxx = -RI_FLOAT_MAX;
- m_userMaxy = -RI_FLOAT_MAX;
-
- try
- {
- m_segmentToVertex.resize(m_segments.size());
-
- int coordIndex = 0;
- Vector2 s(0,0); //the beginning of the current subpath
- Vector2 o(0,0); //the last point of the previous segment
- Vector2 p(0,0); //the last internal control point of the previous segment, if the segment was a (regular or smooth) quadratic or cubic Bezier, or else the last point of the previous segment
-
- //tessellate the path segments
- coordIndex = 0;
- s.set(0,0);
- o.set(0,0);
- p.set(0,0);
- bool subpathHasGeometry = false;
- VGPathSegment prevSegment = VG_MOVE_TO;
- for(int i=0;i<m_segments.size();i++)
- {
- VGPathSegment segment = getPathSegment(m_segments[i]);
- VGPathAbsRel absRel = getPathAbsRel(m_segments[i]);
- int coords = segmentToNumCoordinates(segment);
- m_segmentToVertex[i].start = m_vertices.size();
-
- switch(segment)
- {
- case VG_CLOSE_PATH:
- {
- RI_ASSERT(coords == 0);
- addEndPath(pathToSurface, o, s, subpathHasGeometry, CLOSE_SUBPATH);
- p = s;
- o = s;
- subpathHasGeometry = false;
- break;
- }
-
- case VG_MOVE_TO:
- {
- RI_ASSERT(coords == 2);
- Vector2 c(getCoordinate(coordIndex+0), getCoordinate(coordIndex+1));
- if(absRel == VG_RELATIVE)
- c += o;
- if(prevSegment != VG_MOVE_TO && prevSegment != VG_CLOSE_PATH)
- addEndPath(pathToSurface, o, s, subpathHasGeometry, IMPLICIT_CLOSE_SUBPATH);
- s = c;
- p = c;
- o = c;
- subpathHasGeometry = false;
- break;
- }
-
- case VG_LINE_TO:
- {
- RI_ASSERT(coords == 2);
- Vector2 c(getCoordinate(coordIndex+0), getCoordinate(coordIndex+1));
- if(absRel == VG_RELATIVE)
- c += o;
- if(addLineTo(pathToSurface, o, c, subpathHasGeometry))
- subpathHasGeometry = true;
- p = c;
- o = c;
- break;
- }
-
- case VG_HLINE_TO:
- {
- RI_ASSERT(coords == 1);
- Vector2 c(getCoordinate(coordIndex+0), o.y);
- if(absRel == VG_RELATIVE)
- c.x += o.x;
- if(addLineTo(pathToSurface, o, c, subpathHasGeometry))
- subpathHasGeometry = true;
- p = c;
- o = c;
- break;
- }
-
- case VG_VLINE_TO:
- {
- RI_ASSERT(coords == 1);
- Vector2 c(o.x, getCoordinate(coordIndex+0));
- if(absRel == VG_RELATIVE)
- c.y += o.y;
- if(addLineTo(pathToSurface, o, c, subpathHasGeometry))
- subpathHasGeometry = true;
- p = c;
- o = c;
- break;
- }
-
- case VG_QUAD_TO:
- {
- RI_ASSERT(coords == 4);
- Vector2 c0(getCoordinate(coordIndex+0), getCoordinate(coordIndex+1));
- Vector2 c1(getCoordinate(coordIndex+2), getCoordinate(coordIndex+3));
- if(absRel == VG_RELATIVE)
- {
- c0 += o;
- c1 += o;
- }
- if(addQuadTo(pathToSurface, o, c0, c1, subpathHasGeometry, strokeWidth))
- subpathHasGeometry = true;
- p = c0;
- o = c1;
- break;
- }
-
- case VG_SQUAD_TO:
- {
- RI_ASSERT(coords == 2);
- Vector2 c0 = 2.0f * o - p;
- Vector2 c1(getCoordinate(coordIndex+0), getCoordinate(coordIndex+1));
- if(absRel == VG_RELATIVE)
- c1 += o;
- if(addQuadTo(pathToSurface, o, c0, c1, subpathHasGeometry, strokeWidth))
- subpathHasGeometry = true;
- p = c0;
- o = c1;
- break;
- }
-
- case VG_CUBIC_TO:
- {
- RI_ASSERT(coords == 6);
- Vector2 c0(getCoordinate(coordIndex+0), getCoordinate(coordIndex+1));
- Vector2 c1(getCoordinate(coordIndex+2), getCoordinate(coordIndex+3));
- Vector2 c2(getCoordinate(coordIndex+4), getCoordinate(coordIndex+5));
- if(absRel == VG_RELATIVE)
- {
- c0 += o;
- c1 += o;
- c2 += o;
- }
- if(addCubicTo(pathToSurface, o, c0, c1, c2, subpathHasGeometry, strokeWidth))
- subpathHasGeometry = true;
- p = c1;
- o = c2;
- break;
- }
-
- case VG_SCUBIC_TO:
- {
- RI_ASSERT(coords == 4);
- Vector2 c0 = 2.0f * o - p;
- Vector2 c1(getCoordinate(coordIndex+0), getCoordinate(coordIndex+1));
- Vector2 c2(getCoordinate(coordIndex+2), getCoordinate(coordIndex+3));
- if(absRel == VG_RELATIVE)
- {
- c1 += o;
- c2 += o;
- }
- if(addCubicTo(pathToSurface, o, c0, c1, c2, subpathHasGeometry, strokeWidth))
- subpathHasGeometry = true;
- p = c1;
- o = c2;
- break;
- }
-
- default:
- {
- RI_ASSERT(segment == VG_SCCWARC_TO || segment == VG_SCWARC_TO ||
- segment == VG_LCCWARC_TO || segment == VG_LCWARC_TO);
- RI_ASSERT(coords == 5);
- RIfloat rh = getCoordinate(coordIndex+0);
- RIfloat rv = getCoordinate(coordIndex+1);
- RIfloat rot = getCoordinate(coordIndex+2);
- Vector2 c(getCoordinate(coordIndex+3), getCoordinate(coordIndex+4));
-
- Vector2 cr = c;
- if(absRel == VG_ABSOLUTE)
- cr -= o;
- else
- c += o;
-
- if(addArcTo(pathToSurface, o, rh, rv, rot, c, cr, segment, subpathHasGeometry, strokeWidth))
- subpathHasGeometry = true;
- p = c;
- o = c;
- break;
- }
- }
-
- if(m_vertices.size() > m_segmentToVertex[i].start)
- { //segment produced vertices
- m_segmentToVertex[i].end = m_vertices.size() - 1;
- }
- else
- { //segment didn't produce vertices (zero-length segment). Ignore it.
- m_segmentToVertex[i].start = m_segmentToVertex[i].end = m_vertices.size()-1;
- }
- prevSegment = segment;
- coordIndex += coords;
- }
-
- //add an implicit MOVE_TO to the end to close the last subpath.
- //if the subpath contained only zero-length segments, this produces the necessary geometry to get it stroked
- // and included in path bounds. The geometry won't be included in the pointAlongPath query.
- if(prevSegment != VG_MOVE_TO && prevSegment != VG_CLOSE_PATH)
- addEndPath(pathToSurface, o, s, subpathHasGeometry, IMPLICIT_CLOSE_SUBPATH);
-
- //check that the flags are correct
-#ifdef RI_DEBUG
- int prev = -1;
- bool subpathStarted = false;
- bool segmentStarted = false;
- for(int i=0;i<m_vertices.size();i++)
- {
- Vertex& v = m_vertices[i];
-
- if(v.flags & START_SUBPATH)
- {
- RI_ASSERT(!subpathStarted);
- RI_ASSERT(v.flags & START_SEGMENT);
- RI_ASSERT(!(v.flags & END_SUBPATH));
- RI_ASSERT(!(v.flags & END_SEGMENT));
- RI_ASSERT(!(v.flags & CLOSE_SUBPATH));
- RI_ASSERT(!(v.flags & IMPLICIT_CLOSE_SUBPATH));
- subpathStarted = true;
- }
-
- if(v.flags & START_SEGMENT)
- {
- RI_ASSERT(subpathStarted || (v.flags & CLOSE_SUBPATH) || (v.flags & IMPLICIT_CLOSE_SUBPATH));
- RI_ASSERT(!segmentStarted);
- RI_ASSERT(!(v.flags & END_SUBPATH));
- RI_ASSERT(!(v.flags & END_SEGMENT));
- segmentStarted = true;
- }
-
- if( v.flags & CLOSE_SUBPATH )
- {
- RI_ASSERT(segmentStarted);
- RI_ASSERT(!subpathStarted);
- RI_ASSERT((v.flags & START_SEGMENT) || (v.flags & END_SEGMENT));
- RI_ASSERT(!(v.flags & IMPLICIT_CLOSE_SUBPATH));
- RI_ASSERT(!(v.flags & START_SUBPATH));
- RI_ASSERT(!(v.flags & END_SUBPATH));
- }
- if( v.flags & IMPLICIT_CLOSE_SUBPATH )
- {
- RI_ASSERT(segmentStarted);
- RI_ASSERT(!subpathStarted);
- RI_ASSERT((v.flags & START_SEGMENT) || (v.flags & END_SEGMENT));
- RI_ASSERT(!(v.flags & CLOSE_SUBPATH));
- RI_ASSERT(!(v.flags & START_SUBPATH));
- RI_ASSERT(!(v.flags & END_SUBPATH));
- }
-
- if( prev >= 0 )
- {
- RI_ASSERT(segmentStarted);
- RI_ASSERT(subpathStarted || ((m_vertices[prev].flags & CLOSE_SUBPATH) && (m_vertices[i].flags & CLOSE_SUBPATH)) ||
- ((m_vertices[prev].flags & IMPLICIT_CLOSE_SUBPATH) && (m_vertices[i].flags & IMPLICIT_CLOSE_SUBPATH)));
- }
-
- prev = i;
- if(v.flags & END_SEGMENT)
- {
- RI_ASSERT(subpathStarted || (v.flags & CLOSE_SUBPATH) || (v.flags & IMPLICIT_CLOSE_SUBPATH));
- RI_ASSERT(segmentStarted);
- RI_ASSERT(!(v.flags & START_SUBPATH));
- RI_ASSERT(!(v.flags & START_SEGMENT));
- segmentStarted = false;
- prev = -1;
- }
-
- if(v.flags & END_SUBPATH)
- {
- RI_ASSERT(subpathStarted);
- RI_ASSERT(v.flags & END_SEGMENT);
- RI_ASSERT(!(v.flags & START_SUBPATH));
- RI_ASSERT(!(v.flags & START_SEGMENT));
- RI_ASSERT(!(v.flags & CLOSE_SUBPATH));
- RI_ASSERT(!(v.flags & IMPLICIT_CLOSE_SUBPATH));
- subpathStarted = false;
- }
- }
-#endif //RI_DEBUG
- }
- catch(std::bad_alloc)
- {
- m_vertices.clear();
- throw;
- }
-}
-
-//==============================================================================================
-
-} //namespace OpenVGRI
-
-//==============================================================================================