From 6b9841f75655fabd491f7410643272d36eddc77e Mon Sep 17 00:00:00 2001 From: Travis Bryson Date: Tue, 23 Aug 2005 00:34:32 +0000 Subject: This putback may break Windows/Mac build temporarily for a few hours until we synchronize with builds on all of our target platforms as we are rushing this a bit so that we can properly reorganize the workspace shortly, and with such fundamental changes, this is considered a "risky" putback. So advising to hold off on bringover a few hours for non-X11 targets. This is the majority of changes required for Native I/O IndirectBuffer support for JSR 231. The changes are not yet complete, and Indirect Buffers (buffers backed by an array) should not yet be used (although what is being putback here has been tested and is working). IndirectBuffer support is being added in JSR 231 since this will be the method often used to send down arrays to the public API, by "wrapping" them, enabling us to eliminate many of the API "explosions" that happen in the older, JOGL approach, enabling the number of public APIs in JSR 231 to be greatly reduced, and map more cleanly to native OpenGL. Soon we will be removing the old API explosions and Indirect Buffers will be the only way to send down an array to many APIs, but at this point there are no public API changes putback for this. We will be providing code samples. The changes to any program source code are *very* straightforward. Offsets into Native I/O buffers and offsets within the arrays that back them are also supported. We will also provide code examples for this. So, for example, you do not need to rewrap an array when you want to send down its elements but starting at somewhere besides the zeroth index. This putback adds the support for all methods not accessed internally by function pointers (dispatch methods in the expanded code). The support for function pointers (mostly APIs that were later additions to OpenGL, mostly things that are or originally were extensions) will come in a subsequent putback. The native code for the dispatch methods is mostly generated, however (just never called currently). The Java part for dispatch methods is not complete yet, and is not yet generated. git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/svn-server-sync/jogl/branches/JSR-231@352 232f8b59-042b-4e1e-8c03-345bb8c30851 --- .../java/games/gluegen/CMethodBindingEmitter.java | 64 ++++++- .../games/gluegen/CMethodBindingImplEmitter.java | 9 +- src/net/java/games/gluegen/JavaEmitter.java | 45 ++++- .../games/gluegen/JavaMethodBindingEmitter.java | 32 +++- .../gluegen/JavaMethodBindingImplEmitter.java | 193 +++++++++++++++++++-- .../games/gluegen/opengl/CGLPAWrapperEmitter.java | 6 +- .../gluegen/opengl/JavaGLPAWrapperEmitter.java | 4 +- .../java/games/gluegen/runtime/BufferFactory.java | 4 +- 8 files changed, 314 insertions(+), 43 deletions(-) diff --git a/src/net/java/games/gluegen/CMethodBindingEmitter.java b/src/net/java/games/gluegen/CMethodBindingEmitter.java index 5cf2833d9..2616f151b 100644 --- a/src/net/java/games/gluegen/CMethodBindingEmitter.java +++ b/src/net/java/games/gluegen/CMethodBindingEmitter.java @@ -57,6 +57,8 @@ public class CMethodBindingEmitter extends FunctionEmitter protected MethodBinding binding; + protected boolean indirectBufferInterface = false; + /** Name of the package in which the corresponding Java method resides.*/ private String packageName; @@ -137,6 +139,17 @@ public class CMethodBindingEmitter extends FunctionEmitter public final MethodBinding getBinding() { return binding; } + + public boolean isIndirectBufferInterface() { + return indirectBufferInterface; + } + + + public void setIndirectBufferInterface(boolean indirect) { + indirectBufferInterface = indirect; + } + + public String getName() { return binding.getName(); } @@ -343,8 +356,10 @@ public class CMethodBindingEmitter extends FunctionEmitter writer.print(" "); writer.print(binding.getArgumentName(i)); ++numEmitted; - // Add Buffer offset argument immediately after any Buffer arguments - if(javaArgType.isNIOBuffer() || javaArgType.isNIOBufferArray()) { + + // Replace following for indirect buffer case + // if(javaArgType.isNIOBuffer() || javaArgType.isNIOBufferArray()) { + if((javaArgType.isNIOBuffer() && !isIndirectBufferInterface()) || javaArgType.isNIOBufferArray()) { if(!javaArgType.isArray()) { numBufferOffsetArgs++; writer.print(", jint " + byteOffsetConversionArgName(numBufferOffsetArgs)); @@ -355,6 +370,10 @@ public class CMethodBindingEmitter extends FunctionEmitter } } + // indirect buffer case needs same offset syntax as arrays + if(javaArgType.isNIOBuffer() && isIndirectBufferInterface()) + writer.print(", jint " + binding.getArgumentName(i) + "_offset"); + // Add array primitive index/offset parameter if(javaArgType.isArray() && !javaArgType.isNIOBufferArray() && !javaArgType.isStringArray()) { writer.print(", jint " + binding.getArgumentName(i) + "_offset"); @@ -499,7 +518,8 @@ public class CMethodBindingEmitter extends FunctionEmitter // Convert all Buffers to pointers first so we don't have to // call ReleasePrimitiveArrayCritical for any arrays if any // incoming buffers aren't direct - if (binding.hasContainingType()) { + // we don't want to fall in here for indirectBuffer case, since its an array + if (binding.hasContainingType() && !isIndirectBufferInterface()) { byteOffsetCounter++; emitPointerConversion(writer, binding, binding.getContainingType(), @@ -514,7 +534,8 @@ public class CMethodBindingEmitter extends FunctionEmitter if (type.isJNIEnv() || binding.isArgumentThisPointer(i)) { continue; } - if (type.isNIOBuffer()) { + + if (type.isNIOBuffer() && !isIndirectBufferInterface()) { byteOffsetCounter++; emitPointerConversion(writer, binding, type, binding.getCArgumentType(i), @@ -533,6 +554,12 @@ public class CMethodBindingEmitter extends FunctionEmitter continue; } + // create array replacement type for Buffer for indirect Buffer case + if(isIndirectBufferInterface() && javaArgType.isNIOBuffer()) { + float[] c = new float[1]; + javaArgType = JavaType.createForClass(c.getClass()); + } + if (javaArgType.isArray()) { boolean needsDataCopy = javaArgTypeNeedsDataCopy(javaArgType); Class subArrayElementJavaType = javaArgType.getJavaClass().getComponentType(); @@ -755,6 +782,14 @@ public class CMethodBindingEmitter extends FunctionEmitter if (javaArgType.isJNIEnv() || binding.isArgumentThisPointer(i)) { continue; } + + + // create array type for Indirect Buffer case + if(isIndirectBufferInterface() && javaArgType.isNIOBuffer()) { + float[] c = new float[1]; + javaArgType = JavaType.createForClass(c.getClass()); + } + if (javaArgType.isArray()) { boolean needsDataCopy = javaArgTypeNeedsDataCopy(javaArgType); Class subArrayElementJavaType = javaArgType.getJavaClass().getComponentType(); @@ -936,7 +971,10 @@ public class CMethodBindingEmitter extends FunctionEmitter // For mapping from byte primitive array type to type* case produces code: // (GLtype*)((char*)_ptr0 + varName_offset) // where varName_offset is the number of bytes offset as calculated in Java code - if(javaArgType.isArray() && !javaArgType.isNIOBufferArray() && !javaArgType.isStringArray()) { + // also, output same for indirect buffer as for array + if(javaArgType.isNIOBuffer() && isIndirectBufferInterface()) + writer.print("( (char*)"); + else if(javaArgType.isArray() && !javaArgType.isNIOBufferArray() && !javaArgType.isStringArray()) { writer.print("( (char*)"); } /* End of this section of new code for array offsets */ @@ -947,7 +985,9 @@ public class CMethodBindingEmitter extends FunctionEmitter } /* Continuation of special code for accounting for array offsets */ - if(javaArgType.isArray() && !javaArgType.isNIOBufferArray() && !javaArgType.isStringArray()) { + if(javaArgType.isNIOBuffer() && isIndirectBufferInterface()) + writer.print(" + " + binding.getArgumentName(i) + "_offset)"); + else if(javaArgType.isArray() && !javaArgType.isNIOBufferArray() && !javaArgType.isStringArray()) { writer.print(" + " + binding.getArgumentName(i) + "_offset)"); } /* End of this section of new code for array offsets */ @@ -1148,9 +1188,15 @@ public class CMethodBindingEmitter extends FunctionEmitter else if (c == Double.TYPE) res.append("D"); else throw new InternalError("Illegal primitive type"); } else { - res.append("L"); - res.append(c.getName().replace('.', '_')); - res.append("_2"); + if(!isIndirectBufferInterface()) { + res.append("L"); + res.append(c.getName().replace('.', '_')); + res.append("_2"); + } else { // indirect buffer sends array as object + res.append("L"); + res.append("java_lang_Object"); + res.append("_2"); + } } } diff --git a/src/net/java/games/gluegen/CMethodBindingImplEmitter.java b/src/net/java/games/gluegen/CMethodBindingImplEmitter.java index 2052bcf98..3f3505896 100644 --- a/src/net/java/games/gluegen/CMethodBindingImplEmitter.java +++ b/src/net/java/games/gluegen/CMethodBindingImplEmitter.java @@ -69,7 +69,9 @@ public class CMethodBindingImplEmitter extends CMethodBindingEmitter { super.emitName(writer); if (!getIsOverloadedBinding()) { - if(!arrayImplRoutine) + if( isIndirectBufferInterface() ) + writer.print("2"); + else if(!arrayImplRoutine) writer.print("0"); else writer.print("1"); @@ -84,7 +86,9 @@ public class CMethodBindingImplEmitter extends CMethodBindingEmitter StringBuffer buf = new StringBuffer(); buf.append(jniMangle(binding.getName())); - if(!arrayImplRoutine) + if( isIndirectBufferInterface() ) + buf.append("2"); + else if(!arrayImplRoutine) buf.append("0"); else buf.append("1"); @@ -92,6 +96,7 @@ public class CMethodBindingImplEmitter extends CMethodBindingEmitter buf.append("__"); for (int i = 0; i < binding.getNumArguments(); i++) { JavaType type = binding.getJavaArgumentType(i); + Class c = type.getJavaClass(); if (c != null) { jniMangle(c, buf); diff --git a/src/net/java/games/gluegen/JavaEmitter.java b/src/net/java/games/gluegen/JavaEmitter.java index 1203bd1fb..dad954db2 100644 --- a/src/net/java/games/gluegen/JavaEmitter.java +++ b/src/net/java/games/gluegen/JavaEmitter.java @@ -351,7 +351,8 @@ public class JavaEmitter implements GlueEmitter { // the binding like any normal binding because no special binding // generation (wrapper methods, etc) will be necessary. MethodBinding specialBinding = binding.createNIOBufferVariant(); - + + if (cfg.allStatic() && binding.hasContainingType()) { // This should not currently happen since structs are emitted using a different mechanism throw new IllegalArgumentException("Cannot create binding in AllStatic mode because method has containing type: \"" + @@ -359,7 +360,8 @@ public class JavaEmitter implements GlueEmitter { } boolean isUnimplemented = cfg.isUnimplemented(binding.getName()); - + JavaMethodBindingImplEmitter entryPoint=null; + if (cfg.emitImpl()) { // Generate the emitter for the method which may do conversion // from type wrappers to NIO Buffers or which may call the @@ -371,8 +373,7 @@ public class JavaEmitter implements GlueEmitter { arrayImplMethod = true; } - JavaMethodBindingImplEmitter entryPoint = - new JavaMethodBindingImplEmitter(binding, + entryPoint = new JavaMethodBindingImplEmitter(binding, (cfg.allStatic() ? javaWriter() : javaImplWriter()), cfg.runtimeExceptionType(), isUnimplemented, @@ -419,8 +420,24 @@ public class JavaEmitter implements GlueEmitter { wrappedEntryPoint.addModifier(JavaMethodBindingEmitter.STATIC); // Doesn't really matter wrappedEntryPoint.addModifier(JavaMethodBindingEmitter.NATIVE); allEmitters.add(wrappedEntryPoint); + + String bindingName = specialBinding.getName(); + if(binding != specialBinding && bindingName.contains("gl") && !bindingName.contains("glX") + && !bindingName.contains("wgl") && !bindingName.contains("CGL")) { + JavaMethodBindingEmitter wrappedEntryPoint2 = + new JavaMethodBindingEmitter(specialBinding, output, cfg.runtimeExceptionType(), + true, arrayImplMethod); + wrappedEntryPoint2.addModifier(JavaMethodBindingEmitter.PRIVATE); + wrappedEntryPoint2.addModifier(JavaMethodBindingEmitter.STATIC); // Doesn't really matter + wrappedEntryPoint2.addModifier(JavaMethodBindingEmitter.NATIVE); + + entryPoint.setGenerateIndirectBufferInterface(true); + wrappedEntryPoint2.setIndirectBufferInterface(true); + allEmitters.add(wrappedEntryPoint2); + } + } - + CMethodBindingEmitter cEmitter = makeCEmitter(specialBinding, overloaded, @@ -429,6 +446,23 @@ public class JavaEmitter implements GlueEmitter { cfg.implPackageName(), cfg.implClassName(), cWriter()); allEmitters.add(cEmitter); + + String bindingName = specialBinding.getName(); + if(binding != specialBinding && bindingName.contains("gl") && !bindingName.contains("glX") + && !bindingName.contains("wgl") && !bindingName.contains("CGL") ) { + + CMethodBindingEmitter cEmitter2 = + makeCEmitter(specialBinding, + //overloaded, + true, + true, + arrayImplMethod, + cfg.implPackageName(), cfg.implClassName(), + cWriter()); + cEmitter2.setIndirectBufferInterface(true); + allEmitters.add(cEmitter2); + } + } } } // end iteration over expanded bindings @@ -1351,6 +1385,7 @@ public class JavaEmitter implements GlueEmitter { } } + // NIO variants for non-void* C primitive pointer types if ((cfg.nioMode() == JavaConfiguration.NIO_MODE_ALL_POINTERS && !cfg.noNio(mb.getCSymbol().getName())) || diff --git a/src/net/java/games/gluegen/JavaMethodBindingEmitter.java b/src/net/java/games/gluegen/JavaMethodBindingEmitter.java index 993133d48..1d227dfc9 100644 --- a/src/net/java/games/gluegen/JavaMethodBindingEmitter.java +++ b/src/net/java/games/gluegen/JavaMethodBindingEmitter.java @@ -71,6 +71,8 @@ public class JavaMethodBindingEmitter extends FunctionEmitter protected boolean prefixedMethod = false; + protected boolean indirectBufferInterface = false; + // A non-null value indicates that rather than returning a compound // type accessor we are returning an array of such accessors; this // expression is a MessageFormat string taking the names of the @@ -109,6 +111,15 @@ public class JavaMethodBindingEmitter extends FunctionEmitter return binding.getName(); } + public boolean isIndirectBufferInterface() { + return indirectBufferInterface; + } + + + public void setIndirectBufferInterface(boolean indirect) { + indirectBufferInterface = indirect; + } + /** The type of exception (must subclass java.lang.RuntimeException) raised if runtime @@ -134,7 +145,8 @@ public class JavaMethodBindingEmitter extends FunctionEmitter } protected String getReturnTypeString(boolean skipArray) { - if (skipArray || (getReturnedArrayLengthExpression() == null && !binding.getJavaReturnType().isArrayOfCompoundTypeWrappers())) { + if (skipArray || (getReturnedArrayLengthExpression() == null && + !binding.getJavaReturnType().isArrayOfCompoundTypeWrappers())) { return binding.getJavaReturnType().getName(); } return binding.getJavaReturnType().getName() + "[]"; @@ -186,10 +198,18 @@ public class JavaMethodBindingEmitter extends FunctionEmitter if (needComma) { writer.print(", "); } - + + // indirect buffer array sent down as object + if(isIndirectBufferInterface() && type.isNIOBuffer() ) { + writer.print(" Object "); + } else { writer.print(type.getName()); + } + writer.print(" "); writer.print(binding.getArgumentName(i)); + + ++numEmitted; needComma = true; @@ -218,10 +238,12 @@ public class JavaMethodBindingEmitter extends FunctionEmitter protected String getImplMethodName() { - if(!forArrayImplementingMethodCall) - return binding.getName() + "0"; + if( isIndirectBufferInterface() ) + return binding.getName() + "2"; + else if(!forArrayImplementingMethodCall) + return binding.getName() + "0"; else - return binding.getName() + "1"; + return binding.getName() + "1"; } diff --git a/src/net/java/games/gluegen/JavaMethodBindingImplEmitter.java b/src/net/java/games/gluegen/JavaMethodBindingImplEmitter.java index 922f60794..3cbc8081d 100644 --- a/src/net/java/games/gluegen/JavaMethodBindingImplEmitter.java +++ b/src/net/java/games/gluegen/JavaMethodBindingImplEmitter.java @@ -85,8 +85,8 @@ public class JavaMethodBindingImplEmitter extends JavaMethodBindingEmitter writer.println(" throw new " + getRuntimeExceptionType() + "(\"Unimplemented\");"); } else { emitPreCallSetup(binding, writer); - emitReturnVariableSetup(binding, writer); - emitCall(binding, writer); + //emitReturnVariableSetup(binding, writer); + emitReturnVariableSetupAndCall(binding, writer); } writer.println(" }"); } else { @@ -94,6 +94,18 @@ public class JavaMethodBindingImplEmitter extends JavaMethodBindingEmitter } } + + protected boolean generateIndirectBufferInterface = false; + + public boolean isGenerateIndirectBufferInterface() { + return generateIndirectBufferInterface; + } + + public void setGenerateIndirectBufferInterface(boolean generateIndirect) { + generateIndirectBufferInterface = generateIndirect; + } + + protected boolean isUnimplemented() { return isUnimplemented; } @@ -107,7 +119,12 @@ public class JavaMethodBindingImplEmitter extends JavaMethodBindingEmitter } protected void emitPreCallSetup(MethodBinding binding, PrintWriter writer) { - emitArrayLengthAndNIOBufferChecks(binding, writer); + if(isGenerateIndirectBufferInterface()) { + // case for when indirect Buffer is a possibility + emitArrayLengthAndNIOInDirectBufferChecks(binding, writer); + } else { + emitArrayLengthAndNIOBufferChecks(binding, writer); + } } @@ -141,7 +158,7 @@ public class JavaMethodBindingImplEmitter extends JavaMethodBindingEmitter binding.getArgumentName(i) + "\\\" was not a direct buffer\");"); writer.println(" }"); // get the Buffer Array offset values and save them into another array to send down to JNI - writer.print(" " + arrayName + "[_ctr] = BufferFactory.getPositionByteOffset("); + writer.print(" " + arrayName + "[_ctr] = BufferFactory.getDirectBufferByteOffset("); writer.println(argName + "[_ctr]);"); writer.println(" }"); writer.println(" }"); @@ -156,6 +173,75 @@ public class JavaMethodBindingImplEmitter extends JavaMethodBindingEmitter } } + + protected void emitArrayLengthAndNIOInDirectBufferChecks(MethodBinding binding, PrintWriter writer) { + int numBufferOffsetArrayArgs = 0; + boolean firstBuffer = true; + // Check lengths of any incoming arrays if necessary + for (int i = 0; i < binding.getNumArguments(); i++) { + Type type = binding.getCArgumentType(i); + if (type.isArray()) { + ArrayType arrayType = type.asArray(); + writer.println(" if (" + binding.getArgumentName(i) + ".length < " + + arrayType.getLength() + ")"); + writer.println(" throw new " + getRuntimeExceptionType() + + "(\"Length of array \\\"" + binding.getArgumentName(i) + + "\\\" was less than the required " + arrayType.getLength() + "\");"); + } else { + JavaType javaType = binding.getJavaArgumentType(i); + if (javaType.isNIOBuffer()) { + if(firstBuffer == true) { + firstBuffer = false; + writer.println(" boolean direct = true, firstTime = true, result = true;"); + } + writer.println(" result = BufferFactory.isDirect(" + binding.getArgumentName(i) + ");"); + writer.println(" if(firstTime == true) {"); + writer.println(" direct = result;"); + writer.println(" firstTime = false;"); + writer.println(" } else {"); + writer.println(" if(direct != result)"); + writer.println(" throw new " + getRuntimeExceptionType() + + "(\"Argument \\\"" + binding.getArgumentName(i) + + "\\\" :Not all Buffers in this method were direct or indirect\");"); + writer.println(" }"); + } else if (javaType.isNIOBufferArray()) { + if(firstBuffer == true) { + firstBuffer = false; + writer.println(" boolean direct = true, firstTime = true, result = true;"); + } + numBufferOffsetArrayArgs++; + String argName = binding.getArgumentName(i); + String arrayName = byteOffsetArrayConversionArgName(numBufferOffsetArrayArgs); + writer.println(" int[] " + arrayName + " = new int[" + argName + ".length];"); + writer.println(" if (" + argName + " != null) {"); + // Check direct/indirect buffer properties of all buffers within + writer.println(" for (int _ctr = 0; _ctr < " + argName + ".length; _ctr++) {"); + writer.println(" result = BufferFactory.isDirect(" + argName + "[_ctr]);"); + + writer.println(" if(firstTime == true) {"); + writer.println(" direct = result;"); + writer.println(" firstTime = false;"); + writer.println(" } else {"); + writer.println(" if(direct != result)"); + writer.println(" throw new " + getRuntimeExceptionType() + "(\"Element \" + _ctr + \" of argument \\\"" + binding.getArgumentName(i) + "\\\":Mixture of Direct/Indirect Buffers in Method Args\");"); + writer.println(" }"); + // get the Buffer Array offset values and save them into another array to send down to JNI + writer.println(" if(direct)"); + writer.print(" " + arrayName + "[_ctr] = BufferFactory.getDirectBufferByteOffset("); + writer.println(argName + "[_ctr]);"); + writer.println(" else"); + writer.print(" " + arrayName + "[_ctr] = BufferFactory.getIndirectBufferByteOffset("); + writer.println(argName + "[_ctr]);"); + writer.println(" }"); + writer.println(" }"); + } + } + } + } + + + +/* old method before indirect buffer support was added protected void emitReturnVariableSetup(MethodBinding binding, PrintWriter writer) { writer.print(" "); JavaType returnType = binding.getJavaReturnType(); @@ -172,19 +258,68 @@ public class JavaMethodBindingImplEmitter extends JavaMethodBindingEmitter } } } +*/ + + + protected void emitReturnVariableSetupAndCall(MethodBinding binding, PrintWriter writer) { + + boolean returnFunction = false; - protected void emitCall(MethodBinding binding, PrintWriter writer) { + writer.print(" "); + JavaType returnType = binding.getJavaReturnType(); + if (!returnType.isVoid()) { + if (returnType.isCompoundTypeWrapper() || + returnType.isNIOByteBuffer()) { + writer.println("ByteBuffer _res;"); + writer.print(" _res = "); + } else if (returnType.isArrayOfCompoundTypeWrappers()) { + writer.println("ByteBuffer[] _res;"); + writer.print(" _res = "); + } else { + if(isGenerateIndirectBufferInterface()) + returnFunction = true; + else + writer.print("return "); + } + } + + + if(isGenerateIndirectBufferInterface()) { + //binding.setIndirectVariant(false); + //writer.println(" boolean direct = true;"); + writer.println(" if(direct) {"); + writer.print(" "); + }; + if(returnFunction) writer.print("return "); writer.print(getImplMethodName()); writer.print("("); - emitCallArguments(binding, writer); + emitCallArguments(binding, writer, false); writer.print(")"); + if(isGenerateIndirectBufferInterface()) { + writer.println(";"); + //binding.setIndirectVariant(true); + writer.println(" } else { "); + if(returnFunction) writer.print("return "); + // get the indirect Buffer implementation name + setIndirectBufferInterface(true); + writer.print(" " + getImplMethodName()); + writer.print("("); + setIndirectBufferInterface(false); + emitCallArguments(binding, writer, true); + writer.println(");"); + writer.println(" }"); + }; emitCallResultReturn(binding, writer); } - - protected int emitCallArguments(MethodBinding binding, PrintWriter writer) { + + + protected int emitCallArguments(MethodBinding binding, PrintWriter writer, boolean indirectCase) { boolean needComma = false; int numArgsEmitted = 0; int numBufferOffsetArgs = 0, numBufferOffsetArrayArgs = 0; + boolean generateDirectAndIndirect; + + generateDirectAndIndirect = isGenerateIndirectBufferInterface(); if (binding.hasContainingType()) { // Emit this pointer @@ -194,7 +329,7 @@ public class JavaMethodBindingImplEmitter extends JavaMethodBindingEmitter ++numArgsEmitted; numBufferOffsetArgs++; //writer.print(", " + byteOffsetConversionArgName(numBufferOffsetArgs)); - writer.print(", BufferFactory.getPositionByteOffset(getBuffer())"); + writer.print(", BufferFactory.getDirectBufferByteOffset(getBuffer())"); } for (int i = 0; i < binding.getNumArguments(); i++) { JavaType type = binding.getJavaArgumentType(i); @@ -217,14 +352,20 @@ public class JavaMethodBindingImplEmitter extends JavaMethodBindingEmitter if (type.isCompoundTypeWrapper()) { writer.print("(("); } - writer.print(binding.getArgumentName(i)); + + if(type.isNIOBuffer() && !type.isNIOBufferArray() && generateDirectAndIndirect && indirectCase) { + writer.print("BufferFactory.getArray(" + binding.getArgumentName(i) + ")"); + } else { + writer.print(binding.getArgumentName(i)); + } + if (type.isCompoundTypeWrapper()) { writer.print(" == null) ? null : "); writer.print(binding.getArgumentName(i)); writer.print(".getBuffer())"); numBufferOffsetArgs++; //writer.print(", " + byteOffsetConversionArgName(numBufferOffsetArgs)); - writer.print(", BufferFactory.getPositionByteOffset(((" + binding.getArgumentName(i)); + writer.print(", BufferFactory.getDirectBufferByteOffset(((" + binding.getArgumentName(i)); writer.print(" == null) ? null : " + binding.getArgumentName(i) + ".getBuffer()))"); } needComma = true; @@ -232,8 +373,18 @@ public class JavaMethodBindingImplEmitter extends JavaMethodBindingEmitter if(type.isNIOBuffer() || type.isNIOBufferArray()) { if(!type.isArray()) { numBufferOffsetArgs++; - writer.print - (", BufferFactory.getPositionByteOffset(" + binding.getArgumentName(i) + ")"); + if(generateDirectAndIndirect) { + if(!indirectCase) { + writer.print + (", BufferFactory.getDirectBufferByteOffset(" + binding.getArgumentName(i) + ")"); + } else { + writer.print + (", BufferFactory.getIndirectBufferByteOffset(" + binding.getArgumentName(i) + ")"); + } + } else { + writer.print + (", BufferFactory.getDirectBufferByteOffset(" + binding.getArgumentName(i) + ")"); + } } else { numBufferOffsetArrayArgs++; writer.print(", " + byteOffsetArrayConversionArgName(numBufferOffsetArrayArgs)); @@ -267,8 +418,12 @@ public class JavaMethodBindingImplEmitter extends JavaMethodBindingEmitter protected void emitCallResultReturn(MethodBinding binding, PrintWriter writer) { JavaType returnType = binding.getJavaReturnType(); + boolean indirect; + + indirect = isGenerateIndirectBufferInterface(); + if (returnType.isCompoundTypeWrapper()) { - writer.println(";"); + if(!indirect) writer.println(";"); String fmt = getReturnedArrayLengthExpression(); writer.println(" if (_res == null) return null;"); if (fmt == null) { @@ -304,20 +459,24 @@ public class JavaMethodBindingImplEmitter extends JavaMethodBindingEmitter writer.println(" }"); writer.print (" return _retarray"); } - } else if (returnType.isNIOBuffer()) { writer.println(";"); + } else if (returnType.isNIOBuffer()) { + if(!indirect) writer.println(";"); writer.println(" if (_res == null) return null;"); writer.print(" return _res.order(ByteOrder.nativeOrder())"); - } else if (returnType.isArrayOfCompoundTypeWrappers()) { writer.println(";"); + } else if (returnType.isArrayOfCompoundTypeWrappers()) { + if(!indirect) writer.println(";"); writer.println(" if (_res == null) return null;"); writer.println(" " + getReturnTypeString(false) + " _retarray = new " + getReturnTypeString(true) + "[_res.length];"); writer.println(" for (int _count = 0; _count < _res.length; _count++) {"); writer.println(" _retarray[_count] = new " + getReturnTypeString(true) + "(_res[_count]);"); writer.println(" }"); writer.print (" return _retarray"); + writer.println(";"); + } else { + if(!indirect) writer.println(";"); } - writer.println(";"); } } diff --git a/src/net/java/games/gluegen/opengl/CGLPAWrapperEmitter.java b/src/net/java/games/gluegen/opengl/CGLPAWrapperEmitter.java index 586641576..e233d7155 100644 --- a/src/net/java/games/gluegen/opengl/CGLPAWrapperEmitter.java +++ b/src/net/java/games/gluegen/opengl/CGLPAWrapperEmitter.java @@ -74,6 +74,8 @@ public class CGLPAWrapperEmitter extends CMethodBindingEmitter // if(binding.signatureUsesPrimitiveArrays()) // arrayImplRoutine = true; + indirectBufferInterface = methodToWrap.isIndirectBufferInterface(); + if (methodToWrap.getReturnValueCapacityExpression() != null) { setReturnValueCapacityExpression(methodToWrap.getReturnValueCapacityExpression()); } @@ -237,7 +239,9 @@ public class CGLPAWrapperEmitter extends CMethodBindingEmitter StringBuffer buf = new StringBuffer(); buf.append(jniMangle(binding.getName())); - if(binding.signatureUsesPrimitiveArrays()) + if( isIndirectBufferInterface() ) + buf.append("2"); + else if(binding.signatureUsesPrimitiveArrays()) buf.append("1"); buf.append("__"); diff --git a/src/net/java/games/gluegen/opengl/JavaGLPAWrapperEmitter.java b/src/net/java/games/gluegen/opengl/JavaGLPAWrapperEmitter.java index 951faf178..d0eafa8de 100644 --- a/src/net/java/games/gluegen/opengl/JavaGLPAWrapperEmitter.java +++ b/src/net/java/games/gluegen/opengl/JavaGLPAWrapperEmitter.java @@ -174,8 +174,8 @@ public class JavaGLPAWrapperEmitter extends JavaMethodBindingImplEmitter writer.println(" }"); } - protected int emitCallArguments(MethodBinding binding, PrintWriter writer) { - int numEmitted = super.emitCallArguments(binding, writer); + protected int emitCallArguments(MethodBinding binding, PrintWriter writer, boolean indirect) { + int numEmitted = super.emitCallArguments(binding, writer, indirect); if (numEmitted > 0) { writer.print(", "); } diff --git a/src/net/java/games/gluegen/runtime/BufferFactory.java b/src/net/java/games/gluegen/runtime/BufferFactory.java index 3e51aad9a..cae81b1b3 100644 --- a/src/net/java/games/gluegen/runtime/BufferFactory.java +++ b/src/net/java/games/gluegen/runtime/BufferFactory.java @@ -86,7 +86,7 @@ public class BufferFactory { account the Buffer position and the underlying type. This is the total offset for Direct Buffers. */ - public static int getPositionByteOffset(Buffer buf) { + public static int getDirectBufferByteOffset(Buffer buf) { if(buf == null) { return 0; } @@ -140,7 +140,7 @@ public class BufferFactory { object. The array offset also includes the position offset within the buffer, in addition to any array offset. */ - public static int getTotalByteOffset(Buffer buf) { + public static int getIndirectBufferByteOffset(Buffer buf) { if(buf == null) { return 0; } -- cgit v1.2.3