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

started with the image api, refactored buffer

Browse Source
This commit is contained in:
shamanDevel 2016-04-22 08:48:37 +02:00
parent a6be243db1
commit 4416295069
11 changed files with 838 additions and 361 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

153
jme3-core/src/main/java/com/jme3/opencl/Buffer.java
View File

@ -37,44 +37,121 @@ import java.nio.ByteBuffer;
* *
* @author Sebastian Weiss * @author Sebastian Weiss
*/ */
public interface Buffer { public abstract class Buffer {
int getSize(); public abstract int getSize();
MemoryAccess getMemoryAccessFlags();
void read(CommandQueue queue, ByteBuffer dest, int size, int offset);
void read(CommandQueue queue, ByteBuffer dest, int size);
void read(CommandQueue queue, ByteBuffer dest);
Event readAsync(CommandQueue queue, ByteBuffer dest, int size, int offset);
Event readAsync(CommandQueue queue, ByteBuffer dest, int size);
Event readAsync(CommandQueue queue, ByteBuffer dest);
void write(CommandQueue queue, ByteBuffer src, int size, int offset);
void write(CommandQueue queue, ByteBuffer src, int size);
void write(CommandQueue queue, ByteBuffer src);
Event writeAsync(CommandQueue queue, ByteBuffer src, int size, int offset);
Event writeAsync(CommandQueue queue, ByteBuffer src, int size);
Event writeAsync(CommandQueue queue, ByteBuffer src);
void copyTo(CommandQueue queue, Buffer dest, int size, int srcOffset, int destOffset);
void copyTo(CommandQueue queue, Buffer dest, int size);
void copyTo(CommandQueue queue, Buffer dest);
Event copyToAsync(CommandQueue queue, Buffer dest, int size, int srcOffset, int destOffset); public abstract MemoryAccess getMemoryAccessFlags();
Event copyToAsync(CommandQueue queue, Buffer dest, int size);
Event copyToAsync(CommandQueue queue, Buffer dest); public abstract void read(CommandQueue queue, ByteBuffer dest, int size, int offset);
ByteBuffer map(CommandQueue queue, int size, int offset, MappingAccess access); public void read(CommandQueue queue, ByteBuffer dest, int size) {
ByteBuffer map(CommandQueue queue, int size, MappingAccess access); read(queue, dest, size, 0);
ByteBuffer map(CommandQueue queue, MappingAccess access); }
void unmap(CommandQueue queue, ByteBuffer ptr);
public void read(CommandQueue queue, ByteBuffer dest) {
//TODO: async mapping read(queue, dest, getSize());
}
//TODO: clEnqueueFillBuffer
public abstract Event readAsync(CommandQueue queue, ByteBuffer dest, int size, int offset);
//TODO: image read/write
public Event readAsync(CommandQueue queue, ByteBuffer dest, int size) {
return readAsync(queue, dest, size, 0);
}
public Event readAsync(CommandQueue queue, ByteBuffer dest) {
return readAsync(queue, dest, getSize());
}
public abstract void write(CommandQueue queue, ByteBuffer src, int size, int offset);
public void write(CommandQueue queue, ByteBuffer src, int size) {
write(queue, src, size, 0);
}
public void write(CommandQueue queue, ByteBuffer src) {
write(queue, src, getSize());
}
public abstract Event writeAsync(CommandQueue queue, ByteBuffer src, int size, int offset);
public Event writeAsync(CommandQueue queue, ByteBuffer src, int size) {
return writeAsync(queue, src, size, 0);
}
public Event writeAsync(CommandQueue queue, ByteBuffer src) {
return writeAsync(queue, src, getSize());
}
public abstract void copyTo(CommandQueue queue, Buffer dest, int size, int srcOffset, int destOffset);
public void copyTo(CommandQueue queue, Buffer dest, int size) {
copyTo(queue, dest, size, 0, 0);
}
public void copyTo(CommandQueue queue, Buffer dest) {
copyTo(queue, dest, getSize());
}
public abstract Event copyToAsync(CommandQueue queue, Buffer dest, int size, int srcOffset, int destOffset);
public Event copyToAsync(CommandQueue queue, Buffer dest, int size) {
return copyToAsync(queue, dest, size, 0, 0);
}
public Event copyToAsync(CommandQueue queue, Buffer dest) {
return copyToAsync(queue, dest, getSize());
}
public abstract ByteBuffer map(CommandQueue queue, int size, int offset, MappingAccess access);
public ByteBuffer map(CommandQueue queue, int size, MappingAccess access) {
return map(queue, size, 0, access);
}
public ByteBuffer map(CommandQueue queue, MappingAccess access) {
return map(queue, getSize(), access);
}
public abstract void unmap(CommandQueue queue, ByteBuffer ptr);
public abstract AsyncMapping mapAsync(CommandQueue queue, int size, int offset, MappingAccess access);
public AsyncMapping mapAsync(CommandQueue queue, int size, MappingAccess access) {
return mapAsync(queue, size, 0, access);
}
public AsyncMapping mapAsync(CommandQueue queue, MappingAccess access) {
return mapAsync(queue, getSize(), 0, access);
}
public abstract Event fillAsync(CommandQueue queue, ByteBuffer pattern, int size, int offset);
//TODO: copy to image
/**
* Result of an async mapping operation, contains the event and the target byte buffer.
* This is a work-around since no generic pair-structure is avaiable.
*
* @author Sebastian Weiss
*/
public static class AsyncMapping {
public final Event event;
public final ByteBuffer buffer;
public AsyncMapping(Event event, ByteBuffer buffer) {
super();
this.event = event;
this.buffer = buffer;
}
public Event getEvent() {
return event;
}
public ByteBuffer getBuffer() {
return buffer;
}
}
public abstract Event copyToImageAsync(CommandQueue queue, Image dest, long srcOffset, long[] destOrigin, long[] destRegion);
} }

171
jme3-core/src/main/java/com/jme3/opencl/CL.java
View File

@ -1,171 +0,0 @@
/*
* Copyright (c) 2009-2016 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jme3.opencl;
import java.nio.*;
/**
* Interface for OpenCL implementations
*
* @author Sebastian Weiss
*/
@Deprecated
public interface CL {
//temp buffers for argument passing
public static class TempBuffer {
/**
* 16-Bytes (4 floats) of a byte buffer
*/
public final ByteBuffer b16;
/**
* Short-buffer view on b16
*/
public final ShortBuffer b16s;
/**
* int buffer view on b16
*/
public final IntBuffer b16i;
/**
* long buffer view on b16
*/
public final LongBuffer b16l;
/**
* float buffer view on b16
*/
public final FloatBuffer b16f;
/**
* double buffer view on b16
*/
public final DoubleBuffer b16d;
public TempBuffer(ByteBuffer b16) {
this.b16 = b16;
b16.rewind();
this.b16s = b16.asShortBuffer();
this.b16i = b16.asIntBuffer();
this.b16l = b16.asLongBuffer();
this.b16f = b16.asFloatBuffer();
this.b16d = b16.asDoubleBuffer();
}
}
/**
* Returns up to 4 temp buffer instances
*
* @return
*/
TempBuffer[] getTempBuffers();
//entry point
long getContext();
//OpenCL functions
long clCreateCommandQueue(long context, long device, boolean profiling);
void clReleaseCommandQueue(long queue);
long clCreateBuffer(long context, MemoryAccess access, int size, ByteBuffer hostPtr);
long clEnqueueReadBuffer(long queue, long buffer, boolean blocking, int offset, int size, ByteBuffer ptr);
long clEnqueueWriteBuffer(long queue, long buffer, boolean blocking, int offset, int size, ByteBuffer ptr);
long clEnqueueCopyBuffer(long queue, long srcBuffer, long dstBuffer, int srcOffset, int dstOffset, int size);
long clEnqueueFillBuffer(long queue, long buffer, ByteBuffer pattern, int patternSize, int offset, int size);
long clEnqueueMapBuffer(long queue, long buffer, boolean blocking, MappingAccess flags, int offset, int size);
long clCreateImage(long context, MemoryAccess access, Context.ImageFormat format, Context.ImageDescriptor desc, ByteBuffer ptr);
Context.ImageFormat[] clGetSupportedImageFormats(long context, MemoryAccess ma, Context.ImageType type);
long clEnqueueReadImage(long queue, long image, boolean blocking, ByteBuffer origin, ByteBuffer region, int rowPitch, int slicePitch, ByteBuffer ptr);
long clEnqueueWriteImage(long queue, long image, boolean blocking, ByteBuffer origin, ByteBuffer region, int inputRowPitch, int intputSlicePitch, ByteBuffer ptr);
long clEnqueueCopyImage(long queue, long srcImage, long dstImage, ByteBuffer srcOrigin, ByteBuffer dstOrigin, ByteBuffer region);
long clEnqueueFillImage(long queue, long image, ByteBuffer fillColor, ByteBuffer origin, ByteBuffer region);
long clEnqueueCopyImageToBuffer(long queue, long srcImage, long dstBuffer, ByteBuffer srcOrigin, ByteBuffer region, int dstOffset);
long clEnqueueCopyBufferToImage(long queue, long srcBuffer, long dstImage, int srcOffset, ByteBuffer dstOrigin, ByteBuffer region);
long clEnqueueMapImage(long queue, long image, boolean blocking, MappingAccess ma, ByteBuffer origin, ByteBuffer region, int rowPitch, int slicePitch);
//TODO: clGetImageInfo
void clReleaseMemObject(long mem);
long clEnqueueUnmapMemObject(long queue, long mem, ByteBuffer ptr);
int getMemSize(long mem); //uses clGetMemObjectInfo
long clCreateProgramWithSource(long context, CharSequence[] sources);
//TODO: create from binary
long clReleaseProgram(long program);
void clBuildProgram(long program, long[] devices, CharSequence optpions) throws KernelCompilationException;
String getKernelNames(long program); //uses clGetProgramInfo
long clCreateKernel(long program, String kernelName);
void clReleaseKernel(long kernel);
void clSetKernelArg(long kernel, int argIndex, int argSize, ByteBuffer argValue);
String getKernelName(long kernel); //uses clGetKernelInfo
int getKernelNumArgs(long kernel); //uses clGetKernelInfo
//TODO: clGetKernelWorkGroupInfo
long clEnqueueNDRangeKernel(long queue, long kernel, int workDim,
ByteBuffer globalWorkOffset, ByteBuffer globalWorkSize, ByteBuffer localWorkSize);
void clWaitForEvents(long[] events);
void clWaitForEvent(long event);
boolean isEventCompleted(long event); //uses clGetEventInfo
void clReleaseEvent(long event);
void clFlush(long queue);
void clFinish(long queue);
}

66
jme3-core/src/main/java/com/jme3/opencl/Context.java
View File

@ -34,6 +34,9 @@ package com.jme3.opencl;
import com.jme3.asset.AssetInfo; import com.jme3.asset.AssetInfo;
import com.jme3.asset.AssetKey; import com.jme3.asset.AssetKey;
import com.jme3.asset.AssetManager; import com.jme3.asset.AssetManager;
import com.jme3.opencl.Image.ImageDescriptor;
import com.jme3.opencl.Image.ImageFormat;
import com.jme3.opencl.Image.ImageType;
import com.jme3.scene.VertexBuffer; import com.jme3.scene.VertexBuffer;
import com.jme3.scene.mesh.IndexBuffer; import com.jme3.scene.mesh.IndexBuffer;
import java.io.BufferedReader; import java.io.BufferedReader;
@ -70,69 +73,10 @@ public abstract class Context {
return createBufferFromHost(data, MemoryAccess.READ_WRITE); return createBufferFromHost(data, MemoryAccess.READ_WRITE);
} }
public static enum ImageChannelOrder {
R, Rx, A,
INTENSITY,
LUMINANCE,
RG, RGx, RA,
RGB, RGBx,
RGBA,
ARGB, BGRA
}
public static enum ImageChannelType {
SNORM_INT8,
SNORM_INT16,
UNORM_INT8,
UNROM_INT16,
UNORM_SHORT_565,
UNROM_SHORT_555,
UNORM_INT_101010,
SIGNED_INT8,
SIGNED_INT16,
SIGNED_INT32,
UNSIGNED_INT8,
UNSIGNED_INT16,
UNSIGNED_INT32,
HALF_FLOAT,
FLOAT
}
public static class ImageFormat { //Struct
public ImageChannelOrder channelOrder;
public ImageChannelType channelType;
}
public static enum ImageType {
IMAGE_1D,
IMAGE_1D_BUFFER,
IMAGE_2D,
IMAGE_3D,
IMAGE_1D_ARRAY,
IMAGE_2D_ARRAY
}
public static class ImageDescriptor { //Struct
public ImageType type;
public int width;
public int height;
public int depth;
public int arraySize;
public int rowPitch;
public int slicePitch;
public int numMipLevels;
public int numSamples;
public Buffer buffer;
}
public abstract Image createImage(MemoryAccess access, ImageFormat format, ImageDescriptor descr, ByteBuffer hostPtr); public abstract Image createImage(MemoryAccess access, ImageFormat format, ImageDescriptor descr, ByteBuffer hostPtr);
//TODO: add simplified methods for 1D, 2D, 3D textures //TODO: add simplified methods for 1D, 2D, 3D textures
public abstract ImageFormat[] querySupportedFormats(MemoryAccess access, ImageType type);
//Interop //Interop
public abstract Buffer bindVertexBuffer(VertexBuffer vb); public abstract Buffer bindVertexBuffer(VertexBuffer vb);
public abstract Buffer bindIndexBuffer(IndexBuffer ib); public abstract Buffer bindIndexBuffer(IndexBuffer ib);

196
jme3-core/src/main/java/com/jme3/opencl/Image.java
View File

@ -31,10 +31,206 @@
*/ */
package com.jme3.opencl; package com.jme3.opencl;
import com.jme3.math.ColorRGBA;
import java.nio.ByteBuffer;
import java.util.Objects;
/** /**
* *
* @author Sebastian Weiss * @author Sebastian Weiss
*/ */
public interface Image { public interface Image {
public static enum ImageChannelType {
SNORM_INT8,
SNORM_INT16,
UNORM_INT8,
UNORM_INT16,
UNORM_SHORT_565,
UNORM_SHORT_555,
UNORM_INT_101010,
SIGNED_INT8,
SIGNED_INT16,
SIGNED_INT32,
UNSIGNED_INT8,
UNSIGNED_INT16,
UNSIGNED_INT32,
HALF_FLOAT,
FLOAT
}
public static enum ImageChannelOrder {
R, Rx, A,
INTENSITY,
LUMINANCE,
RG, RGx, RA,
RGB, RGBx,
RGBA,
ARGB, BGRA
}
public static class ImageFormat { //Struct
public ImageChannelOrder channelOrder;
public ImageChannelType channelType;
public ImageFormat() {
}
public ImageFormat(ImageChannelOrder channelOrder, ImageChannelType channelType) {
this.channelOrder = channelOrder;
this.channelType = channelType;
}
@Override
public String toString() {
return "ImageFormat{" + "channelOrder=" + channelOrder + ", channelType=" + channelType + '}';
}
@Override
public int hashCode() {
int hash = 5;
hash = 61 * hash + Objects.hashCode(this.channelOrder);
hash = 61 * hash + Objects.hashCode(this.channelType);
return hash;
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final ImageFormat other = (ImageFormat) obj;
if (this.channelOrder != other.channelOrder) {
return false;
}
if (this.channelType != other.channelType) {
return false;
}
return true;
}
}
public static enum ImageType {
IMAGE_1D,
IMAGE_1D_BUFFER,
IMAGE_2D,
IMAGE_3D,
IMAGE_1D_ARRAY,
IMAGE_2D_ARRAY
}
public static class ImageDescriptor { //Struct
public ImageType type;
public long width;
public long height;
public long depth;
public long arraySize;
public long rowPitch;
public long slicePitch;
/*
public int numMipLevels; //They must always be set to zero
public int numSamples;
*/
public ImageDescriptor() {
}
public ImageDescriptor(ImageType type, long width, long height, long depth, long arraySize, long rowPitch, long slicePitch) {
this.type = type;
this.width = width;
this.height = height;
this.depth = depth;
this.arraySize = arraySize;
this.rowPitch = rowPitch;
this.slicePitch = slicePitch;
}
public ImageDescriptor(ImageType type, long width, long height, long depth, long arraySize) {
this.type = type;
this.width = width;
this.height = height;
this.depth = depth;
this.arraySize = arraySize;
this.rowPitch = 0;
this.slicePitch = 0;
}
@Override
public String toString() {
return "ImageDescriptor{" + "type=" + type + ", width=" + width + ", height=" + height + ", depth=" + depth + ", arraySize=" + arraySize + ", rowPitch=" + rowPitch + ", slicePitch=" + slicePitch + '}';
}
}
long getWidth();
long getHeight();
long getDepth();
long getRowPitch();
long getSlicePitch();
long getArraySize();
ImageFormat getImageFormat();
ImageType getImageType();
int getElementSize();
void readImage(CommandQueue queue, ByteBuffer dest, long[] origin, long[] region, long rowPitch, long slicePitch);
Event readImageAsync(CommandQueue queue, ByteBuffer dest, long[] origin, long[] region, long rowPitch, long slicePitch);
void writeImage(CommandQueue queue, ByteBuffer dest, long[] origin, long[] region, long rowPitch, long slicePitch);
Event writeImageAsync(CommandQueue queue, ByteBuffer dest, long[] origin, long[] region, long rowPitch, long slicePitch);
void copyTo(CommandQueue queue, Image dest, long[] srcOrigin, long[] destOrigin, long[] region);
Event copyToAsync(CommandQueue queue, Image dest, long[] srcOrigin, long[] destOrigin, long[] region);
ImageMapping map(CommandQueue queue, long[] origin, long[] region, MappingAccess access);
ImageMapping mapAsync(CommandQueue queue, long[] origin, long[] region, MappingAccess access);
void unmap(CommandQueue queue, ImageMapping mapping);
public static class ImageMapping {
public final ByteBuffer buffer;
public final long rowPitch;
public final long slicePitch;
public final Event event;
public ImageMapping(ByteBuffer buffer, long rowPitch, long slicePitch, Event event) {
this.buffer = buffer;
this.rowPitch = rowPitch;
this.slicePitch = slicePitch;
this.event = event;
}
public ImageMapping(ByteBuffer buffer, long rowPitch, long slicePitch) {
this.buffer = buffer;
this.rowPitch = rowPitch;
this.slicePitch = slicePitch;
this.event = null;
}
}
/**
* Fills the image with the specified color.
* Does <b>only</b> work if the image channel is {@link ImageChannelType#FLOAT}
* or {@link ImageChannelType#HALF_FLOAT}.
* @param queue
* @param origin
* @param region
* @param color
* @return
*/
Event fillAsync(CommandQueue queue, long[] origin, long[] region, ColorRGBA color);
/**
* Fills the image with the specified color given as four integer variables.
* Does <b>not</b> work if the image channel is {@link ImageChannelType#FLOAT}
* or {@link ImageChannelType#HALF_FLOAT}.
* @param queue
* @param origin
* @param region
* @param color
* @return
*/
Event fillIntegerAsync(CommandQueue queue, long[] origin, long[] region, int[] color);
Event copyToBufferAsync(CommandQueue queue, Buffer dest, long[] srcOrigin, long[] srcRegion, long destOffset);
} }

2
jme3-core/src/main/java/com/jme3/opencl/Kernel.java
View File

@ -102,6 +102,8 @@ public abstract class Kernel {
public abstract void setArg(int index, LocalMem t); public abstract void setArg(int index, LocalMem t);
public abstract void setArg(int index, Buffer t); public abstract void setArg(int index, Buffer t);
public abstract void setArg(int index, Image i);
public abstract void setArg(int index, byte b); public abstract void setArg(int index, byte b);

81
jme3-examples/src/main/java/jme3test/opencl/HelloOpenCL.java
View File

@ -40,6 +40,8 @@ import com.jme3.system.AppSettings;
import com.jme3.util.BufferUtils; import com.jme3.util.BufferUtils;
import java.nio.ByteBuffer; import java.nio.ByteBuffer;
import java.nio.FloatBuffer; import java.nio.FloatBuffer;
import java.util.Arrays;
import java.util.Objects;
import java.util.logging.Level; import java.util.logging.Level;
import java.util.logging.Logger; import java.util.logging.Logger;
@ -78,6 +80,7 @@ public class HelloOpenCL extends SimpleApplication {
str.append("\nTests:"); str.append("\nTests:");
str.append("\n Buffers: ").append(testBuffer(clContext, clQueue)); str.append("\n Buffers: ").append(testBuffer(clContext, clQueue));
str.append("\n Kernel: ").append(testKernel(clContext, clQueue)); str.append("\n Kernel: ").append(testKernel(clContext, clQueue));
str.append("\n Images: ").append(testImages(clContext, clQueue));
BitmapText txt1 = new BitmapText(fnt); BitmapText txt1 = new BitmapText(fnt);
txt1.setText(str.toString()); txt1.setText(str.toString());
@ -85,6 +88,31 @@ public class HelloOpenCL extends SimpleApplication {
guiNode.attachChild(txt1); guiNode.attachChild(txt1);
} }
private static void assertEquals(byte expected, byte actual, String message) {
if (expected != actual) {
System.err.println(message+": expected="+expected+", actual="+actual);
throw new AssertionError();
}
}
private static void assertEquals(long expected, long actual, String message) {
if (expected != actual) {
System.err.println(message+": expected="+expected+", actual="+actual);
throw new AssertionError();
}
}
private static void assertEquals(double expected, double actual, String message) {
if (Math.abs(expected - actual) >= 0.00001) {
System.err.println(message+": expected="+expected+", actual="+actual);
throw new AssertionError();
}
}
private static void assertEquals(Object expected, Object actual, String message) {
if (!Objects.equals(expected, actual)) {
System.err.println(message+": expected="+expected+", actual="+actual);
throw new AssertionError();
}
}
private boolean testBuffer(Context clContext, CommandQueue clQueue) { private boolean testBuffer(Context clContext, CommandQueue clQueue) {
try { try {
//create two buffers //create two buffers
@ -110,10 +138,7 @@ public class HelloOpenCL extends SimpleApplication {
h1.rewind(); h1.rewind();
for (int i=0; i<256; ++i) { for (int i=0; i<256; ++i) {
byte b = h1.get(); byte b = h1.get();
if (b != (byte)i) { assertEquals((byte) i, b, "Wrong byte read");
System.err.println("Wrong byte read: expected="+i+", actual="+b);
return false;
}
} }
//read buffer with offset //read buffer with offset
@ -125,12 +150,12 @@ public class HelloOpenCL extends SimpleApplication {
h1.position(5); h1.position(5);
for (int i=0; i<high-low; ++i) { for (int i=0; i<high-low; ++i) {
byte b = h1.get(); byte b = h1.get();
if (b != (byte)(i+low)) { assertEquals((byte) (i+low), b, "Wrong byte read");
System.err.println("Wrong byte read: expected="+(i+low)+", actual="+b);
return false;
}
} }
} catch (AssertionError ex) {
LOG.log(Level.SEVERE, "Buffer test failed with an assertion error");
return false;
} catch (Exception ex) { } catch (Exception ex) {
LOG.log(Level.SEVERE, "Buffer test failed with:", ex); LOG.log(Level.SEVERE, "Buffer test failed with:", ex);
return false; return false;
@ -163,18 +188,48 @@ public class HelloOpenCL extends SimpleApplication {
FloatBuffer buff = buf.asFloatBuffer(); FloatBuffer buff = buf.asFloatBuffer();
for (int i=0; i<size; ++i) { for (int i=0; i<size; ++i) {
float v = buff.get(i); float v = buff.get(i);
if (v != value) { assertEquals(value, v, "Buffer filled with the wrong value at index "+i);
System.err.println("Buffer filled with the wrong value at index "+i+": expected="+value+", actual="+v);
buffer.unmap(clQueue, buf);
return false;
}
} }
buffer.unmap(clQueue, buf); buffer.unmap(clQueue, buf);
} catch (AssertionError ex) {
LOG.log(Level.SEVERE, "kernel test failed with an assertion error");
return false;
} catch (Exception ex) { } catch (Exception ex) {
LOG.log(Level.SEVERE, "kernel test failed with:", ex); LOG.log(Level.SEVERE, "kernel test failed with:", ex);
return false; return false;
} }
return true; return true;
} }
private boolean testImages(Context clContext, CommandQueue clQueue) {
try {
//query supported formats
for (MemoryAccess ma : MemoryAccess.values()) {
for (Image.ImageType type : Image.ImageType.values()) {
System.out.println("Formats for "+ma+" and "+type+": "+Arrays.toString(clContext.querySupportedFormats(ma, type)));
}
}
//create an image
Image.ImageFormat format = new Image.ImageFormat(Image.ImageChannelOrder.RGBA, Image.ImageChannelType.FLOAT);
Image.ImageDescriptor descr = new Image.ImageDescriptor(Image.ImageType.IMAGE_2D, 1920, 1080, 0, 0, 0, 0);
Image image = clContext.createImage(MemoryAccess.READ_WRITE, format, descr, null);
System.out.println("image created");
//check queries
assertEquals(descr.type, image.getImageType(), "Wrong image type");
assertEquals(format, image.getImageFormat(), "Wrong image format");
assertEquals(descr.width, image.getWidth(), "Wrong width");
assertEquals(descr.height, image.getHeight(), "Wrong height");
} catch (AssertionError ex) {
LOG.log(Level.SEVERE, "image test failed with an assertion error");
return false;
} catch (Exception ex) {
LOG.log(Level.SEVERE, "image test failed with:", ex);
return false;
}
return true;
}
} }

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

@ -33,16 +33,13 @@ package com.jme3.opencl.lwjgl;
import com.jme3.opencl.*; import com.jme3.opencl.*;
import java.nio.ByteBuffer; import java.nio.ByteBuffer;
import org.lwjgl.opencl.CL10; import org.lwjgl.opencl.*;
import org.lwjgl.opencl.CLCommandQueue;
import org.lwjgl.opencl.CLEvent;
import org.lwjgl.opencl.CLMem;
/** /**
* *
* @author Sebastian Weiss * @author Sebastian Weiss
*/ */
public class LwjglBuffer implements Buffer { public class LwjglBuffer extends Buffer {
private final CLMem buffer; private final CLMem buffer;
@ -72,16 +69,6 @@ public class LwjglBuffer implements Buffer {
Utils.checkError(ret, "clEnqueueReadBuffer"); Utils.checkError(ret, "clEnqueueReadBuffer");
} }
@Override
public void read(CommandQueue queue, ByteBuffer dest, int size) {
read(queue, dest, size, 0);
}
@Override
public void read(CommandQueue queue, ByteBuffer dest) {
read(queue, dest, getSize());
}
@Override @Override
public Event readAsync(CommandQueue queue, ByteBuffer dest, int size, int offset) { public Event readAsync(CommandQueue queue, ByteBuffer dest, int size, int offset) {
//Note: LWJGL does not support the size parameter, I have to set the buffer limit //Note: LWJGL does not support the size parameter, I have to set the buffer limit
@ -94,16 +81,6 @@ public class LwjglBuffer implements Buffer {
return new LwjglEvent(q.getCLEvent(event)); return new LwjglEvent(q.getCLEvent(event));
} }
@Override
public Event readAsync(CommandQueue queue, ByteBuffer dest, int size) {
return readAsync(queue, dest, size, 0);
}
@Override
public Event readAsync(CommandQueue queue, ByteBuffer dest) {
return readAsync(queue, dest, getSize());
}
@Override @Override
public void write(CommandQueue queue, ByteBuffer src, int size, int offset) { public void write(CommandQueue queue, ByteBuffer src, int size, int offset) {
//Note: LWJGL does not support the size parameter, I have to set the buffer limit //Note: LWJGL does not support the size parameter, I have to set the buffer limit
@ -113,16 +90,6 @@ public class LwjglBuffer implements Buffer {
Utils.checkError(ret, "clEnqueueWriteBuffer"); Utils.checkError(ret, "clEnqueueWriteBuffer");
} }
@Override
public void write(CommandQueue queue, ByteBuffer src, int size) {
write(queue, src, size, 0);
}
@Override
public void write(CommandQueue queue, ByteBuffer src) {
write(queue, src, getSize());
}
@Override @Override
public Event writeAsync(CommandQueue queue, ByteBuffer src, int size, int offset) { public Event writeAsync(CommandQueue queue, ByteBuffer src, int size, int offset) {
//Note: LWJGL does not support the size parameter, I have to set the buffer limit //Note: LWJGL does not support the size parameter, I have to set the buffer limit
@ -135,16 +102,6 @@ public class LwjglBuffer implements Buffer {
return new LwjglEvent(q.getCLEvent(event)); return new LwjglEvent(q.getCLEvent(event));
} }
@Override
public Event writeAsync(CommandQueue queue, ByteBuffer src, int size) {
return writeAsync(queue, src, size, 0);
}
@Override
public Event writeAsync(CommandQueue queue, ByteBuffer src) {
return writeAsync(queue, src, getSize());
}
@Override @Override
public void copyTo(CommandQueue queue, Buffer dest, int size, int srcOffset, int destOffset) { public void copyTo(CommandQueue queue, Buffer dest, int size, int srcOffset, int destOffset) {
CLCommandQueue q = ((LwjglCommandQueue)queue).getQueue(); CLCommandQueue q = ((LwjglCommandQueue)queue).getQueue();
@ -156,16 +113,6 @@ public class LwjglBuffer implements Buffer {
Utils.checkError(ret, "clWaitForEvents"); Utils.checkError(ret, "clWaitForEvents");
} }
@Override
public void copyTo(CommandQueue queue, Buffer dest, int size) {
copyTo(queue, dest, size, 0, 0);
}
@Override
public void copyTo(CommandQueue queue, Buffer dest) {
copyTo(queue, dest, getSize());
}
@Override @Override
public Event copyToAsync(CommandQueue queue, Buffer dest, int size, int srcOffset, int destOffset) { public Event copyToAsync(CommandQueue queue, Buffer dest, int size, int srcOffset, int destOffset) {
CLCommandQueue q = ((LwjglCommandQueue)queue).getQueue(); CLCommandQueue q = ((LwjglCommandQueue)queue).getQueue();
@ -176,16 +123,6 @@ public class LwjglBuffer implements Buffer {
return new LwjglEvent(q.getCLEvent(event)); return new LwjglEvent(q.getCLEvent(event));
} }
@Override
public Event copyToAsync(CommandQueue queue, Buffer dest, int size) {
return copyToAsync(queue, dest, size, 0, 0);
}
@Override
public Event copyToAsync(CommandQueue queue, Buffer dest) {
return copyToAsync(queue, dest, getSize());
}
@Override @Override
public ByteBuffer map(CommandQueue queue, int size, int offset, MappingAccess access) { public ByteBuffer map(CommandQueue queue, int size, int offset, MappingAccess access) {
CLCommandQueue q = ((LwjglCommandQueue) queue).getQueue(); CLCommandQueue q = ((LwjglCommandQueue) queue).getQueue();
@ -196,16 +133,6 @@ public class LwjglBuffer implements Buffer {
return b; return b;
} }
@Override
public ByteBuffer map(CommandQueue queue, int size, MappingAccess access) {
return map(queue, size, 0, access);
}
@Override
public ByteBuffer map(CommandQueue queue, MappingAccess access) {
return map(queue, getSize(), access);
}
@Override @Override
public void unmap(CommandQueue queue, ByteBuffer ptr) { public void unmap(CommandQueue queue, ByteBuffer ptr) {
CLCommandQueue q = ((LwjglCommandQueue) queue).getQueue(); CLCommandQueue q = ((LwjglCommandQueue) queue).getQueue();
@ -216,5 +143,42 @@ public class LwjglBuffer implements Buffer {
ret = CL10.clWaitForEvents(q.getCLEvent(event)); ret = CL10.clWaitForEvents(q.getCLEvent(event));
Utils.checkError(ret, "clWaitForEvents"); Utils.checkError(ret, "clWaitForEvents");
} }
@Override
public com.jme3.opencl.Buffer.AsyncMapping mapAsync(CommandQueue queue, int size, int offset, MappingAccess access) {
Utils.pointerBuffers[0].rewind();
Utils.errorBuffer.rewind();
CLCommandQueue q = ((LwjglCommandQueue) queue).getQueue();
long flags = Utils.getMappingAccessFlags(access);
ByteBuffer buf = CL10.clEnqueueMapBuffer(q, buffer, CL10.CL_FALSE, flags, offset, size, null, Utils.pointerBuffers[0], Utils.errorBuffer);
Utils.checkError(Utils.errorBuffer, "clEnqueueMapBuffer");
long event = Utils.pointerBuffers[0].get(0);
return new com.jme3.opencl.Buffer.AsyncMapping(new LwjglEvent(q.getCLEvent(event)), buf);
}
@Override
public Event fillAsync(CommandQueue queue, ByteBuffer pattern, int size, int offset) {
Utils.pointerBuffers[0].rewind();
CLCommandQueue q = ((LwjglCommandQueue) queue).getQueue();
int ret = CL12.clEnqueueFillBuffer(q, buffer, pattern, offset, size, null, Utils.pointerBuffers[0]);
Utils.checkError(ret, "clEnqueueFillBuffer");
long event = Utils.pointerBuffers[0].get(0);
return new LwjglEvent(q.getCLEvent(event));
}
@Override
public Event copyToImageAsync(CommandQueue queue, Image dest, long srcOffset, long[] destOrigin, long[] destRegion) {
Utils.pointerBuffers[0].rewind();
Utils.pointerBuffers[1].rewind();
Utils.pointerBuffers[2].rewind();
Utils.pointerBuffers[1].put(destOrigin).position(0);
Utils.pointerBuffers[2].put(destRegion).position(0);
CLCommandQueue q = ((LwjglCommandQueue) queue).getQueue();
int ret = CL10.clEnqueueCopyBufferToImage(q, buffer, ((LwjglImage) dest).getImage(),
srcOffset, Utils.pointerBuffers[1], Utils.pointerBuffers[2], null, Utils.pointerBuffers[0]);
Utils.checkError(ret, "clEnqueueCopyBufferToImage");
long event = Utils.pointerBuffers[0].get(0);
return new LwjglEvent(q.getCLEvent(event));
}
} }

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

@ -35,16 +35,20 @@ import com.jme3.asset.AssetInfo;
import com.jme3.asset.AssetKey; import com.jme3.asset.AssetKey;
import com.jme3.asset.AssetManager; import com.jme3.asset.AssetManager;
import com.jme3.opencl.*; import com.jme3.opencl.*;
import com.jme3.opencl.Image.ImageDescriptor;
import com.jme3.opencl.Image.ImageFormat;
import com.jme3.scene.VertexBuffer; import com.jme3.scene.VertexBuffer;
import com.jme3.scene.mesh.IndexBuffer; import com.jme3.scene.mesh.IndexBuffer;
import java.io.BufferedReader; import java.io.BufferedReader;
import java.io.IOException; import java.io.IOException;
import java.io.InputStreamReader; import java.io.InputStreamReader;
import java.nio.ByteBuffer; import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.util.Arrays; import java.util.Arrays;
import java.util.List; import java.util.List;
import java.util.logging.Level; import java.util.logging.Level;
import java.util.logging.Logger; import java.util.logging.Logger;
import org.lwjgl.BufferUtils;
import org.lwjgl.opencl.*; import org.lwjgl.opencl.*;
import sun.misc.IOUtils; import sun.misc.IOUtils;
@ -101,7 +105,52 @@ public class LwjglContext extends Context {
@Override @Override
public Image createImage(MemoryAccess access, ImageFormat format, ImageDescriptor descr, ByteBuffer hostPtr) { public Image createImage(MemoryAccess access, ImageFormat format, ImageDescriptor descr, ByteBuffer hostPtr) {
throw new UnsupportedOperationException("Not supported yet."); long memFlags = Utils.getMemoryAccessFlags(access);
Utils.errorBuffer.rewind();
//fill image format
Utils.tempBuffers[0].b16i.rewind();
Utils.tempBuffers[0].b16i.put(LwjglImage.decodeImageChannelOrder(format.channelOrder))
.put(LwjglImage.decodeImageChannelType(format.channelType));
Utils.tempBuffers[0].b16.rewind();
//fill image desc
Utils.b80l.rewind();
Utils.b80l.put(LwjglImage.decodeImageType(descr.type))
.put(descr.width).put(descr.height).put(descr.depth)
.put(descr.arraySize).put(descr.rowPitch).put(descr.slicePitch)
.put(0).put(0).put(0);
Utils.b80.rewind();
//create image
CLMem mem = CL12.clCreateImage(context, memFlags, Utils.tempBuffers[0].b16, Utils.b80, hostPtr, Utils.errorBuffer);
Utils.checkError(Utils.errorBuffer, "clCreateImage");
return new LwjglImage(mem);
}
@Override
public ImageFormat[] querySupportedFormats(MemoryAccess access, Image.ImageType type) {
long memFlags = Utils.getMemoryAccessFlags(access);
int typeFlag = LwjglImage.decodeImageType(type);
Utils.tempBuffers[0].b16i.rewind();
//query count
int ret = CL10.clGetSupportedImageFormats(context, memFlags, typeFlag, null, Utils.tempBuffers[0].b16i);
Utils.checkError(ret, "clGetSupportedImageFormats");
int count = Utils.tempBuffers[0].b16i.get(0);
if (count == 0) {
return new ImageFormat[0];
}
//get formats
ByteBuffer formatsB = BufferUtils.createByteBuffer(count * 8);
ret = CL10.clGetSupportedImageFormats(context, memFlags, typeFlag, formatsB, null);
Utils.checkError(ret, "clGetSupportedImageFormats");
//convert formats
ImageFormat[] formats = new ImageFormat[count];
IntBuffer formatsBi = formatsB.asIntBuffer();
formatsBi.rewind();
for (int i=0; i<count; ++i) {
Image.ImageChannelOrder channelOrder = LwjglImage.encodeImageChannelOrder(formatsBi.get());
Image.ImageChannelType channelType = LwjglImage.encodeImageChannelType(formatsBi.get());
formats[i] = new ImageFormat(channelOrder, channelType);
}
return formats;
} }
@Override @Override

351
jme3-lwjgl/src/main/java/com/jme3/opencl/lwjgl/LwjglImage.java Normal file
View File

@ -0,0 +1,351 @@
/*
* Copyright (c) 2009-2016 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jme3.opencl.lwjgl;
import com.jme3.math.ColorRGBA;
import com.jme3.opencl.*;
import java.nio.ByteBuffer;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.lwjgl.opencl.CL10;
import org.lwjgl.opencl.CL11;
import org.lwjgl.opencl.CL12;
import org.lwjgl.opencl.CLMem;
import org.lwjgl.opencl.api.CLImageFormat;
/**
*
* @author Sebastian Weiss
*/
public class LwjglImage implements Image {
private static final Logger LOG = Logger.getLogger(LwjglImage.class.getName());
private final CLMem image;
public LwjglImage(CLMem image) {
this.image = image;
}
public CLMem getImage() {
return image;
}
public static int decodeImageChannelOrder(ImageChannelOrder order) {
switch (order) {
case A:
return CL10.CL_A;
case ARGB:
return CL10.CL_ARGB;
case BGRA:
return CL10.CL_BGRA;
case INTENSITY:
return CL10.CL_INTENSITY;
case LUMINANCE:
return CL10.CL_LUMINANCE;
case R:
return CL10.CL_R;
case RA:
return CL10.CL_RA;
case RG:
return CL10.CL_RG;
case RGB:
return CL10.CL_RGB;
case RGBA:
return CL10.CL_RGBA;
case RGBx:
return CL11.CL_RGBx;
case RGx:
return CL11.CL_RGx;
case Rx:
return CL11.CL_Rx;
default:
throw new IllegalArgumentException("unknown image channel order: " + order);
}
}
public static ImageChannelOrder encodeImageChannelOrder(int order) {
switch (order) {
case CL10.CL_A:
return ImageChannelOrder.A;
case CL10.CL_ARGB:
return ImageChannelOrder.ARGB;
case CL10.CL_BGRA:
return ImageChannelOrder.BGRA;
case CL10.CL_INTENSITY:
return ImageChannelOrder.INTENSITY;
case CL10.CL_LUMINANCE:
return ImageChannelOrder.LUMINANCE;
case CL10.CL_R:
return ImageChannelOrder.R;
case CL10.CL_RA:
return ImageChannelOrder.RA;
case CL10.CL_RG:
return ImageChannelOrder.RG;
case CL10.CL_RGB:
return ImageChannelOrder.RGB;
case CL10.CL_RGBA:
return ImageChannelOrder.RGBA;
case CL11.CL_RGBx:
return ImageChannelOrder.RGBx;
case CL11.CL_RGx:
return ImageChannelOrder.RGx;
case CL11.CL_Rx:
return ImageChannelOrder.Rx;
default:
//throw new OpenCLException("unknown image channel order id: " + order);
LOG.log(Level.WARNING, "Unknown image channel order id: {0}", order);
return null;
}
}
public static int decodeImageChannelType(ImageChannelType type) {
switch (type) {
case FLOAT:
return CL10.CL_FLOAT;
case HALF_FLOAT:
return CL10.CL_HALF_FLOAT;
case SIGNED_INT16:
return CL10.CL_SIGNED_INT16;
case SIGNED_INT32:
return CL10.CL_SIGNED_INT32;
case SIGNED_INT8:
return CL10.CL_SIGNED_INT8;
case SNORM_INT16:
return CL10.CL_SNORM_INT16;
case SNORM_INT8:
return CL10.CL_SNORM_INT8;
case UNORM_INT8:
return CL10.CL_UNORM_INT8;
case UNORM_INT_101010:
return CL10.CL_UNORM_INT_101010;
case UNORM_INT16:
return CL10.CL_UNORM_INT16;
case UNORM_SHORT_565:
return CL10.CL_UNORM_SHORT_565;
case UNORM_SHORT_555:
return CL10.CL_UNORM_SHORT_555;
case UNSIGNED_INT16:
return CL10.CL_UNSIGNED_INT16;
case UNSIGNED_INT32:
return CL10.CL_UNSIGNED_INT32;
case UNSIGNED_INT8:
return CL10.CL_UNSIGNED_INT8;
default:
throw new IllegalArgumentException("Unknown image channel type: " + type);
}
}
public static ImageChannelType encodeImageChannelType(int type) {
switch (type) {
case CL10.CL_FLOAT:
return ImageChannelType.FLOAT;
case CL10.CL_HALF_FLOAT:
return ImageChannelType.HALF_FLOAT;
case CL10.CL_SIGNED_INT16:
return ImageChannelType.SIGNED_INT16;
case CL10.CL_SIGNED_INT32:
return ImageChannelType.SIGNED_INT32;
case CL10.CL_SIGNED_INT8:
return ImageChannelType.SIGNED_INT8;
case CL10.CL_SNORM_INT16:
return ImageChannelType.SNORM_INT16;
case CL10.CL_SNORM_INT8:
return ImageChannelType.SNORM_INT8;
case CL10.CL_UNORM_INT8:
return ImageChannelType.UNORM_INT8;
case CL10.CL_UNORM_INT16:
return ImageChannelType.UNORM_INT16;
case CL10.CL_UNORM_INT_101010:
return ImageChannelType.UNORM_INT_101010;
case CL10.CL_UNORM_SHORT_555:
return ImageChannelType.UNORM_SHORT_555;
case CL10.CL_UNORM_SHORT_565:
return ImageChannelType.UNORM_SHORT_565;
case CL10.CL_UNSIGNED_INT16:
return ImageChannelType.UNSIGNED_INT16;
case CL10.CL_UNSIGNED_INT32:
return ImageChannelType.UNSIGNED_INT32;
case CL10.CL_UNSIGNED_INT8:
return ImageChannelType.UNSIGNED_INT8;
default:
//throw new OpenCLException("unknown image channel type id: " + type);
LOG.log(Level.WARNING, "Unknown image channel type id: {0}", type);
return null;
}
}
public static int decodeImageType(ImageType type) {
switch (type) {
case IMAGE_1D:
return CL12.CL_MEM_OBJECT_IMAGE1D;
case IMAGE_1D_ARRAY:
return CL12.CL_MEM_OBJECT_IMAGE1D_ARRAY;
case IMAGE_1D_BUFFER:
return CL12.CL_MEM_OBJECT_IMAGE1D_BUFFER;
case IMAGE_2D:
return CL10.CL_MEM_OBJECT_IMAGE2D;
case IMAGE_2D_ARRAY:
return CL12.CL_MEM_OBJECT_IMAGE2D_ARRAY;
case IMAGE_3D:
return CL10.CL_MEM_OBJECT_IMAGE3D;
default:
throw new IllegalArgumentException("Unknown image type: " + type);
}
}
public static ImageType encodeImageType(int type) {
switch (type) {
case CL12.CL_MEM_OBJECT_IMAGE1D:
return ImageType.IMAGE_1D;
case CL12.CL_MEM_OBJECT_IMAGE1D_ARRAY:
return ImageType.IMAGE_1D_ARRAY;
case CL12.CL_MEM_OBJECT_IMAGE1D_BUFFER:
return ImageType.IMAGE_1D_BUFFER;
case CL10.CL_MEM_OBJECT_IMAGE2D:
return ImageType.IMAGE_2D;
case CL12.CL_MEM_OBJECT_IMAGE2D_ARRAY:
return ImageType.IMAGE_2D_ARRAY;
case CL10.CL_MEM_OBJECT_IMAGE3D:
return ImageType.IMAGE_3D;
default:
throw new OpenCLException("Unknown image type id: " + type);
}
}
@Override
public long getWidth() {
return image.getInfoSize(CL10.CL_IMAGE_WIDTH);
}
@Override
public long getHeight() {
return image.getInfoSize(CL10.CL_IMAGE_HEIGHT);
}
@Override
public long getDepth() {
return image.getInfoSize(CL10.CL_IMAGE_DEPTH);
}
@Override
public long getRowPitch() {
return image.getInfoSize(CL10.CL_IMAGE_ROW_PITCH);
}
@Override
public long getSlicePitch() {
return image.getInfoSize(CL10.CL_IMAGE_SLICE_PITCH);
}
@Override
public long getArraySize() {
return image.getInfoSize(CL12.CL_IMAGE_ARRAY_SIZE);
}
@Override
public ImageFormat getImageFormat() {
CLImageFormat format = image.getImageFormat();
return new ImageFormat(encodeImageChannelOrder(format.getChannelOrder()), encodeImageChannelType(format.getChannelType()));
}
@Override
public ImageType getImageType() {
int type = image.getInfoInt(CL10.CL_MEM_TYPE);
return encodeImageType(type);
}
@Override
public int getElementSize() {
return (int) image.getInfoSize(CL10.CL_IMAGE_ELEMENT_SIZE);
}
@Override
public void readImage(CommandQueue queue, ByteBuffer dest, long[] origin, long[] region, long rowPitch, long slicePitch) {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public Event readImageAsync(CommandQueue queue, ByteBuffer dest, long[] origin, long[] region, long rowPitch, long slicePitch) {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public void writeImage(CommandQueue queue, ByteBuffer dest, long[] origin, long[] region, long rowPitch, long slicePitch) {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public Event writeImageAsync(CommandQueue queue, ByteBuffer dest, long[] origin, long[] region, long rowPitch, long slicePitch) {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public void copyTo(CommandQueue queue, Image dest, long[] srcOrigin, long[] destOrigin, long[] region) {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public Event copyToAsync(CommandQueue queue, Image dest, long[] srcOrigin, long[] destOrigin, long[] region) {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public ImageMapping map(CommandQueue queue, long[] origin, long[] region, MappingAccess access) {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public ImageMapping mapAsync(CommandQueue queue, long[] origin, long[] region, MappingAccess access) {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public void unmap(CommandQueue queue, ImageMapping mapping) {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public Event fillAsync(CommandQueue queue, long[] origin, long[] region, ColorRGBA color) {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public Event fillIntegerAsync(CommandQueue queue, long[] origin, long[] region, int[] color) {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public Event copyToBufferAsync(CommandQueue queue, Buffer dest, long[] srcOrigin, long[] srcRegion, long destOffset) {
throw new UnsupportedOperationException("Not supported yet.");
}
}

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

@ -85,6 +85,12 @@ public class LwjglKernel extends Kernel {
int ret = CL10.clSetKernelArg(kernel, index, ((LwjglBuffer) t).getBuffer()); int ret = CL10.clSetKernelArg(kernel, index, ((LwjglBuffer) t).getBuffer());
Utils.checkError(ret, "clSetKernelArg"); Utils.checkError(ret, "clSetKernelArg");
} }
@Override
public void setArg(int index, Image i) {
int ret = CL10.clSetKernelArg(kernel, index, ((LwjglImage) i).getImage());
Utils.checkError(ret, "clSetKernelArg");
}
@Override @Override
public void setArg(int index, byte b) { public void setArg(int index, byte b) {

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

@ -76,14 +76,18 @@ public class Utils {
b16d = b16.asDoubleBuffer(); b16d = b16.asDoubleBuffer();
} }
} }
public static TempBuffer[] tempBuffers = new TempBuffer[8]; public static final ByteBuffer b80; //needed for ImageDescriptor
public static PointerBuffer[] pointerBuffers = new PointerBuffer[8]; public static final LongBuffer b80l;
public static final TempBuffer[] tempBuffers = new TempBuffer[8];
public static final PointerBuffer[] pointerBuffers = new PointerBuffer[8];
static { static {
for (int i=0; i<8; ++i) { for (int i=0; i<8; ++i) {
tempBuffers[i] = new TempBuffer(); tempBuffers[i] = new TempBuffer();
pointerBuffers[i] = PointerBuffer.allocateDirect(4); pointerBuffers[i] = PointerBuffer.allocateDirect(4);
} }
errorBuffer = BufferUtils.createIntBuffer(1); errorBuffer = BufferUtils.createIntBuffer(1);
b80 = BufferUtils.createByteBuffer(80);
b80l = b80.asLongBuffer();
} }
public static IntBuffer errorBuffer; public static IntBuffer errorBuffer;