From c986b1fd284a63413c3bd2be8acb6dcd5c7e7532 Mon Sep 17 00:00:00 2001 From: rmistry Date: Mon, 23 Jun 2014 06:06:36 -0700 Subject: Revert of Add functions to support NV_path_rendering in OpenGL ES (https://codereview.chromium.org/345723002/) Reason for revert: Will have to unfortunately revert this CL in order to revert https://codereview.chromium.org/319043005/ Original issue's description: > Add functions to support NV_path_rendering in OpenGL ES > > Add OpenGL ES extension functions needed to support NV_path_rendering in OpenGL > ES. > > The added glProgramPathFragmentInputGenNV call is defined in NV_path_rendering > revision 30, similar to following: > > Append to the end of the "Shader Inputs" subsection of Section 3.12.2 > "Shader Execution": > > The command > > void ProgramPathFragmentInputGenNV(uint program, > int location, > enum genMode, > int components, > const float *coeffs); > > controls how a user-defined (non-built-in) fragment input of a > GLSL program object is computed for fragment shading operations that > occur as a result of CoverFillPathNV or CoverStrokePathNV. > > /program/ names a GLSL program object. If /program/ has not been > successfully linked, the error INVALID_OPERATION is generated. > > The given fragment input generation state is loaded into the fragment > input variable location identified by /location/. This location > is a value returned either by GetProgramResourceLocation with a > /programInterface/ of FRAGMENT_INPUT_NV and a given fragment shader > input variable name or by GetProgramResourceiv with FRAGMENT_INPUT_NV > for the /programInterface/ and LOCATION for the property for a given > fragment input resource index. > > .... > > glProgramPathFragmentInputGenNV will be used instead of glPathTexGen, > because the latter depends on fixed function pipeline that is not > exposed in ES. > > Also add glGetProgramResourceLocation from OpenGL 4.3 or > ARB_program_interface_query. > > Also add FRAGMENT_INPUT define to be used with glGetProgramResourceLocation. > > The added functions are not used yet, but they're needed when implementing > NV_path_rendering support for OpenGL ES. They can also be used on OpenGL. > > Remove uncalled NV_path_rendering functions, so they do not cause confusion > or take space in the interface definition. The ones that are later used > can be re-added when needed. > > Remove definitions NV_path_rendering that are for NV_path_rendering function > parameters that are not used. The ones that are later used > can be re-added when needed. > > Committed: https://skia.googlesource.com/skia/+/4a995dfff2ecf91e8bf999d77e3218cec596232c R=bsalomon@google.com, kkinnunen@nvidia.com TBR=bsalomon@google.com, kkinnunen@nvidia.com NOTREECHECKS=true NOTRY=true Author: rmistry@google.com Review URL: https://codereview.chromium.org/349983002 --- src/gpu/gl/GrGLAssembleGLESInterface.h | 32 -------- src/gpu/gl/GrGLAssembleInterface.cpp | 38 ++++++++-- src/gpu/gl/GrGLCaps.cpp | 8 +- src/gpu/gl/GrGLDefines.h | 81 +++++++++++++++++++- src/gpu/gl/GrGLInterface.cpp | 133 +++++++++++++++++++++++---------- 5 files changed, 205 insertions(+), 87 deletions(-) (limited to 'src/gpu/gl') diff --git a/src/gpu/gl/GrGLAssembleGLESInterface.h b/src/gpu/gl/GrGLAssembleGLESInterface.h index 2a3f4f6734..ddbc980929 100644 --- a/src/gpu/gl/GrGLAssembleGLESInterface.h +++ b/src/gpu/gl/GrGLAssembleGLESInterface.h @@ -233,38 +233,6 @@ const GrGLInterface* GrGLAssembleGLESInterface(void* ctx, GrGLGetProc get) { GET_PROC(InvalidateTexImage); GET_PROC(InvalidateTexSubImage); - if (extensions.has("GL_EXT_direct_state_access")) { - GET_PROC_SUFFIX(MatrixLoadf, EXT); - GET_PROC_SUFFIX(MatrixLoadIdentity, EXT); - } - -#if USE_LINKED && GL_ES_VERSION_3_1 - GET_LINKED(GetProgramResourceLocation); -#else - if (version >= GR_GL_VER(3,1)) { - GET_PROC(GetProgramResourceLocation); - } -#endif - - if (extensions.has("GL_NV_path_rendering")) { - GET_PROC_SUFFIX(PathCommands, NV); - GET_PROC_SUFFIX(PathCoords, NV); - GET_PROC_SUFFIX(PathParameteri, NV); - GET_PROC_SUFFIX(PathParameterf, NV); - GET_PROC_SUFFIX(GenPaths, NV); - GET_PROC_SUFFIX(DeletePaths, NV); - GET_PROC_SUFFIX(PathStencilFunc, NV); - GET_PROC_SUFFIX(StencilFillPath, NV); - GET_PROC_SUFFIX(StencilStrokePath, NV); - GET_PROC_SUFFIX(StencilFillPathInstanced, NV); - GET_PROC_SUFFIX(StencilStrokePathInstanced, NV); - GET_PROC_SUFFIX(CoverFillPath, NV); - GET_PROC_SUFFIX(CoverStrokePath, NV); - GET_PROC_SUFFIX(CoverFillPathInstanced, NV); - GET_PROC_SUFFIX(CoverStrokePathInstanced, NV); - GET_PROC_SUFFIX(ProgramPathFragmentInputGen, NV); - } - interface->fStandard = kGLES_GrGLStandard; interface->fExtensions.swap(&extensions); diff --git a/src/gpu/gl/GrGLAssembleInterface.cpp b/src/gpu/gl/GrGLAssembleInterface.cpp index 4c02a6eb58..98dabffe13 100644 --- a/src/gpu/gl/GrGLAssembleInterface.cpp +++ b/src/gpu/gl/GrGLAssembleInterface.cpp @@ -224,21 +224,53 @@ const GrGLInterface* GrGLAssembleGLInterface(void* ctx, GrGLGetProc get) { if (extensions.has("GL_NV_path_rendering")) { GET_PROC_SUFFIX(PathCommands, NV); GET_PROC_SUFFIX(PathCoords, NV); + GET_PROC_SUFFIX(PathSubCommands, NV); + GET_PROC_SUFFIX(PathSubCoords, NV); + GET_PROC_SUFFIX(PathString, NV); + GET_PROC_SUFFIX(PathGlyphs, NV); + GET_PROC_SUFFIX(PathGlyphRange, NV); + GET_PROC_SUFFIX(WeightPaths, NV); + GET_PROC_SUFFIX(CopyPath, NV); + GET_PROC_SUFFIX(InterpolatePaths, NV); + GET_PROC_SUFFIX(TransformPath, NV); + GET_PROC_SUFFIX(PathParameteriv, NV); GET_PROC_SUFFIX(PathParameteri, NV); + GET_PROC_SUFFIX(PathParameterfv, NV); GET_PROC_SUFFIX(PathParameterf, NV); + GET_PROC_SUFFIX(PathDashArray, NV); GET_PROC_SUFFIX(GenPaths, NV); GET_PROC_SUFFIX(DeletePaths, NV); + GET_PROC_SUFFIX(IsPath, NV); GET_PROC_SUFFIX(PathStencilFunc, NV); + GET_PROC_SUFFIX(PathStencilDepthOffset, NV); GET_PROC_SUFFIX(StencilFillPath, NV); GET_PROC_SUFFIX(StencilStrokePath, NV); GET_PROC_SUFFIX(StencilFillPathInstanced, NV); GET_PROC_SUFFIX(StencilStrokePathInstanced, NV); + GET_PROC_SUFFIX(PathCoverDepthFunc, NV); + GET_PROC_SUFFIX(PathColorGen, NV); GET_PROC_SUFFIX(PathTexGen, NV); + GET_PROC_SUFFIX(PathFogGen, NV); GET_PROC_SUFFIX(CoverFillPath, NV); GET_PROC_SUFFIX(CoverStrokePath, NV); GET_PROC_SUFFIX(CoverFillPathInstanced, NV); GET_PROC_SUFFIX(CoverStrokePathInstanced, NV); - GET_PROC_SUFFIX(ProgramPathFragmentInputGen, NV); + GET_PROC_SUFFIX(GetPathParameteriv, NV); + GET_PROC_SUFFIX(GetPathParameterfv, NV); + GET_PROC_SUFFIX(GetPathCommands, NV); + GET_PROC_SUFFIX(GetPathCoords, NV); + GET_PROC_SUFFIX(GetPathDashArray, NV); + GET_PROC_SUFFIX(GetPathMetrics, NV); + GET_PROC_SUFFIX(GetPathMetricRange, NV); + GET_PROC_SUFFIX(GetPathSpacing, NV); + GET_PROC_SUFFIX(GetPathColorGeniv, NV); + GET_PROC_SUFFIX(GetPathColorGenfv, NV); + GET_PROC_SUFFIX(GetPathTexGeniv, NV); + GET_PROC_SUFFIX(GetPathTexGenfv, NV); + GET_PROC_SUFFIX(IsPointInFillPath, NV); + GET_PROC_SUFFIX(IsPointInStrokePath, NV); + GET_PROC_SUFFIX(GetPathLength, NV); + GET_PROC_SUFFIX(PointAlongPath, NV); } if (extensions.has("GL_EXT_debug_marker")) { @@ -256,10 +288,6 @@ const GrGLInterface* GrGLAssembleGLInterface(void* ctx, GrGLGetProc get) { GET_PROC(InvalidateTexSubImage); } - if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_program_interface_query")) { - GET_PROC(GetProgramResourceLocation); - } - interface->fStandard = kGL_GrGLStandard; interface->fExtensions.swap(&extensions); diff --git a/src/gpu/gl/GrGLCaps.cpp b/src/gpu/gl/GrGLCaps.cpp index 94a295cf7e..fdf6cacc08 100644 --- a/src/gpu/gl/GrGLCaps.cpp +++ b/src/gpu/gl/GrGLCaps.cpp @@ -312,13 +312,7 @@ bool GrGLCaps::init(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) { fMaxRenderTargetSize = SkTMin(fMaxTextureSize, fMaxRenderTargetSize); fPathRenderingSupport = ctxInfo.hasExtension("GL_NV_path_rendering") && - ctxInfo.hasExtension("GL_EXT_direct_state_access") && - (kGL_GrGLStandard == standard && - (ctxInfo.version() >= GR_GL_VER(4,3) || - ctxInfo.hasExtension("GL_ARB_program_interface_query"))); - // Note: path rendering is not yet implemented for GLES. - // Once it is, this will contain also: - // || (kGLES_GrGLStandard == standard && ctxInfo.version() >= GR_GL_VER(3,1)) + ctxInfo.hasExtension("GL_EXT_direct_state_access"); fGpuTracingSupport = ctxInfo.hasExtension("GL_EXT_debug_marker"); diff --git a/src/gpu/gl/GrGLDefines.h b/src/gpu/gl/GrGLDefines.h index 1e8d7cc278..e2ddde88c4 100644 --- a/src/gpu/gl/GrGLDefines.h +++ b/src/gpu/gl/GrGLDefines.h @@ -827,6 +827,19 @@ #define GR_GL_ARC_TO 0xFE #define GR_GL_RELATIVE_ARC_TO 0xFF +// path string formats +#define GR_GL_PATH_FORMAT_SVG 0x9070 +#define GR_GL_PATH_FORMAT_PS 0x9071 + +// font targets +#define GR_GL_STANDARD_FONT_NAME 0x9072 +#define GR_GL_SYSTEM_FONT_NAME 0x9073 +#define GR_GL_FILE_NAME 0x9074 + +// handle missing glyphs +#define GR_GL_SKIP_MISSING_GLYPH 0x90A9 +#define GR_GL_USE_MISSING_GLYPH 0x90AA + // path parameters #define GR_GL_PATH_STROKE_WIDTH 0x9075 #define GR_GL_PATH_INITIAL_END_CAP 0x9077 @@ -857,6 +870,10 @@ #define GR_GL_COUNT_DOWN 0x9089 /* GL_PATH_FILL_MODE_NV */ +// path color gen +/* GL_PRIMARY_COLOR */ +#define GR_GL_SECONDARY_COLOR 0x852D + // gen mode /* GL_NONE */ /* GL_EYE_LINEAR */ @@ -880,6 +897,11 @@ #define GR_GL_TRANSPOSE_AFFINE_2D 0x9096 #define GR_GL_TRANSPOSE_AFFINE_3D 0x9098 +// path string types +#define GR_GL_UTF8 0x909A +#define GR_GL_UTF16 0x909B + +#define GR_GL_PATH_COMPUTED_LENGTH 0x90A0 // cap/dash values /* GL_FLAT */ @@ -894,9 +916,60 @@ #define GR_GL_MITER_REVERT 0x90A7 #define GR_GL_MITER_TRUNCATE 0x90A8 -// NV_path_rendering extension to ARB_program_interface_query: -// .. corresponds to the set of active input variables used by the fragment -// shader stage of (if a fragment stage exists). -#define GR_GL_FRAGMENT_INPUT 0x936D +// path dash reset values +#define GR_GL_MOVE_TO_RESETS 0x90B5 +#define GR_GL_MOVE_TO_CONTINUES 0x90B6 + +// font styles +/* GL_NONE */ +#define GR_GL_BOLD_BIT 0x01 +#define GR_GL_ITALIC_BIT 0x02 + +// pnames for glGet +#define GR_GL_PATH_ERROR_POSITION 0x90AB +#define GR_GL_PATH_FOG_GEN_MODE 0x90AC +#define GR_GL_PATH_STENCIL_FUNC 0x90B7 +#define GR_GL_PATH_STENCIL_REF 0x90B8 +#define GR_GL_PATH_STENCIL_VALUE_MASK 0x90B9 +#define GR_GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR 0x90BD +#define GR_GL_PATH_STENCIL_DEPTH_OFFSET_UNITS 0x90BE +#define GR_GL_PATH_COVER_DEPTH_FUNC 0x90BF + +// per-glyph metrics bits in metric mask query +#define GR_GL_GLYPH_WIDTH_BIT 0x01 +#define GR_GL_GLYPH_HEIGHT_BIT 0x02 +#define GR_GL_GLYPH_HORIZONTAL_BEARING_X_BIT 0x04 +#define GR_GL_GLYPH_HORIZONTAL_BEARING_Y_BIT 0x08 +#define GR_GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT 0x10 +#define GR_GL_GLYPH_VERTICAL_BEARING_X_BIT 0x20 +#define GR_GL_GLYPH_VERTICAL_BEARING_Y_BIT 0x40 +#define GR_GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT 0x80 +#define GR_GL_GLYPH_HAS_KERNING 0x100 + +// per-font face metrics in metric mask query +#define GR_GL_FONT_X_MIN_BOUNDS 0x00010000 +#define GR_GL_FONT_Y_MIN_BOUNDS 0x00020000 +#define GR_GL_FONT_X_MAX_BOUNDS 0x00040000 +#define GR_GL_FONT_Y_MAX_BOUNDS 0x00080000 +#define GR_GL_FONT_UNITS_PER_EM 0x00100000 +#define GR_GL_FONT_ASCENDER 0x00200000 +#define GR_GL_FONT_DESCENDER 0x00400000 +#define GR_GL_FONT_HEIGHT 0x00800000 +#define GR_GL_FONT_MAX_ADVANCE_WIDTH 0x01000000 +#define GR_GL_FONT_MAX_ADVANCE_HEIGHT 0x02000000 +#define GR_GL_FONT_UNDERLINE_POSITION 0x04000000 +#define GR_GL_FONT_UNDERLINE_THICKNESS 0x08000000 +#define GR_GL_FONT_HAS_KERNING 0x10000000 + +// path list modes (glGetPathSpacing) +#define GR_GL_ACCUM_ADJACENT_PAIRS 0x90AD +#define GR_GL_ADJACENT_PAIRS 0x90AE +#define GR_GL_FIRST_TO_REST 0x90AF + +//path gen modes +#define GR_GL_PATH_GEN_MODE 0x90B0 +#define GR_GL_PATH_GEN_COEFF 0x90B1 +#define GR_GL_PATH_GEN_COLOR_FORMAT 0x90B2 +#define GR_GL_PATH_GEN_COMPONENTS 0x90B3 #endif diff --git a/src/gpu/gl/GrGLInterface.cpp b/src/gpu/gl/GrGLInterface.cpp index 825ad69029..b81d9ceeb8 100644 --- a/src/gpu/gl/GrGLInterface.cpp +++ b/src/gpu/gl/GrGLInterface.cpp @@ -39,23 +39,57 @@ const GrGLInterface* GrGLInterfaceRemoveNVPR(const GrGLInterface* interface) { GrGLInterface* newInterface = GrGLInterface::NewClone(interface); newInterface->fExtensions.remove("GL_NV_path_rendering"); + newInterface->fFunctions.fPathCommands = NULL; newInterface->fFunctions.fPathCoords = NULL; + newInterface->fFunctions.fPathSubCommands = NULL; + newInterface->fFunctions.fPathSubCoords = NULL; + newInterface->fFunctions.fPathString = NULL; + newInterface->fFunctions.fPathGlyphs = NULL; + newInterface->fFunctions.fPathGlyphRange = NULL; + newInterface->fFunctions.fWeightPaths = NULL; + newInterface->fFunctions.fCopyPath = NULL; + newInterface->fFunctions.fInterpolatePaths = NULL; + newInterface->fFunctions.fTransformPath = NULL; + newInterface->fFunctions.fPathParameteriv = NULL; newInterface->fFunctions.fPathParameteri = NULL; + newInterface->fFunctions.fPathParameterfv = NULL; newInterface->fFunctions.fPathParameterf = NULL; + newInterface->fFunctions.fPathDashArray = NULL; newInterface->fFunctions.fGenPaths = NULL; newInterface->fFunctions.fDeletePaths = NULL; + newInterface->fFunctions.fIsPath = NULL; newInterface->fFunctions.fPathStencilFunc = NULL; + newInterface->fFunctions.fPathStencilDepthOffset = NULL; newInterface->fFunctions.fStencilFillPath = NULL; newInterface->fFunctions.fStencilStrokePath = NULL; newInterface->fFunctions.fStencilFillPathInstanced = NULL; newInterface->fFunctions.fStencilStrokePathInstanced = NULL; + newInterface->fFunctions.fPathCoverDepthFunc = NULL; + newInterface->fFunctions.fPathColorGen = NULL; newInterface->fFunctions.fPathTexGen = NULL; + newInterface->fFunctions.fPathFogGen = NULL; newInterface->fFunctions.fCoverFillPath = NULL; newInterface->fFunctions.fCoverStrokePath = NULL; newInterface->fFunctions.fCoverFillPathInstanced = NULL; newInterface->fFunctions.fCoverStrokePathInstanced = NULL; - newInterface->fFunctions.fProgramPathFragmentInputGen = NULL; + newInterface->fFunctions.fGetPathParameteriv = NULL; + newInterface->fFunctions.fGetPathParameterfv = NULL; + newInterface->fFunctions.fGetPathCommands = NULL; + newInterface->fFunctions.fGetPathCoords = NULL; + newInterface->fFunctions.fGetPathDashArray = NULL; + newInterface->fFunctions.fGetPathMetrics = NULL; + newInterface->fFunctions.fGetPathMetricRange = NULL; + newInterface->fFunctions.fGetPathSpacing = NULL; + newInterface->fFunctions.fGetPathColorGeniv = NULL; + newInterface->fFunctions.fGetPathColorGenfv = NULL; + newInterface->fFunctions.fGetPathTexGeniv = NULL; + newInterface->fFunctions.fGetPathTexGenfv = NULL; + newInterface->fFunctions.fIsPointInFillPath = NULL; + newInterface->fFunctions.fIsPointInStrokePath = NULL; + newInterface->fFunctions.fGetPathLength = NULL; + newInterface->fFunctions.fPointAlongPath = NULL; + return newInterface; } @@ -258,6 +292,65 @@ bool GrGLInterface::validate() const { RETURN_FALSE_INTERFACE } } + if (fExtensions.has("GL_EXT_direct_state_access")) { + if (NULL == fFunctions.fMatrixLoadf || + NULL == fFunctions.fMatrixLoadIdentity) { + RETURN_FALSE_INTERFACE + } + } + if (fExtensions.has("GL_NV_path_rendering")) { + if (NULL == fFunctions.fPathCommands || + NULL == fFunctions.fPathCoords || + NULL == fFunctions.fPathSubCommands || + NULL == fFunctions.fPathSubCoords || + NULL == fFunctions.fPathString || + NULL == fFunctions.fPathGlyphs || + NULL == fFunctions.fPathGlyphRange || + NULL == fFunctions.fWeightPaths || + NULL == fFunctions.fCopyPath || + NULL == fFunctions.fInterpolatePaths || + NULL == fFunctions.fTransformPath || + NULL == fFunctions.fPathParameteriv || + NULL == fFunctions.fPathParameteri || + NULL == fFunctions.fPathParameterfv || + NULL == fFunctions.fPathParameterf || + NULL == fFunctions.fPathDashArray || + NULL == fFunctions.fGenPaths || + NULL == fFunctions.fDeletePaths || + NULL == fFunctions.fIsPath || + NULL == fFunctions.fPathStencilFunc || + NULL == fFunctions.fPathStencilDepthOffset || + NULL == fFunctions.fStencilFillPath || + NULL == fFunctions.fStencilStrokePath || + NULL == fFunctions.fStencilFillPathInstanced || + NULL == fFunctions.fStencilStrokePathInstanced || + NULL == fFunctions.fPathCoverDepthFunc || + NULL == fFunctions.fPathColorGen || + NULL == fFunctions.fPathTexGen || + NULL == fFunctions.fPathFogGen || + NULL == fFunctions.fCoverFillPath || + NULL == fFunctions.fCoverStrokePath || + NULL == fFunctions.fCoverFillPathInstanced || + NULL == fFunctions.fCoverStrokePathInstanced || + NULL == fFunctions.fGetPathParameteriv || + NULL == fFunctions.fGetPathParameterfv || + NULL == fFunctions.fGetPathCommands || + NULL == fFunctions.fGetPathCoords || + NULL == fFunctions.fGetPathDashArray || + NULL == fFunctions.fGetPathMetrics || + NULL == fFunctions.fGetPathMetricRange || + NULL == fFunctions.fGetPathSpacing || + NULL == fFunctions.fGetPathColorGeniv || + NULL == fFunctions.fGetPathColorGenfv || + NULL == fFunctions.fGetPathTexGeniv || + NULL == fFunctions.fGetPathTexGenfv || + NULL == fFunctions.fIsPointInFillPath || + NULL == fFunctions.fIsPointInStrokePath || + NULL == fFunctions.fGetPathLength || + NULL == fFunctions.fPointAlongPath) { + RETURN_FALSE_INTERFACE + } + } } // optional function on desktop before 1.3 @@ -433,43 +526,5 @@ bool GrGLInterface::validate() const { RETURN_FALSE_INTERFACE; } } - if (fExtensions.has("GL_EXT_direct_state_access")) { - if (NULL == fFunctions.fMatrixLoadf || - NULL == fFunctions.fMatrixLoadIdentity) { - RETURN_FALSE_INTERFACE - } - } - if ((kGL_GrGLStandard == fStandard && glVer >= GR_GL_VER(4,3)) || - fExtensions.has("GL_ARB_program_interface_query")) { - if (NULL == fFunctions.fGetProgramResourceLocation) { - RETURN_FALSE_INTERFACE - } - } - if (fExtensions.has("GL_NV_path_rendering")) { - if (NULL == fFunctions.fPathCommands || - NULL == fFunctions.fPathCoords || - NULL == fFunctions.fPathParameteri || - NULL == fFunctions.fPathParameterf || - NULL == fFunctions.fGenPaths || - NULL == fFunctions.fDeletePaths || - NULL == fFunctions.fPathStencilFunc || - NULL == fFunctions.fStencilFillPath || - NULL == fFunctions.fStencilStrokePath || - NULL == fFunctions.fStencilFillPathInstanced || - NULL == fFunctions.fStencilStrokePathInstanced || - NULL == fFunctions.fCoverFillPath || - NULL == fFunctions.fCoverStrokePath || - NULL == fFunctions.fCoverFillPathInstanced || - NULL == fFunctions.fCoverStrokePathInstanced) { - RETURN_FALSE_INTERFACE - } - // Currently ProgramPathFragmentInputGen is not used on - // OpenGL, rather PathTexGen is. - if ((kGL_GrGLStandard == fStandard && NULL == fFunctions.fPathTexGen) || - (kGLES_GrGLStandard == fStandard && NULL == fFunctions.fProgramPathFragmentInputGen)) { - RETURN_FALSE_INTERFACE - } - } - return true; } -- cgit v1.2.3