22 Mar
2013
22 Mar
'13
3:10 p.m.
Author: jgardou
Date: Fri Mar 22 15:10:46 2013
New Revision: 58571
URL: http://svn.reactos.org/svn/reactos?rev=58571&view=rev
Log:
[OPENGL32]
* Sync implementation of wglUseFontBitmaps and wglUseFontOutlines with WINE 1.5.26
Modified:
trunk/reactos/dll/opengl/opengl32/font.c
trunk/reactos/dll/opengl/opengl32/opengl32.spec
Modified: trunk/reactos/dll/opengl/opengl32/font.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/opengl/opengl32/font.c…
==============================================================================
--- trunk/reactos/dll/opengl/opengl32/font.c [iso-8859-1] (original)
+++ trunk/reactos/dll/opengl/opengl32/font.c [iso-8859-1] Fri Mar 22 15:10:46 2013
@@ -1,1155 +1,565 @@
-/****************************************************************************
-* Copyright (C) 1991-2004 SciTech Software, Inc. All rights reserved.
-*
-* 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
-* SCITECH SOFTWARE INC 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 "opengl32.h"
+/* Window-specific OpenGL functions implementation.
+ *
+ * Copyright (c) 1999 Lionel Ulmer
+ * Copyright (c) 2005 Raphael Junqueira
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdarg.h>
#include <math.h>
-
-#define LINE_BUF_QUANT 4000
-#define VERT_BUF_QUANT 4000
-
-static HFONT hNewFont, hOldFont;
-static FLOAT ScaleFactor;
-static FLOAT* LineBuf;
-static DWORD LineBufSize;
-static DWORD LineBufIndex;
-static FLOAT* VertBuf;
-static DWORD VertBufSize;
-static DWORD VertBufIndex;
-static GLenum TessErrorOccurred;
-
-/*****************************************************************************
-* AppendToLineBuf
-*
-* Appends one floating-point value to the global LineBuf array. Return value
-* is non-zero for success, zero for failure.
-*****************************************************************************/
-
-INT AppendToLineBuf(FLOAT value)
-{
- if (LineBufIndex >= LineBufSize)
- {
- FLOAT* f;
- LineBufSize += LINE_BUF_QUANT;
-
- f = (FLOAT*) HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, LineBuf,
(LineBufSize) * sizeof(FLOAT));
- if (!f)
- return 0;
- LineBuf = f;
- }
- LineBuf[LineBufIndex++] = value;
- return 1;
-}
-
-/*****************************************************************************
-* AppendToVertBuf
-*
-* Appends one floating-point value to the global VertBuf array. Return value
-* is non-zero for success, zero for failure.
-*
-* Note that we can't realloc this one, because the tessellator is using
-* pointers into it.
-*****************************************************************************/
-
-INT AppendToVertBuf(FLOAT value)
-{
- if (VertBufIndex >= VertBufSize)
- return 0;
- VertBuf[VertBufIndex++] = value;
- return 1;
-}
-
-/*****************************************************************************
-* GetWord
-*
-* Fetch the next 16-bit word from a little-endian byte stream, and increment
-* the stream pointer to the next unscanned byte.
-*****************************************************************************/
-
-LONG GetWord(UCHAR** p)
-{
- LONG value;
-
- value = ((*p)[1] << 8) + (*p)[0];
- *p += 2;
- return value;
-}
-
-/*****************************************************************************
-* GetDWord
-*
-* Fetch the next 32-bit word from a little-endian byte stream, and increment
-* the stream pointer to the next unscanned byte.
-*****************************************************************************/
-
-LONG GetDWord(UCHAR** p)
-{
- LONG value;
-
- value = ((*p)[3] << 24) + ((*p)[2] << 16) + ((*p)[1] << 8) +
(*p)[0];
- *p += 4;
- return value;
-}
-
-/*****************************************************************************
-* GetFixed
-*
-* Fetch the next 32-bit fixed-point value from a little-endian byte stream,
-* convert it to floating-point, and increment the stream pointer to the next
-* unscanned byte.
-*****************************************************************************/
-double GetFixed(UCHAR** p)
-{
- LONG hiBits, loBits;
- double value;
-
- loBits = GetWord(p);
- hiBits = GetWord(p);
- value = (double) ((hiBits << 16) | loBits) / 65536.0;
-
- return value * ScaleFactor;
-}
-
-
-/*****************************************************************************
-**
-** InvertGlyphBitmap.
-**
-** Invert the bitmap so that it suits OpenGL's representation.
-** Each row starts on a double word boundary.
-**
-*****************************************************************************/
-
-VOID InvertGlyphBitmap(INT w, INT h, DWORD *fptr, DWORD *tptr)
-{
- INT dWordsInRow = (w+31)/32;
- INT i, j;
-
- if (w <= 0 || h <= 0) {
- return;
- }
-
- tptr += ((h-1)*dWordsInRow);
- for (i = 0; i < h; i++) {
- for (j = 0; j < dWordsInRow; j++) {
- *(tptr + j) = *(fptr + j);
- }
- tptr -= dWordsInRow;
- fptr += dWordsInRow;
- }
-}
-
-/*****************************************************************************
-* CreateHighResolutionFont
-*
-* Gets metrics for the current font and creates an equivalent font
-* scaled to the design units of the font.
-*
-*****************************************************************************/
-
-HFONT CreateHighResolutionFont(HDC hDC)
-{
- UINT otmSize;
- OUTLINETEXTMETRIC *otm;
- LONG fontHeight, fontWidth, fontUnits;
- LOGFONTW logFont, logFontFaceName;
-
- otmSize = GetOutlineTextMetricsW(hDC, 0, NULL);
- if (!otmSize)
- return NULL;
-
- otm = (OUTLINETEXTMETRIC *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, otmSize);
- if (!otm)
- return NULL;
-
- otm->otmSize = otmSize;
- if (!GetOutlineTextMetricsW(hDC, otmSize, otm))
- return NULL;
-
- GetObjectW(GetCurrentObject(hDC, OBJ_FONT), sizeof(logFontFaceName),
&logFontFaceName);
-
- fontHeight = otm->otmTextMetrics.tmHeight -
- otm->otmTextMetrics.tmInternalLeading;
- fontWidth = otm->otmTextMetrics.tmAveCharWidth;
- fontUnits = (LONG) otm->otmEMSquare;
-
- ScaleFactor = 1.0F / (FLOAT) fontUnits;
-
- logFont.lfHeight = - ((LONG) fontUnits);
- logFont.lfWidth = (LONG)((FLOAT) (fontWidth * fontUnits) / (FLOAT) fontHeight);
- logFont.lfEscapement = 0;
- logFont.lfOrientation = 0;
- logFont.lfWeight = otm->otmTextMetrics.tmWeight;
- logFont.lfItalic = otm->otmTextMetrics.tmItalic;
- logFont.lfUnderline = otm->otmTextMetrics.tmUnderlined;
- logFont.lfStrikeOut = otm->otmTextMetrics.tmStruckOut;
- logFont.lfCharSet = otm->otmTextMetrics.tmCharSet;
- logFont.lfOutPrecision = OUT_OUTLINE_PRECIS;
- logFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
- logFont.lfQuality = DEFAULT_QUALITY;
- logFont.lfPitchAndFamily =
- otm->otmTextMetrics.tmPitchAndFamily & 0xf0;
- wcscpy(logFont.lfFaceName, logFontFaceName.lfFaceName);
-
- hNewFont = CreateFontIndirectW(&logFont);
-
- HeapFree(GetProcessHeap(), 0, otm);
-
- return hNewFont;
-}
-
-/*****************************************************************************
-* MakeLinesFromArc
-*
-* Subdivides one arc of a quadratic spline until the chordal deviation
-* tolerance requirement is met, then places the resulting set of line
-* segments in the global LineBuf.
-*****************************************************************************/
-INT MakeLinesFromArc(FLOAT x0, FLOAT y0, FLOAT x1, FLOAT y1, FLOAT x2, FLOAT y2,
- DWORD vertexCountIndex, FLOAT chordalDeviationSquared)
-{
- FLOAT x01;
- FLOAT y01;
- FLOAT x12;
- FLOAT y12;
- FLOAT midPointX;
- FLOAT midPointY;
- FLOAT deltaX;
- FLOAT deltaY;
-
- /*
- * Calculate midpoint of the curve by de Casteljau:
- */
- x01 = 0.5F * (x0 + x1);
- y01 = 0.5F * (y0 + y1);
- x12 = 0.5F * (x1 + x2);
- y12 = 0.5F * (y1 + y2);
- midPointX = 0.5F * (x01 + x12);
- midPointY = 0.5F * (y01 + y12);
-
-
- /*
- * Estimate chordal deviation by the distance from the midpoint
- * of the curve to its non-pointpolated control point. If this
- * distance is greater than the specified chordal deviation
- * constraint, then subdivide. Otherwise, generate polylines
- * from the three control points.
- */
- deltaX = midPointX - x1;
- deltaY = midPointY - y1;
-
- if (deltaX * deltaX + deltaY * deltaY > chordalDeviationSquared)
- {
- MakeLinesFromArc( x0, y0,
- x01, y01,
- midPointX, midPointY,
- vertexCountIndex,
- chordalDeviationSquared);
-
- MakeLinesFromArc( midPointX, midPointY,
- x12, y12,
- x2, y2,
- vertexCountIndex,
- chordalDeviationSquared);
- }
- else
- {
- /*
- * The "pen" is already at (x0, y0), so we don't need to
- * add that point to the LineBuf.
+#include <GL/gl.h>
+
+#include <windef.h>
+#include <winbase.h>
+#include <wingdi.h>
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(wgl);
+
+/***********************************************************************
+ * wglUseFontBitmaps_common
+ */
+static BOOL wglUseFontBitmaps_common( HDC hdc, DWORD first, DWORD count, DWORD listBase,
BOOL unicode )
+{
+ GLYPHMETRICS gm;
+ unsigned int glyph, size = 0;
+ void *bitmap = NULL, *gl_bitmap = NULL;
+ int org_alignment;
+ BOOL ret = TRUE;
+
+ glGetIntegerv(GL_UNPACK_ALIGNMENT, &org_alignment);
+ glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
+
+ for (glyph = first; glyph < first + count; glyph++) {
+ static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
+ unsigned int needed_size, height, width, width_int;
+
+ if (unicode)
+ needed_size = GetGlyphOutlineW(hdc, glyph, GGO_BITMAP, &gm, 0, NULL,
&identity);
+ else
+ needed_size = GetGlyphOutlineA(hdc, glyph, GGO_BITMAP, &gm, 0, NULL,
&identity);
+
+ TRACE("Glyph: %3d / List: %d size %d\n", glyph, listBase,
needed_size);
+ if (needed_size == GDI_ERROR) {
+ ret = FALSE;
+ break;
+ }
+
+ if (needed_size > size) {
+ size = needed_size;
+ HeapFree(GetProcessHeap(), 0, bitmap);
+ HeapFree(GetProcessHeap(), 0, gl_bitmap);
+ bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
+ gl_bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
+ }
+ if (unicode)
+ ret = (GetGlyphOutlineW(hdc, glyph, GGO_BITMAP, &gm, size, bitmap,
&identity) != GDI_ERROR);
+ else
+ ret = (GetGlyphOutlineA(hdc, glyph, GGO_BITMAP, &gm, size, bitmap,
&identity) != GDI_ERROR);
+ if (!ret) break;
+
+ if (TRACE_ON(wgl)) {
+ unsigned int bitmask;
+ unsigned char *bitmap_ = bitmap;
+
+ TRACE(" - bbox: %d x %d\n", gm.gmBlackBoxX, gm.gmBlackBoxY);
+ TRACE(" - origin: (%d, %d)\n", gm.gmptGlyphOrigin.x,
gm.gmptGlyphOrigin.y);
+ TRACE(" - increment: %d - %d\n", gm.gmCellIncX, gm.gmCellIncY);
+ if (needed_size != 0) {
+ TRACE(" - bitmap:\n");
+ for (height = 0; height < gm.gmBlackBoxY; height++) {
+ TRACE(" ");
+ for (width = 0, bitmask = 0x80; width < gm.gmBlackBoxX; width++,
bitmask >>= 1) {
+ if (bitmask == 0) {
+ bitmap_ += 1;
+ bitmask = 0x80;
+ }
+ if (*bitmap_ & bitmask)
+ TRACE("*");
+ else
+ TRACE(" ");
+ }
+ bitmap_ += (4 - ((UINT_PTR)bitmap_ & 0x03));
+ TRACE("\n");
+ }
+ }
+ }
+
+ /* In OpenGL, the bitmap is drawn from the bottom to the top... So we need to
invert the
+ * glyph for it to be drawn properly.
*/
- if (!AppendToLineBuf(x1)
- || !AppendToLineBuf(y1)
- || !AppendToLineBuf(x2)
- || !AppendToLineBuf(y2))
- return 0;
- LineBuf[vertexCountIndex] += 2.0F;
- }
-
- return 1;
-}
-
-/*****************************************************************************
-* MakeLinesFromTTQSpline
-*
-* Converts points from the poly quadratic spline in a TT_PRIM_QSPLINE
-* structure to polyline points in the global LineBuf.
-*****************************************************************************/
-
-INT MakeLinesFromTTQSpline( UCHAR** pp, DWORD vertexCountIndex, WORD pointCount, FLOAT
chordalDeviation)
-{
- FLOAT x0, y0, x1, y1, x2, y2;
- WORD point;
-
- /*
- * Process each of the non-pointpolated points in the outline.
- * To do this, we need to generate two pointpolated points (the
- * start and end of the arc) for each non-pointpolated point.
- * The first pointpolated point is always the one most recently
- * stored in LineBuf, so we just extract it from there. The
- * second pointpolated point is either the average of the next
- * two points in the QSpline, or the last point in the QSpline
- * if only one remains.
- */
- for (point = 0; point < pointCount - 1; ++point)
- {
- x0 = LineBuf[LineBufIndex - 2];
- y0 = LineBuf[LineBufIndex - 1];
-
- x1 = (FLOAT) GetFixed(pp);
- y1 = (FLOAT) GetFixed(pp);
-
- if (point == pointCount - 2)
- {
- /*
- * This is the last arc in the QSpline. The final
- * point is the end of the arc.
- */
- x2 = (FLOAT) GetFixed(pp);
- y2 = (FLOAT) GetFixed(pp);
- }
- else
- {
- /*
- * Peek at the next point in the input to compute
- * the end of the arc:
- */
- x2 = 0.5F * (x1 + (FLOAT) GetFixed(pp));
- y2 = 0.5F * (y1 + (FLOAT) GetFixed(pp));
- /*
- * Push the point back onto the input so it will
- * be reused as the next off-curve point:
- */
- *pp -= 8;
- }
-
- if (!MakeLinesFromArc( x0, y0,
- x1, y1,
- x2, y2,
- vertexCountIndex,
- chordalDeviation * chordalDeviation))
- return 0;
- }
-
- return 1;
-}
-
-/*****************************************************************************
-* MakeLinesFromTTLine
-*
-* Converts points from the polyline in a TT_PRIM_LINE structure to
-* equivalent points in the global LineBuf.
-*****************************************************************************/
-INT MakeLinesFromTTLine(UCHAR** pp, DWORD vertexCountIndex, WORD pointCount)
-{
- /*
- * Just copy the line segments into the line buffer (converting
- * type as we go):
- */
- LineBuf[vertexCountIndex] += pointCount;
- while (pointCount--)
- {
- if (!AppendToLineBuf((FLOAT) GetFixed(pp)) /* X coord */
- || !AppendToLineBuf((FLOAT) GetFixed(pp))) /* Y coord */
- return 0;
- }
-
- return 1;
-}
-
-/*****************************************************************************
-* MakeLinesFromTTPolyCurve
-*
-* Converts the lines and splines in a single TTPOLYCURVE structure to points
-* in the global LineBuf.
-*****************************************************************************/
-
-INT MakeLinesFromTTPolycurve(UCHAR** pp, DWORD vertexCountIndex, FLOAT chordalDeviation)
-{
- WORD type;
- WORD pointCount;
-
- /*
- * Pick up the relevant fields of the TTPOLYCURVE structure:
- */
- type = (WORD) GetWord(pp);
- pointCount = (WORD) GetWord(pp);
-
- /*
- * Convert the "curve" to line segments:
- */
- if (type == TT_PRIM_LINE)
- return MakeLinesFromTTLine( pp,
- vertexCountIndex,
- pointCount);
- else if (type == TT_PRIM_QSPLINE)
- return MakeLinesFromTTQSpline( pp,
- vertexCountIndex,
- pointCount,
- chordalDeviation);
- else
- return 0;
-}
-
-/*****************************************************************************
-* MakeLinesFromTTPolygon
-*
-* Converts a TTPOLYGONHEADER and its associated curve structures into a
-* single polyline loop in the global LineBuf.
-*****************************************************************************/
-
-INT MakeLinesFromTTPolygon(UCHAR** pp, FLOAT chordalDeviation)
-{
- DWORD polySize;
- UCHAR* polyStart;
- DWORD vertexCountIndex;
-
- /*
- * Record where the polygon data begins, and where the loop's
- * vertex count resides:
- */
- polyStart = *pp;
- vertexCountIndex = LineBufIndex;
- if (!AppendToLineBuf(0.0F))
- return 0;
-
- /*
- * Extract relevant data from the TTPOLYGONHEADER:
- */
- polySize = GetDWord(pp);
- if (GetDWord(pp) != TT_POLYGON_TYPE) /* polygon type */
- return 0;
- if (!AppendToLineBuf((FLOAT) GetFixed(pp))) /* first X coord */
- return 0;
- if (!AppendToLineBuf((FLOAT) GetFixed(pp))) /* first Y coord */
- return 0;
- LineBuf[vertexCountIndex] += 1.0F;
-
- /*
- * Process each of the TTPOLYCURVE structures in the polygon:
- */
- while (*pp < polyStart + polySize)
- if (!MakeLinesFromTTPolycurve( pp,
- vertexCountIndex,
- chordalDeviation))
- return 0;
-
- return 1;
-}
-
-/*****************************************************************************
-* TessVertexOut
-*
-* Used by tessellator to handle output vertexes.
-*****************************************************************************/
-
-VOID CALLBACK TessVertexOutData(FLOAT p[3], GLfloat *pz)
-{
- GLfloat v[3];
- v[0] = (GLfloat) p[0];
- v[1] = (GLfloat) p[1];
- v[2] = *pz;
- glVertex3fv(v);
-}
-
-/*****************************************************************************
-* TessCombine
-*
-* Used by tessellator to handle self-pointsecting contours and degenerate
-* geometry.
-*****************************************************************************/
-VOID CALLBACK TessCombine(double coords[3], VOID* vertex_data[4], FLOAT weight[4],
VOID** outData)
-{
- if (!AppendToVertBuf((FLOAT) coords[0])
- || !AppendToVertBuf((FLOAT) coords[1])
- || !AppendToVertBuf((FLOAT) coords[2]))
- TessErrorOccurred = GL_OUT_OF_MEMORY;
-
- *outData = VertBuf + (VertBufIndex - 3);
-}
-
-/*****************************************************************************
-* TessError
-*
-* Saves the last tessellator error code in the global TessErrorOccurred.
-*****************************************************************************/
-
-VOID CALLBACK TessError(GLenum error)
-{
- TessErrorOccurred = error;
-}
-
-/*****************************************************************************
-* MakeLinesFromGlyph
-*
-* Converts the outline of a glyph from the TTPOLYGON format to a simple
-* array of floating-point values containing one or more loops.
-*
-* The first element of the output array is a count of the number of loops.
-* The loop data follows this count. Each loop consists of a count of the
-* number of vertices it contains, followed by the vertices. Each vertex
-* is an X and Y coordinate. For example, a single triangle might be
-* described by this array:
-*
-* 1., 3., 0., 0., 1., 0., 0., 1.
-* ^ ^ ^ ^ ^ ^ ^ ^
-* #loops #verts x1 y1 x2 y2 x3 y3
-*
-* A two-loop glyph would look like this:
-*
-* 2., 3., 0.,0., 1.,0., 0.,1., 3., .2,.2, .4,.2, .2,.4
-*
-* Line segments from the TTPOLYGON are transferred to the output array in
-* the obvious way. Quadratic splines in the TTPOLYGON are converted to
-* collections of line segments
-*****************************************************************************/
-
-INT MakeLinesFromGlyph(UCHAR* glyphBuf, DWORD glyphSize, FLOAT chordalDeviation)
-{
- UCHAR* p;
- INT status = 0;
-
- /*
- * Pick up all the polygons (aka loops) that make up the glyph:
- */
- if (!AppendToLineBuf(0.0F)) /* loop count at LineBuf[0] */
- goto exit;
-
- p = glyphBuf;
- while (p < glyphBuf + glyphSize)
- {
- if (!MakeLinesFromTTPolygon(&p, chordalDeviation))
- goto exit;
- LineBuf[0] += 1.0F; /* increment loop count */
- }
-
- status = 1;
-
-exit:
- return status;
-}
-
-/*****************************************************************************
-* DrawGlyph
-*
-* Converts the outline of a glyph to OpenGL drawing primitives, tessellating
-* as needed, and then draws the glyph. Tessellation of the quadratic splines
-* in the outline is controlled by "chordalDeviation", and the drawing
-* primitives (lines or polygons) are selected by "format".
-*
-* Return value is nonzero for success, zero for failure.
-*
-* Does not check for OpenGL errors, so if the caller needs to know about them,
-* it should call glGetError().
-*****************************************************************************/
-
-INT DrawGlyph(UCHAR* glyphBuf, DWORD glyphSize, FLOAT chordalDeviation, FLOAT extrusion,
INT format)
-{
- INT status = 0;
- FLOAT* p;
- DWORD loop;
- DWORD point;
- GLUtesselator* tess = NULL;
-
- /*
- * Initialize the global buffer into which we place the outlines:
- */
- LineBuf = (FLOAT*) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (LINE_BUF_QUANT) *
sizeof(FLOAT));
-
- if(!LineBuf)
- goto exit;
-
- LineBufSize = LINE_BUF_QUANT;
- LineBufIndex = 0;
-
- /*
- * Convert the glyph outlines to a set of polyline loops.
- * (See MakeLinesFromGlyph() for the format of the loop data
- * structure.)
- */
- if (!MakeLinesFromGlyph(glyphBuf, glyphSize, chordalDeviation))
- goto exit;
- p = LineBuf;
-
-
- /*
- * Now draw the loops in the appropriate format:
- */
- if (format == WGL_FONT_LINES)
- {
- /*
- * This is the easy case. Just draw the outlines.
- */
- for (loop = (DWORD) *p++; loop; --loop)
- {
- glBegin(GL_LINE_LOOP);
- for (point = (DWORD) *p++; point; --point)
- {
- glVertex2fv(p);
- p += 2;
+ if (needed_size != 0) {
+ width_int = (gm.gmBlackBoxX + 31) / 32;
+ for (height = 0; height < gm.gmBlackBoxY; height++) {
+ for (width = 0; width < width_int; width++) {
+ ((int *) gl_bitmap)[(gm.gmBlackBoxY - height - 1) * width_int +
width] =
+ ((int *) bitmap)[height * width_int + width];
+ }
}
- glEnd();
- }
- status = 1;
- }
-
- else if (format == WGL_FONT_POLYGONS)
- {
- double v[3];
- FLOAT *save_p = p;
- GLfloat z_value;
-
- /*
- * This is the hard case. We have to set up a tessellator
- * to convert the outlines into a set of polygonal
- * primitives, which the tessellator passes to some
- * auxiliary routines for drawing.
- */
-
- VertBuf = (FLOAT*) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (VERT_BUF_QUANT)
* sizeof(FLOAT));
-
- if (!VertBuf)
- goto exit;
-
- VertBufSize = VERT_BUF_QUANT;
- VertBufIndex = 0;
-
- if (!(tess = gluNewTess()))
- goto exit;
-
- gluTessCallback(tess, GLU_BEGIN, (VOID(CALLBACK *)()) glBegin);
- gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (VOID(CALLBACK *)())
TessVertexOutData);
- gluTessCallback(tess, GLU_END, (VOID(CALLBACK *)()) glEnd);
- gluTessCallback(tess, GLU_ERROR, (VOID(CALLBACK *)()) TessError);
- gluTessCallback(tess, GLU_TESS_COMBINE, (VOID(CALLBACK *)()) TessCombine);
- gluTessNormal(tess, 0.0F, 0.0F, 1.0F);
-
- TessErrorOccurred = 0;
- glNormal3f(0.0f, 0.0f, 1.0f);
- v[2] = 0.0;
- z_value = 0.0f;
-
- gluTessBeginPolygon(tess, &z_value);
-
- for (loop = (DWORD) *p++; loop; --loop)
- {
- gluTessBeginContour(tess);
-
- for (point = (DWORD) *p++; point; --point)
- {
- v[0] = p[0];
- v[1] = p[1];
- gluTessVertex(tess, v, p);
- p += 2;
- }
-
- gluTessEndContour(tess);
- }
- gluTessEndPolygon(tess);
-
- status = !TessErrorOccurred;
-
- /* Extrusion code */
- if (extrusion)
- {
- DWORD loops;
- GLfloat thickness = (GLfloat) - extrusion;
- FLOAT *vert, *vert2;
- DWORD count;
-
- p = save_p;
- loops = (DWORD) *p++;
-
- for (loop = 0; loop < loops; loop++)
- {
- GLfloat dx, dy, len;
- DWORD last;
-
- count = (DWORD) *p++;
- glBegin(GL_QUAD_STRIP);
-
- /* Check if the first and last vertex are identical
- * so we don't draw the same quad twice.
- */
- vert = p + (count-1)*2;
- last = (p[0] == vert[0] && p[1] == vert[1]) ? count-1 : count;
-
- for (point = 0; point <= last; point++)
- {
- vert = p + 2 * (point % last);
- vert2 = p + 2 * ((point+1) % last);
-
- dx = vert[0] - vert2[0];
- dy = vert[1] - vert2[1];
- len = (GLfloat)sqrt(dx * dx + dy * dy);
-
- glNormal3f(dy / len, -dx / len, 0.0f);
- glVertex3f((GLfloat) vert[0],
- (GLfloat) vert[1], thickness);
- glVertex3f((GLfloat) vert[0],
- (GLfloat) vert[1], 0.0f);
- }
-
- glEnd();
- p += count*2;
- }
-
- /* Draw the back face */
- p = save_p;
- v[2] = thickness;
- glNormal3f(0.0f, 0.0f, -1.0f);
- gluTessNormal(tess, 0.0F, 0.0F, -1.0F);
-
- gluTessBeginPolygon(tess, &thickness);
-
- for (loop = (DWORD) *p++; loop; --loop)
- {
- count = (DWORD) *p++;
-
- gluTessBeginContour(tess);
-
- for (point = 0; point < count; point++)
- {
- vert = p + ((count-point-1)<<1);
- v[0] = vert[0];
- v[1] = vert[1];
- gluTessVertex(tess, v, vert);
- }
- p += count*2;
-
- gluTessEndContour(tess);
- }
- gluTessEndPolygon(tess);
- }
-
-#if !defined(NDEBUG)
- if (TessErrorOccurred)
- DBGPRINT("Tessellation error %s\n",
gluErrorString(TessErrorOccurred));
-#endif
- }
-
-
-exit:
-
- if(LineBuf)
- HeapFree(GetProcessHeap(), 0, LineBuf);
-
- if(VertBuf)
- HeapFree(GetProcessHeap(), 0, VertBuf);
-
- if (tess)
- gluDeleteTess(tess);
-
- return status;
-}
-
-
-/*****************************************************************************
-* MakeDisplayListFromGlyph
-*
-* Converts the outline of a glyph to an OpenGL display list.
-*
-* Return value is nonzero for success, zero for failure.
-*
-* Does not check for OpenGL errors, so if the caller needs to know about them,
-* it should call glGetError().
-*****************************************************************************/
-
-INT MakeDisplayListFromGlyph(DWORD listName, UCHAR* glyphBuf, DWORD glyphSize,
LPGLYPHMETRICSFLOAT glyphMetricsFloat,
- FLOAT chordalDeviation, FLOAT extrusion, INT format)
-{
- INT status;
-
- glNewList(listName, GL_COMPILE);
- status = DrawGlyph(glyphBuf, glyphSize, chordalDeviation, extrusion, format);
- glTranslatef(glyphMetricsFloat->gmfCellIncX,
glyphMetricsFloat->gmfCellIncY, 0.0F);
- glEndList();
-
- return status;
-}
-
-// ***********************************************************************
-
-/*****************************************************************************
-* IntUseFontBitmaps
-*
-* Converts a subrange of the glyphs in a GDI font to OpenGL display
-* lists.
-*
-* Extended to support any GDI font, not just TrueType fonts. (DaveM)
-*
-*****************************************************************************/
-
-BOOL APIENTRY IntUseFontBitmapsW(HDC hDC, DWORD first, DWORD count, DWORD listBase)
-{
- INT i, ox, oy, ix, iy;
- INT w = 0, h = 0;
- INT iBufSize, iCurBufSize = 0;
- DWORD *bitmapBuffer = NULL;
- DWORD *invertedBitmapBuffer = NULL;
- BOOL bSuccessOrFail = TRUE;
- BOOL bTrueType = FALSE;
- TEXTMETRIC tm;
- GLYPHMETRICS gm;
- RASTERIZER_STATUS rs;
- MAT2 mat;
- SIZE size;
- RECT rect;
- HDC hDCMem;
- HBITMAP hBitmap;
- BITMAPINFO bmi;
- HFONT hFont;
-
- // Set up a unity matrix.
- ZeroMemory(&mat, sizeof(mat));
- mat.eM11.value = 1;
- mat.eM22.value = 1;
-
- // Test to see if selected font is TrueType or not
- ZeroMemory(&tm, sizeof(tm));
- if (!GetTextMetrics(hDC, &tm))
- {
- DBGPRINT("Font metrics error\n");
- return FALSE;
- }
- bTrueType = (tm.tmPitchAndFamily & TMPF_TRUETYPE) ? TRUE : FALSE;
-
- // Test to see if TRUE-TYPE capabilities are installed
- // (only necessary if TrueType font selected)
- ZeroMemory(&rs, sizeof(rs));
-
- if (bTrueType)
- {
- if (!GetRasterizerCaps (&rs, sizeof (RASTERIZER_STATUS)) || !(rs.wFlags &
TT_ENABLED))
- {
- DBGPRINT("No TrueType caps\n");
- bTrueType = FALSE;
- }
- }
-
- // Trick to get the current font handle
- hFont = SelectObject(hDC, GetStockObject(SYSTEM_FONT));
- SelectObject(hDC, hFont);
-
- // Have memory device context available for holding bitmaps of font glyphs
- hDCMem = CreateCompatibleDC(hDC);
- SelectObject(hDCMem, hFont);
- SetTextColor(hDCMem, RGB(0xFF, 0xFF, 0xFF));
- SetBkColor(hDCMem, 0);
-
- for (i = first; (DWORD) i < (first + count); i++)
- {
- // Find out how much space is needed for the bitmap so we can
- // Set the buffer size correctly.
- if (bTrueType)
- {
- // Use TrueType support to get bitmap size of glyph
- iBufSize = GetGlyphOutline(hDC, i, GGO_BITMAP, &gm, 0, NULL, &mat);
- if (iBufSize == GDI_ERROR)
- {
- bSuccessOrFail = FALSE;
- break;
- }
- }
- else
- {
- // Use generic GDI support to compute bitmap size of glyph
- w = tm.tmMaxCharWidth;
- h = tm.tmHeight;
- if (GetTextExtentPoint32(hDC, (LPCTSTR)&i, 1, &size))
- {
- w = size.cx;
- h = size.cy;
- }
- iBufSize = w * h;
- // Use DWORD multiple for compatibility
- iBufSize += 3;
- iBufSize /= 4;
- iBufSize *= 4;
- }
-
- // If we need to allocate Larger Buffers, then do so - but allocate
- // An extra 50 % so that we don't do too many mallocs !
- if (iBufSize > iCurBufSize)
- {
- if (bitmapBuffer)
- {
- HeapFree(GetProcessHeap(), 0, bitmapBuffer);
- }
- if (invertedBitmapBuffer)
- {
- HeapFree(GetProcessHeap(), 0, invertedBitmapBuffer);
- }
-
- iCurBufSize = iBufSize * 2;
- bitmapBuffer = (DWORD *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
iCurBufSize);
- invertedBitmapBuffer = (DWORD *) HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, iCurBufSize);
-
- if (bitmapBuffer == NULL || invertedBitmapBuffer == NULL)
- {
- bSuccessOrFail = FALSE;
- break;
- }
- }
-
- // If we fail to get the Glyph data, delete the display lists
- // Created so far and return FALSE.
- if (bTrueType)
- {
- // Use TrueType support to get bitmap of glyph
- if (GetGlyphOutline(hDC, i, GGO_BITMAP, &gm, iBufSize, bitmapBuffer,
&mat) == GDI_ERROR)
- {
- bSuccessOrFail = FALSE;
- break;
- }
-
- // Setup glBitmap parameters for current font glyph
- w = gm.gmBlackBoxX;
- h = gm.gmBlackBoxY;
- ox = gm.gmptGlyphOrigin.x;
- oy = gm.gmptGlyphOrigin.y;
- ix = gm.gmCellIncX;
- iy = gm.gmCellIncY;
- }
- else
- {
- // Use generic GDI support to create bitmap of glyph
- ZeroMemory(bitmapBuffer, iBufSize);
-
- if (i >= tm.tmFirstChar && i <= tm.tmLastChar)
- {
- // Only create bitmaps for actual font glyphs
- hBitmap = CreateBitmap(w, h, 1, 1, NULL);
- SelectObject(hDCMem, hBitmap);
- // Make bitmap of current font glyph
- SetRect(&rect, 0, 0, w, h);
- DrawText(hDCMem, (LPCTSTR)&i, 1, &rect,
- DT_LEFT | DT_BOTTOM | DT_SINGLELINE | DT_NOCLIP);
- // Make copy of bitmap in our local buffer
- ZeroMemory(&bmi, sizeof(bmi));
- bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
- bmi.bmiHeader.biWidth = w;
- bmi.bmiHeader.biHeight = -h;
- bmi.bmiHeader.biPlanes = 1;
- bmi.bmiHeader.biBitCount = 1;
- bmi.bmiHeader.biCompression = BI_RGB;
- GetDIBits(hDCMem, hBitmap, 0, h, bitmapBuffer, &bmi, 0);
- DeleteObject(hBitmap);
- }
- else
- {
- // Otherwise use empty display list for non-existing glyph
- iBufSize = 0;
- }
-
- // Setup glBitmap parameters for current font glyph
- ox = 0;
- oy = tm.tmDescent;
- ix = w;
- iy = 0;
- }
-
- // Create an OpenGL display list.
- glNewList((listBase + i), GL_COMPILE);
-
- // Some fonts have no data for the space character, yet advertise
- // a non-zero size.
- if (0 == iBufSize)
- {
- glBitmap(0, 0, 0.0f, 0.0f, (GLfloat) ix, (GLfloat) iy, NULL);
- }
- else
- {
- // Invert the Glyph data.
- InvertGlyphBitmap(w, h, bitmapBuffer, invertedBitmapBuffer);
-
- // Render an OpenGL bitmap and invert the origin.
- glBitmap(w, h,
- (GLfloat) ox, (GLfloat) (h-oy),
- (GLfloat) ix, (GLfloat) iy,
- (GLubyte *) invertedBitmapBuffer);
- }
-
- // Close this display list.
+ }
+
+ glNewList(listBase++, GL_COMPILE);
+ if (needed_size != 0) {
+ glBitmap(gm.gmBlackBoxX, gm.gmBlackBoxY,
+ 0 - gm.gmptGlyphOrigin.x, (int) gm.gmBlackBoxY - gm.gmptGlyphOrigin.y,
+ gm.gmCellIncX, gm.gmCellIncY,
+ gl_bitmap);
+ } else {
+ /* This is the case of 'empty' glyphs like the space character */
+ glBitmap(0, 0, 0, 0, gm.gmCellIncX, gm.gmCellIncY, NULL);
+ }
glEndList();
}
- if (bSuccessOrFail == FALSE)
+ glPixelStorei(GL_UNPACK_ALIGNMENT, org_alignment);
+ HeapFree(GetProcessHeap(), 0, bitmap);
+ HeapFree(GetProcessHeap(), 0, gl_bitmap);
+ return ret;
+}
+
+/***********************************************************************
+ * wglUseFontBitmapsA (OPENGL32.@)
+ */
+BOOL WINAPI wglUseFontBitmapsA(HDC hdc, DWORD first, DWORD count, DWORD listBase)
+{
+ return wglUseFontBitmaps_common( hdc, first, count, listBase, FALSE );
+}
+
+/***********************************************************************
+ * wglUseFontBitmapsW (OPENGL32.@)
+ */
+BOOL WINAPI wglUseFontBitmapsW(HDC hdc, DWORD first, DWORD count, DWORD listBase)
+{
+ return wglUseFontBitmaps_common( hdc, first, count, listBase, TRUE );
+}
+
+/* FIXME: should probably have a glu.h header */
+
+typedef struct GLUtesselator GLUtesselator;
+typedef void (WINAPI *_GLUfuncptr)(void);
+
+#define GLU_TESS_BEGIN 100100
+#define GLU_TESS_VERTEX 100101
+#define GLU_TESS_END 100102
+
+static GLUtesselator * (WINAPI *pgluNewTess)(void);
+static void (WINAPI *pgluDeleteTess)(GLUtesselator *tess);
+static void (WINAPI *pgluTessNormal)(GLUtesselator *tess, GLdouble x, GLdouble y,
GLdouble z);
+static void (WINAPI *pgluTessBeginPolygon)(GLUtesselator *tess, void *polygon_data);
+static void (WINAPI *pgluTessEndPolygon)(GLUtesselator *tess);
+static void (WINAPI *pgluTessCallback)(GLUtesselator *tess, GLenum which, _GLUfuncptr
fn);
+static void (WINAPI *pgluTessBeginContour)(GLUtesselator *tess);
+static void (WINAPI *pgluTessEndContour)(GLUtesselator *tess);
+static void (WINAPI *pgluTessVertex)(GLUtesselator *tess, GLdouble *location, GLvoid*
data);
+
+static HMODULE load_libglu(void)
+{
+ static const WCHAR glu32W[] =
{'g','l','u','3','2','.','d','l','l',0};
+ static int already_loaded;
+ static HMODULE module;
+
+ if (already_loaded) return module;
+ already_loaded = 1;
+
+ TRACE("Trying to load GLU library\n");
+ module = LoadLibraryW( glu32W );
+ if (!module)
{
- DBGPRINT("DGL_UseFontBitmaps: Get glyph failed\n");
- glDeleteLists((i+listBase), (i-first));
+ WARN("Failed to load glu32\n");
+ return NULL;
}
-
- // Release resources used
- DeleteObject(hFont);
- DeleteDC(hDCMem);
-
- if (bitmapBuffer)
- HeapFree(GetProcessHeap(), 0, bitmapBuffer);
-
- if (invertedBitmapBuffer)
- HeapFree(GetProcessHeap(), 0, invertedBitmapBuffer);
-
- return(bSuccessOrFail);
-}
-
-BOOL APIENTRY IntUseFontBitmapsA(HDC hDC, DWORD first, DWORD count, DWORD listBase)
-{
- /* Just call IntUseFontBitmapsW for now */
- return IntUseFontBitmapsW(hDC, first, count, listBase);
-}
-
-
-
-/*****************************************************************************
-* IntUseFontOutlines
-*
-* Converts a subrange of the glyphs in a TrueType font to OpenGL display
-* lists.
-*****************************************************************************/
-
-BOOL APIENTRY IntUseFontOutlinesW(HDC hDC, DWORD first, DWORD count, DWORD listBase,
FLOAT chordalDeviation,
- FLOAT extrusion, INT format, GLYPHMETRICSFLOAT
*glyphMetricsFloatArray)
-{
- DWORD glyphIndex;
- UCHAR* glyphBuf;
- DWORD glyphBufSize;
-
- /*
- * Flush any previous OpenGL errors. This allows us to check for
- * new errors so they can be reported via the function return value.
- */
- while (glGetError() != GL_NO_ERROR);
-
- /*
- * Make sure that the current font can be sampled accurately.
- */
- hNewFont = CreateHighResolutionFont(hDC);
-
- if (!hNewFont)
- return FALSE;
-
- hOldFont = SelectObject(hDC, hNewFont);
- if (!hOldFont)
- return FALSE;
-
- /*
- * Preallocate a buffer for the outline data, and track its size:
- */
- glyphBuf = (UCHAR*) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, glyphBufSize =
10240);
-
- if (!glyphBuf)
- return FALSE; /*WGL_STATUS_NOT_ENOUGH_MEMORY*/
-
- /*
- * Process each glyph in the given range:
- */
- for (glyphIndex = first; glyphIndex - first < count; ++glyphIndex)
+#define LOAD_FUNCPTR(f) p##f = (void *)GetProcAddress( module, #f )
+ LOAD_FUNCPTR(gluNewTess);
+ LOAD_FUNCPTR(gluDeleteTess);
+ LOAD_FUNCPTR(gluTessBeginContour);
+ LOAD_FUNCPTR(gluTessNormal);
+ LOAD_FUNCPTR(gluTessBeginPolygon);
+ LOAD_FUNCPTR(gluTessCallback);
+ LOAD_FUNCPTR(gluTessEndContour);
+ LOAD_FUNCPTR(gluTessEndPolygon);
+ LOAD_FUNCPTR(gluTessVertex);
+#undef LOAD_FUNCPTR
+ return module;
+}
+
+static void fixed_to_double(POINTFX fixed, UINT em_size, GLdouble vertex[3])
+{
+ vertex[0] = (fixed.x.value + (GLdouble)fixed.x.fract / (1 << 16)) / em_size;
+ vertex[1] = (fixed.y.value + (GLdouble)fixed.y.fract / (1 << 16)) / em_size;
+ vertex[2] = 0.0;
+}
+
+static void WINAPI tess_callback_vertex(GLvoid *vertex)
+{
+ GLdouble *dbl = vertex;
+ TRACE("%f, %f, %f\n", dbl[0], dbl[1], dbl[2]);
+ glVertex3dv(vertex);
+}
+
+static void WINAPI tess_callback_begin(GLenum which)
+{
+ TRACE("%d\n", which);
+ glBegin(which);
+}
+
+static void WINAPI tess_callback_end(void)
+{
+ TRACE("\n");
+ glEnd();
+}
+
+typedef struct _bezier_vector {
+ GLdouble x;
+ GLdouble y;
+} bezier_vector;
+
+static double bezier_deviation_squared(const bezier_vector *p)
+{
+ bezier_vector deviation;
+ bezier_vector vertex;
+ bezier_vector base;
+ double base_length;
+ double dot;
+
+ vertex.x = (p[0].x + p[1].x*2 + p[2].x)/4 - p[0].x;
+ vertex.y = (p[0].y + p[1].y*2 + p[2].y)/4 - p[0].y;
+
+ base.x = p[2].x - p[0].x;
+ base.y = p[2].y - p[0].y;
+
+ base_length = sqrt(base.x*base.x + base.y*base.y);
+ base.x /= base_length;
+ base.y /= base_length;
+
+ dot = base.x*vertex.x + base.y*vertex.y;
+ dot = min(max(dot, 0.0), base_length);
+ base.x *= dot;
+ base.y *= dot;
+
+ deviation.x = vertex.x-base.x;
+ deviation.y = vertex.y-base.y;
+
+ return deviation.x*deviation.x + deviation.y*deviation.y;
+}
+
+static int bezier_approximate(const bezier_vector *p, bezier_vector *points, FLOAT
deviation)
+{
+ bezier_vector first_curve[3];
+ bezier_vector second_curve[3];
+ bezier_vector vertex;
+ int total_vertices;
+
+ if(bezier_deviation_squared(p) <= deviation*deviation)
{
- GLYPHMETRICS glyphMetrics;
- DWORD glyphSize;
- static MAT2 matrix =
+ if(points)
+ *points = p[2];
+ return 1;
+ }
+
+ vertex.x = (p[0].x + p[1].x*2 + p[2].x)/4;
+ vertex.y = (p[0].y + p[1].y*2 + p[2].y)/4;
+
+ first_curve[0] = p[0];
+ first_curve[1].x = (p[0].x + p[1].x)/2;
+ first_curve[1].y = (p[0].y + p[1].y)/2;
+ first_curve[2] = vertex;
+
+ second_curve[0] = vertex;
+ second_curve[1].x = (p[2].x + p[1].x)/2;
+ second_curve[1].y = (p[2].y + p[1].y)/2;
+ second_curve[2] = p[2];
+
+ total_vertices = bezier_approximate(first_curve, points, deviation);
+ if(points)
+ points += total_vertices;
+ total_vertices += bezier_approximate(second_curve, points, deviation);
+ return total_vertices;
+}
+
+/***********************************************************************
+ * wglUseFontOutlines_common
+ */
+static BOOL wglUseFontOutlines_common(HDC hdc,
+ DWORD first,
+ DWORD count,
+ DWORD listBase,
+ FLOAT deviation,
+ FLOAT extrusion,
+ int format,
+ LPGLYPHMETRICSFLOAT lpgmf,
+ BOOL unicode)
+{
+ UINT glyph;
+ const MAT2 identity = {{0,1},{0,0},{0,0},{0,1}};
+ GLUtesselator *tess = NULL;
+ LOGFONTW lf;
+ HFONT old_font, unscaled_font;
+ UINT em_size = 1024;
+ RECT rc;
+
+ TRACE("(%p, %d, %d, %d, %f, %f, %d, %p, %s)\n", hdc, first, count,
+ listBase, deviation, extrusion, format, lpgmf, unicode ? "W" :
"A");
+
+ if(deviation <= 0.0)
+ deviation = 1.0/em_size;
+
+ if(format == WGL_FONT_POLYGONS)
+ {
+ if (!load_libglu())
{
- {0, 1}, {0, 0},
- {0, 0}, {0, 1}
- };
- LPGLYPHMETRICSFLOAT glyphMetricsFloat = &glyphMetricsFloatArray[glyphIndex -
first];
-
- /*
- * Determine how much space is needed to store the glyph's
- * outlines. If our glyph buffer isn't large enough,
- * resize it.
- */
-
- glyphSize = GetGlyphOutline(hDC, glyphIndex, GGO_NATIVE, &glyphMetrics, 0,
NULL, &matrix);
-
- if (glyphSize == GDI_ERROR)
- return FALSE; /*WGL_STATUS_FAILURE*/
-
- if (glyphSize > glyphBufSize)
+ ERR("glu32 is required for this function but isn't
available\n");
+ return FALSE;
+ }
+
+ tess = pgluNewTess();
+ if(!tess) return FALSE;
+ pgluTessCallback(tess, GLU_TESS_VERTEX, (_GLUfuncptr)tess_callback_vertex);
+ pgluTessCallback(tess, GLU_TESS_BEGIN, (_GLUfuncptr)tess_callback_begin);
+ pgluTessCallback(tess, GLU_TESS_END, tess_callback_end);
+ }
+
+ GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(lf), &lf);
+ rc.left = rc.right = rc.bottom = 0;
+ rc.top = em_size;
+ DPtoLP(hdc, (POINT*)&rc, 2);
+ lf.lfHeight = -abs(rc.top - rc.bottom);
+ lf.lfOrientation = lf.lfEscapement = 0;
+ unscaled_font = CreateFontIndirectW(&lf);
+ old_font = SelectObject(hdc, unscaled_font);
+
+ for (glyph = first; glyph < first + count; glyph++)
+ {
+ DWORD needed;
+ GLYPHMETRICS gm;
+ BYTE *buf;
+ TTPOLYGONHEADER *pph;
+ TTPOLYCURVE *ppc;
+ GLdouble *vertices = NULL;
+ int vertex_total = -1;
+
+ if(unicode)
+ needed = GetGlyphOutlineW(hdc, glyph, GGO_NATIVE, &gm, 0, NULL,
&identity);
+ else
+ needed = GetGlyphOutlineA(hdc, glyph, GGO_NATIVE, &gm, 0, NULL,
&identity);
+
+ if(needed == GDI_ERROR)
+ goto error;
+
+ buf = HeapAlloc(GetProcessHeap(), 0, needed);
+
+ if(unicode)
+ GetGlyphOutlineW(hdc, glyph, GGO_NATIVE, &gm, needed, buf,
&identity);
+ else
+ GetGlyphOutlineA(hdc, glyph, GGO_NATIVE, &gm, needed, buf,
&identity);
+
+ TRACE("glyph %d\n", glyph);
+
+ if(lpgmf)
{
- HeapFree(GetProcessHeap(), 0, glyphBuf);
- glyphBuf = (UCHAR*) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
glyphBufSize = glyphSize);
- if (!glyphBuf)
- return FALSE; /*WGL_STATUS_NOT_ENOUGH_MEMORY*/
- }
-
-
- /*
- * Get the glyph's outlines.
- */
- if (GetGlyphOutline(hDC, glyphIndex, GGO_NATIVE, &glyphMetrics, glyphBufSize,
glyphBuf, &matrix) == GDI_ERROR)
+ lpgmf->gmfBlackBoxX = (float)gm.gmBlackBoxX / em_size;
+ lpgmf->gmfBlackBoxY = (float)gm.gmBlackBoxY / em_size;
+ lpgmf->gmfptGlyphOrigin.x = (float)gm.gmptGlyphOrigin.x / em_size;
+ lpgmf->gmfptGlyphOrigin.y = (float)gm.gmptGlyphOrigin.y / em_size;
+ lpgmf->gmfCellIncX = (float)gm.gmCellIncX / em_size;
+ lpgmf->gmfCellIncY = (float)gm.gmCellIncY / em_size;
+
+ TRACE("%fx%f at %f,%f inc %f,%f\n", lpgmf->gmfBlackBoxX,
lpgmf->gmfBlackBoxY,
+ lpgmf->gmfptGlyphOrigin.x, lpgmf->gmfptGlyphOrigin.y,
lpgmf->gmfCellIncX, lpgmf->gmfCellIncY);
+ lpgmf++;
+ }
+
+ glNewList(listBase++, GL_COMPILE);
+ glFrontFace(GL_CCW);
+ if(format == WGL_FONT_POLYGONS)
{
- HeapFree(GetProcessHeap(), 0, glyphBuf);
- return FALSE; /*WGL_STATUS_FAILURE*/
- }
-
- glyphMetricsFloat->gmfBlackBoxX =
- (FLOAT) glyphMetrics.gmBlackBoxX * ScaleFactor;
- glyphMetricsFloat->gmfBlackBoxY =
- (FLOAT) glyphMetrics.gmBlackBoxY * ScaleFactor;
- glyphMetricsFloat->gmfptGlyphOrigin.x =
- (FLOAT) glyphMetrics.gmptGlyphOrigin.x * ScaleFactor;
- glyphMetricsFloat->gmfptGlyphOrigin.y =
- (FLOAT) glyphMetrics.gmptGlyphOrigin.y * ScaleFactor;
- glyphMetricsFloat->gmfCellIncX =
- (FLOAT) glyphMetrics.gmCellIncX * ScaleFactor;
- glyphMetricsFloat->gmfCellIncY =
- (FLOAT) glyphMetrics.gmCellIncY * ScaleFactor;
-
- /*
- * Turn the glyph into a display list:
- */
- if (!MakeDisplayListFromGlyph((glyphIndex - first) + listBase, glyphBuf,
glyphSize, glyphMetricsFloat,
- chordalDeviation + ScaleFactor, extrusion,
format))
+ glNormal3d(0.0, 0.0, 1.0);
+ pgluTessNormal(tess, 0, 0, 1);
+ pgluTessBeginPolygon(tess, NULL);
+ }
+
+ while(!vertices)
{
- HeapFree(GetProcessHeap(), 0, glyphBuf);
- return FALSE; /*WGL_STATUS_FAILURE*/
- }
+ if(vertex_total != -1)
+ vertices = HeapAlloc(GetProcessHeap(), 0, vertex_total * 3 *
sizeof(GLdouble));
+ vertex_total = 0;
+
+ pph = (TTPOLYGONHEADER*)buf;
+ while((BYTE*)pph < buf + needed)
+ {
+ GLdouble previous[3];
+ fixed_to_double(pph->pfxStart, em_size, previous);
+
+ if(vertices)
+ TRACE("\tstart %d, %d\n", pph->pfxStart.x.value,
pph->pfxStart.y.value);
+
+ if(format == WGL_FONT_POLYGONS)
+ pgluTessBeginContour(tess);
+ else
+ glBegin(GL_LINE_LOOP);
+
+ if(vertices)
+ {
+ fixed_to_double(pph->pfxStart, em_size, vertices);
+ if(format == WGL_FONT_POLYGONS)
+ pgluTessVertex(tess, vertices, vertices);
+ else
+ glVertex3d(vertices[0], vertices[1], vertices[2]);
+ vertices += 3;
+ }
+ vertex_total++;
+
+ ppc = (TTPOLYCURVE*)((char*)pph + sizeof(*pph));
+ while((char*)ppc < (char*)pph + pph->cb)
+ {
+ int i, j;
+ int num;
+
+ switch(ppc->wType) {
+ case TT_PRIM_LINE:
+ for(i = 0; i < ppc->cpfx; i++)
+ {
+ if(vertices)
+ {
+ TRACE("\t\tline to %d, %d\n",
+ ppc->apfx[i].x.value, ppc->apfx[i].y.value);
+ fixed_to_double(ppc->apfx[i], em_size, vertices);
+ if(format == WGL_FONT_POLYGONS)
+ pgluTessVertex(tess, vertices, vertices);
+ else
+ glVertex3d(vertices[0], vertices[1], vertices[2]);
+ vertices += 3;
+ }
+ fixed_to_double(ppc->apfx[i], em_size, previous);
+ vertex_total++;
+ }
+ break;
+
+ case TT_PRIM_QSPLINE:
+ for(i = 0; i < ppc->cpfx-1; i++)
+ {
+ bezier_vector curve[3];
+ bezier_vector *points;
+ GLdouble curve_vertex[3];
+
+ if(vertices)
+ TRACE("\t\tcurve %d,%d %d,%d\n",
+ ppc->apfx[i].x.value,
ppc->apfx[i].y.value,
+ ppc->apfx[i + 1].x.value, ppc->apfx[i +
1].y.value);
+
+ curve[0].x = previous[0];
+ curve[0].y = previous[1];
+ fixed_to_double(ppc->apfx[i], em_size, curve_vertex);
+ curve[1].x = curve_vertex[0];
+ curve[1].y = curve_vertex[1];
+ fixed_to_double(ppc->apfx[i + 1], em_size, curve_vertex);
+ curve[2].x = curve_vertex[0];
+ curve[2].y = curve_vertex[1];
+ if(i < ppc->cpfx-2)
+ {
+ curve[2].x = (curve[1].x + curve[2].x)/2;
+ curve[2].y = (curve[1].y + curve[2].y)/2;
+ }
+ num = bezier_approximate(curve, NULL, deviation);
+ points = HeapAlloc(GetProcessHeap(), 0,
num*sizeof(bezier_vector));
+ num = bezier_approximate(curve, points, deviation);
+ vertex_total += num;
+ if(vertices)
+ {
+ for(j=0; j<num; j++)
+ {
+ TRACE("\t\t\tvertex at %f,%f\n",
points[j].x, points[j].y);
+ vertices[0] = points[j].x;
+ vertices[1] = points[j].y;
+ vertices[2] = 0.0;
+ if(format == WGL_FONT_POLYGONS)
+ pgluTessVertex(tess, vertices, vertices);
+ else
+ glVertex3d(vertices[0], vertices[1],
vertices[2]);
+ vertices += 3;
+ }
+ }
+ HeapFree(GetProcessHeap(), 0, points);
+ previous[0] = curve[2].x;
+ previous[1] = curve[2].y;
+ }
+ break;
+ default:
+ ERR("\t\tcurve type = %d\n", ppc->wType);
+ if(format == WGL_FONT_POLYGONS)
+ pgluTessEndContour(tess);
+ else
+ glEnd();
+ goto error_in_list;
+ }
+
+ ppc = (TTPOLYCURVE*)((char*)ppc + sizeof(*ppc) +
+ (ppc->cpfx - 1) * sizeof(POINTFX));
+ }
+ if(format == WGL_FONT_POLYGONS)
+ pgluTessEndContour(tess);
+ else
+ glEnd();
+ pph = (TTPOLYGONHEADER*)((char*)pph + pph->cb);
+ }
+ }
+
+error_in_list:
+ if(format == WGL_FONT_POLYGONS)
+ pgluTessEndPolygon(tess);
+ glTranslated((GLdouble)gm.gmCellIncX / em_size, (GLdouble)gm.gmCellIncY /
em_size, 0.0);
+ glEndList();
+ HeapFree(GetProcessHeap(), 0, buf);
+ HeapFree(GetProcessHeap(), 0, vertices);
}
- /*
- * Clean up temporary storage and return. If an error occurred,
- * clear all OpenGL error flags and return FAILURE status;
- * otherwise just return SUCCESS.
- */
- HeapFree(GetProcessHeap(), 0, glyphBuf);
-
- DeleteObject(SelectObject(hDC, hOldFont));
-
- if (glGetError() == GL_NO_ERROR)
- {
- return TRUE; /*WGL_STATUS_SUCCESS*/
- }
- else
- {
- while (glGetError() != GL_NO_ERROR);
-
- return FALSE; /*WGL_STATUS_FAILURE*/
- }
-}
-
-BOOL APIENTRY IntUseFontOutlinesA(HDC hDC, DWORD first, DWORD count, DWORD listBase,
FLOAT chordalDeviation,
- FLOAT extrusion, INT format, GLYPHMETRICSFLOAT
*glyphMetricsFloatArray)
-{
- /* Just call IntUseFontOutlinesW for now */
- return IntUseFontOutlinesW(hDC, first, count, listBase, chordalDeviation, extrusion,
format, glyphMetricsFloatArray);
-}
+ error:
+ DeleteObject(SelectObject(hdc, old_font));
+ if(format == WGL_FONT_POLYGONS)
+ pgluDeleteTess(tess);
+ return TRUE;
+
+}
+
+/***********************************************************************
+ * wglUseFontOutlinesA (OPENGL32.@)
+ */
+BOOL WINAPI wglUseFontOutlinesA(HDC hdc,
+ DWORD first,
+ DWORD count,
+ DWORD listBase,
+ FLOAT deviation,
+ FLOAT extrusion,
+ int format,
+ LPGLYPHMETRICSFLOAT lpgmf)
+{
+ return wglUseFontOutlines_common(hdc, first, count, listBase, deviation, extrusion,
format, lpgmf, FALSE);
+}
+
+/***********************************************************************
+ * wglUseFontOutlinesW (OPENGL32.@)
+ */
+BOOL WINAPI wglUseFontOutlinesW(HDC hdc,
+ DWORD first,
+ DWORD count,
+ DWORD listBase,
+ FLOAT deviation,
+ FLOAT extrusion,
+ int format,
+ LPGLYPHMETRICSFLOAT lpgmf)
+{
+ return wglUseFontOutlines_common(hdc, first, count, listBase, deviation, extrusion,
format, lpgmf, TRUE);
+}
Modified: trunk/reactos/dll/opengl/opengl32/opengl32.spec
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/opengl/opengl32/opengl…
==============================================================================
--- trunk/reactos/dll/opengl/opengl32/opengl32.spec [iso-8859-1] (original)
+++ trunk/reactos/dll/opengl/opengl32/opengl32.spec [iso-8859-1] Fri Mar 22 15:10:46 2013
@@ -363,7 +363,7 @@
@ stdcall wglSwapBuffers(long) rosglSwapBuffers
@ stdcall wglSwapLayerBuffers(long long) rosglSwapLayerBuffers
@ stub wglSwapMultipleBuffers
-@ stdcall wglUseFontBitmapsA(long long long long) rosglUseFontBitmapsA
-@ stdcall wglUseFontBitmapsW(long long long long) rosglUseFontBitmapsW
-@ stdcall wglUseFontOutlinesA(long long long long long long long ptr)
rosglUseFontOutlinesA
-@ stdcall wglUseFontOutlinesW(long long long long long long long ptr)
rosglUseFontOutlinesW
+@ stdcall wglUseFontBitmapsA(long long long long)
+@ stdcall wglUseFontBitmapsW(long long long long)
+@ stdcall wglUseFontOutlinesA(long long long long long long long ptr)
+@ stdcall wglUseFontOutlinesW(long long long long long long long ptr)