JOGL v2.6.0-rc-20250706
JOGL, High-Performance Graphics Binding for Java™ (public API).
GLConfiguration.java
Go to the documentation of this file.
1/*
2 * Copyright (c) 2003-2005 Sun Microsystems, Inc. All Rights Reserved.
3 * Copyright (c) 2010 JogAmp Community. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met:
8 *
9 * - Redistribution of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 *
12 * - Redistribution in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * Neither the name of Sun Microsystems, Inc. or the names of
17 * contributors may be used to endorse or promote products derived from
18 * this software without specific prior written permission.
19 *
20 * This software is provided "AS IS," without a warranty of any kind. ALL
21 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
22 * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
23 * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
24 * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
25 * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
26 * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
27 * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
28 * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
29 * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
30 * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
31 * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
32 *
33 * You acknowledge that this software is not designed or intended for use
34 * in the design, construction, operation or maintenance of any nuclear
35 * facility.
36 *
37 * Sun gratefully acknowledges that this software was originally authored
38 * and developed by Kenneth Bradley Russell and Christopher John Kline.
39 */
40package com.jogamp.gluegen.opengl;
41
42import static java.util.logging.Level.INFO;
43
44import com.jogamp.gluegen.GlueEmitterControls;
45import com.jogamp.gluegen.GlueGen;
46import com.jogamp.gluegen.MethodBinding;
47import com.jogamp.gluegen.cgram.types.AliasedSymbol;
48import com.jogamp.gluegen.procaddress.ProcAddressConfiguration;
49import com.jogamp.gluegen.runtime.opengl.GLNameResolver;
50
51import java.io.File;
52import java.io.IOException;
53import java.util.ArrayList;
54import java.util.HashMap;
55import java.util.HashSet;
56import java.util.Iterator;
57import java.util.List;
58import java.util.Map;
59import java.util.NoSuchElementException;
60import java.util.Set;
61import java.util.StringTokenizer;
62
63public class GLConfiguration extends ProcAddressConfiguration {
64
65 // The following data members support ignoring an entire extension at a time
66 private final List<String> glSemHeaders = new ArrayList<String>();
67 private final Set<String> ignoredExtensions = new HashSet<String>();
68 private final Set<String> forcedExtensions = new HashSet<String>();
69 private final Set<String> renameExtensionsIntoCore = new HashSet<String>();
70 private BuildStaticGLInfo glSemInfo;
71
72 // GLDocHeaders include GLSemHeaders!
73 boolean dropDocInfo = false;
74 private final List<String> glDocHeaders = new ArrayList<String>();
75 // GLDocInfo include GLSemInfo!
76 private BuildStaticGLInfo glDocInfo;
77 private final Map<String, String> javaDocSymbolRenames = new HashMap<String, String>();
78 private final Map<String, Set<String>> javaDocRenamedSymbols = new HashMap<String, Set<String>>();
79
80 // Maps function names to the kind of buffer object it deals with
81 private final Map<String, GLEmitter.BufferObjectKind> bufferObjectKinds = new HashMap<String, GLEmitter.BufferObjectKind>();
82 private final Set<String> bufferObjectOnly = new HashSet<String>();
83 private final GLEmitter emitter;
84 private final Set<String> dropUniqVendorExtensions = new HashSet<String>();
85
86 // This directive is off by default but can help automatically
87 // indicate which extensions have been folded into the core OpenGL
88 // namespace, and if not, then why not
89 private boolean autoUnifyExtensions = false;
90 private boolean allowNonGLExtensions = false;
91
92 public GLConfiguration(final GLEmitter emitter) {
93 super();
94 this.emitter = emitter;
95 try {
96 setProcAddressNameExpr("PFN $UPPERCASE({0}) PROC");
97 } catch (final NoSuchElementException e) {
98 throw new RuntimeException("Error configuring ProcAddressNameExpr", e);
99 }
100 }
101
102 @Override
103 protected void dispatch(final String cmd, final StringTokenizer tok, final File file, final String filename, final int lineNo) throws IOException {
104 if (cmd.equalsIgnoreCase("IgnoreExtension")) {
105 final String sym = readString("IgnoreExtension", tok, filename, lineNo);
106 ignoredExtensions.add(sym);
107 } else if (cmd.equalsIgnoreCase("ForceExtension")) {
108 final String sym = readString("ForceExtension", tok, filename, lineNo);
109 forcedExtensions.add(sym);
110 } else if (cmd.equalsIgnoreCase("RenameExtensionIntoCore")) {
111 final String sym = readString("RenameExtensionIntoCore", tok, filename, lineNo);
112 renameExtensionsIntoCore.add(sym);
113 } else if (cmd.equalsIgnoreCase("AllowNonGLExtensions")) {
114 allowNonGLExtensions = readBoolean("AllowNonGLExtensions", tok, filename, lineNo).booleanValue();
115 } else if (cmd.equalsIgnoreCase("AutoUnifyExtensions")) {
116 autoUnifyExtensions = readBoolean("AutoUnifyExtensions", tok, filename, lineNo).booleanValue();
117 } else if (cmd.equalsIgnoreCase("GLSemHeader")) {
118 final String sym = readString("GLSemHeader", tok, filename, lineNo);
119 if( !glSemHeaders.contains(sym) ) {
120 glSemHeaders.add(sym);
121 }
122 if( !dropDocInfo && !glDocHeaders.contains(sym) ) {
123 glDocHeaders.add(sym);
124 }
125 } else if (cmd.equalsIgnoreCase("GLDocHeader")) {
126 final String sym = readString("GLDocHeader", tok, filename, lineNo);
127 if( !dropDocInfo && !glDocHeaders.contains(sym) ) {
128 glDocHeaders.add(sym);
129 }
130 } else if (cmd.equalsIgnoreCase("DropAllGLDocHeader")) {
131 dropDocInfo = readBoolean("DropAllGLDocHeader", tok, filename, lineNo).booleanValue();
132 } else if (cmd.equalsIgnoreCase("BufferObjectKind")) {
133 readBufferObjectKind(tok, filename, lineNo);
134 } else if (cmd.equalsIgnoreCase("BufferObjectOnly")) {
135 final String sym = readString("BufferObjectOnly", tok, filename, lineNo);
136 bufferObjectOnly.add(sym);
137 } else if (cmd.equalsIgnoreCase("DropUniqVendorExtensions")) {
138 final String sym = readString("DropUniqVendorExtensions", tok, filename, lineNo);
139 dropUniqVendorExtensions.add(sym);
140 } else {
141 super.dispatch(cmd, tok, file, filename, lineNo);
142 }
143 }
144
145 protected void readBufferObjectKind(final StringTokenizer tok, final String filename, final int lineNo) {
146 try {
147 final String kindString = tok.nextToken();
148 GLEmitter.BufferObjectKind kind = null;
149 final String target = tok.nextToken();
150 if (kindString.equalsIgnoreCase("UnpackPixel")) {
151 kind = GLEmitter.BufferObjectKind.UNPACK_PIXEL;
152 } else if (kindString.equalsIgnoreCase("PackPixel")) {
153 kind = GLEmitter.BufferObjectKind.PACK_PIXEL;
154 } else if (kindString.equalsIgnoreCase("Array")) {
155 kind = GLEmitter.BufferObjectKind.ARRAY;
156 } else if (kindString.equalsIgnoreCase("Element")) {
157 kind = GLEmitter.BufferObjectKind.ELEMENT;
158 } else if (kindString.equalsIgnoreCase("Indirect")) {
159 kind = GLEmitter.BufferObjectKind.INDIRECT;
160 } else {
161 throw new RuntimeException("Error parsing \"BufferObjectKind\" command at line " + lineNo
162 + " in file \"" + filename + "\": illegal BufferObjectKind \""
163 + kindString + "\", expected one of UnpackPixel, PackPixel, Array, Element or Indirect");
164 }
165
166 bufferObjectKinds.put(target, kind);
167 } catch (final NoSuchElementException e) {
168 throw new RuntimeException("Error parsing \"BufferObjectKind\" command at line " + lineNo
169 + " in file \"" + filename + "\"", e);
170 }
171 }
172
173 /** Overrides javaPrologueForMethod in superclass and
174 automatically generates prologue code for functions associated
175 with buffer objects. */
176 @Override
177 public List<String> javaPrologueForMethod(final MethodBinding binding, final boolean forImplementingMethodCall, final boolean eraseBufferAndArrayTypes) {
178
179 List<String> res = super.javaPrologueForMethod(binding, forImplementingMethodCall, eraseBufferAndArrayTypes);
180 final GLEmitter.BufferObjectKind kind = getBufferObjectKind(binding.getCSymbol());
181 if (kind != null) {
182 // Need to generate appropriate prologue based on both buffer
183 // object kind and whether this variant of the MethodBinding
184 // is the one accepting a "long" as argument
185 //
186 // NOTE we MUST NOT mutate the array returned from the super
187 // call!
188 final ArrayList<String> res2 = new ArrayList<String>();
189 if (res != null) {
190 res2.addAll(res);
191 }
192 res = res2;
193
194 String prologue = "check";
195
196 if (kind == GLEmitter.BufferObjectKind.UNPACK_PIXEL) {
197 prologue = prologue + "UnpackPBO";
198 } else if (kind == GLEmitter.BufferObjectKind.PACK_PIXEL) {
199 prologue = prologue + "PackPBO";
200 } else if (kind == GLEmitter.BufferObjectKind.ARRAY) {
201 prologue = prologue + "ArrayVBO";
202 } else if (kind == GLEmitter.BufferObjectKind.ELEMENT) {
203 prologue = prologue + "ElementVBO";
204 } else if (kind == GLEmitter.BufferObjectKind.INDIRECT) {
205 prologue = prologue + "IndirectVBO";
206 } else {
207 throw new RuntimeException("Unknown BufferObjectKind " + kind);
208 }
209
210 if (emitter.isBufferObjectMethodBinding(binding)) {
211 prologue = prologue + "Bound";
212 } else {
213 prologue = prologue + "Unbound";
214 }
215
216 prologue = prologue + "(true);";
217
218 res.add(0, prologue);
219
220 // Must also filter out bogus rangeCheck directives for VBO/PBO
221 // variants
222 if (emitter.isBufferObjectMethodBinding(binding)) {
223 for (final Iterator<String> iter = res.iterator(); iter.hasNext();) {
224 final String line = iter.next();
225 if (line.indexOf("Buffers.rangeCheck") >= 0) {
226 iter.remove();
227 }
228 }
229 }
230 }
231
232 return res;
233 }
234
235 @Override
236 public void logIgnores() {
237 LOG.log(INFO, "GL Ignored extensions: {0}", ignoredExtensions.size());
238 for (final String str : ignoredExtensions) {
239 LOG.log(INFO, "\t{0}", str);
240 }
241 LOG.log(INFO, "GL Forced extensions: {0}", forcedExtensions.size());
242 for (final String str : forcedExtensions) {
243 LOG.log(INFO, "\t{0}", str);
244 }
245 super.logIgnores();
246 }
247
248 @Override
249 public void logRenames() {
250 LOG.log(INFO, "GL Renamed extensions into core: {0}", renameExtensionsIntoCore.size());
251 for (final String str : renameExtensionsIntoCore) {
252 LOG.log(INFO, "\t{0}", str);
253 }
254 super.logRenames();
255 }
256
257 protected boolean isIgnoredExtension(final String extensionName) {
258 if( ignoredExtensions.contains(extensionName) ) {
259 return !forcedExtensions.contains(extensionName);
260 } else {
261 return false;
262 }
263 }
264
265 protected boolean shouldIgnoreExtension(final AliasedSymbol symbol) {
266 final Set<String> symExtensionNames;
267 // collect current-name symbol extensions
268 {
269 final Set<String> s = glSemInfo.getExtension(symbol.getName());
270 if( null != s ) {
271 symExtensionNames = s;
272 } else {
273 symExtensionNames = new HashSet<String>();
274 }
275 }
276 // collect renamed symbol extensions
277 if( symbol.hasAliases() ) {
278 final Set<String> aliases = symbol.getAliasedNames();
279 for(final String alias : aliases) {
280 final Set<String> s = glSemInfo.getExtension(alias);
281 if( null != s && s.size() > 0 ) {
282 symExtensionNames.addAll(s);
283 }
284 }
285 }
286 boolean ignoreExtension = symExtensionNames.size() > 0 &&
287 ignoredExtensions.containsAll(symExtensionNames);
288
289 if( LOG.isLoggable(INFO) ) {
290 final Set<String> ignoredSymExtensionNames = new HashSet<String>();
291 final Set<String> notIgnoredSymExtensionNames = new HashSet<String>();
292 for(final Iterator<String> i=symExtensionNames.iterator(); i.hasNext(); ) {
293 final String extensionName = i.next();
294 if ( null != extensionName && ignoredExtensions.contains(extensionName) ) {
295 ignoredSymExtensionNames.add(extensionName);
296 } else {
297 notIgnoredSymExtensionNames.add(extensionName);
298 }
299 }
300 if( ignoreExtension ) {
301 LOG.log(INFO, getASTLocusTag(symbol), "Ignored symbol {0} of all extensions <{1}>", symbol, symExtensionNames);
302 } else if( ignoredSymExtensionNames.size() > 0 ) {
303 LOG.log(INFO, getASTLocusTag(symbol), "Not ignored symbol {0}; Ignored in <{1}>, but active in <{2}>",
304 symbol, ignoredSymExtensionNames, notIgnoredSymExtensionNames);
305 }
306 }
307 if( !ignoreExtension ) {
308 // Check whether the current-name denotes an ignored vendor extension
309 final String name = symbol.getName();
310 final boolean isGLEnum = GLNameResolver.isGLEnumeration(name);
311 final boolean isGLFunc = GLNameResolver.isGLFunction(name);
312 String extSuffix = null;
313 if (isGLFunc || isGLEnum) {
314 if (GLNameResolver.isExtensionVEN(name, isGLFunc)) {
315 extSuffix = GLNameResolver.getExtensionSuffix(name, isGLFunc);
316 if (getDropUniqVendorExtensions(extSuffix)) {
317 LOG.log(INFO, getASTLocusTag(symbol), "Ignore UniqVendorEXT: {0}, vendor {1}, isGLFunc {2}, isGLEnum {3}",
318 symbol, extSuffix, isGLFunc, isGLEnum);
319 ignoreExtension = true;
320 }
321 }
322 }
323 if (!ignoreExtension) {
324 LOG.log(INFO, getASTLocusTag(symbol), "Not ignored UniqVendorEXT: {0}, vendor {1}, isGLFunc {2}, isGLEnum {3}",
325 symbol, extSuffix, isGLFunc, isGLEnum);
326 }
327 }
328 if( ignoreExtension ) {
329 ignoreExtension = !shouldForceExtension( symbol, symExtensionNames);
330 }
331 return ignoreExtension;
332 }
333 public boolean shouldForceExtension(final AliasedSymbol symbol, final Set<String> symExtensionNames) {
334 for(final Iterator<String> i=symExtensionNames.iterator(); i.hasNext(); ) {
335 final String extensionName = i.next();
336 if ( extensionName != null && forcedExtensions.contains(extensionName) ) {
337 LOG.log(INFO, getASTLocusTag(symbol), "Not ignored symbol {0} of extension <{1}>", symbol, extensionName);
338 return true;
339 }
340 }
341 return false;
342 }
343
344 /**
345 * {@inheritDoc}
346 * <p>
347 * Implementation extends the exclusion query w/ {@link #shouldIgnoreExtension(AliasedSymbol) the list of ignored extensions}.
348 * </p>
349 * <p>
350 * If passing the former, it calls down to {@link #shouldIgnoreInInterface_Int(AliasedSymbol)}.
351 * </p>
352 */
353 @Override
354 public boolean shouldIgnoreInInterface(final AliasedSymbol symbol) {
355 return shouldIgnoreExtension(symbol) || shouldIgnoreInInterface_Int(symbol);
356 }
357
358 /**
359 * {@inheritDoc}
360 * <p>
361 * Implementation extends the exclusion query w/ {@link #shouldIgnoreExtension(AliasedSymbol) the list of ignored extensions}.
362 * </p>
363 * <p>
364 * If passing the former, it calls down to {@link #shouldIgnoreInImpl_Int(AliasedSymbol)}.
365 * </p>
366 */
367 @Override
368 public boolean shouldIgnoreInImpl(final AliasedSymbol symbol) {
369 return shouldIgnoreExtension(symbol) || shouldIgnoreInImpl_Int(symbol);
370 }
371
372 /** Should we automatically ignore extensions that have already been
373 fully subsumed into the OpenGL core namespace, and if they have
374 not been, indicate which definition is not already in the core? */
375 public boolean getAutoUnifyExtensions() {
376 return autoUnifyExtensions;
377 }
378
379 /** If true, accept all non encapsulated defines and functions,
380 * as it is mandatory for GL declarations. */
381 public boolean getAllowNonGLExtensions() {
382 return allowNonGLExtensions;
383 }
384
385 /** shall the non unified (uniq) vendor extensions be dropped ? */
386 public boolean getDropUniqVendorExtensions(final String extName) {
387 return dropUniqVendorExtensions.contains(extName);
388 }
389
390 /** Returns the kind of buffer object this function deals with, or
391 null if none. */
392 GLEmitter.BufferObjectKind getBufferObjectKind(final AliasedSymbol symbol) {
393 final String name = symbol.getName();
394 final Set<String> aliases = symbol.getAliasedNames();
395 GLEmitter.BufferObjectKind res = bufferObjectKinds.get( name );
396 if( null == res ) {
397 res = oneInMap(bufferObjectKinds, aliases);
398 }
399 return res;
400 }
401
402 public boolean isBufferObjectFunction(final AliasedSymbol symbol) {
403 return null != getBufferObjectKind(symbol);
404 }
405
406 public boolean isBufferObjectOnly(final String name) {
407 return bufferObjectOnly.contains(name);
408 }
409
410 /**
411 * Parses any GL headers specified in the configuration file for
412 * the purpose of being able to ignore an extension at a time.
413 * <p>
414 * Targeting semantic information, i.e. influences code generation.
415 * </p>
416 */
417 public void parseGLSemHeaders(final GlueEmitterControls controls) throws IOException {
418 glSemInfo = new BuildStaticGLInfo();
419 glSemInfo.setDebug(GlueGen.debug());
420 if (!glSemHeaders.isEmpty()) {
421 for (final String file : glSemHeaders) {
422 final String fullPath = controls.findHeaderFile(file);
423 if (fullPath == null) {
424 throw new IOException("Unable to locate header file \"" + file + "\"");
425 }
426 glSemInfo.parse(fullPath);
427 }
428 }
429 }
430
431 /**
432 * Returns the information about the association between #defines,
433 * function symbols and the OpenGL extensions they are defined in.
434 * <p>
435 * This instance targets semantic information, i.e. influences code generation.
436 * </p>
437 */
439 return glSemInfo;
440 }
441
442 /**
443 * Parses any GL headers specified in the configuration file for
444 * the purpose of being able to ignore an extension at a time.
445 * <p>
446 * Targeting API documentation information, i.e. <i>not</i> influencing code generation.
447 * </p>
448 */
449 public void parseGLDocHeaders(final GlueEmitterControls controls) throws IOException {
450 glDocInfo = new BuildStaticGLInfo();
451 glDocInfo.setDebug(GlueGen.debug());
452 if (!glDocHeaders.isEmpty()) {
453 for (final String file : glDocHeaders) {
454 final String fullPath = controls.findHeaderFile(file);
455 if (fullPath == null) {
456 throw new IOException("Unable to locate header file \"" + file + "\"");
457 }
458 glDocInfo.parse(fullPath);
459 }
460 }
461 }
462
463 @Override
464 public Set<String> getAliasedDocNames(final AliasedSymbol symbol) {
465 return getRenamedJavaDocSymbols(symbol.getName());
466 }
467
468 /**
469 * Returns the information about the association between #defines,
470 * function symbols and the OpenGL extensions they are defined in.
471 * <p>
472 * This instance targets API documentation information, i.e. <i>not</i> influencing code generation.
473 * </p>
474 * <p>
475 * GLDocInfo include GLSemInfo!
476 * </p>
477 */
479 return glDocInfo;
480 }
481
482 /** Returns a set of replaced javadoc names to the given <code>aliasedName</code>. */
483 public Set<String> getRenamedJavaDocSymbols(final String aliasedName) {
484 return javaDocRenamedSymbols.get(aliasedName);
485 }
486
487 /**
488 * {@inheritDoc}
489 * <p>
490 * Also adds a javadoc rename directive for the given symbol.
491 * </p>
492 */
493 @Override
494 public void addJavaSymbolRename(final String origName, final String newName) {
495 super.addJavaSymbolRename(origName, newName);
496 if( !dropDocInfo ) {
497 addJavaDocSymbolRename(origName, newName);
498 }
499 }
500
501 /**
502 * Adds a javadoc rename directive for the given symbol.
503 */
504 public void addJavaDocSymbolRename(final String origName, final String newName) {
505 LOG.log(INFO, "\tDoc Rename {0} -> {1}", origName, newName);
506 final String prevValue = javaDocSymbolRenames.put(origName, newName);
507 if(null != prevValue && !prevValue.equals(newName)) {
508 throw new RuntimeException("Doc-Rename-Override Attampt: "+origName+" -> "+newName+
509 ", but "+origName+" -> "+prevValue+" already exist. Run in 'debug' mode to analyze!");
510 }
511
512 Set<String> origNames = javaDocRenamedSymbols.get(newName);
513 if(null == origNames) {
514 origNames = new HashSet<String>();
515 javaDocRenamedSymbols.put(newName, origNames);
516 }
517 origNames.add(origName);
518 }
519
520 /** Returns the OpenGL extensions that should have all of their
521 constant definitions and functions renamed into the core
522 namespace; for example, glGenFramebuffersEXT to
523 glGenFramebuffers and GL_FRAMEBUFFER_EXT to GL_FRAMEBUFFER. */
524 public Set<String> getExtensionsRenamedIntoCore() {
525 return renameExtensionsIntoCore;
526 }
527}
Builds the StaticGLInfo class from the OpenGL header files (i.e., gl.h and glext.h) whose paths were ...
void parse(final String[] cHeaderFilePaths)
Parses the supplied C header files and adds the function associations contained therein to the intern...
Set< String > getExtension(final String identifier)
void parseGLDocHeaders(final GlueEmitterControls controls)
Parses any GL headers specified in the configuration file for the purpose of being able to ignore an ...
List< String > javaPrologueForMethod(final MethodBinding binding, final boolean forImplementingMethodCall, final boolean eraseBufferAndArrayTypes)
Overrides javaPrologueForMethod in superclass and automatically generates prologue code for functions...
BuildStaticGLInfo getGLDocInfo()
Returns the information about the association between #defines, function symbols and the OpenGL exten...
boolean isIgnoredExtension(final String extensionName)
boolean shouldIgnoreInImpl(final AliasedSymbol symbol)
void readBufferObjectKind(final StringTokenizer tok, final String filename, final int lineNo)
boolean shouldForceExtension(final AliasedSymbol symbol, final Set< String > symExtensionNames)
void parseGLSemHeaders(final GlueEmitterControls controls)
Parses any GL headers specified in the configuration file for the purpose of being able to ignore an ...
Set< String > getAliasedDocNames(final AliasedSymbol symbol)
void dispatch(final String cmd, final StringTokenizer tok, final File file, final String filename, final int lineNo)
Set< String > getRenamedJavaDocSymbols(final String aliasedName)
Returns a set of replaced javadoc names to the given aliasedName.
boolean getAutoUnifyExtensions()
Should we automatically ignore extensions that have already been fully subsumed into the OpenGL core ...
boolean isBufferObjectFunction(final AliasedSymbol symbol)
boolean isBufferObjectOnly(final String name)
void addJavaSymbolRename(final String origName, final String newName)
boolean shouldIgnoreExtension(final AliasedSymbol symbol)
boolean shouldIgnoreInInterface(final AliasedSymbol symbol)
void addJavaDocSymbolRename(final String origName, final String newName)
Adds a javadoc rename directive for the given symbol.
boolean getDropUniqVendorExtensions(final String extName)
shall the non unified (uniq) vendor extensions be dropped ?
Set< String > getExtensionsRenamedIntoCore()
Returns the OpenGL extensions that should have all of their constant definitions and functions rename...
boolean getAllowNonGLExtensions()
If true, accept all non encapsulated defines and functions, as it is mandatory for GL declarations.
BuildStaticGLInfo getGLSemInfo()
Returns the information about the association between #defines, function symbols and the OpenGL exten...
A subclass of ProcAddressEmitter with special OpenGL-specific configuration abilities.
Definition: GLEmitter.java:74
boolean isBufferObjectMethodBinding(final MethodBinding binding)
Definition: GLEmitter.java:376
Runtime utility identify and resolve extension names, which may be subsumed to core.
static final boolean isExtensionVEN(final String str, final boolean isGLFunc)
static final String getExtensionSuffix(final String str, final boolean isGLFunc)
static final boolean isGLFunction(final String str)
static final boolean isGLEnumeration(final String str)