From 37a92b86d13e89d0dcec92be6d23ceced29dbc36 Mon Sep 17 00:00:00 2001 From: scuri Date: Mon, 21 Jun 2010 22:55:10 +0000 Subject: *** empty log message *** --- src/ftgl/FTVectoriser.cpp | 328 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 328 insertions(+) create mode 100644 src/ftgl/FTVectoriser.cpp (limited to 'src/ftgl/FTVectoriser.cpp') diff --git a/src/ftgl/FTVectoriser.cpp b/src/ftgl/FTVectoriser.cpp new file mode 100644 index 0000000..ea5c571 --- /dev/null +++ b/src/ftgl/FTVectoriser.cpp @@ -0,0 +1,328 @@ +/* + * FTGL - OpenGL font library + * + * Copyright (c) 2001-2004 Henry Maddocks + * Copyright (c) 2008 Éric Beets + * Copyright (c) 2008 Sam Hocevar + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is 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 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. + */ + +#include "config.h" + +#include "FTInternals.h" +#include "FTVectoriser.h" + +#ifndef CALLBACK +#define CALLBACK +#endif + +#if defined __APPLE_CC__ && __APPLE_CC__ < 5465 + typedef GLvoid (*GLUTesselatorFunction) (...); +#elif defined WIN32 && !defined __CYGWIN__ + typedef GLvoid (CALLBACK *GLUTesselatorFunction) (); +#else + typedef GLvoid (*GLUTesselatorFunction) (); +#endif + + +void CALLBACK ftglError(GLenum errCode, FTMesh* mesh) +{ + mesh->Error(errCode); +} + + +void CALLBACK ftglVertex(void* data, FTMesh* mesh) +{ + FTGL_DOUBLE* vertex = static_cast(data); + mesh->AddPoint(vertex[0], vertex[1], vertex[2]); +} + + +void CALLBACK ftglCombine(FTGL_DOUBLE coords[3], void* vertex_data[4], GLfloat weight[4], void** outData, FTMesh* mesh) +{ + const FTGL_DOUBLE* vertex = static_cast(coords); + *outData = const_cast(mesh->Combine(vertex[0], vertex[1], vertex[2])); +} + +void CALLBACK ftglBegin(GLenum type, FTMesh* mesh) +{ + mesh->Begin(type); +} + + +void CALLBACK ftglEnd(FTMesh* mesh) +{ + mesh->End(); +} + + +FTMesh::FTMesh() +: currentTesselation(0), + err(0) +{ + tesselationList.reserve(16); +} + + +FTMesh::~FTMesh() +{ + for(size_t t = 0; t < tesselationList.size(); ++t) + { + delete tesselationList[t]; + } + + tesselationList.clear(); +} + + +void FTMesh::AddPoint(const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z) +{ + currentTesselation->AddPoint(x, y, z); +} + + +const FTGL_DOUBLE* FTMesh::Combine(const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z) +{ + tempPointList.push_back(FTPoint(x, y,z)); + return static_cast(tempPointList.back()); +} + + +void FTMesh::Begin(GLenum meshType) +{ + currentTesselation = new FTTesselation(meshType); +} + + +void FTMesh::End() +{ + tesselationList.push_back(currentTesselation); +} + + +const FTTesselation* const FTMesh::Tesselation(size_t index) const +{ + return (index < tesselationList.size()) ? tesselationList[index] : NULL; +} + + +FTVectoriser::FTVectoriser(const FT_GlyphSlot glyph) +: contourList(0), + mesh(0), + ftContourCount(0), + contourFlag(0) +{ + if(glyph) + { + outline = glyph->outline; + + ftContourCount = outline.n_contours; + contourList = 0; + contourFlag = outline.flags; + + ProcessContours(); + } +} + + +FTVectoriser::~FTVectoriser() +{ + for(size_t c = 0; c < ContourCount(); ++c) + { + delete contourList[c]; + } + + delete [] contourList; + delete mesh; +} + + +void FTVectoriser::ProcessContours() +{ + short contourLength = 0; + short startIndex = 0; + short endIndex = 0; + + contourList = new FTContour*[ftContourCount]; + + for(int i = 0; i < ftContourCount; ++i) + { + FT_Vector* pointList = &outline.points[startIndex]; + char* tagList = &outline.tags[startIndex]; + + endIndex = outline.contours[i]; + contourLength = (endIndex - startIndex) + 1; + + FTContour* contour = new FTContour(pointList, tagList, contourLength); + + contourList[i] = contour; + + startIndex = endIndex + 1; + } + + // Compute each contour's parity. FIXME: see if FT_Outline_Get_Orientation + // can do it for us. + for(int i = 0; i < ftContourCount; i++) + { + FTContour *c1 = contourList[i]; + + // 1. Find the leftmost point. + FTPoint leftmost(65536.0, 0.0); + + for(size_t n = 0; n < c1->PointCount(); n++) + { + FTPoint p = c1->Point(n); + if(p.X() < leftmost.X()) + { + leftmost = p; + } + } + + // 2. Count how many other contours we cross when going further to + // the left. + int parity = 0; + + for(int j = 0; j < ftContourCount; j++) + { + if(j == i) + { + continue; + } + + FTContour *c2 = contourList[j]; + + for(size_t n = 0; n < c2->PointCount(); n++) + { + FTPoint p1 = c2->Point(n); + FTPoint p2 = c2->Point((n + 1) % c2->PointCount()); + + /* FIXME: combinations of >= > <= and < do not seem stable */ + if((p1.Y() < leftmost.Y() && p2.Y() < leftmost.Y()) + || (p1.Y() >= leftmost.Y() && p2.Y() >= leftmost.Y()) + || (p1.X() > leftmost.X() && p2.X() > leftmost.X())) + { + continue; + } + else if(p1.X() < leftmost.X() && p2.X() < leftmost.X()) + { + parity++; + } + else + { + FTPoint a = p1 - leftmost; + FTPoint b = p2 - leftmost; + if(b.X() * a.Y() > b.Y() * a.X()) + { + parity++; + } + } + } + } + + // 3. Make sure the glyph has the proper parity. + c1->SetParity(parity); + } +} + + +size_t FTVectoriser::PointCount() +{ + size_t s = 0; + for(size_t c = 0; c < ContourCount(); ++c) + { + s += contourList[c]->PointCount(); + } + + return s; +} + + +const FTContour* const FTVectoriser::Contour(size_t index) const +{ + return (index < ContourCount()) ? contourList[index] : NULL; +} + + +void FTVectoriser::MakeMesh(FTGL_DOUBLE zNormal, int outsetType, float outsetSize) +{ + if(mesh) + { + delete mesh; + } + + mesh = new FTMesh; + + GLUtesselator* tobj = gluNewTess(); + + gluTessCallback(tobj, GLU_TESS_BEGIN_DATA, (GLUTesselatorFunction)ftglBegin); + gluTessCallback(tobj, GLU_TESS_VERTEX_DATA, (GLUTesselatorFunction)ftglVertex); + gluTessCallback(tobj, GLU_TESS_COMBINE_DATA, (GLUTesselatorFunction)ftglCombine); + gluTessCallback(tobj, GLU_TESS_END_DATA, (GLUTesselatorFunction)ftglEnd); + gluTessCallback(tobj, GLU_TESS_ERROR_DATA, (GLUTesselatorFunction)ftglError); + + if(contourFlag & ft_outline_even_odd_fill) // ft_outline_reverse_fill + { + gluTessProperty(tobj, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD); + } + else + { + gluTessProperty(tobj, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_NONZERO); + } + + + gluTessProperty(tobj, GLU_TESS_TOLERANCE, 0); + gluTessNormal(tobj, 0.0f, 0.0f, zNormal); + gluTessBeginPolygon(tobj, mesh); + + for(size_t c = 0; c < ContourCount(); ++c) + { + /* Build the */ + switch(outsetType) + { + case 1 : contourList[c]->buildFrontOutset(outsetSize); break; + case 2 : contourList[c]->buildBackOutset(outsetSize); break; + } + const FTContour* contour = contourList[c]; + + + gluTessBeginContour(tobj); + for(size_t p = 0; p < contour->PointCount(); ++p) + { + const FTGL_DOUBLE* d; + switch(outsetType) + { + case 1: d = contour->FrontPoint(p); break; + case 2: d = contour->BackPoint(p); break; + case 0: default: d = contour->Point(p); break; + } + // XXX: gluTessVertex doesn't modify the data but does not + // specify "const" in its prototype, so we cannot cast to + // a const type. + gluTessVertex(tobj, (GLdouble *)d, (GLvoid *)d); + } + + gluTessEndContour(tobj); + } + gluTessEndPolygon(tobj); + + gluDeleteTess(tobj); +} + -- cgit v1.2.3