sigonasr2/jmonkeyengine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

implemented all changes regarding OpenCL (and some missing stuff)

Browse Source
This commit is contained in:
Sebastian Weiß 2016-08-26 14:40:44 +02:00
parent e40ebdc5c6
commit e8f76d43fe
19 changed files with 1998 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
jme3-core/src/main/java/com/jme3/audio/openal/ALC.java
View File

@ -59,6 +59,8 @@ public interface ALC {
*/
static final int ALC_DEFAULT_ALL_DEVICES_SPECIFIER = 0x1012;
static final int ALC_ALL_DEVICES_SPECIFIER = 0x1013;
//public static ALCCapabilities createCapabilities(long device);
public void createALC();
public void destroyALC();

4
jme3-lwjgl3/src/main/java/com/jme3/input/lwjgl/GlfwKeyInput.java
View File

@ -95,7 +95,7 @@ public class GlfwKeyInput implements KeyInput {
@Override
public void callback(long args) {
throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
super.callback(args);
}
});
@ -124,7 +124,7 @@ public class GlfwKeyInput implements KeyInput {
@Override
public void callback(long args) {
throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
super.callback(args);
}
});

541
jme3-lwjgl3/src/main/java/com/jme3/lwjgl3/utils/APIBuffer.java Normal file
View File

@ -0,0 +1,541 @@
/*
* Copyright LWJGL. All rights reserved.
* License terms: http://lwjgl.org/license.php
*/
package com.jme3.lwjgl3.utils;
import org.lwjgl.BufferUtils;
import org.lwjgl.PointerBuffer;
import java.nio.ByteBuffer;
import java.util.Arrays;
import static org.lwjgl.system.Pointer.*;
import static org.lwjgl.system.MathUtil.*;
import org.lwjgl.system.MemoryUtil;
import static org.lwjgl.system.MemoryUtil.*;
/**
* Helper class for alternative API functions. Instead of the user
* passing their own buffer, thread-local instances of this class
* are used internally instead.
*/
public class APIBuffer {
private static final int DEFAULT_CAPACITY = 128;
private ByteBuffer buffer;
private long address;
private int offset;
private int stackDepth;
private int[] stack = new int[4];
public APIBuffer() {
buffer = BufferUtils.createByteBuffer(DEFAULT_CAPACITY);
address = memAddress(buffer);
}
/** Resets the parameter offset to 0. */
public APIBuffer reset() {
offset = 0;
return this;
}
/** Pushes the current parameter offset to a stack. */
public APIBuffer push() {
if ( stackDepth == stack.length )
stack = Arrays.copyOf(stack, stack.length << 1);
stack[stackDepth++] = offset;
// Upward align the current offset to the pointer size.
offset = (offset + (POINTER_SIZE - 1)) & -POINTER_SIZE;
return this;
}
/** Restores the last pushed parameter offset. */
public APIBuffer pop() {
offset = stack[--stackDepth];
return this;
}
/** Returns the current parameter offset. */
public int getOffset() {
return offset;
}
/** Sets the current parameter offset. */
public void setOffset(int offset) {
this.offset = offset;
}
/** Returns the memory address of the internal {@link ByteBuffer}. This address may change after a call to one of the {@code <type>Param()} methods. */
public long address() {
return address;
}
/** Returns the memory address of the specified {@code offset}. This address may change after a call to one of the {@code <type>Param()} methods. */
public long address(int offset) {
return address + offset;
}
/**
* Returns the memory address of the specified {@code offset} or {@link MemoryUtil#NULL NULL} if the specified {@code value} is null. This address may
* change after a call to one of the {@code <type>Param()} methods.
*/
public long addressSafe(Object value, int offset) {
return value == null ? NULL : address(offset);
}
/** Returns the {@link ByteBuffer} that backs this {@link APIBuffer}. */
public ByteBuffer buffer() {
return buffer;
}
private void ensureCapacity(int capacity) {
if ( capacity <= buffer.capacity() )
return;
ByteBuffer resized = BufferUtils.createByteBuffer(mathRoundPoT(capacity));
resized.put(buffer);
resized.clear();
buffer = resized;
address = memAddress(resized);
}
// ---------------------------------------------------------------------------------------------------------------------
private int param(int bytes) {
return param(bytes, bytes);
}
private int param(int bytes, int alignment) {
// Upward align the current offset to the specified alignment
int param = (offset + (alignment - 1)) & -alignment;
ensureCapacity(offset = param + bytes);
return param;
}
/** Ensures space for an additional boolean value and returns the address offset. */
public int booleanParam() { return param(1); }
/** Ensures space for an additional byte value and returns the address offset. */
public int byteParam() { return param(1); }
/** Ensures space for an additional short value and returns the address offset. */
public int shortParam() { return param(2); }
/** Ensures space for an additional int value and returns the address offset. */
public int intParam() { return param(4); }
/** Ensures space for an additional long value and returns the address offset. */
public int longParam() { return param(8); }
/** Ensures space for an additional float value and returns the address offset. */
public int floatParam() { return param(4); }
/** Ensures space for an additional double value and returns the address offset. */
public int doubleParam() { return param(8); }
/** Ensures space for an additional pointer value and returns the address offset. */
public int pointerParam() { return param(POINTER_SIZE); }
/** Ensures space for an additional buffer with the specified size (in bytes) and returns the address offset. */
public int bufferParam(int size) { return param(size, POINTER_SIZE); }
// ---------------------------------------------------------------------------------------------------------------------
/** Ensures space for an additional boolean value, sets the specified value at the allocated offset and returns that offset. */
public int booleanParam(boolean value) {
int offset = booleanParam();
buffer.put(offset, value ? (byte)1 : (byte)0);
return offset;
}
/** Ensures space for an additional byte value, sets the specified value at the allocated offset and returns that offset. */
public int byteParam(byte value) {
int offset = byteParam();
buffer.put(offset, value);
return offset;
}
/** Ensures space for an additional short value, sets the specified value at the allocated offset and returns that offset. */
public int shortParam(short value) {
int offset = shortParam();
buffer.putShort(offset, value);
return offset;
}
/** Ensures space for an additional int value, sets the specified value at the allocated offset and returns that offset. */
public int intParam(int value) {
int offset = intParam();
buffer.putInt(offset, value);
return offset;
}
/** Ensures space for an additional long value, sets the specified value at the allocated offset and returns that offset. */
public int longParam(long value) {
int offset = longParam();
buffer.putLong(offset, value);
return offset;
}
/** Ensures space for an additional float value, sets the specified value at the allocated offset and returns that offset. */
public int floatParam(float value) {
int offset = floatParam();
buffer.putFloat(offset, value);
return offset;
}
/** Ensures space for an additional double value, sets the specified value at the allocated offset and returns that offset. */
public int doubleParam(double value) {
int offset = doubleParam();
buffer.putDouble(offset, value);
return offset;
}
/** Ensures space for an additional pointer value, sets the specified value at the allocated offset and returns that offset. */
public int pointerParam(long value) {
int offset = pointerParam();
PointerBuffer.put(buffer, offset, value);
return offset;
}
// ----
/** Ensures space for an additional pointer buffer, sets the specified memory addresses and returns the address offset. */
public int pointerArrayParam(long... pointers) {
int buffersAddress = bufferParam(pointers.length << POINTER_SHIFT);
for ( int i = 0; i < pointers.length; i++ )
pointerParam(buffersAddress, i, pointers[i]);
return buffersAddress;
}
/** Ensures space for an additional pointer buffer, sets the memory addresses of the specified buffers and returns the address offset. */
public int pointerArrayParam(ByteBuffer... buffers) {
int buffersAddress = bufferParam(buffers.length << POINTER_SHIFT);
for ( int i = 0; i < buffers.length; i++ )
pointerParam(buffersAddress, i, memAddress(buffers[i]));
return buffersAddress;
}
/**
* Ensures space for two additional pointer buffers, sets the memory addresses and remaining bytes of the specified buffers and returns the address
* offset.
*/
public int pointerArrayParamp(ByteBuffer... buffers) {
int buffersAddress = pointerArrayParam(buffers);
int buffersLengths = bufferParam(buffers.length << POINTER_SHIFT);
for ( int i = 0; i < buffers.length; i++ )
pointerParam(buffersLengths, i, buffers[i].remaining());
return buffersAddress;
}
// ---------------------------------------------------------------------------------------------------------------------
/**
* ASCII encodes the specified strings with a null-terminator and ensures space for a buffer filled with the memory addresses of the encoded strings.
*
* <p>The encoded buffers must be later freed with {@link #pointerArrayFree(int, int)}.</p>
*
* @return the offset to the memory address buffer
*/
public int pointerArrayParamASCII(CharSequence... strings) {
int buffersAddress = bufferParam(strings.length << POINTER_SHIFT);
for ( int i = 0; i < strings.length; i++ ) {
ByteBuffer buffer = MemoryUtil.memASCII(strings[i]);
pointerParam(buffersAddress, i, memAddress(buffer));
}
return buffersAddress;
}
/**
* ASCII encodes the specified strings and ensures space for two additional buffers filled with the lengths and memory addresses of the encoded strings,
* respectively. The lengths are 4-bytes integers and the memory address buffer starts immediately after the lengths buffer.
*
* <p>The encoded buffers must be later freed with {@link #pointerArrayFree(int, int)}.</p>
*
* @return the offset to the lengths buffer
*/
public int pointerArrayParamASCIIi(CharSequence... strings) {
int buffersAddress = bufferParam(strings.length << POINTER_SHIFT);
int lengthsAddress = bufferParam(strings.length << 2);
for ( int i = 0; i < strings.length; i++ ) {
ByteBuffer buffer = MemoryUtil.memASCII(strings[i]);
pointerParam(buffersAddress, i, memAddress(buffer));
intParam(lengthsAddress, i, buffer.remaining());
}
return buffersAddress;
}
/**
* ASCII encodes the specified strings and ensures space for two additional buffers filled with the lengths and memory addresses of the encoded strings,
* respectively. The lengths are pointer-sized integers and the memory address buffer starts immediately after the lengths buffer.
*
* <p>The encoded buffers must be later freed with {@link #pointerArrayFree(int, int)}.</p>
*
* @return the offset to the lengths buffer
*/
public int pointerArrayParamASCIIp(CharSequence... strings) {
int buffersAddress = bufferParam(strings.length << POINTER_SHIFT);
int lengthsAddress = bufferParam(strings.length << POINTER_SHIFT);
for ( int i = 0; i < strings.length; i++ ) {
ByteBuffer buffer = MemoryUtil.memASCII(strings[i]);
pointerParam(buffersAddress, i, memAddress(buffer));
pointerParam(lengthsAddress, i, buffer.remaining());
}
return buffersAddress;
}
/**
* UTF8 encodes the specified strings with a null-terminator and ensures space for a buffer filled with the memory addresses of the encoded strings.
*
* <p>The encoded buffers must be later freed with {@link #pointerArrayFree(int, int)}.</p>
*
* @return the offset to the memory address buffer
*/
public int pointerArrayParamUTF8(CharSequence... strings) {
int buffersAddress = bufferParam(strings.length << POINTER_SHIFT);
for ( int i = 0; i < strings.length; i++ ) {
ByteBuffer buffer = MemoryUtil.memUTF8(strings[i]);
pointerParam(buffersAddress, i, memAddress(buffer));
}
return buffersAddress;
}
/**
* UTF8 encodes the specified strings and ensures space for two additional buffers filled with the lengths and memory addresses of the encoded strings,
* respectively. The lengths are 4-bytes integers and the memory address buffer starts immediately after the lengths buffer.
*
* <p>The encoded buffers must be later freed with {@link #pointerArrayFree(int, int)}.</p>
*
* @return the offset to the lengths buffer
*/
public int pointerArrayParamUTF8i(CharSequence... strings) {
int buffersAddress = bufferParam(strings.length << POINTER_SHIFT);
int lengthsAddress = bufferParam(strings.length << 2);
for ( int i = 0; i < strings.length; i++ ) {
ByteBuffer buffer = MemoryUtil.memUTF8(strings[i]);
pointerParam(buffersAddress, i, memAddress(buffer));
intParam(lengthsAddress, i, buffer.remaining());
}
return buffersAddress;
}
/**
* UTF8 encodes the specified strings and ensures space for two additional buffers filled with the lengths and memory addresses of the encoded strings,
* respectively. The lengths are pointer-sized integers and the memory address buffer starts immediately after the lengths buffer.
*
* <p>The encoded buffers must be later freed with {@link #pointerArrayFree(int, int)}.</p>
*
* @return the offset to the lengths buffer
*/
public int pointerArrayParamUTF8p(CharSequence... strings) {
int buffersAddress = bufferParam(strings.length << POINTER_SHIFT);
int lengthsAddress = bufferParam(strings.length << POINTER_SHIFT);
for ( int i = 0; i < strings.length; i++ ) {
ByteBuffer buffer = MemoryUtil.memUTF8(strings[i]);
pointerParam(buffersAddress, i, memAddress(buffer));
pointerParam(lengthsAddress, i, buffer.remaining());
}
return buffersAddress;
}
/**
* UTF16 encodes the specified strings with a null-terminator and ensures space for a buffer filled with the memory addresses of the encoded strings.
*
* <p>The encoded buffers must be later freed with {@link #pointerArrayFree(int, int)}.</p>
*
* @return the offset to the memory address buffer
*/
public int pointerArrayParamUTF16(CharSequence... strings) {
int buffersAddress = bufferParam(strings.length << POINTER_SHIFT);
for ( int i = 0; i < strings.length; i++ ) {
ByteBuffer buffer = MemoryUtil.memUTF16(strings[i]);
pointerParam(buffersAddress, i, memAddress(buffer));
}
return buffersAddress;
}
/**
* UTF16 encodes the specified strings and ensures space for two additional buffers filled with the lengths and memory addresses of the encoded strings,
* respectively. The lengths are 4-bytes integers and the memory address buffer starts immediately after the lengths buffer.
*
* <p>The encoded buffers must be later freed with {@link #pointerArrayFree(int, int)}.</p>
*
* @return the offset to the lengths buffer
*/
public int pointerArrayParamUTF16i(CharSequence... strings) {
int buffersAddress = bufferParam(strings.length << POINTER_SHIFT);
int lengthsAddress = bufferParam(strings.length << 2);
for ( int i = 0; i < strings.length; i++ ) {
ByteBuffer buffer = MemoryUtil.memUTF16(strings[i]);
pointerParam(buffersAddress, i, memAddress(buffer));
intParam(lengthsAddress, i, buffer.remaining());
}
return buffersAddress;
}
/**
* UTF16 encodes the specified strings and ensures space for two additional buffers filled with the lengths and memory addresses of the encoded strings,
* respectively. The lengths are pointer-sized integers and the memory address buffer starts immediately after the lengths buffer.
*
* <p>The encoded buffers must be later freed with {@link #pointerArrayFree(int, int)}.</p>
*
* @return the offset to the lengths buffer
*/
public int pointerArrayParamUTF16p(CharSequence... strings) {
int buffersAddress = bufferParam(strings.length << POINTER_SHIFT);
int lengthsAddress = bufferParam(strings.length << POINTER_SHIFT);
for ( int i = 0; i < strings.length; i++ ) {
ByteBuffer buffer = MemoryUtil.memUTF16(strings[i]);
pointerParam(buffersAddress, i, memAddress(buffer));
pointerParam(lengthsAddress, i, buffer.remaining());
}
return buffersAddress;
}
// ---------------------------------------------------------------------------------------------------------------------
/** Frees {@code length} memory blocks stored in the APIBuffer, starting at the specified {@code offset}. */
public void pointerArrayFree(int offset, int length) {
for ( int i = 0; i < length; i++ )
nmemFree(pointerValue(offset + (i << POINTER_SHIFT)));
}
// ---------------------------------------------------------------------------------------------------------------------
/** Sets an int value at the specified index of the int buffer that starts at the specified offset. */
public void intParam(int offset, int index, int value) {
buffer.putInt(offset + (index << 2), value);
}
/** Sets a pointer value at the specified index of the pointer buffer that starts at the specified offset. */
public void pointerParam(int offset, int index, long value) {
PointerBuffer.put(buffer, offset + (index << POINTER_SHIFT), value);
}
// ---------------------------------------------------------------------------------------------------------------------
/** Ensures space for the specified string encoded in ASCII, encodes the string at the allocated offset and returns that offset. */
public int stringParamASCII(CharSequence value, boolean nullTerminated) {
if ( value == null )
return -1;
int offset = bufferParam(value.length() + (nullTerminated ? 1 : 0));
MemoryUtil.memASCII(value, nullTerminated, buffer, offset);
return offset;
}
/** Ensures space for the specified string encoded in UTF-8, encodes the string at the allocated offset and returns that offset. */
public int stringParamUTF8(CharSequence value, boolean nullTerminated) {
if ( value == null )
return -1;
int encodedLen = MemoryUtil.memLengthUTF8(value, nullTerminated);
int offset = bufferParam(encodedLen);
MemoryUtil.memUTF8(value, nullTerminated, buffer, offset);
return offset;
}
/** Ensures space for the specified string encoded in UTF-16, encodes the string at the allocated offset and returns that offset. */
public int stringParamUTF16(CharSequence value, boolean nullTerminated) {
if ( value == null )
return -1;
int offset = bufferParam((value.length() + (nullTerminated ? 1 : 0)) << 1);
MemoryUtil.memUTF16(value, nullTerminated, buffer, offset);
return offset;
}
// ---------------------------------------------------------------------------------------------------------------------
/** Returns the boolean value at the specified offset. */
public boolean booleanValue(int offset) { return buffer.get(offset) != 0; }
/** Returns the boolean value at the specified offset. */
public byte byteValue(int offset) { return buffer.get(offset); }
/** Returns the short value at the specified offset. */
public short shortValue(int offset) { return buffer.getShort(offset); }
/** Returns the int value at the specified offset. */
public int intValue(int offset) { return buffer.getInt(offset); }
/** Returns the long value at the specified offset. */
public long longValue(int offset) { return buffer.getLong(offset); }
/** Returns the float value at the specified offset. */
public float floatValue(int offset) { return buffer.getFloat(offset); }
/** Returns the double value at the specified offset. */
public double doubleValue(int offset) { return buffer.getDouble(offset); }
/** Returns the pointer value at the specified offset. */
public long pointerValue(int offset) { return PointerBuffer.get(buffer, offset); }
/** Returns the ASCII string value at the specified byte range. */
public String stringValueASCII(int offset, int limit) {
buffer.position(offset);
buffer.limit(limit);
try {
return MemoryUtil.memASCII(buffer);
} finally {
buffer.clear();
}
}
/** Returns the UTF8 string value at the specified byte range. */
public String stringValueUTF8(int offset, int limit) {
buffer.position(offset);
buffer.limit(limit);
try {
return MemoryUtil.memUTF8(buffer);
} finally {
buffer.clear();
}
}
/** Returns the UTF16 string value at the specified byte range. */
public String stringValueUTF16(int offset, int limit) {
buffer.position(offset);
buffer.limit(limit);
try {
return MemoryUtil.memUTF16(buffer);
} finally {
buffer.clear();
}
}
}

192
jme3-lwjgl3/src/main/java/com/jme3/lwjgl3/utils/APIUtil.java Normal file
View File

@ -0,0 +1,192 @@
/*
* Copyright LWJGL. All rights reserved.
* License terms: http://lwjgl.org/license.php
*/
package com.jme3.lwjgl3.utils;
import com.jme3.lwjgl3.utils.APIBuffer;
import org.lwjgl.system.linux.LinuxLibrary;
import org.lwjgl.system.macosx.MacOSXLibrary;
import org.lwjgl.system.windows.WindowsLibrary;
import java.io.PrintStream;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Utility class useful to API bindings. [INTERNAL USE ONLY]
*
* <p>Method names in this class are prefixed with {@code api} to avoid ambiguities when used with static imports.</p>
*/
public final class APIUtil {
private static final ThreadLocal<APIBuffer> API_BUFFERS = new ThreadLocal<APIBuffer>() {
@Override
protected APIBuffer initialValue() {
return new APIBuffer();
}
};
private APIUtil() {
}
/** Returns a thread-local {@link APIBuffer} that has been reset. */
public static APIBuffer apiBuffer() {
return API_BUFFERS.get().reset();
}
/**
* Returns a thread-local {@link APIBuffer}, without resetting it. This makes the APIBuffer work like a stack when used in nested API calls. The user is
* responsible for resetting the {@link APIBuffer} to an appropriate state before the nested call returns.
*
* @see APIBuffer#pop
*/
public static APIBuffer apiStack() {
return API_BUFFERS.get().push();
}
/** A data class for API versioning information. */
public static class APIVersion {
/** Returns the API major version. */
public final int major;
/** Returns the API minor version. */
public final int minor;
/** Returns the API revision. May be null. */
public final String revision;
/** Returns the API implementation-specific versioning information. May be null. */
public final String implementation;
public APIVersion(int major, int minor) {
this(major, minor, null, null);
}
public APIVersion(int major, int minor, String revision, String implementation) {
this.major = major;
this.minor = minor;
this.revision = revision;
this.implementation = implementation;
}
}
/**
* Parses a version string. The version string must have the format {@code MAJOR.MINOR.REVISION IMPL}, where {@code MAJOR} is the major version (integer),
* {@code MINOR} is the minor version (integer), {@code REVISION} is the revision version (string, optional) and {@code IMPL} is implementation-specific
* information (string, optional).
*
* @param version the API version string
*
* @return the parsed {@link APIVersion}
*/
public static APIVersion apiParseVersion(String version) {
return apiParseVersion(version, null);
}
/**
* Parses a version string. The version string must have the format {@code PREFIX MAJOR.MINOR.REVISION IMPL}, where {@code PREFIX} is the specified prefix
* (string, optional), {@code MAJOR} is the major version (integer), {@code MINOR} is the minor version (integer), {@code REVISION} is the revision version
* (string, optional) and {@code IMPL} is implementation-specific information (string, optional).
*
* @param version the version string
* @param prefix the version string prefix, may be null
*
* @return the parsed {@link APIVersion}
*/
public static APIVersion apiParseVersion(String version, String prefix) {
String pattern = "([0-9]+)[.]([0-9]+)([.]\\S+)?\\s*(.+)?";
if ( prefix != null )
pattern = prefix + "\\s+" + pattern;
Matcher matcher = Pattern.compile(pattern).matcher(version);
if ( !matcher.matches() )
throw new IllegalArgumentException(String.format("Malformed API version string [%s]", version));
return new APIVersion(
Integer.parseInt(matcher.group(1)),
Integer.parseInt(matcher.group(2)),
matcher.group(3),
matcher.group(4)
);
}
public static String apiUnknownToken(int token) {
return apiUnknownToken("Unknown", token);
}
public static String apiUnknownToken(String description, int token) {
return String.format("%s [0x%X]", description, token);
}
/**
* Returns a map of public static final integer fields in the specified classes, to their String representations. An optional filter can be specified to
* only include specific fields. The target map may be null, in which case a new map is allocated and returned.
*
* <p>This method is useful when debugging to quickly identify values returned from an API.</p>
*
* @param filter the filter to use (optional)
* @param target the target map (optional)
* @param tokenClasses the classes to get tokens from
*
* @return the token map
*/
public static Map<Integer, String> apiClassTokens(TokenFilter filter, Map<Integer, String> target, Class<?>... tokenClasses) {
if ( target == null )
target = new HashMap<Integer, String>(64);
int TOKEN_MODIFIERS = Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL;
for ( Class<?> tokenClass : tokenClasses ) {
if ( tokenClass == null )
continue;
for ( Field field : tokenClass.getDeclaredFields() ) {
// Get only <public static final int> fields.
if ( (field.getModifiers() & TOKEN_MODIFIERS) == TOKEN_MODIFIERS && field.getType() == int.class ) {
try {
int value = field.getInt(null);
if ( filter != null && !filter.accept(field, value) )
continue;
String name = target.get(value);
target.put(value, name == null ? field.getName() : name + "|" + field.getName());
} catch (IllegalAccessException e) {
// Ignore
}
}
}
}
return target;
}
public static Class<?> apiOptionalClass(String className) {
try {
return Class.forName(className);
} catch (ClassNotFoundException e) {
return null;
}
}
/** Simple interface for Field filtering. */
public interface TokenFilter {
/**
* Should return true if the specified Field passes the filter.
*
* @param field the Field to test
* @param value the integer value of the field
*
* @return true if the Field is accepted
*/
boolean accept(Field field, int value);
}
}

1
jme3-lwjgl3/src/main/java/com/jme3/opencl/lwjgl/LwjglBuffer.java
View File

@ -32,6 +32,7 @@
package com.jme3.opencl.lwjgl;
import com.jme3.opencl.*;
import com.jme3.opencl.lwjgl.info.Info;
import java.nio.ByteBuffer;
import org.lwjgl.opencl.*;

2
jme3-lwjgl3/src/main/java/com/jme3/opencl/lwjgl/LwjglContext.java
View File

@ -146,7 +146,7 @@ public class LwjglContext extends Context {
}
//get formats
CLImageFormat.Buffer formatsB = new CLImageFormat.Buffer(BufferUtils.createByteBuffer(count * CLImageFormat.SIZEOF));
ret = CL10.clGetSupportedImageFormats(context, memFlags, typeFlag, formatsB, null);
ret = CL10.clGetSupportedImageFormats(context, memFlags, typeFlag, formatsB, (IntBuffer) null);
Utils.checkError(ret, "clGetSupportedImageFormats");
//convert formats
ImageFormat[] formats = new ImageFormat[count];

78
jme3-lwjgl3/src/main/java/com/jme3/opencl/lwjgl/LwjglDevice.java
View File

@ -33,13 +33,12 @@ package com.jme3.opencl.lwjgl;
import com.jme3.opencl.Device;
import com.jme3.opencl.Platform;
import com.jme3.opencl.lwjgl.info.Info;
import java.util.Arrays;
import java.util.Collection;
import org.lwjgl.PointerBuffer;
import org.lwjgl.opencl.CL10;
import org.lwjgl.opencl.CL11;
import org.lwjgl.opencl.CLDevice;
import org.lwjgl.opencl.Info;
/**
*
@ -47,18 +46,15 @@ import org.lwjgl.opencl.Info;
*/
public final class LwjglDevice implements Device {
final CLDevice device;
final long device;
final LwjglPlatform platform;
public LwjglDevice(CLDevice device, LwjglPlatform platform) {
public LwjglDevice(long device, LwjglPlatform platform) {
this.device = device;
this.platform = platform;
}
public long getDevice() {
return device.address();
}
public CLDevice getCLDevice() {
return device;
}
@ -69,7 +65,7 @@ public final class LwjglDevice implements Device {
@Override
public DeviceType getDeviceType() {
int type = Info.clGetDeviceInfoInt(device.address(), CL10.CL_DEVICE_TYPE);
int type = Info.clGetDeviceInfoInt(device, CL10.CL_DEVICE_TYPE);
switch (type) {
case CL10.CL_DEVICE_TYPE_ACCELERATOR: return DeviceType.ACCELEARTOR;
case CL10.CL_DEVICE_TYPE_CPU: return DeviceType.CPU;
@ -80,17 +76,17 @@ public final class LwjglDevice implements Device {
@Override
public int getVendorId() {
return Info.clGetDeviceInfoInt(device.address(), CL10.CL_DEVICE_VENDOR_ID);
return Info.clGetDeviceInfoInt(device, CL10.CL_DEVICE_VENDOR_ID);
}
@Override
public boolean isAvailable() {
return Info.clGetDeviceInfoBoolean(device.address(), CL10.CL_DEVICE_AVAILABLE);
return Info.clGetDeviceInfoBoolean(device, CL10.CL_DEVICE_AVAILABLE);
}
@Override
public boolean hasCompiler() {
return Info.clGetDeviceInfoBoolean(device.address(), CL10.CL_DEVICE_COMPILER_AVAILABLE);
return Info.clGetDeviceInfoBoolean(device, CL10.CL_DEVICE_COMPILER_AVAILABLE);
}
@Override
@ -105,17 +101,17 @@ public final class LwjglDevice implements Device {
@Override
public boolean hasErrorCorrectingMemory() {
return Info.clGetDeviceInfoBoolean(device.address(), CL10.CL_DEVICE_ERROR_CORRECTION_SUPPORT);
return Info.clGetDeviceInfoBoolean(device, CL10.CL_DEVICE_ERROR_CORRECTION_SUPPORT);
}
@Override
public boolean hasUnifiedMemory() {
return Info.clGetDeviceInfoBoolean(device.address(), CL11.CL_DEVICE_HOST_UNIFIED_MEMORY);
return Info.clGetDeviceInfoBoolean(device, CL11.CL_DEVICE_HOST_UNIFIED_MEMORY);
}
@Override
public boolean hasImageSupport() {
return Info.clGetDeviceInfoBoolean(device.address(), CL10.CL_DEVICE_IMAGE_SUPPORT);
return Info.clGetDeviceInfoBoolean(device, CL10.CL_DEVICE_IMAGE_SUPPORT);
}
@Override
@ -135,39 +131,39 @@ public final class LwjglDevice implements Device {
@Override
public Collection<? extends String> getExtensions() {
return Arrays.asList(Info.clGetDeviceInfoStringASCII(device.address(), CL10.CL_DEVICE_EXTENSIONS).split(" "));
return Arrays.asList(Info.clGetDeviceInfoStringASCII(device, CL10.CL_DEVICE_EXTENSIONS).split(" "));
}
@Override
public int getComputeUnits() {
return Info.clGetDeviceInfoInt(device.address(), CL10.CL_DEVICE_MAX_COMPUTE_UNITS);
return Info.clGetDeviceInfoInt(device, CL10.CL_DEVICE_MAX_COMPUTE_UNITS);
}
@Override
public int getClockFrequency() {
return Info.clGetDeviceInfoInt(device.address(), CL10.CL_DEVICE_MAX_CLOCK_FREQUENCY);
return Info.clGetDeviceInfoInt(device, CL10.CL_DEVICE_MAX_CLOCK_FREQUENCY);
}
@Override
public int getAddressBits() {
return Info.clGetDeviceInfoInt(device.address(), CL10.CL_DEVICE_ADDRESS_BITS);
return Info.clGetDeviceInfoInt(device, CL10.CL_DEVICE_ADDRESS_BITS);
}
@Override
public boolean isLittleEndian() {
return Info.clGetDeviceInfoBoolean(device.address(), CL10.CL_DEVICE_ENDIAN_LITTLE);
return Info.clGetDeviceInfoBoolean(device, CL10.CL_DEVICE_ENDIAN_LITTLE);
}
@Override
public long getMaximumWorkItemDimensions() {
return Info.clGetDeviceInfoInt(device.address(), CL10.CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS);
return Info.clGetDeviceInfoInt(device, CL10.CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS);
}
@Override
public long[] getMaximumWorkItemSizes() {
int dim = (int) getMaximumWorkItemDimensions();
PointerBuffer sizes = PointerBuffer.allocateDirect(dim);
Info.clGetDeviceInfoPointers(device.address(), CL10.CL_DEVICE_MAX_WORK_ITEM_SIZES, sizes);
Info.clGetDeviceInfoPointers(device, CL10.CL_DEVICE_MAX_WORK_ITEM_SIZES, sizes);
long[] sx = new long[dim];
sizes.get(sx);
return sx;
@ -175,74 +171,74 @@ public final class LwjglDevice implements Device {
@Override
public long getMaxiumWorkItemsPerGroup() {
return Info.clGetDeviceInfoPointer(device.address(), CL10.CL_DEVICE_MAX_WORK_GROUP_SIZE);
return Info.clGetDeviceInfoPointer(device, CL10.CL_DEVICE_MAX_WORK_GROUP_SIZE);
}
@Override
public int getMaximumSamplers() {
return Info.clGetDeviceInfoInt(device.address(), CL10.CL_DEVICE_MAX_SAMPLERS);
return Info.clGetDeviceInfoInt(device, CL10.CL_DEVICE_MAX_SAMPLERS);
}
@Override
public int getMaximumReadImages() {
return Info.clGetDeviceInfoInt(device.address(), CL10.CL_DEVICE_MAX_READ_IMAGE_ARGS);
return Info.clGetDeviceInfoInt(device, CL10.CL_DEVICE_MAX_READ_IMAGE_ARGS);
}
@Override
public int getMaximumWriteImages() {
return Info.clGetDeviceInfoInt(device.address(), CL10.CL_DEVICE_MAX_WRITE_IMAGE_ARGS);
return Info.clGetDeviceInfoInt(device, CL10.CL_DEVICE_MAX_WRITE_IMAGE_ARGS);
}
@Override
public long[] getMaximumImage2DSize() {
return new long[] {
Info.clGetDeviceInfoPointer(device.address(), CL10.CL_DEVICE_IMAGE2D_MAX_WIDTH),
Info.clGetDeviceInfoPointer(device.address(), CL10.CL_DEVICE_IMAGE2D_MAX_HEIGHT)
Info.clGetDeviceInfoPointer(device, CL10.CL_DEVICE_IMAGE2D_MAX_WIDTH),
Info.clGetDeviceInfoPointer(device, CL10.CL_DEVICE_IMAGE2D_MAX_HEIGHT)
};
}
@Override
public long[] getMaximumImage3DSize() {
return new long[] {
Info.clGetDeviceInfoPointer(device.address(), CL10.CL_DEVICE_IMAGE3D_MAX_WIDTH),
Info.clGetDeviceInfoPointer(device.address(), CL10.CL_DEVICE_IMAGE3D_MAX_HEIGHT),
Info.clGetDeviceInfoPointer(device.address(), CL10.CL_DEVICE_IMAGE3D_MAX_DEPTH)
Info.clGetDeviceInfoPointer(device, CL10.CL_DEVICE_IMAGE3D_MAX_WIDTH),
Info.clGetDeviceInfoPointer(device, CL10.CL_DEVICE_IMAGE3D_MAX_HEIGHT),
Info.clGetDeviceInfoPointer(device, CL10.CL_DEVICE_IMAGE3D_MAX_DEPTH)
};
}
@Override
public long getMaximumAllocationSize() {
return Info.clGetDeviceInfoLong(device.address(), CL10.CL_DEVICE_MAX_MEM_ALLOC_SIZE);
return Info.clGetDeviceInfoLong(device, CL10.CL_DEVICE_MAX_MEM_ALLOC_SIZE);
}
@Override
public long getGlobalMemorySize() {
return Info.clGetDeviceInfoLong(device.address(), CL10.CL_DEVICE_GLOBAL_MEM_SIZE);
return Info.clGetDeviceInfoLong(device, CL10.CL_DEVICE_GLOBAL_MEM_SIZE);
}
@Override
public long getLocalMemorySize() {
return Info.clGetDeviceInfoLong(device.address(), CL10.CL_DEVICE_LOCAL_MEM_SIZE);
return Info.clGetDeviceInfoLong(device, CL10.CL_DEVICE_LOCAL_MEM_SIZE);
}
@Override
public long getMaximumConstantBufferSize() {
return Info.clGetDeviceInfoLong(device.address(), CL10.CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE);
return Info.clGetDeviceInfoLong(device, CL10.CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE);
}
@Override
public int getMaximumConstantArguments() {
return Info.clGetDeviceInfoInt(device.address(), CL10.CL_DEVICE_MAX_CONSTANT_ARGS);
return Info.clGetDeviceInfoInt(device, CL10.CL_DEVICE_MAX_CONSTANT_ARGS);
}
@Override
public String getProfile() {
return Info.clGetDeviceInfoStringASCII(device.address(), CL10.CL_DEVICE_PROFILE);
return Info.clGetDeviceInfoStringASCII(device, CL10.CL_DEVICE_PROFILE);
}
@Override
public String getVersion() {
return Info.clGetDeviceInfoStringASCII(device.address(), CL10.CL_DEVICE_VERSION);
return Info.clGetDeviceInfoStringASCII(device, CL10.CL_DEVICE_VERSION);
}
@Override
@ -257,7 +253,7 @@ public final class LwjglDevice implements Device {
@Override
public String getCompilerVersion() {
return Info.clGetDeviceInfoStringASCII(device.address(), CL11.CL_DEVICE_OPENCL_C_VERSION);
return Info.clGetDeviceInfoStringASCII(device, CL11.CL_DEVICE_OPENCL_C_VERSION);
}
@Override
@ -272,7 +268,7 @@ public final class LwjglDevice implements Device {
@Override
public String getDriverVersion() {
return Info.clGetDeviceInfoStringASCII(device.address(), CL10.CL_DRIVER_VERSION);
return Info.clGetDeviceInfoStringASCII(device, CL10.CL_DRIVER_VERSION);
}
@Override
@ -287,12 +283,12 @@ public final class LwjglDevice implements Device {
@Override
public String getName() {
return Info.clGetDeviceInfoStringASCII(device.address(), CL10.CL_DEVICE_NAME);
return Info.clGetDeviceInfoStringASCII(device, CL10.CL_DEVICE_NAME);
}
@Override
public String getVendor() {
return Info.clGetDeviceInfoStringASCII(device.address(), CL10.CL_DEVICE_VENDOR);
return Info.clGetDeviceInfoStringASCII(device, CL10.CL_DEVICE_VENDOR);
}
@Override

2
jme3-lwjgl3/src/main/java/com/jme3/opencl/lwjgl/LwjglEvent.java
View File

@ -32,9 +32,9 @@
package com.jme3.opencl.lwjgl;
import com.jme3.opencl.Event;
import com.jme3.opencl.lwjgl.info.Info;
import java.util.logging.Logger;
import org.lwjgl.opencl.CL10;
import org.lwjgl.opencl.Info;
/**
*

6
jme3-lwjgl3/src/main/java/com/jme3/opencl/lwjgl/LwjglImage.java
View File

@ -33,6 +33,7 @@ package com.jme3.opencl.lwjgl;
import com.jme3.math.ColorRGBA;
import com.jme3.opencl.*;
import com.jme3.opencl.lwjgl.info.Info;
import java.nio.ByteBuffer;
import java.util.logging.Level;
import java.util.logging.Logger;
@ -272,7 +273,10 @@ public class LwjglImage extends Image {
public ImageFormat getImageFormat() {
Utils.b80.rewind();
CLImageFormat format = new CLImageFormat(Utils.b80);
int ret = CL10.clGetImageInfo(image, CL10.CL_IMAGE_FORMAT, format.sizeof(), Utils.b80, null);
int limit = Utils.b80.limit();
Utils.b80.limit(format.sizeof());
int ret = CL10.clGetImageInfo(image, CL10.CL_IMAGE_FORMAT, Utils.b80, null);
Utils.b80.limit(limit);
Utils.checkError(ret, "clGetImageInfo");
return new ImageFormat(encodeImageChannelOrder(format.image_channel_order()), encodeImageChannelType(format.image_channel_data_type()));
}

3
jme3-lwjgl3/src/main/java/com/jme3/opencl/lwjgl/LwjglKernel.java
View File

@ -37,11 +37,10 @@ import com.jme3.math.Vector2f;
import com.jme3.math.Vector4f;
import com.jme3.opencl.*;
import com.jme3.opencl.Buffer;
import com.jme3.opencl.lwjgl.info.Info;
import java.nio.*;
import org.lwjgl.PointerBuffer;
import org.lwjgl.opencl.CL10;
import org.lwjgl.opencl.CLDevice;
import org.lwjgl.opencl.Info;
/**
*

66
jme3-lwjgl3/src/main/java/com/jme3/opencl/lwjgl/LwjglPlatform.java
View File

@ -31,16 +31,20 @@
*/
package com.jme3.opencl.lwjgl;
import com.jme3.lwjgl3.utils.APIBuffer;
import static com.jme3.lwjgl3.utils.APIUtil.apiBuffer;
import com.jme3.opencl.Device;
import com.jme3.opencl.Platform;
import com.jme3.opencl.lwjgl.info.Info;
import java.nio.IntBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.lwjgl.PointerBuffer;
import org.lwjgl.opencl.CL10;
import org.lwjgl.opencl.CLDevice;
import org.lwjgl.opencl.CLPlatform;
import org.lwjgl.opencl.Info;
import static org.lwjgl.system.Pointer.POINTER_SHIFT;
/**
*
@ -48,14 +52,14 @@ import org.lwjgl.opencl.Info;
*/
public final class LwjglPlatform implements Platform {
final CLPlatform platform;
final long platform;
List<LwjglDevice> devices;
public LwjglPlatform(CLPlatform platform) {
public LwjglPlatform(long platform) {
this.platform = platform;
}
public CLPlatform getPlatform() {
public long getPlatform() {
return platform;
}
@ -63,16 +67,54 @@ public final class LwjglPlatform implements Platform {
public List<LwjglDevice> getDevices() {
if (devices == null) {
devices = new ArrayList<>();
for (CLDevice d : platform.getDevices(CL10.CL_DEVICE_TYPE_ALL)) {
for (long d : getDevices(CL10.CL_DEVICE_TYPE_ALL)) {
devices.add(new LwjglDevice(d, this));
}
}
return devices;
}
/**
* Returns a list of the available devices on this platform that match the
* specified type, filtered by the specified filter.
*
* Copied from the old release.
*
* @param device_type the device type
* @param filter the device filter
*
* @return the available devices
*/
private long[] getDevices(int device_type) {
int[] count = new int[1];
int errcode = CL10.clGetDeviceIDs(platform, device_type, null, count);
if (errcode == CL10.CL_DEVICE_NOT_FOUND) {
return new long[0];
}
Utils.checkError(errcode, "clGetDeviceIDs");
int num_devices = count[0];
if (num_devices == 0) {
return new long[0];
}
PointerBuffer devices = PointerBuffer.allocateDirect(num_devices);
errcode = CL10.clGetDeviceIDs(platform, device_type,devices, (IntBuffer) null);
Utils.checkError(errcode, "clGetDeviceIDs");
long[] deviceIDs = new long[num_devices];
devices.rewind();
for (int i = 0; i < num_devices; i++) {
deviceIDs[i] = devices.get();
}
return deviceIDs;
}
@Override
public String getProfile() {
return Info.clGetPlatformInfoStringASCII(platform.address(), CL10.CL_PLATFORM_PROFILE);
return Info.clGetPlatformInfoStringASCII(platform, CL10.CL_PLATFORM_PROFILE);
}
@Override
@ -87,7 +129,7 @@ public final class LwjglPlatform implements Platform {
@Override
public String getVersion() {
return Info.clGetPlatformInfoStringASCII(platform.address(), CL10.CL_PLATFORM_VERSION);
return Info.clGetPlatformInfoStringASCII(platform, CL10.CL_PLATFORM_VERSION);
}
@Override
@ -102,12 +144,12 @@ public final class LwjglPlatform implements Platform {
@Override
public String getName() {
return Info.clGetPlatformInfoStringASCII(platform.address(), CL10.CL_PLATFORM_NAME);
return Info.clGetPlatformInfoStringASCII(platform, CL10.CL_PLATFORM_NAME);
}
@Override
public String getVendor() {
return Info.clGetPlatformInfoStringASCII(platform.address(), CL10.CL_PLATFORM_VENDOR);
return Info.clGetPlatformInfoStringASCII(platform, CL10.CL_PLATFORM_VENDOR);
}
@Override
@ -122,7 +164,7 @@ public final class LwjglPlatform implements Platform {
@Override
public Collection<? extends String> getExtensions() {
return Arrays.asList(Info.clGetPlatformInfoStringASCII(platform.address(), CL10.CL_PLATFORM_EXTENSIONS).split(" "));
return Arrays.asList(Info.clGetPlatformInfoStringASCII(platform, CL10.CL_PLATFORM_EXTENSIONS).split(" "));
}
@Override

7
jme3-lwjgl3/src/main/java/com/jme3/opencl/lwjgl/LwjglProgram.java
View File

@ -32,14 +32,15 @@
package com.jme3.opencl.lwjgl;
import com.jme3.opencl.*;
import com.jme3.opencl.lwjgl.info.Info;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.lwjgl.BufferUtils;
import org.lwjgl.PointerBuffer;
import org.lwjgl.opencl.*;
import org.lwjgl.system.MemoryUtil;
import org.lwjgl.system.Pointer;
/**
*
@ -94,7 +95,7 @@ public class LwjglProgram extends Program {
final ByteBuffer buffer = BufferUtils.createByteBuffer(count);
ret = CL10.clGetProgramBuildInfo(program, device, CL10.CL_PROGRAM_BUILD_LOG, buffer, null);
Utils.checkError(ret, "clGetProgramBuildInfo");
return MemoryUtil.memDecodeASCII(buffer);
return MemoryUtil.memASCII(buffer);
}
private String Log() {
@ -123,7 +124,7 @@ public class LwjglProgram extends Program {
Utils.checkError(ret, "clCreateKernelsInProgram");
int count = Utils.tempBuffers[0].b16i.get(0);
PointerBuffer buf = PointerBuffer.allocateDirect(count);
ret = CL10.clCreateKernelsInProgram(program, buf, null);
ret = CL10.clCreateKernelsInProgram(program, buf, (IntBuffer) null);
Utils.checkError(ret, "clCreateKernelsInProgram");
Kernel[] kx = new Kernel[count];
for (int i=0; i<count; ++i) {

1
jme3-lwjgl3/src/main/java/com/jme3/opencl/lwjgl/Utils.java
View File

@ -34,6 +34,7 @@ package com.jme3.opencl.lwjgl;
import com.jme3.opencl.MappingAccess;
import com.jme3.opencl.MemoryAccess;
import com.jme3.opencl.OpenCLException;
import com.jme3.opencl.lwjgl.info.CLUtil;
import java.nio.*;
import java.util.logging.Level;
import java.util.logging.Logger;

106
jme3-lwjgl3/src/main/java/com/jme3/opencl/lwjgl/info/CLUtil.java Normal file
View File

@ -0,0 +1,106 @@
/*
* Copyright LWJGL. All rights reserved.
* License terms: http://lwjgl.org/license.php
*/
package com.jme3.opencl.lwjgl.info;
import com.jme3.lwjgl3.utils.APIUtil.TokenFilter;
import com.jme3.opencl.OpenCLException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.function.BiPredicate;
import org.lwjgl.opencl.CL10;
import static org.lwjgl.opencl.CL10.*;
import org.lwjgl.opencl.CL11;
import org.lwjgl.opencl.CL12;
import org.lwjgl.opencl.CL20;
import org.lwjgl.opencl.INTELAccelerator;
import org.lwjgl.opencl.KHRICD;
import static org.lwjgl.system.APIUtil.*;
public final class CLUtil {
/** Maps OpenCL error token values to their String representations. */
private static final Map<Integer, String> CL_ERROR_TOKENS = apiClassTokens(
new BiPredicate<Field, Integer>() {
private final List<String> EXCLUDE = Arrays.asList("CL_DEVICE_TYPE_ALL", "CL_BUILD_NONE", "CL_BUILD_ERROR", "CL_BUILD_IN_PROGRESS");
@Override
public boolean test(Field field, Integer value) {
return value < 0 && !EXCLUDE.contains(field.getName()); // OpenCL errors have negative values.
}
},
null,
CL10.class,
apiOptionalClass("org.lwjgl.opencl.CL10GL"),
CL11.class,
CL12.class,
CL20.class,
apiOptionalClass("org.lwjgl.opencl.APPLEGLSharing"),
INTELAccelerator.class,
apiOptionalClass("org.lwjgl.opencl.KHRGLSharing"),
apiOptionalClass("org.lwjgl.opencl.KHREGLEvent"),
apiOptionalClass("org.lwjgl.opencl.KHREGLImage"),
KHRICD.class
/*, EXTDeviceFission.class*/
);
private CLUtil() {}
/**
* Checks the {@code errcode} present in the current position of the specified {@code errcode_ret} buffer and throws an {@link OpenCLException} if it's not
* equal to {@link CL10#CL_SUCCESS}.
*
* @param errcode_ret the {@code errcode} buffer
*
* @throws OpenCLException
*/
public static void checkCLError(ByteBuffer errcode_ret) {
checkCLError(errcode_ret.getInt(errcode_ret.position()));
}
/**
* Checks the {@code errcode} present in the current position of the specified {@code errcode_ret} buffer and throws an {@link OpenCLException} if it's not
* equal to {@link CL10#CL_SUCCESS}.
*
* @param errcode_ret the {@code errcode} buffer
*
* @throws OpenCLException
*/
public static void checkCLError(IntBuffer errcode_ret) {
checkCLError(errcode_ret.get(errcode_ret.position()));
}
/**
* Checks the specified {@code errcode} and throws an {@link OpenCLException} if it's not equal to {@link CL10#CL_SUCCESS}.
*
* @param errcode the {@code errcode} to check
*
* @throws OpenCLException
*/
public static void checkCLError(int errcode) {
if ( errcode != CL_SUCCESS )
throw new OpenCLException(getErrcodeName(errcode));
}
/**
* Returns the token name of the specified {@code errcode}.
*
* @param errcode the {@code errcode}
*
* @return the {@code errcode} token name
*/
public static String getErrcodeName(int errcode) {
String errname = CL_ERROR_TOKENS.get(errcode);
if ( errname == null )
errname = apiUnknownToken(errcode);
return errname;
}
}

402
jme3-lwjgl3/src/main/java/com/jme3/opencl/lwjgl/info/Info.java Normal file
View File

@ -0,0 +1,402 @@
/*
* Copyright LWJGL. All rights reserved.
* License terms: http://lwjgl.org/license.php
* MACHINE GENERATED FILE, DO NOT EDIT
*/
package com.jme3.opencl.lwjgl.info;
import org.lwjgl.PointerBuffer;
import static org.lwjgl.opencl.CL10.*;
import static org.lwjgl.opencl.CL12.*;
import static org.lwjgl.opencl.CL20.*;
import static org.lwjgl.opencl.CL10GL.*;
/**
* This class provides methods that can be used to query information about OpenCL objects. These methods are similar to the corresponding
* {@code clGet&lt;Type&gt;Info} function for each object type, except that only a single value is returned. Which one of these methods should be used
* depends on the type of the information being queried.
*/
public final class Info {
private Info() {
}
// ------------------------------------
// Platform (CL10.clGetPlatformInfo)
// ------------------------------------
private static final InfoQuery PLATFORM = new InfoQuery() {
@Override
protected int get(long pointer, int param_name, long param_value_size, long param_value, long param_value_size_ret) {
return nclGetPlatformInfo(pointer, param_name, param_value_size, param_value, param_value_size_ret);
}
};
/** String version of: {@link CL10#clGetPlatformInfo GetPlatformInfo} */
public static String clGetPlatformInfoStringASCII(long platform, int param_name) { return PLATFORM.getStringASCII(platform, param_name); }
/** String with explicit length version of: {@link CL10#clGetPlatformInfo GetPlatformInfo}*/
public static String clGetPlatformInfoStringASCII(long platform, int param_name, int param_value_size) { return PLATFORM.getStringASCII(platform, param_name, param_value_size); }
/** UTF-8 string version of: {@link CL10#clGetPlatformInfo GetPlatformInfo} */
public static String clGetPlatformInfoStringUTF8(long platform, int param_name) { return PLATFORM.getStringUTF8(platform, param_name); }
/** UTF-8 string with explicit length version of: {@link CL10#clGetPlatformInfo GetPlatformInfo} */
public static String clGetPlatformInfoStringUTF8(long platform, int param_name, int param_value_size) { return PLATFORM.getStringUTF8(platform, param_name, param_value_size); }
// ------------------------------------
// Device (CL10.clGetDeviceInfo)
// ------------------------------------
private static final InfoQuery DEVICE = new InfoQuery() {
@Override
protected int get(long pointer, int param_name, long param_value_size, long param_value, long param_value_size_ret) {
return nclGetDeviceInfo(pointer, param_name, param_value_size, param_value, param_value_size_ret);
}
};
/** Single boolean value version of: {@link CL10#clGetDeviceInfo GetDeviceInfo} */
public static boolean clGetDeviceInfoBoolean(long device, int param_name) { return DEVICE.getBoolean(device, param_name); }
/** Single int value version of: {@link CL10#clGetDeviceInfo GetDeviceInfo} */
public static int clGetDeviceInfoInt(long device, int param_name) { return DEVICE.getInt(device, param_name); }
/** Single long value version of: {@link CL10#clGetDeviceInfo GetDeviceInfo} */
public static long clGetDeviceInfoLong(long device, int param_name) { return DEVICE.getLong(device, param_name); }
/** Single pointer value version of: {@link CL10#clGetDeviceInfo GetDeviceInfo} */
public static long clGetDeviceInfoPointer(long device, int param_name) { return DEVICE.getPointer(device, param_name); }
/** PointBuffer version of: {@link CL10#clGetDeviceInfo GetDeviceInfo} */
public static int clGetDeviceInfoPointers(long device, int param_name, PointerBuffer target) { return DEVICE.getPointers(device, param_name, target); }
/** String version of: {@link CL10#clGetDeviceInfo GetDeviceInfo} */
public static String clGetDeviceInfoStringASCII(long device, int param_name) { return DEVICE.getStringASCII(device, param_name); }
/** String with explicit length version of: {@link CL10#clGetDeviceInfo GetDeviceInfo}*/
public static String clGetDeviceInfoStringASCII(long device, int param_name, int param_value_size) { return DEVICE.getStringASCII(device, param_name, param_value_size); }
/** UTF-8 string version of: {@link CL10#clGetDeviceInfo GetDeviceInfo} */
public static String clGetDeviceInfoStringUTF8(long device, int param_name) { return DEVICE.getStringUTF8(device, param_name); }
/** UTF-8 string with explicit length version of: {@link CL10#clGetDeviceInfo GetDeviceInfo} */
public static String clGetDeviceInfoStringUTF8(long device, int param_name, int param_value_size) { return DEVICE.getStringUTF8(device, param_name, param_value_size); }
// ------------------------------------
// Context (CL10.clGetContextInfo)
// ------------------------------------
private static final InfoQuery CONTEXT = new InfoQuery() {
@Override
protected int get(long pointer, int param_name, long param_value_size, long param_value, long param_value_size_ret) {
return nclGetContextInfo(pointer, param_name, param_value_size, param_value, param_value_size_ret);
}
};
/** Single int value version of: {@link CL10#clGetContextInfo GetContextInfo} */
public static int clGetContextInfoInt(long context, int param_name) { return CONTEXT.getInt(context, param_name); }
/** Single pointer value version of: {@link CL10#clGetContextInfo GetContextInfo} */
public static long clGetContextInfoPointer(long context, int param_name) { return CONTEXT.getPointer(context, param_name); }
/** PointBuffer version of: {@link CL10#clGetContextInfo GetContextInfo} */
public static int clGetContextInfoPointers(long context, int param_name, PointerBuffer target) { return CONTEXT.getPointers(context, param_name, target); }
// ------------------------------------
// Command Queue (CL10.clGetCommandQueueInfo)
// ------------------------------------
private static final InfoQuery COMMAND_QUEUE = new InfoQuery() {
@Override
protected int get(long pointer, int param_name, long param_value_size, long param_value, long param_value_size_ret) {
return nclGetCommandQueueInfo(pointer, param_name, param_value_size, param_value, param_value_size_ret);
}
};
/** Single int value version of: {@link CL10#clGetCommandQueueInfo GetCommandQueueInfo} */
public static int clGetCommandQueueInfoInt(long command_queue, int param_name) { return COMMAND_QUEUE.getInt(command_queue, param_name); }
/** Single pointer value version of: {@link CL10#clGetCommandQueueInfo GetCommandQueueInfo} */
public static long clGetCommandQueueInfoPointer(long command_queue, int param_name) { return COMMAND_QUEUE.getPointer(command_queue, param_name); }
/** PointBuffer version of: {@link CL10#clGetCommandQueueInfo GetCommandQueueInfo} */
public static int clGetCommandQueueInfoPointers(long command_queue, int param_name, PointerBuffer target) { return COMMAND_QUEUE.getPointers(command_queue, param_name, target); }
// ------------------------------------
// Mem Object (CL10.clGetMemObjectInfo)
// ------------------------------------
private static final InfoQuery MEM_OBJECT = new InfoQuery() {
@Override
protected int get(long pointer, int param_name, long param_value_size, long param_value, long param_value_size_ret) {
return nclGetMemObjectInfo(pointer, param_name, param_value_size, param_value, param_value_size_ret);
}
};
/** Single boolean value version of: {@link CL10#clGetMemObjectInfo GetMemObjectInfo} */
public static boolean clGetMemObjectInfoBoolean(long memobj, int param_name) { return MEM_OBJECT.getBoolean(memobj, param_name); }
/** Single int value version of: {@link CL10#clGetMemObjectInfo GetMemObjectInfo} */
public static int clGetMemObjectInfoInt(long memobj, int param_name) { return MEM_OBJECT.getInt(memobj, param_name); }
/** Single long value version of: {@link CL10#clGetMemObjectInfo GetMemObjectInfo} */
public static long clGetMemObjectInfoLong(long memobj, int param_name) { return MEM_OBJECT.getLong(memobj, param_name); }
/** Single pointer value version of: {@link CL10#clGetMemObjectInfo GetMemObjectInfo} */
public static long clGetMemObjectInfoPointer(long memobj, int param_name) { return MEM_OBJECT.getPointer(memobj, param_name); }
/** PointBuffer version of: {@link CL10#clGetMemObjectInfo GetMemObjectInfo} */
public static int clGetMemObjectInfoPointers(long memobj, int param_name, PointerBuffer target) { return MEM_OBJECT.getPointers(memobj, param_name, target); }
// ------------------------------------
// Image (CL10.clGetImageInfo)
// ------------------------------------
private static final InfoQuery IMAGE = new InfoQuery() {
@Override
protected int get(long pointer, int param_name, long param_value_size, long param_value, long param_value_size_ret) {
return nclGetImageInfo(pointer, param_name, param_value_size, param_value, param_value_size_ret);
}
};
/** Single int value version of: {@link CL10#clGetImageInfo GetImageInfo} */
public static int clGetImageInfoInt(long image, int param_name) { return IMAGE.getInt(image, param_name); }
/** Single pointer value version of: {@link CL10#clGetImageInfo GetImageInfo} */
public static long clGetImageInfoPointer(long image, int param_name) { return IMAGE.getPointer(image, param_name); }
/** PointBuffer version of: {@link CL10#clGetImageInfo GetImageInfo} */
public static int clGetImageInfoPointers(long image, int param_name, PointerBuffer target) { return IMAGE.getPointers(image, param_name, target); }
// ------------------------------------
// Pipe (CL20.clGetPipeInfo)
// ------------------------------------
private static final InfoQuery PIPE = new InfoQuery() {
@Override
protected int get(long pointer, int param_name, long param_value_size, long param_value, long param_value_size_ret) {
return nclGetPipeInfo(pointer, param_name, param_value_size, param_value, param_value_size_ret);
}
};
/** Single int value version of: {@link CL20#clGetPipeInfo GetPipeInfo} */
public static int clGetPipeInfoInt(long pipe, int param_name) { return PIPE.getInt(pipe, param_name); }
// ------------------------------------
// Program (CL10.clGetProgramInfo)
// ------------------------------------
private static final InfoQuery PROGRAM = new InfoQuery() {
@Override
protected int get(long pointer, int param_name, long param_value_size, long param_value, long param_value_size_ret) {
return nclGetProgramInfo(pointer, param_name, param_value_size, param_value, param_value_size_ret);
}
};
/** Single int value version of: {@link CL10#clGetProgramInfo GetProgramInfo} */
public static int clGetProgramInfoInt(long program, int param_name) { return PROGRAM.getInt(program, param_name); }
/** Single pointer value version of: {@link CL10#clGetProgramInfo GetProgramInfo} */
public static long clGetProgramInfoPointer(long program, int param_name) { return PROGRAM.getPointer(program, param_name); }
/** PointBuffer version of: {@link CL10#clGetProgramInfo GetProgramInfo} */
public static int clGetProgramInfoPointers(long program, int param_name, PointerBuffer target) { return PROGRAM.getPointers(program, param_name, target); }
/** String version of: {@link CL10#clGetProgramInfo GetProgramInfo} */
public static String clGetProgramInfoStringASCII(long program, int param_name) { return PROGRAM.getStringASCII(program, param_name); }
/** String with explicit length version of: {@link CL10#clGetProgramInfo GetProgramInfo}*/
public static String clGetProgramInfoStringASCII(long program, int param_name, int param_value_size) { return PROGRAM.getStringASCII(program, param_name, param_value_size); }
/** UTF-8 string version of: {@link CL10#clGetProgramInfo GetProgramInfo} */
public static String clGetProgramInfoStringUTF8(long program, int param_name) { return PROGRAM.getStringUTF8(program, param_name); }
/** UTF-8 string with explicit length version of: {@link CL10#clGetProgramInfo GetProgramInfo} */
public static String clGetProgramInfoStringUTF8(long program, int param_name, int param_value_size) { return PROGRAM.getStringUTF8(program, param_name, param_value_size); }
// ------------------------------------
// Program Build (CL10.clGetProgramBuildInfo)
// ------------------------------------
private static final InfoQueryObject PROGRAM_BUILD = new InfoQueryObject() {
@Override
protected int get(long pointer, long arg, int param_name, long param_value_size, long param_value, long param_value_size_ret) {
return nclGetProgramBuildInfo(pointer, arg, param_name, param_value_size, param_value, param_value_size_ret);
}
};
/** Single int value version of: {@link CL10#clGetProgramBuildInfo GetProgramBuildInfo} */
public static int clGetProgramBuildInfoInt(long program, long device, int param_name) { return PROGRAM_BUILD.getInt(program, device, param_name); }
/** Single pointer value version of: {@link CL10#clGetProgramBuildInfo GetProgramBuildInfo} */
public static long clGetProgramBuildInfoPointer(long program, long device, int param_name) { return PROGRAM_BUILD.getPointer(program, device, param_name); }
/** PointBuffer version of: {@link CL10#clGetProgramBuildInfo GetProgramBuildInfo} */
public static int clGetProgramBuildInfoPointers(long program, long device, int param_name, PointerBuffer target) { return PROGRAM_BUILD.getPointers(program, device, param_name, target); }
/** String version of: {@link CL10#clGetProgramBuildInfo GetProgramBuildInfo} */
public static String clGetProgramBuildInfoStringASCII(long program, long device, int param_name) { return PROGRAM_BUILD.getStringASCII(program, device, param_name); }
/** String with explicit length version of: {@link CL10#clGetProgramBuildInfo GetProgramBuildInfo}*/
public static String clGetProgramBuildInfoStringASCII(long program, long device, int param_name, int param_value_size) { return PROGRAM_BUILD.getStringASCII(program, device, param_name, param_value_size); }
/** UTF-8 string version of: {@link CL10#clGetProgramBuildInfo GetProgramBuildInfo} */
public static String clGetProgramBuildInfoStringUTF8(long program, long device, int param_name) { return PROGRAM_BUILD.getStringUTF8(program, device, param_name); }
/** UTF-8 string with explicit length version of: {@link CL10#clGetProgramBuildInfo GetProgramBuildInfo} */
public static String clGetProgramBuildInfoStringUTF8(long program, long device, int param_name, int param_value_size) { return PROGRAM_BUILD.getStringUTF8(program, device, param_name, param_value_size); }
// ------------------------------------
// Kernel (CL10.clGetKernelInfo)
// ------------------------------------
private static final InfoQuery KERNEL = new InfoQuery() {
@Override
protected int get(long pointer, int param_name, long param_value_size, long param_value, long param_value_size_ret) {
return nclGetKernelInfo(pointer, param_name, param_value_size, param_value, param_value_size_ret);
}
};
/** Single int value version of: {@link CL10#clGetKernelInfo GetKernelInfo} */
public static int clGetKernelInfoInt(long kernel, int param_name) { return KERNEL.getInt(kernel, param_name); }
/** Single pointer value version of: {@link CL10#clGetKernelInfo GetKernelInfo} */
public static long clGetKernelInfoPointer(long kernel, int param_name) { return KERNEL.getPointer(kernel, param_name); }
/** PointBuffer version of: {@link CL10#clGetKernelInfo GetKernelInfo} */
public static int clGetKernelInfoPointers(long kernel, int param_name, PointerBuffer target) { return KERNEL.getPointers(kernel, param_name, target); }
/** String version of: {@link CL10#clGetKernelInfo GetKernelInfo} */
public static String clGetKernelInfoStringASCII(long kernel, int param_name) { return KERNEL.getStringASCII(kernel, param_name); }
/** String with explicit length version of: {@link CL10#clGetKernelInfo GetKernelInfo}*/
public static String clGetKernelInfoStringASCII(long kernel, int param_name, int param_value_size) { return KERNEL.getStringASCII(kernel, param_name, param_value_size); }
/** UTF-8 string version of: {@link CL10#clGetKernelInfo GetKernelInfo} */
public static String clGetKernelInfoStringUTF8(long kernel, int param_name) { return KERNEL.getStringUTF8(kernel, param_name); }
/** UTF-8 string with explicit length version of: {@link CL10#clGetKernelInfo GetKernelInfo} */
public static String clGetKernelInfoStringUTF8(long kernel, int param_name, int param_value_size) { return KERNEL.getStringUTF8(kernel, param_name, param_value_size); }
// ------------------------------------
// Kernel WorkGroup (CL10.clGetKernelWorkGroupInfo)
// ------------------------------------
private static final InfoQueryObject KERNEL_WORKGROUP = new InfoQueryObject() {
@Override
protected int get(long pointer, long arg, int param_name, long param_value_size, long param_value, long param_value_size_ret) {
return nclGetKernelWorkGroupInfo(pointer, arg, param_name, param_value_size, param_value, param_value_size_ret);
}
};
/** Single long value version of: {@link CL10#clGetKernelWorkGroupInfo GetKernelWorkGroupInfo} */
public static long clGetKernelWorkGroupInfoLong(long kernel, long device, int param_name) { return KERNEL_WORKGROUP.getLong(kernel, device, param_name); }
/** Single pointer value version of: {@link CL10#clGetKernelWorkGroupInfo GetKernelWorkGroupInfo} */
public static long clGetKernelWorkGroupInfoPointer(long kernel, long device, int param_name) { return KERNEL_WORKGROUP.getPointer(kernel, device, param_name); }
/** PointBuffer version of: {@link CL10#clGetKernelWorkGroupInfo GetKernelWorkGroupInfo} */
public static int clGetKernelWorkGroupInfoPointers(long kernel, long device, int param_name, PointerBuffer target) { return KERNEL_WORKGROUP.getPointers(kernel, device, param_name, target); }
// ------------------------------------
// Kernel Arg (CL12.clGetKernelArgInfo)
// ------------------------------------
private static final InfoQueryInt KERNEL_ARG = new InfoQueryInt() {
@Override
protected int get(long pointer, int arg, int param_name, long param_value_size, long param_value, long param_value_size_ret) {
return nclGetKernelArgInfo(pointer, arg, param_name, param_value_size, param_value, param_value_size_ret);
}
};
/** Single int value version of: {@link CL12#clGetKernelArgInfo GetKernelArgInfo} */
public static int clGetKernelArgInfoInt(long kernel, int arg_indx, int param_name) { return KERNEL_ARG.getInt(kernel, arg_indx, param_name); }
/** Single long value version of: {@link CL12#clGetKernelArgInfo GetKernelArgInfo} */
public static long clGetKernelArgInfoLong(long kernel, int arg_indx, int param_name) { return KERNEL_ARG.getLong(kernel, arg_indx, param_name); }
/** String version of: {@link CL12#clGetKernelArgInfo GetKernelArgInfo} */
public static String clGetKernelArgInfoStringASCII(long kernel, int arg_indx, int param_name) { return KERNEL_ARG.getStringASCII(kernel, arg_indx, param_name); }
/** String with explicit length version of: {@link CL12#clGetKernelArgInfo GetKernelArgInfo}*/
public static String clGetKernelArgInfoStringASCII(long kernel, int arg_indx, int param_name, int param_value_size) { return KERNEL_ARG.getStringASCII(kernel, arg_indx, param_name, param_value_size); }
/** UTF-8 string version of: {@link CL12#clGetKernelArgInfo GetKernelArgInfo} */
public static String clGetKernelArgInfoStringUTF8(long kernel, int arg_indx, int param_name) { return KERNEL_ARG.getStringUTF8(kernel, arg_indx, param_name); }
/** UTF-8 string with explicit length version of: {@link CL12#clGetKernelArgInfo GetKernelArgInfo} */
public static String clGetKernelArgInfoStringUTF8(long kernel, int arg_indx, int param_name, int param_value_size) { return KERNEL_ARG.getStringUTF8(kernel, arg_indx, param_name, param_value_size); }
// ------------------------------------
// Sampler (CL10.clGetSamplerInfo)
// ------------------------------------
private static final InfoQuery SAMPLER = new InfoQuery() {
@Override
protected int get(long pointer, int param_name, long param_value_size, long param_value, long param_value_size_ret) {
return nclGetSamplerInfo(pointer, param_name, param_value_size, param_value, param_value_size_ret);
}
};
/** Single boolean value version of: {@link CL10#clGetSamplerInfo GetSamplerInfo} */
public static boolean clGetSamplerInfoBoolean(long sampler, int param_name) { return SAMPLER.getBoolean(sampler, param_name); }
/** Single int value version of: {@link CL10#clGetSamplerInfo GetSamplerInfo} */
public static int clGetSamplerInfoInt(long sampler, int param_name) { return SAMPLER.getInt(sampler, param_name); }
/** Single pointer value version of: {@link CL10#clGetSamplerInfo GetSamplerInfo} */
public static long clGetSamplerInfoPointer(long sampler, int param_name) { return SAMPLER.getPointer(sampler, param_name); }
/** PointBuffer version of: {@link CL10#clGetSamplerInfo GetSamplerInfo} */
public static int clGetSamplerInfoPointers(long sampler, int param_name, PointerBuffer target) { return SAMPLER.getPointers(sampler, param_name, target); }
// ------------------------------------
// Event (CL10.clGetEventInfo)
// ------------------------------------
private static final InfoQuery EVENT = new InfoQuery() {
@Override
protected int get(long pointer, int param_name, long param_value_size, long param_value, long param_value_size_ret) {
return nclGetEventInfo(pointer, param_name, param_value_size, param_value, param_value_size_ret);
}
};
/** Single int value version of: {@link CL10#clGetEventInfo GetEventInfo} */
public static int clGetEventInfoInt(long event, int param_name) { return EVENT.getInt(event, param_name); }
/** Single pointer value version of: {@link CL10#clGetEventInfo GetEventInfo} */
public static long clGetEventInfoPointer(long event, int param_name) { return EVENT.getPointer(event, param_name); }
/** PointBuffer version of: {@link CL10#clGetEventInfo GetEventInfo} */
public static int clGetEventInfoPointers(long event, int param_name, PointerBuffer target) { return EVENT.getPointers(event, param_name, target); }
// ------------------------------------
// Event Profiling (CL10.clGetEventProfilingInfo)
// ------------------------------------
private static final InfoQuery EVENT_PROFILING = new InfoQuery() {
@Override
protected int get(long pointer, int param_name, long param_value_size, long param_value, long param_value_size_ret) {
return nclGetEventProfilingInfo(pointer, param_name, param_value_size, param_value, param_value_size_ret);
}
};
/** Single long value version of: {@link CL10#clGetEventProfilingInfo GetEventProfilingInfo} */
public static long clGetEventProfilingInfoLong(long event, int param_name) { return EVENT_PROFILING.getLong(event, param_name); }
// ------------------------------------
// GL Texture (CL10GL.clGetGLTextureInfo)
// ------------------------------------
private static final InfoQuery GL_TEXTURE = new InfoQuery() {
@Override
protected int get(long pointer, int param_name, long param_value_size, long param_value, long param_value_size_ret) {
return nclGetGLTextureInfo(pointer, param_name, param_value_size, param_value, param_value_size_ret);
}
};
/** Single int value version of: {@link CL10GL#clGetGLTextureInfo GetGLTextureInfo} */
public static int clGetGLTextureInfoInt(long memobj, int param_name) { return GL_TEXTURE.getInt(memobj, param_name); }
}

196
jme3-lwjgl3/src/main/java/com/jme3/opencl/lwjgl/info/InfoQuery.java Normal file
View File

@ -0,0 +1,196 @@
/*
* Copyright LWJGL. All rights reserved.
* License terms: http://lwjgl.org/license.php
*/
package com.jme3.opencl.lwjgl.info;
import com.jme3.lwjgl3.utils.APIBuffer;
import static com.jme3.lwjgl3.utils.APIUtil.apiBuffer;
import static com.jme3.opencl.lwjgl.info.CLUtil.checkCLError;
import org.lwjgl.PointerBuffer;
import static org.lwjgl.system.Checks.*;
import static org.lwjgl.system.MemoryUtil.*;
import static org.lwjgl.system.Pointer.*;
/**
* Base class for OpenCL object information queries.
* <p/>
* All methods require the object being queried (a pointer value) and the integer parameter name.
*
* @see Info
*/
abstract class InfoQuery {
protected abstract int get(long pointer, int param_name, long param_value_size, long param_value, long param_value_size_ret);
InfoQuery() {
}
/**
* Returns the integer value for the specified {@code param_name}, converted to a boolean.
*
* @param object the object to query
* @param param_name the parameter to query
*
* @return the parameter's boolean value
*/
boolean getBoolean(long object, int param_name) {
return getInt(object, param_name) != 0;
}
/**
* Returns the integer value for the specified {@code param_name}.
* <p/>
* For integer parameters that may be 32 or 64 bits (e.g. {@code size_t}), {@link #getPointer} should be used instead.
*
* @param object the object to query
* @param param_name the parameter to query
*
* @return the parameter's int value
*/
int getInt(long object, int param_name) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, param_name, 4L, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return __buffer.intValue(0);
}
/**
* Returns the long value for the specified {@code param_name}.
* <p/>
* For integer parameters that may be 32 or 64 bits (e.g. {@code size_t}), {@link #getPointer} should be used instead.
*
* @param object the object to query
* @param param_name the parameter to query
*
* @return the parameter's long value
*/
long getLong(long object, int param_name) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, param_name, 8L, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return __buffer.longValue(0);
}
/**
* Returns the pointer value for the specified {@code param_name}.
* <p/>
* This method should also be used for integer parameters that may be 32 or 64 bits (e.g. {@code size_t}).
*
* @param object the object to query
* @param param_name the parameter to query
*
* @return the parameter's pointer value
*/
long getPointer(long object, int param_name) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, param_name, POINTER_SIZE, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return __buffer.pointerValue(0);
}
/**
* Writes the pointer list for the specified {@code param_name} into {@code target}.
* <p/>
* This method should also be used for integer parameters that may be 32 or 64 bits (e.g. {@code size_t}).
*
* @param object the object to query
* @param param_name the parameter to query
* @param target the buffer in which to put the returned pointer list
*
* @return how many pointers were actually returned
*/
int getPointers(long object, int param_name, PointerBuffer target) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, param_name, target.remaining() * POINTER_SIZE, memAddress(target), __buffer.address());
if ( DEBUG )
checkCLError(errcode);
return (int)(__buffer.pointerValue(0) >> POINTER_SHIFT);
}
/**
* Returns the string value for the specified {@code param_name}. The raw bytes returned are assumed to be ASCII encoded.
*
* @param object the object to query
* @param param_name the parameter to query
*
* @return the parameter's string value
*/
String getStringASCII(long object, int param_name) {
APIBuffer __buffer = apiBuffer();
int bytes = getString(object, param_name, __buffer);
return __buffer.stringValueASCII(0, bytes);
}
/**
* Returns the string value for the specified {@code param_name}. The raw bytes returned are assumed to be ASCII encoded and have length equal to {@code
* param_value_size}.
*
* @param object the object to query
* @param param_name the parameter to query
* @param param_value_size the explicit string length
*
* @return the parameter's string value
*/
String getStringASCII(long object, int param_name, int param_value_size) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, param_name, param_value_size, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return __buffer.stringValueASCII(0, param_value_size);
}
/**
* Returns the string value for the specified {@code param_name}. The raw bytes returned are assumed to be UTF-8 encoded.
*
* @param object the object to query
* @param param_name the parameter to query
*
* @return the parameter's string value
*/
String getStringUTF8(long object, int param_name) {
APIBuffer __buffer = apiBuffer();
int bytes = getString(object, param_name, __buffer);
return __buffer.stringValueUTF8(0, bytes);
}
/**
* Returns the string value for the specified {@code param_name}. The raw bytes returned are assumed to be UTF-8 encoded and have length equal to {@code
* param_value_size}.
*
* @param object the object to query
* @param param_name the parameter to query
* @param param_value_size the explicit string length
*
* @return the parameter's string value
*/
String getStringUTF8(long object, int param_name, int param_value_size) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, param_name, param_value_size, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return __buffer.stringValueUTF8(0, param_value_size);
}
private int getString(long object, int param_name, APIBuffer __buffer) {
// Get string length
int errcode = get(object, param_name, 0, NULL, __buffer.address());
if ( DEBUG )
checkCLError(errcode);
int bytes = (int)__buffer.pointerValue(0);
__buffer.bufferParam(bytes);
// Get string
errcode = get(object, param_name, bytes, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return bytes - 1; // all OpenCL char[] parameters are null-terminated
}
}

205
jme3-lwjgl3/src/main/java/com/jme3/opencl/lwjgl/info/InfoQueryInt.java Normal file
View File

@ -0,0 +1,205 @@
/*
* Copyright LWJGL. All rights reserved.
* License terms: http://lwjgl.org/license.php
*/
package com.jme3.opencl.lwjgl.info;
import com.jme3.lwjgl3.utils.APIBuffer;
import static com.jme3.lwjgl3.utils.APIUtil.apiBuffer;
import static com.jme3.opencl.lwjgl.info.CLUtil.checkCLError;
import org.lwjgl.PointerBuffer;
import static org.lwjgl.system.Checks.*;
import static org.lwjgl.system.MemoryUtil.*;
import static org.lwjgl.system.Pointer.*;
/**
* Base class for OpenCL object information queries.
* <p/>
* All methods require the object being queried (a pointer value), a second integer argument and the integer parameter name.
*
* @see Info
*/
abstract class InfoQueryInt {
protected abstract int get(long pointer, int arg, int param_name, long param_value_size, long param_value, long param_value_size_ret);
InfoQueryInt() {
}
/**
* Returns the integer value for the specified {@code param_name}, converted to a boolean.
*
* @param object the object to query
* @param arg an integer argument
* @param param_name the parameter to query
*
* @return the parameter's boolean value
*/
boolean getBoolean(long object, int arg, int param_name) {
return getInt(object, arg, param_name) != 0;
}
/**
* Returns the integer value for the specified {@code param_name}.
* <p/>
* For integer parameters that may be 32 or 64 bits (e.g. {@code size_t}), {@link #getPointer} should be used instead.
*
* @param object the object to query
* @param arg an integer argument
* @param param_name the parameter to query
*
* @return the parameter's int value
*/
int getInt(long object, int arg, int param_name) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, arg, param_name, 4L, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return __buffer.intValue(0);
}
/**
* Returns the long value for the specified {@code param_name}.
* <p/>
* For integer parameters that may be 32 or 64 bits (e.g. {@code size_t}), {@link #getPointer} should be used instead.
*
* @param object the object to query
* @param arg an integer argument
* @param param_name the parameter to query
*
* @return the parameter's long value
*/
long getLong(long object, int arg, int param_name) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, arg, param_name, 8L, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return __buffer.longValue(0);
}
/**
* Returns the pointer value for the specified {@code param_name}.
* <p/>
* This method should also be used for integer parameters that may be 32 or 64 bits (e.g. {@code size_t}).
*
* @param object the object to query
* @param arg an integer argument
* @param param_name the parameter to query
*
* @return the parameter's pointer value
*/
long getPointer(long object, int arg, int param_name) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, arg, param_name, POINTER_SIZE, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return __buffer.pointerValue(0);
}
/**
* Writes the pointer list for the specified {@code param_name} into {@code target}.
* <p/>
* This method should also be used for integer parameters that may be 32 or 64 bits (e.g. {@code size_t}).
*
* @param object the object to query
* @param arg an integer argument
* @param param_name the parameter to query
* @param target the buffer in which to put the returned pointer list
*
* @return how many pointers were actually returned
*/
int getPointers(long object, int arg, int param_name, PointerBuffer target) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, arg, param_name, target.remaining() * POINTER_SIZE, memAddress(target), __buffer.address());
if ( DEBUG )
checkCLError(errcode);
return (int)(__buffer.pointerValue(0) >> POINTER_SHIFT);
}
/**
* Returns the string value for the specified {@code param_name}. The raw bytes returned are assumed to be ASCII encoded.
*
* @param object the object to query
* @param arg an integer argument
* @param param_name the parameter to query
*
* @return the parameter's string value
*/
String getStringASCII(long object, int arg, int param_name) {
APIBuffer __buffer = apiBuffer();
int bytes = getString(object, arg, param_name, __buffer);
return __buffer.stringValueASCII(0, bytes);
}
/**
* Returns the string value for the specified {@code param_name}. The raw bytes returned are assumed to be ASCII encoded and have length equal to {@code
* param_value_size}.
*
* @param object the object to query
* @param arg an integer argument
* @param param_name the parameter to query
* @param param_value_size the explicit string length
*
* @return the parameter's string value
*/
String getStringASCII(long object, int arg, int param_name, int param_value_size) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, arg, param_name, param_value_size, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return __buffer.stringValueASCII(0, param_value_size);
}
/**
* Returns the string value for the specified {@code param_name}. The raw bytes returned are assumed to be UTF-8 encoded.
*
* @param object the object to query
* @param arg an integer argument
* @param param_name the parameter to query
*
* @return the parameter's string value
*/
String getStringUTF8(long object, int arg, int param_name) {
APIBuffer __buffer = apiBuffer();
int bytes = getString(object, arg, param_name, __buffer);
return __buffer.stringValueUTF8(0, bytes);
}
/**
* Returns the string value for the specified {@code param_name}. The raw bytes returned are assumed to be UTF-8 encoded and have length equal to {@code
* param_value_size}.
*
* @param object the object to query
* @param arg an integer argument
* @param param_name the parameter to query
* @param param_value_size the explicit string length
*
* @return the parameter's string value
*/
String getStringUTF8(long object, int arg, int param_name, int param_value_size) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, arg, param_name, param_value_size, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return __buffer.stringValueUTF8(0, param_value_size);
}
private int getString(long object, int arg, int param_name, APIBuffer __buffer) {
// Get string length
int errcode = get(object, arg, param_name, 0, NULL, __buffer.address());
if ( DEBUG )
checkCLError(errcode);
int bytes = (int)__buffer.pointerValue(0);
__buffer.bufferParam(bytes + POINTER_SIZE);
// Get string
errcode = get(object, arg, param_name, bytes, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return bytes - 1; // all OpenCL char[] parameters are null-terminated
}
}

205
jme3-lwjgl3/src/main/java/com/jme3/opencl/lwjgl/info/InfoQueryObject.java Normal file
View File

@ -0,0 +1,205 @@
/*
* Copyright LWJGL. All rights reserved.
* License terms: http://lwjgl.org/license.php
*/
package com.jme3.opencl.lwjgl.info;
import com.jme3.lwjgl3.utils.APIBuffer;
import static com.jme3.lwjgl3.utils.APIUtil.apiBuffer;
import static com.jme3.opencl.lwjgl.info.CLUtil.checkCLError;
import org.lwjgl.PointerBuffer;
import static org.lwjgl.system.Checks.*;
import static org.lwjgl.system.MemoryUtil.*;
import static org.lwjgl.system.Pointer.*;
/**
* Base class for OpenCL object information queries.
* <p/>
* All methods require the object being queried (a pointer value), a second object argument (another pointer value) and the integer parameter name.
*
* @see org.lwjgl.opencl.Info
*/
abstract class InfoQueryObject {
protected abstract int get(long pointer, long arg, int param_name, long param_value_size, long param_value, long param_value_size_ret);
InfoQueryObject() {
}
/**
* Returns the integer value for the specified {@code param_name}, converted to a boolean.
*
* @param object the object to query
* @param arg an object argument
* @param param_name the parameter to query
*
* @return the parameter's boolean value
*/
boolean getBoolean(long object, long arg, int param_name) {
return getInt(object, arg, param_name) != 0;
}
/**
* Returns the integer value for the specified {@code param_name}.
* <p/>
* For integer parameters that may be 32 or 64 bits (e.g. {@code size_t}), {@link #getPointer} should be used instead.
*
* @param object the object to query
* @param arg an object argument
* @param param_name the parameter to query
*
* @return the parameter's int value
*/
int getInt(long object, long arg, int param_name) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, arg, param_name, 4L, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return __buffer.intValue(0);
}
/**
* Returns the long value for the specified {@code param_name}.
* <p/>
* For integer parameters that may be 32 or 64 bits (e.g. {@code size_t}), {@link #getPointer} should be used instead.
*
* @param object the object to query
* @param arg an object argument
* @param param_name the parameter to query
*
* @return the parameter's long value
*/
long getLong(long object, long arg, int param_name) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, arg, param_name, 8L, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return __buffer.longValue(0);
}
/**
* Returns the pointer value for the specified {@code param_name}.
* <p/>
* This method should also be used for integer parameters that may be 32 or 64 bits (e.g. {@code size_t}).
*
* @param object the object to query
* @param arg an object argument
* @param param_name the parameter to query
*
* @return the parameter's pointer value
*/
long getPointer(long object, long arg, int param_name) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, arg, param_name, POINTER_SIZE, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return __buffer.pointerValue(0);
}
/**
* Writes the pointer list for the specified {@code param_name} into {@code target}.
* <p/>
* This method should also be used for integer parameters that may be 32 or 64 bits (e.g. {@code size_t}).
*
* @param object the object to query
* @param arg an object argument
* @param param_name the parameter to query
* @param target the buffer in which to put the returned pointer list
*
* @return how many pointers were actually returned
*/
int getPointers(long object, long arg, int param_name, PointerBuffer target) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, arg, param_name, target.remaining() * POINTER_SIZE, memAddress(target), __buffer.address());
if ( DEBUG )
checkCLError(errcode);
return (int)(__buffer.pointerValue(0) >> POINTER_SHIFT);
}
/**
* Returns the string value for the specified {@code param_name}. The raw bytes returned are assumed to be ASCII encoded.
*
* @param object the object to query
* @param arg an object argument
* @param param_name the parameter to query
*
* @return the parameter's string value
*/
String getStringASCII(long object, long arg, int param_name) {
APIBuffer __buffer = apiBuffer();
int bytes = getString(object, arg, param_name, __buffer);
return __buffer.stringValueASCII(0, bytes);
}
/**
* Returns the string value for the specified {@code param_name}. The raw bytes returned are assumed to be ASCII encoded and have length equal to {@code
* param_value_size}.
*
* @param object the object to query
* @param arg an object argument
* @param param_name the parameter to query
* @param param_value_size the explicit string length
*
* @return the parameter's string value
*/
String getStringASCII(long object, long arg, int param_name, int param_value_size) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, arg, param_name, param_value_size, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return __buffer.stringValueASCII(0, param_value_size);
}
/**
* Returns the string value for the specified {@code param_name}. The raw bytes returned are assumed to be UTF-8 encoded.
*
* @param object the object to query
* @param arg an object argument
* @param param_name the parameter to query
*
* @return the parameter's string value
*/
String getStringUTF8(long object, long arg, int param_name) {
APIBuffer __buffer = apiBuffer();
int bytes = getString(object, arg, param_name, __buffer);
return __buffer.stringValueUTF8(0, bytes);
}
/**
* Returns the string value for the specified {@code param_name}. The raw bytes returned are assumed to be UTF-8 encoded and have length equal to {@code
* param_value_size}.
*
* @param object the object to query
* @param arg an object argument
* @param param_name the parameter to query
* @param param_value_size the explicit string length
*
* @return the parameter's string value
*/
String getStringUTF8(long object, long arg, int param_name, int param_value_size) {
APIBuffer __buffer = apiBuffer();
int errcode = get(object, arg, param_name, param_value_size, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return __buffer.stringValueUTF8(0, param_value_size);
}
private int getString(long object, long arg, int param_name, APIBuffer __buffer) {
// Get string length
int errcode = get(object, arg, param_name, 0, NULL, __buffer.address());
if ( DEBUG )
checkCLError(errcode);
int bytes = (int)__buffer.pointerValue(0);
__buffer.bufferParam(bytes + POINTER_SIZE);
// Get string
errcode = get(object, arg, param_name, bytes, __buffer.address(), NULL);
if ( DEBUG )
checkCLError(errcode);
return bytes - 1; // all OpenCL char[] parameters are null-terminated
}
}

50
jme3-lwjgl3/src/main/java/com/jme3/system/lwjgl/LwjglContext.java
View File

@ -50,6 +50,7 @@ import com.jme3.renderer.lwjgl.LwjglGLFboEXT;
import com.jme3.renderer.lwjgl.LwjglGLFboGL3;
import com.jme3.renderer.opengl.*;
import com.jme3.system.*;
import java.nio.IntBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
@ -105,9 +106,9 @@ public abstract class LwjglContext implements JmeContext {
protected int determineMaxSamples() {
// If we already have a valid context, determine samples using current context.
if (GLFW.glfwExtensionSupported("GL_ARB_framebuffer_object") == GLFW_TRUE) {
if (GLFW.glfwExtensionSupported("GL_ARB_framebuffer_object")) {
return glGetInteger(ARBFramebufferObject.GL_MAX_SAMPLES);
} else if (GLFW.glfwExtensionSupported("GL_EXT_framebuffer_multisample") == GLFW_TRUE) {
} else if (GLFW.glfwExtensionSupported("GL_EXT_framebuffer_multisample")) {
return glGetInteger(EXTFramebufferMultisample.GL_MAX_SAMPLES_EXT);
}
@ -197,7 +198,40 @@ public abstract class LwjglContext implements JmeContext {
renderable.set(true);
}
/**
* Returns a list of the available platforms, filtered by the specified
* filter.
*
* Copied from the old release
*
* @param filter the platform filter
*
* @return the available platforms
*/
private static long[] getPlatforms() {
int[] count = new int[1];
int errcode = CL10.clGetPlatformIDs(null, count);
Utils.checkError(errcode, "clGetDeviceIDs");
int num_platforms = count[0];
if (num_platforms == 0) {
return new long[0];
}
PointerBuffer platforms = PointerBuffer.allocateDirect(num_platforms);
errcode = CL10.clGetPlatformIDs(platforms, (IntBuffer) null);
Utils.checkError(errcode, "clGetDeviceIDs");
platforms.rewind();
long[] platformIDs = new long[num_platforms];
for (int i = 0; i < num_platforms; i++) {
platformIDs[i] = platforms.get();
}
return platformIDs;
}
protected void initOpenCL(long window) {
logger.info("Initialize OpenCL with LWJGL3");
@ -211,7 +245,7 @@ public abstract class LwjglContext implements JmeContext {
//load platforms and devices
StringBuilder platformInfos = new StringBuilder();
ArrayList<LwjglPlatform> platforms = new ArrayList<>();
for (CLPlatform p : CLPlatform.getPlatforms()) {
for (long p : getPlatforms()) {
platforms.add(new LwjglPlatform(p));
}
platformInfos.append("Available OpenCL platforms:");
@ -260,7 +294,7 @@ public abstract class LwjglContext implements JmeContext {
chooser = new DefaultPlatformChooser();
}
List<? extends Device> choosenDevices = chooser.chooseDevices(platforms);
List<CLDevice> devices = new ArrayList<>(choosenDevices.size());
List<Long> devices = new ArrayList<>(choosenDevices.size());
LwjglPlatform platform = null;
for (Device d : choosenDevices) {
if (!(d instanceof LwjglDevice)) {
@ -274,7 +308,7 @@ public abstract class LwjglContext implements JmeContext {
logger.severe("attempt to use devices from different platforms");
return;
}
devices.add(ld.getCLDevice());
devices.add(ld.getDevice());
}
if (devices.isEmpty()) {
logger.warning("no devices specified, no OpenCL context created");
@ -294,7 +328,7 @@ public abstract class LwjglContext implements JmeContext {
logger.info("OpenCL context created");
}
private long createContext(final CLPlatform platform, final List<CLDevice> devices, long window) throws Exception {
private long createContext(final long platform, final List<Long> devices, long window) throws Exception {
final int propertyCount = 2 + 4 + 1;
@ -330,7 +364,7 @@ public abstract class LwjglContext implements JmeContext {
Utils.errorBuffer.rewind();
PointerBuffer deviceBuffer = PointerBuffer.allocateDirect(devices.size());
for (CLDevice d : devices) {
for (long d : devices) {
deviceBuffer.put(d);
}
deviceBuffer.flip();