Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright LWJGL. All rights reserved.
* License terms: https://www.lwjgl.org/license
* MACHINE GENERATED FILE, DO NOT EDIT
*/
package org.lwjgl.opengles;
import java.nio.*;
import org.lwjgl.system.*;
import static org.lwjgl.system.Checks.*;
import static org.lwjgl.system.JNI.*;
import static org.lwjgl.system.MemoryStack.*;
import static org.lwjgl.system.MemoryUtil.*;
import static org.lwjgl.opengles.GLES20.*;
/**
* Native bindings to the NV_path_rendering extension.
*
*
Conventional OpenGL supports rendering images (pixel rectangles and bitmaps) and simple geometric primitives (points, lines, polygons).
*
*
This extension adds a new rendering paradigm, known as path rendering, for rendering filled and stroked paths. Path rendering is not novel but rather a
* standard part of most resolution-independent 2D rendering systems such as Flash, PDF, Silverlight, SVG, Java 2D, Office drawings, TrueType fonts,
* PostScript and its fonts, Quartz 2D, XML Paper Specification (XPS), and OpenVG. What is novel is the ability to mix path rendering with arbitrary
* OpenGL 3D rendering and imaging.
*
*
With this extension, path rendering becomes a first-class rendering mode within the OpenGL graphics system that can be arbitrarily mixed with existing
* OpenGL rendering and can take advantage of OpenGL's existing mechanisms for texturing, programmability, and per-fragment operations.
*
*
Unlike geometric primitive rendering, paths are specified on a 2D (non-projective) plane rather than in 3D (projective) space. Even though the path is
* defined in a 2D plane, every path can be transformed into 3D clip space allowing for 3D view frustum & user-defined clipping, depth offset, and depth
* testing in the same manner as geometric primitive rendering.
*
*
Both geometric primitive rendering and path rendering support rasterization of edges defined by line segments; however, path rendering also allows path
* segments to be specified by Bezier (cubic or quadratic) curves or partial elliptical arcs. This allows path rendering to define truly curved primitive
* boundaries unlike the straight edges of line and polygon primitives. Whereas geometric primitive rendering requires convex polygons for well-defined
* rendering results, path rendering allows (and encourages!) concave and curved outlines to be specified. These paths are even allowed to self-intersect.
*
*
When filling closed paths, the winding of paths (counterclockwise or clockwise) determines whether pixels are inside or outside of the path.
*
*
Paths can also be stroked whereby, conceptually, a fixed-width "brush" is pulled along the path such that the brush remains orthogonal to the gradient
* of each path segment. Samples within the sweep of this brush are considered inside the stroke of the path.
*
*
This extension supports path rendering through a sequence of three operations:
*
*
*
Path specification is the process of creating and updating a path object consisting of a set of path commands and a corresponding set of 2D
* vertices.
*
*
Path commands can be specified explicitly from path command and coordinate data, parsed from a string based on standard grammars for representing
* paths, or specified by a particular glyph of standard font representations. Also new paths can be specified by weighting one or more existing paths
* so long as all the weighted paths have consistent command sequences.
*
*
Each path object contains zero or more subpaths specified by a sequence of line segments, partial elliptical arcs, and (cubic or quadratic) Bezier
* curve segments. Each path may contain multiple subpaths that can be closed (forming a contour) or open.
*
Path stenciling is the process of updating the stencil buffer based on a path's coverage transformed into window space.
*
*
Path stenciling can determine either the filled or stroked coverage of a path.
*
*
The details of path stenciling are explained within the core of the specification.
*
*
Stenciling a stroked path supports all the standard embellishments for path stroking such as end caps, join styles, miter limits, dashing, and dash
* caps. These stroking properties specified are parameters of path objects.
*
Path covering is the process of emitting simple (convex & planar) geometry that (conservatively) "covers" the path's sample coverage in the stencil
* buffer. During path covering, stencil testing can be configured to discard fragments not within the actual coverage of the path as determined by
* prior path stenciling.
*
*
Path covering can cover either the filled or stroked coverage of a path.
*
*
The details of path covering are explained within the core of the specification.
*
*
*
To render a path object into the color buffer, an application specifies a path object and then uses a two-step rendering process. First, the path
* object is stenciled whereby the path object's stroked or filled coverage is rasterized into the stencil buffer. Second, the path object is covered
* whereby conservative bounding geometry for the path is transformed and rasterized with stencil testing configured to test against the coverage
* information written to the stencil buffer in the first step so that only fragments covered by the path are written during this second step. Also during
* this second step written pixels typically have their stencil value reset (so there's no need for clearing the stencil buffer between rendering each
* path).
*/
public class NVPathRendering {
/** Accepted in elements of the {@code commands} array parameter of PathCommandsNV and PathSubCommandsNV. */
public static final byte
GL_CLOSE_PATH_NV = 0x0,
GL_MOVE_TO_NV = 0x2,
GL_RELATIVE_MOVE_TO_NV = 0x3,
GL_LINE_TO_NV = 0x4,
GL_RELATIVE_LINE_TO_NV = 0x5,
GL_HORIZONTAL_LINE_TO_NV = 0x6,
GL_RELATIVE_HORIZONTAL_LINE_TO_NV = 0x7,
GL_VERTICAL_LINE_TO_NV = 0x8,
GL_RELATIVE_VERTICAL_LINE_TO_NV = 0x9,
GL_QUADRATIC_CURVE_TO_NV = 0xA,
GL_RELATIVE_QUADRATIC_CURVE_TO_NV = 0xB,
GL_CUBIC_CURVE_TO_NV = 0xC,
GL_RELATIVE_CUBIC_CURVE_TO_NV = 0xD,
GL_SMOOTH_QUADRATIC_CURVE_TO_NV = 0xE,
GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV = 0xF,
GL_SMOOTH_CUBIC_CURVE_TO_NV = 0x10,
GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV = 0x11,
GL_SMALL_CCW_ARC_TO_NV = 0x12,
GL_RELATIVE_SMALL_CCW_ARC_TO_NV = 0x13,
GL_SMALL_CW_ARC_TO_NV = 0x14,
GL_RELATIVE_SMALL_CW_ARC_TO_NV = 0x15,
GL_LARGE_CCW_ARC_TO_NV = 0x16,
GL_RELATIVE_LARGE_CCW_ARC_TO_NV = 0x17,
GL_LARGE_CW_ARC_TO_NV = 0x18,
GL_RELATIVE_LARGE_CW_ARC_TO_NV = 0x19,
GL_CONIC_CURVE_TO_NV = 0x1A,
GL_RELATIVE_CONIC_CURVE_TO_NV = 0x1B,
GL_ROUNDED_RECT_NV = (byte)0xE8,
GL_RELATIVE_ROUNDED_RECT_NV = (byte)0xE9,
GL_ROUNDED_RECT2_NV = (byte)0xEA,
GL_RELATIVE_ROUNDED_RECT2_NV = (byte)0xEB,
GL_ROUNDED_RECT4_NV = (byte)0xEC,
GL_RELATIVE_ROUNDED_RECT4_NV = (byte)0xED,
GL_ROUNDED_RECT8_NV = (byte)0xEE,
GL_RELATIVE_ROUNDED_RECT8_NV = (byte)0xEF,
GL_RESTART_PATH_NV = (byte)0xF0,
GL_DUP_FIRST_CUBIC_CURVE_TO_NV = (byte)0xF2,
GL_DUP_LAST_CUBIC_CURVE_TO_NV = (byte)0xF4,
GL_RECT_NV = (byte)0xF6,
GL_RELATIVE_RECT_NV = (byte)0xF7,
GL_CIRCULAR_CCW_ARC_TO_NV = (byte)0xF8,
GL_CIRCULAR_CW_ARC_TO_NV = (byte)0xFA,
GL_CIRCULAR_TANGENT_ARC_TO_NV = (byte)0xFC,
GL_ARC_TO_NV = (byte)0xFE,
GL_RELATIVE_ARC_TO_NV = (byte)0xFF;
/** Accepted by the {@code format} parameter of PathStringNV. */
public static final int
GL_PATH_FORMAT_SVG_NV = 0x9070,
GL_PATH_FORMAT_PS_NV = 0x9071;
/** Accepted by the {@code fontTarget} parameter of PathGlyphsNV, PathGlyphRangeNV, and PathGlyphIndexRangeNV. */
public static final int
GL_STANDARD_FONT_NAME_NV = 0x9072,
GL_SYSTEM_FONT_NAME_NV = 0x9073,
GL_FILE_NAME_NV = 0x9074;
/** Accepted by the {@code fontTarget} parameter of PathMemoryGlyphIndexArrayNV. */
public static final int GL_STANDARD_FONT_FORMAT_NV = 0x936C;
/** Accepted by the {@code handleMissingGlyph} parameter of PathGlyphsNV and PathGlyphRangeNV. */
public static final int
GL_SKIP_MISSING_GLYPH_NV = 0x90A9,
GL_USE_MISSING_GLYPH_NV = 0x90AA;
/** Returned by PathGlyphIndexRangeNV. */
public static final int
GL_FONT_GLYPHS_AVAILABLE_NV = 0x9368,
GL_FONT_TARGET_UNAVAILABLE_NV = 0x9369,
GL_FONT_UNAVAILABLE_NV = 0x936A,
GL_FONT_UNINTELLIGIBLE_NV = 0x936B;
/**
* Accepted by the {@code pname} parameter of PathParameterfNV, PathParameterfvNV, GetPathParameterfvNV, PathParameteriNV, PathParameterivNV, and
* GetPathParameterivNV.
*/
public static final int
GL_PATH_STROKE_WIDTH_NV = 0x9075,
GL_PATH_INITIAL_END_CAP_NV = 0x9077,
GL_PATH_TERMINAL_END_CAP_NV = 0x9078,
GL_PATH_JOIN_STYLE_NV = 0x9079,
GL_PATH_MITER_LIMIT_NV = 0x907A,
GL_PATH_INITIAL_DASH_CAP_NV = 0x907C,
GL_PATH_TERMINAL_DASH_CAP_NV = 0x907D,
GL_PATH_DASH_OFFSET_NV = 0x907E,
GL_PATH_CLIENT_LENGTH_NV = 0x907F,
GL_PATH_DASH_OFFSET_RESET_NV = 0x90B4,
GL_PATH_FILL_MODE_NV = 0x9080,
GL_PATH_FILL_MASK_NV = 0x9081,
GL_PATH_FILL_COVER_MODE_NV = 0x9082,
GL_PATH_STROKE_COVER_MODE_NV = 0x9083,
GL_PATH_STROKE_MASK_NV = 0x9084,
GL_PATH_STROKE_BOUND_NV = 0x9086;
/** Accepted by the {@code pname} parameter of PathParameterfNV and PathParameterfvNV. */
public static final int
GL_PATH_END_CAPS_NV = 0x9076,
GL_PATH_DASH_CAPS_NV = 0x907B;
/** Accepted by the {@code fillMode} parameter of StencilFillPathNV and StencilFillPathInstancedNV. */
public static final int
GL_COUNT_UP_NV = 0x9088,
GL_COUNT_DOWN_NV = 0x9089;
/** Accepted by the {@code genMode} parameter of PathColorGenNV, PathTexGenNV, ProgramPathFragmentInputGenNV. */
public static final int GL_PATH_OBJECT_BOUNDING_BOX_NV = 0x908A;
/** Accepted by the {@code coverMode} parameter of CoverFillPathNV and CoverFillPathInstancedNV. */
public static final int
GL_CONVEX_HULL_NV = 0x908B,
GL_BOUNDING_BOX_NV = 0x908D;
/**
* Accepted by the {@code transformType} parameter of StencilFillPathInstancedNV, StencilStrokePathInstancedNV, CoverFillPathInstancedNV, and
* CoverStrokePathInstancedNV.
*/
public static final int
GL_TRANSLATE_X_NV = 0x908E,
GL_TRANSLATE_Y_NV = 0x908F,
GL_TRANSLATE_2D_NV = 0x9090,
GL_TRANSLATE_3D_NV = 0x9091,
GL_AFFINE_2D_NV = 0x9092,
GL_AFFINE_3D_NV = 0x9094,
GL_TRANSPOSE_AFFINE_2D_NV = 0x9096,
GL_TRANSPOSE_AFFINE_3D_NV = 0x9098;
/**
* Accepted by the {@code type} or {@code pathNameType} parameter of StencilFillPathInstancedNV, StencilStrokePathInstancedNV, CoverFillPathInstancedNV,
* CoverStrokePathInstancedNV, GetPathMetricsNV, and GetPathSpacingNV.
*/
public static final int
GL_UTF8_NV = 0x909A,
GL_UTF16_NV = 0x909B;
/** Accepted by the {@code coverMode} parameter of CoverFillPathInstancedNV. */
public static final int GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV = 0x909C;
/** Accepted by the {@code pname} parameter of GetPathParameterfvNV and GetPathParameterivNV. */
public static final int
GL_PATH_COMMAND_COUNT_NV = 0x909D,
GL_PATH_COORD_COUNT_NV = 0x909E,
GL_PATH_DASH_ARRAY_COUNT_NV = 0x909F,
GL_PATH_COMPUTED_LENGTH_NV = 0x90A0,
GL_PATH_FILL_BOUNDING_BOX_NV = 0x90A1,
GL_PATH_STROKE_BOUNDING_BOX_NV = 0x90A2;
/**
* Accepted by the {@code value} parameter of PathParameterfNV, PathParameterfvNV, PathParameteriNV, and PathParameterivNV when {@code pname} is one of
* PATH_END_CAPS_NV, PATH_INTIAL_END_CAP_NV, PATH_TERMINAL_END_CAP_NV, PATH_DASH_CAPS_NV, PATH_INITIAL_DASH_CAP_NV, and PATH_TERMINAL_DASH_CAP_NV.
*/
public static final int
GL_SQUARE_NV = 0x90A3,
GL_ROUND_NV = 0x90A4,
GL_TRIANGULAR_NV = 0x90A5;
/**
* Accepted by the {@code value} parameter of PathParameterfNV, PathParameterfvNV, PathParameteriNV, and PathParameterivNV when {@code pname} is
* PATH_JOIN_STYLE_NV.
*/
public static final int
GL_BEVEL_NV = 0x90A6,
GL_MITER_REVERT_NV = 0x90A7,
GL_MITER_TRUNCATE_NV = 0x90A8;
/**
* Accepted by the {@code value} parameter of PathParameterfNV, PathParameterfvNV, PathParameteriNV, and PathParameterivNV when {@code pname} is
* PATH_DASH_OFFSET_RESET_NV.
*/
public static final int
GL_MOVE_TO_RESETS_NV = 0x90B5,
GL_MOVE_TO_CONTINUES_NV = 0x90B6;
/** Accepted by the {@code fontStyle} parameter of PathGlyphsNV, PathGlyphRangeNV, and PathGlyphIndexRangeNV. */
public static final int
GL_BOLD_BIT_NV = 0x1,
GL_ITALIC_BIT_NV = 0x2;
/** Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetInteger64v, GetFloatv, and GetDoublev. */
public static final int
GL_PATH_ERROR_POSITION_NV = 0x90AB,
GL_PATH_STENCIL_FUNC_NV = 0x90B7,
GL_PATH_STENCIL_REF_NV = 0x90B8,
GL_PATH_STENCIL_VALUE_MASK_NV = 0x90B9,
GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV = 0x90BD,
GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV = 0x90BE,
GL_PATH_COVER_DEPTH_FUNC_NV = 0x90BF;
/** Accepted as a bit within the {@code metricQueryMask} parameter of GetPathMetricRangeNV or GetPathMetricsNV. */
public static final int
GL_GLYPH_WIDTH_BIT_NV = 0x1,
GL_GLYPH_HEIGHT_BIT_NV = 0x2,
GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV = 0x4,
GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV = 0x8,
GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV = 0x10,
GL_GLYPH_VERTICAL_BEARING_X_BIT_NV = 0x20,
GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV = 0x40,
GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV = 0x80,
GL_GLYPH_HAS_KERNING_BIT_NV = 0x100,
GL_FONT_X_MIN_BOUNDS_BIT_NV = 0x10000,
GL_FONT_Y_MIN_BOUNDS_BIT_NV = 0x20000,
GL_FONT_X_MAX_BOUNDS_BIT_NV = 0x40000,
GL_FONT_Y_MAX_BOUNDS_BIT_NV = 0x80000,
GL_FONT_UNITS_PER_EM_BIT_NV = 0x100000,
GL_FONT_ASCENDER_BIT_NV = 0x200000,
GL_FONT_DESCENDER_BIT_NV = 0x400000,
GL_FONT_HEIGHT_BIT_NV = 0x800000,
GL_FONT_MAX_ADVANCE_WIDTH_BIT_NV = 0x1000000,
GL_FONT_MAX_ADVANCE_HEIGHT_BIT_NV = 0x2000000,
GL_FONT_UNDERLINE_POSITION_BIT_NV = 0x4000000,
GL_FONT_UNDERLINE_THICKNESS_BIT_NV = 0x8000000,
GL_FONT_HAS_KERNING_BIT_NV = 0x10000000,
GL_FONT_NUM_GLYPH_INDICES_BIT_NV = 0x20000000;
/** Accepted by the {@code pathListMode} parameter of GetPathSpacingNV. */
public static final int
GL_ACCUM_ADJACENT_PAIRS_NV = 0x90AD,
GL_ADJACENT_PAIRS_NV = 0x90AE,
GL_FIRST_TO_REST_NV = 0x90AF;
/**
* Accepted by the {@code programInterface} parameter of GetProgramInterfaceiv, GetProgramResourceIndex, GetProgramResourceName, GetProgramResourceiv,
* GetProgramResourcefvNV, and GetProgramResourceLocation.
*/
public static final int GL_FRAGMENT_INPUT_NV = 0x936D;
/** Token values for matrices. */
public static final int
GL_PATH_PROJECTION_NV = 0x1701,
GL_PATH_MODELVIEW_NV = 0x1700,
GL_PATH_MODELVIEW_STACK_DEPTH_NV = 0xBA3,
GL_PATH_MODELVIEW_MATRIX_NV = 0xBA6,
GL_PATH_MAX_MODELVIEW_STACK_DEPTH_NV = 0xD36,
GL_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV = 0x84E3,
GL_PATH_PROJECTION_STACK_DEPTH_NV = 0xBA4,
GL_PATH_PROJECTION_MATRIX_NV = 0xBA7,
GL_PATH_MAX_PROJECTION_STACK_DEPTH_NV = 0xD38,
GL_PATH_TRANSPOSE_PROJECTION_MATRIX_NV = 0x84E4;
/** The following types are defined as alias to the GL tokens. */
public static final int
GL_2_BYTES_NV = 0x1407,
GL_3_BYTES_NV = 0x1408,
GL_4_BYTES_NV = 0x1409,
GL_EYE_LINEAR_NV = 0x2400,
GL_OBJECT_LINEAR_NV = 0x2401,
GL_CONSTANT_NV = 0x8576;
static { GLES.initialize(); }
protected NVPathRendering() {
throw new UnsupportedOperationException();
}
static boolean isAvailable(GLESCapabilities caps) {
return checkFunctions(
caps.glPathCommandsNV, caps.glPathCoordsNV, caps.glPathSubCommandsNV, caps.glPathSubCoordsNV, caps.glPathStringNV, caps.glPathGlyphsNV,
caps.glPathGlyphRangeNV, caps.glCopyPathNV, caps.glInterpolatePathsNV, caps.glTransformPathNV, caps.glPathParameterivNV, caps.glPathParameteriNV,
caps.glPathParameterfvNV, caps.glPathParameterfNV, caps.glPathDashArrayNV, caps.glGenPathsNV, caps.glDeletePathsNV, caps.glIsPathNV,
caps.glPathStencilFuncNV, caps.glPathStencilDepthOffsetNV, caps.glStencilFillPathNV, caps.glStencilStrokePathNV, caps.glStencilFillPathInstancedNV,
caps.glStencilStrokePathInstancedNV, caps.glPathCoverDepthFuncNV, caps.glCoverFillPathNV, caps.glCoverStrokePathNV, caps.glCoverFillPathInstancedNV,
caps.glCoverStrokePathInstancedNV, caps.glGetPathParameterivNV, caps.glGetPathParameterfvNV, caps.glGetPathCommandsNV, caps.glGetPathCoordsNV,
caps.glGetPathDashArrayNV, caps.glGetPathMetricsNV, caps.glGetPathMetricRangeNV, caps.glGetPathSpacingNV, caps.glIsPointInFillPathNV,
caps.glIsPointInStrokePathNV, caps.glGetPathLengthNV, caps.glPointAlongPathNV
);
}
// --- [ glPathCommandsNV ] ---
/** Unsafe version of: {@link #glPathCommandsNV PathCommandsNV} */
public static native void nglPathCommandsNV(int path, int numCommands, long commands, int numCoords, int coordType, long coords);
/**
*
*
* @param path
* @param commands
* @param coordType one of:
* @param coords
*/
public static void glPathSubCommandsNV(int path, int commandStart, int commandsToDelete, ByteBuffer commands, int coordType, ShortBuffer coords) {
nglPathSubCommandsNV(path, commandStart, commandsToDelete, commands.remaining(), memAddress(commands), coords.remaining(), coordType, memAddress(coords));
}
/**
*
*
* @param path
* @param commandStart
* @param commandsToDelete
* @param commands
* @param coordType one of:
{@link GLES20#GL_BYTE BYTE}
{@link GLES20#GL_UNSIGNED_BYTE UNSIGNED_BYTE}
{@link GLES20#GL_SHORT SHORT}
{@link GLES20#GL_UNSIGNED_SHORT UNSIGNED_SHORT}
{@link GLES20#GL_FLOAT FLOAT}
* @param coords
*/
public static void glPathSubCommandsNV(int path, int commandStart, int commandsToDelete, ByteBuffer commands, int coordType, FloatBuffer coords) {
nglPathSubCommandsNV(path, commandStart, commandsToDelete, commands.remaining(), memAddress(commands), coords.remaining(), coordType, memAddress(coords));
}
// --- [ glPathSubCoordsNV ] ---
/** Unsafe version of: {@link #glPathSubCoordsNV PathSubCoordsNV} */
public static native void nglPathSubCoordsNV(int path, int coordStart, int numCoords, int coordType, long coords);
/**
*
*
* @param path
* @param coordStart
* @param coordType one of:
{@link GLES20#GL_BYTE BYTE}
{@link GLES20#GL_UNSIGNED_BYTE UNSIGNED_BYTE}
{@link GLES20#GL_SHORT SHORT}
{@link GLES20#GL_UNSIGNED_SHORT UNSIGNED_SHORT}
{@link GLES20#GL_FLOAT FLOAT}
* @param coords
*/
public static void glPathSubCoordsNV(int path, int coordStart, int coordType, ByteBuffer coords) {
nglPathSubCoordsNV(path, coordStart, coords.remaining() >> GLESChecks.typeToByteShift(coordType), coordType, memAddress(coords));
}
/**
*
*
* @param path
* @param coordStart
* @param coordType one of:
{@link GLES20#GL_BYTE BYTE}
{@link GLES20#GL_UNSIGNED_BYTE UNSIGNED_BYTE}
{@link GLES20#GL_SHORT SHORT}
{@link GLES20#GL_UNSIGNED_SHORT UNSIGNED_SHORT}
{@link GLES20#GL_FLOAT FLOAT}
* @param coords
*/
public static void glPathSubCoordsNV(int path, int coordStart, int coordType, ShortBuffer coords) {
nglPathSubCoordsNV(path, coordStart, coords.remaining(), coordType, memAddress(coords));
}
/**
*
*
* @param path
* @param coordStart
* @param coordType one of:
{@link GLES20#GL_BYTE BYTE}
{@link GLES20#GL_UNSIGNED_BYTE UNSIGNED_BYTE}
{@link GLES20#GL_SHORT SHORT}
{@link GLES20#GL_UNSIGNED_SHORT UNSIGNED_SHORT}
{@link GLES20#GL_FLOAT FLOAT}
* @param coords
*/
public static void glPathSubCoordsNV(int path, int coordStart, int coordType, FloatBuffer coords) {
nglPathSubCoordsNV(path, coordStart, coords.remaining(), coordType, memAddress(coords));
}
// --- [ glPathStringNV ] ---
/** Unsafe version of: {@link #glPathStringNV PathStringNV} */
public static native void nglPathStringNV(int path, int format, int length, long pathString);
/**
*
*
* @param path
* @param format one of:
{@link #GL_PATH_FORMAT_SVG_NV PATH_FORMAT_SVG_NV}
{@link #GL_PATH_FORMAT_PS_NV PATH_FORMAT_PS_NV}
* @param pathString
*/
public static void glPathStringNV(int path, int format, ByteBuffer pathString) {
nglPathStringNV(path, format, pathString.remaining(), memAddress(pathString));
}
// --- [ glPathGlyphsNV ] ---
/** Unsafe version of: {@link #glPathGlyphsNV PathGlyphsNV} */
public static native void nglPathGlyphsNV(int firstPathName, int fontTarget, long fontName, int fontStyle, int numGlyphs, int type, long charcodes, int handleMissingGlyphs, int pathParameterTemplate, float emScale);
/**
*
*
* @param firstPathName
* @param fontTarget one of:
* @param pathParameterTemplate
* @param emScale
*/
public static void glPathGlyphRangeNV(int firstPathName, int fontTarget, ByteBuffer fontName, int fontStyle, int firstGlyph, int numGlyphs, int handleMissingGlyphs, int pathParameterTemplate, float emScale) {
if ( CHECKS )
checkNT1(fontName);
nglPathGlyphRangeNV(firstPathName, fontTarget, memAddress(fontName), fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale);
}
// --- [ glPathGlyphIndexArrayNV ] ---
/** Unsafe version of: {@link #glPathGlyphIndexArrayNV PathGlyphIndexArrayNV} */
public static native int nglPathGlyphIndexArrayNV(int firstPathName, int fontTarget, long fontName, int fontStyle, int firstGlyphIndex, int numGlyphs, int pathParameterTemplate, float emScale);
/**
*
*
* @param firstPathName
* @param fontTarget one of:
* @param fontName
* @param fontStyle one or more of:
{@link #GL_BOLD_BIT_NV BOLD_BIT_NV}
{@link #GL_ITALIC_BIT_NV ITALIC_BIT_NV}
* @param firstGlyphIndex
* @param numGlyphs
* @param pathParameterTemplate
* @param emScale
*/
public static int glPathGlyphIndexArrayNV(int firstPathName, int fontTarget, ByteBuffer fontName, int fontStyle, int firstGlyphIndex, int numGlyphs, int pathParameterTemplate, float emScale) {
if ( CHECKS )
checkNT1(fontName);
return nglPathGlyphIndexArrayNV(firstPathName, fontTarget, memAddress(fontName), fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
}
// --- [ glPathMemoryGlyphIndexArrayNV ] ---
/** Unsafe version of: {@link #glPathMemoryGlyphIndexArrayNV PathMemoryGlyphIndexArrayNV} */
public static native int nglPathMemoryGlyphIndexArrayNV(int firstPathName, int fontTarget, long fontSize, long fontData, int faceIndex, int firstGlyphIndex, int numGlyphs, int pathParameterTemplate, float emScale);
/**
*
*
* @param firstPathName
* @param fontTarget one of:
* @param value
*/
public static void glPathParameterfNV(int path, int pname, float value) {
nglPathParameterfNV(path, pname, value);
}
// --- [ glPathDashArrayNV ] ---
public static native void nglPathDashArrayNV(int path, int dashCount, long dashArray);
public static void glPathDashArrayNV(int path, FloatBuffer dashArray) {
nglPathDashArrayNV(path, dashArray.remaining(), memAddress(dashArray));
}
// --- [ glGenPathsNV ] ---
public static native int nglGenPathsNV(int range);
public static int glGenPathsNV(int range) {
return nglGenPathsNV(range);
}
// --- [ glDeletePathsNV ] ---
public static native void nglDeletePathsNV(int path, int range);
public static void glDeletePathsNV(int path, int range) {
nglDeletePathsNV(path, range);
}
// --- [ glIsPathNV ] ---
public static native boolean nglIsPathNV(int path);
public static boolean glIsPathNV(int path) {
return nglIsPathNV(path);
}
// --- [ glPathStencilFuncNV ] ---
public static native void nglPathStencilFuncNV(int func, int ref, int mask);
public static void glPathStencilFuncNV(int func, int ref, int mask) {
nglPathStencilFuncNV(func, ref, mask);
}
// --- [ glPathStencilDepthOffsetNV ] ---
public static native void nglPathStencilDepthOffsetNV(float factor, float units);
public static void glPathStencilDepthOffsetNV(float factor, float units) {
nglPathStencilDepthOffsetNV(factor, units);
}
// --- [ glStencilFillPathNV ] ---
/** Unsafe version of: {@link #glStencilFillPathNV StencilFillPathNV} */
public static native void nglStencilFillPathNV(int path, int fillMode, int mask);
/**
*
*
* @param path
* @param fillMode one of:
{@link GLES20#GL_INVERT INVERT}
{@link #GL_COUNT_UP_NV COUNT_UP_NV}
{@link #GL_COUNT_DOWN_NV COUNT_DOWN_NV}
{@link #GL_PATH_FILL_MODE_NV PATH_FILL_MODE_NV}
* @param mask
*/
public static void glStencilFillPathNV(int path, int fillMode, int mask) {
nglStencilFillPathNV(path, fillMode, mask);
}
// --- [ glStencilStrokePathNV ] ---
public static native void nglStencilStrokePathNV(int path, int reference, int mask);
public static void glStencilStrokePathNV(int path, int reference, int mask) {
nglStencilStrokePathNV(path, reference, mask);
}
// --- [ glStencilFillPathInstancedNV ] ---
/** Unsafe version of: {@link #glStencilFillPathInstancedNV StencilFillPathInstancedNV} */
public static native void nglStencilFillPathInstancedNV(int numPaths, int pathNameType, long paths, int pathBase, int fillMode, int mask, int transformType, long transformValues);
/**
*
*
* @param pathNameType one of:
* @param transformValues
*/
public static void glStencilStrokePathInstancedNV(int pathNameType, ByteBuffer paths, int pathBase, int reference, int mask, int transformType, FloatBuffer transformValues) {
int numPaths = paths.remaining() / pathNameTypeToBytes(pathNameType);
if ( CHECKS )
check(transformValues, numPaths * transformTypeToElements(transformType));
nglStencilStrokePathInstancedNV(numPaths, pathNameType, memAddress(paths), pathBase, reference, mask, transformType, memAddress(transformValues));
}
// --- [ glPathCoverDepthFuncNV ] ---
public static native void nglPathCoverDepthFuncNV(int zfunc);
public static void glPathCoverDepthFuncNV(int zfunc) {
nglPathCoverDepthFuncNV(zfunc);
}
// --- [ glCoverFillPathNV ] ---
/** Unsafe version of: {@link #glCoverFillPathNV CoverFillPathNV} */
public static native void nglCoverFillPathNV(int path, int coverMode);
/**
*
*
* @param path
* @param coverMode one of:
{@link #GL_CONVEX_HULL_NV CONVEX_HULL_NV}
{@link #GL_BOUNDING_BOX_NV BOUNDING_BOX_NV}
*/
public static void glCoverFillPathNV(int path, int coverMode) {
nglCoverFillPathNV(path, coverMode);
}
// --- [ glCoverStrokePathNV ] ---
/** Unsafe version of: {@link #glCoverStrokePathNV CoverStrokePathNV} */
public static native void nglCoverStrokePathNV(int path, int coverMode);
/**
*
*
* @param path
* @param coverMode one of:
{@link #GL_CONVEX_HULL_NV CONVEX_HULL_NV}
{@link #GL_BOUNDING_BOX_NV BOUNDING_BOX_NV}
*/
public static void glCoverStrokePathNV(int path, int coverMode) {
nglCoverStrokePathNV(path, coverMode);
}
// --- [ glCoverFillPathInstancedNV ] ---
/** Unsafe version of: {@link #glCoverFillPathInstancedNV CoverFillPathInstancedNV} */
public static native void nglCoverFillPathInstancedNV(int numPaths, int pathNameType, long paths, int pathBase, int coverMode, int transformType, long transformValues);
/**
*
*
* @param pathNameType one of:
* @param transformValues
*/
public static void glCoverStrokePathInstancedNV(int pathNameType, ByteBuffer paths, int pathBase, int coverMode, int transformType, FloatBuffer transformValues) {
int numPaths = paths.remaining() / pathNameTypeToBytes(pathNameType);
if ( CHECKS )
check(transformValues, numPaths * transformTypeToElements(transformType));
nglCoverStrokePathInstancedNV(numPaths, pathNameType, memAddress(paths), pathBase, coverMode, transformType, memAddress(transformValues));
}
// --- [ glStencilThenCoverFillPathNV ] ---
/** Unsafe version of: {@link #glStencilThenCoverFillPathNV StencilThenCoverFillPathNV} */
public static native void nglStencilThenCoverFillPathNV(int path, int fillMode, int mask, int coverMode);
/**
*
*
* @param path
* @param fillMode one of:
{@link GLES20#GL_INVERT INVERT}
{@link #GL_COUNT_UP_NV COUNT_UP_NV}
{@link #GL_COUNT_DOWN_NV COUNT_DOWN_NV}
{@link #GL_PATH_FILL_MODE_NV PATH_FILL_MODE_NV}
* @param mask
* @param coverMode one of:
{@link #GL_CONVEX_HULL_NV CONVEX_HULL_NV}
{@link #GL_BOUNDING_BOX_NV BOUNDING_BOX_NV}
*/
public static void glStencilThenCoverFillPathNV(int path, int fillMode, int mask, int coverMode) {
nglStencilThenCoverFillPathNV(path, fillMode, mask, coverMode);
}
// --- [ glStencilThenCoverStrokePathNV ] ---
/** Unsafe version of: {@link #glStencilThenCoverStrokePathNV StencilThenCoverStrokePathNV} */
public static native void nglStencilThenCoverStrokePathNV(int path, int reference, int mask, int coverMode);
/**
*
*
* @param path
* @param reference
* @param mask
* @param coverMode one of:
{@link #GL_CONVEX_HULL_NV CONVEX_HULL_NV}
{@link #GL_BOUNDING_BOX_NV BOUNDING_BOX_NV}
*/
public static void glStencilThenCoverStrokePathNV(int path, int reference, int mask, int coverMode) {
nglStencilThenCoverStrokePathNV(path, reference, mask, coverMode);
}
// --- [ glStencilThenCoverFillPathInstancedNV ] ---
/** Unsafe version of: {@link #glStencilThenCoverFillPathInstancedNV StencilThenCoverFillPathInstancedNV} */
public static native void nglStencilThenCoverFillPathInstancedNV(int numPaths, int pathNameType, long paths, int pathBase, int fillMode, int mask, int coverMode, int transformType, long transformValues);
/**
*
*
* @param pathNameType one of:
* @param transformValues
*/
public static void glStencilThenCoverFillPathInstancedNV(int pathNameType, ByteBuffer paths, int pathBase, int fillMode, int mask, int coverMode, int transformType, FloatBuffer transformValues) {
int numPaths = paths.remaining() / pathNameTypeToBytes(pathNameType);
if ( CHECKS )
check(transformValues, numPaths * transformTypeToElements(transformType));
nglStencilThenCoverFillPathInstancedNV(numPaths, pathNameType, memAddress(paths), pathBase, fillMode, mask, coverMode, transformType, memAddress(transformValues));
}
// --- [ glStencilThenCoverStrokePathInstancedNV ] ---
/** Unsafe version of: {@link #glStencilThenCoverStrokePathInstancedNV StencilThenCoverStrokePathInstancedNV} */
public static native void nglStencilThenCoverStrokePathInstancedNV(int numPaths, int pathNameType, long paths, int pathBase, int reference, int mask, int coverMode, int transformType, long transformValues);
/**
*
*
* @param pathNameType one of:
