/** * Releases a shared buffer object. * Call this method after the buffer object was acquired by * {@link #acquireBufferForSharingAsync(com.jme3.opencl.CommandQueue) } * to hand the control back to OpenGL. * The generated event object is directly released, resulting in * performance improvements. * @param queue the command queue */ public void releaseBufferForSharingNoEvent(CommandQueue queue) { //default implementation, overwrite for better performance releaseBufferForSharingAsync(queue).release(); }
/** * Releases a shared image object. * Call this method after the image object was acquired by * {@link #acquireImageForSharingAsync(com.jme3.opencl.CommandQueue) } * to hand the control back to OpenGL. * The generated event object is directly released, resulting in * performance improvements. * @param queue the command queue */ public void releaseImageForSharingNoEvent(CommandQueue queue) { //default implementation, overwrite it for performance improvements releaseImageForSharingAsync(queue).release(); }
private void updateOpenCL(float tpf) { //aquire resource texCL.acquireImageForSharingNoEvent(clQueue); //no need to wait for the returned event, since the kernel implicitely waits for it (same command queue) //execute kernel Kernel.WorkSize ws = new Kernel.WorkSize(settings.getWidth(), settings.getHeight()); kernel.Run1NoEvent(clQueue, ws, texCL, C, 16); //release resource texCL.releaseImageForSharingNoEvent(clQueue); }
/** * Alternative version of {@link #mapAsync(com.jme3.opencl.CommandQueue, long, com.jme3.opencl.MappingAccess) }, * sets {@code size} to {@link #getSize() }. * <b>Important:</b> The mapped memory MUST be released by calling * {@link #unmap(com.jme3.opencl.CommandQueue, java.nio.ByteBuffer) }. */ public AsyncMapping mapAsync(CommandQueue queue, MappingAccess access) { return mapAsync(queue, getSize(), 0, access); }
/** * Alternative version of {@link #writeAsync(com.jme3.opencl.CommandQueue, java.nio.ByteBuffer, long) }, * sets {@code size} to {@link #getSize() }. */ public Event writeAsync(CommandQueue queue, ByteBuffer src) { return writeAsync(queue, src, getSize()); }
/** * Alternative version of {@link #createProgramFromSourceFilesWithInclude(com.jme3.asset.AssetManager, java.lang.String, java.util.List) } * with an empty include string * @throws AssetNotFoundException if a file could not be loaded */ public Program createProgramFromSourceFiles(AssetManager assetManager, List<String> resources) { return createProgramFromSourceFilesWithInclude(assetManager, "", resources); }
/** * Calls {@link #loadFromCache(java.lang.String, java.lang.String) } * with the additional build arguments set to {@code ""}. * @param id a unique identifier of the program * @return the loaded and built program or {@code null} if this * program could not be loaded from the cache * @see #loadFromCache(java.lang.String, java.lang.String) */ public Program loadFromCache(String id) { return loadFromCache(id, ""); }
/** * Alternative version of {@link #copyTo(com.jme3.opencl.CommandQueue, com.jme3.opencl.Buffer, long, long, long) }, * sets {@code srcOffset} and {@code destOffset} to zero. */ public void copyTo(CommandQueue queue, Buffer dest, long size) { copyTo(queue, dest, size, 0, 0); }
@Override public Kernel register() { super.register(); return this; }
/** * Sets the global work size to a 1D grid * @param size the size in 1D */ public void setGlobalWorkSize(int size) { globalWorkSize.set(1, size); }
private void setArgs(Object... args) { for (int i = 0; i < args.length; ++i) { setArg(i, args[i]); } }
/** * Alternative version of {@link #mapAsync(com.jme3.opencl.CommandQueue, long, long, com.jme3.opencl.MappingAccess) }, * sets {@code offset} to zero. * <b>Important:</b> The mapped memory MUST be released by calling * {@link #unmap(com.jme3.opencl.CommandQueue, java.nio.ByteBuffer) }. */ public AsyncMapping mapAsync(CommandQueue queue, long size, MappingAccess access) { return mapAsync(queue, size, 0, access); } /**
@Override @SuppressWarnings("FinalizeDeclaration") protected void finalize() throws Throwable { release(); } @Override
/** * Alternative version of {@link #createBufferFromHost(java.nio.ByteBuffer, com.jme3.opencl.MemoryAccess) }, * creates a buffer with read and write access. * @param data the host buffer to use * @return the new buffer */ public Buffer createBufferFromHost(ByteBuffer data) { return createBufferFromHost(data, MemoryAccess.READ_WRITE); }
@Override public void release() { releaser.release(); } @Override
@Override public Event register() { super.register(); return this; }