void NVprPathRendererState::validate()
{
if (valid) {
return;
}
NVprPathCacheProcessor processor(owner, path, fill_rule);
owner->processSegments(processor);
if (owner->style.do_stroke) {
glPathParameteriNV(path, GL_PATH_JOIN_STYLE_NV, lineJoinConverter(owner));
glPathParameteriNV(path, GL_PATH_END_CAPS_NV, lineCapConverter(owner));
glPathParameterfNV(path, GL_PATH_STROKE_WIDTH_NV, owner->style.stroke_width);
glPathParameterfNV(path, GL_PATH_MITER_LIMIT_NV, owner->style.miter_limit);
if (owner->style.dash_array.size()) {
glPathDashArrayNV(path, GLsizei(owner->style.dash_array.size()), &owner->style.dash_array[0]);
glPathParameteriNV(path, GL_PATH_DASH_CAPS_NV, lineCapConverter(owner));
glPathParameterfNV(path, GL_PATH_DASH_OFFSET_NV, owner->style.dash_offset);
GLenum dash_offset_reset = (owner->style.dash_phase == PathStyle::MOVETO_RESETS)
? GL_MOVE_TO_RESETS_NV
: GL_MOVE_TO_CONTINUES_NV;
glPathParameteriNV(path, GL_PATH_DASH_OFFSET_RESET_NV, dash_offset_reset);
} else {
glPathDashArrayNV(path, 0, NULL);
}
}
valid = true;
}
static void nvpr_render_shape(void *render, LVGShapeCollection *shapecol, LVGColorTransform *cxform, float ratio, int blend_mode)
{
//render_ctx *ctx = render;
for (int j = 0; j < shapecol->num_shapes; j++)
{
NSVGshape *shape = shapecol->shapes + j;
NSVGshape *shape2 = shapecol->morph ? shapecol->morph->shapes + j : 0;
GLuint pathObj = shape->cache;
if (shape2)
pathObj = morph_shape(shape, shape2, ratio);
/*GLfloat object_bbox[4], fill_bbox[4], stroke_bbox[4];
glGetPathParameterfvNV(pathObj, GL_PATH_OBJECT_BOUNDING_BOX_NV, object_bbox);
glGetPathParameterfvNV(pathObj, GL_PATH_FILL_BOUNDING_BOX_NV, fill_bbox);
glGetPathParameterfvNV(pathObj, GL_PATH_STROKE_BOUNDING_BOX_NV, stroke_bbox);*/
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
switch(blend_mode)
{
case BLEND_LAYER: assert(0); break;
case BLEND_MULTIPLY: glBlendFunc(GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA); break;
case BLEND_SCREEN: glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR); break;
case BLEND_LIGHTEN: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_MAX); break;
case BLEND_DARKEN: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_MIN); break;
case BLEND_DIFFERENCE: assert(0); break;
case BLEND_ADD: glBlendFunc(GL_ONE, GL_ONE); break;
case BLEND_SUBTRACT: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_REVERSE_SUBTRACT); break;
case BLEND_INVERT: assert(0); break;
case BLEND_ALPHA: assert(0); break;
case BLEND_ERASE: assert(0); break;
case BLEND_OVERLAY: assert(0); glBlendFunc(GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA); break;
case BLEND_HARDLIGHT: assert(0); break;
}
glStencilFunc(GL_NOTEQUAL, 0, 0x1F);
glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO);
glEnable(GL_STENCIL_TEST);
if (NSVG_PAINT_NONE != shape->fill.type)
{
if (NSVG_PAINT_COLOR == shape->fill.type)
{
NVGcolor c = transformColor(nvgColorU32(shape->fill.color), cxform);
glColor4f(c.r, c.g, c.b, c.a);
} else if (NSVG_PAINT_LINEAR_GRADIENT == shape->fill.type)
LinearGrad(shape, cxform, 1);
else if (NSVG_PAINT_RADIAL_GRADIENT == shape->fill.type)
RadialGrad(shape, cxform, 1);
else if (NSVG_PAINT_IMAGE == shape->fill.type)
ImagePaint(shape, cxform, 1);
glStencilFillPathNV(pathObj, (NSVG_FILLRULE_EVENODD == shape->fillRule) ? GL_INVERT : GL_COUNT_UP_NV, 0x1F);
glCoverFillPathNV(pathObj, GL_BOUNDING_BOX_NV);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glPathTexGenNV(GL_TEXTURE0, GL_NONE, 0, NULL);
glPathColorGenNV(GL_PRIMARY_COLOR, GL_NONE, 0, NULL);
glDisable(GL_TEXTURE_2D);
}
if (/*NSVG_PAINT_NONE != shape->stroke.type*/NSVG_PAINT_COLOR == shape->stroke.type)
{
if (NSVG_PAINT_COLOR == shape->stroke.type)
{
NVGcolor c = transformColor(nvgColorU32(shape->stroke.color), cxform);
glColor4f(c.r, c.g, c.b, c.a);
}/* else if (NSVG_PAINT_LINEAR_GRADIENT == shape->stroke.type)
LinearGrad(shape, cxform, 0);
else if (NSVG_PAINT_RADIAL_GRADIENT == shape->stroke.type)
RadialGrad(shape, cxform, 0);
else if (NSVG_PAINT_IMAGE == shape->stroke.type)
ImagePaint(shape, cxform, 0);*/
glPathParameterfNV(pathObj, GL_PATH_STROKE_WIDTH_NV, shape->strokeWidth);
if (NSVG_JOIN_ROUND == shape->strokeLineJoin)
glPathParameteriNV(pathObj, GL_PATH_JOIN_STYLE_NV, GL_ROUND_NV);
else if (NSVG_JOIN_BEVEL == shape->strokeLineJoin)
glPathParameteriNV(pathObj, GL_PATH_JOIN_STYLE_NV, GL_BEVEL_NV);
else if (NSVG_JOIN_MITER == shape->strokeLineJoin)
glPathParameteriNV(pathObj, GL_PATH_JOIN_STYLE_NV, GL_MITER_TRUNCATE_NV);
glPathParameterfNV(pathObj, GL_PATH_MITER_LIMIT_NV, shape->miterLimit);
if (NSVG_CAP_ROUND == shape->strokeLineCap)
glPathParameteriNV(pathObj, GL_PATH_END_CAPS_NV, GL_ROUND_NV);
else if (NSVG_CAP_BUTT == shape->strokeLineCap)
glPathParameteriNV(pathObj, GL_PATH_END_CAPS_NV, GL_FLAT);
else if (NSVG_CAP_SQUARE == shape->strokeLineCap)
glPathParameteriNV(pathObj, GL_PATH_END_CAPS_NV, GL_SQUARE_NV);
GLint reference = 0x1;
glStencilStrokePathNV(pathObj, reference, 0x1F);
glCoverStrokePathNV(pathObj, GL_BOUNDING_BOX_NV);
glPathColorGenNV(GL_PRIMARY_COLOR, GL_NONE, 0, NULL);
}
glDisable(GL_STENCIL_TEST);
glDisable(GL_BLEND);
if (shape2)
glDeletePathsNV(pathObj, 1);
}
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPathRendering_nglPathParameteriNV(JNIEnv *env, jclass clazz, jint path, jint pname, jint value, jlong function_pointer) {
glPathParameteriNVPROC glPathParameteriNV = (glPathParameteriNVPROC)((intptr_t)function_pointer);
glPathParameteriNV(path, pname, value);
}
void NVPFont::createGlyphs()
{
if ( mGlyphBase != 0 ) {
glDeletePathsNV ( mGlyphBase, 1+numChars );
}
mGlyphBase = 0;
mPathTemplate = 0;
/* Create a range of path objects corresponding to Latin-1 character codes. */
mGlyphBase = glGenPathsNV ( 1+numChars );
/* Use the path object at the end of the range as a template. */
mPathTemplate = mGlyphBase;
//set stroke width of path as percentage of emscale
glPathCommandsNV ( mPathTemplate, 0, NULL, 0, GL_FLOAT, NULL );
glPathParameteriNV ( mPathTemplate, GL_PATH_STROKE_WIDTH_NV, GLint ( mStrokeWidth * mEmScale ) );
glPathParameteriNV ( mPathTemplate, GL_PATH_JOIN_STYLE_NV, GL_ROUND_NV );
//attempt to load glyphs from mFontname system font. If mFontName can't be found then load Arial. if Arial can't be found
//then load the default sans system font
glPathGlyphRangeNV ( mGlyphBase, mSystemFont ? GL_SYSTEM_FONT_NAME_NV : GL_FILE_NAME_NV, mFontName.c_str(), GL_NONE,
0, numChars,
GL_SKIP_MISSING_GLYPH_NV, mPathTemplate, GLfloat ( mEmScale ) );
glPathGlyphRangeNV ( mGlyphBase, GL_SYSTEM_FONT_NAME_NV, "Arial", GL_NONE,
0, numChars,
GL_SKIP_MISSING_GLYPH_NV, mPathTemplate, GLfloat ( mEmScale ) );
glPathGlyphRangeNV ( mGlyphBase, GL_STANDARD_FONT_NAME_NV, "Sans", GL_NONE,
0, numChars, GL_USE_MISSING_GLYPH_NV, mPathTemplate, GLfloat ( mEmScale ) );
float font_data[4];
glGetPathMetricRangeNV ( GL_FONT_Y_MIN_BOUNDS_BIT_NV | GL_FONT_Y_MAX_BOUNDS_BIT_NV |
GL_FONT_UNDERLINE_POSITION_BIT_NV | GL_FONT_UNDERLINE_THICKNESS_BIT_NV,
mGlyphBase + ' ', /*count*/1,
4 * sizeof ( GLfloat ),
font_data );
mFontMetrics.mYMin = font_data[0];
mFontMetrics.mYMax = font_data[1];
mFontMetrics.mUnderlinePosition = font_data[2];
mFontMetrics.mUnderlineThickness = font_data[3];
glGetPathMetricRangeNV ( GL_FONT_X_MIN_BOUNDS_BIT_NV | GL_FONT_X_MAX_BOUNDS_BIT_NV |
GL_FONT_UNITS_PER_EM_BIT_NV | GL_FONT_ASCENDER_BIT_NV,
mGlyphBase + ' ', /*count*/1,
4 * sizeof ( GLfloat ),
font_data );
mFontMetrics.mXMin = font_data[0];
mFontMetrics.mXMax = font_data[1];
mFontMetrics.mEmUnits = font_data[2];
mFontMetrics.mAscender = font_data[3];
glGetPathMetricRangeNV ( GL_FONT_DESCENDER_BIT_NV | GL_FONT_HEIGHT_BIT_NV | GL_FONT_MAX_ADVANCE_WIDTH_BIT_NV | GL_FONT_MAX_ADVANCE_HEIGHT_BIT_NV,
mGlyphBase + ' ', /*count*/1,
4 * sizeof ( GLfloat ),
font_data );
mFontMetrics.mDescender = font_data[0];
mFontMetrics.mFontHeight = font_data[1];
mFontMetrics.mMaxAdvanceWidth = font_data[2];
mFontMetrics.mMaxAdvanceHeight = font_data[3];
GLfloat glyphMetrics[256];
mGlyphMetrics = GlyphMetrics::create();
//collect glyph metrics
glGetPathMetricRangeNV ( GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV,
mGlyphBase, numChars,
0, /* stride of zero means sizeof(GLfloat) since 1 bit in mask */
glyphMetrics );
mGlyphMetrics->mHorizontalAdvance = std::vector<float> ( glyphMetrics, glyphMetrics + sizeof glyphMetrics / sizeof glyphMetrics[0] );
glGetPathMetricRangeNV ( GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV,
mGlyphBase, numChars,
0, /* stride of zero means sizeof(GLfloat) since 1 bit in mask */
glyphMetrics );
mGlyphMetrics->mVerticalAdvance = std::vector<float> ( glyphMetrics, glyphMetrics + sizeof glyphMetrics / sizeof glyphMetrics[0] );
glGetPathMetricRangeNV ( GL_GLYPH_WIDTH_BIT_NV,
mGlyphBase, numChars,
0, /* stride of zero means sizeof(GLfloat) since 1 bit in mask */
glyphMetrics );
mGlyphMetrics->mGlyphWidth = std::vector<float> ( glyphMetrics, glyphMetrics + sizeof glyphMetrics / sizeof glyphMetrics[0] );
glGetPathMetricRangeNV ( GL_GLYPH_HEIGHT_BIT_NV,
mGlyphBase, numChars,
0, /* stride of zero means sizeof(GLfloat) since 1 bit in mask */
glyphMetrics );
mGlyphMetrics->mGlyphHeight = std::vector<float> ( glyphMetrics, glyphMetrics + sizeof glyphMetrics / sizeof glyphMetrics[0] );
glGetPathMetricRangeNV ( GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV,
mGlyphBase, numChars,
0, /* stride of zero means sizeof(GLfloat) since 1 bit in mask */
glyphMetrics );
mGlyphMetrics->mHorizontalBearingX = std::vector<float> ( glyphMetrics, glyphMetrics + sizeof glyphMetrics / sizeof glyphMetrics[0] );
glGetPathMetricRangeNV ( GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV,
mGlyphBase, numChars,
0, /* stride of zero means sizeof(GLfloat) since 1 bit in mask */
glyphMetrics );
mGlyphMetrics->mHorizontalBearingY = std::vector<float> ( glyphMetrics, glyphMetrics + sizeof glyphMetrics / sizeof glyphMetrics[0] );
glGetPathMetricRangeNV ( GL_GLYPH_VERTICAL_BEARING_X_BIT_NV,
mGlyphBase, numChars,
0, /* stride of zero means sizeof(GLfloat) since 1 bit in mask */
glyphMetrics );
mGlyphMetrics->mVerticalBearingX = std::vector<float> ( glyphMetrics, glyphMetrics + sizeof glyphMetrics / sizeof glyphMetrics[0] );
glGetPathMetricRangeNV ( GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV,
mGlyphBase, numChars,
0, /* stride of zero means sizeof(GLfloat) since 1 bit in mask */
glyphMetrics );
mGlyphMetrics->mVerticalBearingY = std::vector<float> ( glyphMetrics, glyphMetrics + sizeof glyphMetrics / sizeof glyphMetrics[0] );
}
