getCLEventRegistry() { return clEvents; }
/**
* Called from OpenCL methods that generate CLEvents.
*
* @param event a buffer containing a CLEvent pointer.
*/
void registerCLEvent(final PointerBuffer event) {
if ( event != null )
new CLEvent(event.get(event.position()), this);
}
int release() {
try {
return super.release();
} finally {
if ( !isValid() )
getParent().getCLCommandQueueRegistry().unregisterObject(this);
}
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLEventCallback.java 0000644 0001750 0001750 00000004362 11543426510 022404 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
/**
* Instances of this class can be used to receive OpenCL memory object destruction notifications.
*
* @author Spasi
*/
public abstract class CLEventCallback extends CLCallback {
protected CLEventCallback() {
super(CallbackUtil.getEventCallback());
}
/**
* Called from native code.
*
* @param event_address the CLEvent object pointer
*/
private void handleMessage(long event_address, int event_command_exec_status) {
handleMessage(CLContext.getCLEventGlobal(event_address), event_command_exec_status);
}
/**
* The callback method.
*
* @param event the CLEvent object
*/
protected abstract void handleMessage(CLEvent event, int event_command_exec_status);
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLObjectChild.java 0000644 0001750 0001750 00000004136 11543426510 022057 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
import org.lwjgl.LWJGLUtil;
/**
* Base class for all CLObjects that are associated with a parent CLObject.
*
* @author Spasi
*/
abstract class CLObjectChild extends CLObjectRetainable {
private final P parent;
protected CLObjectChild(final long pointer, final P parent) {
super(pointer);
if ( LWJGLUtil.DEBUG && parent != null && !parent.isValid() )
throw new IllegalStateException("The parent specified is not a valid CL object.");
this.parent = parent;
}
public P getParent() {
return parent;
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLContext.java 0000644 0001750 0001750 00000023434 11543426510 021333 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
import org.lwjgl.LWJGLException;
import org.lwjgl.opencl.api.CLImageFormat;
import org.lwjgl.opencl.api.Filter;
import org.lwjgl.opengl.Drawable;
import java.nio.IntBuffer;
import java.util.List;
/**
* This class is a wrapper around a cl_context pointer.
*
* @author Spasi
*/
public final class CLContext extends CLObjectChild {
private static final CLContextUtil util = (CLContextUtil)CLPlatform.getInfoUtilInstance(CLContext.class, "CL_CONTEXT_UTIL");
private final CLObjectRegistry clCommandQueues;
private final CLObjectRegistry clMems;
private final CLObjectRegistry clSamplers;
private final CLObjectRegistry clPrograms;
private final CLObjectRegistry clEvents;
/** Global registry for build callbacks. */
static final FastLongMap clProgramsGlobal = new FastLongMap();
/** Global registry for event callbacks. */
static final FastLongMap clEventsGlobal = new FastLongMap();
CLContext(final long pointer, final CLPlatform platform) {
super(pointer, platform);
// We do not need to register the context with the platform,
// there is no API that returns cl_context, except clCreateContext.
if ( isValid() ) {
clCommandQueues = new CLObjectRegistry();
clMems = new CLObjectRegistry();
clSamplers = new CLObjectRegistry();
clPrograms = new CLObjectRegistryGlobal(clProgramsGlobal);
clEvents = new CLObjectRegistryGlobal(clEventsGlobal);
} else {
clCommandQueues = null;
clMems = null;
clSamplers = null;
clPrograms = null;
clEvents = null;
}
}
/**
* Returns a CLCommandQueue associated with this context.
*
* @param id the command queue object id
*
* @return the CLCommandQueue object
*/
public CLCommandQueue getCLCommandQueue(final long id) { return clCommandQueues.getObject(id); }
/**
* Returns a CLMem associated with this context.
*
* @param id the memory object id
*
* @return the CLMem object
*/
public CLMem getCLMem(final long id) { return clMems.getObject(id); }
/**
* Returns a CLSampler associated with this context.
*
* @param id the sampler object id
*
* @return the CLSampler object
*/
public CLSampler getCLSampler(final long id) { return clSamplers.getObject(id); }
/**
* Returns a CLProgram associated with this context.
*
* @param id the program object id
*
* @return the CLProgram object
*/
public CLProgram getCLProgram(final long id) { return clPrograms.getObject(id); }
/**
* Returns a user CLEvent associated with this context.
*
* @param id the event object id
*
* @return the CLEvent object
*/
public CLEvent getCLEvent(final long id) { return clEvents.getObject(id); }
// ---------------[ UTILITY METHODS ]---------------
/**
* Creates a new CLContext.
*
* @param platform the platform to use
* @param devices the devices to use
* @param errcode_ret the error code result
*
* @return the new CLContext
*
* @throws LWJGLException if an exception occurs while creating the context
*/
public static CLContext create(final CLPlatform platform, final List devices, final IntBuffer errcode_ret) throws LWJGLException {
return create(platform, devices, null, null, errcode_ret);
}
/**
* Creates a new CLContext.
*
* @param platform the platform to use
* @param devices the devices to use
* @param pfn_notify the context callback function
* @param errcode_ret the error code result
*
* @return the new CLContext
*
* @throws LWJGLException if an exception occurs while creating the context
*/
public static CLContext create(final CLPlatform platform, final List devices, final CLContextCallback pfn_notify, final IntBuffer errcode_ret) throws LWJGLException {
return create(platform, devices, pfn_notify, null, errcode_ret);
}
/**
* Creates a new CLContext.
*
* @param platform the platform to use
* @param devices the devices to use
* @param share_drawable the OpenGL drawable to share objects with
* @param errcode_ret the error code result
*
* @return the new CLContext
*
* @throws LWJGLException if an exception occurs while creating the context
*/
public static CLContext create(final CLPlatform platform, final List devices, final CLContextCallback pfn_notify, final Drawable share_drawable, final IntBuffer errcode_ret) throws LWJGLException {
return util.create(platform, devices, pfn_notify, share_drawable, errcode_ret);
}
/**
* Creates a new CLContext.
*
* @param platform the platform to use
* @param device_type the device type to use
* @param errcode_ret the error code result
*
* @return the new CLContext
*
* @throws LWJGLException if an exception occurs while creating the context
*/
public static CLContext createFromType(final CLPlatform platform, final long device_type, final IntBuffer errcode_ret) throws LWJGLException {
return util.createFromType(platform, device_type, null, null, errcode_ret);
}
/**
* Creates a new CLContext.
*
* @param platform the platform to use
* @param device_type the device type to use
* @param pfn_notify the context callback function
* @param errcode_ret the error code result
*
* @return the new CLContext
*
* @throws LWJGLException if an exception occurs while creating the context
*/
public static CLContext createFromType(final CLPlatform platform, final long device_type, final CLContextCallback pfn_notify, final IntBuffer errcode_ret) throws LWJGLException {
return util.createFromType(platform, device_type, pfn_notify, null, errcode_ret);
}
/**
* Creates a new CLContext.
*
* @param platform the platform to use
* @param device_type the device type to use
* @param share_drawable the OpenGL drawable to share objects with
* @param errcode_ret the error code result
*
* @return the new CLContext
*
* @throws LWJGLException if an exception occurs while creating the context
*/
public static CLContext createFromType(final CLPlatform platform, final long device_type, final CLContextCallback pfn_notify, final Drawable share_drawable, final IntBuffer errcode_ret) throws LWJGLException {
return util.createFromType(platform, device_type, pfn_notify, share_drawable, errcode_ret);
}
/**
* Returns the integer value of the specified parameter.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public int getInfoInt(int param_name) {
return util.getInfoInt(this, param_name);
}
/**
* Returns the list of devices in context.
*
* @return the list of devices
*/
public List getInfoDevices() {
return util.getInfoDevices(this);
}
public List getSupportedImageFormats(final long flags, final int image_type) {
return getSupportedImageFormats(flags, image_type, null);
}
public List getSupportedImageFormats(final long flags, final int image_type, final Filter filter) {
return util.getSupportedImageFormats(this, flags, image_type, filter);
}
/** CLContext utility methods interface. */
interface CLContextUtil extends InfoUtil {
List getInfoDevices(CLContext context);
CLContext create(CLPlatform platform, List devices, CLContextCallback pfn_notify, Drawable share_drawable, IntBuffer errcode_ret) throws LWJGLException;
CLContext createFromType(CLPlatform platform, long device_type, CLContextCallback pfn_notify, Drawable share_drawable, IntBuffer errcode_ret) throws LWJGLException;
List getSupportedImageFormats(CLContext context, final long flags, final int image_type, Filter filter);
}
// -------[ IMPLEMENTATION STUFF BELOW ]-------
CLObjectRegistry getCLCommandQueueRegistry() { return clCommandQueues; }
CLObjectRegistry getCLMemRegistry() { return clMems; }
CLObjectRegistry getCLSamplerRegistry() { return clSamplers; }
CLObjectRegistry getCLProgramRegistry() { return clPrograms; }
CLObjectRegistry getCLEventRegistry() { return clEvents; }
static CLProgram getCLProgramGlobal(final long id) { return clProgramsGlobal.get(id); }
static CLEvent getCLEventGlobal(final long id) { return clEventsGlobal.get(id); }
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/OpenCLException.java 0000644 0001750 0001750 00000003704 11543426510 022465 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
public class OpenCLException extends RuntimeException {
private static final long serialVersionUID = 1L;
public OpenCLException() {
super();
}
public OpenCLException(final String message) {
super(message);
}
public OpenCLException(final String message, final Throwable cause) {
super(message, cause);
}
public OpenCLException(final Throwable cause) {
super(cause);
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLNativeKernel.java 0000644 0001750 0001750 00000004613 11543426510 022274 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
import java.nio.ByteBuffer;
/**
* Instances of this class can be used to execute native kernels. clEnqueueNativeKernel will build
* the its arguments automatically, in a way that allows execute to receive an array
* of ByteBuffers, pointing to cl_mem objects in global memory. The ByteBuffer objects should not
* be used outside the handleMessage method.
*
* @author Spasi
* @see CL10#clEnqueueNativeKernel
* @see #execute(java.nio.ByteBuffer[])
*/
public abstract class CLNativeKernel extends CLCallback {
protected CLNativeKernel() {
super(CallbackUtil.getNativeKernelCallback());
}
/**
* Implement this method to execute an action on cl_mem objects in global memory.
*
* @param memobjs an array of ByteBuffers pointing to cl_mem global memory.
*/
protected abstract void execute(ByteBuffer[] memobjs);
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLObjectRetainable.java 0000644 0001750 0001750 00000004422 11543426510 023100 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
/**
* Base class for all retainable OpenCL objects.
*
* @author Spasi
*/
abstract class CLObjectRetainable extends CLObject {
private int refCount;
protected CLObjectRetainable(final long pointer) {
super(pointer);
if ( super.isValid() )
this.refCount = 1;
}
public final int getReferenceCount() {
return refCount;
}
public final boolean isValid() {
return refCount > 0;
}
int retain() {
checkValid();
//System.out.println(getClass().getSimpleName() + " REF COUNT: " + pointer + " - " + (refCount + 1));
return ++refCount;
}
int release() {
checkValid();
//System.out.println(getClass().getSimpleName() + " REF COUNT: " + pointer + " - " + (refCount - 1));
return --refCount;
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLMemObjectDestructorCallback.java 0000644 0001750 0001750 00000004010 11543426510 025235 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
/**
* Instances of this class can be used to receive OpenCL memory object destruction notifications.
*
* @author Spasi
*/
public abstract class CLMemObjectDestructorCallback extends CLCallback {
protected CLMemObjectDestructorCallback() {
super(CallbackUtil.getMemObjectDestructorCallback());
}
/**
* The callback method.
*
* @param memobj id of the CLMem object that was destroyed
*/
protected abstract void handleMessage(long memobj);
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/InfoUtil.java 0000644 0001750 0001750 00000003742 11543426510 021221 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
/**
* Base interface for information utility classes.
*
* @author Spasi
*/
interface InfoUtil {
int getInfoInt(final T object, final int param_name);
long getInfoSize(final T object, final int param_name);
long[] getInfoSizeArray(final T object, final int param_name);
long getInfoLong(final T object, final int param_name);
String getInfoString(final T object, final int param_name);
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/api/ 0000755 0001750 0001750 00000000000 11543426510 017370 5 ustar zero79 zero79 lwjgl-2.7.1/src/java/org/lwjgl/opencl/api/CLImageFormat.java 0000644 0001750 0001750 00000004141 11543426510 022645 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl.api;
/**
* Simple container for cl_image_format struct values.
*
* @author Spasi
*/
public final class CLImageFormat {
/** The cl_image_format struct size in bytes. */
public static final int STRUCT_SIZE = 2 * 4;
private final int channelOrder;
private final int channelType;
public CLImageFormat(final int channelOrder, final int channelType) {
this.channelOrder = channelOrder;
this.channelType = channelType;
}
public int getChannelOrder() {
return channelOrder;
}
public int getChannelType() {
return channelType;
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/api/Filter.java 0000644 0001750 0001750 00000003523 11543426510 021463 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl.api;
/**
* Simple filter interface.
*
* @author Spasi
*/
public interface Filter {
/**
* Returns true if the specified object passes the filter.
*
* @param object the object to test
*
* @return true if the object is accepted
*/
boolean accept(T object);
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/api/CLBufferRegion.java 0000644 0001750 0001750 00000004125 11543426510 023031 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl.api;
import org.lwjgl.PointerBuffer;
/**
* Simple container for cl_buffer_region struct values.
*
* @author Spasi
*/
public final class CLBufferRegion {
/** The cl_buffer_region struct size in bytes. */
public static final int STRUCT_SIZE = 2 * PointerBuffer.getPointerSize();
private final int origin;
private final int size;
public CLBufferRegion(final int origin, final int size) {
this.origin = origin;
this.size = size;
}
public int getOrigin() {
return origin;
}
public int getSize() {
return size;
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/APIUtil.java 0000644 0001750 0001750 00000037515 11543426510 020744 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
import org.lwjgl.BufferUtils;
import org.lwjgl.LWJGLUtil;
import org.lwjgl.PointerBuffer;
import org.lwjgl.opencl.FastLongMap.Entry;
import java.nio.*;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;
import static org.lwjgl.opencl.APPLEGLSharing.*;
import static org.lwjgl.opencl.CL10.*;
import static org.lwjgl.opencl.EXTDeviceFission.*;
import static org.lwjgl.opencl.KHRGLSharing.*;
/**
* Utility class for OpenCL API calls.
*
* @author spasi
*/
final class APIUtil {
private static final int INITIAL_BUFFER_SIZE = 256;
private static final int INITIAL_LENGTHS_SIZE = 4;
private static final int BUFFERS_SIZE = 32;
private static final ThreadLocal arrayTL = new ThreadLocal() {
protected char[] initialValue() { return new char[INITIAL_BUFFER_SIZE]; }
};
private static final ThreadLocal bufferByteTL = new ThreadLocal() {
protected ByteBuffer initialValue() { return BufferUtils.createByteBuffer(INITIAL_BUFFER_SIZE); }
};
private static final ThreadLocal bufferPointerTL = new ThreadLocal() {
protected PointerBuffer initialValue() { return BufferUtils.createPointerBuffer(INITIAL_BUFFER_SIZE); }
};
private static final ThreadLocal lengthsTL = new ThreadLocal() {
protected PointerBuffer initialValue() { return BufferUtils.createPointerBuffer(INITIAL_LENGTHS_SIZE); }
};
private static final ThreadLocal buffersTL = new ThreadLocal() {
protected Buffers initialValue() { return new Buffers(); }
};
private APIUtil() {
}
private static char[] getArray(final int size) {
char[] array = arrayTL.get();
if ( array.length < size ) {
int sizeNew = array.length << 1;
while ( sizeNew < size )
sizeNew <<= 1;
array = new char[size];
arrayTL.set(array);
}
return array;
}
static ByteBuffer getBufferByte(final int size) {
ByteBuffer buffer = bufferByteTL.get();
if ( buffer.capacity() < size ) {
int sizeNew = buffer.capacity() << 1;
while ( sizeNew < size )
sizeNew <<= 1;
buffer = BufferUtils.createByteBuffer(size);
bufferByteTL.set(buffer);
} else
buffer.clear();
return buffer;
}
private static ByteBuffer getBufferByteOffset(final int size) {
ByteBuffer buffer = bufferByteTL.get();
if ( buffer.capacity() < size ) {
int sizeNew = buffer.capacity() << 1;
while ( sizeNew < size )
sizeNew <<= 1;
final ByteBuffer bufferNew = BufferUtils.createByteBuffer(size);
bufferNew.put(buffer);
bufferByteTL.set(buffer = bufferNew);
} else {
buffer.position(buffer.limit());
buffer.limit(buffer.capacity());
}
return buffer;
}
static PointerBuffer getBufferPointer(final int size) {
PointerBuffer buffer = bufferPointerTL.get();
if ( buffer.capacity() < size ) {
int sizeNew = buffer.capacity() << 1;
while ( sizeNew < size )
sizeNew <<= 1;
buffer = BufferUtils.createPointerBuffer(size);
bufferPointerTL.set(buffer);
} else
buffer.clear();
return buffer;
}
static ShortBuffer getBufferShort() { return buffersTL.get().shorts; }
static IntBuffer getBufferInt() { return buffersTL.get().ints; }
static IntBuffer getBufferIntDebug() { return buffersTL.get().intsDebug; }
static LongBuffer getBufferLong() { return buffersTL.get().longs; }
static FloatBuffer getBufferFloat() { return buffersTL.get().floats; }
static DoubleBuffer getBufferDouble() { return buffersTL.get().doubles; }
static PointerBuffer getBufferPointer() { return buffersTL.get().pointers; }
static PointerBuffer getLengths() {
return getLengths(1);
}
static PointerBuffer getLengths(final int size) {
PointerBuffer lengths = lengthsTL.get();
if ( lengths.capacity() < size ) {
int sizeNew = lengths.capacity();
while ( sizeNew < size )
sizeNew <<= 1;
lengths = BufferUtils.createPointerBuffer(size);
lengthsTL.set(lengths);
} else
lengths.clear();
return lengths;
}
/**
* Simple ASCII encoding.
*
* @param buffer The target buffer
* @param string The source string
*/
private static ByteBuffer encode(final ByteBuffer buffer, final CharSequence string) {
for ( int i = 0; i < string.length(); i++ ) {
final char c = string.charAt(i);
if ( LWJGLUtil.DEBUG && 0x80 <= c ) // Silently ignore and map to 0x1A.
buffer.put((byte)0x1A);
else
buffer.put((byte)c);
}
return buffer;
}
/**
* Reads a byte string from the specified buffer.
*
* @param buffer
*
* @return the buffer as a String.
*/
static String getString(final ByteBuffer buffer) {
final int length = buffer.remaining();
final char[] charArray = getArray(length);
for ( int i = buffer.position(); i < buffer.limit(); i++ )
charArray[i - buffer.position()] = (char)buffer.get(i);
return new String(charArray, 0, length);
}
/**
* Returns a buffer containing the specified string as bytes.
*
* @param string
*
* @return the String as a ByteBuffer
*/
static ByteBuffer getBuffer(final CharSequence string) {
final ByteBuffer buffer = encode(getBufferByte(string.length()), string);
buffer.flip();
return buffer;
}
/**
* Returns a buffer containing the specified string as bytes, starting at the specified offset.
*
* @param string
*
* @return the String as a ByteBuffer
*/
static ByteBuffer getBuffer(final CharSequence string, final int offset) {
final ByteBuffer buffer = encode(getBufferByteOffset(offset + string.length()), string);
buffer.flip();
return buffer;
}
/**
* Returns a buffer containing the specified string as bytes, including null-termination.
*
* @param string
*
* @return the String as a ByteBuffer
*/
static ByteBuffer getBufferNT(final CharSequence string) {
final ByteBuffer buffer = encode(getBufferByte(string.length() + 1), string);
buffer.put((byte)0);
buffer.flip();
return buffer;
}
static int getTotalLength(final CharSequence[] strings) {
int length = 0;
for ( CharSequence string : strings )
length += string.length();
return length;
}
/**
* Returns a buffer containing the specified strings as bytes.
*
* @param strings
*
* @return the Strings as a ByteBuffer
*/
static ByteBuffer getBuffer(final CharSequence[] strings) {
final ByteBuffer buffer = getBufferByte(getTotalLength(strings));
for ( CharSequence string : strings )
encode(buffer, string);
buffer.flip();
return buffer;
}
/**
* Returns a buffer containing the specified strings as bytes, including null-termination.
*
* @param strings
*
* @return the Strings as a ByteBuffer
*/
static ByteBuffer getBufferNT(final CharSequence[] strings) {
final ByteBuffer buffer = getBufferByte(getTotalLength(strings) + strings.length);
for ( CharSequence string : strings ) {
encode(buffer, string);
buffer.put((byte)0);
}
buffer.flip();
return buffer;
}
/**
* Returns a buffer containing the lengths of the specified strings.
*
* @param strings
*
* @return the String lengths in a PointerBuffer
*/
static PointerBuffer getLengths(final CharSequence[] strings) {
PointerBuffer buffer = getLengths(strings.length);
for ( CharSequence string : strings )
buffer.put(string.length());
buffer.flip();
return buffer;
}
/**
* Returns a buffer containing the lengths of the specified buffers.
*
* @param buffers the buffer array
*
* @return the buffer lengths in a PointerBuffer
*/
static PointerBuffer getLengths(final ByteBuffer[] buffers) {
PointerBuffer lengths = getLengths(buffers.length);
for ( ByteBuffer buffer : buffers )
lengths.put(buffer.remaining());
lengths.flip();
return lengths;
}
static int getSize(final PointerBuffer lengths) {
long size = 0;
for ( int i = lengths.position(); i < lengths.limit(); i++ )
size += lengths.get(i);
return (int)size;
}
private static class Buffers {
final ShortBuffer shorts;
final IntBuffer ints;
final IntBuffer intsDebug;
final LongBuffer longs;
final FloatBuffer floats;
final DoubleBuffer doubles;
final PointerBuffer pointers;
Buffers() {
shorts = BufferUtils.createShortBuffer(BUFFERS_SIZE);
ints = BufferUtils.createIntBuffer(BUFFERS_SIZE);
intsDebug = BufferUtils.createIntBuffer(1);
longs = BufferUtils.createLongBuffer(BUFFERS_SIZE);
floats = BufferUtils.createFloatBuffer(BUFFERS_SIZE);
doubles = BufferUtils.createDoubleBuffer(BUFFERS_SIZE);
pointers = BufferUtils.createPointerBuffer(BUFFERS_SIZE);
}
}
/* ------------------------------------------------------------------------
---------------------------------------------------------------------------
OPENCL API UTILITIES BELOW
---------------------------------------------------------------------------
------------------------------------------------------------------------ */
static Set getExtensions(final String extensionList) {
final Set extensions = new HashSet();
if ( extensionList != null ) {
final StringTokenizer tokenizer = new StringTokenizer(extensionList);
while ( tokenizer.hasMoreTokens() )
extensions.add(tokenizer.nextToken());
}
return extensions;
}
static boolean isDevicesParam(final int param_name) {
switch ( param_name ) {
case CL_CONTEXT_DEVICES:
case CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR:
case CL_DEVICES_FOR_GL_CONTEXT_KHR:
case CL_CGL_DEVICE_FOR_CURRENT_VIRTUAL_SCREEN_APPLE:
case CL_CGL_DEVICES_FOR_SUPPORTED_VIRTUAL_SCREENS_APPLE:
return true;
}
return false;
}
static CLPlatform getCLPlatform(final PointerBuffer properties) {
long platformID = 0;
final int keys = properties.remaining() / 2;
for ( int k = 0; k < keys; k++ ) {
final long key = properties.get(k << 1);
if ( key == 0 )
break;
if ( key == CL_CONTEXT_PLATFORM ) {
platformID = properties.get((k << 1) + 1);
break;
}
}
if ( platformID == 0 )
throw new IllegalArgumentException("Could not find CL_CONTEXT_PLATFORM in cl_context_properties.");
final CLPlatform platform = CLPlatform.getCLPlatform(platformID);
if ( platform == null )
throw new IllegalStateException("Could not find a valid CLPlatform. Make sure clGetPlatformIDs has been used before.");
return platform;
}
static ByteBuffer getNativeKernelArgs(final long user_func_ref, final CLMem[] clMems, final long[] sizes) {
final ByteBuffer args = getBufferByte(8 + 4 + (clMems == null ? 0 : clMems.length * (4 + PointerBuffer.getPointerSize())));
args.putLong(0, user_func_ref);
if ( clMems == null )
args.putInt(8, 0);
else {
args.putInt(8, clMems.length);
int byteIndex = 12;
for ( int i = 0; i < clMems.length; i++ ) {
if ( LWJGLUtil.DEBUG && !clMems[i].isValid() )
throw new IllegalArgumentException("An invalid CLMem object was specified.");
args.putInt(byteIndex, (int)sizes[i]); // CLMem size
byteIndex += (4 + PointerBuffer.getPointerSize()); // Skip size and make room for the pointer
}
}
return args;
}
// ------------------------------------------------------------------------------------
/**
* Releases all sub-devices created from the specified CLDevice.
*
* @param device the CLDevice to clear
*/
static void releaseObjects(final CLDevice device) {
// Release objects only if we're about to hit 0.
if ( device.getReferenceCount() > 1 )
return;
releaseObjects(device.getSubCLDeviceRegistry(), DESTRUCTOR_CLSubDevice);
}
/**
* Releases all objects contained in the specified CLContext.
*
* @param context the CLContext to clear
*/
static void releaseObjects(final CLContext context) {
// Release objects only if we're about to hit 0.
if ( context.getReferenceCount() > 1 )
return;
releaseObjects(context.getCLEventRegistry(), DESTRUCTOR_CLEvent);
releaseObjects(context.getCLProgramRegistry(), DESTRUCTOR_CLProgram);
releaseObjects(context.getCLSamplerRegistry(), DESTRUCTOR_CLSampler);
releaseObjects(context.getCLMemRegistry(), DESTRUCTOR_CLMem);
releaseObjects(context.getCLCommandQueueRegistry(), DESTRUCTOR_CLCommandQueue);
}
/**
* Releases all objects contained in the specified CLProgram.
*
* @param program the CLProgram to clear
*/
static void releaseObjects(final CLProgram program) {
// Release objects only if we're about to hit 0.
if ( program.getReferenceCount() > 1 )
return;
releaseObjects(program.getCLKernelRegistry(), DESTRUCTOR_CLKernel);
}
/**
* Releases all objects contained in the specified CLCommandQueue.
*
* @param queue the CLCommandQueue to clear
*/
static void releaseObjects(final CLCommandQueue queue) {
// Release objects only if we're about to hit 0.
if ( queue.getReferenceCount() > 1 )
return;
releaseObjects(queue.getCLEventRegistry(), DESTRUCTOR_CLEvent);
}
private static void releaseObjects(final CLObjectRegistry registry, final ObjectDestructor destructor) {
if ( registry.isEmpty() )
return;
for ( Entry entry : registry.getAll() ) {
final T object = entry.value;
while ( object.isValid() )
destructor.release(object);
}
}
private static final ObjectDestructor DESTRUCTOR_CLSubDevice = new ObjectDestructor() {
public void release(final CLDevice object) { clReleaseDeviceEXT(object); }
};
private static final ObjectDestructor DESTRUCTOR_CLMem = new ObjectDestructor() {
public void release(final CLMem object) { clReleaseMemObject(object); }
};
private static final ObjectDestructor DESTRUCTOR_CLCommandQueue = new ObjectDestructor() {
public void release(final CLCommandQueue object) { clReleaseCommandQueue(object); }
};
private static final ObjectDestructor DESTRUCTOR_CLSampler = new ObjectDestructor() {
public void release(final CLSampler object) { clReleaseSampler(object); }
};
private static final ObjectDestructor DESTRUCTOR_CLProgram = new ObjectDestructor() {
public void release(final CLProgram object) { clReleaseProgram(object); }
};
private static final ObjectDestructor DESTRUCTOR_CLKernel = new ObjectDestructor() {
public void release(final CLKernel object) { clReleaseKernel(object); }
};
private static final ObjectDestructor DESTRUCTOR_CLEvent = new ObjectDestructor() {
public void release(final CLEvent object) { clReleaseEvent(object); }
};
private interface ObjectDestructor {
void release(T object);
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CL.java 0000644 0001750 0001750 00000011150 11543426510 017756 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
import org.lwjgl.LWJGLException;
import org.lwjgl.LWJGLUtil;
import org.lwjgl.Sys;
import java.nio.ByteBuffer;
/**
* LWJGL users must use this class to initialize OpenCL
* before using any other class in the org.lwjgl.opencl package.
*
* @author Spasi
*/
public final class CL {
private static boolean created;
static {
Sys.initialize();
}
private CL() {
}
/**
* Native method to create CL instance
*
* @param oclPaths Array of strings containing paths to search for OpenCL library
*/
private static native void nCreate(String oclPaths) throws LWJGLException;
/**
* Native method to create CL instance from the Mac OS X 10.4 OpenCL framework.
* It is only defined in the Mac OS X native library.
*/
private static native void nCreateDefault() throws LWJGLException;
/** Native method the destroy the CL */
private static native void nDestroy();
/** @return true if CL has been created */
public static boolean isCreated() {
return created;
}
public static void create() throws LWJGLException {
if ( created )
return;
//throw new IllegalStateException("OpenCL has already been created.");
final String libname;
final String[] library_names;
switch ( LWJGLUtil.getPlatform() ) {
case LWJGLUtil.PLATFORM_WINDOWS:
libname = "OpenCL";
library_names = new String[] { "OpenCL.dll" };
break;
case LWJGLUtil.PLATFORM_LINUX:
libname = "OpenCL";
library_names = new String[] { "libOpenCL64.so", "libOpenCL.so" }; // TODO: Fix this
break;
case LWJGLUtil.PLATFORM_MACOSX:
libname = "OpenCL";
library_names = new String[] { "OpenCL.dylib" }; // TODO: Fix this
break;
default:
throw new LWJGLException("Unknown platform: " + LWJGLUtil.getPlatform());
}
final String[] oclPaths = LWJGLUtil.getLibraryPaths(libname, library_names, CL.class.getClassLoader());
LWJGLUtil.log("Found " + oclPaths.length + " OpenCL paths");
for ( String oclPath : oclPaths ) {
try {
nCreate(oclPath);
created = true;
break;
} catch (LWJGLException e) {
LWJGLUtil.log("Failed to load " + oclPath + ": " + e.getMessage());
}
}
if ( !created && LWJGLUtil.getPlatform() == LWJGLUtil.PLATFORM_MACOSX ) {
// Try to load OpenCL from the framework instead
nCreateDefault();
created = true;
}
if ( !created )
throw new LWJGLException("Could not locate OpenCL library.");
if ( !CLCapabilities.OpenCL10 )
throw new RuntimeException("OpenCL 1.0 not supported.");
}
public static void destroy() {
}
/**
* Helper method to get a pointer to a named function with aliases in the OpenCL library.
*
* @param aliases the function name aliases.
*
* @return the function pointer address
*/
static long getFunctionAddress(String[] aliases) {
for ( String aliase : aliases ) {
long address = getFunctionAddress(aliase);
if ( address != 0 )
return address;
}
return 0;
}
static native long getFunctionAddress(String name);
static native ByteBuffer getHostBuffer(final long address, final int size);
private static native void resetNativeStubs(Class clazz);
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLMem.java 0000644 0001750 0001750 00000021571 11543426510 020425 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
import org.lwjgl.opencl.api.CLBufferRegion;
import org.lwjgl.opencl.api.CLImageFormat;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
/**
* This class is a wrapper around a cl_mem pointer.
*
* @author Spasi
*/
public final class CLMem extends CLObjectChild {
private static final CLMemUtil util = (CLMemUtil)CLPlatform.getInfoUtilInstance(CLMem.class, "CL_MEM_UTIL");
CLMem(final long pointer, final CLContext context) {
super(pointer, context);
if ( isValid() )
context.getCLMemRegistry().registerObject(this);
}
// ---------------[ UTILITY METHODS ]---------------
/**
* Creates a new 2D image object.
*
* @param context the context on which to create the image object
* @param flags the memory object flags
* @param image_format the image format
* @param image_width the image width
* @param image_height the image height
* @param image_row_pitch the image row pitch
* @param host_ptr the host buffer from which to read image data (optional)
* @param errcode_ret the error code result
*
* @return the new CLMem object
*/
public static CLMem createImage2D(final CLContext context, final long flags, final CLImageFormat image_format,
final long image_width, final long image_height, final long image_row_pitch,
final Buffer host_ptr, final IntBuffer errcode_ret) {
return util.createImage2D(context, flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret);
}
/**
* Creates a new 3D image object.
*
* @param context the context on which to create the image object
* @param flags the memory object flags
* @param image_format the image format
* @param image_width the image width
* @param image_height the image height
* @param image_depth the image depth
* @param image_row_pitch the image row pitch
* @param image_slice_pitch the image slice pitch
* @param host_ptr the host buffer from which to read image data (optional)
* @param errcode_ret the error code result
*
* @return the new CLMem object
*/
public static CLMem createImage3D(final CLContext context, final long flags, final CLImageFormat image_format,
final long image_width, final long image_height, final long image_depth, final long image_row_pitch, final long image_slice_pitch,
final Buffer host_ptr, final IntBuffer errcode_ret) {
return util.createImage3D(context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret);
}
public CLMem createSubBuffer(final long flags, final int buffer_create_type, final CLBufferRegion buffer_create_info, final IntBuffer errcode_ret) {
return util.createSubBuffer(this, flags, buffer_create_type, buffer_create_info, errcode_ret);
}
/**
* Returns the integer value of the specified parameter.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public int getInfoInt(int param_name) {
return util.getInfoInt(this, param_name);
}
/**
* Returns the size_t value of the specified parameter.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public long getInfoSize(int param_name) {
return util.getInfoSize(this, param_name);
}
/**
* Returns the long value of the specified parameter. Can be used
* for both cl_ulong and cl_bitfield parameters.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public long getInfoLong(int param_name) {
return util.getInfoLong(this, param_name);
}
/**
* Returns a direct ByteBuffer instance that points to the host
* memory that backs this CLMem object. Applicable only to CLMem
* objects that were created with the CL_MEM_USE_HOST_PTR flag.
*
* @return the host memory ByteBuffer
*/
public ByteBuffer getInfoHostBuffer() {
return util.getInfoHostBuffer(this);
}
// clGetImageInfo methods
/**
* Returns the size_t value of the specified parameter. Applicable to image objects only.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public long getImageInfoSize(int param_name) {
return util.getImageInfoSize(this, param_name);
}
/**
* Returns the image format. Applicable to image objects only.
*
* @return the parameter value
*/
public CLImageFormat getImageFormat() {
return util.getImageInfoFormat(this);
}
/**
* Returns the image channel order. Applicable to image objects only.
*
* @return the parameter value
*/
public int getImageChannelOrder() {
return util.getImageInfoFormat(this, 0);
}
/**
* Returns the image channel type. Applicable to image objects only.
*
* @return the parameter value
*/
public int getImageChannelType() {
return util.getImageInfoFormat(this, 1);
}
// clGetGLObjectInfo methods
/**
* Returns the GL object type. Applicable to CLMem objects
* that have been created GL objects only.
*
* @return the parameter value
*/
public int getGLObjectType() {
return util.getGLObjectType(this);
}
/**
* Returns the GL object name. Applicable to CLMem objects
* that have been created GL objects only.
*
* @return the parameter value
*/
public int getGLObjectName() {
return util.getGLObjectName(this);
}
// clGetGLTextureInfo methods
/**
* Returns the int value of the specified parameter. Applicable to CLMem objects
* that have been created by GL textures only.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public int getGLTextureInfoInt(int param_name) {
return util.getGLTextureInfoInt(this, param_name);
}
/** CLMem utility methods interface. */
interface CLMemUtil extends InfoUtil {
CLMem createImage2D(CLContext context, long flags, CLImageFormat image_format, long image_width, long image_height, long image_row_pitch, Buffer host_ptr, IntBuffer errcode_ret);
CLMem createImage3D(CLContext context, long flags, CLImageFormat image_format, long image_width, long image_height, long image_depth, long image_row_pitch, long image_slice_pitch, Buffer host_ptr, IntBuffer errcode_ret);
CLMem createSubBuffer(CLMem mem, long flags, int buffer_create_type, CLBufferRegion buffer_create_info, IntBuffer errcode_ret);
ByteBuffer getInfoHostBuffer(CLMem mem);
long getImageInfoSize(CLMem mem, int param_name);
CLImageFormat getImageInfoFormat(CLMem mem);
int getImageInfoFormat(CLMem mem, int index);
int getGLObjectType(CLMem mem);
int getGLObjectName(CLMem mem);
int getGLTextureInfoInt(CLMem mem, int param_name);
}
// -------[ IMPLEMENTATION STUFF BELOW ]-------
/**
* Sub-buffer factory. clCreateSubBuffer may return an existing CLMem.
*
* @param pointer the sub-buffer id
* @param context the context in which the sub-buffer was created
*
* @return the CLMem that represents the sub-buffer
*/
static CLMem create(final long pointer, final CLContext context) {
CLMem clMem = context.getCLMemRegistry().getObject(pointer);
if ( clMem == null )
clMem = new CLMem(pointer, context);
else
clMem.retain();
return clMem;
}
int release() {
try {
return super.release();
} finally {
if ( !isValid() )
getParent().getCLMemRegistry().unregisterObject(this);
}
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLEvent.java 0000644 0001750 0001750 00000007303 11543426510 020765 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
/**
* This class is a wrapper around a cl_mem pointer.
*
* @author Spasi
*/
public final class CLEvent extends CLObjectChild {
private static final CLEventUtil util = (CLEventUtil)CLPlatform.getInfoUtilInstance(CLEvent.class, "CL_EVENT_UTIL");
private final CLCommandQueue queue;
CLEvent(final long pointer, final CLContext context) {
this(pointer, context, null);
}
CLEvent(final long pointer, final CLCommandQueue queue) {
this(pointer, queue.getParent(), queue);
}
CLEvent(final long pointer, final CLContext context, final CLCommandQueue queue) {
super(pointer, context);
if ( isValid() ) {
this.queue = queue;
if ( queue == null )
context.getCLEventRegistry().registerObject(this);
else
queue.getCLEventRegistry().registerObject(this);
} else
this.queue = null;
}
/**
* Returns the command-queue associated with this event. For
* user events this method returns null.
*
* @return the command-queue or null if this is a user event
*/
public CLCommandQueue getCLCommandQueue() {
return queue;
}
// ---------------[ UTILITY METHODS ]---------------
/**
* Returns the integer value of the specified parameter.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public int getInfoInt(final int param_name) {
return util.getInfoInt(this, param_name);
}
// clGetEventProfilingInfo methods
/**
* Returns the long value of the specified parameter. Can be used
* for both cl_ulong and cl_bitfield parameters.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public long getProfilingInfoLong(int param_name) {
return util.getProfilingInfoLong(this, param_name);
}
/** CLEvent utility methods interface. */
interface CLEventUtil extends InfoUtil {
long getProfilingInfoLong(CLEvent event, int param_name);
}
// -------[ IMPLEMENTATION STUFF BELOW ]-------
int release() {
try {
return super.release();
} finally {
if ( !isValid() ) {
if ( queue == null )
getParent().getCLEventRegistry().unregisterObject(this);
else
queue.getCLEventRegistry().unregisterObject(this);
}
}
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/InfoUtilAbstract.java 0000644 0001750 0001750 00000010332 11543426510 022676 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
import org.lwjgl.LWJGLUtil;
import org.lwjgl.PointerBuffer;
import java.nio.ByteBuffer;
import static org.lwjgl.opencl.CL10.*;
/**
* Base implementation of information utility classes.
*
* @author Spasi
*/
abstract class InfoUtilAbstract implements InfoUtil {
protected InfoUtilAbstract() {
}
protected abstract int getInfo(T object, int param_name, ByteBuffer param_value, PointerBuffer param_value_size_ret);
// Optional
protected int getInfoSizeArraySize(final T object, final int param_name) {
throw new UnsupportedOperationException();
}
protected PointerBuffer getSizesBuffer(final T object, final int param_name) {
final int size = getInfoSizeArraySize(object, param_name);
final PointerBuffer buffer = APIUtil.getBufferPointer(size);
buffer.limit(size);
getInfo(object, param_name, buffer.getBuffer(), null);
return buffer;
}
public int getInfoInt(final T object, final int param_name) {
object.checkValid();
final ByteBuffer buffer = APIUtil.getBufferByte(4);
getInfo(object, param_name, buffer, null);
return buffer.getInt(0);
}
public long getInfoSize(final T object, final int param_name) {
object.checkValid();
final PointerBuffer buffer = APIUtil.getBufferPointer();
getInfo(object, param_name, buffer.getBuffer(), null);
return buffer.get(0);
}
public long[] getInfoSizeArray(final T object, final int param_name) {
object.checkValid();
final int size = getInfoSizeArraySize(object, param_name);
final PointerBuffer buffer = APIUtil.getBufferPointer(size);
getInfo(object, param_name, buffer.getBuffer(), null);
final long[] array = new long[size];
for ( int i = 0; i < size; i++ )
array[i] = buffer.get(i);
return array;
}
public long getInfoLong(final T object, final int param_name) {
object.checkValid();
final ByteBuffer buffer = APIUtil.getBufferByte(8);
getInfo(object, param_name, buffer, null);
return buffer.getLong(0);
}
public String getInfoString(final T object, final int param_name) {
object.checkValid();
final int bytes = getSizeRet(object, param_name);
if ( bytes <= 1 )
return null;
final ByteBuffer buffer = APIUtil.getBufferByte(bytes);
getInfo(object, param_name, buffer, null);
buffer.limit(bytes - 1); // Exclude null-termination
return APIUtil.getString(buffer);
}
protected final int getSizeRet(final T object, final int param_name) {
final PointerBuffer bytes = APIUtil.getBufferPointer();
final int errcode = getInfo(object, param_name, null, bytes);
if ( errcode != CL_SUCCESS )
throw new IllegalArgumentException("Invalid parameter specified: " + LWJGLUtil.toHexString(param_name));
return (int)bytes.get(0);
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLObject.java 0000644 0001750 0001750 00000003533 11543426510 021113 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
import org.lwjgl.PointerWrapperAbstract;
/**
* Base class for all OpenCL objects.
*
* @author Spasi
*/
abstract class CLObject extends PointerWrapperAbstract {
protected CLObject(final long pointer) {
super(pointer);
}
final long getPointerUnsafe() {
return pointer;
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CallbackUtil.java 0000644 0001750 0001750 00000015064 11543426510 022022 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
import java.util.HashMap;
import java.util.Map;
/**
* Utility class that handles OpenCL API callbacks.
*
* @author Spasi
*/
final class CallbackUtil {
private static final Map contextUserData = new HashMap();
private CallbackUtil() {}
/**
* Creates a new global reference to the specified Object.
*
* @param obj the Object
*
* @return the GlobalRef memory address or 0 if the Object is null.
*/
static long createGlobalRef(final Object obj) {
return obj == null ? 0 : ncreateGlobalRef(obj);
}
/**
* Creates a new global reference to the specified Object.
*
* @param obj the Object
*
* @return the GlobalRef memory address.
*/
private static native long ncreateGlobalRef(Object obj);
/**
* Deletes a global reference.
*
* @param ref the GlobalRef memory address.
*/
private static native void deleteGlobalRef(long ref);
/**
* Deletes the global reference represented by user_data if an OpenCL error occured.
*
* @param errcode the error code
* @param user_data the GlobalRef memory address
*/
static void checkCallback(final int errcode, final long user_data) {
if ( errcode != 0x0 && user_data != 0 )
deleteGlobalRef(user_data);
}
/* [ Context callback functionality ]
This is a little weird, so here's an explanation of what's happening for future reference:
Before making the clCreateContext call we create a global reference to the CLContextCallback object (using JNI's NewGlobalRef function).
We pass that global reference to the user_data parameter of clCreateContext. If clCreateContext returns anything but CL_SUCCESS, we
immediately destroy the global reference to avoid the memory leak. If the new context was created successfully, we associate the context
with the global reference in the contextUserData HashMap. On a future call to clReleaseContext, we clear that association and destroy the
global reference (if the reference count is 0).
*/
/**
* Returns the memory address of the native function we pass to clCreateContext(FromType).
*
* @return the callback function address
*/
static native long getContextCallback();
/**
* Associates the specified CLContext with the specified global reference. If the context
* is invalid, the global reference is deleted. NO-OP if user_data is 0.
*
* @param context the CLContext to register
* @param user_data the global reference pointer
*/
static void registerCallback(final CLContext context, final long user_data) {
if ( context.getPointerUnsafe() == 0 ) {
if ( user_data != 0 )
deleteGlobalRef(user_data);
return;
}
if ( user_data != 0 )
contextUserData.put(context, user_data);
}
/**
* Decrements the specified context's reference count, clears its association
* with a CLContextCallback object if it exists and deletes the corresponding
* global reference.
*
* @param context the CLContext to unregister
*/
static void unregisterCallback(final CLContext context) {
if ( context.release() > 0 )
return;
final Long user_data = contextUserData.remove(context);
if ( user_data != null )
deleteGlobalRef(user_data);
}
/* [ Other callback functionality ]
The other callbacks are simpler. We create the GlobalRef before passing the callback,
we delete it when we receive the callback call.
*/
/**
* Returns the memory address of the native function we pass to clSetMemObjectDestructorCallback.
*
* @return the callback function address
*/
static native long getMemObjectDestructorCallback();
/**
* Returns the memory address of the native function we pass to clBuildProgram.
*
* @return the callback function address
*/
static native long getBuildProgramCallback();
/**
* Returns the memory address of the native function we pass to clEnqueueNativeKernel.
*
* @return the callback function address
*/
static native long getNativeKernelCallback();
/**
* Returns the memory address of the native function we pass to clSetEventCallback.
*
* @return the callback function address
*/
static native long getEventCallback();
/**
* Returns the memory address of the native function we pass to clCreateContext(FromType),
* when APPLEContextLoggingUtil.SYSTEM_LOG_CALLBACK is used.
*
* @return the callback function address
*
* @see APPLEContextLoggingUtil#SYSTEM_LOG_CALLBACK
*/
static native long getLogMessageToSystemLogAPPLE();
/**
* Returns the memory address of the native function we pass to clCreateContext(FromType),
* when APPLEContextLoggingUtil.STD_OUT_CALLBACK is used.
*
* @return the callback function address
*
* @see APPLEContextLoggingUtil#STD_OUT_CALLBACK
*/
static native long getLogMessageToStdoutAPPLE();
/**
* Returns the memory address of the native function we pass to clCreateContext(FromType),
* when APPLEContextLoggingUtil.STD_ERR_CALLBACK is used.
*
* @return the callback function address
*
* @see APPLEContextLoggingUtil#STD_ERR_CALLBACK
*/
static native long getLogMessageToStderrAPPLE();
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLFunctionAddress.java 0000644 0001750 0001750 00000003513 11543426510 022776 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
import org.lwjgl.PointerWrapperAbstract;
/**
* This class is a wrapper around an OpenCL extension function pointer.
*
* @author Spasi
*/
final class CLFunctionAddress extends PointerWrapperAbstract {
CLFunctionAddress(final long pointer) {
super(pointer);
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLKernel.java 0000644 0001750 0001750 00000016025 11543426510 021125 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
/**
* This class is a wrapper around a cl_kernel pointer.
*
* @author Spasi
*/
public final class CLKernel extends CLObjectChild {
private static final CLKernelUtil util = (CLKernelUtil)CLPlatform.getInfoUtilInstance(CLKernel.class, "CL_KERNEL_UTIL");
CLKernel(final long pointer, final CLProgram program) {
super(pointer, program);
if ( isValid() )
program.getCLKernelRegistry().registerObject(this);
}
// ---------------[ UTILITY METHODS ]---------------
// clSetKernelArg methods
/**
* Sets a kernel argument at the specified index to the specified
* byte value.
*
* @param index the argument index
* @param value the argument value
*
* @return this CLKernel object
*/
public CLKernel setArg(final int index, final byte value) {
util.setArg(this, index, value);
return this;
}
/**
* Sets a kernel argument at the specified index to the specified
* byte value.
*
* @param index the argument index
* @param value the argument value
*
* @return this CLKernel object
*/
public CLKernel setArg(final int index, final short value) {
util.setArg(this, index, value);
return this;
}
/**
* Sets a kernel argument at the specified index to the specified
* int value.
*
* @param index the argument index
* @param value the argument value
*
* @return this CLKernel object
*/
public CLKernel setArg(final int index, final int value) {
util.setArg(this, index, value);
return this;
}
/**
* Sets a kernel argument at the specified index to the specified
* long value.
*
* @param index the argument index
* @param value the argument value
*
* @return this CLKernel object
*/
public CLKernel setArg(final int index, final long value) {
util.setArg(this, index, value);
return this;
}
/**
* Sets a kernel argument at the specified index to the specified
* float value.
*
* @param index the argument index
* @param value the argument value
*
* @return this CLKernel object
*/
public CLKernel setArg(final int index, final float value) {
util.setArg(this, index, value);
return this;
}
/**
* Sets a kernel argument at the specified index to the specified
* double value.
*
* @param index the argument index
* @param value the argument value
*
* @return this CLKernel object
*/
public CLKernel setArg(final int index, final double value) {
util.setArg(this, index, value);
return this;
}
/**
* Sets a kernel argument at the specified index to the specified
* pointer value.
*
* @param index the argument index
* @param value the argument value
*
* @return this CLKernel object
*/
public CLKernel setArg(final int index, final CLObject value) {
util.setArg(this, index, value);
return this;
}
/**
* Sets the size of a __local kernel argument at the specified index.
*
* @param index the argument index
* @param size the argument size
*
* @return this CLKernel object
*/
public CLKernel setArgSize(final int index, final long size) {
util.setArgSize(this, index, size);
return this;
}
// clGetKernelInfo methods
/**
* Returns the String value of the specified parameter.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public String getInfoString(final int param_name) {
return util.getInfoString(this, param_name);
}
/**
* Returns the integer value of the specified parameter.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public int getInfoInt(final int param_name) {
return util.getInfoInt(this, param_name);
}
// clGetKernelWorkGroupInfo methods
/**
* Returns the size_t value of the specified parameter.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public long getWorkGroupInfoSize(final CLDevice device, int param_name) {
return util.getWorkGroupInfoSize(this, device, param_name);
}
/**
* Returns an array of size_t values of the specified parameter.
*
* @param param_name the parameter
*
* @return the parameter values
*/
public long[] getWorkGroupInfoSizeArray(final CLDevice device, int param_name) {
return util.getWorkGroupInfoSizeArray(this, device, param_name);
}
/**
* Returns the long value of the specified parameter. Can be used
* for both cl_ulong and cl_bitfield parameters.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public long getWorkGroupInfoLong(final CLDevice device, int param_name) {
return util.getWorkGroupInfoLong(this, device, param_name);
}
/** CLKernel utility methods interface. */
interface CLKernelUtil extends InfoUtil {
void setArg(CLKernel kernel, int index, byte value);
void setArg(CLKernel kernel, int index, short value);
void setArg(CLKernel kernel, int index, int value);
void setArg(CLKernel kernel, int index, long value);
void setArg(CLKernel kernel, int index, float value);
void setArg(CLKernel kernel, int index, double value);
void setArg(CLKernel kernel, int index, CLObject pointer);
void setArgSize(CLKernel kernel, int index, long size);
long getWorkGroupInfoSize(CLKernel kernel, CLDevice device, int param_name);
long[] getWorkGroupInfoSizeArray(CLKernel kernel, CLDevice device, int param_name);
long getWorkGroupInfoLong(CLKernel kernel, CLDevice device, int param_name);
}
// -------[ IMPLEMENTATION STUFF BELOW ]-------
int release() {
try {
return super.release();
} finally {
if ( !isValid() )
getParent().getCLKernelRegistry().unregisterObject(this);
}
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLObjectRegistryGlobal.java 0000644 0001750 0001750 00000004252 11543426510 023764 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
/**
* A CLObject registry that also registers/unregisters objects to/from a global registry.
*
* @author Spasi
*/
final class CLObjectRegistryGlobal extends CLObjectRegistry {
private final FastLongMap globalRegistry;
CLObjectRegistryGlobal(final FastLongMap globalRegistry) {
this.globalRegistry = globalRegistry;
}
void registerObject(final T object) {
super.registerObject(object);
globalRegistry.put(object.getPointer(), object);
}
void unregisterObject(final T object) {
super.unregisterObject(object);
globalRegistry.remove(object.getPointerUnsafe());
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLBuildProgramCallback.java 0000644 0001750 0001750 00000004303 11543426510 023705 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
/**
* Instances of this class can be used to receive OpenCL program build notifications.
*
* @author Spasi
*/
public abstract class CLBuildProgramCallback extends CLCallback {
protected CLBuildProgramCallback() {
super(CallbackUtil.getBuildProgramCallback());
}
/**
* Called from native code.
*
* @param program_address the CLProgram object pointer
*/
private void handleMessage(long program_address) {
handleMessage(CLContext.getCLProgramGlobal(program_address));
}
/**
* The callback method.
*
* @param program the CLProgram object that was built
*/
protected abstract void handleMessage(CLProgram program);
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLObjectRegistry.java 0000644 0001750 0001750 00000002115 11543426510 022637 0 ustar zero79 zero79 package org.lwjgl.opencl;
import org.lwjgl.LWJGLUtil;
/**
* A CLObjectChild container.
*
* @author Spasi
*/
class CLObjectRegistry {
private FastLongMap registry;
CLObjectRegistry() {
}
final boolean isEmpty() {
return registry == null || registry.isEmpty();
}
final T getObject(final long id) {
return registry == null ? null : registry.get(id);
}
final boolean hasObject(final long id) {
return registry != null && registry.containsKey(id);
}
final Iterable> getAll() {
return registry;
}
void registerObject(final T object) {
final FastLongMap map = getMap();
final Long key = object.getPointer();
if ( LWJGLUtil.DEBUG && map.containsKey(key) )
throw new IllegalStateException("Duplicate object found: " + object.getClass() + " - " + key);
getMap().put(object.getPointer(), object);
}
void unregisterObject(final T object) {
getMap().remove(object.getPointerUnsafe());
}
private FastLongMap getMap() {
if ( registry == null )
registry = new FastLongMap();
return registry;
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLContextCallback.java 0000644 0001750 0001750 00000004757 11543426510 022757 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
import org.lwjgl.PointerWrapperAbstract;
import java.nio.ByteBuffer;
/**
* Instances of this class can be used to receive OpenCL context error notifications.
*
* @author Spasi
*/
public abstract class CLContextCallback extends PointerWrapperAbstract {
private final boolean custom;
protected CLContextCallback() {
super(CallbackUtil.getContextCallback());
custom = false;
}
/**
* This constructor allows non-LWJGL implementations.
*
* @param pointer
*/
protected CLContextCallback(final long pointer) {
super(pointer);
if ( pointer == 0 )
throw new RuntimeException("Invalid callback function pointer specified.");
custom = true;
}
final boolean isCustom() {
return custom;
}
/**
* The callback method.
*
* @param errinfo the error description
* @param private_info optional error data (may be null)
*/
protected abstract void handleMessage(String errinfo, ByteBuffer private_info);
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/APPLEContextLoggingUtil.java 0000644 0001750 0001750 00000006073 11543426510 024043 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
import java.nio.ByteBuffer;
/**
* Utility class that provides CLContextCallback implementations that use
* the APPLE_ContextLoggingFunctions callback functions.
*
* TODO: Test this class
*
* @author Spasi
*/
public final class APPLEContextLoggingUtil {
/** Sends all log messages to the Apple System Logger. */
public static final CLContextCallback SYSTEM_LOG_CALLBACK;
/** Sends all log messages to the file descriptor stdout. */
public static final CLContextCallback STD_OUT_CALLBACK;
/** Sends all log messages to the file descriptor stderr. */
public static final CLContextCallback STD_ERR_CALLBACK;
static {
if ( CLCapabilities.CL_APPLE_ContextLoggingFunctions ) {
SYSTEM_LOG_CALLBACK = new CLContextCallback(CallbackUtil.getLogMessageToSystemLogAPPLE()) {
protected void handleMessage(final String errinfo, final ByteBuffer private_info) { throw new UnsupportedOperationException(); }
};
STD_OUT_CALLBACK = new CLContextCallback(CallbackUtil.getLogMessageToStdoutAPPLE()) {
protected void handleMessage(final String errinfo, final ByteBuffer private_info) { throw new UnsupportedOperationException(); }
};
STD_ERR_CALLBACK = new CLContextCallback(CallbackUtil.getLogMessageToStderrAPPLE()) {
protected void handleMessage(final String errinfo, final ByteBuffer private_info) { throw new UnsupportedOperationException(); }
};
} else {
SYSTEM_LOG_CALLBACK = null;
STD_OUT_CALLBACK = null;
STD_ERR_CALLBACK = null;
}
}
private APPLEContextLoggingUtil() {}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/FastLongMap.java 0000644 0001750 0001750 00000012716 11543426510 021644 0 ustar zero79 zero79 /*
* Copyright 2002-2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*/
package org.lwjgl.opencl;
import java.util.Iterator;
/**
* A hash map using primitive longs as keys rather than objects.
*
* @author Justin Couch
* @author Alex Chaffee (alex@apache.org)
* @author Stephen Colebourne
* @author Nathan Sweet
*/
final class FastLongMap implements Iterable> {
private Entry[] table;
private int size, mask, capacity, threshold;
/** Same as: FastLongMap(16, 0.75f); */
FastLongMap() {
this(16, 0.75f);
}
/** Same as: FastLongMap(initialCapacity, 0.75f); */
FastLongMap(int initialCapacity) {
this(initialCapacity, 0.75f);
}
FastLongMap(int initialCapacity, float loadFactor) {
if ( initialCapacity > 1 << 30 ) throw new IllegalArgumentException("initialCapacity is too large.");
if ( initialCapacity < 0 ) throw new IllegalArgumentException("initialCapacity must be greater than zero.");
if ( loadFactor <= 0 ) throw new IllegalArgumentException("initialCapacity must be greater than zero.");
capacity = 1;
while ( capacity < initialCapacity )
capacity <<= 1;
this.threshold = (int)(capacity * loadFactor);
this.table = new Entry[capacity];
this.mask = capacity - 1;
}
private int index(final long key) {
return index(key, mask);
}
private static int index(final long key, final int mask) {
final int hash = (int)(key ^ (key >>> 32));
return hash & mask;
}
public V put(long key, V value) {
final Entry[] table = this.table;
int index = index(key);
// Check if key already exists.
for ( Entry e = table[index]; e != null; e = e.next ) {
if ( e.key != key ) continue;
V oldValue = e.value;
e.value = value;
return oldValue;
}
table[index] = new Entry(key, value, table[index]);
if ( size++ >= threshold )
rehash(table);
return null;
}
private void rehash(final Entry[] table) {
final int newCapacity = 2 * capacity;
final int newMask = newCapacity - 1;
final Entry[] newTable = new Entry[newCapacity];
for ( int i = 0, index; i < table.length; i++ ) {
Entry e = table[i];
if ( e == null ) continue;
do {
final Entry next = e.next;
index = index(e.key, newMask);
e.next = newTable[index];
newTable[index] = e;
e = next;
} while ( e != null );
}
this.table = newTable;
capacity = newCapacity;
mask = newMask;
threshold *= 2;
}
public V get(long key) {
final int index = index(key);
for ( Entry e = table[index]; e != null; e = e.next )
if ( e.key == key ) return e.value;
return null;
}
public boolean containsValue(Object value) {
final Entry[] table = this.table;
for ( int i = table.length - 1; i >= 0; i-- )
for ( Entry e = table[i]; e != null; e = e.next )
if ( e.value.equals(value) ) return true;
return false;
}
public boolean containsKey(long key) {
final int index = index(key);
for ( Entry e = table[index]; e != null; e = e.next )
if ( e.key == key ) return true;
return false;
}
public V remove(long key) {
final int index = index(key);
Entry prev = table[index];
Entry e = prev;
while ( e != null ) {
Entry next = e.next;
if ( e.key == key ) {
size--;
if ( prev == e )
table[index] = next;
else
prev.next = next;
return e.value;
}
prev = e;
e = next;
}
return null;
}
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
public void clear() {
final Entry[] table = this.table;
for ( int index = table.length - 1; index >= 0; index-- )
table[index] = null;
size = 0;
}
public EntryIterator iterator() {
return new EntryIterator();
}
public class EntryIterator implements Iterator> {
private int nextIndex;
private Entry current;
EntryIterator() {
reset();
}
public void reset() {
current = null;
// Find first bucket.
final Entry[] table = FastLongMap.this.table;
int i;
for ( i = table.length - 1; i >= 0; i-- )
if ( table[i] != null ) break;
nextIndex = i;
}
public boolean hasNext() {
if ( nextIndex >= 0 ) return true;
Entry e = current;
return e != null && e.next != null;
}
public Entry next() {
// Next entry in current bucket.
Entry e = current;
if ( e != null ) {
e = e.next;
if ( e != null ) {
current = e;
return e;
}
}
// Use the bucket at nextIndex and find the next nextIndex.
final Entry[] table = FastLongMap.this.table;
int i = nextIndex;
e = current = table[i];
while ( --i >= 0 )
if ( table[i] != null ) break;
nextIndex = i;
return e;
}
public void remove() {
FastLongMap.this.remove(current.key);
}
}
static final class Entry {
final long key;
T value;
Entry next;
Entry(long key, T value, Entry next) {
this.key = key;
this.value = value;
this.next = next;
}
public long getKey() {
return key;
}
public T getValue() {
return value;
}
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLPlatform.java 0000644 0001750 0001750 00000016136 11543426510 021474 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
import org.lwjgl.PointerBuffer;
import org.lwjgl.opencl.api.Filter;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.util.List;
import static java.lang.Math.*;
/**
* This class is a wrapper around a cl_platform_id pointer.
*
* @author Spasi
*/
public final class CLPlatform extends CLObject {
private static final CLPlatformUtil util = (CLPlatformUtil)getInfoUtilInstance(CLPlatform.class, "CL_PLATFORM_UTIL");
private static final FastLongMap clPlatforms = new FastLongMap();
private final CLObjectRegistry clDevices;
/** Global registry for build callbacks. */
static final FastLongMap clDevicesGlobal = new FastLongMap();
private Object caps;
CLPlatform(final long pointer) {
super(pointer);
if ( isValid() ) {
clPlatforms.put(pointer, this);
clDevices = new CLObjectRegistryGlobal(clDevicesGlobal);
} else
clDevices = null;
}
/**
* Returns a CLPlatform with the specified id.
*
* @param id the platform object id
*
* @return the CLPlatform object
*/
public static CLPlatform getCLPlatform(final long id) { return clPlatforms.get(id); }
/**
* Returns a CLDevice that is available on this platform.
*
* @param id the device object id
*
* @return the CLDevice object
*/
public CLDevice getCLDevice(final long id) { return clDevices.getObject(id); }
// ---------------[ UTILITY METHODS ]---------------
@SuppressWarnings("unchecked")
static InfoUtil getInfoUtilInstance(final Class clazz, final String fieldName) {
InfoUtil instance = null;
try {
final Class infoUtil = Class.forName("org.lwjgl.opencl.InfoUtilFactory");
instance = (InfoUtil)infoUtil.getDeclaredField(fieldName).get(null);
} catch (Exception e) {
// Ignore
}
return instance;
}
/**
* Returns a list of all the available platforms.
*
* @return the available platforms
*/
public static List getPlatforms() {
return getPlatforms(null);
}
/**
* Returns a list of the available platforms, filtered by the specified filter.
*
* @param filter the platform filter
*
* @return the available platforms
*/
public static List getPlatforms(final Filter filter) {
return util.getPlatforms(filter);
}
/**
* Returns the String value of the specified parameter.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public String getInfoString(int param_name) {
return util.getInfoString(this, param_name);
}
/**
* Returns a list of the available devices on this platform that
* match the specified type.
*
* @param device_type the device type
*
* @return the available devices
*/
public List getDevices(final int device_type) {
return getDevices(device_type, null);
}
/**
* Returns a list of the available devices on this platform that
* match the specified type, filtered by the specified filter.
*
* @param device_type the device type
* @param filter the device filter
*
* @return the available devices
*/
public List getDevices(final int device_type, final Filter filter) {
return util.getDevices(this, device_type, filter);
}
/** CLPlatform utility methods interface. */
interface CLPlatformUtil extends InfoUtil {
List getPlatforms(Filter filter);
List getDevices(CLPlatform platform, int device_type, final Filter filter);
}
// -------[ IMPLEMENTATION STUFF BELOW ]-------
void setCapabilities(final Object caps) {
this.caps = caps;
}
Object getCapabilities() {
return caps;
}
/**
* Called from clGetPlatformIDs to register new platforms.
*
* @param platforms a buffer containing CLPlatform pointers.
*/
static void registerCLPlatforms(final PointerBuffer platforms, final IntBuffer num_platforms) {
if ( platforms == null )
return;
final int pos = platforms.position();
final int count = min(num_platforms.get(0), platforms.remaining()); // We can't depend on .remaining()
for ( int i = 0; i < count; i++ ) {
final long id = platforms.get(pos + i);
if ( !clPlatforms.containsKey(id) )
new CLPlatform(id);
}
}
CLObjectRegistry getCLDeviceRegistry() { return clDevices; }
static CLDevice getCLDeviceGlobal(final long id) { return clDevicesGlobal.get(id); }
/**
* Called from clGetDeviceIDs to register new devices.
*
* @param devices a buffer containing CLDevice pointers.
*/
void registerCLDevices(final PointerBuffer devices, final IntBuffer num_devices) {
final int pos = devices.position();
final int count = min(num_devices.get(num_devices.position()), devices.remaining()); // We can't depend on .remaining()
for ( int i = 0; i < count; i++ ) {
final long id = devices.get(pos + i);
if ( !clDevices.hasObject(id) )
new CLDevice(id, this);
}
}
/**
* Called from clGetContextInfo to register new devices.
*
* @param devices a buffer containing CLDevice pointers.
*/
void registerCLDevices(final ByteBuffer devices, final PointerBuffer num_devices) {
final int pos = devices.position();
final int count = min((int)num_devices.get(num_devices.position()), devices.remaining()) / PointerBuffer.getPointerSize(); // We can't depend on .remaining()
for ( int i = 0; i < count; i++ ) {
final int offset = pos + (i * PointerBuffer.getPointerSize());
final long id = PointerBuffer.is64Bit() ? devices.getLong(offset) : devices.getInt(offset);
if ( !clDevices.hasObject(id) )
new CLDevice(id, this);
}
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLSampler.java 0000644 0001750 0001750 00000005404 11543426510 021307 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
/**
* This class is a wrapper around a cl_sampler pointer.
*
* @author Spasi
*/
public final class CLSampler extends CLObjectChild {
private static final InfoUtil util = CLPlatform.getInfoUtilInstance(CLSampler.class, "CL_SAMPLER_UTIL");
CLSampler(final long pointer, final CLContext context) {
super(pointer, context);
if ( isValid() )
context.getCLSamplerRegistry().registerObject(this);
}
// ---------------[ UTILITY METHODS ]---------------
/**
* Returns the integer value of the specified parameter.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public int getInfoInt(int param_name) {
return util.getInfoInt(this, param_name);
}
/**
* Returns the long value of the specified parameter. Can be used
* for both cl_ulong and cl_bitfield parameters.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public long getInfoLong(int param_name) {
return util.getInfoLong(this, param_name);
}
// -------[ IMPLEMENTATION STUFF BELOW ]-------
int release() {
try {
return super.release();
} finally {
if ( !isValid() )
getParent().getCLSamplerRegistry().unregisterObject(this);
}
}
} lwjgl-2.7.1/src/java/org/lwjgl/opencl/CLProgram.java 0000644 0001750 0001750 00000014547 11543426510 021323 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.opencl;
import org.lwjgl.PointerBuffer;
import java.nio.ByteBuffer;
/**
* This class is a wrapper around a cl_program pointer.
*
* @author Spasi
*/
public final class CLProgram extends CLObjectChild {
private static final CLProgramUtil util = (CLProgramUtil)CLPlatform.getInfoUtilInstance(CLProgram.class, "CL_PROGRAM_UTIL");
private final CLObjectRegistry clKernels;
CLProgram(final long pointer, final CLContext context) {
super(pointer, context);
if ( isValid() ) {
context.getCLProgramRegistry().registerObject(this);
clKernels = new CLObjectRegistry();
} else
clKernels = null;
}
/**
* Returns a CLKernel associated with this program.
*
* @param id the kernel id
*
* @return the CLKernel object
*/
public CLKernel getCLKernel(final long id) {
return clKernels.getObject(id);
}
// ---------------[ UTILITY METHODS ]---------------
/**
* Creates kernel objects for all kernels functions in this program.
*
* @return a CLKernel array
*/
public CLKernel[] createKernelsInProgram() {
return util.createKernelsInProgram(this);
}
/**
* Returns the String value of the specified parameter.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public String getInfoString(final int param_name) {
return util.getInfoString(this, param_name);
}
/**
* Returns the integer value of the specified parameter.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public int getInfoInt(final int param_name) {
return util.getInfoInt(this, param_name);
}
/**
* Returns an array of size_t values of the specified parameter.
*
* @param param_name the parameter
*
* @return the parameter values
*/
public long[] getInfoSizeArray(final int param_name) {
return util.getInfoSizeArray(this, param_name);
}
/**
* Returns an array of CLDevices associated with this program.
*
* @return the array of devices
*/
public CLDevice[] getInfoDevices() {
return util.getInfoDevices(this);
}
/**
* Returns the program binaries for all devices associated with program,
* written sequentially in the target ByteBuffer. If the target
* parameter is null, a new ByteBuffer will be allocated. If not, the
* target ByteBuffer must be big enough to hold the program binaries, as
* returned by CL_PROGRAM_BINARY_SIZES.
*
* @param target the target ByteBuffer array.
*
* @return the array of devices
*/
public ByteBuffer getInfoBinaries(final ByteBuffer target) {
return util.getInfoBinaries(this, target);
}
/**
* Returns the program binaries for all devices associated with program,
* as a ByteBuffer array. If the target parameter is null,
* a new ByteBuffer array will be allocated. If not, the target ByteBuffers
* must be big enough to hold the program binaries, as returned by
* CL_PROGRAM_BINARY_SIZES.
*
* @param target the target ByteBuffer array.
*
* @return the array of devices
*/
public ByteBuffer[] getInfoBinaries(final ByteBuffer[] target) {
return util.getInfoBinaries(this, target);
}
// clGetProgramBuildInfo methods
/**
* Returns the String value of the specified parameter.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public String getBuildInfoString(final CLDevice device, final int param_name) {
return util.getBuildInfoString(this, device, param_name);
}
/**
* Returns the integer value of the specified parameter.
*
* @param param_name the parameter
*
* @return the parameter value
*/
public int getBuildInfoInt(final CLDevice device, final int param_name) {
return util.getBuildInfoInt(this, device, param_name);
}
/** CLProgram utility methods interface. */
interface CLProgramUtil extends InfoUtil {
CLKernel[] createKernelsInProgram(CLProgram program);
CLDevice[] getInfoDevices(CLProgram program);
ByteBuffer getInfoBinaries(CLProgram program, ByteBuffer target);
ByteBuffer[] getInfoBinaries(CLProgram program, ByteBuffer[] target);
String getBuildInfoString(CLProgram program, final CLDevice device, int param_name);
int getBuildInfoInt(CLProgram program, final CLDevice device, int param_name);
}
// -------[ IMPLEMENTATION STUFF BELOW ]-------
CLObjectRegistry getCLKernelRegistry() { return clKernels; }
/**
* Called from clCreateKernelsInProgram to register new CLKernels.
*
* @param kernels a buffer containing CLKernel pointers.
*/
void registerCLKernels(final PointerBuffer kernels) {
for ( int i = kernels.position(); i < kernels.limit(); i++ ) {
final long pointer = kernels.get(i);
if ( pointer != 0 )
new CLKernel(pointer, this);
}
}
int release() {
try {
return super.release();
} finally {
if ( !isValid() )
getParent().getCLProgramRegistry().unregisterObject(this);
}
}
} lwjgl-2.7.1/src/java/org/lwjgl/LWJGLException.java 0000644 0001750 0001750 00000004570 11543426510 020746 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl;
/**
*
* This exception is supplied to make exception handling more generic for LWJGL
* specific exceptions
*
*
* @author Brian Matzon
* @version $Revision: 2983 $
* $Id: LWJGLException.java 2983 2008-04-07 18:36:09Z matzon $
*/
public class LWJGLException extends Exception {
private static final long serialVersionUID = 1L;
/**
* Plain c'tor
*/
public LWJGLException() {
super();
}
/**
* Creates a new LWJGLException
*
* @param msg
* String identifier for exception
*/
public LWJGLException(String msg) {
super(msg);
}
/**
* @param message
* @param cause
*/
public LWJGLException(String message, Throwable cause) {
super(message, cause);
}
/**
* @param cause
*/
public LWJGLException(Throwable cause) {
super(cause);
}
}
lwjgl-2.7.1/src/java/org/lwjgl/PointerWrapper.java 0000644 0001750 0001750 00000003312 11543426510 021162 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl;
/**
* A common interface for classes that wrap pointer addresses.
*
* @author Spasi
*/
public interface PointerWrapper {
long getPointer();
} lwjgl-2.7.1/src/java/org/lwjgl/examples/ 0000755 0001750 0001750 00000000000 11543426510 017155 5 ustar zero79 zero79 lwjgl-2.7.1/src/java/org/lwjgl/examples/Game.java 0000644 0001750 0001750 00000012462 11543426510 020676 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.examples;
import org.lwjgl.Sys;
import org.lwjgl.input.Keyboard;
import org.lwjgl.openal.AL;
import org.lwjgl.opengl.Display;
import static org.lwjgl.opengl.GL11.*;
/**
*
* This is a very basic skeleton to init a game and run it.
*
* @author $Author: spasi $
* @version $Revision: 3418 $
* $Id: Game.java 3418 2010-09-28 21:11:35Z spasi $
*/
public class Game {
/** Game title */
public static final String GAME_TITLE = "My Game";
/** Desired frame time */
private static final int FRAMERATE = 60;
/** Exit the game */
private static boolean finished;
/** A rotating square! */
private static float angle;
/**
* No constructor needed - this class is static
*/
private Game() {}
/**
* Application init
* @param args Commandline args
*/
public static void main(String[] args) {
try {
init();
run();
} catch (Exception e) {
e.printStackTrace(System.err);
Sys.alert(GAME_TITLE, "An error occured and the game will exit.");
} finally {
cleanup();
}
System.exit(0);
}
/**
* Initialise the game
* @throws Exception if init fails
*/
private static void init() throws Exception {
// Create a fullscreen window with 1:1 orthographic 2D projection, and with
// mouse, keyboard, and gamepad inputs.
Display.setTitle(GAME_TITLE);
Display.setFullscreen(true);
// Enable vsync if we can
Display.setVSyncEnabled(true);
Display.create();
// Start up the sound system
AL.create();
// TODO: Load in your textures etc here
// Put the window into orthographic projection mode with 1:1 pixel ratio.
// We haven't used GLU here to do this to avoid an unnecessary dependency.
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, Display.getDisplayMode().getWidth(), 0.0, Display.getDisplayMode().getHeight(), -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glViewport(0, 0, Display.getDisplayMode().getWidth(), Display.getDisplayMode().getHeight());
}
/**
* Runs the game (the "main loop")
*/
private static void run() {
while (!finished) {
// Always call Window.update(), all the time
Display.update();
if (Display.isCloseRequested()) {
// Check for O/S close requests
finished = true;
} else if (Display.isActive()) {
// The window is in the foreground, so we should play the game
logic();
render();
Display.sync(FRAMERATE);
} else {
// The window is not in the foreground, so we can allow other stuff to run and
// infrequently update
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
logic();
if (Display.isVisible() || Display.isDirty()) {
// Only bother rendering if the window is visible or dirty
render();
}
}
}
}
/**
* Do any game-specific cleanup
*/
private static void cleanup() {
// TODO: save anything you want to disk here
// Stop the sound
AL.destroy();
// Close the window
Display.destroy();
}
/**
* Do all calculations, handle input, etc.
*/
private static void logic() {
// Example input handler: we'll check for the ESC key and finish the game instantly when it's pressed
if (Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)) {
finished = true;
}
// TODO: all your game logic goes here.
angle += 2.0f % 360;
}
/**
* Render the current frame
*/
private static void render() {
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
// TODO: all your rendering goes here
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
glTranslatef(Display.getDisplayMode().getWidth() / 2, Display.getDisplayMode().getHeight() / 2, 0.0f);
glRotatef(angle, 0, 0, 1.0f);
glBegin(GL_QUADS);
glVertex2i(-50, -50);
glVertex2i(50, -50);
glVertex2i(50, 50);
glVertex2i(-50, 50);
glEnd();
glPopMatrix();
}
}
lwjgl-2.7.1/src/java/org/lwjgl/examples/spaceinvaders/ 0000755 0001750 0001750 00000000000 11543426510 022004 5 ustar zero79 zero79 lwjgl-2.7.1/src/java/org/lwjgl/examples/spaceinvaders/Entity.java 0000644 0001750 0001750 00000012431 11543426510 024124 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.examples.spaceinvaders;
import java.awt.Rectangle;
/**
* An entity represents any element that appears in the game. The
* entity is responsible for resolving collisions and movement
* based on a set of properties defined either by subclass or externally.
*
* Note that doubles are used for positions. This may seem strange
* given that pixels locations are integers. However, using double means
* that an entity can move a partial pixel. It doesn't of course mean that
* they will be display half way through a pixel but allows us not lose
* accuracy as we move.
*
* @author Kevin Glass
*/
public abstract class Entity {
/** The current x location of this entity */
protected float x;
/** The current y location of this entity */
protected float y;
/** The sprite that represents this entity */
protected Sprite sprite;
/** The current speed of this entity horizontally (pixels/sec) */
protected float dx;
/** The current speed of this entity vertically (pixels/sec) */
protected float dy;
/** The rectangle used for this entity during collisions resolution */
private Rectangle me = new Rectangle();
/** The rectangle used for other entities during collision resolution */
private Rectangle him = new Rectangle();
/**
* Construct a entity based on a sprite image and a location.
*
* @param sprite The reference to the image to be displayed for this entity
* @param x The initial x location of this entity
* @param y The initial y location of this entity
*/
protected Entity(Sprite sprite, int x, int y) {
this.sprite = sprite;
this.x = x;
this.y = y;
}
/**
* Request that this entity move itself based on a certain ammount
* of time passing.
*
* @param delta The ammount of time that has passed in milliseconds
*/
public void move(long delta) {
// update the location of the entity based on move speeds
x += (delta * dx) / 1000;
y += (delta * dy) / 1000;
}
/**
* Set the horizontal speed of this entity
*
* @param dx The horizontal speed of this entity (pixels/sec)
*/
public void setHorizontalMovement(float dx) {
this.dx = dx;
}
/**
* Set the vertical speed of this entity
*
* @param dy The vertical speed of this entity (pixels/sec)
*/
public void setVerticalMovement(float dy) {
this.dy = dy;
}
/**
* Get the horizontal speed of this entity
*
* @return The horizontal speed of this entity (pixels/sec)
*/
public float getHorizontalMovement() {
return dx;
}
/**
* Get the vertical speed of this entity
*
* @return The vertical speed of this entity (pixels/sec)
*/
public float getVerticalMovement() {
return dy;
}
/**
* Draw this entity to the graphics context provided
*/
public void draw() {
sprite.draw((int) x, (int) y);
}
/**
* Do the logic associated with this entity. This method
* will be called periodically based on game events
*/
public void doLogic() {
}
/**
* Get the x location of this entity
*
* @return The x location of this entity
*/
public int getX() {
return (int) x;
}
/**
* Get the y location of this entity
*
* @return The y location of this entity
*/
public int getY() {
return (int) y;
}
/**
* Check if this entity collised with another.
*
* @param other The other entity to check collision against
* @return True if the entities collide with each other
*/
public boolean collidesWith(Entity other) {
me.setBounds((int) x, (int) y, sprite.getWidth(), sprite.getHeight());
him.setBounds((int) other.x, (int) other.y, other.sprite.getWidth(), other.sprite.getHeight());
return me.intersects(him);
}
/**
* Notification that this entity collided with another.
*
* @param other The entity with which this entity collided.
*/
public abstract void collidedWith(Entity other);
} lwjgl-2.7.1/src/java/org/lwjgl/examples/spaceinvaders/Texture.java 0000644 0001750 0001750 00000011103 11543426510 024303 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.examples.spaceinvaders;
import static org.lwjgl.opengl.GL11.*;
/**
* A texture to be bound within OpenGL. This object is responsible for
* keeping track of a given OpenGL texture and for calculating the
* texturing mapping coordinates of the full image.
*
* Since textures need to be powers of 2 the actual texture may be
* considerably bigged that the source image and hence the texture
* mapping coordinates need to be adjusted to matchup drawing the
* sprite against the texture.
*
* @author Kevin Glass
* @author Brian Matzon
*/
public class Texture {
/** The GL target type */
private int target;
/** The GL texture ID */
private int textureID;
/** The height of the image */
private int height;
/** The width of the image */
private int width;
/** The width of the texture */
private int texWidth;
/** The height of the texture */
private int texHeight;
/** The ratio of the width of the image to the texture */
private float widthRatio;
/** The ratio of the height of the image to the texture */
private float heightRatio;
/**
* Create a new texture
*
* @param target The GL target
* @param textureID The GL texture ID
*/
public Texture(int target, int textureID) {
this.target = target;
this.textureID = textureID;
}
/**
* Bind the specified GL context to a texture
*/
public void bind() {
glBindTexture(target, textureID);
}
/**
* Set the height of the image
*
* @param height The height of the image
*/
public void setHeight(int height) {
this.height = height;
setHeight();
}
/**
* Set the width of the image
*
* @param width The width of the image
*/
public void setWidth(int width) {
this.width = width;
setWidth();
}
/**
* Get the height of the original image
*
* @return The height of the original image
*/
public int getImageHeight() {
return height;
}
/**
* Get the width of the original image
*
* @return The width of the original image
*/
public int getImageWidth() {
return width;
}
/**
* Get the height of the physical texture
*
* @return The height of physical texture
*/
public float getHeight() {
return heightRatio;
}
/**
* Get the width of the physical texture
*
* @return The width of physical texture
*/
public float getWidth() {
return widthRatio;
}
/**
* Set the height of this texture
*
* @param texHeight The height of the texture
*/
public void setTextureHeight(int texHeight) {
this.texHeight = texHeight;
setHeight();
}
/**
* Set the width of this texture
*
* @param texWidth The width of the texture
*/
public void setTextureWidth(int texWidth) {
this.texWidth = texWidth;
setWidth();
}
/**
* Set the height of the texture. This will update the
* ratio also.
*/
private void setHeight() {
if (texHeight != 0) {
heightRatio = ((float) height) / texHeight;
}
}
/**
* Set the width of the texture. This will update the
* ratio also.
*/
private void setWidth() {
if (texWidth != 0) {
widthRatio = ((float) width) / texWidth;
}
}
} lwjgl-2.7.1/src/java/org/lwjgl/examples/spaceinvaders/Game.java 0000644 0001750 0001750 00000042406 11543426510 023526 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.examples.spaceinvaders;
import java.util.ArrayList;
import org.lwjgl.LWJGLException;
import org.lwjgl.Sys;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import static org.lwjgl.opengl.GL11.*;
/**
* The main hook of our game. This class with both act as a manager
* for the display and central mediator for the game logic.
*
* Display management will consist of a loop that cycles round all
* entities in the game asking them to move and then drawing them
* in the appropriate place. With the help of an inner class it
* will also allow the player to control the main ship.
*
* As a mediator it will be informed when entities within our game
* detect events (e.g. alient killed, played died) and will take
* appropriate game actions.
*
*
* NOTE:
* This game is a LWJGLized implementation of the Space Invaders game by Kevin
* Glass. The original implementation is renderer agnostic and supports other
* OpenGL implementations as well as Java2D. This version has been made specific
* for LWJGL, and has added input control as well as sound (which the original doesn't,
* at the time of writing).
* You can find the original article here:
* http://www.cokeandcode.com
*
*
* @author Kevin Glass
* @author Brian Matzon
*/
public class Game {
/** The normal title of the window */
private String WINDOW_TITLE = "Space Invaders 104 (for LWJGL)";
/** The width of the game display area */
private int width = 800;
/** The height of the game display area */
private int height = 600;
/** The loader responsible for converting images into OpenGL textures */
private TextureLoader textureLoader;
/** The list of all the entities that exist in our game */
private ArrayList entities = new ArrayList();
/** The list of entities that need to be removed from the game this loop */
private ArrayList removeList = new ArrayList();
/** The entity representing the player */
private ShipEntity ship;
/** List of shots */
private ShotEntity[] shots;
/** The message to display which waiting for a key press */
private Sprite message;
/** The sprite containing the "Press Any Key" message */
private Sprite pressAnyKey;
/** The sprite containing the "You win!" message */
private Sprite youWin;
/** The sprite containing the "You lose!" message */
private Sprite gotYou;
/** Last shot index */
private int shotIndex;
/** The speed at which the player's ship should move (pixels/sec) */
private float moveSpeed = 300;
/** The time at which last fired a shot */
private long lastFire;
/** The interval between our players shot (ms) */
private long firingInterval = 500;
/** The number of aliens left on the screen */
private int alienCount;
/** True if we're holding up game play until a key has been pressed */
private boolean waitingForKeyPress = true;
/** True if game logic needs to be applied this loop, normally as a result of a game event */
private boolean logicRequiredThisLoop;
/** The time at which the last rendering looped started from the point of view of the game logic */
private long lastLoopTime = getTime();
/** True if the fire key has been released */
private boolean fireHasBeenReleased;
/** The time since the last record of fps */
private long lastFpsTime;
/** The recorded fps */
private int fps;
private static long timerTicksPerSecond = Sys.getTimerResolution();
/** True if the game is currently "running", i.e. the game loop is looping */
public static boolean gameRunning = true;
/** SoundManager to make sound with */
private SoundManager soundManager;
/** Whether we're running in fullscreen mode */
private boolean fullscreen;
/** ID of shot effect */
private int SOUND_SHOT;
/** ID of hit effect */
private int SOUND_HIT;
/** ID of start sound */
private int SOUND_START;
/** ID of win sound */
private int SOUND_WIN;
/** ID of loose sound */
private int SOUND_LOOSE;
/** Mouse movement on x axis */
private int mouseX;
/** Is this an application or applet */
private static boolean isApplication;
/**
* Construct our game and set it running.
* @param fullscreen
*
*/
public Game(boolean fullscreen) {
this.fullscreen = fullscreen;
initialize();
}
/**
* Get the high resolution time in milliseconds
*
* @return The high resolution time in milliseconds
*/
public static long getTime() {
// we get the "timer ticks" from the high resolution timer
// multiply by 1000 so our end result is in milliseconds
// then divide by the number of ticks in a second giving
// us a nice clear time in milliseconds
return (Sys.getTime() * 1000) / timerTicksPerSecond;
}
/**
* Sleep for a fixed number of milliseconds.
*
* @param duration The amount of time in milliseconds to sleep for
*/
public static void sleep(long duration) {
try {
Thread.sleep((duration * timerTicksPerSecond) / 1000);
} catch (InterruptedException inte) {
}
}
/**
* Intialise the common elements for the game
*/
public void initialize() {
// initialize the window beforehand
try {
setDisplayMode();
Display.setTitle(WINDOW_TITLE);
Display.setFullscreen(fullscreen);
Display.create();
// grab the mouse, dont want that hideous cursor when we're playing!
if (isApplication) {
Mouse.setGrabbed(true);
}
// enable textures since we're going to use these for our sprites
glEnable(GL_TEXTURE_2D);
// disable the OpenGL depth test since we're rendering 2D graphics
glDisable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, width, height, 0, -1, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glViewport(0, 0, width, height);
textureLoader = new TextureLoader();
// create our sound manager, and initialize it with 7 channels
// 1 channel for sounds, 6 for effects - this should be enough
// since we have a most 4 shots on screen at any one time, which leaves
// us with 2 channels for explosions.
soundManager = new SoundManager();
soundManager.initialize(8);
// load our sound data
SOUND_SHOT = soundManager.addSound("shot.wav");
SOUND_HIT = soundManager.addSound("hit.wav");
SOUND_START = soundManager.addSound("start.wav");
SOUND_WIN = soundManager.addSound("win.wav");
SOUND_LOOSE = soundManager.addSound("loose.wav");
} catch (LWJGLException le) {
System.out.println("Game exiting - exception in initialization:");
le.printStackTrace();
Game.gameRunning = false;
return;
}
// get our sprites
gotYou = getSprite("gotyou.gif");
pressAnyKey = getSprite("pressanykey.gif");
youWin = getSprite("youwin.gif");
message = pressAnyKey;
// setup 5 shots
shots = new ShotEntity[5];
for (int i = 0; i < shots.length; i++) {
shots[i] = new ShotEntity(this, "shot.gif", 0, 0);
}
// setup the initial game state
startGame();
}
/**
* Sets the display mode for fullscreen mode
*/
private boolean setDisplayMode() {
try {
// get modes
DisplayMode[] dm = org.lwjgl.util.Display.getAvailableDisplayModes(width, height, -1, -1, -1, -1, 60, 60);
org.lwjgl.util.Display.setDisplayMode(dm, new String[] {
"width=" + width,
"height=" + height,
"freq=" + 60,
"bpp=" + org.lwjgl.opengl.Display.getDisplayMode().getBitsPerPixel()
});
return true;
} catch (Exception e) {
e.printStackTrace();
System.out.println("Unable to enter fullscreen, continuing in windowed mode");
}
return false;
}
/**
* Start a fresh game, this should clear out any old data and
* create a new set.
*/
private void startGame() {
// clear out any existing entities and intialise a new set
entities.clear();
initEntities();
}
/**
* Initialise the starting state of the entities (ship and aliens). Each
* entitiy will be added to the overall list of entities in the game.
*/
private void initEntities() {
// create the player ship and place it roughly in the center of the screen
ship = new ShipEntity(this, "ship.gif", 370, 550);
entities.add(ship);
// create a block of aliens (5 rows, by 12 aliens, spaced evenly)
alienCount = 0;
for (int row = 0; row < 5; row++) {
for (int x = 0; x < 12; x++) {
Entity alien = new AlienEntity(this, 100 + (x * 50), (50) + row * 30);
entities.add(alien);
alienCount++;
}
}
}
/**
* Notification from a game entity that the logic of the game
* should be run at the next opportunity (normally as a result of some
* game event)
*/
public void updateLogic() {
logicRequiredThisLoop = true;
}
/**
* Remove an entity from the game. The entity removed will
* no longer move or be drawn.
*
* @param entity The entity that should be removed
*/
public void removeEntity(Entity entity) {
removeList.add(entity);
}
/**
* Notification that the player has died.
*/
public void notifyDeath() {
if (!waitingForKeyPress) {
soundManager.playSound(SOUND_LOOSE);
}
message = gotYou;
waitingForKeyPress = true;
}
/**
* Notification that the player has won since all the aliens
* are dead.
*/
public void notifyWin() {
message = youWin;
waitingForKeyPress = true;
soundManager.playSound(SOUND_WIN);
}
/**
* Notification that an alien has been killed
*/
public void notifyAlienKilled() {
// reduce the alient count, if there are none left, the player has won!
alienCount--;
if (alienCount == 0) {
notifyWin();
}
// if there are still some aliens left then they all need to get faster, so
// speed up all the existing aliens
for ( Entity entity : entities ) {
if ( entity instanceof AlienEntity ) {
// speed up by 2%
entity.setHorizontalMovement(entity.getHorizontalMovement() * 1.02f);
}
}
soundManager.playEffect(SOUND_HIT);
}
/**
* Attempt to fire a shot from the player. Its called "try"
* since we must first check that the player can fire at this
* point, i.e. has he/she waited long enough between shots
*/
public void tryToFire() {
// check that we have waiting long enough to fire
if (System.currentTimeMillis() - lastFire < firingInterval) {
return;
}
// if we waited long enough, create the shot entity, and record the time.
lastFire = System.currentTimeMillis();
ShotEntity shot = shots[shotIndex++ % shots.length];
shot.reinitialize(ship.getX() + 10, ship.getY() - 30);
entities.add(shot);
soundManager.playEffect(SOUND_SHOT);
}
/**
* Run the main game loop. This method keeps rendering the scene
* and requesting that the callback update its screen.
*/
private void gameLoop() {
while (Game.gameRunning) {
// clear screen
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// let subsystem paint
frameRendering();
// update window contents
Display.update();
}
// clean up
soundManager.destroy();
Display.destroy();
}
/**
* Notification that a frame is being rendered. Responsible for
* running game logic and rendering the scene.
*/
public void frameRendering() {
//SystemTimer.sleep(lastLoopTime+10-SystemTimer.getTime());
Display.sync(60);
// work out how long its been since the last update, this
// will be used to calculate how far the entities should
// move this loop
long delta = getTime() - lastLoopTime;
lastLoopTime = getTime();
lastFpsTime += delta;
fps++;
// update our FPS counter if a second has passed
if (lastFpsTime >= 1000) {
Display.setTitle(WINDOW_TITLE + " (FPS: " + fps + ")");
lastFpsTime = 0;
fps = 0;
}
// cycle round asking each entity to move itself
if (!waitingForKeyPress && !soundManager.isPlayingSound()) {
for ( Entity entity : entities ) {
entity.move(delta);
}
}
// cycle round drawing all the entities we have in the game
for ( Entity entity : entities ) {
entity.draw();
}
// brute force collisions, compare every entity against
// every other entity. If any of them collide notify
// both entities that the collision has occured
for (int p = 0; p < entities.size(); p++) {
for (int s = p + 1; s < entities.size(); s++) {
Entity me = entities.get(p);
Entity him = entities.get(s);
if (me.collidesWith(him)) {
me.collidedWith(him);
him.collidedWith(me);
}
}
}
// remove any entity that has been marked for clear up
entities.removeAll(removeList);
removeList.clear();
// if a game event has indicated that game logic should
// be resolved, cycle round every entity requesting that
// their personal logic should be considered.
if (logicRequiredThisLoop) {
for ( Entity entity : entities ) {
entity.doLogic();
}
logicRequiredThisLoop = false;
}
// if we're waiting for an "any key" press then draw the
// current message
if (waitingForKeyPress) {
message.draw(325, 250);
}
// resolve the movemfent of the ship. First assume the ship
// isn't moving. If either cursor key is pressed then
// update the movement appropraitely
ship.setHorizontalMovement(0);
// get mouse movement on x axis. We need to get it now, since
// we can only call getDX ONCE! - secondary calls will yield 0, since
// there haven't been any movement since last call.
mouseX = Mouse.getDX();
// we delegate input checking to submethod since we want to check
// for keyboard, mouse & controller
boolean leftPressed = hasInput(Keyboard.KEY_LEFT);
boolean rightPressed = hasInput(Keyboard.KEY_RIGHT);
boolean firePressed = hasInput(Keyboard.KEY_SPACE);
if (!waitingForKeyPress && !soundManager.isPlayingSound()) {
if ((leftPressed) && (!rightPressed)) {
ship.setHorizontalMovement(-moveSpeed);
} else if ((rightPressed) && (!leftPressed)) {
ship.setHorizontalMovement(moveSpeed);
}
// if we're pressing fire, attempt to fire
if (firePressed) {
tryToFire();
}
} else {
if (!firePressed) {
fireHasBeenReleased = true;
}
if ((firePressed) && (fireHasBeenReleased) && !soundManager.isPlayingSound()) {
waitingForKeyPress = false;
fireHasBeenReleased = false;
startGame();
soundManager.playSound(SOUND_START);
}
}
// if escape has been pressed, stop the game
if ((Display.isCloseRequested() || Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)) && isApplication) {
Game.gameRunning = false;
}
}
/**
* @param direction
* @return
*/
private boolean hasInput(int direction) {
switch(direction) {
case Keyboard.KEY_LEFT:
return
Keyboard.isKeyDown(Keyboard.KEY_LEFT) ||
mouseX < 0;
case Keyboard.KEY_RIGHT:
return
Keyboard.isKeyDown(Keyboard.KEY_RIGHT) ||
mouseX > 0;
case Keyboard.KEY_SPACE:
return
Keyboard.isKeyDown(Keyboard.KEY_SPACE) ||
Mouse.isButtonDown(0);
}
return false;
}
/**
* The entry point into the game. We'll simply create an
* instance of class which will start the display and game
* loop.
*
* @param argv The arguments that are passed into our game
*/
public static void main(String argv[]) {
isApplication = true;
System.out.println("Use -fullscreen for fullscreen mode");
new Game((argv.length > 0 && "-fullscreen".equalsIgnoreCase(argv[0]))).execute();
System.exit(0);
}
/**
*
*/
public void execute() {
gameLoop();
}
/**
* Create or get a sprite which displays the image that is pointed
* to in the classpath by "ref"
*
* @param ref A reference to the image to load
* @return A sprite that can be drawn onto the current graphics context.
*/
public Sprite getSprite(String ref) {
return new Sprite(textureLoader, ref);
}
}
lwjgl-2.7.1/src/java/org/lwjgl/examples/spaceinvaders/Sprite.java 0000644 0001750 0001750 00000007253 11543426510 024124 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.examples.spaceinvaders;
import java.io.IOException;
import static org.lwjgl.opengl.GL11.*;
/**
* Implementation of sprite that uses an OpenGL quad and a texture
* to render a given image to the screen.
*
* @author Kevin Glass
* @author Brian Matzon
*/
public class Sprite {
/** The texture that stores the image for this sprite */
private Texture texture;
/** The width in pixels of this sprite */
private int width;
/** The height in pixels of this sprite */
private int height;
/**
* Create a new sprite from a specified image.
*
* @param loader the texture loader to use
* @param ref A reference to the image on which this sprite should be based
*/
public Sprite(TextureLoader loader, String ref) {
try {
texture = loader.getTexture("spaceinvaders/" + ref);
width = texture.getImageWidth();
height = texture.getImageHeight();
} catch (IOException ioe) {
ioe.printStackTrace();
System.exit(-1);
}
}
/**
* Get the width of this sprite in pixels
*
* @return The width of this sprite in pixels
*/
public int getWidth() {
return texture.getImageWidth();
}
/**
* Get the height of this sprite in pixels
*
* @return The height of this sprite in pixels
*/
public int getHeight() {
return texture.getImageHeight();
}
/**
* Draw the sprite at the specified location
*
* @param x The x location at which to draw this sprite
* @param y The y location at which to draw this sprite
*/
public void draw(int x, int y) {
// store the current model matrix
glPushMatrix();
// bind to the appropriate texture for this sprite
texture.bind();
// translate to the right location and prepare to draw
glTranslatef(x, y, 0);
// draw a quad textured to match the sprite
glBegin(GL_QUADS);
{
glTexCoord2f(0, 0);
glVertex2f(0, 0);
glTexCoord2f(0, texture.getHeight());
glVertex2f(0, height);
glTexCoord2f(texture.getWidth(), texture.getHeight());
glVertex2f(width, height);
glTexCoord2f(texture.getWidth(), 0);
glVertex2f(width, 0);
}
glEnd();
// restore the model view matrix to prevent contamination
glPopMatrix();
}
} lwjgl-2.7.1/src/java/org/lwjgl/examples/spaceinvaders/TextureLoader.java 0000644 0001750 0001750 00000024454 11543426510 025447 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.examples.spaceinvaders;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.color.ColorSpace;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.ComponentColorModel;
import java.awt.image.DataBuffer;
import java.awt.image.DataBufferByte;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;
import java.io.IOException;
import java.net.URL;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.IntBuffer;
import java.util.HashMap;
import java.util.Hashtable;
import javax.swing.ImageIcon;
import org.lwjgl.BufferUtils;
import static org.lwjgl.opengl.GL11.*;
/**
* A utility class to load textures for OpenGL. This source is based
* on a texture that can be found in the Java Gaming (www.javagaming.org)
* Wiki. It has been simplified slightly for explicit 2D graphics use.
*
* OpenGL uses a particular image format. Since the images that are
* loaded from disk may not match this format this loader introduces
* a intermediate image which the source image is copied into. In turn,
* this image is used as source for the OpenGL texture.
*
* @author Kevin Glass
* @author Brian Matzon
*/
public class TextureLoader {
/** The table of textures that have been loaded in this loader */
private HashMap table = new HashMap();
/** The colour model including alpha for the GL image */
private ColorModel glAlphaColorModel;
/** The colour model for the GL image */
private ColorModel glColorModel;
/** Scratch buffer for texture ID's */
private IntBuffer textureIDBuffer = BufferUtils.createIntBuffer(1);
/**
* Create a new texture loader based on the game panel
*/
public TextureLoader() {
glAlphaColorModel = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB),
new int[] {8,8,8,8},
true,
false,
ComponentColorModel.TRANSLUCENT,
DataBuffer.TYPE_BYTE);
glColorModel = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB),
new int[] {8,8,8,0},
false,
false,
ComponentColorModel.OPAQUE,
DataBuffer.TYPE_BYTE);
}
/**
* Create a new texture ID
*
* @return A new texture ID
*/
private int createTextureID() {
glGenTextures(textureIDBuffer);
return textureIDBuffer.get(0);
}
/**
* Load a texture
*
* @param resourceName The location of the resource to load
* @return The loaded texture
* @throws IOException Indicates a failure to access the resource
*/
public Texture getTexture(String resourceName) throws IOException {
Texture tex = table.get(resourceName);
if (tex != null) {
return tex;
}
tex = getTexture(resourceName,
GL_TEXTURE_2D, // target
GL_RGBA, // dst pixel format
GL_LINEAR, // min filter (unused)
GL_LINEAR);
table.put(resourceName,tex);
return tex;
}
/**
* Load a texture into OpenGL from a image reference on
* disk.
*
* @param resourceName The location of the resource to load
* @param target The GL target to load the texture against
* @param dstPixelFormat The pixel format of the screen
* @param minFilter The minimising filter
* @param magFilter The magnification filter
* @return The loaded texture
* @throws IOException Indicates a failure to access the resource
*/
public Texture getTexture(String resourceName,
int target,
int dstPixelFormat,
int minFilter,
int magFilter) throws IOException {
int srcPixelFormat;
// create the texture ID for this texture
int textureID = createTextureID();
Texture texture = new Texture(target,textureID);
// bind this texture
glBindTexture(target, textureID);
BufferedImage bufferedImage = loadImage(resourceName);
texture.setWidth(bufferedImage.getWidth());
texture.setHeight(bufferedImage.getHeight());
if (bufferedImage.getColorModel().hasAlpha()) {
srcPixelFormat = GL_RGBA;
} else {
srcPixelFormat = GL_RGB;
}
// convert that image into a byte buffer of texture data
ByteBuffer textureBuffer = convertImageData(bufferedImage,texture);
if (target == GL_TEXTURE_2D) {
glTexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilter);
glTexParameteri(target, GL_TEXTURE_MAG_FILTER, magFilter);
}
// produce a texture from the byte buffer
glTexImage2D(target,
0,
dstPixelFormat,
get2Fold(bufferedImage.getWidth()),
get2Fold(bufferedImage.getHeight()),
0,
srcPixelFormat,
GL_UNSIGNED_BYTE,
textureBuffer );
return texture;
}
/**
* Get the closest greater power of 2 to the fold number
*
* @param fold The target number
* @return The power of 2
*/
private static int get2Fold(int fold) {
int ret = 2;
while (ret < fold) {
ret *= 2;
}
return ret;
}
/**
* Convert the buffered image to a texture
*
* @param bufferedImage The image to convert to a texture
* @param texture The texture to store the data into
* @return A buffer containing the data
*/
private ByteBuffer convertImageData(BufferedImage bufferedImage,Texture texture) {
ByteBuffer imageBuffer;
WritableRaster raster;
BufferedImage texImage;
int texWidth = 2;
int texHeight = 2;
// find the closest power of 2 for the width and height
// of the produced texture
while (texWidth < bufferedImage.getWidth()) {
texWidth *= 2;
}
while (texHeight < bufferedImage.getHeight()) {
texHeight *= 2;
}
texture.setTextureHeight(texHeight);
texture.setTextureWidth(texWidth);
// create a raster that can be used by OpenGL as a source
// for a texture
if (bufferedImage.getColorModel().hasAlpha()) {
raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,texWidth,texHeight,4,null);
texImage = new BufferedImage(glAlphaColorModel,raster,false,new Hashtable());
} else {
raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,texWidth,texHeight,3,null);
texImage = new BufferedImage(glColorModel,raster,false,new Hashtable());
}
// copy the source image into the produced image
Graphics g = texImage.getGraphics();
g.setColor(new Color(0f,0f,0f,0f));
g.fillRect(0,0,texWidth,texHeight);
g.drawImage(bufferedImage,0,0,null);
// build a byte buffer from the temporary image
// that be used by OpenGL to produce a texture.
byte[] data = ((DataBufferByte) texImage.getRaster().getDataBuffer()).getData();
imageBuffer = ByteBuffer.allocateDirect(data.length);
imageBuffer.order(ByteOrder.nativeOrder());
imageBuffer.put(data, 0, data.length);
imageBuffer.flip();
return imageBuffer;
}
/**
* Load a given resource as a buffered image
*
* @param ref The location of the resource to load
* @return The loaded buffered image
* @throws IOException Indicates a failure to find a resource
*/
private BufferedImage loadImage(String ref) throws IOException {
URL url = TextureLoader.class.getClassLoader().getResource(ref);
if (url == null) {
throw new IOException("Cannot find: " + ref);
}
// due to an issue with ImageIO and mixed signed code
// we are now using good oldfashioned ImageIcon to load
// images and the paint it on top of a new BufferedImage
Image img = new ImageIcon(url).getImage();
BufferedImage bufferedImage = new BufferedImage(img.getWidth(null), img.getHeight(null), BufferedImage.TYPE_INT_RGB);
Graphics g = bufferedImage.getGraphics();
g.drawImage(img, 0, 0, null);
g.dispose();
return bufferedImage;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/examples/spaceinvaders/GameApplet.java 0000644 0001750 0001750 00000004457 11543426510 024700 0 ustar zero79 zero79 package org.lwjgl.examples.spaceinvaders;
import java.applet.Applet;
import java.awt.BorderLayout;
import java.awt.Canvas;
import org.lwjgl.LWJGLException;
import org.lwjgl.opengl.Display;
public class GameApplet extends Applet {
/** The Canvas where the LWJGL Display is added */
Canvas display_parent;
/** Thread which runs the main game loop */
Thread gameThread;
/** The Game instance */
Game game;
/**
* Once the Canvas is created its add notify method will call this method to
* start the LWJGL Display and game loop in another thread.
*/
public void startLWJGL() {
gameThread = new Thread() {
public void run() {
try {
Display.setParent(display_parent);
} catch (LWJGLException e) {
e.printStackTrace();
}
// start game
game = new Game(false);
game.execute();
}
};
gameThread.start();
}
/**
* Tell game loop to stop running, after which the LWJGL Display will be destoryed.
* The main thread will wait for the Display.destroy() to complete
*/
private void stopLWJGL() {
Game.gameRunning = false;
try {
gameThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void start() {
}
public void stop() {
}
/**
* Applet Destroy method will remove the canvas, before canvas is destroyed it will notify
* stopLWJGL() to stop main game loop and to destroy the Display
*/
public void destroy() {
remove(display_parent);
super.destroy();
System.out.println("Clear up");
}
/**
* initialise applet by adding a canvas to it, this canvas will start the LWJGL Display and game loop
* in another thread. It will also stop the game loop and destroy the display on canvas removal when
* applet is destroyed.
*/
public void init() {
setLayout(new BorderLayout());
try {
display_parent = new Canvas() {
public void addNotify() {
super.addNotify();
startLWJGL();
}
public void removeNotify() {
stopLWJGL();
super.removeNotify();
}
};
display_parent.setSize(getWidth(),getHeight());
add(display_parent);
display_parent.setFocusable(true);
display_parent.requestFocus();
display_parent.setIgnoreRepaint(true);
setVisible(true);
} catch (Exception e) {
System.err.println(e);
throw new RuntimeException("Unable to create display");
}
}
} lwjgl-2.7.1/src/java/org/lwjgl/examples/spaceinvaders/AlienEntity.java 0000644 0001750 0001750 00000011441 11543426510 025075 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.examples.spaceinvaders;
/**
* An entity which represents one of our space invader aliens.
*
* @author Kevin Glass
* @author Brian Matzon
*/
public class AlienEntity extends Entity {
/** Movement made downwards when a border is hit */
private static final int DOWNWARD_MOVEMENT = 10;
/** Border at which player dies */
private static final int BOTTOM_BORDER = 570;
/** Right border at which to shift direction */
private static final int RIGHT_BORDER = 750;
/** Left border at which to shift direction */
private static final int LEFT_BORDER = 10;
/** The speed at which the alient moves horizontally */
private float moveSpeed = 75;
/** The game in which the entity exists */
private Game game;
/** The animation frames */
private Sprite[] frames = new Sprite[4];
/** The time since the last frame change took place */
private long lastFrameChange;
/** The frame duration in milliseconds, i.e. how long any given frame of animation lasts */
private long frameDuration = 250;
/** The current frame of animation being displayed */
private int frameNumber;
/**
* Create a new alien entity
*
* @param game The game in which this entity is being created
* @param x The intial x location of this alien
* @param y The intial y location of this alient
*/
public AlienEntity(Game game, int x, int y) {
super(game.getSprite("alien.gif"), x, y);
// setup the animatin frames
frames[0] = sprite;
frames[1] = game.getSprite("alien2.gif");
frames[2] = sprite;
frames[3] = game.getSprite("alien3.gif");
this.game = game;
dx = -moveSpeed;
}
/**
* Request that this alien moved based on time elapsed
*
* @param delta The time that has elapsed since last move
*/
public void move(long delta) {
// since the move tells us how much time has passed
// by we can use it to drive the animation, however
// its the not the prettiest solution
lastFrameChange += delta;
// if we need to change the frame, update the frame number
// and flip over the sprite in use
if (lastFrameChange > frameDuration) {
// reset our frame change time counter
lastFrameChange = 0;
// update the frame
frameNumber++;
if (frameNumber >= frames.length) {
frameNumber = 0;
}
sprite = frames[frameNumber];
}
// if we have reached the left hand side of the screen and
// are moving left then request a logic update
if ((dx < 0) && (x < LEFT_BORDER)) {
game.updateLogic();
}
// and vice vesa, if we have reached the right hand side of
// the screen and are moving right, request a logic update
if ((dx > 0) && (x > RIGHT_BORDER)) {
game.updateLogic();
}
// proceed with normal move
super.move(delta);
}
/**
* Update the game logic related to aliens
*/
public void doLogic() {
// swap over horizontal movement and move down the
// screen a bit
dx = -dx;
y += DOWNWARD_MOVEMENT;
// if we've reached the bottom of the screen then the player
// dies
if (y > BOTTOM_BORDER) {
game.notifyDeath();
}
}
/**
* Notification that this alien has collided with another entity
*
* @param other The other entity
*/
public void collidedWith(Entity other) {
// collisions with aliens are handled elsewhere
}
} lwjgl-2.7.1/src/java/org/lwjgl/examples/spaceinvaders/ShotEntity.java 0000644 0001750 0001750 00000007062 11543426510 024766 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.examples.spaceinvaders;
/**
* An entity representing a shot fired by the player's ship
*
* @author Kevin Glass
* @author Brian Matzon
*/
public class ShotEntity extends Entity {
/** Top border at which shots are outside */
private static final int TOP_BORDER = -100;
/** The vertical speed at which the players shot moves */
private float moveSpeed = -300;
/** The game in which this entity exists */
private Game game;
/** True if this shot has been "used", i.e. its hit something */
private boolean used;
/**
* Create a new shot from the player
*
* @param game The game in which the shot has been created
* @param sprite The sprite representing this shot
* @param x The initial x location of the shot
* @param y The initial y location of the shot
*/
public ShotEntity(Game game, String sprite, int x, int y) {
super(game.getSprite(sprite), x, y);
this.game = game;
dy = moveSpeed;
}
/**
* Reinitializes this entity, for reuse
*
* @param x new x coordinate
* @param y new y coordinate
*/
public void reinitialize(int x, int y) {
this.x = x;
this.y = y;
used = false;
}
/**
* Request that this shot moved based on time elapsed
*
* @param delta The time that has elapsed since last move
*/
public void move(long delta) {
// proceed with normal move
super.move(delta);
// if we shot off the screen, remove ourselfs
if (y < TOP_BORDER) {
game.removeEntity(this);
}
}
/**
* Notification that this shot has collided with another
* entity
*
* @param other The other entity with which we've collided
*/
public void collidedWith(Entity other) {
// prevents double kills, if we've already hit something,
// don't collide
if (used) {
return;
}
// if we've hit an alien, kill it!
if (other instanceof AlienEntity) {
// remove the affected entities
game.removeEntity(this);
game.removeEntity(other);
// notify the game that the alien has been killed
game.notifyAlienKilled();
used = true;
}
}
} lwjgl-2.7.1/src/java/org/lwjgl/examples/spaceinvaders/SoundManager.java 0000644 0001750 0001750 00000013106 11543426510 025233 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.examples.spaceinvaders;
import java.nio.IntBuffer;
import org.lwjgl.BufferUtils;
import org.lwjgl.LWJGLException;
import org.lwjgl.openal.AL;
import org.lwjgl.openal.AL10;
import org.lwjgl.util.WaveData;
/**
*
* Simple sound manager for OpenAL using n sources accessed in
* a round robin schedule. Source n is reserved for a single buffer and checking for
* whether it's playing.
*
* @author Brian Matzon
* @version $Revision: 3418 $
* $Id: SoundManager.java 3418 2010-09-28 21:11:35Z spasi $
*/
public class SoundManager {
/** We support at most 256 buffers*/
private int[] buffers = new int[256];
/** Number of sources is limited tby user (and hardware) */
private int[] sources;
/** Our internal scratch buffer */
private IntBuffer scratchBuffer = BufferUtils.createIntBuffer(256);
/** Whether we're running in no sound mode */
private boolean soundOutput;
/** Current index in our buffers */
private int bufferIndex;
/** Current index in our source list */
private int sourceIndex;
/**
* Creates a new SoundManager
*/
public SoundManager() {
}
/**
* Plays a sound effect
* @param buffer Buffer index to play gotten from addSound
*/
public void playEffect(int buffer) {
if(soundOutput) {
// make sure we never choose last channel, since it is used for special sounds
int channel = sources[(sourceIndex++ % (sources.length-1))];
// link buffer and source, and play it
AL10.alSourcei(channel, AL10.AL_BUFFER, buffers[buffer]);
AL10.alSourcePlay(channel);
}
}
/**
* Plays a sound on last source
* @param buffer Buffer index to play gotten from addSound
*/
public void playSound(int buffer) {
if(soundOutput) {
AL10.alSourcei(sources[sources.length-1], AL10.AL_BUFFER, buffers[buffer]);
AL10.alSourcePlay(sources[sources.length-1]);
}
}
/**
* Whether a sound is playing on last source
* @return true if a source is playing right now on source n
*/
public boolean isPlayingSound() {
return AL10.alGetSourcei(sources[sources.length-1], AL10.AL_SOURCE_STATE) == AL10.AL_PLAYING;
}
/**
* Initializes the SoundManager
*
* @param channels Number of channels to create
*/
public void initialize(int channels) {
try {
AL.create();
// allocate sources
scratchBuffer.limit(channels);
AL10.alGenSources(scratchBuffer);
scratchBuffer.rewind();
scratchBuffer.get(sources = new int[channels]);
// could we allocate all channels?
if(AL10.alGetError() != AL10.AL_NO_ERROR) {
throw new LWJGLException("Unable to allocate " + channels + " sources");
}
// we have sound
soundOutput = true;
} catch (LWJGLException le) {
le.printStackTrace();
System.out.println("Sound disabled");
}
}
/**
* Adds a sound to the Sound Managers pool
*
* @param path Path to file to load
* @return index into SoundManagers buffer list
*/
public int addSound(String path) {
// Generate 1 buffer entry
scratchBuffer.rewind().position(0).limit(1);
AL10.alGenBuffers(scratchBuffer);
buffers[bufferIndex] = scratchBuffer.get(0);
// load wave data from buffer
WaveData wavefile = WaveData.create("spaceinvaders/" + path);
// copy to buffers
AL10.alBufferData(buffers[bufferIndex], wavefile.format, wavefile.data, wavefile.samplerate);
// unload file again
wavefile.dispose();
// return index for this sound
return bufferIndex++;
}
/**
* Destroy this SoundManager
*/
public void destroy() {
if(soundOutput) {
// stop playing sounds
scratchBuffer.position(0).limit(sources.length);
scratchBuffer.put(sources).flip();
AL10.alSourceStop(scratchBuffer);
// destroy sources
AL10.alDeleteSources(scratchBuffer);
// destroy buffers
scratchBuffer.position(0).limit(bufferIndex);
scratchBuffer.put(buffers, 0, bufferIndex).flip();
AL10.alDeleteBuffers(scratchBuffer);
// destory OpenAL
AL.destroy();
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/examples/spaceinvaders/ShipEntity.java 0000644 0001750 0001750 00000006406 11543426510 024755 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.examples.spaceinvaders;
/**
* The entity that represents the players ship
*
* @author Kevin Glass
* @author Brian Matzon
*/
public class ShipEntity extends Entity {
/** Right border at which to disallow further movement */
private static final int RIGHT_BORDER = 750;
/** Left border at which to disallow further movement */
private static final int LEFT_BORDER = 10;
/** The game in which the ship exists */
private Game game;
/**
* Create a new entity to represent the players ship
*
* @param game The game in which the ship is being created
* @param ref The reference to the sprite to show for the ship
* @param x The initial x location of the player's ship
* @param y The initial y location of the player's ship
*/
public ShipEntity(Game game,String ref,int x,int y) {
super(game.getSprite(ref), x, y);
this.game = game;
}
/**
* Request that the ship move itself based on an elapsed ammount of
* time
*
* @param delta The time that has elapsed since last move (ms)
*/
public void move(long delta) {
// if we're moving left and have reached the left hand side
// of the screen, don't move
if ((dx < 0) && (x < LEFT_BORDER)) {
return;
}
// if we're moving right and have reached the right hand side
// of the screen, don't move
if ((dx > 0) && (x > RIGHT_BORDER)) {
return;
}
super.move(delta);
}
/**
* Notification that the player's ship has collided with something
*
* @param other The entity with which the ship has collided
*/
public void collidedWith(Entity other) {
// if its an alien, notify the game that the player
// is dead
if (other instanceof AlienEntity) {
game.notifyDeath();
}
}
} lwjgl-2.7.1/src/java/org/lwjgl/openal/ 0000755 0001750 0001750 00000000000 11543426510 016615 5 ustar zero79 zero79 lwjgl-2.7.1/src/java/org/lwjgl/openal/Util.java 0000644 0001750 0001750 00000005544 11543426510 020405 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.openal;
/**
* Simple utility class for checking AL/ALC errors
*
* @author cix_foo
* @author Brian Matzon
* @version $Revision: 2983 $
*/
public final class Util {
/** No c'tor */
private Util() {
}
/**
* Checks for any ALC errors and throws an unchecked exception on errors
* @param device Device for which to check ALC errors
*/
public static void checkALCError(ALCdevice device) {
int err = ALC10.alcGetError(device);
if (err != ALC10.ALC_NO_ERROR)
throw new OpenALException(ALC10.alcGetString(AL.getDevice(), err));
}
/**
* Checks for any AL errors and throws an unchecked exception on errors
*/
public static void checkALError() {
int err = AL10.alGetError();
if (err != AL10.AL_NO_ERROR)
throw new OpenALException(err);
}
/**
* Checks for a valid device
* @param device ALCdevice to check the validity of
*/
public static void checkALCValidDevice(ALCdevice device) {
if(!device.isValid()) {
throw new OpenALException("Invalid device: " + device);
}
}
/**
* Checks for a valid context
* @param context ALCcontext to check the validity of
*/
public static void checkALCValidContext(ALCcontext context) {
if(!context.isValid()) {
throw new OpenALException("Invalid context: " + context);
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/openal/EFXUtil.java 0000644 0001750 0001750 00000022164 11543426510 020745 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.openal;
import static org.lwjgl.openal.AL10.*;
import static org.lwjgl.openal.EFX10.*;
/**
* Utility class for the OpenAL extension ALC_EXT_EFX. Provides functions to check for the extension
* and support of various effects and filters.
*
* Currently supports ALC_EXT_EFX version 1.0 effects and filters.
*
* @author Ciardhubh
* @version $Revision$
* $Id$
*/
public final class EFXUtil {
/** Constant for testSupportGeneric to check an effect. */
private static final int EFFECT = 1111;
/** Constant for testSupportGeneric to check a filter. */
private static final int FILTER = 2222;
/** Utility class, hidden contructor. */
private EFXUtil() {
}
/**
* Checks if OpenAL implementation is loaded and supports ALC_EXT_EFX.
*
* @return True if ALC_EXT_EFX is supported, false if not.
* @throws OpenALException If OpenAL has not been created yet.
*/
public static boolean isEfxSupported() {
if (!AL.isCreated()) {
throw new OpenALException("OpenAL has not been created.");
}
return ALC10.alcIsExtensionPresent(AL.getDevice(), ALC_EXT_EFX_NAME);
}
/**
* Tests OpenAL to see whether the given effect type is supported. This is done by creating an
* effect of the given type. If creation succeeds the effect is supported.
*
* @param effectType Type of effect whose support is to be tested, e.g. AL_EFFECT_REVERB.
* @return True if it is supported, false if not.
* @throws OpenALException If the request fails due to an AL_OUT_OF_MEMORY error or OpenAL has
* not been created yet.
* @throws IllegalArgumentException effectType is not a valid effect type.
*/
public static boolean isEffectSupported(final int effectType) {
// Make sure type is a real effect.
switch (effectType) {
case AL_EFFECT_NULL:
case AL_EFFECT_EAXREVERB:
case AL_EFFECT_REVERB:
case AL_EFFECT_CHORUS:
case AL_EFFECT_DISTORTION:
case AL_EFFECT_ECHO:
case AL_EFFECT_FLANGER:
case AL_EFFECT_FREQUENCY_SHIFTER:
case AL_EFFECT_VOCAL_MORPHER:
case AL_EFFECT_PITCH_SHIFTER:
case AL_EFFECT_RING_MODULATOR:
case AL_EFFECT_AUTOWAH:
case AL_EFFECT_COMPRESSOR:
case AL_EFFECT_EQUALIZER:
break;
default:
throw new IllegalArgumentException("Unknown or invalid effect type: " + effectType);
}
return testSupportGeneric(EFFECT, effectType);
}
/**
* Tests OpenAL to see whether the given filter type is supported. This is done by creating a
* filter of the given type. If creation succeeds the filter is supported.
*
* @param filterType Type of filter whose support is to be tested, e.g. AL_FILTER_LOWPASS.
* @return True if it is supported, false if not.
* @throws OpenALException If the request fails due to an AL_OUT_OF_MEMORY error or OpenAL has
* not been created yet.
* @throws IllegalArgumentException filterType is not a valid filter type.
*/
public static boolean isFilterSupported(final int filterType) {
// Make sure type is a real filter.
switch (filterType) {
case AL_FILTER_NULL:
case AL_FILTER_LOWPASS:
case AL_FILTER_HIGHPASS:
case AL_FILTER_BANDPASS:
break;
default:
throw new IllegalArgumentException("Unknown or invalid filter type: " + filterType);
}
return testSupportGeneric(FILTER, filterType);
}
/**
* Generic test function to see if an EFX object supports a given kind of type. Works for
* effects and filters.
*
* @param objectType Type of object to test. Must be either EFXUtil.EFFECT or EFXUtil.FILTER.
* @param typeValue OpenAL type the object should be tested for support, e.g. AL_FILTER_LOWPASS
* or AL_EFFECT_REVERB.
* @return True if object supports typeValue, false else.
*/
private static boolean testSupportGeneric(final int objectType, final int typeValue) {
// Check for supported objectType.
switch (objectType) {
case EFFECT:
case FILTER:
break;
default:
throw new IllegalArgumentException("Invalid objectType: " + objectType);
}
boolean supported = false;
if (isEfxSupported()) {
// Try to create object in order to check AL's response.
alGetError();
int genError;
int testObject = 0;
try {
switch (objectType) { // Create object based on type
case EFFECT:
testObject = alGenEffects();
break;
case FILTER:
testObject = alGenFilters();
break;
default:
throw new IllegalArgumentException("Invalid objectType: " + objectType);
}
genError = alGetError();
} catch (final OpenALException debugBuildException) {
// Hack because OpenALException hides the original error code (short of parsing the
// error message String which would break if it gets changed).
if (debugBuildException.getMessage().contains("AL_OUT_OF_MEMORY")) {
genError = AL_OUT_OF_MEMORY;
} else {
genError = AL_INVALID_OPERATION;
}
}
if (genError == AL_NO_ERROR) {
// Successfully created, now try to set type.
alGetError();
int setError;
try {
switch (objectType) { // Set based on object type
case EFFECT:
alEffecti(testObject, AL_EFFECT_TYPE, typeValue);
break;
case FILTER:
alFilteri(testObject, AL_FILTER_TYPE, typeValue);
break;
default:
throw new IllegalArgumentException("Invalid objectType: " + objectType);
}
setError = alGetError();
} catch (final OpenALException debugBuildException) {
// Hack because OpenALException hides the original error code (short of parsing
// the error message String which would break when it gets changed).
setError = AL_INVALID_VALUE;
}
if (setError == AL_NO_ERROR) {
supported = true;
}
// Cleanup
try {
switch (objectType) { // Set based on object type
case EFFECT:
alDeleteEffects(testObject);
break;
case FILTER:
alDeleteFilters(testObject);
break;
default:
throw new IllegalArgumentException("Invalid objectType: " + objectType);
}
} catch (final OpenALException debugBuildException) {
// Don't care about cleanup errors.
}
} else if (genError == AL_OUT_OF_MEMORY) {
throw new OpenALException(genError);
}
}
return supported;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/openal/ALC11.java 0000644 0001750 0001750 00000020505 11543426510 020223 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.openal;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import org.lwjgl.BufferUtils;
import org.lwjgl.LWJGLException;
import org.lwjgl.LWJGLUtil;
/**
*
* The ALC11 class implements features in OpenAL 1.1, specifically
* ALC methods and properties.
*
*
* @author Brian Matzon
* @see ALC10
* @version $Revision: 2286 $
* $Id: ALC.java 2286 2006-03-23 19:32:21 +0000 (to, 23 mar 2006) matzon $
*/
public final class ALC11 {
public static final int ALC_DEFAULT_ALL_DEVICES_SPECIFIER = 0x1012;
public static final int ALC_ALL_DEVICES_SPECIFIER = 0x1013;
public static final int ALC_CAPTURE_DEVICE_SPECIFIER = 0x310;
public static final int ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER = 0x311;
public static final int ALC_CAPTURE_SAMPLES = 0x312;
public static final int ALC_MONO_SOURCES = 0x1010;
public static final int ALC_STEREO_SOURCES = 0x1011;
/**
* The alcCaptureOpenDevice function allows the application to connect to a capture
* device. To obtain a list of all available capture devices, use getCaptureDevices a list of all
* capture devices will be returned. Retrieving ALC_CAPTURE_DEVICE_SPECIFIER with a valid capture device specified will result
* in the name of that device being returned as a single string.
*
* If the function returns null, then no sound driver/device has been found, or the
* requested format could not be fulfilled.
* The "deviceName" argument is a string that requests a certain device or
* device configuration. If null is specified, the implementation will provide an
* implementation specific default. The "frequency" and "format" arguments specify the format that
* audio data will be presented to the application, and match the values that can be passed to
* alBufferData. The implementation is expected to convert and resample to this format on
* behalf of the application. The "buffersize" argument specifies the number of sample frames
* to buffer in the AL, for example, requesting a format of AL_FORMAT_STEREO16 and
* a buffer size of 1024 would require the AL to store up to 1024 * 4 bytes of audio data.
* Note that the implementation may use a larger buffer than requested if it needs to, but the
* implementation will set up a buffer of at least the requested size.
* Specifying a compressed or extension-supplied format may result in failure, even if the
* extension is supplied for rendering.
*
* LWJGL SPECIFIC: the actual created device is managed internally in lwjgl
*
* @param devicename Name of device to open for capture
* @param frequency Frequency of samples to capture
* @param format Format of samples to capture
* @param buffersize Size of buffer to capture to
* @return ALCdevice if it was possible to open a device
*/
public static ALCdevice alcCaptureOpenDevice(String devicename, int frequency, int format, int buffersize) {
long device_address = nalcCaptureOpenDevice(devicename, frequency, format, buffersize);
if(device_address != 0) {
ALCdevice device = new ALCdevice(device_address);
synchronized (ALC10.devices) {
ALC10.devices.put(device_address, device);
}
return device;
}
return null;
}
static native long nalcCaptureOpenDevice( String devicename, int frequency, int format, int buffersize);
/**
* The alcCaptureCloseDevice function allows the application to disconnect from a capture
* device.
*
* The return code will be true or false, indicating success or failure. If
* the device is null or invalid, an ALC_INVALID_DEVICE error will be generated.
* Once closed, a capture device is invalid.
* @return true if device was successfully closed
*/
public static boolean alcCaptureCloseDevice(ALCdevice device) {
boolean result = nalcCaptureCloseDevice(ALC10.getDevice(device));
synchronized (ALC10.devices) {
device.setInvalid();
ALC10.devices.remove(new Long(device.device));
}
return result;
}
static native boolean nalcCaptureCloseDevice(long device);
/**
* Once a capture device has been opened via alcCaptureOpenDevice, it is made to start
* recording audio via the alcCaptureStart entry point:
*
* Once started, the device will record audio to an internal ring buffer, the size of which was
* specified when opening the device.
* The application may query the capture device to discover how much data is currently
* available via the alcGetInteger with the ALC_CAPTURE_SAMPLES token. This will
* report the number of sample frames currently available.
*/
public static void alcCaptureStart(ALCdevice device) {
nalcCaptureStart(ALC10.getDevice(device));
}
static native void nalcCaptureStart(long device);
/**
* If the application doesn't need to capture more audio for an amount of time, they can halt
* the device without closing it via the alcCaptureStop entry point.
* The implementation is encouraged to optimize for this case. The amount of audio
* samples available after restarting a stopped capture device is reset to zero. The
* application does not need to stop the capture device to read from it.
*/
public static void alcCaptureStop(ALCdevice device) {
nalcCaptureStop(ALC10.getDevice(device));
}
static native void nalcCaptureStop(long device);
/**
* When the application feels there are enough samples available to process, it can obtain
* them from the AL via the alcCaptureSamples entry point.
*
* The "buffer" argument specifies an application-allocated buffer that can contain at least
* "samples" sample frames. The implementation may defer conversion and resampling until
* this point. Requesting more sample frames than are currently available is an error.
*
* @param buffer Buffer to store samples in
* @param samples Number of samples to request
*/
public static void alcCaptureSamples(ALCdevice device, ByteBuffer buffer, int samples ) {
nalcCaptureSamples(ALC10.getDevice(device), buffer, buffer.position(), samples);
}
static native void nalcCaptureSamples(long device, ByteBuffer buffer, int position, int samples );
static native void initNativeStubs() throws LWJGLException;
/**
* Initializes ALC11, including any extensions
* @return true if initialization was successfull
*/
static boolean initialize() {
try {
IntBuffer ib = BufferUtils.createIntBuffer(2);
ALC10.alcGetInteger(AL.getDevice(), ALC10.ALC_MAJOR_VERSION, ib);
ib.position(1);
ALC10.alcGetInteger(AL.getDevice(), ALC10.ALC_MINOR_VERSION, ib);
int major = ib.get(0);
int minor = ib.get(1);
// checking for version 1.x+
if(major >= 1) {
// checking for version 1.1+
if(major > 1 || minor >= 1) {
ALC11.initNativeStubs();
AL11.initNativeStubs();
}
}
} catch (LWJGLException le) {
LWJGLUtil.log("failed to initialize ALC11: " + le);
return false;
}
return true;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/openal/AL.java 0000644 0001750 0001750 00000017361 11543426510 017764 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.openal;
import org.lwjgl.LWJGLException;
import org.lwjgl.LWJGLUtil;
import org.lwjgl.Sys;
/**
*
* The AL class implements the actual creation code for linking to the native library
* OpenAL.
*
*
* @author Brian Matzon
* @version $Revision: 3418 $
* $Id: AL.java 3418 2010-09-28 21:11:35Z spasi $
*/
public final class AL {
/** ALCdevice instance. */
static ALCdevice device;
/** Current ALCcontext. */
static ALCcontext context;
/** Have we been created? */
private static boolean created;
static {
Sys.initialize();
}
private AL() {
}
/**
* Native method to create AL instance
*
* @param oalPath Path to search for OpenAL library
*/
private static native void nCreate(String oalPath) throws LWJGLException;
/**
* Native method to create AL instance from the Mac OS X 10.4 OpenAL framework.
* It is only defined in the Mac OS X native library.
*/
private static native void nCreateDefault() throws LWJGLException;
/**
* Native method the destroy the AL
*/
private static native void nDestroy();
/**
* @return true if AL has been created
*/
public static boolean isCreated() {
return created;
}
/**
* Creates an OpenAL instance. Using this constructor will cause OpenAL to
* open the device using supplied device argument, and create a context using the context values
* supplied.
*
* @param deviceArguments Arguments supplied to native device
* @param contextFrequency Frequency for mixing output buffer, in units of Hz (Common values include 11025, 22050, and 44100).
* @param contextRefresh Refresh intervalls, in units of Hz.
* @param contextSynchronized Flag, indicating a synchronous context.*
*/
public static void create(String deviceArguments, int contextFrequency, int contextRefresh, boolean contextSynchronized)
throws LWJGLException {
create(deviceArguments, contextFrequency, contextRefresh, contextSynchronized, true);
}
/**
* @param openDevice Whether to automatically open the device
* @see #create(String, int, int, boolean)
*/
public static void create(String deviceArguments, int contextFrequency, int contextRefresh, boolean contextSynchronized, boolean openDevice)
throws LWJGLException {
if (created)
throw new IllegalStateException("Only one OpenAL context may be instantiated at any one time.");
String libname;
String[] library_names;
switch (LWJGLUtil.getPlatform()) {
case LWJGLUtil.PLATFORM_WINDOWS:
libname = "OpenAL32";
library_names = new String[]{"OpenAL64.dll", "OpenAL32.dll"};
break;
case LWJGLUtil.PLATFORM_LINUX:
libname = "openal";
library_names = new String[]{"libopenal64.so", "libopenal.so", "libopenal.so.0"};
break;
case LWJGLUtil.PLATFORM_MACOSX:
libname = "openal";
library_names = new String[]{"openal.dylib"};
break;
default:
throw new LWJGLException("Unknown platform: " + LWJGLUtil.getPlatform());
}
String[] oalPaths = LWJGLUtil.getLibraryPaths(libname, library_names, AL.class.getClassLoader());
LWJGLUtil.log("Found " + oalPaths.length + " OpenAL paths");
for ( String oalPath : oalPaths ) {
try {
nCreate(oalPath);
created = true;
init(deviceArguments, contextFrequency, contextRefresh, contextSynchronized, openDevice);
break;
} catch (LWJGLException e) {
LWJGLUtil.log("Failed to load " + oalPath + ": " + e.getMessage());
}
}
if (!created && LWJGLUtil.getPlatform() == LWJGLUtil.PLATFORM_MACOSX) {
// Try to load OpenAL from the framework instead
nCreateDefault();
created = true;
init(deviceArguments, contextFrequency, contextRefresh, contextSynchronized, openDevice);
}
if (!created)
throw new LWJGLException("Could not locate OpenAL library.");
}
private static void init(String deviceArguments, int contextFrequency, int contextRefresh, boolean contextSynchronized, boolean openDevice) throws LWJGLException {
try {
AL10.initNativeStubs();
ALC10.initNativeStubs();
if(openDevice) {
device = ALC10.alcOpenDevice(deviceArguments);
if (device == null) {
throw new LWJGLException("Could not open ALC device");
}
if (contextFrequency == -1) {
context = ALC10.alcCreateContext(device, null);
} else {
context = ALC10.alcCreateContext(device,
ALCcontext.createAttributeList(contextFrequency, contextRefresh,
contextSynchronized ? ALC10.ALC_TRUE : ALC10.ALC_FALSE));
}
ALC10.alcMakeContextCurrent(context);
}
} catch (LWJGLException e) {
destroy();
throw e;
}
ALC11.initialize();
// Load EFX10 native stubs if ALC_EXT_EFX is supported.
// Is there any situation where the current device supports ALC_EXT_EFX and one
// later created by the user does not?
// Do we have to call resetNativeStubs(EFX10.class); somewhere? Not done for AL11
// either.
// This can either be here or in ALC11, since ALC_EXT_EFX indirectly requires AL 1.1
// for functions like alSource3i.
if (ALC10.alcIsExtensionPresent(device, EFX10.ALC_EXT_EFX_NAME)){
EFX10.initNativeStubs();
}
}
/**
* Creates an OpenAL instance. The empty create will cause OpenAL to
* open the default device, and create a context using default values.
* This method used to use default values that the OpenAL implementation
* chose but this produces unexpected results on some systems; so now
* it defaults to 44100Hz mixing @ 60Hz refresh.
*/
public static void create() throws LWJGLException {
create(null, 44100, 60, false);
}
/**
* Exit cleanly by calling destroy.
*/
public static void destroy() {
if (context != null) {
ALC10.alcMakeContextCurrent(null);
ALC10.alcDestroyContext(context);
context = null;
}
if (device != null) {
boolean result = ALC10.alcCloseDevice(device);
device = null;
}
resetNativeStubs(AL10.class);
resetNativeStubs(AL11.class);
resetNativeStubs(ALC10.class);
resetNativeStubs(ALC11.class);
resetNativeStubs(EFX10.class);
if (created)
nDestroy();
created = false;
}
private static native void resetNativeStubs(Class clazz);
/**
* @return handle to the default AL context.
*/
public static ALCcontext getContext() {
return context;
}
/**
* @return handle to the default AL device.
*/
public static ALCdevice getDevice() {
return device;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/openal/ALCdevice.java 0000644 0001750 0001750 00000007471 11543426510 021250 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.openal;
import java.util.HashMap;
import java.util.Iterator;
/**
* The ALCdevice class represents a device opened in OpenAL space.
*
* ALC introduces the notion of a Device. A Device can be, depending on the
* implementation, a hardware device, or a daemon/OS service/actual server. This
* mechanism also permits different drivers (and hardware) to coexist within the same
* system, as well as allowing several applications to share system resources for audio,
* including a single hardware output device. The details are left to the implementation,
* which has to map the available backends to unique device specifiers.
*
* @author Brian Matzon
* @version $Revision: 3418 $
* $Id: ALCdevice.java 3418 2010-09-28 21:11:35Z spasi $
*/
public final class ALCdevice {
/** Address of actual device */
final long device;
/** Whether this device is valid */
private boolean valid;
/** List of contexts belonging to the device */
private final HashMap contexts = new HashMap();
/**
* Creates a new instance of ALCdevice
*
* @param device address of actual device
*/
ALCdevice(long device) {
this.device = device;
this.valid = true;
}
/*
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object device) {
if(device instanceof ALCdevice) {
return ((ALCdevice)device).device == this.device;
}
return super.equals(device);
}
/**
* Adds a context to the device
*
* @param context context to add to the list of contexts for this device
*/
void addContext(ALCcontext context) {
synchronized (contexts) {
contexts.put(context.context, context);
}
}
/**
* Remove context associated with device
*
* @param context Context to disassociate with device
*/
void removeContext(ALCcontext context) {
synchronized (contexts) {
contexts.remove(context.context);
}
}
/**
* Marks this device and all of its contexts invalid
*/
void setInvalid() {
valid = false;
synchronized (contexts) {
for ( ALCcontext context : contexts.values() )
context.setInvalid();
}
contexts.clear();
}
/**
* @return true if this device is still valid
*/
public boolean isValid() {
return valid;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/openal/OpenALException.java 0000644 0001750 0001750 00000005165 11543426510 022464 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.openal;
/**
*
* Thrown by the debug build library of the LWJGL if any OpenAL operation
* causes an error.
*
* @author Brian Matzon
* @version $Revision: 2983 $
* $Id: OpenALException.java 2983 2008-04-07 18:36:09Z matzon $
*/
public class OpenALException extends RuntimeException {
private static final long serialVersionUID = 1L;
/**
* Constructor for OpenALException.
*/
public OpenALException() {
super();
}
/**
* Constructor that takes an AL error number
*/
public OpenALException(int error_code) {
super("OpenAL error: " + AL10.alGetString(error_code) + " (" + error_code + ")");
}
/**
* Constructor for OpenALException.
* @param message
*/
public OpenALException(String message) {
super(message);
}
/**
* Constructor for OpenALException.
* @param message
* @param cause
*/
public OpenALException(String message, Throwable cause) {
super(message, cause);
}
/**
* Constructor for OpenALException.
* @param cause
*/
public OpenALException(Throwable cause) {
super(cause);
}
}
lwjgl-2.7.1/src/java/org/lwjgl/openal/ALCcontext.java 0000644 0001750 0001750 00000007300 11543426510 021464 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.openal;
import java.nio.IntBuffer;
import org.lwjgl.BufferUtils;
/**
* The ALCcontext class represents a context opened in OpenAL space.
*
* All operations of the AL core API affect a current AL context. Within the scope of AL,
* the ALC is implied - it is not visible as a handle or function parameter. Only one AL
* Context per process can be current at a time. Applications maintaining multiple AL
* Contexts, whether threaded or not, have to set the current context accordingly.
* Applications can have multiple threads that share one more or contexts. In other words,
* AL and ALC are threadsafe.
*
* @author Brian Matzon
* @version $Revision: 3418 $
* $Id: ALCcontext.java 3418 2010-09-28 21:11:35Z spasi $
*/
public final class ALCcontext {
/** Address of actual context */
final long context;
/** Whether this context is valid */
private boolean valid;
/**
* Creates a new instance of ALCcontext
*
* @param context address of actual context
*/
ALCcontext(long context) {
this.context = context;
this.valid = true;
}
/*
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object context) {
if(context instanceof ALCcontext) {
return ((ALCcontext)context).context == this.context;
}
return super.equals(context);
}
/**
* Creates an attribute list in a ByteBuffer
* @param contextFrequency Frequency to add
* @param contextRefresh Refresh rate to add
* @param contextSynchronized Whether to synchronize the context
* @return
*/
static IntBuffer createAttributeList(int contextFrequency, int contextRefresh, int contextSynchronized) {
IntBuffer attribList = BufferUtils.createIntBuffer(7);
attribList.put(ALC10.ALC_FREQUENCY);
attribList.put(contextFrequency);
attribList.put(ALC10.ALC_REFRESH);
attribList.put(contextRefresh);
attribList.put(ALC10.ALC_SYNC);
attribList.put(contextSynchronized);
attribList.put(0); //terminating int
return attribList;
}
/**
* Marks this context as invalid
*
*/
void setInvalid() {
valid = false;
}
/**
* @return true if this context is still valid
*/
public boolean isValid() {
return valid;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/openal/ALC10.java 0000644 0001750 0001750 00000041230 11543426510 020220 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.openal;
import java.nio.Buffer;
import java.nio.IntBuffer;
import java.util.HashMap;
import org.lwjgl.BufferChecks;
import org.lwjgl.LWJGLException;
/**
*
*
* ALC introduces the notion of a Device. A Device can be, depending on the
* implementation, a hardware device, or a daemon/OS service/actual server. This
* mechanism also permits different drivers (and hardware) to coexist within the same
* system, as well as allowing several applications to share system resources for audio,
* including a single hardware output device. The details are left to the
* implementation, which has to map the available backends to unique device
* specifiers (represented as strings).
*
*
* @author Brian Matzon
* @version $Revision: 2286 $
* $Id: ALC.java 2286 2006-03-23 19:32:21 +0000 (to, 23 mar 2006) matzon $
*/
public final class ALC10 {
/** List of active contexts */
static final HashMap contexts = new HashMap();
/** List of active devices */
static final HashMap devices = new HashMap();
/** Bad value */
public static final int ALC_INVALID = 0;
/** Boolean False */
public static final int ALC_FALSE = 0;
/** Boolean True */
public static final int ALC_TRUE = 1;
/** Errors: No Error */
public static final int ALC_NO_ERROR = ALC_FALSE;
/** Major version query. */
public static final int ALC_MAJOR_VERSION = 0x1000;
/** Minor version query. */
public static final int ALC_MINOR_VERSION = 0x1001;
/**
* The size required for the zero-terminated attributes list, for the current context.
**/
public static final int ALC_ATTRIBUTES_SIZE = 0x1002;
/**
* Expects a destination of ALC_CURRENT_ATTRIBUTES_SIZE,
* and provides the attribute list for the current context of the specified device.
*/
public static final int ALC_ALL_ATTRIBUTES = 0x1003;
/** The specifier string for the default device */
public static final int ALC_DEFAULT_DEVICE_SPECIFIER = 0x1004;
/** The specifier string for the device */
public static final int ALC_DEVICE_SPECIFIER = 0x1005;
/** The extensions string for diagnostics and printing */
public static final int ALC_EXTENSIONS = 0x1006;
/** Frequency for mixing output buffer, in units of Hz. */
public static final int ALC_FREQUENCY = 0x1007;
/** Refresh intervalls, in units of Hz. */
public static final int ALC_REFRESH = 0x1008;
/** Flag, indicating a synchronous context. */
public static final int ALC_SYNC = 0x1009;
/** The device argument does not name a valid device */
public static final int ALC_INVALID_DEVICE = 0xA001;
/** The context argument does not name a valid context */
public static final int ALC_INVALID_CONTEXT = 0xA002;
/**
* A function was called at inappropriate time, or in an inappropriate way,
* causing an illegal state. This can be an incompatible ALenum, object ID,
* and/or function.
*/
public static final int ALC_INVALID_ENUM = 0xA003;
/**
* Illegal value passed as an argument to an AL call.
* Applies to parameter values, but not to enumerations.
*/
public static final int ALC_INVALID_VALUE = 0xA004;
/**
* A function could not be completed, because there is not enough
* memory available.
*/
public static final int ALC_OUT_OF_MEMORY = 0xA005;
static native void initNativeStubs() throws LWJGLException;
/**
* The application can obtain certain strings from ALC.
*
* ALC_DEFAULT_DEVICE_SPECIFIER - The specifer string for the default device
* ALC_DEVICE_SPECIFIER - The specifer string for the device
* ALC_EXTENSIONS - The extensions string for diagnostics and printing.
*
* In addition, printable error message strings are provided for all valid error tokens,
* including ALC_NO_ERROR,ALC_INVALID_DEVICE, ALC_INVALID_CONTEXT,
* ALC_INVALID_ENUM, ALC_INVALID_VALUE.
*
* @param pname Property to get
* @return String property from device
*/
public static String alcGetString(ALCdevice device, int pname) {
String result;
result = nalcGetString(getDevice(device), pname);
Util.checkALCError(device);
return result;
}
static native String nalcGetString(long device, int pname);
/**
* The application can query ALC for information using an integer query function.
* For some tokens, null is a legal deviceHandle. In other cases, specifying a null
* device will generate an ALC_INVALID_DEVICE error. The application has to
* specify the size of the destination buffer provided. A null destination or a zero
* size parameter will cause ALC to ignore the query.
*
* ALC_MAJOR_VERSION - Major version query.
* ALC_MINOR_VERSION - Minor version query.
* ALC_ATTRIBUTES_SIZE - The size required for the zero-terminated attributes list,
* for the current context. null is an invalid device. null (no current context
* for the specified device) is legal.
* ALC_ALL_ATTRIBUTES - Expects a destination of ALC_CURRENT_ATTRIBUTES_SIZE,
* and provides the attribute list for the current context of the specified device.
* null is an invalid device. null (no current context for the specified device)
* will return the default attributes defined by the specified device.
*
* @param pname Property to get
* @param integerdata ByteBuffer to write integers to
*/
public static void alcGetInteger(ALCdevice device, int pname, IntBuffer integerdata) {
BufferChecks.checkDirect(integerdata);
nalcGetIntegerv(getDevice(device), pname, integerdata.remaining(), integerdata, integerdata.position());
Util.checkALCError(device);
}
static native void nalcGetIntegerv(long device, int pname, int size, Buffer integerdata, int offset);
/**
* The alcOpenDevice function allows the application (i.e. the client program) to
* connect to a device (i.e. the server).
*
* If the function returns null, then no sound driver/device has been found. The
* argument is a null terminated string that requests a certain device or device
* configuration. If null is specified, the implementation will provide an
* implementation specific default.
*
* @param devicename name of device to open
* @return opened device, or null
*/
public static ALCdevice alcOpenDevice(String devicename) {
long device_address = nalcOpenDevice(devicename);
if(device_address != 0) {
ALCdevice device = new ALCdevice(device_address);
synchronized (ALC10.devices) {
devices.put(device_address, device);
}
return device;
}
return null;
}
static native long nalcOpenDevice(String devicename);
/**
* The alcCloseDevice function allows the application (i.e. the client program) to
* disconnect from a device (i.e. the server).
*
* If deviceHandle is null or invalid, an ALC_INVALID_DEVICE error will be
* generated. Once closed, a deviceHandle is invalid.
*
* @param device address of native device to close
*/
public static boolean alcCloseDevice(ALCdevice device) {
boolean result = nalcCloseDevice(getDevice(device));
synchronized (devices) {
device.setInvalid();
devices.remove(new Long(device.device));
}
return result;
}
static native boolean nalcCloseDevice(long device);
/**
* A context is created using alcCreateContext. The device parameter has to be a valid
* device. The attribute list can be null, or a zero terminated list of integer pairs
* composed of valid ALC attribute tokens and requested values.
*
* Context creation will fail if the application requests attributes that, by themselves,
* can not be provided. Context creation will fail if the combination of specified
* attributes can not be provided. Context creation will fail if a specified attribute, or
* the combination of attributes, does not match the default values for unspecified
* attributes.
*
* @param device address of device to associate context to
* @param attrList Buffer to read attributes from
* @return New context, or null if creation failed
*/
public static ALCcontext alcCreateContext(ALCdevice device, IntBuffer attrList) {
long context_address = nalcCreateContext(getDevice(device), attrList);
Util.checkALCError(device);
if(context_address != 0) {
ALCcontext context = new ALCcontext(context_address);
synchronized (ALC10.contexts) {
contexts.put(context_address, context);
device.addContext(context);
}
return context;
}
return null;
}
static native long nalcCreateContext(long device, IntBuffer attrList);
/**
* To make a Context current with respect to AL Operation (state changes by issueing
* commands), alcMakeContextCurrent is used. The context parameter can be null
* or a valid context pointer. The operation will apply to the device that the context
* was created for.
*
* For each OS process (usually this means for each application), only one context can
* be current at any given time. All AL commands apply to the current context.
* Commands that affect objects shared among contexts (e.g. buffers) have side effects
* on other contexts.
*
* @param context address of context to make current
* @return true if successfull, false if not
*/
public static int alcMakeContextCurrent(ALCcontext context) {
return nalcMakeContextCurrent(getContext(context));
}
static native int nalcMakeContextCurrent(long context);
/**
* The current context is the only context accessible to state changes by AL commands
* (aside from state changes affecting shared objects). However, multiple contexts can
* be processed at the same time. To indicate that a context should be processed (i.e.
* that internal execution state like offset increments are supposed to be performed),
* the application has to use alcProcessContext.
*
* Repeated calls to alcProcessContext are legal, and do not affect a context that is
* already marked as processing. The default state of a context created by
* alcCreateContext is that it is not marked as processing.
*/
public static void alcProcessContext(ALCcontext context) {
nalcProcessContext(getContext(context));
}
static native void nalcProcessContext(long context);
/**
* The application can query for, and obtain an handle to, the current context for the
* application. If there is no current context, null is returned.
*
* @return Current ALCcontext
*/
public static ALCcontext alcGetCurrentContext() {
ALCcontext context = null;
long context_address = nalcGetCurrentContext();
if(context_address != 0) {
synchronized (ALC10.contexts) {
context = ALC10.contexts.get(context_address);
}
}
return context;
}
static native long nalcGetCurrentContext();
/**
* The application can query for, and obtain an handle to, the device of a given context.
*
* @param context address of context to get device for
*/
public static ALCdevice alcGetContextsDevice(ALCcontext context) {
ALCdevice device = null;
long device_address = nalcGetContextsDevice(getContext(context));
if (device_address != 0) {
synchronized (ALC10.devices) {
device = ALC10.devices.get(device_address);
}
}
return device;
}
static native long nalcGetContextsDevice(long context);
/**
* The application can suspend any context from processing (including the current
* one). To indicate that a context should be suspended from processing (i.e. that
* internal execution state like offset increments is not supposed to be changed), the
* application has to use alcSuspendContext.
*
* Repeated calls to alcSuspendContext are legal, and do not affect a context that is
* already marked as suspended. The default state of a context created by
* alcCreateContext is that it is marked as suspended.
*
* @param context address of context to suspend
*/
public static void alcSuspendContext(ALCcontext context) {
nalcSuspendContext(getContext(context));
}
static native void nalcSuspendContext(long context);
/**
* The correct way to destroy a context is to first release it using alcMakeCurrent and
* null. Applications should not attempt to destroy a current context.
*
* @param context address of context to Destroy
*/
public static void alcDestroyContext(ALCcontext context) {
synchronized(ALC10.contexts) {
ALCdevice device = alcGetContextsDevice(context);
nalcDestroyContext(getContext(context));
device.removeContext(context);
context.setInvalid();
}
}
static native void nalcDestroyContext(long context);
/**
* ALC uses the same conventions and mechanisms as AL for error handling. In
* particular, ALC does not use conventions derived from X11 (GLX) or Windows
* (WGL). The alcGetError function can be used to query ALC errors.
*
* Error conditions are specific to the device.
*
* ALC_NO_ERROR - The device handle or specifier does name an accessible driver/server.
* ALC_INVALID_DEVICE - The Context argument does not name a valid context.
* ALC_INVALID_CONTEXT - The Context argument does not name a valid context.
* ALC_INVALID_ENUM - A token used is not valid, or not applicable.
* ALC_INVALID_VALUE - An value (e.g. attribute) is not valid, or not applicable.
*
* @return Errorcode from ALC statemachine
*/
public static int alcGetError(ALCdevice device) {
return nalcGetError(getDevice(device));
}
static native int nalcGetError(long device);
/**
* Verify that a given extension is available for the current context and the device it
* is associated with.
* A null name argument returns ALC_FALSE, as do invalid and unsupported string
* tokens.
*
* @param extName name of extension to find
* @return true if extension is available, false if not
*/
public static boolean alcIsExtensionPresent(ALCdevice device, String extName) {
boolean result = nalcIsExtensionPresent(getDevice(device), extName);
Util.checkALCError(device);
return result;
}
static native boolean nalcIsExtensionPresent(long device, String extName);
/**
* Enumeration/token values are device independend, but tokens defined for
* extensions might not be present for a given device. But only the tokens defined
* by the AL core are guaranteed. Availability of extension tokens dependends on the ALC extension.
*
* Specifying a null name parameter will cause an ALC_INVALID_VALUE error.
*
* @param enumName name of enum to find
* @return value of enumeration
*/
public static int alcGetEnumValue(ALCdevice device, String enumName) {
int result = nalcGetEnumValue(getDevice(device), enumName);
Util.checkALCError(device);
return result;
}
static native int nalcGetEnumValue(long device, String enumName);
static long getDevice(ALCdevice device) {
if(device != null) {
Util.checkALCValidDevice(device);
return device.device;
}
return 0L;
}
static long getContext(ALCcontext context) {
if(context != null) {
Util.checkALCValidContext(context);
return context.context;
}
return 0L;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/ 0000755 0001750 0001750 00000000000 11543426510 016314 5 ustar zero79 zero79 lwjgl-2.7.1/src/java/org/lwjgl/util/ReadableColor.java 0000644 0001750 0001750 00000007442 11543426510 021664 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util;
import java.nio.ByteBuffer;
/**
* Readonly interface for Colors
* @author $Author: spasi $
* @version $Revision: 3418 $
* $Id: ReadableColor.java 3418 2010-09-28 21:11:35Z spasi $
*/
public interface ReadableColor {
/**
* Return the red component (0..255)
* @return int
*/
int getRed();
/**
* Return the red component (0..255)
* @return int
*/
int getGreen();
/**
* Return the red component (0..255)
* @return int
*/
int getBlue();
/**
* Return the red component (0..255)
* @return int
*/
int getAlpha();
/**
* Return the red component
* @return int
*/
byte getRedByte();
/**
* Return the red component
* @return int
*/
byte getGreenByte();
/**
* Return the red component
* @return int
*/
byte getBlueByte();
/**
* Return the red component
* @return int
*/
byte getAlphaByte();
/**
* Write the RGBA color directly out to a ByteBuffer
* @param dest the buffer to write to
*/
void writeRGBA(ByteBuffer dest);
/**
* Write the RGB color directly out to a ByteBuffer
* @param dest the buffer to write to
*/
void writeRGB(ByteBuffer dest);
/**
* Write the ABGR color directly out to a ByteBuffer
* @param dest the buffer to write to
*/
void writeABGR(ByteBuffer dest);
/**
* Write the BGR color directly out to a ByteBuffer
* @param dest the buffer to write to
*/
void writeBGR(ByteBuffer dest);
/**
* Write the BGRA color directly out to a ByteBuffer
* @param dest the buffer to write to
*/
void writeBGRA(ByteBuffer dest);
/**
* Write the ARGB color directly out to a ByteBuffer
* @param dest the buffer to write to
*/
void writeARGB(ByteBuffer dest);
/*
* Some standard colors
*/
ReadableColor RED = new Color(255, 0, 0);
ReadableColor ORANGE = new Color(255, 128, 0);
ReadableColor YELLOW = new Color(255, 255, 0);
ReadableColor GREEN = new Color(0, 255, 0);
ReadableColor CYAN = new Color(0, 255, 255);
ReadableColor BLUE = new Color(0, 0, 255);
ReadableColor PURPLE = new Color(255, 0, 255);
ReadableColor WHITE = new Color(255, 255, 255);
ReadableColor BLACK = new Color(0, 0, 0);
ReadableColor LTGREY = new Color(192, 192, 192);
ReadableColor DKGREY = new Color(64, 64, 64);
ReadableColor GREY = new Color(128, 128, 128);
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/ 0000755 0001750 0001750 00000000000 11543426510 017103 5 ustar zero79 zero79 lwjgl-2.7.1/src/java/org/lwjgl/util/glu/Cylinder.java 0000644 0001750 0001750 00000014215 11543426510 021522 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.glu;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.util.glu.GLU.*;
/**
* Cylinder.java
*
*
* Created 23-dec-2003
* @author Erik Duijs
*/
public class Cylinder extends Quadric {
/**
* Constructor for Cylinder.
*/
public Cylinder() {
super();
}
/**
* draws a cylinder oriented along the z axis. The base of the
* cylinder is placed at z = 0, and the top at z=height. Like a sphere, a
* cylinder is subdivided around the z axis into slices, and along the z axis
* into stacks.
*
* Note that if topRadius is set to zero, then this routine will generate a
* cone.
*
* If the orientation is set to GLU.OUTSIDE (with glu.quadricOrientation), then
* any generated normals point away from the z axis. Otherwise, they point
* toward the z axis.
*
* If texturing is turned on (with glu.quadricTexture), then texture
* coordinates are generated so that t ranges linearly from 0.0 at z = 0 to
* 1.0 at z = height, and s ranges from 0.0 at the +y axis, to 0.25 at the +x
* axis, to 0.5 at the -y axis, to 0.75 at the -x axis, and back to 1.0 at the
* +y axis.
*
* @param baseRadius Specifies the radius of the cylinder at z = 0.
* @param topRadius Specifies the radius of the cylinder at z = height.
* @param height Specifies the height of the cylinder.
* @param slices Specifies the number of subdivisions around the z axis.
* @param stacks Specifies the number of subdivisions along the z axis.
*/
public void draw(float baseRadius, float topRadius, float height, int slices, int stacks) {
float da, r, dr, dz;
float x, y, z, nz, nsign;
int i, j;
if (super.orientation == GLU_INSIDE) {
nsign = -1.0f;
} else {
nsign = 1.0f;
}
da = 2.0f * PI / slices;
dr = (topRadius - baseRadius) / stacks;
dz = height / stacks;
nz = (baseRadius - topRadius) / height;
// Z component of normal vectors
if (super.drawStyle == GLU_POINT) {
glBegin(GL_POINTS);
for (i = 0; i < slices; i++) {
x = cos((i * da));
y = sin((i * da));
normal3f(x * nsign, y * nsign, nz * nsign);
z = 0.0f;
r = baseRadius;
for (j = 0; j <= stacks; j++) {
glVertex3f((x * r), (y * r), z);
z += dz;
r += dr;
}
}
glEnd();
} else if (super.drawStyle == GLU_LINE || super.drawStyle == GLU_SILHOUETTE) {
// Draw rings
if (super.drawStyle == GLU_LINE) {
z = 0.0f;
r = baseRadius;
for (j = 0; j <= stacks; j++) {
glBegin(GL_LINE_LOOP);
for (i = 0; i < slices; i++) {
x = cos((i * da));
y = sin((i * da));
normal3f(x * nsign, y * nsign, nz * nsign);
glVertex3f((x * r), (y * r), z);
}
glEnd();
z += dz;
r += dr;
}
} else {
// draw one ring at each end
if (baseRadius != 0.0) {
glBegin(GL_LINE_LOOP);
for (i = 0; i < slices; i++) {
x = cos((i * da));
y = sin((i * da));
normal3f(x * nsign, y * nsign, nz * nsign);
glVertex3f((x * baseRadius), (y * baseRadius), 0.0f);
}
glEnd();
glBegin(GL_LINE_LOOP);
for (i = 0; i < slices; i++) {
x = cos((i * da));
y = sin((i * da));
normal3f(x * nsign, y * nsign, nz * nsign);
glVertex3f((x * topRadius), (y * topRadius), height);
}
glEnd();
}
}
// draw length lines
glBegin(GL_LINES);
for (i = 0; i < slices; i++) {
x = cos((i * da));
y = sin((i * da));
normal3f(x * nsign, y * nsign, nz * nsign);
glVertex3f((x * baseRadius), (y * baseRadius), 0.0f);
glVertex3f((x * topRadius), (y * topRadius), (height));
}
glEnd();
} else if (super.drawStyle == GLU_FILL) {
float ds = 1.0f / slices;
float dt = 1.0f / stacks;
float t = 0.0f;
z = 0.0f;
r = baseRadius;
for (j = 0; j < stacks; j++) {
float s = 0.0f;
glBegin(GL_QUAD_STRIP);
for (i = 0; i <= slices; i++) {
if (i == slices) {
x = sin(0.0f);
y = cos(0.0f);
} else {
x = sin((i * da));
y = cos((i * da));
}
if (nsign == 1.0f) {
normal3f((x * nsign), (y * nsign), (nz * nsign));
TXTR_COORD(s, t);
glVertex3f((x * r), (y * r), z);
normal3f((x * nsign), (y * nsign), (nz * nsign));
TXTR_COORD(s, t + dt);
glVertex3f((x * (r + dr)), (y * (r + dr)), (z + dz));
} else {
normal3f(x * nsign, y * nsign, nz * nsign);
TXTR_COORD(s, t);
glVertex3f((x * r), (y * r), z);
normal3f(x * nsign, y * nsign, nz * nsign);
TXTR_COORD(s, t + dt);
glVertex3f((x * (r + dr)), (y * (r + dr)), (z + dz));
}
s += ds;
} // for slices
glEnd();
r += dr;
t += dt;
z += dz;
} // for stacks
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/Util.java 0000644 0001750 0001750 00000011650 11543426510 020666 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.glu;
import java.nio.IntBuffer;
import org.lwjgl.BufferUtils;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL12.*;
/**
* Util.java
*
*
* Created 7-jan-2004
*
* @author Erik Duijs
*/
public class Util {
/**
* temp IntBuffer of one for getting an int from some GL functions
*/
private static IntBuffer scratch = BufferUtils.createIntBuffer(16);
/**
* Return ceiling of integer division
*
* @param a
* @param b
*
* @return int
*/
protected static int ceil(int a, int b) {
return (a % b == 0 ? a / b : a / b + 1);
}
/**
* Normalize vector
*
* @param v
*
* @return float[]
*/
protected static float[] normalize(float[] v) {
float r;
r = (float)Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
if ( r == 0.0 )
return v;
r = 1.0f / r;
v[0] *= r;
v[1] *= r;
v[2] *= r;
return v;
}
/**
* Calculate cross-product
*
* @param v1
* @param v2
* @param result
*/
protected static void cross(float[] v1, float[] v2, float[] result) {
result[0] = v1[1] * v2[2] - v1[2] * v2[1];
result[1] = v1[2] * v2[0] - v1[0] * v2[2];
result[2] = v1[0] * v2[1] - v1[1] * v2[0];
}
/**
* Method compPerPix.
*
* @param format
*
* @return int
*/
protected static int compPerPix(int format) {
/* Determine number of components per pixel */
switch ( format ) {
case GL_COLOR_INDEX:
case GL_STENCIL_INDEX:
case GL_DEPTH_COMPONENT:
case GL_RED:
case GL_GREEN:
case GL_BLUE:
case GL_ALPHA:
case GL_LUMINANCE:
return 1;
case GL_LUMINANCE_ALPHA:
return 2;
case GL_RGB:
case GL_BGR:
return 3;
case GL_RGBA:
case GL_BGRA:
return 4;
default :
return -1;
}
}
/**
* Method nearestPower.
*
* Compute the nearest power of 2 number. This algorithm is a little strange, but it works quite well.
*
* @param value
*
* @return int
*/
protected static int nearestPower(int value) {
int i;
i = 1;
/* Error! */
if ( value == 0 )
return -1;
for ( ; ; ) {
if ( value == 1 ) {
return i;
} else if ( value == 3 ) {
return i << 2;
}
value >>= 1;
i <<= 1;
}
}
/**
* Method bytesPerPixel.
*
* @param format
* @param type
*
* @return int
*/
protected static int bytesPerPixel(int format, int type) {
int n, m;
switch ( format ) {
case GL_COLOR_INDEX:
case GL_STENCIL_INDEX:
case GL_DEPTH_COMPONENT:
case GL_RED:
case GL_GREEN:
case GL_BLUE:
case GL_ALPHA:
case GL_LUMINANCE:
n = 1;
break;
case GL_LUMINANCE_ALPHA:
n = 2;
break;
case GL_RGB:
case GL_BGR:
n = 3;
break;
case GL_RGBA:
case GL_BGRA:
n = 4;
break;
default :
n = 0;
}
switch ( type ) {
case GL_UNSIGNED_BYTE:
m = 1;
break;
case GL_BYTE:
m = 1;
break;
case GL_BITMAP:
m = 1;
break;
case GL_UNSIGNED_SHORT:
m = 2;
break;
case GL_SHORT:
m = 2;
break;
case GL_UNSIGNED_INT:
m = 4;
break;
case GL_INT:
m = 4;
break;
case GL_FLOAT:
m = 4;
break;
default :
m = 0;
}
return n * m;
}
/**
* Convenience method for returning an int, rather than getting it out of a buffer yourself.
*
* @param what
*
* @return int
*/
protected static int glGetIntegerv(int what) {
scratch.rewind();
glGetInteger(what, scratch);
return scratch.get();
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/Registry.java 0000644 0001750 0001750 00000005325 11543426510 021563 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.glu;
import static org.lwjgl.util.glu.GLU.*;
/**
* Registry.java
*
*
* Created 11-jan-2004
* @author Erik Duijs
*/
public class Registry extends Util {
private static final String versionString = "1.3";
private static final String extensionString =
"GLU_EXT_nurbs_tessellator " + "GLU_EXT_object_space_tess ";
/**
* Method gluGetString
* @param name
* @return String
*/
public static String gluGetString(int name) {
if (name == GLU_VERSION) {
return versionString;
} else if (name == GLU_EXTENSIONS) {
return extensionString;
}
return null;
}
/**
* Method gluCheckExtension
*
* @param extName is an extension name.
* @param extString is a string of extensions separated by blank(s). There may or
* may not be leading or trailing blank(s) in extString.
* This works in cases of extensions being prefixes of another like
* GL_EXT_texture and GL_EXT_texture3D.
* @return boolean true if extName is found otherwise it returns false.
*/
public static boolean gluCheckExtension(String extName, String extString) {
if (extString == null || extName == null)
return false;
return extString.indexOf(extName) != -1;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/Disk.java 0000644 0001750 0001750 00000013755 11543426510 020653 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.glu;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.util.glu.GLU.*;
/**
* Disk.java
*
*
* Created 23-dec-2003
* @author Erik Duijs
*/
public class Disk extends Quadric {
/**
* Constructor for Disk.
*/
public Disk() {
super();
}
/**
* renders a disk on the z = 0 plane. The disk has a radius of
* outerRadius, and contains a concentric circular hole with a radius of
* innerRadius. If innerRadius is 0, then no hole is generated. The disk is
* subdivided around the z axis into slices (like pizza slices), and also
* about the z axis into rings (as specified by slices and loops,
* respectively).
*
* With respect to orientation, the +z side of the disk is considered to be
* "outside" (see glu.quadricOrientation). This means that if the orientation
* is set to GLU.OUTSIDE, then any normals generated point along the +z axis.
* Otherwise, they point along the -z axis.
*
* If texturing is turned on (with glu.quadricTexture), texture coordinates are
* generated linearly such that where r=outerRadius, the value at (r, 0, 0) is
* (1, 0.5), at (0, r, 0) it is (0.5, 1), at (-r, 0, 0) it is (0, 0.5), and at
* (0, -r, 0) it is (0.5, 0).
*/
public void draw(float innerRadius, float outerRadius, int slices, int loops)
{
float da, dr;
/* Normal vectors */
if (super.normals != GLU_NONE) {
if (super.orientation == GLU_OUTSIDE) {
glNormal3f(0.0f, 0.0f, +1.0f);
}
else {
glNormal3f(0.0f, 0.0f, -1.0f);
}
}
da = 2.0f * PI / slices;
dr = (outerRadius - innerRadius) / loops;
switch (super.drawStyle) {
case GLU_FILL:
{
/* texture of a gluDisk is a cut out of the texture unit square
* x, y in [-outerRadius, +outerRadius]; s, t in [0, 1]
* (linear mapping)
*/
float dtc = 2.0f * outerRadius;
float sa, ca;
float r1 = innerRadius;
int l;
for (l = 0; l < loops; l++) {
float r2 = r1 + dr;
if (super.orientation == GLU_OUTSIDE) {
int s;
glBegin(GL_QUAD_STRIP);
for (s = 0; s <= slices; s++) {
float a;
if (s == slices)
a = 0.0f;
else
a = s * da;
sa = sin(a);
ca = cos(a);
TXTR_COORD(0.5f + sa * r2 / dtc, 0.5f + ca * r2 / dtc);
glVertex2f(r2 * sa, r2 * ca);
TXTR_COORD(0.5f + sa * r1 / dtc, 0.5f + ca * r1 / dtc);
glVertex2f(r1 * sa, r1 * ca);
}
glEnd();
}
else {
int s;
glBegin(GL_QUAD_STRIP);
for (s = slices; s >= 0; s--) {
float a;
if (s == slices)
a = 0.0f;
else
a = s * da;
sa = sin(a);
ca = cos(a);
TXTR_COORD(0.5f - sa * r2 / dtc, 0.5f + ca * r2 / dtc);
glVertex2f(r2 * sa, r2 * ca);
TXTR_COORD(0.5f - sa * r1 / dtc, 0.5f + ca * r1 / dtc);
glVertex2f(r1 * sa, r1 * ca);
}
glEnd();
}
r1 = r2;
}
break;
}
case GLU_LINE:
{
int l, s;
/* draw loops */
for (l = 0; l <= loops; l++) {
float r = innerRadius + l * dr;
glBegin(GL_LINE_LOOP);
for (s = 0; s < slices; s++) {
float a = s * da;
glVertex2f(r * sin(a), r * cos(a));
}
glEnd();
}
/* draw spokes */
for (s = 0; s < slices; s++) {
float a = s * da;
float x = sin(a);
float y = cos(a);
glBegin(GL_LINE_STRIP);
for (l = 0; l <= loops; l++) {
float r = innerRadius + l * dr;
glVertex2f(r * x, r * y);
}
glEnd();
}
break;
}
case GLU_POINT:
{
int s;
glBegin(GL_POINTS);
for (s = 0; s < slices; s++) {
float a = s * da;
float x = sin(a);
float y = cos(a);
int l;
for (l = 0; l <= loops; l++) {
float r = innerRadius * l * dr;
glVertex2f(r * x, r * y);
}
}
glEnd();
break;
}
case GLU_SILHOUETTE:
{
if (innerRadius != 0.0) {
float a;
glBegin(GL_LINE_LOOP);
for (a = 0.0f; a < 2.0 * PI; a += da) {
float x = innerRadius * sin(a);
float y = innerRadius * cos(a);
glVertex2f(x, y);
}
glEnd();
}
{
float a;
glBegin(GL_LINE_LOOP);
for (a = 0; a < 2.0f * PI; a += da) {
float x = outerRadius * sin(a);
float y = outerRadius * cos(a);
glVertex2f(x, y);
}
glEnd();
}
break;
}
default:
return;
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/GLUtessellatorCallback.java 0000644 0001750 0001750 00000040241 11543426510 024275 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu;
/**
* GLUtessellatorCallback interface provides methods that the user will
* override to define the callbacks for a tessellation object.
*
* @author Eric Veach, July 1994
* @author Java Port: Pepijn Van Eeckhoudt, July 2003
* @author Java Port: Nathan Parker Burg, August 2003
*/
public interface GLUtessellatorCallback {
/**
* The begin callback method is invoked like
* {@link javax.media.opengl.GL#glBegin glBegin} to indicate the start of a
* (triangle) primitive. The method takes a single argument of type int. If
* the GLU_TESS_BOUNDARY_ONLY property is set to GL_FALSE, then
* the argument is set to either GL_TRIANGLE_FAN,
* GL_TRIANGLE_STRIP, or GL_TRIANGLES. If the
* GLU_TESS_BOUNDARY_ONLY property is set to GL_TRUE, then the
* argument will be set to GL_LINE_LOOP.
*
* @param type
* Specifics the type of begin/end pair being defined. The following
* values are valid: GL_TRIANGLE_FAN, GL_TRIANGLE_STRIP,
* GL_TRIANGLES or GL_LINE_LOOP.
*
* @see GLU#gluTessCallback gluTessCallback
* @see #end end
* @see #begin begin
*/
void begin(int type);
/**
* The same as the {@link #begin begin} callback method except that
* it takes an additional reference argument. This reference is
* identical to the opaque reference provided when {@link
* GLU#gluTessBeginPolygon gluTessBeginPolygon} was called.
*
* @param type
* Specifics the type of begin/end pair being defined. The following
* values are valid: GL_TRIANGLE_FAN, GL_TRIANGLE_STRIP,
* GL_TRIANGLES or GL_LINE_LOOP.
* @param polygonData
* Specifics a reference to user-defined data.
*
* @see GLU#gluTessCallback gluTessCallback
* @see #endData endData
* @see #begin begin
*/
void beginData(int type, Object polygonData);
/**
* The edgeFlag callback method is similar to
* {@link javax.media.opengl.GL#glEdgeFlag glEdgeFlag}. The method takes
* a single boolean boundaryEdge that indicates which edges lie on the
* polygon boundary. If the boundaryEdge is GL_TRUE, then each vertex
* that follows begins an edge that lies on the polygon boundary, that is,
* an edge that separates an interior region from an exterior one. If the
* boundaryEdge is GL_FALSE, then each vertex that follows begins an
* edge that lies in the polygon interior. The edge flag callback (if
* defined) is invoked before the first vertex callback.
*
* Since triangle fans and triangle strips do not support edge flags, the
* begin callback is not called with GL_TRIANGLE_FAN or
* GL_TRIANGLE_STRIP if a non-null edge flag callback is provided.
* (If the callback is initialized to null, there is no impact on
* performance). Instead, the fans and strips are converted to independent
* triangles.
*
* @param boundaryEdge
* Specifics which edges lie on the polygon boundary.
*
* @see GLU#gluTessCallback gluTessCallback
* @see #edgeFlagData edgeFlagData
*/
void edgeFlag(boolean boundaryEdge);
/**
* The same as the {@link #edgeFlag edgeFlage} callback method
* except that it takes an additional reference argument. This
* reference is identical to the opaque reference provided when
* {@link GLU#gluTessBeginPolygon gluTessBeginPolygon} was called.
*
* @param boundaryEdge
* Specifics which edges lie on the polygon boundary.
* @param polygonData
* Specifics a reference to user-defined data.
*
* @see GLU#gluTessCallback gluTessCallback
* @see #edgeFlag edgeFlag
*/
void edgeFlagData(boolean boundaryEdge, Object polygonData);
/**
* The vertex callback method is invoked between the {@link
* #begin begin} and {@link #end end} callback methods. It is
* similar to {@link javax.media.opengl.GL#glVertex3f glVertex3f},
* and it defines the vertices of the triangles created by the
* tessellation process. The method takes a reference as its only
* argument. This reference is identical to the opaque reference
* provided by the user when the vertex was described (see {@link
* GLU#gluTessVertex gluTessVertex}).
*
* @param vertexData
* Specifics a reference to the vertices of the triangles created
* byt the tessellatin process.
*
* @see GLU#gluTessCallback gluTessCallback
* @see #vertexData vertexData
*/
void vertex(Object vertexData);
/**
* The same as the {@link #vertex vertex} callback method except
* that it takes an additional reference argument. This reference is
* identical to the opaque reference provided when {@link
* GLU#gluTessBeginPolygon gluTessBeginPolygon} was called.
*
* @param vertexData
* Specifics a reference to the vertices of the triangles created
* byt the tessellatin process.
* @param polygonData
* Specifics a reference to user-defined data.
*
* @see GLU#gluTessCallback gluTessCallback
* @see #vertex vertex
*/
void vertexData(Object vertexData, Object polygonData);
/**
* The end callback serves the same purpose as
* {@link javax.media.opengl.GL#glEnd glEnd}. It indicates the end of a
* primitive and it takes no arguments.
*
* @see GLU#gluTessCallback gluTessCallback
* @see #begin begin
* @see #endData endData
*/
void end();
/**
* The same as the {@link #end end} callback method except that it
* takes an additional reference argument. This reference is
* identical to the opaque reference provided when {@link
* GLU#gluTessBeginPolygon gluTessBeginPolygon} was called.
*
* @param polygonData
* Specifics a reference to user-defined data.
*
* @see GLU#gluTessCallback gluTessCallback
* @see #beginData beginData
* @see #end end
*/
void endData(Object polygonData);
/**
* The combine callback method is called to create a new vertex when
* the tessellation detects an intersection, or wishes to merge features. The
* method takes four arguments: an array of three elements each of type
* double, an array of four references, an array of four elements each of
* type float, and a reference to a reference.
*
* The vertex is defined as a linear combination of up to four existing
* vertices, stored in data. The coefficients of the linear combination
* are given by weight; these weights always add up to 1. All vertex
* pointers are valid even when some of the weights are 0. coords gives
* the location of the new vertex.
*
* The user must allocate another vertex, interpolate parameters using
* data and weight, and return the new vertex pointer in
* outData. This handle is supplied during rendering callbacks. The
* user is responsible for freeing the memory some time after
* {@link GLU#gluTessEndPolygon gluTessEndPolygon} is
* called.
*
* For example, if the polygon lies in an arbitrary plane in 3-space, and a
* color is associated with each vertex, the GLU_TESS_COMBINE
* callback might look like this:
*
*
* void myCombine(double[] coords, Object[] data,
* float[] weight, Object[] outData)
* {
* MyVertex newVertex = new MyVertex();
*
* newVertex.x = coords[0];
* newVertex.y = coords[1];
* newVertex.z = coords[2];
* newVertex.r = weight[0]*data[0].r +
* weight[1]*data[1].r +
* weight[2]*data[2].r +
* weight[3]*data[3].r;
* newVertex.g = weight[0]*data[0].g +
* weight[1]*data[1].g +
* weight[2]*data[2].g +
* weight[3]*data[3].g;
* newVertex.b = weight[0]*data[0].b +
* weight[1]*data[1].b +
* weight[2]*data[2].b +
* weight[3]*data[3].b;
* newVertex.a = weight[0]*data[0].a +
* weight[1]*data[1].a +
* weight[2]*data[2].a +
* weight[3]*data[3].a;
* outData = newVertex;
* }
*
* @param coords
* Specifics the location of the new vertex.
* @param data
* Specifics the vertices used to create the new vertex.
* @param weight
* Specifics the weights used to create the new vertex.
* @param outData
* Reference user the put the coodinates of the new vertex.
*
* @see GLU#gluTessCallback gluTessCallback
* @see #combineData combineData
*/
void combine(double[] coords, Object[] data,
float[] weight, Object[] outData);
/**
* The same as the {@link #combine combine} callback method except
* that it takes an additional reference argument. This reference is
* identical to the opaque reference provided when {@link
* GLU#gluTessBeginPolygon gluTessBeginPolygon} was called.
*
* @param coords
* Specifics the location of the new vertex.
* @param data
* Specifics the vertices used to create the new vertex.
* @param weight
* Specifics the weights used to create the new vertex.
* @param outData
* Reference user the put the coodinates of the new vertex.
* @param polygonData
* Specifics a reference to user-defined data.
*
* @see GLU#gluTessCallback gluTessCallback
* @see #combine combine
*/
void combineData(double[] coords, Object[] data,
float[] weight, Object[] outData,
Object polygonData);
/**
* The error callback method is called when an error is encountered.
* The one argument is of type int; it indicates the specific error that
* occurred and will be set to one of GLU_TESS_MISSING_BEGIN_POLYGON,
* GLU_TESS_MISSING_END_POLYGON, GLU_TESS_MISSING_BEGIN_CONTOUR,
* GLU_TESS_MISSING_END_CONTOUR, GLU_TESS_COORD_TOO_LARGE,
* GLU_TESS_NEED_COMBINE_CALLBACK or GLU_OUT_OF_MEMORY.
* Character strings describing these errors can be retrieved with the
* {@link GLU#gluErrorString gluErrorString} call.
*
* The GLU library will recover from the first four errors by inserting the
* missing call(s). GLU_TESS_COORD_TOO_LARGE indicates that some
* vertex coordinate exceeded the predefined constant
* GLU_TESS_MAX_COORD in absolute value, and that the value has been
* clamped. (Coordinate values must be small enough so that two can be
* multiplied together without overflow.)
* GLU_TESS_NEED_COMBINE_CALLBACK indicates that the tessellation
* detected an intersection between two edges in the input data, and the
* GLU_TESS_COMBINE or GLU_TESS_COMBINE_DATA callback was not
* provided. No output is generated. GLU_OUT_OF_MEMORY indicates that
* there is not enough memory so no output is generated.
*
* @param errnum
* Specifics the error number code.
*
* @see GLU#gluTessCallback gluTessCallback
* @see #errorData errorData
*/
void error(int errnum);
/**
* The same as the {@link #error error} callback method except that
* it takes an additional reference argument. This reference is
* identical to the opaque reference provided when {@link
* GLU#gluTessBeginPolygon gluTessBeginPolygon} was called.
*
* @param errnum
* Specifics the error number code.
* @param polygonData
* Specifics a reference to user-defined data.
*
* @see GLU#gluTessCallback gluTessCallback
* @see #error error
*/
void errorData(int errnum, Object polygonData);
//void mesh(com.sun.opengl.impl.tessellator.GLUmesh mesh);
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/MipMap.java 0000644 0001750 0001750 00000022032 11543426510 021130 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.glu;
import java.nio.ByteBuffer;
import org.lwjgl.BufferUtils;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.util.glu.GLU.*;
/**
* MipMap.java
*
*
* Created 11-jan-2004
* @author Erik Duijs
*/
public class MipMap extends Util {
/**
* Method gluBuild2DMipmaps
*
* @param target
* @param components
* @param width
* @param height
* @param format
* @param type
* @param data
* @return int
*/
public static int gluBuild2DMipmaps(final int target,
final int components, final int width, final int height,
final int format, final int type, final ByteBuffer data) {
if ( width < 1 || height < 1 ) return GLU_INVALID_VALUE;
final int bpp = bytesPerPixel(format, type);
if ( bpp == 0 )
return GLU_INVALID_ENUM;
final int maxSize = glGetIntegerv(GL_MAX_TEXTURE_SIZE);
int w = nearestPower(width);
if ( w > maxSize )
w = maxSize;
int h = nearestPower(height);
if ( h > maxSize )
h = maxSize;
// Get current glPixelStore state
PixelStoreState pss = new PixelStoreState();
// set pixel packing
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glPixelStorei(GL_PACK_SKIP_ROWS, 0);
glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
ByteBuffer image;
int retVal = 0;
boolean done = false;
if ( w != width || h != height ) {
// must rescale image to get "top" mipmap texture image
image = BufferUtils.createByteBuffer((w + 4) * h * bpp);
int error = gluScaleImage(format, width, height, type, data, w, h, type, image);
if ( error != 0 ) {
retVal = error;
done = true;
}
/* set pixel unpacking */
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
} else {
image = data;
}
ByteBuffer bufferA = null;
ByteBuffer bufferB = null;
int level = 0;
while ( !done ) {
if (image != data) {
/* set pixel unpacking */
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
}
glTexImage2D(target, level, components, w, h, 0, format, type, image);
if ( w == 1 && h == 1 )
break;
final int newW = (w < 2) ? 1 : w >> 1;
final int newH = (h < 2) ? 1 : h >> 1;
final ByteBuffer newImage;
if ( bufferA == null )
newImage = (bufferA = BufferUtils.createByteBuffer((newW + 4) * newH * bpp));
else if ( bufferB == null )
newImage = (bufferB = BufferUtils.createByteBuffer((newW + 4) * newH * bpp));
else
newImage = bufferB;
int error = gluScaleImage(format, w, h, type, image, newW, newH, type, newImage);
if ( error != 0 ) {
retVal = error;
done = true;
}
image = newImage;
if ( bufferB != null )
bufferB = bufferA;
w = newW;
h = newH;
level++;
}
// Restore original glPixelStore state
pss.save();
return retVal;
}
/**
* Method gluScaleImage.
* @param format
* @param widthIn
* @param heightIn
* @param typein
* @param dataIn
* @param widthOut
* @param heightOut
* @param typeOut
* @param dataOut
* @return int
*/
public static int gluScaleImage(int format,
int widthIn, int heightIn, int typein, ByteBuffer dataIn,
int widthOut, int heightOut, int typeOut, ByteBuffer dataOut) {
final int components = compPerPix(format);
if ( components == -1 )
return GLU_INVALID_ENUM;
int i, j, k;
float[] tempIn, tempOut;
float sx, sy;
int sizein, sizeout;
int rowstride, rowlen;
// temp image data
tempIn = new float[widthIn * heightIn * components];
tempOut = new float[widthOut * heightOut * components];
// Determine bytes per input type
switch ( typein ) {
case GL_UNSIGNED_BYTE:
sizein = 1;
break;
case GL_FLOAT:
sizein = 4;
break;
default:
return GL_INVALID_ENUM;
}
// Determine bytes per output type
switch ( typeOut ) {
case GL_UNSIGNED_BYTE:
sizeout = 1;
break;
case GL_FLOAT:
sizeout = 4;
break;
default:
return GL_INVALID_ENUM;
}
// Get glPixelStore state
PixelStoreState pss = new PixelStoreState();
//Unpack the pixel data and convert to floating point
if ( pss.unpackRowLength > 0 )
rowlen = pss.unpackRowLength;
else
rowlen = widthIn;
if ( sizein >= pss.unpackAlignment )
rowstride = components * rowlen;
else
rowstride = pss.unpackAlignment / sizein * ceil(components * rowlen * sizein, pss.unpackAlignment);
switch ( typein ) {
case GL_UNSIGNED_BYTE:
k = 0;
dataIn.rewind();
for ( i = 0; i < heightIn; i++ ) {
int ubptr = i * rowstride + pss.unpackSkipRows * rowstride + pss.unpackSkipPixels * components;
for ( j = 0; j < widthIn * components; j++ ) {
tempIn[k++] = dataIn.get(ubptr++) & 0xff;
}
}
break;
case GL_FLOAT:
k = 0;
dataIn.rewind();
for ( i = 0; i < heightIn; i++ )
{
int fptr = 4 * (i * rowstride + pss.unpackSkipRows * rowstride + pss.unpackSkipPixels * components);
for ( j = 0; j < widthIn * components; j++ )
{
tempIn[k++] = dataIn.getFloat(fptr);
fptr += 4;
}
}
break;
default:
return GLU_INVALID_ENUM;
}
// Do scaling
sx = (float)widthIn / (float)widthOut;
sy = (float)heightIn / (float)heightOut;
float[] c = new float[components];
int src, dst;
for ( int iy = 0; iy < heightOut; iy++ ) {
for ( int ix = 0; ix < widthOut; ix++ ) {
int x0 = (int)(ix * sx);
int x1 = (int)((ix + 1) * sx);
int y0 = (int)(iy * sy);
int y1 = (int)((iy + 1) * sy);
int readPix = 0;
// reset weighted pixel
for ( int ic = 0; ic < components; ic++ ) {
c[ic] = 0;
}
// create weighted pixel
for ( int ix0 = x0; ix0 < x1; ix0++ ) {
for ( int iy0 = y0; iy0 < y1; iy0++ ) {
src = (iy0 * widthIn + ix0) * components;
for ( int ic = 0; ic < components; ic++ ) {
c[ic] += tempIn[src + ic];
}
readPix++;
}
}
// store weighted pixel
dst = (iy * widthOut + ix) * components;
if ( readPix == 0 ) {
// Image is sized up, caused by non power of two texture as input
src = (y0 * widthIn + x0) * components;
for ( int ic = 0; ic < components; ic++ ) {
tempOut[dst++] = tempIn[src + ic];
}
} else {
// sized down
for ( k = 0; k < components; k++ ) {
tempOut[dst++] = c[k] / readPix;
}
}
}
}
// Convert temp output
if ( pss.packRowLength > 0 )
rowlen = pss.packRowLength;
else
rowlen = widthOut;
if ( sizeout >= pss.packAlignment )
rowstride = components * rowlen;
else
rowstride = pss.packAlignment / sizeout * ceil(components * rowlen * sizeout, pss.packAlignment);
switch ( typeOut ) {
case GL_UNSIGNED_BYTE:
k = 0;
for ( i = 0; i < heightOut; i++ ) {
int ubptr = i * rowstride + pss.packSkipRows * rowstride + pss.packSkipPixels * components;
for ( j = 0; j < widthOut * components; j++ ) {
dataOut.put(ubptr++, (byte)tempOut[k++]);
}
}
break;
case GL_FLOAT:
k = 0;
for ( i = 0; i < heightOut; i++ ) {
int fptr = 4 * (i * rowstride + pss.unpackSkipRows * rowstride + pss.unpackSkipPixels * components);
for ( j = 0; j < widthOut * components; j++ ) {
dataOut.putFloat(fptr, tempOut[k++]);
fptr += 4;
}
}
break;
default:
return GLU_INVALID_ENUM;
}
return 0;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/GLUtessellatorCallbackAdapter.java 0000644 0001750 0001750 00000013015 11543426510 025575 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu;
/**
* The GLUtessellatorCallbackAdapter provides a default implementation of
* {@link GLUtessellatorCallback GLUtessellatorCallback}
* with empty callback methods. This class can be extended to provide user
* defined callback methods.
*
* @author Eric Veach, July 1994
* @author Java Port: Pepijn Van Eechhoudt, July 2003
* @author Java Port: Nathan Parker Burg, August 2003
*/
public class GLUtessellatorCallbackAdapter implements GLUtessellatorCallback {
public void begin(int type) {}
public void edgeFlag(boolean boundaryEdge) {}
public void vertex(Object vertexData) {}
public void end() {}
// public void mesh(com.sun.opengl.impl.tessellator.GLUmesh mesh) {}
public void error(int errnum) {}
public void combine(double[] coords, Object[] data,
float[] weight, Object[] outData) {}
public void beginData(int type, Object polygonData) {}
public void edgeFlagData(boolean boundaryEdge,
Object polygonData) {}
public void vertexData(Object vertexData, Object polygonData) {}
public void endData(Object polygonData) {}
public void errorData(int errnum, Object polygonData) {}
public void combineData(double[] coords, Object[] data,
float[] weight, Object[] outData,
Object polygonData) {}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/GLUtessellator.java 0000644 0001750 0001750 00000004524 11543426510 022664 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.glu;
public interface GLUtessellator {
void gluDeleteTess();
void gluTessProperty(int which, double value);
/* Returns tessellator property */
void gluGetTessProperty(int which, double[] value,
int value_offset); /* gluGetTessProperty() */
void gluTessNormal(double x, double y, double z);
void gluTessCallback(int which,
GLUtessellatorCallback aCallback);
void gluTessVertex(double[] coords, int coords_offset,
Object vertexData);
void gluTessBeginPolygon(Object data);
void gluTessBeginContour();
void gluTessEndContour();
void gluTessEndPolygon();
/*******************************************************/
/* Obsolete calls -- for backward compatibility */
void gluBeginPolygon();
/*ARGSUSED*/
void gluNextContour(int type);
void gluEndPolygon();
} lwjgl-2.7.1/src/java/org/lwjgl/util/glu/Project.java 0000644 0001750 0001750 00000024215 11543426510 021360 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.glu;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.GL11;
import static org.lwjgl.opengl.GL11.*;
/**
* Project.java
*
*
* Created 11-jan-2004
*
* @author Erik Duijs
*/
public class Project extends Util {
private static final float[] IDENTITY_MATRIX =
new float[] {
1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f };
private static final FloatBuffer matrix = BufferUtils.createFloatBuffer(16);
private static final FloatBuffer finalMatrix = BufferUtils.createFloatBuffer(16);
private static final FloatBuffer tempMatrix = BufferUtils.createFloatBuffer(16);
private static final float[] in = new float[4];
private static final float[] out = new float[4];
private static final float[] forward = new float[3];
private static final float[] side = new float[3];
private static final float[] up = new float[3];
/**
* Make matrix an identity matrix
*/
private static void __gluMakeIdentityf(FloatBuffer m) {
int oldPos = m.position();
m.put(IDENTITY_MATRIX);
m.position(oldPos);
}
/**
* Method __gluMultMatrixVecf
*
* @param finalMatrix
* @param in
* @param out
*/
private static void __gluMultMatrixVecf(FloatBuffer m, float[] in, float[] out) {
for (int i = 0; i < 4; i++) {
out[i] =
in[0] * m.get(m.position() + 0*4 + i)
+ in[1] * m.get(m.position() + 1*4 + i)
+ in[2] * m.get(m.position() + 2*4 + i)
+ in[3] * m.get(m.position() + 3*4 + i);
}
}
/**
* @param src
* @param inverse
*
* @return
*/
private static boolean __gluInvertMatrixf(FloatBuffer src, FloatBuffer inverse) {
int i, j, k, swap;
float t;
FloatBuffer temp = Project.tempMatrix;
for (i = 0; i < 16; i++) {
temp.put(i, src.get(i + src.position()));
}
__gluMakeIdentityf(inverse);
for (i = 0; i < 4; i++) {
/*
* * Look for largest element in column
*/
swap = i;
for (j = i + 1; j < 4; j++) {
/*
* if (fabs(temp[j][i]) > fabs(temp[i][i])) { swap = j;
*/
if (Math.abs(temp.get(j*4 + i)) > Math.abs(temp.get(i* 4 + i))) {
swap = j;
}
}
if (swap != i) {
/*
* * Swap rows.
*/
for (k = 0; k < 4; k++) {
t = temp.get(i*4 + k);
temp.put(i*4 + k, temp.get(swap*4 + k));
temp.put(swap*4 + k, t);
t = inverse.get(i*4 + k);
inverse.put(i*4 + k, inverse.get(swap*4 + k));
//inverse.put((i << 2) + k, inverse.get((swap << 2) + k));
inverse.put(swap*4 + k, t);
//inverse.put((swap << 2) + k, t);
}
}
if (temp.get(i*4 + i) == 0) {
/*
* * No non-zero pivot. The matrix is singular, which shouldn't *
* happen. This means the user gave us a bad matrix.
*/
return false;
}
t = temp.get(i*4 + i);
for (k = 0; k < 4; k++) {
temp.put(i*4 + k, temp.get(i*4 + k)/t);
inverse.put(i*4 + k, inverse.get(i*4 + k)/t);
}
for (j = 0; j < 4; j++) {
if (j != i) {
t = temp.get(j*4 + i);
for (k = 0; k < 4; k++) {
temp.put(j*4 + k, temp.get(j*4 + k) - temp.get(i*4 + k) * t);
inverse.put(j*4 + k, inverse.get(j*4 + k) - inverse.get(i*4 + k) * t);
/*inverse.put(
(j << 2) + k,
inverse.get((j << 2) + k) - inverse.get((i << 2) + k) * t);*/
}
}
}
}
return true;
}
/**
* @param a
* @param b
* @param r
*/
private static void __gluMultMatricesf(FloatBuffer a, FloatBuffer b, FloatBuffer r) {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
r.put(r.position() + i*4 + j,
a.get(a.position() + i*4 + 0) * b.get(b.position() + 0*4 + j) + a.get(a.position() + i*4 + 1) * b.get(b.position() + 1*4 + j) + a.get(a.position() + i*4 + 2) * b.get(b.position() + 2*4 + j) + a.get(a.position() + i*4 + 3) * b.get(b.position() + 3*4 + j));
}
}
}
/**
* Method gluPerspective.
*
* @param fovy
* @param aspect
* @param zNear
* @param zFar
*/
public static void gluPerspective(float fovy, float aspect, float zNear, float zFar) {
float sine, cotangent, deltaZ;
float radians = fovy / 2 * GLU.PI / 180;
deltaZ = zFar - zNear;
sine = (float) Math.sin(radians);
if ((deltaZ == 0) || (sine == 0) || (aspect == 0)) {
return;
}
cotangent = (float) Math.cos(radians) / sine;
__gluMakeIdentityf(matrix);
matrix.put(0 * 4 + 0, cotangent / aspect);
matrix.put(1 * 4 + 1, cotangent);
matrix.put(2 * 4 + 2, - (zFar + zNear) / deltaZ);
matrix.put(2 * 4 + 3, -1);
matrix.put(3 * 4 + 2, -2 * zNear * zFar / deltaZ);
matrix.put(3 * 4 + 3, 0);
glMultMatrix(matrix);
}
/**
* Method gluLookAt
*
* @param eyex
* @param eyey
* @param eyez
* @param centerx
* @param centery
* @param centerz
* @param upx
* @param upy
* @param upz
*/
public static void gluLookAt(
float eyex,
float eyey,
float eyez,
float centerx,
float centery,
float centerz,
float upx,
float upy,
float upz) {
float[] forward = Project.forward;
float[] side = Project.side;
float[] up = Project.up;
forward[0] = centerx - eyex;
forward[1] = centery - eyey;
forward[2] = centerz - eyez;
up[0] = upx;
up[1] = upy;
up[2] = upz;
normalize(forward);
/* Side = forward x up */
cross(forward, up, side);
normalize(side);
/* Recompute up as: up = side x forward */
cross(side, forward, up);
__gluMakeIdentityf(matrix);
matrix.put(0 * 4 + 0, side[0]);
matrix.put(1 * 4 + 0, side[1]);
matrix.put(2 * 4 + 0, side[2]);
matrix.put(0 * 4 + 1, up[0]);
matrix.put(1 * 4 + 1, up[1]);
matrix.put(2 * 4 + 1, up[2]);
matrix.put(0 * 4 + 2, -forward[0]);
matrix.put(1 * 4 + 2, -forward[1]);
matrix.put(2 * 4 + 2, -forward[2]);
glMultMatrix(matrix);
glTranslatef(-eyex, -eyey, -eyez);
}
/**
* Method gluProject
*
* @param objx
* @param objy
* @param objz
* @param modelMatrix
* @param projMatrix
* @param viewport
* @param win_pos
*/
public static boolean gluProject(
float objx,
float objy,
float objz,
FloatBuffer modelMatrix,
FloatBuffer projMatrix,
IntBuffer viewport,
FloatBuffer win_pos) {
float[] in = Project.in;
float[] out = Project.out;
in[0] = objx;
in[1] = objy;
in[2] = objz;
in[3] = 1.0f;
__gluMultMatrixVecf(modelMatrix, in, out);
__gluMultMatrixVecf(projMatrix, out, in);
if (in[3] == 0.0)
return false;
in[3] = (1.0f / in[3]) * 0.5f;
// Map x, y and z to range 0-1
in[0] = in[0] * in[3] + 0.5f;
in[1] = in[1] * in[3] + 0.5f;
in[2] = in[2] * in[3] + 0.5f;
// Map x,y to viewport
win_pos.put(0, in[0] * viewport.get(viewport.position() + 2) + viewport.get(viewport.position() + 0));
win_pos.put(1, in[1] * viewport.get(viewport.position() + 3) + viewport.get(viewport.position() + 1));
win_pos.put(2, in[2]);
return true;
}
/**
* Method gluUnproject
*
* @param winx
* @param winy
* @param winz
* @param modelMatrix
* @param projMatrix
* @param viewport
* @param obj_pos
*/
public static boolean gluUnProject(
float winx,
float winy,
float winz,
FloatBuffer modelMatrix,
FloatBuffer projMatrix,
IntBuffer viewport,
FloatBuffer obj_pos) {
float[] in = Project.in;
float[] out = Project.out;
__gluMultMatricesf(modelMatrix, projMatrix, finalMatrix);
if (!__gluInvertMatrixf(finalMatrix, finalMatrix))
return false;
in[0] = winx;
in[1] = winy;
in[2] = winz;
in[3] = 1.0f;
// Map x and y from window coordinates
in[0] = (in[0] - viewport.get(viewport.position() + 0)) / viewport.get(viewport.position() + 2);
in[1] = (in[1] - viewport.get(viewport.position() + 1)) / viewport.get(viewport.position() + 3);
// Map to range -1 to 1
in[0] = in[0] * 2 - 1;
in[1] = in[1] * 2 - 1;
in[2] = in[2] * 2 - 1;
__gluMultMatrixVecf(finalMatrix, in, out);
if (out[3] == 0.0)
return false;
out[3] = 1.0f / out[3];
obj_pos.put(obj_pos.position() + 0, out[0] * out[3]);
obj_pos.put(obj_pos.position() + 1, out[1] * out[3]);
obj_pos.put(obj_pos.position() + 2, out[2] * out[3]);
return true;
}
/**
* Method gluPickMatrix
*
* @param x
* @param y
* @param deltaX
* @param deltaY
* @param viewport
*/
public static void gluPickMatrix(
float x,
float y,
float deltaX,
float deltaY,
IntBuffer viewport) {
if (deltaX <= 0 || deltaY <= 0) {
return;
}
/* Translate and scale the picked region to the entire window */
glTranslatef(
(viewport.get(viewport.position() + 2) - 2 * (x - viewport.get(viewport.position() + 0))) / deltaX,
(viewport.get(viewport.position() + 3) - 2 * (y - viewport.get(viewport.position() + 1))) / deltaY,
0);
glScalef(viewport.get(viewport.position() + 2) / deltaX, viewport.get(viewport.position() + 3) / deltaY, 1.0f);
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/PartialDisk.java 0000644 0001750 0001750 00000024325 11543426510 022163 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.glu;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.util.glu.GLU.*;
/**
* PartialDisk.java
*
*
* Created 23-dec-2003
*
* @author Erik Duijs
*/
public class PartialDisk extends Quadric {
private static final int CACHE_SIZE = 240;
/**
* Constructor for PartialDisk.
*/
public PartialDisk() {
super();
}
/**
* renders a partial disk on the z=0 plane. A partial disk is similar to a
* full disk, except that only the subset of the disk from startAngle
* through startAngle + sweepAngle is included (where 0 degrees is along
* the +y axis, 90 degrees along the +x axis, 180 along the -y axis, and
* 270 along the -x axis).
*
* The partial disk has a radius of outerRadius, and contains a concentric
* circular hole with a radius of innerRadius. If innerRadius is zero, then
* no hole is generated. The partial disk is subdivided around the z axis
* into slices (like pizza slices), and also about the z axis into rings
* (as specified by slices and loops, respectively).
*
* With respect to orientation, the +z side of the partial disk is
* considered to be outside (see gluQuadricOrientation). This means that if
* the orientation is set to GLU.GLU_OUTSIDE, then any normals generated point
* along the +z axis. Otherwise, they point along the -z axis.
*
* If texturing is turned on (with gluQuadricTexture), texture coordinates
* are generated linearly such that where r=outerRadius, the value at (r, 0, 0)
* is (1, 0.5), at (0, r, 0) it is (0.5, 1), at (-r, 0, 0) it is (0, 0.5),
* and at (0, -r, 0) it is (0.5, 0).
*/
public void draw(
float innerRadius,
float outerRadius,
int slices,
int loops,
float startAngle,
float sweepAngle) {
int i, j;
float[] sinCache = new float[CACHE_SIZE];
float[] cosCache = new float[CACHE_SIZE];
float angle;
float sintemp, costemp;
float deltaRadius;
float radiusLow, radiusHigh;
float texLow = 0, texHigh = 0;
float angleOffset;
int slices2;
int finish;
if (slices >= CACHE_SIZE)
slices = CACHE_SIZE - 1;
if (slices < 2
|| loops < 1
|| outerRadius <= 0.0f
|| innerRadius < 0.0f
|| innerRadius > outerRadius) {
//gluQuadricError(qobj, GLU.GLU_INVALID_VALUE);
System.err.println("PartialDisk: GLU_INVALID_VALUE");
return;
}
if (sweepAngle < -360.0f)
sweepAngle = 360.0f;
if (sweepAngle > 360.0f)
sweepAngle = 360.0f;
if (sweepAngle < 0) {
startAngle += sweepAngle;
sweepAngle = -sweepAngle;
}
if (sweepAngle == 360.0f) {
slices2 = slices;
} else {
slices2 = slices + 1;
}
/* Compute length (needed for normal calculations) */
deltaRadius = outerRadius - innerRadius;
/* Cache is the vertex locations cache */
angleOffset = startAngle / 180.0f * PI;
for (i = 0; i <= slices; i++) {
angle = angleOffset + ((PI * sweepAngle) / 180.0f) * i / slices;
sinCache[i] = sin(angle);
cosCache[i] = cos(angle);
}
if (sweepAngle == 360.0f) {
sinCache[slices] = sinCache[0];
cosCache[slices] = cosCache[0];
}
switch (super.normals) {
case GLU_FLAT :
case GLU_SMOOTH :
if (super.orientation == GLU_OUTSIDE) {
glNormal3f(0.0f, 0.0f, 1.0f);
} else {
glNormal3f(0.0f, 0.0f, -1.0f);
}
break;
default :
case GLU_NONE :
break;
}
switch (super.drawStyle) {
case GLU_FILL :
if (innerRadius == .0f) {
finish = loops - 1;
/* Triangle strip for inner polygons */
glBegin(GL_TRIANGLE_FAN);
if (super.textureFlag) {
glTexCoord2f(0.5f, 0.5f);
}
glVertex3f(0.0f, 0.0f, 0.0f);
radiusLow = outerRadius - deltaRadius * ((float) (loops - 1) / loops);
if (super.textureFlag) {
texLow = radiusLow / outerRadius / 2;
}
if (super.orientation == GLU_OUTSIDE) {
for (i = slices; i >= 0; i--) {
if (super.textureFlag) {
glTexCoord2f(
texLow * sinCache[i] + 0.5f,
texLow * cosCache[i] + 0.5f);
}
glVertex3f(radiusLow * sinCache[i], radiusLow * cosCache[i], 0.0f);
}
} else {
for (i = 0; i <= slices; i++) {
if (super.textureFlag) {
glTexCoord2f(
texLow * sinCache[i] + 0.5f,
texLow * cosCache[i] + 0.5f);
}
glVertex3f(radiusLow * sinCache[i], radiusLow * cosCache[i], 0.0f);
}
}
glEnd();
} else {
finish = loops;
}
for (j = 0; j < finish; j++) {
radiusLow = outerRadius - deltaRadius * ((float) j / loops);
radiusHigh = outerRadius - deltaRadius * ((float) (j + 1) / loops);
if (super.textureFlag) {
texLow = radiusLow / outerRadius / 2;
texHigh = radiusHigh / outerRadius / 2;
}
glBegin(GL_QUAD_STRIP);
for (i = 0; i <= slices; i++) {
if (super.orientation == GLU_OUTSIDE) {
if (super.textureFlag) {
glTexCoord2f(
texLow * sinCache[i] + 0.5f,
texLow * cosCache[i] + 0.5f);
}
glVertex3f(radiusLow * sinCache[i], radiusLow * cosCache[i], 0.0f);
if (super.textureFlag) {
glTexCoord2f(
texHigh * sinCache[i] + 0.5f,
texHigh * cosCache[i] + 0.5f);
}
glVertex3f(
radiusHigh * sinCache[i],
radiusHigh * cosCache[i],
0.0f);
} else {
if (super.textureFlag) {
glTexCoord2f(
texHigh * sinCache[i] + 0.5f,
texHigh * cosCache[i] + 0.5f);
}
glVertex3f(
radiusHigh * sinCache[i],
radiusHigh * cosCache[i],
0.0f);
if (super.textureFlag) {
glTexCoord2f(
texLow * sinCache[i] + 0.5f,
texLow * cosCache[i] + 0.5f);
}
glVertex3f(radiusLow * sinCache[i], radiusLow * cosCache[i], 0.0f);
}
}
glEnd();
}
break;
case GLU_POINT :
glBegin(GL_POINTS);
for (i = 0; i < slices2; i++) {
sintemp = sinCache[i];
costemp = cosCache[i];
for (j = 0; j <= loops; j++) {
radiusLow = outerRadius - deltaRadius * ((float) j / loops);
if (super.textureFlag) {
texLow = radiusLow / outerRadius / 2;
glTexCoord2f(
texLow * sinCache[i] + 0.5f,
texLow * cosCache[i] + 0.5f);
}
glVertex3f(radiusLow * sintemp, radiusLow * costemp, 0.0f);
}
}
glEnd();
break;
case GLU_LINE :
if (innerRadius == outerRadius) {
glBegin(GL_LINE_STRIP);
for (i = 0; i <= slices; i++) {
if (super.textureFlag) {
glTexCoord2f(sinCache[i] / 2 + 0.5f, cosCache[i] / 2 + 0.5f);
}
glVertex3f(innerRadius * sinCache[i], innerRadius * cosCache[i], 0.0f);
}
glEnd();
break;
}
for (j = 0; j <= loops; j++) {
radiusLow = outerRadius - deltaRadius * ((float) j / loops);
if (super.textureFlag) {
texLow = radiusLow / outerRadius / 2;
}
glBegin(GL_LINE_STRIP);
for (i = 0; i <= slices; i++) {
if (super.textureFlag) {
glTexCoord2f(
texLow * sinCache[i] + 0.5f,
texLow * cosCache[i] + 0.5f);
}
glVertex3f(radiusLow * sinCache[i], radiusLow * cosCache[i], 0.0f);
}
glEnd();
}
for (i = 0; i < slices2; i++) {
sintemp = sinCache[i];
costemp = cosCache[i];
glBegin(GL_LINE_STRIP);
for (j = 0; j <= loops; j++) {
radiusLow = outerRadius - deltaRadius * ((float) j / loops);
if (super.textureFlag) {
texLow = radiusLow / outerRadius / 2;
}
if (super.textureFlag) {
glTexCoord2f(
texLow * sinCache[i] + 0.5f,
texLow * cosCache[i] + 0.5f);
}
glVertex3f(radiusLow * sintemp, radiusLow * costemp, 0.0f);
}
glEnd();
}
break;
case GLU_SILHOUETTE :
if (sweepAngle < 360.0f) {
for (i = 0; i <= slices; i += slices) {
sintemp = sinCache[i];
costemp = cosCache[i];
glBegin(GL_LINE_STRIP);
for (j = 0; j <= loops; j++) {
radiusLow = outerRadius - deltaRadius * ((float) j / loops);
if (super.textureFlag) {
texLow = radiusLow / outerRadius / 2;
glTexCoord2f(
texLow * sinCache[i] + 0.5f,
texLow * cosCache[i] + 0.5f);
}
glVertex3f(radiusLow * sintemp, radiusLow * costemp, 0.0f);
}
glEnd();
}
}
for (j = 0; j <= loops; j += loops) {
radiusLow = outerRadius - deltaRadius * ((float) j / loops);
if (super.textureFlag) {
texLow = radiusLow / outerRadius / 2;
}
glBegin(GL_LINE_STRIP);
for (i = 0; i <= slices; i++) {
if (super.textureFlag) {
glTexCoord2f(
texLow * sinCache[i] + 0.5f,
texLow * cosCache[i] + 0.5f);
}
glVertex3f(radiusLow * sinCache[i], radiusLow * cosCache[i], 0.0f);
}
glEnd();
if (innerRadius == outerRadius)
break;
}
break;
default :
break;
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/ 0000755 0001750 0001750 00000000000 11543426510 021611 5 ustar zero79 zero79 lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/PriorityQSort.java 0000644 0001750 0001750 00000024770 11543426510 025300 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
class PriorityQSort extends PriorityQ {
PriorityQHeap heap;
Object[] keys;
// JAVA: 'order' contains indices into the keys array.
// This simulates the indirect pointers used in the original C code
// (from Frank Suykens, Luciad.com).
int[] order;
int size, max;
boolean initialized;
PriorityQ.Leq leq;
PriorityQSort(PriorityQ.Leq leq) {
heap = new PriorityQHeap(leq);
keys = new Object[PriorityQ.INIT_SIZE];
size = 0;
max = PriorityQ.INIT_SIZE;
initialized = false;
this.leq = leq;
}
/* really __gl_pqSortDeletePriorityQ */
void pqDeletePriorityQ() {
if (heap != null) heap.pqDeletePriorityQ();
order = null;
keys = null;
}
private static boolean LT(PriorityQ.Leq leq, Object x, Object y) {
return (!PriorityQHeap.LEQ(leq, y, x));
}
private static boolean GT(PriorityQ.Leq leq, Object x, Object y) {
return (!PriorityQHeap.LEQ(leq, x, y));
}
private static void Swap(int[] array, int a, int b) {
if (true) {
int tmp = array[a];
array[a] = array[b];
array[b] = tmp;
} else {
}
}
private static class Stack {
int p, r;
}
/* really __gl_pqSortInit */
boolean pqInit() {
int p, r, i, j;
int piv;
Stack[] stack = new Stack[50];
for (int k = 0; k < stack.length; k++) {
stack[k] = new Stack();
}
int top = 0;
int seed = 2016473283;
/* Create an array of indirect pointers to the keys, so that we
* the handles we have returned are still valid.
*/
order = new int[size + 1];
/* the previous line is a patch to compensate for the fact that IBM */
/* machines return a null on a malloc of zero bytes (unlike SGI), */
/* so we have to put in this defense to guard against a memory */
/* fault four lines down. from fossum@austin.ibm.com. */
p = 0;
r = size - 1;
for (piv = 0, i = p; i <= r; ++piv, ++i) {
// indirect pointers: keep an index into the keys array, not a direct pointer to its contents
order[i] = piv;
}
/* Sort the indirect pointers in descending order,
* using randomized Quicksort
*/
stack[top].p = p;
stack[top].r = r;
++top;
while (--top >= 0) {
p = stack[top].p;
r = stack[top].r;
while (r > p + 10) {
seed = Math.abs( seed * 1539415821 + 1 );
i = p + seed % (r - p + 1);
piv = order[i];
order[i] = order[p];
order[p] = piv;
i = p - 1;
j = r + 1;
do {
do {
++i;
} while (GT(leq, keys[order[i]], keys[piv]));
do {
--j;
} while (LT(leq, keys[order[j]], keys[piv]));
Swap(order, i, j);
} while (i < j);
Swap(order, i, j); /* Undo last swap */
if (i - p < r - j) {
stack[top].p = j + 1;
stack[top].r = r;
++top;
r = i - 1;
} else {
stack[top].p = p;
stack[top].r = i - 1;
++top;
p = j + 1;
}
}
/* Insertion sort small lists */
for (i = p + 1; i <= r; ++i) {
piv = order[i];
for (j = i; j > p && LT(leq, keys[order[j - 1]], keys[piv]); --j) {
order[j] = order[j - 1];
}
order[j] = piv;
}
}
max = size;
initialized = true;
heap.pqInit(); /* always succeeds */
/* #ifndef NDEBUG
p = order;
r = p + size - 1;
for (i = p; i < r; ++i) {
Assertion.doAssert(LEQ( * * (i + 1), **i ));
}
#endif*/
return true;
}
/* really __gl_pqSortInsert */
/* returns LONG_MAX iff out of memory */
int pqInsert(Object keyNew) {
int curr;
if (initialized) {
return heap.pqInsert(keyNew);
}
curr = size;
if (++size >= max) {
Object[] saveKey = keys;
/* If the heap overflows, double its size. */
max <<= 1;
// pq->keys = (PQHeapKey *)memRealloc( pq->keys,(size_t)(pq->max * sizeof( pq->keys[0] )));
Object[] pqKeys = new Object[max];
System.arraycopy( keys, 0, pqKeys, 0, keys.length );
keys = pqKeys;
if (keys == null) {
keys = saveKey; /* restore ptr to free upon return */
return Integer.MAX_VALUE;
}
}
assert curr != Integer.MAX_VALUE;
keys[curr] = keyNew;
/* Negative handles index the sorted array. */
return -(curr + 1);
}
/* really __gl_pqSortExtractMin */
Object pqExtractMin() {
Object sortMin, heapMin;
if (size == 0) {
return heap.pqExtractMin();
}
sortMin = keys[order[size - 1]];
if (!heap.pqIsEmpty()) {
heapMin = heap.pqMinimum();
if (LEQ(leq, heapMin, sortMin)) {
return heap.pqExtractMin();
}
}
do {
--size;
} while (size > 0 && keys[order[size - 1]] == null);
return sortMin;
}
/* really __gl_pqSortMinimum */
Object pqMinimum() {
Object sortMin, heapMin;
if (size == 0) {
return heap.pqMinimum();
}
sortMin = keys[order[size - 1]];
if (!heap.pqIsEmpty()) {
heapMin = heap.pqMinimum();
if (PriorityQHeap.LEQ(leq, heapMin, sortMin)) {
return heapMin;
}
}
return sortMin;
}
/* really __gl_pqSortIsEmpty */
boolean pqIsEmpty() {
return (size == 0) && heap.pqIsEmpty();
}
/* really __gl_pqSortDelete */
void pqDelete(int curr) {
if (curr >= 0) {
heap.pqDelete(curr);
return;
}
curr = -(curr + 1);
assert curr < max && keys[curr] != null;
keys[curr] = null;
while (size > 0 && keys[order[size - 1]] == null) {
--size;
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/GLUmesh.java 0000644 0001750 0001750 00000010776 11543426510 023773 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
class GLUmesh {
GLUvertex vHead = new GLUvertex(); /* dummy header for vertex list */
GLUface fHead = new GLUface(); /* dummy header for face list */
GLUhalfEdge eHead = new GLUhalfEdge(true); /* dummy header for edge list */
GLUhalfEdge eHeadSym = new GLUhalfEdge(false); /* and its symmetric counterpart */
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/GLUhalfEdge.java 0000644 0001750 0001750 00000011544 11543426510 024530 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
class GLUhalfEdge {
public GLUhalfEdge next; /* doubly-linked list (prev==Sym->next) */
public GLUhalfEdge Sym; /* same edge, opposite direction */
public GLUhalfEdge Onext; /* next edge CCW around origin */
public GLUhalfEdge Lnext; /* next edge CCW around left face */
public GLUvertex Org; /* origin vertex (Overtex too long) */
public GLUface Lface; /* left face */
/* Internal data (keep hidden) */
public ActiveRegion activeRegion; /* a region with this upper edge (sweep.c) */
public int winding; /* change in winding number when crossing */
public boolean first;
GLUhalfEdge(boolean first) {
this.first = first;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/TessMono.java 0000644 0001750 0001750 00000024477 11543426510 024241 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
class TessMono {
/* __gl_meshTessellateMonoRegion( face ) tessellates a monotone region
* (what else would it do??) The region must consist of a single
* loop of half-edges (see mesh.h) oriented CCW. "Monotone" in this
* case means that any vertical line intersects the interior of the
* region in a single interval.
*
* Tessellation consists of adding interior edges (actually pairs of
* half-edges), to split the region into non-overlapping triangles.
*
* The basic idea is explained in Preparata and Shamos (which I don''t
* have handy right now), although their implementation is more
* complicated than this one. The are two edge chains, an upper chain
* and a lower chain. We process all vertices from both chains in order,
* from right to left.
*
* The algorithm ensures that the following invariant holds after each
* vertex is processed: the untessellated region consists of two
* chains, where one chain (say the upper) is a single edge, and
* the other chain is concave. The left vertex of the single edge
* is always to the left of all vertices in the concave chain.
*
* Each step consists of adding the rightmost unprocessed vertex to one
* of the two chains, and forming a fan of triangles from the rightmost
* of two chain endpoints. Determining whether we can add each triangle
* to the fan is a simple orientation test. By making the fan as large
* as possible, we restore the invariant (check it yourself).
*/
static boolean __gl_meshTessellateMonoRegion(GLUface face) {
GLUhalfEdge up, lo;
/* All edges are oriented CCW around the boundary of the region.
* First, find the half-edge whose origin vertex is rightmost.
* Since the sweep goes from left to right, face->anEdge should
* be close to the edge we want.
*/
up = face.anEdge;
assert (up.Lnext != up && up.Lnext.Lnext != up);
for (; Geom.VertLeq(up.Sym.Org, up.Org); up = up.Onext.Sym)
;
for (; Geom.VertLeq(up.Org, up.Sym.Org); up = up.Lnext)
;
lo = up.Onext.Sym;
while (up.Lnext != lo) {
if (Geom.VertLeq(up.Sym.Org, lo.Org)) {
/* up.Sym.Org is on the left. It is safe to form triangles from lo.Org.
* The EdgeGoesLeft test guarantees progress even when some triangles
* are CW, given that the upper and lower chains are truly monotone.
*/
while (lo.Lnext != up && (Geom.EdgeGoesLeft(lo.Lnext)
|| Geom.EdgeSign(lo.Org, lo.Sym.Org, lo.Lnext.Sym.Org) <= 0)) {
GLUhalfEdge tempHalfEdge = Mesh.__gl_meshConnect(lo.Lnext, lo);
if (tempHalfEdge == null) return false;
lo = tempHalfEdge.Sym;
}
lo = lo.Onext.Sym;
} else {
/* lo.Org is on the left. We can make CCW triangles from up.Sym.Org. */
while (lo.Lnext != up && (Geom.EdgeGoesRight(up.Onext.Sym)
|| Geom.EdgeSign(up.Sym.Org, up.Org, up.Onext.Sym.Org) >= 0)) {
GLUhalfEdge tempHalfEdge = Mesh.__gl_meshConnect(up, up.Onext.Sym);
if (tempHalfEdge == null) return false;
up = tempHalfEdge.Sym;
}
up = up.Lnext;
}
}
/* Now lo.Org == up.Sym.Org == the leftmost vertex. The remaining region
* can be tessellated in a fan from this leftmost vertex.
*/
assert (lo.Lnext != up);
while (lo.Lnext.Lnext != up) {
GLUhalfEdge tempHalfEdge = Mesh.__gl_meshConnect(lo.Lnext, lo);
if (tempHalfEdge == null) return false;
lo = tempHalfEdge.Sym;
}
return true;
}
/* __gl_meshTessellateInterior( mesh ) tessellates each region of
* the mesh which is marked "inside" the polygon. Each such region
* must be monotone.
*/
public static boolean __gl_meshTessellateInterior(GLUmesh mesh) {
GLUface f, next;
/*LINTED*/
for (f = mesh.fHead.next; f != mesh.fHead; f = next) {
/* Make sure we don''t try to tessellate the new triangles. */
next = f.next;
if (f.inside) {
if (!__gl_meshTessellateMonoRegion(f)) return false;
}
}
return true;
}
/* __gl_meshDiscardExterior( mesh ) zaps (ie. sets to NULL) all faces
* which are not marked "inside" the polygon. Since further mesh operations
* on NULL faces are not allowed, the main purpose is to clean up the
* mesh so that exterior loops are not represented in the data structure.
*/
public static void __gl_meshDiscardExterior(GLUmesh mesh) {
GLUface f, next;
/*LINTED*/
for (f = mesh.fHead.next; f != mesh.fHead; f = next) {
/* Since f will be destroyed, save its next pointer. */
next = f.next;
if (!f.inside) {
Mesh.__gl_meshZapFace(f);
}
}
}
// private static final int MARKED_FOR_DELETION = 0x7fffffff;
/* __gl_meshSetWindingNumber( mesh, value, keepOnlyBoundary ) resets the
* winding numbers on all edges so that regions marked "inside" the
* polygon have a winding number of "value", and regions outside
* have a winding number of 0.
*
* If keepOnlyBoundary is TRUE, it also deletes all edges which do not
* separate an interior region from an exterior one.
*/
public static boolean __gl_meshSetWindingNumber(GLUmesh mesh, int value, boolean keepOnlyBoundary) {
GLUhalfEdge e, eNext;
for (e = mesh.eHead.next; e != mesh.eHead; e = eNext) {
eNext = e.next;
if (e.Sym.Lface.inside != e.Lface.inside) {
/* This is a boundary edge (one side is interior, one is exterior). */
e.winding = (e.Lface.inside) ? value : -value;
} else {
/* Both regions are interior, or both are exterior. */
if (!keepOnlyBoundary) {
e.winding = 0;
} else {
if (!Mesh.__gl_meshDelete(e)) return false;
}
}
}
return true;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/GLUface.java 0000644 0001750 0001750 00000011241 11543426510 023721 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
class GLUface {
public GLUface next; /* next face (never NULL) */
public GLUface prev; /* previous face (never NULL) */
public GLUhalfEdge anEdge; /* a half edge with this left face */
public Object data; /* room for client's data */
/* Internal data (keep hidden) */
public GLUface trail; /* "stack" for conversion to strips */
public boolean marked; /* flag for conversion to strips */
public boolean inside; /* this face is in the polygon interior */
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/Normal.java 0000644 0001750 0001750 00000026662 11543426510 023720 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
import org.lwjgl.util.glu.GLU;
class Normal {
private Normal() {
}
static boolean SLANTED_SWEEP;
static double S_UNIT_X; /* Pre-normalized */
static double S_UNIT_Y;
private static final boolean TRUE_PROJECT = false;
static {
if (SLANTED_SWEEP) {
/* The "feature merging" is not intended to be complete. There are
* special cases where edges are nearly parallel to the sweep line
* which are not implemented. The algorithm should still behave
* robustly (ie. produce a reasonable tesselation) in the presence
* of such edges, however it may miss features which could have been
* merged. We could minimize this effect by choosing the sweep line
* direction to be something unusual (ie. not parallel to one of the
* coordinate axes).
*/
S_UNIT_X = 0.50941539564955385; /* Pre-normalized */
S_UNIT_Y = 0.86052074622010633;
} else {
S_UNIT_X = 1.0;
S_UNIT_Y = 0.0;
}
}
private static double Dot(double[] u, double[] v) {
return (u[0] * v[0] + u[1] * v[1] + u[2] * v[2]);
}
static void Normalize(double[] v) {
double len = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
assert (len > 0);
len = Math.sqrt(len);
v[0] /= len;
v[1] /= len;
v[2] /= len;
}
static int LongAxis(double[] v) {
int i = 0;
if (Math.abs(v[1]) > Math.abs(v[0])) {
i = 1;
}
if (Math.abs(v[2]) > Math.abs(v[i])) {
i = 2;
}
return i;
}
static void ComputeNormal(GLUtessellatorImpl tess, double[] norm) {
GLUvertex v, v1, v2;
double c, tLen2, maxLen2;
double[] maxVal, minVal, d1, d2, tNorm;
GLUvertex[] maxVert, minVert;
GLUvertex vHead = tess.mesh.vHead;
int i;
maxVal = new double[3];
minVal = new double[3];
minVert = new GLUvertex[3];
maxVert = new GLUvertex[3];
d1 = new double[3];
d2 = new double[3];
tNorm = new double[3];
maxVal[0] = maxVal[1] = maxVal[2] = -2 * GLU.TESS_MAX_COORD;
minVal[0] = minVal[1] = minVal[2] = 2 * GLU.TESS_MAX_COORD;
for (v = vHead.next; v != vHead; v = v.next) {
for (i = 0; i < 3; ++i) {
c = v.coords[i];
if (c < minVal[i]) {
minVal[i] = c;
minVert[i] = v;
}
if (c > maxVal[i]) {
maxVal[i] = c;
maxVert[i] = v;
}
}
}
/* Find two vertices separated by at least 1/sqrt(3) of the maximum
* distance between any two vertices
*/
i = 0;
if (maxVal[1] - minVal[1] > maxVal[0] - minVal[0]) {
i = 1;
}
if (maxVal[2] - minVal[2] > maxVal[i] - minVal[i]) {
i = 2;
}
if (minVal[i] >= maxVal[i]) {
/* All vertices are the same -- normal doesn't matter */
norm[0] = 0;
norm[1] = 0;
norm[2] = 1;
return;
}
/* Look for a third vertex which forms the triangle with maximum area
* (Length of normal == twice the triangle area)
*/
maxLen2 = 0;
v1 = minVert[i];
v2 = maxVert[i];
d1[0] = v1.coords[0] - v2.coords[0];
d1[1] = v1.coords[1] - v2.coords[1];
d1[2] = v1.coords[2] - v2.coords[2];
for (v = vHead.next; v != vHead; v = v.next) {
d2[0] = v.coords[0] - v2.coords[0];
d2[1] = v.coords[1] - v2.coords[1];
d2[2] = v.coords[2] - v2.coords[2];
tNorm[0] = d1[1] * d2[2] - d1[2] * d2[1];
tNorm[1] = d1[2] * d2[0] - d1[0] * d2[2];
tNorm[2] = d1[0] * d2[1] - d1[1] * d2[0];
tLen2 = tNorm[0] * tNorm[0] + tNorm[1] * tNorm[1] + tNorm[2] * tNorm[2];
if (tLen2 > maxLen2) {
maxLen2 = tLen2;
norm[0] = tNorm[0];
norm[1] = tNorm[1];
norm[2] = tNorm[2];
}
}
if (maxLen2 <= 0) {
/* All points lie on a single line -- any decent normal will do */
norm[0] = norm[1] = norm[2] = 0;
norm[LongAxis(d1)] = 1;
}
}
static void CheckOrientation(GLUtessellatorImpl tess) {
double area;
GLUface f, fHead = tess.mesh.fHead;
GLUvertex v, vHead = tess.mesh.vHead;
GLUhalfEdge e;
/* When we compute the normal automatically, we choose the orientation
* so that the the sum of the signed areas of all contours is non-negative.
*/
area = 0;
for (f = fHead.next; f != fHead; f = f.next) {
e = f.anEdge;
if (e.winding <= 0) continue;
do {
area += (e.Org.s - e.Sym.Org.s) * (e.Org.t + e.Sym.Org.t);
e = e.Lnext;
} while (e != f.anEdge);
}
if (area < 0) {
/* Reverse the orientation by flipping all the t-coordinates */
for (v = vHead.next; v != vHead; v = v.next) {
v.t = -v.t;
}
tess.tUnit[0] = -tess.tUnit[0];
tess.tUnit[1] = -tess.tUnit[1];
tess.tUnit[2] = -tess.tUnit[2];
}
}
/* Determine the polygon normal and project vertices onto the plane
* of the polygon.
*/
public static void __gl_projectPolygon(GLUtessellatorImpl tess) {
GLUvertex v, vHead = tess.mesh.vHead;
double w;
double[] norm = new double[3];
double[] sUnit, tUnit;
int i;
boolean computedNormal = false;
norm[0] = tess.normal[0];
norm[1] = tess.normal[1];
norm[2] = tess.normal[2];
if (norm[0] == 0 && norm[1] == 0 && norm[2] == 0) {
ComputeNormal(tess, norm);
computedNormal = true;
}
sUnit = tess.sUnit;
tUnit = tess.tUnit;
i = LongAxis(norm);
if (TRUE_PROJECT) {
/* Choose the initial sUnit vector to be approximately perpendicular
* to the normal.
*/
Normalize(norm);
sUnit[i] = 0;
sUnit[(i + 1) % 3] = S_UNIT_X;
sUnit[(i + 2) % 3] = S_UNIT_Y;
/* Now make it exactly perpendicular */
w = Dot(sUnit, norm);
sUnit[0] -= w * norm[0];
sUnit[1] -= w * norm[1];
sUnit[2] -= w * norm[2];
Normalize(sUnit);
/* Choose tUnit so that (sUnit,tUnit,norm) form a right-handed frame */
tUnit[0] = norm[1] * sUnit[2] - norm[2] * sUnit[1];
tUnit[1] = norm[2] * sUnit[0] - norm[0] * sUnit[2];
tUnit[2] = norm[0] * sUnit[1] - norm[1] * sUnit[0];
Normalize(tUnit);
} else {
/* Project perpendicular to a coordinate axis -- better numerically */
sUnit[i] = 0;
sUnit[(i + 1) % 3] = S_UNIT_X;
sUnit[(i + 2) % 3] = S_UNIT_Y;
tUnit[i] = 0;
tUnit[(i + 1) % 3] = (norm[i] > 0) ? -S_UNIT_Y : S_UNIT_Y;
tUnit[(i + 2) % 3] = (norm[i] > 0) ? S_UNIT_X : -S_UNIT_X;
}
/* Project the vertices onto the sweep plane */
for (v = vHead.next; v != vHead; v = v.next) {
v.s = Dot(v.coords, sUnit);
v.t = Dot(v.coords, tUnit);
}
if (computedNormal) {
CheckOrientation(tess);
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/Dict.java 0000644 0001750 0001750 00000014135 11543426510 023343 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
class Dict {
DictNode head;
Object frame;
DictLeq leq;
private Dict() {
}
static Dict dictNewDict(Object frame, DictLeq leq) {
Dict dict = new Dict();
dict.head = new DictNode();
dict.head.key = null;
dict.head.next = dict.head;
dict.head.prev = dict.head;
dict.frame = frame;
dict.leq = leq;
return dict;
}
static void dictDeleteDict(Dict dict) {
dict.head = null;
dict.frame = null;
dict.leq = null;
}
static DictNode dictInsert(Dict dict, Object key) {
return dictInsertBefore(dict, dict.head, key);
}
static DictNode dictInsertBefore(Dict dict, DictNode node, Object key) {
do {
node = node.prev;
} while (node.key != null && !dict.leq.leq(dict.frame, node.key, key));
DictNode newNode = new DictNode();
newNode.key = key;
newNode.next = node.next;
node.next.prev = newNode;
newNode.prev = node;
node.next = newNode;
return newNode;
}
static Object dictKey(DictNode aNode) {
return aNode.key;
}
static DictNode dictSucc(DictNode aNode) {
return aNode.next;
}
static DictNode dictPred(DictNode aNode) {
return aNode.prev;
}
static DictNode dictMin(Dict aDict) {
return aDict.head.next;
}
static DictNode dictMax(Dict aDict) {
return aDict.head.prev;
}
static void dictDelete(Dict dict, DictNode node) {
node.next.prev = node.prev;
node.prev.next = node.next;
}
static DictNode dictSearch(Dict dict, Object key) {
DictNode node = dict.head;
do {
node = node.next;
} while (node.key != null && !(dict.leq.leq(dict.frame, key, node.key)));
return node;
}
public interface DictLeq {
boolean leq(Object frame, Object key1, Object key2);
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/PriorityQ.java 0000644 0001750 0001750 00000012276 11543426510 024426 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
abstract class PriorityQ {
public static final int INIT_SIZE = 32;
public static class PQnode {
int handle;
}
public static class PQhandleElem {
Object key;
int node;
}
public interface Leq {
boolean leq(Object key1, Object key2);
}
// #ifdef FOR_TRITE_TEST_PROGRAM
// private static boolean LEQ(PriorityQCommon.Leq leq, Object x,Object y) {
// return pq.leq.leq(x,y);
// }
// #else
/* Violates modularity, but a little faster */
// #include "geom.h"
public static boolean LEQ(Leq leq, Object x, Object y) {
return Geom.VertLeq((GLUvertex) x, (GLUvertex) y);
}
static PriorityQ pqNewPriorityQ(Leq leq) {
return new PriorityQSort(leq);
}
abstract void pqDeletePriorityQ();
abstract boolean pqInit();
abstract int pqInsert(Object keyNew);
abstract Object pqExtractMin();
abstract void pqDelete(int hCurr);
abstract Object pqMinimum();
abstract boolean pqIsEmpty();
// #endif
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/Sweep.java 0000644 0001750 0001750 00000162462 11543426510 023552 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
import static org.lwjgl.util.glu.GLU.*;
class Sweep {
private Sweep() {
}
// #ifdef FOR_TRITE_TEST_PROGRAM
// extern void DebugEvent( GLUtessellator *tess );
// #else
private static void DebugEvent(GLUtessellatorImpl tess) {
}
// #endif
/*
* Invariants for the Edge Dictionary.
* - each pair of adjacent edges e2=Succ(e1) satisfies EdgeLeq(e1,e2)
* at any valid location of the sweep event
* - if EdgeLeq(e2,e1) as well (at any valid sweep event), then e1 and e2
* share a common endpoint
* - for each e, e.Dst has been processed, but not e.Org
* - each edge e satisfies VertLeq(e.Dst,event) && VertLeq(event,e.Org)
* where "event" is the current sweep line event.
* - no edge e has zero length
*
* Invariants for the Mesh (the processed portion).
* - the portion of the mesh left of the sweep line is a planar graph,
* ie. there is *some* way to embed it in the plane
* - no processed edge has zero length
* - no two processed vertices have identical coordinates
* - each "inside" region is monotone, ie. can be broken into two chains
* of monotonically increasing vertices according to VertLeq(v1,v2)
* - a non-invariant: these chains may intersect (very slightly)
*
* Invariants for the Sweep.
* - if none of the edges incident to the event vertex have an activeRegion
* (ie. none of these edges are in the edge dictionary), then the vertex
* has only right-going edges.
* - if an edge is marked "fixUpperEdge" (it is a temporary edge introduced
* by ConnectRightVertex), then it is the only right-going edge from
* its associated vertex. (This says that these edges exist only
* when it is necessary.)
*/
/* When we merge two edges into one, we need to compute the combined
* winding of the new edge.
*/
private static void AddWinding(GLUhalfEdge eDst, GLUhalfEdge eSrc) {
eDst.winding += eSrc.winding;
eDst.Sym.winding += eSrc.Sym.winding;
}
private static ActiveRegion RegionBelow(ActiveRegion r) {
return ((ActiveRegion) Dict.dictKey(Dict.dictPred(r.nodeUp)));
}
private static ActiveRegion RegionAbove(ActiveRegion r) {
return ((ActiveRegion) Dict.dictKey(Dict.dictSucc(r.nodeUp)));
}
static boolean EdgeLeq(GLUtessellatorImpl tess, ActiveRegion reg1, ActiveRegion reg2)
/*
* Both edges must be directed from right to left (this is the canonical
* direction for the upper edge of each region).
*
* The strategy is to evaluate a "t" value for each edge at the
* current sweep line position, given by tess.event. The calculations
* are designed to be very stable, but of course they are not perfect.
*
* Special case: if both edge destinations are at the sweep event,
* we sort the edges by slope (they would otherwise compare equally).
*/ {
GLUvertex event = tess.event;
GLUhalfEdge e1, e2;
double t1, t2;
e1 = reg1.eUp;
e2 = reg2.eUp;
if (e1.Sym.Org == event) {
if (e2.Sym.Org == event) {
/* Two edges right of the sweep line which meet at the sweep event.
* Sort them by slope.
*/
if (Geom.VertLeq(e1.Org, e2.Org)) {
return Geom.EdgeSign(e2.Sym.Org, e1.Org, e2.Org) <= 0;
}
return Geom.EdgeSign(e1.Sym.Org, e2.Org, e1.Org) >= 0;
}
return Geom.EdgeSign(e2.Sym.Org, event, e2.Org) <= 0;
}
if (e2.Sym.Org == event) {
return Geom.EdgeSign(e1.Sym.Org, event, e1.Org) >= 0;
}
/* General case - compute signed distance *from* e1, e2 to event */
t1 = Geom.EdgeEval(e1.Sym.Org, event, e1.Org);
t2 = Geom.EdgeEval(e2.Sym.Org, event, e2.Org);
return (t1 >= t2);
}
static void DeleteRegion(GLUtessellatorImpl tess, ActiveRegion reg) {
if (reg.fixUpperEdge) {
/* It was created with zero winding number, so it better be
* deleted with zero winding number (ie. it better not get merged
* with a real edge).
*/
assert (reg.eUp.winding == 0);
}
reg.eUp.activeRegion = null;
Dict.dictDelete(tess.dict, reg.nodeUp); /* __gl_dictListDelete */
}
static boolean FixUpperEdge(ActiveRegion reg, GLUhalfEdge newEdge)
/*
* Replace an upper edge which needs fixing (see ConnectRightVertex).
*/ {
assert (reg.fixUpperEdge);
if (!Mesh.__gl_meshDelete(reg.eUp)) return false;
reg.fixUpperEdge = false;
reg.eUp = newEdge;
newEdge.activeRegion = reg;
return true;
}
static ActiveRegion TopLeftRegion(ActiveRegion reg) {
GLUvertex org = reg.eUp.Org;
GLUhalfEdge e;
/* Find the region above the uppermost edge with the same origin */
do {
reg = RegionAbove(reg);
} while (reg.eUp.Org == org);
/* If the edge above was a temporary edge introduced by ConnectRightVertex,
* now is the time to fix it.
*/
if (reg.fixUpperEdge) {
e = Mesh.__gl_meshConnect(RegionBelow(reg).eUp.Sym, reg.eUp.Lnext);
if (e == null) return null;
if (!FixUpperEdge(reg, e)) return null;
reg = RegionAbove(reg);
}
return reg;
}
static ActiveRegion TopRightRegion(ActiveRegion reg) {
GLUvertex dst = reg.eUp.Sym.Org;
/* Find the region above the uppermost edge with the same destination */
do {
reg = RegionAbove(reg);
} while (reg.eUp.Sym.Org == dst);
return reg;
}
static ActiveRegion AddRegionBelow(GLUtessellatorImpl tess,
ActiveRegion regAbove,
GLUhalfEdge eNewUp)
/*
* Add a new active region to the sweep line, *somewhere* below "regAbove"
* (according to where the new edge belongs in the sweep-line dictionary).
* The upper edge of the new region will be "eNewUp".
* Winding number and "inside" flag are not updated.
*/ {
ActiveRegion regNew = new ActiveRegion();
if (regNew == null) throw new RuntimeException();
regNew.eUp = eNewUp;
/* __gl_dictListInsertBefore */
regNew.nodeUp = Dict.dictInsertBefore(tess.dict, regAbove.nodeUp, regNew);
if (regNew.nodeUp == null) throw new RuntimeException();
regNew.fixUpperEdge = false;
regNew.sentinel = false;
regNew.dirty = false;
eNewUp.activeRegion = regNew;
return regNew;
}
static boolean IsWindingInside(GLUtessellatorImpl tess, int n) {
switch (tess.windingRule) {
case GLU_TESS_WINDING_ODD:
return (n & 1) != 0;
case GLU_TESS_WINDING_NONZERO:
return (n != 0);
case GLU_TESS_WINDING_POSITIVE:
return (n > 0);
case GLU_TESS_WINDING_NEGATIVE:
return (n < 0);
case GLU_TESS_WINDING_ABS_GEQ_TWO:
return (n >= 2) || (n <= -2);
}
/*LINTED*/
// assert (false);
throw new InternalError();
/*NOTREACHED*/
}
static void ComputeWinding(GLUtessellatorImpl tess, ActiveRegion reg) {
reg.windingNumber = RegionAbove(reg).windingNumber + reg.eUp.winding;
reg.inside = IsWindingInside(tess, reg.windingNumber);
}
static void FinishRegion(GLUtessellatorImpl tess, ActiveRegion reg)
/*
* Delete a region from the sweep line. This happens when the upper
* and lower chains of a region meet (at a vertex on the sweep line).
* The "inside" flag is copied to the appropriate mesh face (we could
* not do this before -- since the structure of the mesh is always
* changing, this face may not have even existed until now).
*/ {
GLUhalfEdge e = reg.eUp;
GLUface f = e.Lface;
f.inside = reg.inside;
f.anEdge = e; /* optimization for __gl_meshTessellateMonoRegion() */
DeleteRegion(tess, reg);
}
static GLUhalfEdge FinishLeftRegions(GLUtessellatorImpl tess,
ActiveRegion regFirst, ActiveRegion regLast)
/*
* We are given a vertex with one or more left-going edges. All affected
* edges should be in the edge dictionary. Starting at regFirst.eUp,
* we walk down deleting all regions where both edges have the same
* origin vOrg. At the same time we copy the "inside" flag from the
* active region to the face, since at this point each face will belong
* to at most one region (this was not necessarily true until this point
* in the sweep). The walk stops at the region above regLast; if regLast
* is null we walk as far as possible. At the same time we relink the
* mesh if necessary, so that the ordering of edges around vOrg is the
* same as in the dictionary.
*/ {
ActiveRegion reg, regPrev;
GLUhalfEdge e, ePrev;
regPrev = regFirst;
ePrev = regFirst.eUp;
while (regPrev != regLast) {
regPrev.fixUpperEdge = false; /* placement was OK */
reg = RegionBelow(regPrev);
e = reg.eUp;
if (e.Org != ePrev.Org) {
if (!reg.fixUpperEdge) {
/* Remove the last left-going edge. Even though there are no further
* edges in the dictionary with this origin, there may be further
* such edges in the mesh (if we are adding left edges to a vertex
* that has already been processed). Thus it is important to call
* FinishRegion rather than just DeleteRegion.
*/
FinishRegion(tess, regPrev);
break;
}
/* If the edge below was a temporary edge introduced by
* ConnectRightVertex, now is the time to fix it.
*/
e = Mesh.__gl_meshConnect(ePrev.Onext.Sym, e.Sym);
if (e == null) throw new RuntimeException();
if (!FixUpperEdge(reg, e)) throw new RuntimeException();
}
/* Relink edges so that ePrev.Onext == e */
if (ePrev.Onext != e) {
if (!Mesh.__gl_meshSplice(e.Sym.Lnext, e)) throw new RuntimeException();
if (!Mesh.__gl_meshSplice(ePrev, e)) throw new RuntimeException();
}
FinishRegion(tess, regPrev); /* may change reg.eUp */
ePrev = reg.eUp;
regPrev = reg;
}
return ePrev;
}
static void AddRightEdges(GLUtessellatorImpl tess, ActiveRegion regUp,
GLUhalfEdge eFirst, GLUhalfEdge eLast, GLUhalfEdge eTopLeft,
boolean cleanUp)
/*
* Purpose: insert right-going edges into the edge dictionary, and update
* winding numbers and mesh connectivity appropriately. All right-going
* edges share a common origin vOrg. Edges are inserted CCW starting at
* eFirst; the last edge inserted is eLast.Sym.Lnext. If vOrg has any
* left-going edges already processed, then eTopLeft must be the edge
* such that an imaginary upward vertical segment from vOrg would be
* contained between eTopLeft.Sym.Lnext and eTopLeft; otherwise eTopLeft
* should be null.
*/ {
ActiveRegion reg, regPrev;
GLUhalfEdge e, ePrev;
boolean firstTime = true;
/* Insert the new right-going edges in the dictionary */
e = eFirst;
do {
assert (Geom.VertLeq(e.Org, e.Sym.Org));
AddRegionBelow(tess, regUp, e.Sym);
e = e.Onext;
} while (e != eLast);
/* Walk *all* right-going edges from e.Org, in the dictionary order,
* updating the winding numbers of each region, and re-linking the mesh
* edges to match the dictionary ordering (if necessary).
*/
if (eTopLeft == null) {
eTopLeft = RegionBelow(regUp).eUp.Sym.Onext;
}
regPrev = regUp;
ePrev = eTopLeft;
for (; ;) {
reg = RegionBelow(regPrev);
e = reg.eUp.Sym;
if (e.Org != ePrev.Org) break;
if (e.Onext != ePrev) {
/* Unlink e from its current position, and relink below ePrev */
if (!Mesh.__gl_meshSplice(e.Sym.Lnext, e)) throw new RuntimeException();
if (!Mesh.__gl_meshSplice(ePrev.Sym.Lnext, e)) throw new RuntimeException();
}
/* Compute the winding number and "inside" flag for the new regions */
reg.windingNumber = regPrev.windingNumber - e.winding;
reg.inside = IsWindingInside(tess, reg.windingNumber);
/* Check for two outgoing edges with same slope -- process these
* before any intersection tests (see example in __gl_computeInterior).
*/
regPrev.dirty = true;
if (!firstTime && CheckForRightSplice(tess, regPrev)) {
AddWinding(e, ePrev);
DeleteRegion(tess, regPrev);
if (!Mesh.__gl_meshDelete(ePrev)) throw new RuntimeException();
}
firstTime = false;
regPrev = reg;
ePrev = e;
}
regPrev.dirty = true;
assert (regPrev.windingNumber - e.winding == reg.windingNumber);
if (cleanUp) {
/* Check for intersections between newly adjacent edges. */
WalkDirtyRegions(tess, regPrev);
}
}
static void CallCombine(GLUtessellatorImpl tess, GLUvertex isect,
Object[] data, float[] weights, boolean needed) {
double[] coords = new double[3];
/* Copy coord data in case the callback changes it. */
coords[0] = isect.coords[0];
coords[1] = isect.coords[1];
coords[2] = isect.coords[2];
Object[] outData = new Object[1];
tess.callCombineOrCombineData(coords, data, weights, outData);
isect.data = outData[0];
if (isect.data == null) {
if (!needed) {
isect.data = data[0];
} else if (!tess.fatalError) {
/* The only way fatal error is when two edges are found to intersect,
* but the user has not provided the callback necessary to handle
* generated intersection points.
*/
tess.callErrorOrErrorData(GLU_TESS_NEED_COMBINE_CALLBACK);
tess.fatalError = true;
}
}
}
static void SpliceMergeVertices(GLUtessellatorImpl tess, GLUhalfEdge e1,
GLUhalfEdge e2)
/*
* Two vertices with idential coordinates are combined into one.
* e1.Org is kept, while e2.Org is discarded.
*/ {
Object[] data = new Object[4];
float[] weights = new float[]{0.5f, 0.5f, 0.0f, 0.0f};
data[0] = e1.Org.data;
data[1] = e2.Org.data;
CallCombine(tess, e1.Org, data, weights, false);
if (!Mesh.__gl_meshSplice(e1, e2)) throw new RuntimeException();
}
static void VertexWeights(GLUvertex isect, GLUvertex org, GLUvertex dst,
float[] weights)
/*
* Find some weights which describe how the intersection vertex is
* a linear combination of "org" and "dest". Each of the two edges
* which generated "isect" is allocated 50% of the weight; each edge
* splits the weight between its org and dst according to the
* relative distance to "isect".
*/ {
double t1 = Geom.VertL1dist(org, isect);
double t2 = Geom.VertL1dist(dst, isect);
weights[0] = (float) (0.5 * t2 / (t1 + t2));
weights[1] = (float) (0.5 * t1 / (t1 + t2));
isect.coords[0] += weights[0] * org.coords[0] + weights[1] * dst.coords[0];
isect.coords[1] += weights[0] * org.coords[1] + weights[1] * dst.coords[1];
isect.coords[2] += weights[0] * org.coords[2] + weights[1] * dst.coords[2];
}
static void GetIntersectData(GLUtessellatorImpl tess, GLUvertex isect,
GLUvertex orgUp, GLUvertex dstUp,
GLUvertex orgLo, GLUvertex dstLo)
/*
* We've computed a new intersection point, now we need a "data" pointer
* from the user so that we can refer to this new vertex in the
* rendering callbacks.
*/ {
Object[] data = new Object[4];
float[] weights = new float[4];
float[] weights1 = new float[2];
float[] weights2 = new float[2];
data[0] = orgUp.data;
data[1] = dstUp.data;
data[2] = orgLo.data;
data[3] = dstLo.data;
isect.coords[0] = isect.coords[1] = isect.coords[2] = 0;
VertexWeights(isect, orgUp, dstUp, weights1);
VertexWeights(isect, orgLo, dstLo, weights2);
System.arraycopy(weights1, 0, weights, 0, 2);
System.arraycopy(weights2, 0, weights, 2, 2);
CallCombine(tess, isect, data, weights, true);
}
static boolean CheckForRightSplice(GLUtessellatorImpl tess, ActiveRegion regUp)
/*
* Check the upper and lower edge of "regUp", to make sure that the
* eUp.Org is above eLo, or eLo.Org is below eUp (depending on which
* origin is leftmost).
*
* The main purpose is to splice right-going edges with the same
* dest vertex and nearly identical slopes (ie. we can't distinguish
* the slopes numerically). However the splicing can also help us
* to recover from numerical errors. For example, suppose at one
* point we checked eUp and eLo, and decided that eUp.Org is barely
* above eLo. Then later, we split eLo into two edges (eg. from
* a splice operation like this one). This can change the result of
* our test so that now eUp.Org is incident to eLo, or barely below it.
* We must correct this condition to maintain the dictionary invariants.
*
* One possibility is to check these edges for intersection again
* (ie. CheckForIntersect). This is what we do if possible. However
* CheckForIntersect requires that tess.event lies between eUp and eLo,
* so that it has something to fall back on when the intersection
* calculation gives us an unusable answer. So, for those cases where
* we can't check for intersection, this routine fixes the problem
* by just splicing the offending vertex into the other edge.
* This is a guaranteed solution, no matter how degenerate things get.
* Basically this is a combinatorial solution to a numerical problem.
*/ {
ActiveRegion regLo = RegionBelow(regUp);
GLUhalfEdge eUp = regUp.eUp;
GLUhalfEdge eLo = regLo.eUp;
if (Geom.VertLeq(eUp.Org, eLo.Org)) {
if (Geom.EdgeSign(eLo.Sym.Org, eUp.Org, eLo.Org) > 0) return false;
/* eUp.Org appears to be below eLo */
if (!Geom.VertEq(eUp.Org, eLo.Org)) {
/* Splice eUp.Org into eLo */
if (Mesh.__gl_meshSplitEdge(eLo.Sym) == null) throw new RuntimeException();
if (!Mesh.__gl_meshSplice(eUp, eLo.Sym.Lnext)) throw new RuntimeException();
regUp.dirty = regLo.dirty = true;
} else if (eUp.Org != eLo.Org) {
/* merge the two vertices, discarding eUp.Org */
tess.pq.pqDelete(eUp.Org.pqHandle); /* __gl_pqSortDelete */
SpliceMergeVertices(tess, eLo.Sym.Lnext, eUp);
}
} else {
if (Geom.EdgeSign(eUp.Sym.Org, eLo.Org, eUp.Org) < 0) return false;
/* eLo.Org appears to be above eUp, so splice eLo.Org into eUp */
RegionAbove(regUp).dirty = regUp.dirty = true;
if (Mesh.__gl_meshSplitEdge(eUp.Sym) == null) throw new RuntimeException();
if (!Mesh.__gl_meshSplice(eLo.Sym.Lnext, eUp)) throw new RuntimeException();
}
return true;
}
static boolean CheckForLeftSplice(GLUtessellatorImpl tess, ActiveRegion regUp)
/*
* Check the upper and lower edge of "regUp", to make sure that the
* eUp.Sym.Org is above eLo, or eLo.Sym.Org is below eUp (depending on which
* destination is rightmost).
*
* Theoretically, this should always be true. However, splitting an edge
* into two pieces can change the results of previous tests. For example,
* suppose at one point we checked eUp and eLo, and decided that eUp.Sym.Org
* is barely above eLo. Then later, we split eLo into two edges (eg. from
* a splice operation like this one). This can change the result of
* the test so that now eUp.Sym.Org is incident to eLo, or barely below it.
* We must correct this condition to maintain the dictionary invariants
* (otherwise new edges might get inserted in the wrong place in the
* dictionary, and bad stuff will happen).
*
* We fix the problem by just splicing the offending vertex into the
* other edge.
*/ {
ActiveRegion regLo = RegionBelow(regUp);
GLUhalfEdge eUp = regUp.eUp;
GLUhalfEdge eLo = regLo.eUp;
GLUhalfEdge e;
assert (!Geom.VertEq(eUp.Sym.Org, eLo.Sym.Org));
if (Geom.VertLeq(eUp.Sym.Org, eLo.Sym.Org)) {
if (Geom.EdgeSign(eUp.Sym.Org, eLo.Sym.Org, eUp.Org) < 0) return false;
/* eLo.Sym.Org is above eUp, so splice eLo.Sym.Org into eUp */
RegionAbove(regUp).dirty = regUp.dirty = true;
e = Mesh.__gl_meshSplitEdge(eUp);
if (e == null) throw new RuntimeException();
if (!Mesh.__gl_meshSplice(eLo.Sym, e)) throw new RuntimeException();
e.Lface.inside = regUp.inside;
} else {
if (Geom.EdgeSign(eLo.Sym.Org, eUp.Sym.Org, eLo.Org) > 0) return false;
/* eUp.Sym.Org is below eLo, so splice eUp.Sym.Org into eLo */
regUp.dirty = regLo.dirty = true;
e = Mesh.__gl_meshSplitEdge(eLo);
if (e == null) throw new RuntimeException();
if (!Mesh.__gl_meshSplice(eUp.Lnext, eLo.Sym)) throw new RuntimeException();
e.Sym.Lface.inside = regUp.inside;
}
return true;
}
static boolean CheckForIntersect(GLUtessellatorImpl tess, ActiveRegion regUp)
/*
* Check the upper and lower edges of the given region to see if
* they intersect. If so, create the intersection and add it
* to the data structures.
*
* Returns true if adding the new intersection resulted in a recursive
* call to AddRightEdges(); in this case all "dirty" regions have been
* checked for intersections, and possibly regUp has been deleted.
*/ {
ActiveRegion regLo = RegionBelow(regUp);
GLUhalfEdge eUp = regUp.eUp;
GLUhalfEdge eLo = regLo.eUp;
GLUvertex orgUp = eUp.Org;
GLUvertex orgLo = eLo.Org;
GLUvertex dstUp = eUp.Sym.Org;
GLUvertex dstLo = eLo.Sym.Org;
double tMinUp, tMaxLo;
GLUvertex isect = new GLUvertex();
GLUvertex orgMin;
GLUhalfEdge e;
assert (!Geom.VertEq(dstLo, dstUp));
assert (Geom.EdgeSign(dstUp, tess.event, orgUp) <= 0);
assert (Geom.EdgeSign(dstLo, tess.event, orgLo) >= 0);
assert (orgUp != tess.event && orgLo != tess.event);
assert (!regUp.fixUpperEdge && !regLo.fixUpperEdge);
if (orgUp == orgLo) return false; /* right endpoints are the same */
tMinUp = Math.min(orgUp.t, dstUp.t);
tMaxLo = Math.max(orgLo.t, dstLo.t);
if (tMinUp > tMaxLo) return false; /* t ranges do not overlap */
if (Geom.VertLeq(orgUp, orgLo)) {
if (Geom.EdgeSign(dstLo, orgUp, orgLo) > 0) return false;
} else {
if (Geom.EdgeSign(dstUp, orgLo, orgUp) < 0) return false;
}
/* At this point the edges intersect, at least marginally */
DebugEvent(tess);
Geom.EdgeIntersect(dstUp, orgUp, dstLo, orgLo, isect);
/* The following properties are guaranteed: */
assert (Math.min(orgUp.t, dstUp.t) <= isect.t);
assert (isect.t <= Math.max(orgLo.t, dstLo.t));
assert (Math.min(dstLo.s, dstUp.s) <= isect.s);
assert (isect.s <= Math.max(orgLo.s, orgUp.s));
if (Geom.VertLeq(isect, tess.event)) {
/* The intersection point lies slightly to the left of the sweep line,
* so move it until it''s slightly to the right of the sweep line.
* (If we had perfect numerical precision, this would never happen
* in the first place). The easiest and safest thing to do is
* replace the intersection by tess.event.
*/
isect.s = tess.event.s;
isect.t = tess.event.t;
}
/* Similarly, if the computed intersection lies to the right of the
* rightmost origin (which should rarely happen), it can cause
* unbelievable inefficiency on sufficiently degenerate inputs.
* (If you have the test program, try running test54.d with the
* "X zoom" option turned on).
*/
orgMin = Geom.VertLeq(orgUp, orgLo) ? orgUp : orgLo;
if (Geom.VertLeq(orgMin, isect)) {
isect.s = orgMin.s;
isect.t = orgMin.t;
}
if (Geom.VertEq(isect, orgUp) || Geom.VertEq(isect, orgLo)) {
/* Easy case -- intersection at one of the right endpoints */
CheckForRightSplice(tess, regUp);
return false;
}
if ((!Geom.VertEq(dstUp, tess.event)
&& Geom.EdgeSign(dstUp, tess.event, isect) >= 0)
|| (!Geom.VertEq(dstLo, tess.event)
&& Geom.EdgeSign(dstLo, tess.event, isect) <= 0)) {
/* Very unusual -- the new upper or lower edge would pass on the
* wrong side of the sweep event, or through it. This can happen
* due to very small numerical errors in the intersection calculation.
*/
if (dstLo == tess.event) {
/* Splice dstLo into eUp, and process the new region(s) */
if (Mesh.__gl_meshSplitEdge(eUp.Sym) == null) throw new RuntimeException();
if (!Mesh.__gl_meshSplice(eLo.Sym, eUp)) throw new RuntimeException();
regUp = TopLeftRegion(regUp);
if (regUp == null) throw new RuntimeException();
eUp = RegionBelow(regUp).eUp;
FinishLeftRegions(tess, RegionBelow(regUp), regLo);
AddRightEdges(tess, regUp, eUp.Sym.Lnext, eUp, eUp, true);
return true;
}
if (dstUp == tess.event) {
/* Splice dstUp into eLo, and process the new region(s) */
if (Mesh.__gl_meshSplitEdge(eLo.Sym) == null) throw new RuntimeException();
if (!Mesh.__gl_meshSplice(eUp.Lnext, eLo.Sym.Lnext)) throw new RuntimeException();
regLo = regUp;
regUp = TopRightRegion(regUp);
e = RegionBelow(regUp).eUp.Sym.Onext;
regLo.eUp = eLo.Sym.Lnext;
eLo = FinishLeftRegions(tess, regLo, null);
AddRightEdges(tess, regUp, eLo.Onext, eUp.Sym.Onext, e, true);
return true;
}
/* Special case: called from ConnectRightVertex. If either
* edge passes on the wrong side of tess.event, split it
* (and wait for ConnectRightVertex to splice it appropriately).
*/
if (Geom.EdgeSign(dstUp, tess.event, isect) >= 0) {
RegionAbove(regUp).dirty = regUp.dirty = true;
if (Mesh.__gl_meshSplitEdge(eUp.Sym) == null) throw new RuntimeException();
eUp.Org.s = tess.event.s;
eUp.Org.t = tess.event.t;
}
if (Geom.EdgeSign(dstLo, tess.event, isect) <= 0) {
regUp.dirty = regLo.dirty = true;
if (Mesh.__gl_meshSplitEdge(eLo.Sym) == null) throw new RuntimeException();
eLo.Org.s = tess.event.s;
eLo.Org.t = tess.event.t;
}
/* leave the rest for ConnectRightVertex */
return false;
}
/* General case -- split both edges, splice into new vertex.
* When we do the splice operation, the order of the arguments is
* arbitrary as far as correctness goes. However, when the operation
* creates a new face, the work done is proportional to the size of
* the new face. We expect the faces in the processed part of
* the mesh (ie. eUp.Lface) to be smaller than the faces in the
* unprocessed original contours (which will be eLo.Sym.Lnext.Lface).
*/
if (Mesh.__gl_meshSplitEdge(eUp.Sym) == null) throw new RuntimeException();
if (Mesh.__gl_meshSplitEdge(eLo.Sym) == null) throw new RuntimeException();
if (!Mesh.__gl_meshSplice(eLo.Sym.Lnext, eUp)) throw new RuntimeException();
eUp.Org.s = isect.s;
eUp.Org.t = isect.t;
eUp.Org.pqHandle = tess.pq.pqInsert(eUp.Org); /* __gl_pqSortInsert */
if (eUp.Org.pqHandle == Long.MAX_VALUE) {
tess.pq.pqDeletePriorityQ(); /* __gl_pqSortDeletePriorityQ */
tess.pq = null;
throw new RuntimeException();
}
GetIntersectData(tess, eUp.Org, orgUp, dstUp, orgLo, dstLo);
RegionAbove(regUp).dirty = regUp.dirty = regLo.dirty = true;
return false;
}
static void WalkDirtyRegions(GLUtessellatorImpl tess, ActiveRegion regUp)
/*
* When the upper or lower edge of any region changes, the region is
* marked "dirty". This routine walks through all the dirty regions
* and makes sure that the dictionary invariants are satisfied
* (see the comments at the beginning of this file). Of course
* new dirty regions can be created as we make changes to restore
* the invariants.
*/ {
ActiveRegion regLo = RegionBelow(regUp);
GLUhalfEdge eUp, eLo;
for (; ;) {
/* Find the lowest dirty region (we walk from the bottom up). */
while (regLo.dirty) {
regUp = regLo;
regLo = RegionBelow(regLo);
}
if (!regUp.dirty) {
regLo = regUp;
regUp = RegionAbove(regUp);
if (regUp == null || !regUp.dirty) {
/* We've walked all the dirty regions */
return;
}
}
regUp.dirty = false;
eUp = regUp.eUp;
eLo = regLo.eUp;
if (eUp.Sym.Org != eLo.Sym.Org) {
/* Check that the edge ordering is obeyed at the Dst vertices. */
if (CheckForLeftSplice(tess, regUp)) {
/* If the upper or lower edge was marked fixUpperEdge, then
* we no longer need it (since these edges are needed only for
* vertices which otherwise have no right-going edges).
*/
if (regLo.fixUpperEdge) {
DeleteRegion(tess, regLo);
if (!Mesh.__gl_meshDelete(eLo)) throw new RuntimeException();
regLo = RegionBelow(regUp);
eLo = regLo.eUp;
} else if (regUp.fixUpperEdge) {
DeleteRegion(tess, regUp);
if (!Mesh.__gl_meshDelete(eUp)) throw new RuntimeException();
regUp = RegionAbove(regLo);
eUp = regUp.eUp;
}
}
}
if (eUp.Org != eLo.Org) {
if (eUp.Sym.Org != eLo.Sym.Org
&& !regUp.fixUpperEdge && !regLo.fixUpperEdge
&& (eUp.Sym.Org == tess.event || eLo.Sym.Org == tess.event)) {
/* When all else fails in CheckForIntersect(), it uses tess.event
* as the intersection location. To make this possible, it requires
* that tess.event lie between the upper and lower edges, and also
* that neither of these is marked fixUpperEdge (since in the worst
* case it might splice one of these edges into tess.event, and
* violate the invariant that fixable edges are the only right-going
* edge from their associated vertex).
*/
if (CheckForIntersect(tess, regUp)) {
/* WalkDirtyRegions() was called recursively; we're done */
return;
}
} else {
/* Even though we can't use CheckForIntersect(), the Org vertices
* may violate the dictionary edge ordering. Check and correct this.
*/
CheckForRightSplice(tess, regUp);
}
}
if (eUp.Org == eLo.Org && eUp.Sym.Org == eLo.Sym.Org) {
/* A degenerate loop consisting of only two edges -- delete it. */
AddWinding(eLo, eUp);
DeleteRegion(tess, regUp);
if (!Mesh.__gl_meshDelete(eUp)) throw new RuntimeException();
regUp = RegionAbove(regLo);
}
}
}
static void ConnectRightVertex(GLUtessellatorImpl tess, ActiveRegion regUp,
GLUhalfEdge eBottomLeft)
/*
* Purpose: connect a "right" vertex vEvent (one where all edges go left)
* to the unprocessed portion of the mesh. Since there are no right-going
* edges, two regions (one above vEvent and one below) are being merged
* into one. "regUp" is the upper of these two regions.
*
* There are two reasons for doing this (adding a right-going edge):
* - if the two regions being merged are "inside", we must add an edge
* to keep them separated (the combined region would not be monotone).
* - in any case, we must leave some record of vEvent in the dictionary,
* so that we can merge vEvent with features that we have not seen yet.
* For example, maybe there is a vertical edge which passes just to
* the right of vEvent; we would like to splice vEvent into this edge.
*
* However, we don't want to connect vEvent to just any vertex. We don''t
* want the new edge to cross any other edges; otherwise we will create
* intersection vertices even when the input data had no self-intersections.
* (This is a bad thing; if the user's input data has no intersections,
* we don't want to generate any false intersections ourselves.)
*
* Our eventual goal is to connect vEvent to the leftmost unprocessed
* vertex of the combined region (the union of regUp and regLo).
* But because of unseen vertices with all right-going edges, and also
* new vertices which may be created by edge intersections, we don''t
* know where that leftmost unprocessed vertex is. In the meantime, we
* connect vEvent to the closest vertex of either chain, and mark the region
* as "fixUpperEdge". This flag says to delete and reconnect this edge
* to the next processed vertex on the boundary of the combined region.
* Quite possibly the vertex we connected to will turn out to be the
* closest one, in which case we won''t need to make any changes.
*/ {
GLUhalfEdge eNew;
GLUhalfEdge eTopLeft = eBottomLeft.Onext;
ActiveRegion regLo = RegionBelow(regUp);
GLUhalfEdge eUp = regUp.eUp;
GLUhalfEdge eLo = regLo.eUp;
boolean degenerate = false;
if (eUp.Sym.Org != eLo.Sym.Org) {
CheckForIntersect(tess, regUp);
}
/* Possible new degeneracies: upper or lower edge of regUp may pass
* through vEvent, or may coincide with new intersection vertex
*/
if (Geom.VertEq(eUp.Org, tess.event)) {
if (!Mesh.__gl_meshSplice(eTopLeft.Sym.Lnext, eUp)) throw new RuntimeException();
regUp = TopLeftRegion(regUp);
if (regUp == null) throw new RuntimeException();
eTopLeft = RegionBelow(regUp).eUp;
FinishLeftRegions(tess, RegionBelow(regUp), regLo);
degenerate = true;
}
if (Geom.VertEq(eLo.Org, tess.event)) {
if (!Mesh.__gl_meshSplice(eBottomLeft, eLo.Sym.Lnext)) throw new RuntimeException();
eBottomLeft = FinishLeftRegions(tess, regLo, null);
degenerate = true;
}
if (degenerate) {
AddRightEdges(tess, regUp, eBottomLeft.Onext, eTopLeft, eTopLeft, true);
return;
}
/* Non-degenerate situation -- need to add a temporary, fixable edge.
* Connect to the closer of eLo.Org, eUp.Org.
*/
if (Geom.VertLeq(eLo.Org, eUp.Org)) {
eNew = eLo.Sym.Lnext;
} else {
eNew = eUp;
}
eNew = Mesh.__gl_meshConnect(eBottomLeft.Onext.Sym, eNew);
if (eNew == null) throw new RuntimeException();
/* Prevent cleanup, otherwise eNew might disappear before we've even
* had a chance to mark it as a temporary edge.
*/
AddRightEdges(tess, regUp, eNew, eNew.Onext, eNew.Onext, false);
eNew.Sym.activeRegion.fixUpperEdge = true;
WalkDirtyRegions(tess, regUp);
}
/* Because vertices at exactly the same location are merged together
* before we process the sweep event, some degenerate cases can't occur.
* However if someone eventually makes the modifications required to
* merge features which are close together, the cases below marked
* TOLERANCE_NONZERO will be useful. They were debugged before the
* code to merge identical vertices in the main loop was added.
*/
private static final boolean TOLERANCE_NONZERO = false;
static void ConnectLeftDegenerate(GLUtessellatorImpl tess,
ActiveRegion regUp, GLUvertex vEvent)
/*
* The event vertex lies exacty on an already-processed edge or vertex.
* Adding the new vertex involves splicing it into the already-processed
* part of the mesh.
*/ {
GLUhalfEdge e, eTopLeft, eTopRight, eLast;
ActiveRegion reg;
e = regUp.eUp;
if (Geom.VertEq(e.Org, vEvent)) {
/* e.Org is an unprocessed vertex - just combine them, and wait
* for e.Org to be pulled from the queue
*/
assert (TOLERANCE_NONZERO);
SpliceMergeVertices(tess, e, vEvent.anEdge);
return;
}
if (!Geom.VertEq(e.Sym.Org, vEvent)) {
/* General case -- splice vEvent into edge e which passes through it */
if (Mesh.__gl_meshSplitEdge(e.Sym) == null) throw new RuntimeException();
if (regUp.fixUpperEdge) {
/* This edge was fixable -- delete unused portion of original edge */
if (!Mesh.__gl_meshDelete(e.Onext)) throw new RuntimeException();
regUp.fixUpperEdge = false;
}
if (!Mesh.__gl_meshSplice(vEvent.anEdge, e)) throw new RuntimeException();
SweepEvent(tess, vEvent); /* recurse */
return;
}
/* vEvent coincides with e.Sym.Org, which has already been processed.
* Splice in the additional right-going edges.
*/
assert (TOLERANCE_NONZERO);
regUp = TopRightRegion(regUp);
reg = RegionBelow(regUp);
eTopRight = reg.eUp.Sym;
eTopLeft = eLast = eTopRight.Onext;
if (reg.fixUpperEdge) {
/* Here e.Sym.Org has only a single fixable edge going right.
* We can delete it since now we have some real right-going edges.
*/
assert (eTopLeft != eTopRight); /* there are some left edges too */
DeleteRegion(tess, reg);
if (!Mesh.__gl_meshDelete(eTopRight)) throw new RuntimeException();
eTopRight = eTopLeft.Sym.Lnext;
}
if (!Mesh.__gl_meshSplice(vEvent.anEdge, eTopRight)) throw new RuntimeException();
if (!Geom.EdgeGoesLeft(eTopLeft)) {
/* e.Sym.Org had no left-going edges -- indicate this to AddRightEdges() */
eTopLeft = null;
}
AddRightEdges(tess, regUp, eTopRight.Onext, eLast, eTopLeft, true);
}
static void ConnectLeftVertex(GLUtessellatorImpl tess, GLUvertex vEvent)
/*
* Purpose: connect a "left" vertex (one where both edges go right)
* to the processed portion of the mesh. Let R be the active region
* containing vEvent, and let U and L be the upper and lower edge
* chains of R. There are two possibilities:
*
* - the normal case: split R into two regions, by connecting vEvent to
* the rightmost vertex of U or L lying to the left of the sweep line
*
* - the degenerate case: if vEvent is close enough to U or L, we
* merge vEvent into that edge chain. The subcases are:
* - merging with the rightmost vertex of U or L
* - merging with the active edge of U or L
* - merging with an already-processed portion of U or L
*/ {
ActiveRegion regUp, regLo, reg;
GLUhalfEdge eUp, eLo, eNew;
ActiveRegion tmp = new ActiveRegion();
/* assert ( vEvent.anEdge.Onext.Onext == vEvent.anEdge ); */
/* Get a pointer to the active region containing vEvent */
tmp.eUp = vEvent.anEdge.Sym;
/* __GL_DICTLISTKEY */ /* __gl_dictListSearch */
regUp = (ActiveRegion) Dict.dictKey(Dict.dictSearch(tess.dict, tmp));
regLo = RegionBelow(regUp);
eUp = regUp.eUp;
eLo = regLo.eUp;
/* Try merging with U or L first */
if (Geom.EdgeSign(eUp.Sym.Org, vEvent, eUp.Org) == 0) {
ConnectLeftDegenerate(tess, regUp, vEvent);
return;
}
/* Connect vEvent to rightmost processed vertex of either chain.
* e.Sym.Org is the vertex that we will connect to vEvent.
*/
reg = Geom.VertLeq(eLo.Sym.Org, eUp.Sym.Org) ? regUp : regLo;
if (regUp.inside || reg.fixUpperEdge) {
if (reg == regUp) {
eNew = Mesh.__gl_meshConnect(vEvent.anEdge.Sym, eUp.Lnext);
if (eNew == null) throw new RuntimeException();
} else {
GLUhalfEdge tempHalfEdge = Mesh.__gl_meshConnect(eLo.Sym.Onext.Sym, vEvent.anEdge);
if (tempHalfEdge == null) throw new RuntimeException();
eNew = tempHalfEdge.Sym;
}
if (reg.fixUpperEdge) {
if (!FixUpperEdge(reg, eNew)) throw new RuntimeException();
} else {
ComputeWinding(tess, AddRegionBelow(tess, regUp, eNew));
}
SweepEvent(tess, vEvent);
} else {
/* The new vertex is in a region which does not belong to the polygon.
* We don''t need to connect this vertex to the rest of the mesh.
*/
AddRightEdges(tess, regUp, vEvent.anEdge, vEvent.anEdge, null, true);
}
}
static void SweepEvent(GLUtessellatorImpl tess, GLUvertex vEvent)
/*
* Does everything necessary when the sweep line crosses a vertex.
* Updates the mesh and the edge dictionary.
*/ {
ActiveRegion regUp, reg;
GLUhalfEdge e, eTopLeft, eBottomLeft;
tess.event = vEvent; /* for access in EdgeLeq() */
DebugEvent(tess);
/* Check if this vertex is the right endpoint of an edge that is
* already in the dictionary. In this case we don't need to waste
* time searching for the location to insert new edges.
*/
e = vEvent.anEdge;
while (e.activeRegion == null) {
e = e.Onext;
if (e == vEvent.anEdge) {
/* All edges go right -- not incident to any processed edges */
ConnectLeftVertex(tess, vEvent);
return;
}
}
/* Processing consists of two phases: first we "finish" all the
* active regions where both the upper and lower edges terminate
* at vEvent (ie. vEvent is closing off these regions).
* We mark these faces "inside" or "outside" the polygon according
* to their winding number, and delete the edges from the dictionary.
* This takes care of all the left-going edges from vEvent.
*/
regUp = TopLeftRegion(e.activeRegion);
if (regUp == null) throw new RuntimeException();
reg = RegionBelow(regUp);
eTopLeft = reg.eUp;
eBottomLeft = FinishLeftRegions(tess, reg, null);
/* Next we process all the right-going edges from vEvent. This
* involves adding the edges to the dictionary, and creating the
* associated "active regions" which record information about the
* regions between adjacent dictionary edges.
*/
if (eBottomLeft.Onext == eTopLeft) {
/* No right-going edges -- add a temporary "fixable" edge */
ConnectRightVertex(tess, regUp, eBottomLeft);
} else {
AddRightEdges(tess, regUp, eBottomLeft.Onext, eTopLeft, eTopLeft, true);
}
}
/* Make the sentinel coordinates big enough that they will never be
* merged with real input features. (Even with the largest possible
* input contour and the maximum tolerance of 1.0, no merging will be
* done with coordinates larger than 3 * GLU_TESS_MAX_COORD).
*/
private static final double SENTINEL_COORD = (4.0 * GLU_TESS_MAX_COORD);
static void AddSentinel(GLUtessellatorImpl tess, double t)
/*
* We add two sentinel edges above and below all other edges,
* to avoid special cases at the top and bottom.
*/ {
GLUhalfEdge e;
ActiveRegion reg = new ActiveRegion();
if (reg == null) throw new RuntimeException();
e = Mesh.__gl_meshMakeEdge(tess.mesh);
if (e == null) throw new RuntimeException();
e.Org.s = SENTINEL_COORD;
e.Org.t = t;
e.Sym.Org.s = -SENTINEL_COORD;
e.Sym.Org.t = t;
tess.event = e.Sym.Org; /* initialize it */
reg.eUp = e;
reg.windingNumber = 0;
reg.inside = false;
reg.fixUpperEdge = false;
reg.sentinel = true;
reg.dirty = false;
reg.nodeUp = Dict.dictInsert(tess.dict, reg); /* __gl_dictListInsertBefore */
if (reg.nodeUp == null) throw new RuntimeException();
}
static void InitEdgeDict(final GLUtessellatorImpl tess)
/*
* We maintain an ordering of edge intersections with the sweep line.
* This order is maintained in a dynamic dictionary.
*/ {
/* __gl_dictListNewDict */
tess.dict = Dict.dictNewDict(tess, new Dict.DictLeq() {
public boolean leq(Object frame, Object key1, Object key2) {
return EdgeLeq(tess, (ActiveRegion) key1, (ActiveRegion) key2);
}
});
if (tess.dict == null) throw new RuntimeException();
AddSentinel(tess, -SENTINEL_COORD);
AddSentinel(tess, SENTINEL_COORD);
}
static void DoneEdgeDict(GLUtessellatorImpl tess) {
ActiveRegion reg;
int fixedEdges = 0;
/* __GL_DICTLISTKEY */ /* __GL_DICTLISTMIN */
while ((reg = (ActiveRegion) Dict.dictKey(Dict.dictMin(tess.dict))) != null) {
/*
* At the end of all processing, the dictionary should contain
* only the two sentinel edges, plus at most one "fixable" edge
* created by ConnectRightVertex().
*/
if (!reg.sentinel) {
assert (reg.fixUpperEdge);
assert (++fixedEdges == 1);
}
assert (reg.windingNumber == 0);
DeleteRegion(tess, reg);
/* __gl_meshDelete( reg.eUp );*/
}
Dict.dictDeleteDict(tess.dict); /* __gl_dictListDeleteDict */
}
static void RemoveDegenerateEdges(GLUtessellatorImpl tess)
/*
* Remove zero-length edges, and contours with fewer than 3 vertices.
*/ {
GLUhalfEdge e, eNext, eLnext;
GLUhalfEdge eHead = tess.mesh.eHead;
/*LINTED*/
for (e = eHead.next; e != eHead; e = eNext) {
eNext = e.next;
eLnext = e.Lnext;
if (Geom.VertEq(e.Org, e.Sym.Org) && e.Lnext.Lnext != e) {
/* Zero-length edge, contour has at least 3 edges */
SpliceMergeVertices(tess, eLnext, e); /* deletes e.Org */
if (!Mesh.__gl_meshDelete(e)) throw new RuntimeException(); /* e is a self-loop */
e = eLnext;
eLnext = e.Lnext;
}
if (eLnext.Lnext == e) {
/* Degenerate contour (one or two edges) */
if (eLnext != e) {
if (eLnext == eNext || eLnext == eNext.Sym) {
eNext = eNext.next;
}
if (!Mesh.__gl_meshDelete(eLnext)) throw new RuntimeException();
}
if (e == eNext || e == eNext.Sym) {
eNext = eNext.next;
}
if (!Mesh.__gl_meshDelete(e)) throw new RuntimeException();
}
}
}
static boolean InitPriorityQ(GLUtessellatorImpl tess)
/*
* Insert all vertices into the priority queue which determines the
* order in which vertices cross the sweep line.
*/ {
PriorityQ pq;
GLUvertex v, vHead;
/* __gl_pqSortNewPriorityQ */
pq = tess.pq = PriorityQ.pqNewPriorityQ(new PriorityQ.Leq() {
public boolean leq(Object key1, Object key2) {
return Geom.VertLeq(((GLUvertex) key1), (GLUvertex) key2);
}
});
if (pq == null) return false;
vHead = tess.mesh.vHead;
for (v = vHead.next; v != vHead; v = v.next) {
v.pqHandle = pq.pqInsert(v); /* __gl_pqSortInsert */
if (v.pqHandle == Long.MAX_VALUE) break;
}
if (v != vHead || !pq.pqInit()) { /* __gl_pqSortInit */
tess.pq.pqDeletePriorityQ(); /* __gl_pqSortDeletePriorityQ */
tess.pq = null;
return false;
}
return true;
}
static void DonePriorityQ(GLUtessellatorImpl tess) {
tess.pq.pqDeletePriorityQ(); /* __gl_pqSortDeletePriorityQ */
}
static boolean RemoveDegenerateFaces(GLUmesh mesh)
/*
* Delete any degenerate faces with only two edges. WalkDirtyRegions()
* will catch almost all of these, but it won't catch degenerate faces
* produced by splice operations on already-processed edges.
* The two places this can happen are in FinishLeftRegions(), when
* we splice in a "temporary" edge produced by ConnectRightVertex(),
* and in CheckForLeftSplice(), where we splice already-processed
* edges to ensure that our dictionary invariants are not violated
* by numerical errors.
*
* In both these cases it is *very* dangerous to delete the offending
* edge at the time, since one of the routines further up the stack
* will sometimes be keeping a pointer to that edge.
*/ {
GLUface f, fNext;
GLUhalfEdge e;
/*LINTED*/
for (f = mesh.fHead.next; f != mesh.fHead; f = fNext) {
fNext = f.next;
e = f.anEdge;
assert (e.Lnext != e);
if (e.Lnext.Lnext == e) {
/* A face with only two edges */
AddWinding(e.Onext, e);
if (!Mesh.__gl_meshDelete(e)) return false;
}
}
return true;
}
public static boolean __gl_computeInterior(GLUtessellatorImpl tess)
/*
* __gl_computeInterior( tess ) computes the planar arrangement specified
* by the given contours, and further subdivides this arrangement
* into regions. Each region is marked "inside" if it belongs
* to the polygon, according to the rule given by tess.windingRule.
* Each interior region is guaranteed be monotone.
*/ {
GLUvertex v, vNext;
tess.fatalError = false;
/* Each vertex defines an event for our sweep line. Start by inserting
* all the vertices in a priority queue. Events are processed in
* lexicographic order, ie.
*
* e1 < e2 iff e1.x < e2.x || (e1.x == e2.x && e1.y < e2.y)
*/
RemoveDegenerateEdges(tess);
if (!InitPriorityQ(tess)) return false; /* if error */
InitEdgeDict(tess);
/* __gl_pqSortExtractMin */
while ((v = (GLUvertex) tess.pq.pqExtractMin()) != null) {
for (; ;) {
vNext = (GLUvertex) tess.pq.pqMinimum(); /* __gl_pqSortMinimum */
if (vNext == null || !Geom.VertEq(vNext, v)) break;
/* Merge together all vertices at exactly the same location.
* This is more efficient than processing them one at a time,
* simplifies the code (see ConnectLeftDegenerate), and is also
* important for correct handling of certain degenerate cases.
* For example, suppose there are two identical edges A and B
* that belong to different contours (so without this code they would
* be processed by separate sweep events). Suppose another edge C
* crosses A and B from above. When A is processed, we split it
* at its intersection point with C. However this also splits C,
* so when we insert B we may compute a slightly different
* intersection point. This might leave two edges with a small
* gap between them. This kind of error is especially obvious
* when using boundary extraction (GLU_TESS_BOUNDARY_ONLY).
*/
vNext = (GLUvertex) tess.pq.pqExtractMin(); /* __gl_pqSortExtractMin*/
SpliceMergeVertices(tess, v.anEdge, vNext.anEdge);
}
SweepEvent(tess, v);
}
/* Set tess.event for debugging purposes */
/* __GL_DICTLISTKEY */ /* __GL_DICTLISTMIN */
tess.event = ((ActiveRegion) Dict.dictKey(Dict.dictMin(tess.dict))).eUp.Org;
DebugEvent(tess);
DoneEdgeDict(tess);
DonePriorityQ(tess);
if (!RemoveDegenerateFaces(tess.mesh)) return false;
Mesh.__gl_meshCheckMesh(tess.mesh);
return true;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/CachedVertex.java 0000644 0001750 0001750 00000010415 11543426510 025022 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
class CachedVertex {
public double[] coords = new double[3];
public Object data;
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/DictNode.java 0000644 0001750 0001750 00000010373 11543426510 024151 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
class DictNode {
Object key;
DictNode next;
DictNode prev;
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/Mesh.java 0000644 0001750 0001750 00000063230 11543426510 023354 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
class Mesh {
private Mesh() {
}
/************************ Utility Routines ************************/
/* MakeEdge creates a new pair of half-edges which form their own loop.
* No vertex or face structures are allocated, but these must be assigned
* before the current edge operation is completed.
*/
static GLUhalfEdge MakeEdge(GLUhalfEdge eNext) {
GLUhalfEdge e;
GLUhalfEdge eSym;
GLUhalfEdge ePrev;
// EdgePair * pair = (EdgePair *)
// memAlloc(sizeof(EdgePair));
// if (pair == NULL) return NULL;
//
// e = &pair - > e;
e = new GLUhalfEdge(true);
// eSym = &pair - > eSym;
eSym = new GLUhalfEdge(false);
/* Make sure eNext points to the first edge of the edge pair */
if (!eNext.first) {
eNext = eNext.Sym;
}
/* Insert in circular doubly-linked list before eNext.
* Note that the prev pointer is stored in Sym->next.
*/
ePrev = eNext.Sym.next;
eSym.next = ePrev;
ePrev.Sym.next = e;
e.next = eNext;
eNext.Sym.next = eSym;
e.Sym = eSym;
e.Onext = e;
e.Lnext = eSym;
e.Org = null;
e.Lface = null;
e.winding = 0;
e.activeRegion = null;
eSym.Sym = e;
eSym.Onext = eSym;
eSym.Lnext = e;
eSym.Org = null;
eSym.Lface = null;
eSym.winding = 0;
eSym.activeRegion = null;
return e;
}
/* Splice( a, b ) is best described by the Guibas/Stolfi paper or the
* CS348a notes (see mesh.h). Basically it modifies the mesh so that
* a->Onext and b->Onext are exchanged. This can have various effects
* depending on whether a and b belong to different face or vertex rings.
* For more explanation see __gl_meshSplice() below.
*/
static void Splice(GLUhalfEdge a, GLUhalfEdge b) {
GLUhalfEdge aOnext = a.Onext;
GLUhalfEdge bOnext = b.Onext;
aOnext.Sym.Lnext = b;
bOnext.Sym.Lnext = a;
a.Onext = bOnext;
b.Onext = aOnext;
}
/* MakeVertex( newVertex, eOrig, vNext ) attaches a new vertex and makes it the
* origin of all edges in the vertex loop to which eOrig belongs. "vNext" gives
* a place to insert the new vertex in the global vertex list. We insert
* the new vertex *before* vNext so that algorithms which walk the vertex
* list will not see the newly created vertices.
*/
static void MakeVertex(GLUvertex newVertex,
GLUhalfEdge eOrig, GLUvertex vNext) {
GLUhalfEdge e;
GLUvertex vPrev;
GLUvertex vNew = newVertex;
assert (vNew != null);
/* insert in circular doubly-linked list before vNext */
vPrev = vNext.prev;
vNew.prev = vPrev;
vPrev.next = vNew;
vNew.next = vNext;
vNext.prev = vNew;
vNew.anEdge = eOrig;
vNew.data = null;
/* leave coords, s, t undefined */
/* fix other edges on this vertex loop */
e = eOrig;
do {
e.Org = vNew;
e = e.Onext;
} while (e != eOrig);
}
/* MakeFace( newFace, eOrig, fNext ) attaches a new face and makes it the left
* face of all edges in the face loop to which eOrig belongs. "fNext" gives
* a place to insert the new face in the global face list. We insert
* the new face *before* fNext so that algorithms which walk the face
* list will not see the newly created faces.
*/
static void MakeFace(GLUface newFace, GLUhalfEdge eOrig, GLUface fNext) {
GLUhalfEdge e;
GLUface fPrev;
GLUface fNew = newFace;
assert (fNew != null);
/* insert in circular doubly-linked list before fNext */
fPrev = fNext.prev;
fNew.prev = fPrev;
fPrev.next = fNew;
fNew.next = fNext;
fNext.prev = fNew;
fNew.anEdge = eOrig;
fNew.data = null;
fNew.trail = null;
fNew.marked = false;
/* The new face is marked "inside" if the old one was. This is a
* convenience for the common case where a face has been split in two.
*/
fNew.inside = fNext.inside;
/* fix other edges on this face loop */
e = eOrig;
do {
e.Lface = fNew;
e = e.Lnext;
} while (e != eOrig);
}
/* KillEdge( eDel ) destroys an edge (the half-edges eDel and eDel->Sym),
* and removes from the global edge list.
*/
static void KillEdge(GLUhalfEdge eDel) {
GLUhalfEdge ePrev, eNext;
/* Half-edges are allocated in pairs, see EdgePair above */
if (!eDel.first) {
eDel = eDel.Sym;
}
/* delete from circular doubly-linked list */
eNext = eDel.next;
ePrev = eDel.Sym.next;
eNext.Sym.next = ePrev;
ePrev.Sym.next = eNext;
}
/* KillVertex( vDel ) destroys a vertex and removes it from the global
* vertex list. It updates the vertex loop to point to a given new vertex.
*/
static void KillVertex(GLUvertex vDel, GLUvertex newOrg) {
GLUhalfEdge e, eStart = vDel.anEdge;
GLUvertex vPrev, vNext;
/* change the origin of all affected edges */
e = eStart;
do {
e.Org = newOrg;
e = e.Onext;
} while (e != eStart);
/* delete from circular doubly-linked list */
vPrev = vDel.prev;
vNext = vDel.next;
vNext.prev = vPrev;
vPrev.next = vNext;
}
/* KillFace( fDel ) destroys a face and removes it from the global face
* list. It updates the face loop to point to a given new face.
*/
static void KillFace(GLUface fDel, GLUface newLface) {
GLUhalfEdge e, eStart = fDel.anEdge;
GLUface fPrev, fNext;
/* change the left face of all affected edges */
e = eStart;
do {
e.Lface = newLface;
e = e.Lnext;
} while (e != eStart);
/* delete from circular doubly-linked list */
fPrev = fDel.prev;
fNext = fDel.next;
fNext.prev = fPrev;
fPrev.next = fNext;
}
/****************** Basic Edge Operations **********************/
/* __gl_meshMakeEdge creates one edge, two vertices, and a loop (face).
* The loop consists of the two new half-edges.
*/
public static GLUhalfEdge __gl_meshMakeEdge(GLUmesh mesh) {
GLUvertex newVertex1 = new GLUvertex();
GLUvertex newVertex2 = new GLUvertex();
GLUface newFace = new GLUface();
GLUhalfEdge e;
e = MakeEdge(mesh.eHead);
if (e == null) return null;
MakeVertex(newVertex1, e, mesh.vHead);
MakeVertex(newVertex2, e.Sym, mesh.vHead);
MakeFace(newFace, e, mesh.fHead);
return e;
}
/* __gl_meshSplice( eOrg, eDst ) is the basic operation for changing the
* mesh connectivity and topology. It changes the mesh so that
* eOrg->Onext <- OLD( eDst->Onext )
* eDst->Onext <- OLD( eOrg->Onext )
* where OLD(...) means the value before the meshSplice operation.
*
* This can have two effects on the vertex structure:
* - if eOrg->Org != eDst->Org, the two vertices are merged together
* - if eOrg->Org == eDst->Org, the origin is split into two vertices
* In both cases, eDst->Org is changed and eOrg->Org is untouched.
*
* Similarly (and independently) for the face structure,
* - if eOrg->Lface == eDst->Lface, one loop is split into two
* - if eOrg->Lface != eDst->Lface, two distinct loops are joined into one
* In both cases, eDst->Lface is changed and eOrg->Lface is unaffected.
*
* Some special cases:
* If eDst == eOrg, the operation has no effect.
* If eDst == eOrg->Lnext, the new face will have a single edge.
* If eDst == eOrg->Lprev, the old face will have a single edge.
* If eDst == eOrg->Onext, the new vertex will have a single edge.
* If eDst == eOrg->Oprev, the old vertex will have a single edge.
*/
public static boolean __gl_meshSplice(GLUhalfEdge eOrg, GLUhalfEdge eDst) {
boolean joiningLoops = false;
boolean joiningVertices = false;
if (eOrg == eDst) return true;
if (eDst.Org != eOrg.Org) {
/* We are merging two disjoint vertices -- destroy eDst->Org */
joiningVertices = true;
KillVertex(eDst.Org, eOrg.Org);
}
if (eDst.Lface != eOrg.Lface) {
/* We are connecting two disjoint loops -- destroy eDst.Lface */
joiningLoops = true;
KillFace(eDst.Lface, eOrg.Lface);
}
/* Change the edge structure */
Splice(eDst, eOrg);
if (!joiningVertices) {
GLUvertex newVertex = new GLUvertex();
/* We split one vertex into two -- the new vertex is eDst.Org.
* Make sure the old vertex points to a valid half-edge.
*/
MakeVertex(newVertex, eDst, eOrg.Org);
eOrg.Org.anEdge = eOrg;
}
if (!joiningLoops) {
GLUface newFace = new GLUface();
/* We split one loop into two -- the new loop is eDst.Lface.
* Make sure the old face points to a valid half-edge.
*/
MakeFace(newFace, eDst, eOrg.Lface);
eOrg.Lface.anEdge = eOrg;
}
return true;
}
/* __gl_meshDelete( eDel ) removes the edge eDel. There are several cases:
* if (eDel.Lface != eDel.Rface), we join two loops into one; the loop
* eDel.Lface is deleted. Otherwise, we are splitting one loop into two;
* the newly created loop will contain eDel.Dst. If the deletion of eDel
* would create isolated vertices, those are deleted as well.
*
* This function could be implemented as two calls to __gl_meshSplice
* plus a few calls to memFree, but this would allocate and delete
* unnecessary vertices and faces.
*/
static boolean __gl_meshDelete(GLUhalfEdge eDel) {
GLUhalfEdge eDelSym = eDel.Sym;
boolean joiningLoops = false;
/* First step: disconnect the origin vertex eDel.Org. We make all
* changes to get a consistent mesh in this "intermediate" state.
*/
if (eDel.Lface != eDel.Sym.Lface) {
/* We are joining two loops into one -- remove the left face */
joiningLoops = true;
KillFace(eDel.Lface, eDel.Sym.Lface);
}
if (eDel.Onext == eDel) {
KillVertex(eDel.Org, null);
} else {
/* Make sure that eDel.Org and eDel.Sym.Lface point to valid half-edges */
eDel.Sym.Lface.anEdge = eDel.Sym.Lnext;
eDel.Org.anEdge = eDel.Onext;
Splice(eDel, eDel.Sym.Lnext);
if (!joiningLoops) {
GLUface newFace = new GLUface();
/* We are splitting one loop into two -- create a new loop for eDel. */
MakeFace(newFace, eDel, eDel.Lface);
}
}
/* Claim: the mesh is now in a consistent state, except that eDel.Org
* may have been deleted. Now we disconnect eDel.Dst.
*/
if (eDelSym.Onext == eDelSym) {
KillVertex(eDelSym.Org, null);
KillFace(eDelSym.Lface, null);
} else {
/* Make sure that eDel.Dst and eDel.Lface point to valid half-edges */
eDel.Lface.anEdge = eDelSym.Sym.Lnext;
eDelSym.Org.anEdge = eDelSym.Onext;
Splice(eDelSym, eDelSym.Sym.Lnext);
}
/* Any isolated vertices or faces have already been freed. */
KillEdge(eDel);
return true;
}
/******************** Other Edge Operations **********************/
/* All these routines can be implemented with the basic edge
* operations above. They are provided for convenience and efficiency.
*/
/* __gl_meshAddEdgeVertex( eOrg ) creates a new edge eNew such that
* eNew == eOrg.Lnext, and eNew.Dst is a newly created vertex.
* eOrg and eNew will have the same left face.
*/
static GLUhalfEdge __gl_meshAddEdgeVertex(GLUhalfEdge eOrg) {
GLUhalfEdge eNewSym;
GLUhalfEdge eNew = MakeEdge(eOrg);
eNewSym = eNew.Sym;
/* Connect the new edge appropriately */
Splice(eNew, eOrg.Lnext);
/* Set the vertex and face information */
eNew.Org = eOrg.Sym.Org;
{
GLUvertex newVertex = new GLUvertex();
MakeVertex(newVertex, eNewSym, eNew.Org);
}
eNew.Lface = eNewSym.Lface = eOrg.Lface;
return eNew;
}
/* __gl_meshSplitEdge( eOrg ) splits eOrg into two edges eOrg and eNew,
* such that eNew == eOrg.Lnext. The new vertex is eOrg.Sym.Org == eNew.Org.
* eOrg and eNew will have the same left face.
*/
public static GLUhalfEdge __gl_meshSplitEdge(GLUhalfEdge eOrg) {
GLUhalfEdge eNew;
GLUhalfEdge tempHalfEdge = __gl_meshAddEdgeVertex(eOrg);
eNew = tempHalfEdge.Sym;
/* Disconnect eOrg from eOrg.Sym.Org and connect it to eNew.Org */
Splice(eOrg.Sym, eOrg.Sym.Sym.Lnext);
Splice(eOrg.Sym, eNew);
/* Set the vertex and face information */
eOrg.Sym.Org = eNew.Org;
eNew.Sym.Org.anEdge = eNew.Sym; /* may have pointed to eOrg.Sym */
eNew.Sym.Lface = eOrg.Sym.Lface;
eNew.winding = eOrg.winding; /* copy old winding information */
eNew.Sym.winding = eOrg.Sym.winding;
return eNew;
}
/* __gl_meshConnect( eOrg, eDst ) creates a new edge from eOrg.Sym.Org
* to eDst.Org, and returns the corresponding half-edge eNew.
* If eOrg.Lface == eDst.Lface, this splits one loop into two,
* and the newly created loop is eNew.Lface. Otherwise, two disjoint
* loops are merged into one, and the loop eDst.Lface is destroyed.
*
* If (eOrg == eDst), the new face will have only two edges.
* If (eOrg.Lnext == eDst), the old face is reduced to a single edge.
* If (eOrg.Lnext.Lnext == eDst), the old face is reduced to two edges.
*/
static GLUhalfEdge __gl_meshConnect(GLUhalfEdge eOrg, GLUhalfEdge eDst) {
GLUhalfEdge eNewSym;
boolean joiningLoops = false;
GLUhalfEdge eNew = MakeEdge(eOrg);
eNewSym = eNew.Sym;
if (eDst.Lface != eOrg.Lface) {
/* We are connecting two disjoint loops -- destroy eDst.Lface */
joiningLoops = true;
KillFace(eDst.Lface, eOrg.Lface);
}
/* Connect the new edge appropriately */
Splice(eNew, eOrg.Lnext);
Splice(eNewSym, eDst);
/* Set the vertex and face information */
eNew.Org = eOrg.Sym.Org;
eNewSym.Org = eDst.Org;
eNew.Lface = eNewSym.Lface = eOrg.Lface;
/* Make sure the old face points to a valid half-edge */
eOrg.Lface.anEdge = eNewSym;
if (!joiningLoops) {
GLUface newFace = new GLUface();
/* We split one loop into two -- the new loop is eNew.Lface */
MakeFace(newFace, eNew, eOrg.Lface);
}
return eNew;
}
/******************** Other Operations **********************/
/* __gl_meshZapFace( fZap ) destroys a face and removes it from the
* global face list. All edges of fZap will have a null pointer as their
* left face. Any edges which also have a null pointer as their right face
* are deleted entirely (along with any isolated vertices this produces).
* An entire mesh can be deleted by zapping its faces, one at a time,
* in any order. Zapped faces cannot be used in further mesh operations!
*/
static void __gl_meshZapFace(GLUface fZap) {
GLUhalfEdge eStart = fZap.anEdge;
GLUhalfEdge e, eNext, eSym;
GLUface fPrev, fNext;
/* walk around face, deleting edges whose right face is also null */
eNext = eStart.Lnext;
do {
e = eNext;
eNext = e.Lnext;
e.Lface = null;
if (e.Sym.Lface == null) {
/* delete the edge -- see __gl_MeshDelete above */
if (e.Onext == e) {
KillVertex(e.Org, null);
} else {
/* Make sure that e.Org points to a valid half-edge */
e.Org.anEdge = e.Onext;
Splice(e, e.Sym.Lnext);
}
eSym = e.Sym;
if (eSym.Onext == eSym) {
KillVertex(eSym.Org, null);
} else {
/* Make sure that eSym.Org points to a valid half-edge */
eSym.Org.anEdge = eSym.Onext;
Splice(eSym, eSym.Sym.Lnext);
}
KillEdge(e);
}
} while (e != eStart);
/* delete from circular doubly-linked list */
fPrev = fZap.prev;
fNext = fZap.next;
fNext.prev = fPrev;
fPrev.next = fNext;
}
/* __gl_meshNewMesh() creates a new mesh with no edges, no vertices,
* and no loops (what we usually call a "face").
*/
public static GLUmesh __gl_meshNewMesh() {
GLUvertex v;
GLUface f;
GLUhalfEdge e;
GLUhalfEdge eSym;
GLUmesh mesh = new GLUmesh();
v = mesh.vHead;
f = mesh.fHead;
e = mesh.eHead;
eSym = mesh.eHeadSym;
v.next = v.prev = v;
v.anEdge = null;
v.data = null;
f.next = f.prev = f;
f.anEdge = null;
f.data = null;
f.trail = null;
f.marked = false;
f.inside = false;
e.next = e;
e.Sym = eSym;
e.Onext = null;
e.Lnext = null;
e.Org = null;
e.Lface = null;
e.winding = 0;
e.activeRegion = null;
eSym.next = eSym;
eSym.Sym = e;
eSym.Onext = null;
eSym.Lnext = null;
eSym.Org = null;
eSym.Lface = null;
eSym.winding = 0;
eSym.activeRegion = null;
return mesh;
}
/* __gl_meshUnion( mesh1, mesh2 ) forms the union of all structures in
* both meshes, and returns the new mesh (the old meshes are destroyed).
*/
static GLUmesh __gl_meshUnion(GLUmesh mesh1, GLUmesh mesh2) {
GLUface f1 = mesh1.fHead;
GLUvertex v1 = mesh1.vHead;
GLUhalfEdge e1 = mesh1.eHead;
GLUface f2 = mesh2.fHead;
GLUvertex v2 = mesh2.vHead;
GLUhalfEdge e2 = mesh2.eHead;
/* Add the faces, vertices, and edges of mesh2 to those of mesh1 */
if (f2.next != f2) {
f1.prev.next = f2.next;
f2.next.prev = f1.prev;
f2.prev.next = f1;
f1.prev = f2.prev;
}
if (v2.next != v2) {
v1.prev.next = v2.next;
v2.next.prev = v1.prev;
v2.prev.next = v1;
v1.prev = v2.prev;
}
if (e2.next != e2) {
e1.Sym.next.Sym.next = e2.next;
e2.next.Sym.next = e1.Sym.next;
e2.Sym.next.Sym.next = e1;
e1.Sym.next = e2.Sym.next;
}
return mesh1;
}
/* __gl_meshDeleteMesh( mesh ) will free all storage for any valid mesh.
*/
static void __gl_meshDeleteMeshZap(GLUmesh mesh) {
GLUface fHead = mesh.fHead;
while (fHead.next != fHead) {
__gl_meshZapFace(fHead.next);
}
assert (mesh.vHead.next == mesh.vHead);
}
/* __gl_meshDeleteMesh( mesh ) will free all storage for any valid mesh.
*/
public static void __gl_meshDeleteMesh(GLUmesh mesh) {
GLUface f, fNext;
GLUvertex v, vNext;
GLUhalfEdge e, eNext;
for (f = mesh.fHead.next; f != mesh.fHead; f = fNext) {
fNext = f.next;
}
for (v = mesh.vHead.next; v != mesh.vHead; v = vNext) {
vNext = v.next;
}
for (e = mesh.eHead.next; e != mesh.eHead; e = eNext) {
/* One call frees both e and e.Sym (see EdgePair above) */
eNext = e.next;
}
}
/* __gl_meshCheckMesh( mesh ) checks a mesh for self-consistency.
*/
public static void __gl_meshCheckMesh(GLUmesh mesh) {
GLUface fHead = mesh.fHead;
GLUvertex vHead = mesh.vHead;
GLUhalfEdge eHead = mesh.eHead;
GLUface f, fPrev;
GLUvertex v, vPrev;
GLUhalfEdge e, ePrev;
fPrev = fHead;
for (fPrev = fHead; (f = fPrev.next) != fHead; fPrev = f) {
assert (f.prev == fPrev);
e = f.anEdge;
do {
assert (e.Sym != e);
assert (e.Sym.Sym == e);
assert (e.Lnext.Onext.Sym == e);
assert (e.Onext.Sym.Lnext == e);
assert (e.Lface == f);
e = e.Lnext;
} while (e != f.anEdge);
}
assert (f.prev == fPrev && f.anEdge == null && f.data == null);
vPrev = vHead;
for (vPrev = vHead; (v = vPrev.next) != vHead; vPrev = v) {
assert (v.prev == vPrev);
e = v.anEdge;
do {
assert (e.Sym != e);
assert (e.Sym.Sym == e);
assert (e.Lnext.Onext.Sym == e);
assert (e.Onext.Sym.Lnext == e);
assert (e.Org == v);
e = e.Onext;
} while (e != v.anEdge);
}
assert (v.prev == vPrev && v.anEdge == null && v.data == null);
ePrev = eHead;
for (ePrev = eHead; (e = ePrev.next) != eHead; ePrev = e) {
assert (e.Sym.next == ePrev.Sym);
assert (e.Sym != e);
assert (e.Sym.Sym == e);
assert (e.Org != null);
assert (e.Sym.Org != null);
assert (e.Lnext.Onext.Sym == e);
assert (e.Onext.Sym.Lnext == e);
}
assert (e.Sym.next == ePrev.Sym
&& e.Sym == mesh.eHeadSym
&& e.Sym.Sym == e
&& e.Org == null && e.Sym.Org == null
&& e.Lface == null && e.Sym.Lface == null);
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/ActiveRegion.java 0000644 0001750 0001750 00000011735 11543426510 025042 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
class ActiveRegion {
GLUhalfEdge eUp; /* upper edge, directed right to left */
DictNode nodeUp; /* dictionary node corresponding to eUp */
int windingNumber; /* used to determine which regions are
* inside the polygon */
boolean inside; /* is this region inside the polygon? */
boolean sentinel; /* marks fake edges at t = +/-infinity */
boolean dirty; /* marks regions where the upper or lower
* edge has changed, but we haven't checked
* whether they intersect yet */
boolean fixUpperEdge; /* marks temporary edges introduced when
* we process a "right vertex" (one without
* any edges leaving to the right) */
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/Render.java 0000644 0001750 0001750 00000053340 11543426510 023700 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.util.glu.GLU.*;
class Render {
private static final boolean USE_OPTIMIZED_CODE_PATH = false;
private Render() {
}
private static final RenderFan renderFan = new RenderFan();
private static final RenderStrip renderStrip = new RenderStrip();
private static final RenderTriangle renderTriangle = new RenderTriangle();
/* This structure remembers the information we need about a primitive
* to be able to render it later, once we have determined which
* primitive is able to use the most triangles.
*/
private static class FaceCount {
private FaceCount() {
}
private FaceCount(long size, GLUhalfEdge eStart, renderCallBack render) {
this.size = size;
this.eStart = eStart;
this.render = render;
}
long size; /* number of triangles used */
GLUhalfEdge eStart; /* edge where this primitive starts */
renderCallBack render;
};
private interface renderCallBack {
void render(GLUtessellatorImpl tess, GLUhalfEdge e, long size);
}
/************************ Strips and Fans decomposition ******************/
/* __gl_renderMesh( tess, mesh ) takes a mesh and breaks it into triangle
* fans, strips, and separate triangles. A substantial effort is made
* to use as few rendering primitives as possible (ie. to make the fans
* and strips as large as possible).
*
* The rendering output is provided as callbacks (see the api).
*/
public static void __gl_renderMesh(GLUtessellatorImpl tess, GLUmesh mesh) {
GLUface f;
/* Make a list of separate triangles so we can render them all at once */
tess.lonelyTriList = null;
for (f = mesh.fHead.next; f != mesh.fHead; f = f.next) {
f.marked = false;
}
for (f = mesh.fHead.next; f != mesh.fHead; f = f.next) {
/* We examine all faces in an arbitrary order. Whenever we find
* an unprocessed face F, we output a group of faces including F
* whose size is maximum.
*/
if (f.inside && !f.marked) {
RenderMaximumFaceGroup(tess, f);
assert (f.marked);
}
}
if (tess.lonelyTriList != null) {
RenderLonelyTriangles(tess, tess.lonelyTriList);
tess.lonelyTriList = null;
}
}
static void RenderMaximumFaceGroup(GLUtessellatorImpl tess, GLUface fOrig) {
/* We want to find the largest triangle fan or strip of unmarked faces
* which includes the given face fOrig. There are 3 possible fans
* passing through fOrig (one centered at each vertex), and 3 possible
* strips (one for each CCW permutation of the vertices). Our strategy
* is to try all of these, and take the primitive which uses the most
* triangles (a greedy approach).
*/
GLUhalfEdge e = fOrig.anEdge;
FaceCount max = new FaceCount();
FaceCount newFace;
max.size = 1;
max.eStart = e;
max.render = renderTriangle;
if (!tess.flagBoundary) {
newFace = MaximumFan(e);
if (newFace.size > max.size) {
max = newFace;
}
newFace = MaximumFan(e.Lnext);
if (newFace.size > max.size) {
max = newFace;
}
newFace = MaximumFan(e.Onext.Sym);
if (newFace.size > max.size) {
max = newFace;
}
newFace = MaximumStrip(e);
if (newFace.size > max.size) {
max = newFace;
}
newFace = MaximumStrip(e.Lnext);
if (newFace.size > max.size) {
max = newFace;
}
newFace = MaximumStrip(e.Onext.Sym);
if (newFace.size > max.size) {
max = newFace;
}
}
max.render.render(tess, max.eStart, max.size);
}
/* Macros which keep track of faces we have marked temporarily, and allow
* us to backtrack when necessary. With triangle fans, this is not
* really necessary, since the only awkward case is a loop of triangles
* around a single origin vertex. However with strips the situation is
* more complicated, and we need a general tracking method like the
* one here.
*/
private static boolean Marked(GLUface f) {
return !f.inside || f.marked;
}
private static GLUface AddToTrail(GLUface f, GLUface t) {
f.trail = t;
f.marked = true;
return f;
}
private static void FreeTrail(GLUface t) {
if (true) {
while (t != null) {
t.marked = false;
t = t.trail;
}
} else {
/* absorb trailing semicolon */
}
}
static FaceCount MaximumFan(GLUhalfEdge eOrig) {
/* eOrig.Lface is the face we want to render. We want to find the size
* of a maximal fan around eOrig.Org. To do this we just walk around
* the origin vertex as far as possible in both directions.
*/
FaceCount newFace = new FaceCount(0, null, renderFan);
GLUface trail = null;
GLUhalfEdge e;
for (e = eOrig; !Marked(e.Lface); e = e.Onext) {
trail = AddToTrail(e.Lface, trail);
++newFace.size;
}
for (e = eOrig; !Marked(e.Sym.Lface); e = e.Sym.Lnext) {
trail = AddToTrail(e.Sym.Lface, trail);
++newFace.size;
}
newFace.eStart = e;
/*LINTED*/
FreeTrail(trail);
return newFace;
}
private static boolean IsEven(long n) {
return (n & 0x1L) == 0;
}
static FaceCount MaximumStrip(GLUhalfEdge eOrig) {
/* Here we are looking for a maximal strip that contains the vertices
* eOrig.Org, eOrig.Dst, eOrig.Lnext.Dst (in that order or the
* reverse, such that all triangles are oriented CCW).
*
* Again we walk forward and backward as far as possible. However for
* strips there is a twist: to get CCW orientations, there must be
* an *even* number of triangles in the strip on one side of eOrig.
* We walk the strip starting on a side with an even number of triangles;
* if both side have an odd number, we are forced to shorten one side.
*/
FaceCount newFace = new FaceCount(0, null, renderStrip);
long headSize = 0, tailSize = 0;
GLUface trail = null;
GLUhalfEdge e, eTail, eHead;
for (e = eOrig; !Marked(e.Lface); ++tailSize, e = e.Onext) {
trail = AddToTrail(e.Lface, trail);
++tailSize;
e = e.Lnext.Sym;
if (Marked(e.Lface)) break;
trail = AddToTrail(e.Lface, trail);
}
eTail = e;
for (e = eOrig; !Marked(e.Sym.Lface); ++headSize, e = e.Sym.Onext.Sym) {
trail = AddToTrail(e.Sym.Lface, trail);
++headSize;
e = e.Sym.Lnext;
if (Marked(e.Sym.Lface)) break;
trail = AddToTrail(e.Sym.Lface, trail);
}
eHead = e;
newFace.size = tailSize + headSize;
if (IsEven(tailSize)) {
newFace.eStart = eTail.Sym;
} else if (IsEven(headSize)) {
newFace.eStart = eHead;
} else {
/* Both sides have odd length, we must shorten one of them. In fact,
* we must start from eHead to guarantee inclusion of eOrig.Lface.
*/
--newFace.size;
newFace.eStart = eHead.Onext;
}
/*LINTED*/
FreeTrail(trail);
return newFace;
}
private static class RenderTriangle implements renderCallBack {
public void render(GLUtessellatorImpl tess, GLUhalfEdge e, long size) {
/* Just add the triangle to a triangle list, so we can render all
* the separate triangles at once.
*/
assert (size == 1);
tess.lonelyTriList = AddToTrail(e.Lface, tess.lonelyTriList);
}
}
static void RenderLonelyTriangles(GLUtessellatorImpl tess, GLUface f) {
/* Now we render all the separate triangles which could not be
* grouped into a triangle fan or strip.
*/
GLUhalfEdge e;
int newState;
int edgeState = -1; /* force edge state output for first vertex */
tess.callBeginOrBeginData(GL_TRIANGLES);
for (; f != null; f = f.trail) {
/* Loop once for each edge (there will always be 3 edges) */
e = f.anEdge;
do {
if (tess.flagBoundary) {
/* Set the "edge state" to true just before we output the
* first vertex of each edge on the polygon boundary.
*/
newState = (!e.Sym.Lface.inside) ? 1 : 0;
if (edgeState != newState) {
edgeState = newState;
tess.callEdgeFlagOrEdgeFlagData( edgeState != 0);
}
}
tess.callVertexOrVertexData( e.Org.data);
e = e.Lnext;
} while (e != f.anEdge);
}
tess.callEndOrEndData();
}
private static class RenderFan implements renderCallBack {
public void render(GLUtessellatorImpl tess, GLUhalfEdge e, long size) {
/* Render as many CCW triangles as possible in a fan starting from
* edge "e". The fan *should* contain exactly "size" triangles
* (otherwise we've goofed up somewhere).
*/
tess.callBeginOrBeginData(GL_TRIANGLE_FAN);
tess.callVertexOrVertexData( e.Org.data);
tess.callVertexOrVertexData( e.Sym.Org.data);
while (!Marked(e.Lface)) {
e.Lface.marked = true;
--size;
e = e.Onext;
tess.callVertexOrVertexData( e.Sym.Org.data);
}
assert (size == 0);
tess.callEndOrEndData();
}
}
private static class RenderStrip implements renderCallBack {
public void render(GLUtessellatorImpl tess, GLUhalfEdge e, long size) {
/* Render as many CCW triangles as possible in a strip starting from
* edge "e". The strip *should* contain exactly "size" triangles
* (otherwise we've goofed up somewhere).
*/
tess.callBeginOrBeginData(GL_TRIANGLE_STRIP);
tess.callVertexOrVertexData( e.Org.data);
tess.callVertexOrVertexData( e.Sym.Org.data);
while (!Marked(e.Lface)) {
e.Lface.marked = true;
--size;
e = e.Lnext.Sym;
tess.callVertexOrVertexData( e.Org.data);
if (Marked(e.Lface)) break;
e.Lface.marked = true;
--size;
e = e.Onext;
tess.callVertexOrVertexData( e.Sym.Org.data);
}
assert (size == 0);
tess.callEndOrEndData();
}
}
/************************ Boundary contour decomposition ******************/
/* __gl_renderBoundary( tess, mesh ) takes a mesh, and outputs one
* contour for each face marked "inside". The rendering output is
* provided as callbacks (see the api).
*/
public static void __gl_renderBoundary(GLUtessellatorImpl tess, GLUmesh mesh) {
GLUface f;
GLUhalfEdge e;
for (f = mesh.fHead.next; f != mesh.fHead; f = f.next) {
if (f.inside) {
tess.callBeginOrBeginData(GL_LINE_LOOP);
e = f.anEdge;
do {
tess.callVertexOrVertexData( e.Org.data);
e = e.Lnext;
} while (e != f.anEdge);
tess.callEndOrEndData();
}
}
}
/************************ Quick-and-dirty decomposition ******************/
private static final int SIGN_INCONSISTENT = 2;
static int ComputeNormal(GLUtessellatorImpl tess, double[] norm, boolean check)
/*
* If check==false, we compute the polygon normal and place it in norm[].
* If check==true, we check that each triangle in the fan from v0 has a
* consistent orientation with respect to norm[]. If triangles are
* consistently oriented CCW, return 1; if CW, return -1; if all triangles
* are degenerate return 0; otherwise (no consistent orientation) return
* SIGN_INCONSISTENT.
*/ {
CachedVertex[] v = tess.cache;
// CachedVertex vn = v0 + tess.cacheCount;
int vn = tess.cacheCount;
// CachedVertex vc;
int vc;
double dot, xc, yc, zc, xp, yp, zp;
double[] n = new double[3];
int sign = 0;
/* Find the polygon normal. It is important to get a reasonable
* normal even when the polygon is self-intersecting (eg. a bowtie).
* Otherwise, the computed normal could be very tiny, but perpendicular
* to the true plane of the polygon due to numerical noise. Then all
* the triangles would appear to be degenerate and we would incorrectly
* decompose the polygon as a fan (or simply not render it at all).
*
* We use a sum-of-triangles normal algorithm rather than the more
* efficient sum-of-trapezoids method (used in CheckOrientation()
* in normal.c). This lets us explicitly reverse the signed area
* of some triangles to get a reasonable normal in the self-intersecting
* case.
*/
if (!check) {
norm[0] = norm[1] = norm[2] = 0.0;
}
vc = 1;
xc = v[vc].coords[0] - v[0].coords[0];
yc = v[vc].coords[1] - v[0].coords[1];
zc = v[vc].coords[2] - v[0].coords[2];
while (++vc < vn) {
xp = xc;
yp = yc;
zp = zc;
xc = v[vc].coords[0] - v[0].coords[0];
yc = v[vc].coords[1] - v[0].coords[1];
zc = v[vc].coords[2] - v[0].coords[2];
/* Compute (vp - v0) cross (vc - v0) */
n[0] = yp * zc - zp * yc;
n[1] = zp * xc - xp * zc;
n[2] = xp * yc - yp * xc;
dot = n[0] * norm[0] + n[1] * norm[1] + n[2] * norm[2];
if (!check) {
/* Reverse the contribution of back-facing triangles to get
* a reasonable normal for self-intersecting polygons (see above)
*/
if (dot >= 0) {
norm[0] += n[0];
norm[1] += n[1];
norm[2] += n[2];
} else {
norm[0] -= n[0];
norm[1] -= n[1];
norm[2] -= n[2];
}
} else if (dot != 0) {
/* Check the new orientation for consistency with previous triangles */
if (dot > 0) {
if (sign < 0) return SIGN_INCONSISTENT;
sign = 1;
} else {
if (sign > 0) return SIGN_INCONSISTENT;
sign = -1;
}
}
}
return sign;
}
/* __gl_renderCache( tess ) takes a single contour and tries to render it
* as a triangle fan. This handles convex polygons, as well as some
* non-convex polygons if we get lucky.
*
* Returns true if the polygon was successfully rendered. The rendering
* output is provided as callbacks (see the api).
*/
public static boolean __gl_renderCache(GLUtessellatorImpl tess) {
CachedVertex[] v = tess.cache;
// CachedVertex vn = v0 + tess.cacheCount;
int vn = tess.cacheCount;
// CachedVertex vc;
int vc;
double[] norm = new double[3];
int sign;
if (tess.cacheCount < 3) {
/* Degenerate contour -- no output */
return true;
}
norm[0] = tess.normal[0];
norm[1] = tess.normal[1];
norm[2] = tess.normal[2];
if (norm[0] == 0 && norm[1] == 0 && norm[2] == 0) {
ComputeNormal( tess, norm, false);
}
sign = ComputeNormal( tess, norm, true);
if (sign == SIGN_INCONSISTENT) {
/* Fan triangles did not have a consistent orientation */
return false;
}
if (sign == 0) {
/* All triangles were degenerate */
return true;
}
if ( !USE_OPTIMIZED_CODE_PATH ) {
return false;
} else {
/* Make sure we do the right thing for each winding rule */
switch (tess.windingRule) {
case GLU_TESS_WINDING_ODD:
case GLU_TESS_WINDING_NONZERO:
break;
case GLU_TESS_WINDING_POSITIVE:
if (sign < 0) return true;
break;
case GLU_TESS_WINDING_NEGATIVE:
if (sign > 0) return true;
break;
case GLU_TESS_WINDING_ABS_GEQ_TWO:
return true;
}
tess.callBeginOrBeginData( tess.boundaryOnly ? GL_LINE_LOOP
: (tess.cacheCount > 3) ? GL_TRIANGLE_FAN
: GL_TRIANGLES);
tess.callVertexOrVertexData( v[0].data);
if (sign > 0) {
for (vc = 1; vc < vn; ++vc) {
tess.callVertexOrVertexData( v[vc].data);
}
} else {
for (vc = vn - 1; vc > 0; --vc) {
tess.callVertexOrVertexData( v[vc].data);
}
}
tess.callEndOrEndData();
return true;
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/PriorityQHeap.java 0000644 0001750 0001750 00000023732 11543426510 025223 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
class PriorityQHeap extends PriorityQ {
PriorityQ.PQnode[] nodes;
PriorityQ.PQhandleElem[] handles;
int size, max;
int freeList;
boolean initialized;
PriorityQ.Leq leq;
/* really __gl_pqHeapNewPriorityQ */
PriorityQHeap(PriorityQ.Leq leq) {
size = 0;
max = PriorityQ.INIT_SIZE;
nodes = new PriorityQ.PQnode[PriorityQ.INIT_SIZE + 1];
for (int i = 0; i < nodes.length; i++) {
nodes[i] = new PQnode();
}
handles = new PriorityQ.PQhandleElem[PriorityQ.INIT_SIZE + 1];
for (int i = 0; i < handles.length; i++) {
handles[i] = new PQhandleElem();
}
initialized = false;
freeList = 0;
this.leq = leq;
nodes[1].handle = 1; /* so that Minimum() returns NULL */
handles[1].key = null;
}
/* really __gl_pqHeapDeletePriorityQ */
void pqDeletePriorityQ() {
handles = null;
nodes = null;
}
void FloatDown(int curr) {
PriorityQ.PQnode[] n = nodes;
PriorityQ.PQhandleElem[] h = handles;
int hCurr, hChild;
int child;
hCurr = n[curr].handle;
for (; ;) {
child = curr << 1;
if (child < size && LEQ(leq, h[n[child + 1].handle].key,
h[n[child].handle].key)) {
++child;
}
assert (child <= max);
hChild = n[child].handle;
if (child > size || LEQ(leq, h[hCurr].key, h[hChild].key)) {
n[curr].handle = hCurr;
h[hCurr].node = curr;
break;
}
n[curr].handle = hChild;
h[hChild].node = curr;
curr = child;
}
}
void FloatUp(int curr) {
PriorityQ.PQnode[] n = nodes;
PriorityQ.PQhandleElem[] h = handles;
int hCurr, hParent;
int parent;
hCurr = n[curr].handle;
for (; ;) {
parent = curr >> 1;
hParent = n[parent].handle;
if (parent == 0 || LEQ(leq, h[hParent].key, h[hCurr].key)) {
n[curr].handle = hCurr;
h[hCurr].node = curr;
break;
}
n[curr].handle = hParent;
h[hParent].node = curr;
curr = parent;
}
}
/* really __gl_pqHeapInit */
boolean pqInit() {
int i;
/* This method of building a heap is O(n), rather than O(n lg n). */
for (i = size; i >= 1; --i) {
FloatDown(i);
}
initialized = true;
return true;
}
/* really __gl_pqHeapInsert */
/* returns LONG_MAX iff out of memory */
int pqInsert(Object keyNew) {
int curr;
int free;
curr = ++size;
if ((curr * 2) > max) {
PriorityQ.PQnode[] saveNodes = nodes;
PriorityQ.PQhandleElem[] saveHandles = handles;
/* If the heap overflows, double its size. */
max <<= 1;
// pq->nodes = (PQnode *)memRealloc( pq->nodes, (size_t) ((pq->max + 1) * sizeof( pq->nodes[0] )));
PriorityQ.PQnode[] pqNodes = new PriorityQ.PQnode[max + 1];
System.arraycopy( nodes, 0, pqNodes, 0, nodes.length );
for (int i = nodes.length; i < pqNodes.length; i++) {
pqNodes[i] = new PQnode();
}
nodes = pqNodes;
if (nodes == null) {
nodes = saveNodes; /* restore ptr to free upon return */
return Integer.MAX_VALUE;
}
// pq->handles = (PQhandleElem *)memRealloc( pq->handles,(size_t)((pq->max + 1) * sizeof( pq->handles[0] )));
PriorityQ.PQhandleElem[] pqHandles = new PriorityQ.PQhandleElem[max + 1];
System.arraycopy( handles, 0, pqHandles, 0, handles.length );
for (int i = handles.length; i < pqHandles.length; i++) {
pqHandles[i] = new PQhandleElem();
}
handles = pqHandles;
if (handles == null) {
handles = saveHandles; /* restore ptr to free upon return */
return Integer.MAX_VALUE;
}
}
if (freeList == 0) {
free = curr;
} else {
free = freeList;
freeList = handles[free].node;
}
nodes[curr].handle = free;
handles[free].node = curr;
handles[free].key = keyNew;
if (initialized) {
FloatUp(curr);
}
assert (free != Integer.MAX_VALUE);
return free;
}
/* really __gl_pqHeapExtractMin */
Object pqExtractMin() {
PriorityQ.PQnode[] n = nodes;
PriorityQ.PQhandleElem[] h = handles;
int hMin = n[1].handle;
Object min = h[hMin].key;
if (size > 0) {
n[1].handle = n[size].handle;
h[n[1].handle].node = 1;
h[hMin].key = null;
h[hMin].node = freeList;
freeList = hMin;
if (--size > 0) {
FloatDown(1);
}
}
return min;
}
/* really __gl_pqHeapDelete */
void pqDelete(int hCurr) {
PriorityQ.PQnode[] n = nodes;
PriorityQ.PQhandleElem[] h = handles;
int curr;
assert (hCurr >= 1 && hCurr <= max && h[hCurr].key != null);
curr = h[hCurr].node;
n[curr].handle = n[size].handle;
h[n[curr].handle].node = curr;
if (curr <= --size) {
if (curr <= 1 || LEQ(leq, h[n[curr >> 1].handle].key, h[n[curr].handle].key)) {
FloatDown(curr);
} else {
FloatUp(curr);
}
}
h[hCurr].key = null;
h[hCurr].node = freeList;
freeList = hCurr;
}
Object pqMinimum() {
return handles[nodes[1].handle].key;
}
boolean pqIsEmpty() {
return size == 0;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/GLUtessellatorImpl.java 0000644 0001750 0001750 00000056665 11543426510 026231 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
import org.lwjgl.util.glu.GLUtessellator;
import org.lwjgl.util.glu.GLUtessellatorCallback;
import org.lwjgl.util.glu.GLUtessellatorCallbackAdapter;
import static org.lwjgl.util.glu.GLU.*;
public class GLUtessellatorImpl implements GLUtessellator {
public static final int TESS_MAX_CACHE = 100;
private int state; /* what begin/end calls have we seen? */
private GLUhalfEdge lastEdge; /* lastEdge->Org is the most recent vertex */
GLUmesh mesh; /* stores the input contours, and eventually
the tessellation itself */
/*** state needed for projecting onto the sweep plane ***/
double[] normal = new double[3]; /* user-specified normal (if provided) */
double[] sUnit = new double[3]; /* unit vector in s-direction (debugging) */
double[] tUnit = new double[3]; /* unit vector in t-direction (debugging) */
/*** state needed for the line sweep ***/
private double relTolerance; /* tolerance for merging features */
int windingRule; /* rule for determining polygon interior */
boolean fatalError; /* fatal error: needed combine callback */
Dict dict; /* edge dictionary for sweep line */
PriorityQ pq; /* priority queue of vertex events */
GLUvertex event; /* current sweep event being processed */
/*** state needed for rendering callbacks (see render.c) ***/
boolean flagBoundary; /* mark boundary edges (use EdgeFlag) */
boolean boundaryOnly; /* Extract contours, not triangles */
GLUface lonelyTriList;
/* list of triangles which could not be rendered as strips or fans */
/*** state needed to cache single-contour polygons for renderCache() */
private boolean flushCacheOnNextVertex; /* empty cache on next vertex() call */
int cacheCount; /* number of cached vertices */
CachedVertex[] cache = new CachedVertex[TESS_MAX_CACHE]; /* the vertex data */
/*** rendering callbacks that also pass polygon data ***/
private Object polygonData; /* client data for current polygon */
private GLUtessellatorCallback callBegin;
private GLUtessellatorCallback callEdgeFlag;
private GLUtessellatorCallback callVertex;
private GLUtessellatorCallback callEnd;
// private GLUtessellatorCallback callMesh;
private GLUtessellatorCallback callError;
private GLUtessellatorCallback callCombine;
private GLUtessellatorCallback callBeginData;
private GLUtessellatorCallback callEdgeFlagData;
private GLUtessellatorCallback callVertexData;
private GLUtessellatorCallback callEndData;
// private GLUtessellatorCallback callMeshData;
private GLUtessellatorCallback callErrorData;
private GLUtessellatorCallback callCombineData;
private static final double GLU_TESS_DEFAULT_TOLERANCE = 0.0;
// private static final int GLU_TESS_MESH = 100112; /* void (*)(GLUmesh *mesh) */
private static GLUtessellatorCallback NULL_CB = new GLUtessellatorCallbackAdapter();
// #define MAX_FAST_ALLOC (MAX(sizeof(EdgePair), \
// MAX(sizeof(GLUvertex),sizeof(GLUface))))
public GLUtessellatorImpl() {
state = TessState.T_DORMANT;
normal[0] = 0;
normal[1] = 0;
normal[2] = 0;
relTolerance = GLU_TESS_DEFAULT_TOLERANCE;
windingRule = GLU_TESS_WINDING_ODD;
flagBoundary = false;
boundaryOnly = false;
callBegin = NULL_CB;
callEdgeFlag = NULL_CB;
callVertex = NULL_CB;
callEnd = NULL_CB;
callError = NULL_CB;
callCombine = NULL_CB;
// callMesh = NULL_CB;
callBeginData = NULL_CB;
callEdgeFlagData = NULL_CB;
callVertexData = NULL_CB;
callEndData = NULL_CB;
callErrorData = NULL_CB;
callCombineData = NULL_CB;
polygonData = null;
for (int i = 0; i < cache.length; i++) {
cache[i] = new CachedVertex();
}
}
public static GLUtessellator gluNewTess()
{
return new GLUtessellatorImpl();
}
private void makeDormant() {
/* Return the tessellator to its original dormant state. */
if (mesh != null) {
Mesh.__gl_meshDeleteMesh(mesh);
}
state = TessState.T_DORMANT;
lastEdge = null;
mesh = null;
}
private void requireState(int newState) {
if (state != newState) gotoState(newState);
}
private void gotoState(int newState) {
while (state != newState) {
/* We change the current state one level at a time, to get to
* the desired state.
*/
if (state < newState) {
if (state == TessState.T_DORMANT) {
callErrorOrErrorData(GLU_TESS_MISSING_BEGIN_POLYGON);
gluTessBeginPolygon(null);
} else if (state == TessState.T_IN_POLYGON) {
callErrorOrErrorData(GLU_TESS_MISSING_BEGIN_CONTOUR);
gluTessBeginContour();
}
} else {
if (state == TessState.T_IN_CONTOUR) {
callErrorOrErrorData(GLU_TESS_MISSING_END_CONTOUR);
gluTessEndContour();
} else if (state == TessState.T_IN_POLYGON) {
callErrorOrErrorData(GLU_TESS_MISSING_END_POLYGON);
/* gluTessEndPolygon( tess ) is too much work! */
makeDormant();
}
}
}
}
public void gluDeleteTess() {
requireState(TessState.T_DORMANT);
}
public void gluTessProperty(int which, double value) {
switch (which) {
case GLU_TESS_TOLERANCE:
if (value < 0.0 || value > 1.0) break;
relTolerance = value;
return;
case GLU_TESS_WINDING_RULE:
int windingRule = (int) value;
if (windingRule != value) break; /* not an integer */
switch (windingRule) {
case GLU_TESS_WINDING_ODD:
case GLU_TESS_WINDING_NONZERO:
case GLU_TESS_WINDING_POSITIVE:
case GLU_TESS_WINDING_NEGATIVE:
case GLU_TESS_WINDING_ABS_GEQ_TWO:
this.windingRule = windingRule;
return;
default:
break;
}
case GLU_TESS_BOUNDARY_ONLY:
boundaryOnly = (value != 0);
return;
default:
callErrorOrErrorData(GLU_INVALID_ENUM);
return;
}
callErrorOrErrorData(GLU_INVALID_VALUE);
}
/* Returns tessellator property */
public void gluGetTessProperty(int which, double[] value, int value_offset) {
switch (which) {
case GLU_TESS_TOLERANCE:
/* tolerance should be in range [0..1] */
assert (0.0 <= relTolerance && relTolerance <= 1.0);
value[value_offset] = relTolerance;
break;
case GLU_TESS_WINDING_RULE:
assert (windingRule == GLU_TESS_WINDING_ODD ||
windingRule == GLU_TESS_WINDING_NONZERO ||
windingRule == GLU_TESS_WINDING_POSITIVE ||
windingRule == GLU_TESS_WINDING_NEGATIVE ||
windingRule == GLU_TESS_WINDING_ABS_GEQ_TWO);
value[value_offset] = windingRule;
break;
case GLU_TESS_BOUNDARY_ONLY:
assert (boundaryOnly == true || boundaryOnly == false);
value[value_offset] = boundaryOnly ? 1 : 0;
break;
default:
value[value_offset] = 0.0;
callErrorOrErrorData(GLU_INVALID_ENUM);
break;
}
} /* gluGetTessProperty() */
public void gluTessNormal(double x, double y, double z) {
normal[0] = x;
normal[1] = y;
normal[2] = z;
}
public void gluTessCallback(int which, GLUtessellatorCallback aCallback) {
switch (which) {
case GLU_TESS_BEGIN:
callBegin = aCallback == null ? NULL_CB : aCallback;
return;
case GLU_TESS_BEGIN_DATA:
callBeginData = aCallback == null ? NULL_CB : aCallback;
return;
case GLU_TESS_EDGE_FLAG:
callEdgeFlag = aCallback == null ? NULL_CB : aCallback;
/* If the client wants boundary edges to be flagged,
* we render everything as separate triangles (no strips or fans).
*/
flagBoundary = aCallback != null;
return;
case GLU_TESS_EDGE_FLAG_DATA:
callEdgeFlagData = callBegin = aCallback == null ? NULL_CB : aCallback;
/* If the client wants boundary edges to be flagged,
* we render everything as separate triangles (no strips or fans).
*/
flagBoundary = (aCallback != null);
return;
case GLU_TESS_VERTEX:
callVertex = aCallback == null ? NULL_CB : aCallback;
return;
case GLU_TESS_VERTEX_DATA:
callVertexData = aCallback == null ? NULL_CB : aCallback;
return;
case GLU_TESS_END:
callEnd = aCallback == null ? NULL_CB : aCallback;
return;
case GLU_TESS_END_DATA:
callEndData = aCallback == null ? NULL_CB : aCallback;
return;
case GLU_TESS_ERROR:
callError = aCallback == null ? NULL_CB : aCallback;
return;
case GLU_TESS_ERROR_DATA:
callErrorData = aCallback == null ? NULL_CB : aCallback;
return;
case GLU_TESS_COMBINE:
callCombine = aCallback == null ? NULL_CB : aCallback;
return;
case GLU_TESS_COMBINE_DATA:
callCombineData = aCallback == null ? NULL_CB : aCallback;
return;
// case GLU_TESS_MESH:
// callMesh = aCallback == null ? NULL_CB : aCallback;
// return;
default:
callErrorOrErrorData(GLU_INVALID_ENUM);
return;
}
}
private boolean addVertex(double[] coords, Object vertexData) {
GLUhalfEdge e;
e = lastEdge;
if (e == null) {
/* Make a self-loop (one vertex, one edge). */
e = Mesh.__gl_meshMakeEdge(mesh);
if (e == null) return false;
if (!Mesh.__gl_meshSplice(e, e.Sym)) return false;
} else {
/* Create a new vertex and edge which immediately follow e
* in the ordering around the left face.
*/
if (Mesh.__gl_meshSplitEdge(e) == null) return false;
e = e.Lnext;
}
/* The new vertex is now e.Org. */
e.Org.data = vertexData;
e.Org.coords[0] = coords[0];
e.Org.coords[1] = coords[1];
e.Org.coords[2] = coords[2];
/* The winding of an edge says how the winding number changes as we
* cross from the edge''s right face to its left face. We add the
* vertices in such an order that a CCW contour will add +1 to
* the winding number of the region inside the contour.
*/
e.winding = 1;
e.Sym.winding = -1;
lastEdge = e;
return true;
}
private void cacheVertex(double[] coords, Object vertexData) {
if (cache[cacheCount] == null) {
cache[cacheCount] = new CachedVertex();
}
CachedVertex v = cache[cacheCount];
v.data = vertexData;
v.coords[0] = coords[0];
v.coords[1] = coords[1];
v.coords[2] = coords[2];
++cacheCount;
}
private boolean flushCache() {
CachedVertex[] v = cache;
mesh = Mesh.__gl_meshNewMesh();
if (mesh == null) return false;
for (int i = 0; i < cacheCount; i++) {
CachedVertex vertex = v[i];
if (!addVertex(vertex.coords, vertex.data)) return false;
}
cacheCount = 0;
flushCacheOnNextVertex = false;
return true;
}
public void gluTessVertex(double[] coords, int coords_offset, Object vertexData) {
int i;
boolean tooLarge = false;
double x;
double[] clamped = new double[3];
requireState(TessState.T_IN_CONTOUR);
if (flushCacheOnNextVertex) {
if (!flushCache()) {
callErrorOrErrorData(GLU_OUT_OF_MEMORY);
return;
}
lastEdge = null;
}
for (i = 0; i < 3; ++i) {
x = coords[i+coords_offset];
if (x < -GLU_TESS_MAX_COORD) {
x = -GLU_TESS_MAX_COORD;
tooLarge = true;
}
if (x > GLU_TESS_MAX_COORD) {
x = GLU_TESS_MAX_COORD;
tooLarge = true;
}
clamped[i] = x;
}
if (tooLarge) {
callErrorOrErrorData(GLU_TESS_COORD_TOO_LARGE);
}
if (mesh == null) {
if (cacheCount < TESS_MAX_CACHE) {
cacheVertex(clamped, vertexData);
return;
}
if (!flushCache()) {
callErrorOrErrorData(GLU_OUT_OF_MEMORY);
return;
}
}
if (!addVertex(clamped, vertexData)) {
callErrorOrErrorData(GLU_OUT_OF_MEMORY);
}
}
public void gluTessBeginPolygon(Object data) {
requireState(TessState.T_DORMANT);
state = TessState.T_IN_POLYGON;
cacheCount = 0;
flushCacheOnNextVertex = false;
mesh = null;
polygonData = data;
}
public void gluTessBeginContour() {
requireState(TessState.T_IN_POLYGON);
state = TessState.T_IN_CONTOUR;
lastEdge = null;
if (cacheCount > 0) {
/* Just set a flag so we don't get confused by empty contours
* -- these can be generated accidentally with the obsolete
* NextContour() interface.
*/
flushCacheOnNextVertex = true;
}
}
public void gluTessEndContour() {
requireState(TessState.T_IN_CONTOUR);
state = TessState.T_IN_POLYGON;
}
public void gluTessEndPolygon() {
GLUmesh mesh;
try {
requireState(TessState.T_IN_POLYGON);
state = TessState.T_DORMANT;
if (this.mesh == null) {
if (!flagBoundary /*&& callMesh == NULL_CB*/) {
/* Try some special code to make the easy cases go quickly
* (eg. convex polygons). This code does NOT handle multiple contours,
* intersections, edge flags, and of course it does not generate
* an explicit mesh either.
*/
if (Render.__gl_renderCache(this)) {
polygonData = null;
return;
}
}
if (!flushCache()) throw new RuntimeException(); /* could've used a label*/
}
/* Determine the polygon normal and project vertices onto the plane
* of the polygon.
*/
Normal.__gl_projectPolygon(this);
/* __gl_computeInterior( tess ) computes the planar arrangement specified
* by the given contours, and further subdivides this arrangement
* into regions. Each region is marked "inside" if it belongs
* to the polygon, according to the rule given by windingRule.
* Each interior region is guaranteed be monotone.
*/
if (!Sweep.__gl_computeInterior(this)) {
throw new RuntimeException(); /* could've used a label */
}
mesh = this.mesh;
if (!fatalError) {
boolean rc = true;
/* If the user wants only the boundary contours, we throw away all edges
* except those which separate the interior from the exterior.
* Otherwise we tessellate all the regions marked "inside".
*/
if (boundaryOnly) {
rc = TessMono.__gl_meshSetWindingNumber(mesh, 1, true);
} else {
rc = TessMono.__gl_meshTessellateInterior(mesh);
}
if (!rc) throw new RuntimeException(); /* could've used a label */
Mesh.__gl_meshCheckMesh(mesh);
if (callBegin != NULL_CB || callEnd != NULL_CB
|| callVertex != NULL_CB || callEdgeFlag != NULL_CB
|| callBeginData != NULL_CB
|| callEndData != NULL_CB
|| callVertexData != NULL_CB
|| callEdgeFlagData != NULL_CB) {
if (boundaryOnly) {
Render.__gl_renderBoundary(this, mesh); /* output boundary contours */
} else {
Render.__gl_renderMesh(this, mesh); /* output strips and fans */
}
}
// if (callMesh != NULL_CB) {
//
///* Throw away the exterior faces, so that all faces are interior.
// * This way the user doesn't have to check the "inside" flag,
// * and we don't need to even reveal its existence. It also leaves
// * the freedom for an implementation to not generate the exterior
// * faces in the first place.
// */
// TessMono.__gl_meshDiscardExterior(mesh);
// callMesh.mesh(mesh); /* user wants the mesh itself */
// mesh = null;
// polygonData = null;
// return;
// }
}
Mesh.__gl_meshDeleteMesh(mesh);
polygonData = null;
mesh = null;
} catch (Exception e) {
e.printStackTrace();
callErrorOrErrorData(GLU_OUT_OF_MEMORY);
}
}
/*******************************************************/
/* Obsolete calls -- for backward compatibility */
public void gluBeginPolygon() {
gluTessBeginPolygon(null);
gluTessBeginContour();
}
/*ARGSUSED*/
public void gluNextContour(int type) {
gluTessEndContour();
gluTessBeginContour();
}
public void gluEndPolygon() {
gluTessEndContour();
gluTessEndPolygon();
}
void callBeginOrBeginData(int a) {
if (callBeginData != NULL_CB)
callBeginData.beginData(a, polygonData);
else
callBegin.begin(a);
}
void callVertexOrVertexData(Object a) {
if (callVertexData != NULL_CB)
callVertexData.vertexData(a, polygonData);
else
callVertex.vertex(a);
}
void callEdgeFlagOrEdgeFlagData(boolean a) {
if (callEdgeFlagData != NULL_CB)
callEdgeFlagData.edgeFlagData(a, polygonData);
else
callEdgeFlag.edgeFlag(a);
}
void callEndOrEndData() {
if (callEndData != NULL_CB)
callEndData.endData(polygonData);
else
callEnd.end();
}
void callCombineOrCombineData(double[] coords, Object[] vertexData, float[] weights, Object[] outData) {
if (callCombineData != NULL_CB)
callCombineData.combineData(coords, vertexData, weights, outData, polygonData);
else
callCombine.combine(coords, vertexData, weights, outData);
}
void callErrorOrErrorData(int a) {
if (callErrorData != NULL_CB)
callErrorData.errorData(a, polygonData);
else
callError.error(a);
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/TessState.java 0000644 0001750 0001750 00000010515 11543426510 024375 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
class TessState {
public static final int T_DORMANT = 0;
public static final int T_IN_POLYGON = 1;
public static final int T_IN_CONTOUR = 2;
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/Geom.java 0000644 0001750 0001750 00000031064 11543426510 023347 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
class Geom {
private Geom() {
}
/* Given three vertices u,v,w such that VertLeq(u,v) && VertLeq(v,w),
* evaluates the t-coord of the edge uw at the s-coord of the vertex v.
* Returns v->t - (uw)(v->s), ie. the signed distance from uw to v.
* If uw is vertical (and thus passes thru v), the result is zero.
*
* The calculation is extremely accurate and stable, even when v
* is very close to u or w. In particular if we set v->t = 0 and
* let r be the negated result (this evaluates (uw)(v->s)), then
* r is guaranteed to satisfy MIN(u->t,w->t) <= r <= MAX(u->t,w->t).
*/
static double EdgeEval(GLUvertex u, GLUvertex v, GLUvertex w) {
double gapL, gapR;
assert (VertLeq(u, v) && VertLeq(v, w));
gapL = v.s - u.s;
gapR = w.s - v.s;
if (gapL + gapR > 0) {
if (gapL < gapR) {
return (v.t - u.t) + (u.t - w.t) * (gapL / (gapL + gapR));
} else {
return (v.t - w.t) + (w.t - u.t) * (gapR / (gapL + gapR));
}
}
/* vertical line */
return 0;
}
static double EdgeSign(GLUvertex u, GLUvertex v, GLUvertex w) {
double gapL, gapR;
assert (VertLeq(u, v) && VertLeq(v, w));
gapL = v.s - u.s;
gapR = w.s - v.s;
if (gapL + gapR > 0) {
return (v.t - w.t) * gapL + (v.t - u.t) * gapR;
}
/* vertical line */
return 0;
}
/***********************************************************************
* Define versions of EdgeSign, EdgeEval with s and t transposed.
*/
static double TransEval(GLUvertex u, GLUvertex v, GLUvertex w) {
/* Given three vertices u,v,w such that TransLeq(u,v) && TransLeq(v,w),
* evaluates the t-coord of the edge uw at the s-coord of the vertex v.
* Returns v->s - (uw)(v->t), ie. the signed distance from uw to v.
* If uw is vertical (and thus passes thru v), the result is zero.
*
* The calculation is extremely accurate and stable, even when v
* is very close to u or w. In particular if we set v->s = 0 and
* let r be the negated result (this evaluates (uw)(v->t)), then
* r is guaranteed to satisfy MIN(u->s,w->s) <= r <= MAX(u->s,w->s).
*/
double gapL, gapR;
assert (TransLeq(u, v) && TransLeq(v, w));
gapL = v.t - u.t;
gapR = w.t - v.t;
if (gapL + gapR > 0) {
if (gapL < gapR) {
return (v.s - u.s) + (u.s - w.s) * (gapL / (gapL + gapR));
} else {
return (v.s - w.s) + (w.s - u.s) * (gapR / (gapL + gapR));
}
}
/* vertical line */
return 0;
}
static double TransSign(GLUvertex u, GLUvertex v, GLUvertex w) {
/* Returns a number whose sign matches TransEval(u,v,w) but which
* is cheaper to evaluate. Returns > 0, == 0 , or < 0
* as v is above, on, or below the edge uw.
*/
double gapL, gapR;
assert (TransLeq(u, v) && TransLeq(v, w));
gapL = v.t - u.t;
gapR = w.t - v.t;
if (gapL + gapR > 0) {
return (v.s - w.s) * gapL + (v.s - u.s) * gapR;
}
/* vertical line */
return 0;
}
static boolean VertCCW(GLUvertex u, GLUvertex v, GLUvertex w) {
/* For almost-degenerate situations, the results are not reliable.
* Unless the floating-point arithmetic can be performed without
* rounding errors, *any* implementation will give incorrect results
* on some degenerate inputs, so the client must have some way to
* handle this situation.
*/
return (u.s * (v.t - w.t) + v.s * (w.t - u.t) + w.s * (u.t - v.t)) >= 0;
}
/* Given parameters a,x,b,y returns the value (b*x+a*y)/(a+b),
* or (x+y)/2 if a==b==0. It requires that a,b >= 0, and enforces
* this in the rare case that one argument is slightly negative.
* The implementation is extremely stable numerically.
* In particular it guarantees that the result r satisfies
* MIN(x,y) <= r <= MAX(x,y), and the results are very accurate
* even when a and b differ greatly in magnitude.
*/
static double Interpolate(double a, double x, double b, double y) {
a = (a < 0) ? 0 : a;
b = (b < 0) ? 0 : b;
if (a <= b) {
if (b == 0) {
return (x + y) / 2.0;
} else {
return (x + (y - x) * (a / (a + b)));
}
} else {
return (y + (x - y) * (b / (a + b)));
}
}
static void EdgeIntersect(GLUvertex o1, GLUvertex d1,
GLUvertex o2, GLUvertex d2,
GLUvertex v)
/* Given edges (o1,d1) and (o2,d2), compute their point of intersection.
* The computed point is guaranteed to lie in the intersection of the
* bounding rectangles defined by each edge.
*/ {
double z1, z2;
/* This is certainly not the most efficient way to find the intersection
* of two line segments, but it is very numerically stable.
*
* Strategy: find the two middle vertices in the VertLeq ordering,
* and interpolate the intersection s-value from these. Then repeat
* using the TransLeq ordering to find the intersection t-value.
*/
if (!VertLeq(o1, d1)) {
GLUvertex temp = o1;
o1 = d1;
d1 = temp;
}
if (!VertLeq(o2, d2)) {
GLUvertex temp = o2;
o2 = d2;
d2 = temp;
}
if (!VertLeq(o1, o2)) {
GLUvertex temp = o1;
o1 = o2;
o2 = temp;
temp = d1;
d1 = d2;
d2 = temp;
}
if (!VertLeq(o2, d1)) {
/* Technically, no intersection -- do our best */
v.s = (o2.s + d1.s) / 2.0;
} else if (VertLeq(d1, d2)) {
/* Interpolate between o2 and d1 */
z1 = EdgeEval(o1, o2, d1);
z2 = EdgeEval(o2, d1, d2);
if (z1 + z2 < 0) {
z1 = -z1;
z2 = -z2;
}
v.s = Interpolate(z1, o2.s, z2, d1.s);
} else {
/* Interpolate between o2 and d2 */
z1 = EdgeSign(o1, o2, d1);
z2 = -EdgeSign(o1, d2, d1);
if (z1 + z2 < 0) {
z1 = -z1;
z2 = -z2;
}
v.s = Interpolate(z1, o2.s, z2, d2.s);
}
/* Now repeat the process for t */
if (!TransLeq(o1, d1)) {
GLUvertex temp = o1;
o1 = d1;
d1 = temp;
}
if (!TransLeq(o2, d2)) {
GLUvertex temp = o2;
o2 = d2;
d2 = temp;
}
if (!TransLeq(o1, o2)) {
GLUvertex temp = o2;
o2 = o1;
o1 = temp;
temp = d2;
d2 = d1;
d1 = temp;
}
if (!TransLeq(o2, d1)) {
/* Technically, no intersection -- do our best */
v.t = (o2.t + d1.t) / 2.0;
} else if (TransLeq(d1, d2)) {
/* Interpolate between o2 and d1 */
z1 = TransEval(o1, o2, d1);
z2 = TransEval(o2, d1, d2);
if (z1 + z2 < 0) {
z1 = -z1;
z2 = -z2;
}
v.t = Interpolate(z1, o2.t, z2, d1.t);
} else {
/* Interpolate between o2 and d2 */
z1 = TransSign(o1, o2, d1);
z2 = -TransSign(o1, d2, d1);
if (z1 + z2 < 0) {
z1 = -z1;
z2 = -z2;
}
v.t = Interpolate(z1, o2.t, z2, d2.t);
}
}
static boolean VertEq(GLUvertex u, GLUvertex v) {
return u.s == v.s && u.t == v.t;
}
static boolean VertLeq(GLUvertex u, GLUvertex v) {
return u.s < v.s || (u.s == v.s && u.t <= v.t);
}
/* Versions of VertLeq, EdgeSign, EdgeEval with s and t transposed. */
static boolean TransLeq(GLUvertex u, GLUvertex v) {
return u.t < v.t || (u.t == v.t && u.s <= v.s);
}
static boolean EdgeGoesLeft(GLUhalfEdge e) {
return VertLeq(e.Sym.Org, e.Org);
}
static boolean EdgeGoesRight(GLUhalfEdge e) {
return VertLeq(e.Org, e.Sym.Org);
}
static double VertL1dist(GLUvertex u, GLUvertex v) {
return Math.abs(u.s - v.s) + Math.abs(u.t - v.t);
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/tessellation/GLUvertex.java 0000644 0001750 0001750 00000011242 11543426510 024341 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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.
*/
/*
* Portions Copyright (C) 2003-2006 Sun Microsystems, Inc.
* All rights reserved.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** NOTE: The Original Code (as defined below) has been licensed to Sun
** Microsystems, Inc. ("Sun") under the SGI Free Software License B
** (Version 1.1), shown above ("SGI License"). Pursuant to Section
** 3.2(3) of the SGI License, Sun is distributing the Covered Code to
** you under an alternative license ("Alternative License"). This
** Alternative License includes all of the provisions of the SGI License
** except that Section 2.2 and 11 are omitted. Any differences between
** the Alternative License and the SGI License are offered solely by Sun
** and not by SGI.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
** Author: Eric Veach, July 1994
** Java Port: Pepijn Van Eeckhoudt, July 2003
** Java Port: Nathan Parker Burg, August 2003
*/
package org.lwjgl.util.glu.tessellation;
class GLUvertex {
public GLUvertex next; /* next vertex (never NULL) */
public GLUvertex prev; /* previous vertex (never NULL) */
public GLUhalfEdge anEdge; /* a half-edge with this origin */
public Object data; /* client's data */
/* Internal data (keep hidden) */
public double[] coords = new double[3]; /* vertex location in 3D */
public double s, t; /* projection onto the sweep plane */
public int pqHandle; /* to allow deletion from priority queue */
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/Quadric.java 0000644 0001750 0001750 00000012406 11543426510 021341 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.glu;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.util.glu.GLU.*;
/**
* Quadric.java
*
*
* Created 22-dec-2003
* @author Erik Duijs
*/
public class Quadric {
protected int drawStyle;
protected int orientation;
protected boolean textureFlag;
protected int normals;
/**
* Constructor for Quadric.
*/
public Quadric() {
super();
drawStyle = GLU_FILL;
orientation = GLU_OUTSIDE;
textureFlag = false;
normals = GLU_SMOOTH;
}
/**
* Call glNormal3f after scaling normal to unit length.
*
* @param x
* @param y
* @param z
*/
protected void normal3f(float x, float y, float z) {
float mag;
mag = (float)Math.sqrt(x * x + y * y + z * z);
if (mag > 0.00001F) {
x /= mag;
y /= mag;
z /= mag;
}
glNormal3f(x, y, z);
}
/**
* specifies the draw style for quadrics.
*
* The legal values are as follows:
*
* GLU.FILL: Quadrics are rendered with polygon primitives. The polygons
* are drawn in a counterclockwise fashion with respect to
* their normals (as defined with glu.quadricOrientation).
*
* GLU.LINE: Quadrics are rendered as a set of lines.
*
* GLU.SILHOUETTE: Quadrics are rendered as a set of lines, except that edges
* separating coplanar faces will not be drawn.
*
* GLU.POINT: Quadrics are rendered as a set of points.
*
* @param drawStyle The drawStyle to set
*/
public void setDrawStyle(int drawStyle) {
this.drawStyle = drawStyle;
}
/**
* specifies what kind of normals are desired for quadrics.
* The legal values are as follows:
*
* GLU.NONE: No normals are generated.
*
* GLU.FLAT: One normal is generated for every facet of a quadric.
*
* GLU.SMOOTH: One normal is generated for every vertex of a quadric. This
* is the default.
*
* @param normals The normals to set
*/
public void setNormals(int normals) {
this.normals = normals;
}
/**
* specifies what kind of orientation is desired for.
* The orientation values are as follows:
*
* GLU.OUTSIDE: Quadrics are drawn with normals pointing outward.
*
* GLU.INSIDE: Normals point inward. The default is GLU.OUTSIDE.
*
* Note that the interpretation of outward and inward depends on the quadric
* being drawn.
*
* @param orientation The orientation to set
*/
public void setOrientation(int orientation) {
this.orientation = orientation;
}
/**
* specifies if texture coordinates should be generated for
* quadrics rendered with qobj. If the value of textureCoords is true,
* then texture coordinates are generated, and if textureCoords is false,
* they are not.. The default is false.
*
* The manner in which texture coordinates are generated depends upon the
* specific quadric rendered.
*
* @param textureFlag The textureFlag to set
*/
public void setTextureFlag(boolean textureFlag) {
this.textureFlag = textureFlag;
}
/**
* Returns the drawStyle.
* @return int
*/
public int getDrawStyle() {
return drawStyle;
}
/**
* Returns the normals.
* @return int
*/
public int getNormals() {
return normals;
}
/**
* Returns the orientation.
* @return int
*/
public int getOrientation() {
return orientation;
}
/**
* Returns the textureFlag.
* @return boolean
*/
public boolean getTextureFlag() {
return textureFlag;
}
protected void TXTR_COORD(float x, float y) {
if (textureFlag) glTexCoord2f(x,y);
}
protected float sin(float r) {
return (float)Math.sin(r);
}
protected float cos(float r) {
return (float)Math.cos(r);
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/Sphere.java 0000644 0001750 0001750 00000015072 11543426510 021201 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.glu;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.util.glu.GLU.*;
/**
* Sphere.java
*
*
* Created 23-dec-2003
* @author Erik Duijs
*/
public class Sphere extends Quadric {
/**
* Constructor
*/
public Sphere() {
super();
}
/**
* draws a sphere of the given radius centered around the origin.
* The sphere is subdivided around the z axis into slices and along the z axis
* into stacks (similar to lines of longitude and latitude).
*
* If the orientation is set to GLU.OUTSIDE (with glu.quadricOrientation), then
* any normals generated point away from the center of the sphere. Otherwise,
* they point toward the center of the sphere.
* If texturing is turned on (with glu.quadricTexture), then texture
* coordinates are generated so that t ranges from 0.0 at z=-radius to 1.0 at
* z=radius (t increases linearly along longitudinal lines), and s ranges from
* 0.0 at the +y axis, to 0.25 at the +x axis, to 0.5 at the -y axis, to 0.75
* at the -x axis, and back to 1.0 at the +y axis.
*/
public void draw(float radius, int slices, int stacks) {
// TODO
float rho, drho, theta, dtheta;
float x, y, z;
float s, t, ds, dt;
int i, j, imin, imax;
boolean normals;
float nsign;
normals = super.normals != GLU_NONE;
if (super.orientation == GLU_INSIDE) {
nsign = -1.0f;
} else {
nsign = 1.0f;
}
drho = PI / stacks;
dtheta = 2.0f * PI / slices;
if (super.drawStyle == GLU_FILL) {
if (!super.textureFlag) {
// draw +Z end as a triangle fan
glBegin(GL_TRIANGLE_FAN);
glNormal3f(0.0f, 0.0f, 1.0f);
glVertex3f(0.0f, 0.0f, nsign * radius);
for (j = 0; j <= slices; j++) {
theta = (j == slices) ? 0.0f : j * dtheta;
x = -sin(theta) * sin(drho);
y = cos(theta) * sin(drho);
z = nsign * cos(drho);
if (normals) {
glNormal3f(x * nsign, y * nsign, z * nsign);
}
glVertex3f(x * radius, y * radius, z * radius);
}
glEnd();
}
ds = 1.0f / slices;
dt = 1.0f / stacks;
t = 1.0f; // because loop now runs from 0
if (super.textureFlag) {
imin = 0;
imax = stacks;
} else {
imin = 1;
imax = stacks - 1;
}
// draw intermediate stacks as quad strips
for (i = imin; i < imax; i++) {
rho = i * drho;
glBegin(GL_QUAD_STRIP);
s = 0.0f;
for (j = 0; j <= slices; j++) {
theta = (j == slices) ? 0.0f : j * dtheta;
x = -sin(theta) * sin(rho);
y = cos(theta) * sin(rho);
z = nsign * cos(rho);
if (normals) {
glNormal3f(x * nsign, y * nsign, z * nsign);
}
TXTR_COORD(s, t);
glVertex3f(x * radius, y * radius, z * radius);
x = -sin(theta) * sin(rho + drho);
y = cos(theta) * sin(rho + drho);
z = nsign * cos(rho + drho);
if (normals) {
glNormal3f(x * nsign, y * nsign, z * nsign);
}
TXTR_COORD(s, t - dt);
s += ds;
glVertex3f(x * radius, y * radius, z * radius);
}
glEnd();
t -= dt;
}
if (!super.textureFlag) {
// draw -Z end as a triangle fan
glBegin(GL_TRIANGLE_FAN);
glNormal3f(0.0f, 0.0f, -1.0f);
glVertex3f(0.0f, 0.0f, -radius * nsign);
rho = PI - drho;
s = 1.0f;
for (j = slices; j >= 0; j--) {
theta = (j == slices) ? 0.0f : j * dtheta;
x = -sin(theta) * sin(rho);
y = cos(theta) * sin(rho);
z = nsign * cos(rho);
if (normals)
glNormal3f(x * nsign, y * nsign, z * nsign);
s -= ds;
glVertex3f(x * radius, y * radius, z * radius);
}
glEnd();
}
} else if (
super.drawStyle == GLU_LINE
|| super.drawStyle == GLU_SILHOUETTE) {
// draw stack lines
for (i = 1;
i < stacks;
i++) { // stack line at i==stacks-1 was missing here
rho = i * drho;
glBegin(GL_LINE_LOOP);
for (j = 0; j < slices; j++) {
theta = j * dtheta;
x = cos(theta) * sin(rho);
y = sin(theta) * sin(rho);
z = cos(rho);
if (normals)
glNormal3f(x * nsign, y * nsign, z * nsign);
glVertex3f(x * radius, y * radius, z * radius);
}
glEnd();
}
// draw slice lines
for (j = 0; j < slices; j++) {
theta = j * dtheta;
glBegin(GL_LINE_STRIP);
for (i = 0; i <= stacks; i++) {
rho = i * drho;
x = cos(theta) * sin(rho);
y = sin(theta) * sin(rho);
z = cos(rho);
if (normals)
glNormal3f(x * nsign, y * nsign, z * nsign);
glVertex3f(x * radius, y * radius, z * radius);
}
glEnd();
}
} else if (super.drawStyle == GLU_POINT) {
// top and bottom-most points
glBegin(GL_POINTS);
if (normals)
glNormal3f(0.0f, 0.0f, nsign);
glVertex3f(0.0f, 0.0f, radius);
if (normals)
glNormal3f(0.0f, 0.0f, -nsign);
glVertex3f(0.0f, 0.0f, -radius);
// loop over stacks
for (i = 1; i < stacks - 1; i++) {
rho = i * drho;
for (j = 0; j < slices; j++) {
theta = j * dtheta;
x = cos(theta) * sin(rho);
y = sin(theta) * sin(rho);
z = cos(rho);
if (normals)
glNormal3f(x * nsign, y * nsign, z * nsign);
glVertex3f(x * radius, y * radius, z * radius);
}
}
glEnd();
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/GLU.java 0000644 0001750 0001750 00000035241 11543426510 020402 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.glu;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import org.lwjgl.opengl.Util;
import org.lwjgl.util.glu.tessellation.GLUtessellatorImpl;
import static org.lwjgl.opengl.GL11.*;
/**
* GLU.java
*
*
* Created 23-dec-2003
* @author Erik Duijs
*/
public class GLU {
static final float PI = (float)Math.PI;
/* Errors: (return value 0 = no error) */
public static final int GLU_INVALID_ENUM = 100900;
public static final int GLU_INVALID_VALUE = 100901;
public static final int GLU_OUT_OF_MEMORY = 100902;
public static final int GLU_INCOMPATIBLE_GL_VERSION = 100903;
/* StringName */
public static final int GLU_VERSION = 100800;
public static final int GLU_EXTENSIONS = 100801;
/* Boolean */
public static final boolean GLU_TRUE = true;
public static final boolean GLU_FALSE = false;
/**** Quadric constants ****/
/* QuadricNormal */
public static final int GLU_SMOOTH = 100000;
public static final int GLU_FLAT = 100001;
public static final int GLU_NONE = 100002;
/* QuadricDrawStyle */
public static final int GLU_POINT = 100010;
public static final int GLU_LINE = 100011;
public static final int GLU_FILL = 100012;
public static final int GLU_SILHOUETTE = 100013;
/* QuadricOrientation */
public static final int GLU_OUTSIDE = 100020;
public static final int GLU_INSIDE = 100021;
/* Callback types: */
/* ERROR = 100103 */
/**** Tesselation constants ****/
public static final double GLU_TESS_MAX_COORD = 1.0e150;
public static final double TESS_MAX_COORD = 1.0e150;
/* TessProperty */
public static final int GLU_TESS_WINDING_RULE = 100140;
public static final int GLU_TESS_BOUNDARY_ONLY = 100141;
public static final int GLU_TESS_TOLERANCE = 100142;
/* TessWinding */
public static final int GLU_TESS_WINDING_ODD = 100130;
public static final int GLU_TESS_WINDING_NONZERO = 100131;
public static final int GLU_TESS_WINDING_POSITIVE = 100132;
public static final int GLU_TESS_WINDING_NEGATIVE = 100133;
public static final int GLU_TESS_WINDING_ABS_GEQ_TWO = 100134;
/* TessCallback */
public static final int GLU_TESS_BEGIN = 100100; /* void (CALLBACK*)(GLenum type) */
public static final int GLU_TESS_VERTEX = 100101; /* void (CALLBACK*)(void *data) */
public static final int GLU_TESS_END = 100102; /* void (CALLBACK*)(void) */
public static final int GLU_TESS_ERROR = 100103; /* void (CALLBACK*)(GLenum errno) */
public static final int GLU_TESS_EDGE_FLAG = 100104; /* void (CALLBACK*)(GLboolean boundaryEdge) */
public static final int GLU_TESS_COMBINE = 100105; /* void (CALLBACK*)(GLdouble coords[3],
void *data[4],
GLfloat weight[4],
void **dataOut) */
public static final int GLU_TESS_BEGIN_DATA = 100106; /* void (CALLBACK*)(GLenum type,
void *polygon_data) */
public static final int GLU_TESS_VERTEX_DATA = 100107; /* void (CALLBACK*)(void *data,
void *polygon_data) */
public static final int GLU_TESS_END_DATA = 100108; /* void (CALLBACK*)(void *polygon_data) */
public static final int GLU_TESS_ERROR_DATA = 100109; /* void (CALLBACK*)(GLenum errno,
void *polygon_data) */
public static final int GLU_TESS_EDGE_FLAG_DATA = 100110; /* void (CALLBACK*)(GLboolean boundaryEdge,
void *polygon_data) */
public static final int GLU_TESS_COMBINE_DATA = 100111; /* void (CALLBACK*)(GLdouble coords[3],
void *data[4],
GLfloat weight[4],
void **dataOut,
void *polygon_data) */
/* TessError */
public static final int GLU_TESS_ERROR1 = 100151;
public static final int GLU_TESS_ERROR2 = 100152;
public static final int GLU_TESS_ERROR3 = 100153;
public static final int GLU_TESS_ERROR4 = 100154;
public static final int GLU_TESS_ERROR5 = 100155;
public static final int GLU_TESS_ERROR6 = 100156;
public static final int GLU_TESS_ERROR7 = 100157;
public static final int GLU_TESS_ERROR8 = 100158;
public static final int GLU_TESS_MISSING_BEGIN_POLYGON = GLU_TESS_ERROR1;
public static final int GLU_TESS_MISSING_BEGIN_CONTOUR = GLU_TESS_ERROR2;
public static final int GLU_TESS_MISSING_END_POLYGON = GLU_TESS_ERROR3;
public static final int GLU_TESS_MISSING_END_CONTOUR = GLU_TESS_ERROR4;
public static final int GLU_TESS_COORD_TOO_LARGE = GLU_TESS_ERROR5;
public static final int GLU_TESS_NEED_COMBINE_CALLBACK = GLU_TESS_ERROR6;
/**** NURBS constants ****/
/* NurbsProperty */
public static final int GLU_AUTO_LOAD_MATRIX = 100200;
public static final int GLU_CULLING = 100201;
public static final int GLU_SAMPLING_TOLERANCE = 100203;
public static final int GLU_DISPLAY_MODE = 100204;
public static final int GLU_PARAMETRIC_TOLERANCE = 100202;
public static final int GLU_SAMPLING_METHOD = 100205;
public static final int GLU_U_STEP = 100206;
public static final int GLU_V_STEP = 100207;
/* NurbsSampling */
public static final int GLU_PATH_LENGTH = 100215;
public static final int GLU_PARAMETRIC_ERROR = 100216;
public static final int GLU_DOMAIN_DISTANCE = 100217;
/* NurbsTrim */
public static final int GLU_MAP1_TRIM_2 = 100210;
public static final int GLU_MAP1_TRIM_3 = 100211;
/* NurbsDisplay */
/* FILL = 100012 */
public static final int GLU_OUTLINE_POLYGON = 100240;
public static final int GLU_OUTLINE_PATCH = 100241;
/* NurbsCallback */
/* ERROR = 100103 */
/* NurbsErrors */
public static final int GLU_NURBS_ERROR1 = 100251;
public static final int GLU_NURBS_ERROR2 = 100252;
public static final int GLU_NURBS_ERROR3 = 100253;
public static final int GLU_NURBS_ERROR4 = 100254;
public static final int GLU_NURBS_ERROR5 = 100255;
public static final int GLU_NURBS_ERROR6 = 100256;
public static final int GLU_NURBS_ERROR7 = 100257;
public static final int GLU_NURBS_ERROR8 = 100258;
public static final int GLU_NURBS_ERROR9 = 100259;
public static final int GLU_NURBS_ERROR10 = 100260;
public static final int GLU_NURBS_ERROR11 = 100261;
public static final int GLU_NURBS_ERROR12 = 100262;
public static final int GLU_NURBS_ERROR13 = 100263;
public static final int GLU_NURBS_ERROR14 = 100264;
public static final int GLU_NURBS_ERROR15 = 100265;
public static final int GLU_NURBS_ERROR16 = 100266;
public static final int GLU_NURBS_ERROR17 = 100267;
public static final int GLU_NURBS_ERROR18 = 100268;
public static final int GLU_NURBS_ERROR19 = 100269;
public static final int GLU_NURBS_ERROR20 = 100270;
public static final int GLU_NURBS_ERROR21 = 100271;
public static final int GLU_NURBS_ERROR22 = 100272;
public static final int GLU_NURBS_ERROR23 = 100273;
public static final int GLU_NURBS_ERROR24 = 100274;
public static final int GLU_NURBS_ERROR25 = 100275;
public static final int GLU_NURBS_ERROR26 = 100276;
public static final int GLU_NURBS_ERROR27 = 100277;
public static final int GLU_NURBS_ERROR28 = 100278;
public static final int GLU_NURBS_ERROR29 = 100279;
public static final int GLU_NURBS_ERROR30 = 100280;
public static final int GLU_NURBS_ERROR31 = 100281;
public static final int GLU_NURBS_ERROR32 = 100282;
public static final int GLU_NURBS_ERROR33 = 100283;
public static final int GLU_NURBS_ERROR34 = 100284;
public static final int GLU_NURBS_ERROR35 = 100285;
public static final int GLU_NURBS_ERROR36 = 100286;
public static final int GLU_NURBS_ERROR37 = 100287;
/* Contours types -- obsolete! */
public static final int GLU_CW = 100120;
public static final int GLU_CCW = 100121;
public static final int GLU_INTERIOR = 100122;
public static final int GLU_EXTERIOR = 100123;
public static final int GLU_UNKNOWN = 100124;
/* Names without "TESS_" prefix */
public static final int GLU_BEGIN = GLU_TESS_BEGIN;
public static final int GLU_VERTEX = GLU_TESS_VERTEX;
public static final int GLU_END = GLU_TESS_END;
public static final int GLU_ERROR = GLU_TESS_ERROR;
public static final int GLU_EDGE_FLAG = GLU_TESS_EDGE_FLAG;
/**
* Method gluLookAt
* @param eyex
* @param eyey
* @param eyez
* @param centerx
* @param centery
* @param centerz
* @param upx
* @param upy
* @param upz
*/
public static void gluLookAt(
float eyex,
float eyey,
float eyez,
float centerx,
float centery,
float centerz,
float upx,
float upy,
float upz) {
Project.gluLookAt(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz);
}
/**
* Method gluOrtho2D
* @param left
* @param right
* @param bottom
* @param top
*/
public static void gluOrtho2D(
float left,
float right,
float bottom,
float top) {
glOrtho(left, right, bottom, top, -1.0, 1.0);
}
/**
* Method gluPerspective
* @param fovy
* @param aspect
* @param zNear
* @param zFar
*/
public static void gluPerspective(
float fovy,
float aspect,
float zNear,
float zFar) {
Project.gluPerspective(fovy, aspect, zNear, zFar);
}
/**
* Method gluProject
* @param objx
* @param objy
* @param objz
* @param modelMatrix
* @param projMatrix
* @param viewport
* @param win_pos
*/
public static boolean gluProject(float objx, float objy, float objz,
FloatBuffer modelMatrix,
FloatBuffer projMatrix,
IntBuffer viewport,
FloatBuffer win_pos)
{
return Project.gluProject(objx, objy, objz, modelMatrix, projMatrix, viewport, win_pos);
}
/**
* Method gluUnproject
* @param winx
* @param winy
* @param winz
* @param modelMatrix
* @param projMatrix
* @param viewport
* @param obj_pos
*/
public static boolean gluUnProject(float winx, float winy, float winz,
FloatBuffer modelMatrix,
FloatBuffer projMatrix,
IntBuffer viewport,
FloatBuffer obj_pos)
{
return Project.gluUnProject(winx, winy, winz, modelMatrix, projMatrix, viewport, obj_pos);
}
/**
* Method gluPickMatrix
* @param x
* @param y
* @param width
* @param height
* @param viewport
*/
public static void gluPickMatrix(
float x,
float y,
float width,
float height,
IntBuffer viewport) {
Project.gluPickMatrix(x, y, width, height, viewport);
}
/**
* Method gluGetString.
* @param name
* @return String
*/
public static String gluGetString(int name) {
return Registry.gluGetString(name);
}
/**
* Method gluCheckExtension.
* @param extName
* @param extString
* @return boolean
*/
public static boolean gluCheckExtension(String extName, String extString) {
return Registry.gluCheckExtension(extName, extString);
}
/**
* Method gluBuild2DMipmaps
* @param target
* @param components
* @param width
* @param height
* @param format
* @param type
* @param data
* @return int
*/
public static int gluBuild2DMipmaps(
int target,
int components,
int width,
int height,
int format,
int type,
ByteBuffer data) {
return MipMap.gluBuild2DMipmaps(target, components, width, height, format, type, data);
}
/**
* Method gluScaleImage.
* @param format
* @param widthIn
* @param heightIn
* @param typeIn
* @param dataIn
* @param widthOut
* @param heightOut
* @param typeOut
* @param dataOut
* @return int
*/
public static int gluScaleImage(
int format,
int widthIn,
int heightIn,
int typeIn,
ByteBuffer dataIn,
int widthOut,
int heightOut,
int typeOut,
ByteBuffer dataOut) {
return MipMap.gluScaleImage(format, widthIn, heightIn, typeIn, dataIn, widthOut, heightOut, typeOut, dataOut);
}
public static String gluErrorString(int error_code) {
switch (error_code) {
case GLU_INVALID_ENUM:
return "Invalid enum (glu)";
case GLU_INVALID_VALUE:
return "Invalid value (glu)";
case GLU_OUT_OF_MEMORY:
return "Out of memory (glu)";
default:
return Util.translateGLErrorString(error_code);
}
}
public static GLUtessellator gluNewTess() {
return new GLUtessellatorImpl();
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/glu/PixelStoreState.java 0000644 0001750 0001750 00000005670 11543426510 023055 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.glu;
import static org.lwjgl.opengl.GL11.*;
/**
* PixelStoreState.java
*
*
* Created 11-jan-2004
* @author Erik Duijs
*/
class PixelStoreState extends Util {
public int unpackRowLength;
public int unpackAlignment;
public int unpackSkipRows;
public int unpackSkipPixels;
public int packRowLength;
public int packAlignment;
public int packSkipRows;
public int packSkipPixels;
/**
* Constructor for PixelStoreState.
*/
PixelStoreState() {
super();
load();
}
public void load() {
unpackRowLength = glGetIntegerv(GL_UNPACK_ROW_LENGTH);
unpackAlignment = glGetIntegerv(GL_UNPACK_ALIGNMENT);
unpackSkipRows = glGetIntegerv(GL_UNPACK_SKIP_ROWS);
unpackSkipPixels = glGetIntegerv(GL_UNPACK_SKIP_PIXELS);
packRowLength = glGetIntegerv(GL_PACK_ROW_LENGTH);
packAlignment = glGetIntegerv(GL_PACK_ALIGNMENT);
packSkipRows = glGetIntegerv(GL_PACK_SKIP_ROWS);
packSkipPixels = glGetIntegerv(GL_PACK_SKIP_PIXELS);
}
public void save() {
glPixelStorei(GL_UNPACK_ROW_LENGTH, unpackRowLength);
glPixelStorei(GL_UNPACK_ALIGNMENT, unpackAlignment);
glPixelStorei(GL_UNPACK_SKIP_ROWS, unpackSkipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, unpackSkipPixels);
glPixelStorei(GL_PACK_ROW_LENGTH, packRowLength);
glPixelStorei(GL_PACK_ALIGNMENT, packAlignment);
glPixelStorei(GL_PACK_SKIP_ROWS, packSkipRows);
glPixelStorei(GL_PACK_SKIP_PIXELS, packSkipPixels);
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/applet/ 0000755 0001750 0001750 00000000000 11543426510 017601 5 ustar zero79 zero79 lwjgl-2.7.1/src/java/org/lwjgl/util/applet/AppletLoader.java 0000644 0001750 0001750 00000150062 11543426510 023024 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.applet;
import java.applet.Applet;
import java.applet.AppletStub;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.MediaTracker;
import java.awt.image.ImageObserver;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilePermission;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.HttpURLConnection;
import java.net.JarURLConnection;
import java.net.SocketPermission;
import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLConnection;
import java.security.AccessControlException;
import java.security.AccessController;
import java.security.CodeSource;
import java.security.PermissionCollection;
import java.security.PrivilegedExceptionAction;
import java.security.SecureClassLoader;
import java.security.cert.Certificate;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.JarOutputStream;
import java.util.jar.Pack200;
import java.util.zip.GZIPInputStream;
import sun.security.util.SecurityConstants;
/**
*
* The AppletLoader enables deployment of LWJGL to applets in an easy
* and polished way. The loader will display a configurable logo and progressbar
* while the relevant jars (generic and native) are downloaded from a specified source.
*
*
* The downloaded jars are extracted to the users temporary directory - and if enabled, cached for
* faster loading in future uses.
*
*
* The following applet parameters are required:
*
* - al_main - [String] Full package and class the applet to instantiate and display when loaded.
* - al_logo - [String Path of of the logo resource to paint while loading.
* - al_progressbar - [String] Path of the progressbar resource to paint on top of the logo, width clipped by percentage.
* - al_jars - [String] Comma seperated list of jars to download.
* - al_windows - [String] Jar containing native files for windows.
* - al_linux - [String] Jar containing native files for linux.
* - al_mac - [String] Jar containing native files for mac.
* - al_solaris - [String] Jar containing native files for solaris.
* - al_freebsd - [String] Jar containing native files for freebsd.
*
*
*
* Additionally the following parameters can be supplied to tweak the behaviour of the AppletLoader.
*
* - al_version - [int or float] Version of deployment. If this is specified, the jars will be cached and
* reused if the version matches. If version doesn't match all of the files are reloaded.
* - al_cache - [boolean] Whether to use cache system. Default: true.
* - al_debug - [boolean] Whether to enable debug mode. Default: false.
* - al_prepend_host - [boolean] Whether to limit caching to this domain, disable if your applet is hosted on multple domains and needs to share the cache. Default: true.
*
* - al_windows64 - [String] If specified it will be used instead of al_windows on 64bit windows systems.
* - al_windows32 - [String] If specifed it will be used instead of al_windows on 32bit windows systems.
* - al_linux64 - [String] If specifed it will be used instead of al_linux on 64bit linux systems.
* - al_linux32 - [String] If specifed it will be used instead of al_linux on 32bit linux systems.
*
* - boxbgcolor - [String] any String AWT color ("red", "blue", etc), RGB (0-255) or hex formated color (#RRGGBB) to use as background. Default: #ffffff.
* - boxfgcolor - [String] any String AWT color ("red", "blue", etc), RGB (0-255) or hex formated color (#RRGGBB) to use as foreground. Default: #000000.
*
*
* @author kappaOne
* @author Brian Matzon
* @version $Revision$
* $Id$
*/
public class AppletLoader extends Applet implements Runnable, AppletStub {
/** initializing */
public static final int STATE_INIT = 1;
/** determining which packages that are required */
public static final int STATE_DETERMINING_PACKAGES = 2;
/** checking for already downloaded files */
public static final int STATE_CHECKING_CACHE = 3;
/** downloading packages */
public static final int STATE_DOWNLOADING = 4;
/** extracting packages */
public static final int STATE_EXTRACTING_PACKAGES = 5;
/** updating the classpath */
public static final int STATE_UPDATING_CLASSPATH = 6;
/** switching to real applet */
public static final int STATE_SWITCHING_APPLET = 7;
/** initializing real applet */
public static final int STATE_INITIALIZE_REAL_APPLET = 8;
/** stating real applet */
public static final int STATE_START_REAL_APPLET = 9;
/** done */
public static final int STATE_DONE = 10;
/** used to calculate length of progress bar */
protected int percentage;
/** current size of download in bytes */
protected int currentSizeDownload;
/** total size of download in bytes */
protected int totalSizeDownload;
/** current size of extracted in bytes */
protected int currentSizeExtract;
/** total size of extracted in bytes */
protected int totalSizeExtract;
/** logo to be shown while loading */
protected Image logo, logoBuffer;
/** progressbar to render while loading */
protected Image progressbar, progressbarBuffer;
/** offscreen image used */
protected Image offscreen;
/** set to true while painting is done */
protected boolean painting;
/** background color of applet */
protected Color bgColor = Color.white;
/** color to write foreground in */
protected Color fgColor = Color.black;
/** urls of the jars to download */
protected URL[] urlList;
/** classLoader used to add downloaded jars to the classpath */
protected ClassLoader classLoader;
/** actual thread that does the loading */
protected Thread loaderThread;
/** animation thread that renders our load screen while loading */
protected Thread animationThread;
/** applet to load after all downloads are complete */
protected Applet lwjglApplet;
/** whether a fatal error occured */
protected boolean fatalError;
/** whether we're running in debug mode */
protected boolean debugMode;
/** whether to prepend host to cache path */
protected boolean prependHost;
/** Used to store file names with lastModified time */
protected HashMap filesLastModified;
/** Sizes of files to download */
protected int[] fileSizes;
/** Number of native jars */
protected int nativeJarCount;
/** whether to use caching system, only download files that have changed */
protected boolean cacheEnabled;
/** String to display as a subtask */
protected String subtaskMessage = "";
/** state of applet loader */
protected volatile int state = STATE_INIT;
/** whether lzma is supported */
protected boolean lzmaSupported;
/** whether pack200 is supported */
protected boolean pack200Supported;
/** generic error message to display on error */
protected String[] genericErrorMessage = { "An error occured while loading the applet.",
"Please contact support to resolve this issue.",
""};
/** whether a certificate refused error occured */
protected boolean certificateRefused;
/** error message to display if user refuses to accept certicate*/
protected String[] certificateRefusedMessage = { "Permissions for Applet Refused.",
"Please accept the permissions dialog to allow",
"the applet to continue the loading process."};
/** have natives been loaded by another instance of this applet */
protected static boolean natives_loaded;
/*
* @see java.applet.Applet#init()
*/
public void init() {
setState(STATE_INIT);
// sanity check
String[] requiredArgs = {"al_main", "al_logo", "al_progressbar", "al_jars"};
for ( String requiredArg : requiredArgs ) {
if ( getParameter(requiredArg) == null ) {
fatalErrorOccured("missing required applet parameter: " + requiredArg, null);
return;
}
}
// whether to use cache system
cacheEnabled = getBooleanParameter("al_cache", true);
// whether to run in debug mode
debugMode = getBooleanParameter("al_debug", false);
// whether to prepend host to cache path
prependHost = getBooleanParameter("al_prepend_host", true);
// get colors of applet
bgColor = getColor("boxbgcolor", Color.white);
setBackground(bgColor);
fgColor = getColor("boxfgcolor", Color.black);
// load logos, if value is "" then skip
if (getParameter("al_logo").length() > 0) {
logo = getImage(getParameter("al_logo"));
}
if (getParameter("al_progressbar").length() > 0) {
progressbar = getImage(getParameter("al_progressbar"));
}
// check for lzma support
try {
Class.forName("LZMA.LzmaInputStream");
lzmaSupported = true;
} catch (Throwable e) {
/* no lzma support */
}
// check pack200 support
try {
java.util.jar.Pack200.class.getSimpleName();
pack200Supported = true;
} catch (Throwable e) {
/* no pack200 support */
}
}
/**
* Generates a stacktrace in the form of a string
* @param exception Exception to make stacktrace of
* @return Stacktrace of exception in the form of a string
*/
private static String generateStacktrace(Exception exception) {
Writer result = new StringWriter();
PrintWriter printWriter = new PrintWriter(result);
exception.printStackTrace(printWriter);
return result.toString();
}
/*
* @see java.applet.Applet#start()
*/
public void start() {
if (lwjglApplet != null) {
lwjglApplet.start();
}
else {
if(loaderThread == null && !fatalError) {
loaderThread = new Thread(this);
loaderThread.setName("AppletLoader.loaderThread");
loaderThread.start();
animationThread = new Thread() {
public void run() {
while(loaderThread != null) {
repaint();
AppletLoader.this.sleep(100);
}
animationThread = null;
}
};
animationThread.setName("AppletLoader.animationthread");
animationThread.start();
}
}
}
/*
* @see java.applet.Applet#stop()
*/
public void stop() {
if (lwjglApplet != null) {
lwjglApplet.stop();
}
}
/*
* @see java.applet.Applet#destroy()
*/
public void destroy() {
if (lwjglApplet != null) {
lwjglApplet.destroy();
}
}
/**
* Clean up resources
*/
protected void cleanUp() {
progressbar = null;
logo = null;
logoBuffer = null;
progressbarBuffer = null;
offscreen = null;
}
/**
* Retrieves the applet that has been loaded. Useful for liveconnect.
*/
public Applet getApplet() {
return lwjglApplet;
}
/**
* Transfers the call of AppletResize from the stub to the lwjglApplet.
*/
public void appletResize(int width, int height) {
resize(width, height);
}
/*
* @see java.awt.Container#update(java.awt.Graphics)
*/
public final void update(Graphics g) {
paint(g);
}
/*
* @see java.awt.Container#paint(java.awt.Graphics)
*/
public void paint(Graphics g) {
// don't paint loader if applet loaded
if(state == STATE_DONE) {
cleanUp(); // clean up resources
return;
}
// create offscreen if missing
if (offscreen == null) {
offscreen = createImage(getWidth(), getHeight());
// create buffers for animated gifs
if (logo != null) {
logoBuffer = createImage(logo.getWidth(null), logo.getHeight(null));
// add image observer, it will notify when next animated gif frame is ready
offscreen.getGraphics().drawImage(logo, 0, 0, this);
// in case image is not animated fill image buffer once
imageUpdate(logo, ImageObserver.FRAMEBITS, 0, 0, 0, 0);
}
if (progressbar != null) {
progressbarBuffer = createImage(progressbar.getWidth(null), progressbar.getHeight(null));
// add image observer, it will notify when next animated gif frame is ready
offscreen.getGraphics().drawImage(progressbar, 0, 0, this);
// in case image is not animated fill image buffer once
imageUpdate(progressbar, ImageObserver.FRAMEBITS, 0, 0, 0, 0);
}
}
// draw everything onto an image before drawing to avoid flicker
Graphics og = offscreen.getGraphics();
FontMetrics fm = og.getFontMetrics();
// clear background color
og.setColor(bgColor);
og.fillRect(0, 0, offscreen.getWidth(null), offscreen.getHeight(null));
og.setColor(fgColor);
String message = getDescriptionForState();
// if we had a failure of some sort, notify the user
if (fatalError) {
String[] errorMessage = (certificateRefused) ? certificateRefusedMessage : genericErrorMessage;
for(int i=0; i 0) {
messageX = (offscreen.getWidth(null) - fm.stringWidth(subtaskMessage)) / 2;
og.drawString(subtaskMessage, messageX, messageY+20);
}
// draw loading bar, clipping it depending on percentage done
if (progressbar != null) {
int barSize = (progressbar.getWidth(null) * percentage) / 100;
og.clipRect(x-progressbar.getWidth(null)/2, 0, barSize, offscreen.getHeight(null));
og.drawImage(progressbarBuffer, x-progressbar.getWidth(null)/2, y-progressbar.getHeight(null)/2, this);
}
painting = false;
}
og.dispose();
// finally draw it all centred
g.drawImage(offscreen, (getWidth() - offscreen.getWidth(null))/2, (getHeight() - offscreen.getHeight(null))/2, null);
}
/**
* When an animated gif frame is ready to be drawn the ImageObserver
* will call this method.
*
* The Image frame is copied into a buffer, which is then drawn.
* This is done to prevent image tearing on gif animations.
*/
public boolean imageUpdate(Image img, int flag, int x, int y, int width, int height) {
// finish with this ImageObserver
if (state == STATE_DONE) return false;
// if image frame is ready to be drawn and is currently not being painted
if (flag == ImageObserver.FRAMEBITS && !painting) {
Image buffer;
// select which buffer to fill
if (img == logo) buffer = logoBuffer;
else buffer = progressbarBuffer;
Graphics g = buffer.getGraphics();
// clear background on buffer
g.setColor(bgColor);
g.fillRect(0, 0, buffer.getWidth(null), buffer.getHeight(null));
// buffer background is cleared, so draw logo under progressbar
if (img == progressbar && logo != null) {
g.drawImage(logoBuffer, progressbar.getWidth(null)/2-logo.getWidth(null)/2,
progressbar.getHeight(null)/2-logo.getHeight(null)/2, null);
}
g.drawImage(img, 0, 0, this);
g.dispose();
repaint();
}
return true;
}
/**
* @return string describing the state of the loader
*/
protected String getDescriptionForState() {
switch (state) {
case STATE_INIT:
return "Initializing loader";
case STATE_DETERMINING_PACKAGES:
return "Determining packages to load";
case STATE_CHECKING_CACHE:
return "Calculating download size";
case STATE_DOWNLOADING:
return "Downloading packages";
case STATE_EXTRACTING_PACKAGES:
return "Extracting downloaded packages";
case STATE_UPDATING_CLASSPATH:
return "Updating classpath";
case STATE_SWITCHING_APPLET:
return "Switching applet";
case STATE_INITIALIZE_REAL_APPLET:
return "Initializing real applet";
case STATE_START_REAL_APPLET:
return "Starting real applet";
case STATE_DONE:
return "Done loading";
default:
return "unknown state";
}
}
/**
* Trims the passed file string based on the available capabilities
* @param file string of files to be trimmed
* @return trimmed string based on capabilities of client
*/
protected String trimExtensionByCapabilities(String file) {
if (!pack200Supported) {
file = file.replaceAll(".pack", "");
}
if (!lzmaSupported) {
file = file.replaceAll(".lzma", "");
}
return file;
}
/**
* Reads list of jars to download and adds the urls to urlList
* also finds out which OS you are on and adds appropriate native
* jar to the urlList
*/
protected void loadJarURLs() throws Exception {
setState(STATE_DETERMINING_PACKAGES);
// jars to load
String jarList = getParameter("al_jars");
String nativeJarList = null;
String osName = System.getProperty("os.name");
if (osName.startsWith("Win")) {
// check if arch specific natives have been specified
if (System.getProperty("os.arch").endsWith("64")) {
nativeJarList = getParameter("al_windows64");
} else {
nativeJarList = getParameter("al_windows32");
}
if (nativeJarList == null) {
nativeJarList = getParameter("al_windows");
}
} else if (osName.startsWith("Linux")) {
// check if arch specific natives have been specified
if (System.getProperty("os.arch").endsWith("64")) {
nativeJarList = getParameter("al_linux64");
} else {
nativeJarList = getParameter("al_linux32");
}
if (nativeJarList == null) {
nativeJarList = getParameter("al_linux");
}
} else if (osName.startsWith("Mac") || osName.startsWith("Darwin")) {
nativeJarList = getParameter("al_mac");
} else if (osName.startsWith("Solaris") || osName.startsWith("SunOS")) {
nativeJarList = getParameter("al_solaris");
} else if (osName.startsWith("FreeBSD")) {
nativeJarList = getParameter("al_freebsd");
} else {
fatalErrorOccured("OS (" + osName + ") not supported", null);
return;
}
if (nativeJarList == null) {
fatalErrorOccured("no lwjgl natives files found", null);
return;
}
jarList = trimExtensionByCapabilities(jarList);
StringTokenizer jars = new StringTokenizer(jarList, ", ");
nativeJarList = trimExtensionByCapabilities(nativeJarList);
StringTokenizer nativeJars = new StringTokenizer(nativeJarList, ", ");
int jarCount = jars.countTokens();
nativeJarCount = nativeJars.countTokens();
urlList = new URL[jarCount+nativeJarCount];
URL path = getCodeBase();
// set jars urls
for (int i = 0; i < jarCount; i++) {
urlList[i] = new URL(path, jars.nextToken());
}
for (int i = jarCount; i < jarCount+nativeJarCount; i++) {
urlList[i] = new URL(path, nativeJars.nextToken());
}
}
/**
* 4 steps
*
* 1) check version of applet and decide whether to download jars
* 2) download the jars
* 3) extract natives
* 4) add to jars to class path
* 5) switch applets
*/
public void run() {
setState(STATE_CHECKING_CACHE);
percentage = 5;
try {
debug_sleep(2000);
// parse the urls for the jars into the url list
loadJarURLs();
// get path where applet will be stored
String path = AccessController.doPrivileged(new PrivilegedExceptionAction() {
public String run() throws Exception {
// we append the code base to avoid naming collisions with al_title
String codebase = "";
if(prependHost) {
codebase = getCodeBase().getHost();
if(codebase == null || codebase.length() == 0) {
codebase = "localhost";
}
codebase += File.separator;
}
return getCacheDir() + File.separator + codebase + getParameter("al_title") + File.separator;
}
});
File dir = new File(path);
// create directory
if (!dir.exists()) {
dir.mkdirs();
}
File versionFile = new File(dir, "version");
// if specified applet version already available don't download anything
boolean versionAvailable = false;
// version of applet
String version = getParameter("al_version");
float latestVersion = 0;
// if applet version specifed, check if you have latest version of applet
if (version != null) {
latestVersion = Float.parseFloat(version);
// if version file exists
if (versionFile.exists()) {
// compare to new version
if (latestVersion != readVersionFile(versionFile)) {
versionAvailable = true;
percentage = 90;
if(debugMode) {
System.out.println("Loading Cached Applet Version " + latestVersion);
}
debug_sleep(2000);
}
}
}
// if jars not available or need updating download them
if (!versionAvailable) {
// get jars file sizes and check cache
getJarInfo(dir); // 5-15%
// downloads jars from the server
downloadJars(path); // 15-55%
// Extract Pack and LZMA files
extractJars(path); // 55-65%
// Extracts Native Files
extractNatives(path); // 65-85%
// save version information once jars downloaded successfully
if (version != null) {
percentage = 90;
writeVersionFile(versionFile, latestVersion);
}
// save file names with last modified info once downloaded successfully
writeCacheFile(new File(dir, "cache"), filesLastModified);
}
// add the downloaded jars and natives to classpath
updateClassPath(path);
// set lwjgl properties
setLWJGLProperties();
// make applet switch on EDT as an AWT/Swing permission dialog could be called
EventQueue.invokeAndWait(new Runnable() {
public void run() {
try {
switchApplet();
} catch (Exception e) {
fatalErrorOccured("This occurred while '" + getDescriptionForState() + "'", e);
}
setState(STATE_DONE);
repaint();
}
});
} catch (AccessControlException ace) {
fatalErrorOccured(ace.getMessage(), ace);
certificateRefused = true;
} catch (Exception e) {
fatalErrorOccured("This occurred while '" + getDescriptionForState() + "'", e);
} finally {
loaderThread = null;
}
}
/**
* Parses the java_arguments list and sets lwjgl specific
* properties accordingly, before the launch.
*/
protected void setLWJGLProperties() {
String lwjglArguments = getParameter("lwjgl_arguments");
if(lwjglArguments != null && lwjglArguments.length() > 0) {
int start = lwjglArguments.indexOf("-Dorg.lwjgl");
while(start != -1) {
int end = lwjglArguments.indexOf(" ", start);
if(end == -1) {
end = lwjglArguments.length();
}
String[] keyValue = lwjglArguments.substring(start+2, end).split("=");
System.setProperty(keyValue[0], keyValue[1]);
if(debugMode) {
System.out.println("Setting property " + keyValue[0] + " to " + keyValue[1]);
}
start = lwjglArguments.indexOf("-Dorg.lwjgl", end);
}
}
}
/**
* get path to the lwjgl cache directory
*
* @return path to the lwjgl cache directory
*/
protected String getCacheDir() {
String cacheDir = System.getProperty("deployment.user.cachedir");
if (cacheDir == null || System.getProperty("os.name").startsWith("Win")) {
cacheDir = System.getProperty("java.io.tmpdir");
}
return cacheDir + File.separator + "lwjglcache";
}
/**
* read the current version file
*
* @param file the file to read
* @return the version value of saved file
* @throws Exception if it fails to read value
*/
protected float readVersionFile(File file) throws Exception {
DataInputStream dis = new DataInputStream(new FileInputStream(file));
float version = dis.readFloat();
dis.close();
return version;
}
/**
* write out version file of applet
*
* @param file the file to write out to
* @param version the version of the applet as a float
* @throws Exception if it fails to write file
*/
protected void writeVersionFile(File file, float version) throws Exception {
DataOutputStream dos = new DataOutputStream(new FileOutputStream(file));
dos.writeFloat(version);
dos.close();
}
/**
* read the current cache file
*
* @param file the file to read
* @return the hashmap containing the files names and lastModified times
* @throws Exception if it fails to read hashmap
*/
@SuppressWarnings("unchecked")
protected HashMap readCacheFile(File file) throws Exception {
ObjectInputStream dis = new ObjectInputStream(new FileInputStream(file));
HashMap hashMap = (HashMap)dis.readObject();
dis.close();
return hashMap;
}
/**
* write out cache file of applet
*
* @param file the file to write out to
* @param filesLastModified the hashmap containing files names and lastModified times
* @throws Exception if it fails to write file
*/
protected void writeCacheFile(File file, HashMap filesLastModified) throws Exception {
ObjectOutputStream dos = new ObjectOutputStream(new FileOutputStream(file));
dos.writeObject(filesLastModified);
dos.close();
}
/**
* Edits the ClassPath at runtime to include the jars
* that have just been downloaded and then adds the
* lwjgl natives folder property.
*
* @param path location where applet is stored
* @throws Exception if it fails to add classpath
*/
protected void updateClassPath(final String path) throws Exception {
setState(STATE_UPDATING_CLASSPATH);
percentage = 95;
URL[] urls = new URL[urlList.length];
for (int i = 0; i < urlList.length; i++) {
urls[i] = new URL("file:" + path + getJarName(urlList[i]));
}
// add downloaded jars to the classpath with required permissions
classLoader = new URLClassLoader(urls) {
protected PermissionCollection getPermissions (CodeSource codesource) {
PermissionCollection perms = null;
try {
// getPermissions from original classloader is important as it checks for signed jars and shows any security dialogs needed
Method method = SecureClassLoader.class.getDeclaredMethod("getPermissions", new Class[] { CodeSource.class });
method.setAccessible(true);
perms = (PermissionCollection)method.invoke(getClass().getClassLoader(), new Object[] {codesource});
String host = getCodeBase().getHost();
if (host != null && (host.length() > 0)) {
// add permission for downloaded jars to access host they were from
perms.add(new SocketPermission(host, SecurityConstants.SOCKET_CONNECT_ACCEPT_ACTION));
}
else if ( "file".equals(codesource.getLocation().getProtocol()) ) {
// if running locally add file permission
String path = codesource.getLocation().getFile().replace('/', File.separatorChar);
perms.add(new FilePermission(path, SecurityConstants.FILE_READ_ACTION));
}
} catch (Exception e) {
e.printStackTrace();
}
return perms;
}
// allow non lwjgl native to be found from cache directory
protected String findLibrary (String libname) {
return path + "natives" + File.separator + System.mapLibraryName(libname);
}
};
debug_sleep(2000);
// unload natives loaded by a previous instance of this lwjgl applet
unloadNatives(path);
// add natives files path to native class path
System.setProperty("org.lwjgl.librarypath", path + "natives");
// Make sure jinput knows about the new path too
System.setProperty("net.java.games.input.librarypath", path + "natives");
// set the library path, useful for non lwjgl natives
System.setProperty("java.library.path", path + "natives");
// mark natives as loaded
natives_loaded = true;
}
/**
* Unload natives loaded by a different classloader.
*
* Due to limitations of the jvm, native files can only
* be loaded once and only be used by the classloader
* they were loaded from.
*
* Due to the way applets on plugin1 work, one jvm must
* be used for all applets. We need to use multiple
* classloaders in the same jvm due to LWJGL's static
* nature. In order to solve this we simply remove the
* natives from a previous classloader allowing a new
* classloader to use those natives in the same jvm.
*
* This method will only attempt to unload natives from a
* previous classloader if it detects that the natives have
* been loaded in the same jvm.
*
* @param nativePath directory where natives are stored
*/
private void unloadNatives(String nativePath) {
// check whether natives have been loaded into this jvm
if (!natives_loaded) {
return;
}
try {
Field field = ClassLoader.class.getDeclaredField("loadedLibraryNames");
field.setAccessible(true);
Vector libs = (Vector) field.get(getClass().getClassLoader());
String path = new File(nativePath).getCanonicalPath();
for (int i = 0; i < libs.size(); i++) {
String s = (String) libs.get(i);
// if a native from the nativePath directory is loaded, unload it
if (s.startsWith(path)) {
libs.remove(i);
i--;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* replace the current applet with the lwjgl applet
* using AppletStub and initialise and start it
*/
protected void switchApplet() throws Exception {
setState(STATE_SWITCHING_APPLET);
percentage = 100;
debug_sleep(2000);
Class appletClass = classLoader.loadClass(getParameter("al_main"));
lwjglApplet = (Applet) appletClass.newInstance();
lwjglApplet.setStub(this);
lwjglApplet.setSize(getWidth(), getHeight());
setLayout(new BorderLayout());
add(lwjglApplet);
validate();
setState(STATE_INITIALIZE_REAL_APPLET);
lwjglApplet.init();
setState(STATE_START_REAL_APPLET);
lwjglApplet.start();
}
/**
* This method will get the files sizes of the files to download.
* It wil further get the lastModified time of files
* and save it in a hashmap, if cache is enabled it will mark
* those files that have not changed since last download to not
* redownloaded.
*
* @param dir - location to read cache file from
* @throws Exception - if fails to get infomation
*/
protected void getJarInfo(File dir) throws Exception {
filesLastModified = new HashMap();
// store file sizes and mark which files not to download
fileSizes = new int[urlList.length];
URLConnection urlconnection;
File cacheFile = new File(dir, "cache");
// if cache file exists, load it
if (cacheFile.exists()) {
filesLastModified = readCacheFile(cacheFile);
}
// calculate total size of jars to download
for (int i = 0; i < urlList.length; i++) {
urlconnection = urlList[i].openConnection();
urlconnection.setDefaultUseCaches(false);
if (urlconnection instanceof HttpURLConnection) {
((HttpURLConnection) urlconnection).setRequestMethod("HEAD");
}
fileSizes[i] = urlconnection.getContentLength();
long lastModified = urlconnection.getLastModified();
String fileName = getFileName(urlList[i]);
if (cacheEnabled && lastModified != 0 &&
filesLastModified.containsKey(fileName)) {
long savedLastModified = filesLastModified.get(fileName);
// if lastModifed time is the same, don't redownload
if (savedLastModified == lastModified) {
fileSizes[i] = -2; // mark it to not redownload
}
}
if (fileSizes[i] >= 0) {
totalSizeDownload += fileSizes[i];
}
// put key and value in the hashmap
filesLastModified.put(fileName, lastModified);
// update progress bar
percentage = 5 + (int)(10 * i/(float)urlList.length);
}
}
/**
* Will download the jars from the server using the list of urls
* in urlList, while at the same time updating progress bar
*
* @param path location of the directory to save to
* @throws Exception if download fails
*/
protected void downloadJars(String path) throws Exception {
setState(STATE_DOWNLOADING);
URLConnection urlconnection;
int initialPercentage = percentage = 15;
// download each jar
byte buffer[] = new byte[65536];
for (int i = 0; i < urlList.length; i++) {
// skip file if marked as -2 (already downloaded and not changed)
if (fileSizes[i] == -2) continue;
int unsuccessfulAttempts = 0;
int maxUnsuccessfulAttempts = 3;
boolean downloadFile = true;
// download the jar a max of 3 times
while(downloadFile) {
downloadFile = false;
debug_sleep(2000);
urlconnection = urlList[i].openConnection();
if (urlconnection instanceof HttpURLConnection) {
urlconnection.setRequestProperty("Cache-Control", "no-cache");
urlconnection.connect();
}
String currentFile = getFileName(urlList[i]);
InputStream inputstream = getJarInputStream(currentFile, urlconnection);
FileOutputStream fos = new FileOutputStream(path + currentFile);
int bufferSize;
long downloadStartTime = System.currentTimeMillis();
int downloadedAmount = 0;
int fileSize = 0;
String downloadSpeedMessage = "";
while ((bufferSize = inputstream.read(buffer, 0, buffer.length)) != -1) {
debug_sleep(10);
fos.write(buffer, 0, bufferSize);
currentSizeDownload += bufferSize;
fileSize += bufferSize;
percentage = initialPercentage + ((currentSizeDownload * 45) / totalSizeDownload);
subtaskMessage = "Retrieving: " + currentFile + " " + ((currentSizeDownload * 100) / totalSizeDownload) + "%";
downloadedAmount += bufferSize;
long timeLapse = System.currentTimeMillis() - downloadStartTime;
// update only if a second or more has passed
if (timeLapse >= 1000) {
// get kb/s, nice that bytes/millis is same as kilobytes/seconds
float downloadSpeed = (float) downloadedAmount / timeLapse;
// round to two decimal places
downloadSpeed = ((int)(downloadSpeed*100))/100f;
// set current speed message
downloadSpeedMessage = " - " + downloadSpeed + " KB/sec";
// reset downloaded amount
downloadedAmount = 0;
// reset start time
downloadStartTime = System.currentTimeMillis();
}
subtaskMessage += downloadSpeedMessage;
}
inputstream.close();
fos.close();
// download complete, verify if it was successful
if (urlconnection instanceof HttpURLConnection) {
if (fileSize == fileSizes[i]) {
// successful download
}
else if (fileSizes[i] <= 0) {
// If contentLength for fileSizes[i] <= 0, we don't know if the download
// is complete. We're going to guess the download is complete.
}
else {
unsuccessfulAttempts++;
// download failed try again
if (unsuccessfulAttempts < maxUnsuccessfulAttempts) {
downloadFile = true;
currentSizeDownload -= fileSize; // reset progress bar
}
else {
// retry attempts exhasted, download failed
throw new Exception("failed to download " + currentFile);
}
}
}
}
}
subtaskMessage = "";
}
/**
* Retrieves a jar files input stream. This method exists primarily to fix an Opera hang in getInputStream
* @param urlconnection connection to get input stream from
* @return InputStream or null if not possible
*/
protected InputStream getJarInputStream(final String currentFile, final URLConnection urlconnection) throws Exception {
final InputStream[] is = new InputStream[1];
// try to get the input stream 3 times.
// Wait at most 5 seconds before interrupting the thread
for (int j = 0; j < 3 && is[0] == null; j++) {
Thread t = new Thread() {
public void run() {
try {
is[0] = urlconnection.getInputStream();
} catch (IOException e) {
/* ignored */
}
}
};
t.setName("JarInputStreamThread");
t.start();
int iterationCount = 0;
while(is[0] == null && iterationCount++ < 5) {
try {
t.join(1000);
} catch (InterruptedException inte) {
/* ignored */
}
}
if(is[0] == null) {
try {
t.interrupt();
t.join();
} catch (InterruptedException inte) {
/* ignored */
}
}
}
if(is[0] == null) {
throw new Exception("Unable to get input stream for " + currentFile);
}
return is[0];
}
/**
* Extract LZMA File
* @param in Input path to pack file
* @param out output path to resulting file
* @throws Exception if any errors occur
*/
protected void extractLZMA(String in, String out) throws Exception {
File f = new File(in);
FileInputStream fileInputHandle = new FileInputStream(f);
// use reflection to avoid hard dependency
Class clazz = Class.forName( "LZMA.LzmaInputStream" );
Constructor constructor = clazz.getDeclaredConstructor(InputStream.class);
InputStream inputHandle = (InputStream) constructor.newInstance(fileInputHandle);
OutputStream outputHandle;
outputHandle = new FileOutputStream(out);
byte [] buffer = new byte [1<<14];
int ret = inputHandle.read(buffer);
while (ret >= 1) {
outputHandle.write(buffer,0,ret);
ret = inputHandle.read(buffer);
}
inputHandle.close();
outputHandle.close();
outputHandle = null;
inputHandle = null;
// delete LZMA file, as it is no longer needed
f.delete();
}
/**
* Extract GZip File
* @param in Input path to pack file
* @param out output path to resulting file
* @throws Exception if any errors occur
*/
protected void extractGZip(String in, String out) throws Exception {
File f = new File(in);
FileInputStream fileInputHandle = new FileInputStream(f);
InputStream inputHandle = new GZIPInputStream(fileInputHandle);
OutputStream outputHandle;
outputHandle = new FileOutputStream(out);
byte [] buffer = new byte [1<<14];
int ret = inputHandle.read(buffer);
while (ret >= 1) {
outputHandle.write(buffer,0,ret);
ret = inputHandle.read(buffer);
}
inputHandle.close();
outputHandle.close();
outputHandle = null;
inputHandle = null;
// delete GZip file, as it is no longer needed
f.delete();
}
/**
* Extract Pack File
* @param in Input path to pack file
* @param out output path to resulting file
* @throws Exception if any errors occur
*/
protected void extractPack(String in, String out) throws Exception {
File f = new File(in);
FileOutputStream fostream = new FileOutputStream(out);
JarOutputStream jostream = new JarOutputStream(fostream);
Pack200.Unpacker unpacker = Pack200.newUnpacker();
unpacker.unpack(f, jostream);
jostream.close();
// delete pack file as its no longer needed
f.delete();
}
/**
* Extract all jars from any lzma/gz/pack files
*
* @param path output path
* @throws Exception if any errors occur
*/
protected void extractJars(String path) throws Exception {
setState(STATE_EXTRACTING_PACKAGES);
float increment = (float) 10.0 / urlList.length;
// extract all gz, lzma, pack.gz and pack.lzma files
for (int i = 0; i < urlList.length; i++) {
// if file has not changed, skip it
if (fileSizes[i] == -2) continue;
percentage = 55 + (int) (increment * (i+1));
String filename = getFileName(urlList[i]);
if (filename.endsWith(".pack.lzma")) {
subtaskMessage = "Extracting: " + filename + " to " + filename.replaceAll(".lzma", "");
debug_sleep(1000);
extractLZMA(path + filename, path + filename.replaceAll(".lzma", ""));
subtaskMessage = "Extracting: " + filename.replaceAll(".lzma", "") + " to " + filename.replaceAll(".pack.lzma", "");
debug_sleep(1000);
extractPack(path + filename.replaceAll(".lzma", ""), path + filename.replaceAll(".pack.lzma", ""));
}
else if (filename.endsWith(".pack.gz")) {
subtaskMessage = "Extracting: " + filename + " to " + filename.replaceAll(".gz", "");
debug_sleep(1000);
extractGZip(path + filename, path + filename.replaceAll(".gz", ""));
subtaskMessage = "Extracting: " + filename.replaceAll(".gz", "") + " to " + filename.replaceAll(".pack.gz", "");
debug_sleep(1000);
extractPack(path + filename.replaceAll(".gz", ""), path + filename.replaceAll(".pack.gz", ""));
}
else if (filename.endsWith(".pack")) {
subtaskMessage = "Extracting: " + filename + " to " + filename.replace(".pack", "");
debug_sleep(1000);
extractPack(path + filename, path + filename.replace(".pack", ""));
}
else if (filename.endsWith(".lzma")) {
subtaskMessage = "Extracting: " + filename + " to " + filename.replace(".lzma", "");
debug_sleep(1000);
extractLZMA(path + filename, path + filename.replace(".lzma", ""));
}
else if (filename.endsWith(".gz")) {
subtaskMessage = "Extracting: " + filename + " to " + filename.replace(".gz", "");
debug_sleep(1000);
extractGZip(path + filename, path + filename.replace(".gz", ""));
}
}
}
/**
* This method will extract all file from the native jar and extract them
* to the subdirectory called "natives" in the local path, will also check
* to see if the native jar files is signed properly
*
* @param path base folder containing all downloaded jars
* @throws Exception if it fails to extract files
*/
protected void extractNatives(String path) throws Exception {
setState(STATE_EXTRACTING_PACKAGES);
float percentageParts = 20f/nativeJarCount; // parts for each native jar from 20%
// create native folder
File nativeFolder = new File(path + "natives");
if (!nativeFolder.exists()) {
nativeFolder.mkdir();
}
// get the current certificate to compare against native files
Certificate[] certificate = AppletLoader.class.getProtectionDomain().getCodeSource().getCertificates();
// workaround for bug where cached applet loader does not have certificates!?
if (certificate == null) {
URL location = AppletLoader.class.getProtectionDomain().getCodeSource().getLocation();
// manually load the certificate
JarURLConnection jurl = (JarURLConnection) (new URL("jar:" + location.toString() + "!/org/lwjgl/util/applet/AppletLoader.class").openConnection());
jurl.setDefaultUseCaches(true);
certificate = jurl.getCertificates();
}
for (int i = urlList.length - nativeJarCount; i < urlList.length; i++) {
// if a new native jar was not downloaded, no extracting needed
if (fileSizes[i] == -2) {
continue;
}
// get name of jar file with natives from urlList
String nativeJar = getJarName(urlList[i]);
// open jar file
JarFile jarFile = new JarFile(path + nativeJar, true);
// get list of files in jar
Enumeration entities = jarFile.entries();
totalSizeExtract = 0;
int jarNum = i - (urlList.length - nativeJarCount); // used for progressbar
// calculate the size of the files to extract for progress bar
while (entities.hasMoreElements()) {
JarEntry entry = (JarEntry) entities.nextElement();
// skip directories and anything in directories
// conveniently ignores the manifest
if (entry.isDirectory() || entry.getName().indexOf('/') != -1) {
continue;
}
totalSizeExtract += entry.getSize();
}
currentSizeExtract = 0;
// reset point to begining by getting list of file again
entities = jarFile.entries();
// extract all files from the jar
while (entities.hasMoreElements()) {
JarEntry entry = (JarEntry) entities.nextElement();
// skip directories and anything in directories
// conveniently ignores the manifest
if (entry.isDirectory() || entry.getName().indexOf('/') != -1) {
continue;
}
// check if native file already exists if so delete it to make room for new one
// useful when using the reload button on the browser
File f = new File(path + "natives" + File.separator + entry.getName());
if (f.exists()) {
if (!f.delete()) {
continue; // unable to delete file, it is in use, skip extracting it
}
}
debug_sleep(1000);
InputStream in = jarFile.getInputStream(jarFile.getEntry(entry.getName()));
OutputStream out = new FileOutputStream(path + "natives" + File.separator + entry.getName());
int bufferSize;
byte buffer[] = new byte[65536];
while ((bufferSize = in.read(buffer, 0, buffer.length)) != -1) {
debug_sleep(10);
out.write(buffer, 0, bufferSize);
currentSizeExtract += bufferSize;
// update progress bar
percentage = 65 + (int)(percentageParts * (jarNum + currentSizeExtract/(float)totalSizeExtract));
subtaskMessage = "Extracting: " + entry.getName() + " " + ((currentSizeExtract * 100) / totalSizeExtract) + "%";
}
// validate if the certificate for native file is correct
validateCertificateChain(certificate, entry.getCertificates());
in.close();
out.close();
}
subtaskMessage = "";
jarFile.close();
// delete native jar as it is no longer needed
File f = new File(path + nativeJar);
f.delete();
}
}
/**
* Validates the certificate chain for a single file
*
* @param ownCerts Chain of certificates to check against
* @param native_certs Chain of certificates to check
*/
protected static void validateCertificateChain(Certificate[] ownCerts, Certificate[] native_certs) throws Exception {
if (native_certs == null)
throw new Exception("Unable to validate certificate chain. Native entry did not have a certificate chain at all");
if (ownCerts.length != native_certs.length)
throw new Exception("Unable to validate certificate chain. Chain differs in length [" + ownCerts.length + " vs " + native_certs.length + "]");
for (int i = 0; i < ownCerts.length; i++) {
if (!ownCerts[i].equals(native_certs[i])) {
throw new Exception("Certificate mismatch: " + ownCerts[i] + " != " + native_certs[i]);
}
}
}
/**
* Get Image from path provided
*
* @param s location of the image
* @return the Image file
*/
protected Image getImage(String s) {
Image image = null;
try {
image = getImage(new URL(getCodeBase(), s));
} catch (Exception e) {
/* */
}
// if image failed to load, try another method
if (image == null) {
image = getImage(Thread.currentThread().getContextClassLoader().getResource(s));
}
// if image loaded sucessfully return it
if (image != null) {
return image;
}
// show error as image could not be loaded
fatalErrorOccured("Unable to load logo and progressbar images", null);
return null;
}
/**
* Get Image from path provided
*
* @param url location of the image
* @return the Image file
*/
public Image getImage(URL url) {
try {
Image image = super.getImage(url);
// wait for image to load
MediaTracker tracker = new MediaTracker(this);
tracker.addImage(image, 0);
tracker.waitForAll();
// if no errors return image
if (!tracker.isErrorAny()) {
return image;
}
} catch (Exception e) {
/* */
}
return null;
}
/**
* Get jar name from URL.
*
* @param url Get jar file name from this url
* @return file name as string
*/
protected String getJarName(URL url) {
String fileName = url.getFile();
if (fileName.endsWith(".pack.lzma")) {
fileName = fileName.replaceAll(".pack.lzma", "");
} else if (fileName.endsWith(".pack.gz")) {
fileName = fileName.replaceAll(".pack.gz", "");
} else if (fileName.endsWith(".pack")) {
fileName = fileName.replaceAll(".pack", "");
} else if (fileName.endsWith(".lzma")) {
fileName = fileName.replaceAll(".lzma", "");
} else if (fileName.endsWith(".gz")) {
fileName = fileName.replaceAll(".gz", "");
}
return fileName.substring(fileName.lastIndexOf('/') + 1);
}
/**
* Get file name portion of URL.
*
* @param url Get file name from this url
* @return file name as string
*/
protected String getFileName(URL url) {
String fileName = url.getFile();
return fileName.substring(fileName.lastIndexOf('/') + 1);
}
/**
* Retrieves the color
*
* @param param Color to load
* @param defaultColor Default color to use if no color to load
* @return Color to use
*/
protected Color getColor(String param, Color defaultColor) {
String color = getParameter(param);
if (color == null) return defaultColor;
// Check if RGB format
if (color.indexOf(",") != -1) {
StringTokenizer st = new StringTokenizer(color, ",");
// We've got three components for the color
try {
return new Color(Integer.parseInt(st.nextToken().trim()),
Integer.parseInt(st.nextToken().trim()),
Integer.parseInt(st.nextToken().trim()));
} catch (Exception e) {
// failed to parse
return defaultColor;
}
}
// Check & decode if the color is in hexadecimal color format (i.e. #808000)
try {
return Color.decode(color);
} catch (NumberFormatException e) {
// ignore exception
}
// Get the color by name if it exists
try {
return (Color)Color.class.getField(color).get(null);
} catch (Exception e) {
return defaultColor;
}
}
/**
* Retrieves the boolean value for the applet
* @param name Name of parameter
* @param defaultValue default value to return if no such parameter
* @return value of parameter or defaultValue
*/
protected boolean getBooleanParameter(String name, boolean defaultValue) {
String parameter = getParameter(name);
if(parameter != null) {
return Boolean.parseBoolean(parameter);
}
return defaultValue;
}
/**
* Sets the state of the loaded and prints some debug information
*
* @param error Error message to print
*/
protected void fatalErrorOccured(String error, Exception e) {
fatalError = true;
genericErrorMessage[genericErrorMessage.length-1] = error;
System.out.println(error);
if(e != null) {
System.out.println(e.getMessage());
System.out.println(generateStacktrace(e));
}
repaint();
}
/**
* set the state of applet loader
* @param new state of applet loader
* */
protected void setState(int state) {
this.state = state;
if(debugMode) {
System.out.println(getDescriptionForState());
}
}
/**
* Utility method for sleeping
* Will only really sleep if debug has been enabled
* @param ms milliseconds to sleep
*/
protected void debug_sleep(long ms) {
if(debugMode) {
sleep(ms);
}
}
/**
* Utility method for sleeping
* @param ms milliseconds to sleep
*/
protected void sleep(long ms) {
try {
Thread.sleep(ms);
} catch (Exception e) {
/* ignored */
}
}
} lwjgl-2.7.1/src/java/org/lwjgl/util/Color.java 0000644 0001750 0001750 00000024667 11543426510 020254 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util;
import java.io.Serializable;
import java.nio.ByteBuffer;
/**
* A mutable Color class
* @author $Author: matzon $
* @version $Revision: 2983 $
* $Id: Color.java 2983 2008-04-07 18:36:09Z matzon $
*/
public final class Color implements ReadableColor, Serializable, WritableColor {
static final long serialVersionUID = 1L;
/** Color components, publicly accessible */
private byte red, green, blue, alpha;
/**
* Constructor for Color.
*/
public Color() {
this(0, 0, 0, 255);
}
/**
* Constructor for Color. Alpha defaults to 255.
*/
public Color(int r, int g, int b) {
this(r, g, b, 255);
}
/**
* Constructor for Color. Alpha defaults to 255.
*/
public Color(byte r, byte g, byte b) {
this(r, g, b, (byte) 255);
}
/**
* Constructor for Color.
*/
public Color(int r, int g, int b, int a) {
set(r, g, b, a);
}
/**
* Constructor for Color.
*/
public Color(byte r, byte g, byte b, byte a) {
set(r, g, b, a);
}
/**
* Constructor for Color
*/
public Color(ReadableColor c) {
setColor(c);
}
/**
* Set a color
*/
public void set(int r, int g, int b, int a) {
red = (byte) r;
green = (byte) g;
blue = (byte) b;
alpha = (byte) a;
}
/**
* Set a color
*/
public void set(byte r, byte g, byte b, byte a) {
this.red = r;
this.green = g;
this.blue = b;
this.alpha = a;
}
/**
* Set a color
*/
public void set(int r, int g, int b) {
set(r, g, b, 255);
}
/**
* Set a color
*/
public void set(byte r, byte g, byte b) {
set(r, g, b, (byte) 255);
}
/**
* Accessor
*/
public int getRed() {
return red & 0xFF;
}
/**
* Accessor
*/
public int getGreen() {
return green & 0xFF;
}
/**
* Accessor
*/
public int getBlue() {
return blue & 0xFF;
}
/**
* Accessor
*/
public int getAlpha() {
return alpha & 0xFF;
}
/**
* Set the Red component
*/
public void setRed(int red) {
this.red = (byte) red;
}
/**
* Set the Green component
*/
public void setGreen(int green) {
this.green = (byte) green;
}
/**
* Set the Blue component
*/
public void setBlue(int blue) {
this.blue = (byte) blue;
}
/**
* Set the Alpha component
*/
public void setAlpha(int alpha) {
this.alpha = (byte) alpha;
}
/**
* Set the Red component
*/
public void setRed(byte red) {
this.red = red;
}
/**
* Set the Green component
*/
public void setGreen(byte green) {
this.green = green;
}
/**
* Set the Blue component
*/
public void setBlue(byte blue) {
this.blue = blue;
}
/**
* Set the Alpha component
*/
public void setAlpha(byte alpha) {
this.alpha = alpha;
}
/**
* Stringify
*/
public String toString() {
return "Color [" + getRed() + ", " + getGreen() + ", " + getBlue() + ", " + getAlpha() + "]";
}
/**
* Equals
*/
public boolean equals(Object o) {
return (o != null)
&& (o instanceof ReadableColor)
&& (((ReadableColor) o).getRed() == this.getRed())
&& (((ReadableColor) o).getGreen() == this.getGreen())
&& (((ReadableColor) o).getBlue() == this.getBlue())
&& (((ReadableColor) o).getAlpha() == this.getAlpha());
}
/**
* Hashcode
*/
public int hashCode() {
return (red << 24) | (green << 16) | (blue << 8) | alpha;
}
/* (Overrides)
* @see com.shavenpuppy.jglib.ReadableColor#getAlphaByte()
*/
public byte getAlphaByte() {
return alpha;
}
/* (Overrides)
* @see com.shavenpuppy.jglib.ReadableColor#getBlueByte()
*/
public byte getBlueByte() {
return blue;
}
/* (Overrides)
* @see com.shavenpuppy.jglib.ReadableColor#getGreenByte()
*/
public byte getGreenByte() {
return green;
}
/* (Overrides)
* @see com.shavenpuppy.jglib.ReadableColor#getRedByte()
*/
public byte getRedByte() {
return red;
}
/* (Overrides)
* @see com.shavenpuppy.jglib.ReadableColor#writeRGBA(java.nio.ByteBuffer)
*/
public void writeRGBA(ByteBuffer dest) {
dest.put(red);
dest.put(green);
dest.put(blue);
dest.put(alpha);
}
/* (Overrides)
* @see com.shavenpuppy.jglib.ReadableColor#writeRGB(java.nio.ByteBuffer)
*/
public void writeRGB(ByteBuffer dest) {
dest.put(red);
dest.put(green);
dest.put(blue);
}
/* (Overrides)
* @see com.shavenpuppy.jglib.ReadableColor#writeABGR(java.nio.ByteBuffer)
*/
public void writeABGR(ByteBuffer dest) {
dest.put(alpha);
dest.put(blue);
dest.put(green);
dest.put(red);
}
/* (Overrides)
* @see com.shavenpuppy.jglib.ReadableColor#writeARGB(java.nio.ByteBuffer)
*/
public void writeARGB(ByteBuffer dest) {
dest.put(alpha);
dest.put(red);
dest.put(green);
dest.put(blue);
}
/* (Overrides)
* @see com.shavenpuppy.jglib.ReadableColor#writeBGR(java.nio.ByteBuffer)
*/
public void writeBGR(ByteBuffer dest) {
dest.put(blue);
dest.put(green);
dest.put(red);
}
/* (Overrides)
* @see com.shavenpuppy.jglib.ReadableColor#writeBGRA(java.nio.ByteBuffer)
*/
public void writeBGRA(ByteBuffer dest) {
dest.put(blue);
dest.put(green);
dest.put(red);
dest.put(alpha);
}
/**
* Read a color from a byte buffer
* @param src The source buffer
*/
public void readRGBA(ByteBuffer src) {
red = src.get();
green = src.get();
blue = src.get();
alpha = src.get();
}
/**
* Read a color from a byte buffer
* @param src The source buffer
*/
public void readRGB(ByteBuffer src) {
red = src.get();
green = src.get();
blue = src.get();
}
/**
* Read a color from a byte buffer
* @param src The source buffer
*/
public void readARGB(ByteBuffer src) {
alpha = src.get();
red = src.get();
green = src.get();
blue = src.get();
}
/**
* Read a color from a byte buffer
* @param src The source buffer
*/
public void readBGRA(ByteBuffer src) {
blue = src.get();
green = src.get();
red = src.get();
alpha = src.get();
}
/**
* Read a color from a byte buffer
* @param src The source buffer
*/
public void readBGR(ByteBuffer src) {
blue = src.get();
green = src.get();
red = src.get();
}
/**
* Read a color from a byte buffer
* @param src The source buffer
*/
public void readABGR(ByteBuffer src) {
alpha = src.get();
blue = src.get();
green = src.get();
red = src.get();
}
/**
* Set this color's color by copying another color
* @param src The source color
*/
public void setColor(ReadableColor src) {
red = src.getRedByte();
green = src.getGreenByte();
blue = src.getBlueByte();
alpha = src.getAlphaByte();
}
/**
* HSB to RGB conversion, pinched from java.awt.Color.
* @param hue (0..1.0f)
* @param saturation (0..1.0f)
* @param brightness (0..1.0f)
*/
public void fromHSB(float hue, float saturation, float brightness) {
if (saturation == 0.0F) {
red = green = blue = (byte) (brightness * 255F + 0.5F);
} else {
float f3 = (hue - (float) Math.floor(hue)) * 6F;
float f4 = f3 - (float) Math.floor(f3);
float f5 = brightness * (1.0F - saturation);
float f6 = brightness * (1.0F - saturation * f4);
float f7 = brightness * (1.0F - saturation * (1.0F - f4));
switch ((int) f3) {
case 0 :
red = (byte) (brightness * 255F + 0.5F);
green = (byte) (f7 * 255F + 0.5F);
blue = (byte) (f5 * 255F + 0.5F);
break;
case 1 :
red = (byte) (f6 * 255F + 0.5F);
green = (byte) (brightness * 255F + 0.5F);
blue = (byte) (f5 * 255F + 0.5F);
break;
case 2 :
red = (byte) (f5 * 255F + 0.5F);
green = (byte) (brightness * 255F + 0.5F);
blue = (byte) (f7 * 255F + 0.5F);
break;
case 3 :
red = (byte) (f5 * 255F + 0.5F);
green = (byte) (f6 * 255F + 0.5F);
blue = (byte) (brightness * 255F + 0.5F);
break;
case 4 :
red = (byte) (f7 * 255F + 0.5F);
green = (byte) (f5 * 255F + 0.5F);
blue = (byte) (brightness * 255F + 0.5F);
break;
case 5 :
red = (byte) (brightness * 255F + 0.5F);
green = (byte) (f5 * 255F + 0.5F);
blue = (byte) (f6 * 255F + 0.5F);
break;
}
}
}
/**
* RGB to HSB conversion, pinched from java.awt.Color.
* The HSB value is returned in dest[] if dest[] is supplied.
* Values range from 0..1
* @param dest Destination floats, or null
* @return dest, or a new float array
*/
public float[] toHSB(float dest[]) {
int r = getRed();
int g = getGreen();
int b = getBlue();
if (dest == null)
dest = new float[3];
int l = r <= g ? g : r;
if (b > l)
l = b;
int i1 = r >= g ? g : r;
if (b < i1)
i1 = b;
float brightness = l / 255F;
float saturation;
if (l != 0)
saturation = (float) (l - i1) / (float) l;
else
saturation = 0.0F;
float hue;
if (saturation == 0.0F) {
hue = 0.0F;
} else {
float f3 = (float) (l - r) / (float) (l - i1);
float f4 = (float) (l - g) / (float) (l - i1);
float f5 = (float) (l - b) / (float) (l - i1);
if (r == l)
hue = f5 - f4;
else if (g == l)
hue = (2.0F + f3) - f5;
else
hue = (4F + f4) - f3;
hue /= 6F;
if (hue < 0.0F)
hue++;
}
dest[0] = hue;
dest[1] = saturation;
dest[2] = brightness;
return dest;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/Dimension.java 0000644 0001750 0001750 00000010254 11543426510 021106 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util;
import java.io.Serializable;
/**
* A 2D integer Dimension class, which looks remarkably like an AWT one.
* @author $Author: matzon $
* @version $Revision: 2983 $
* $Id: Dimension.java 2983 2008-04-07 18:36:09Z matzon $
*/
public final class Dimension implements Serializable, ReadableDimension, WritableDimension {
static final long serialVersionUID = 1L;
/** The dimensions! */
private int width, height;
/**
* Constructor for Dimension.
*/
public Dimension() {
super();
}
/**
* Constructor for Dimension.
*/
public Dimension(int w, int h) {
this.width = w;
this.height = h;
}
/**
* Constructor for Dimension.
*/
public Dimension(ReadableDimension d) {
setSize(d);
}
public void setSize(int w, int h) {
this.width = w;
this.height = h;
}
public void setSize(ReadableDimension d) {
this.width = d.getWidth();
this.height = d.getHeight();
}
/* (Overrides)
* @see com.shavenpuppy.jglib.ReadableDimension#getSize(com.shavenpuppy.jglib.Dimension)
*/
public void getSize(WritableDimension dest) {
dest.setSize(this);
}
/**
* Checks whether two dimension objects have equal values.
*/
public boolean equals(Object obj) {
if (obj instanceof ReadableDimension) {
ReadableDimension d = (ReadableDimension) obj;
return (width == d.getWidth()) && (height == d.getHeight());
}
return false;
}
/**
* Returns the hash code for this Dimension.
*
* @return a hash code for this Dimension
*/
public int hashCode() {
int sum = width + height;
return sum * (sum + 1) / 2 + width;
}
/**
* Returns a string representation of the values of this
* Dimension object's height and
* width fields. This method is intended to be used only
* for debugging purposes, and the content and format of the returned
* string may vary between implementations. The returned string may be
* empty but may not be null.
*
* @return a string representation of this Dimension
* object
*/
public String toString() {
return getClass().getName() + "[width=" + width + ",height=" + height + "]";
}
/**
* Gets the height.
* @return Returns a int
*/
public int getHeight() {
return height;
}
/**
* Sets the height.
* @param height The height to set
*/
public void setHeight(int height) {
this.height = height;
}
/**
* Gets the width.
* @return Returns a int
*/
public int getWidth() {
return width;
}
/**
* Sets the width.
* @param width The width to set
*/
public void setWidth(int width) {
this.width = width;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/input/ 0000755 0001750 0001750 00000000000 11543426510 017453 5 ustar zero79 zero79 lwjgl-2.7.1/src/java/org/lwjgl/util/input/ControllerAdapter.java 0000644 0001750 0001750 00000017337 11543426510 023755 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.input;
import org.lwjgl.input.Controller;
/**
* Adapter for the Controller interface. It can be used as placeholder
* Controller, which doesn't do anything (eg if Controllers.create() fails and
* you don't want to take care of that).
*
* @author Onyx, Aho and all the other aliases...
*/
public class ControllerAdapter implements Controller {
/**
* Get the name assigned to this controller.
*
* @return The name assigned to this controller
*/
public String getName() {
return "Dummy Controller";
}
/**
* Get the index of this controller in the collection
*
* @return The index of this controller in the collection
*/
public int getIndex() {
return 0; //-1 maybe?
}
/**
* Retrieve the number of buttons available on this controller
*
* @return The number of butotns available on this controller
*/
public int getButtonCount() {
return 0;
}
/**
* Get the name of the specified button. Be warned, often this is as
* exciting as "Button X"
*
* @param index The index of the button whose name should be retrieved
* @return The name of the button requested
*/
public String getButtonName(int index) {
return "button n/a";
}
/**
* Check if a button is currently pressed
*
* @param index The button to check
* @return True if the button is currently pressed
*/
public boolean isButtonPressed(int index) {
return false;
}
/**
* Poll the controller for new data. This will also update events
*/
public void poll() {
}
/**
* Get the X-Axis value of the POV on this controller
*
* @return The X-Axis value of the POV on this controller
*/
public float getPovX() {
return 0f;
}
/**
* Get the Y-Axis value of the POV on this controller
*
* @return The Y-Axis value of the POV on this controller
*/
public float getPovY() {
return 0f;
}
/**
* Get the dead zone for a specified axis
*
* @param index The index of the axis for which to retrieve the dead zone
* @return The dead zone for the specified axis
*/
public float getDeadZone(int index) {
return 0f;
}
/**
* Set the dead zone for the specified axis
*
* @param index The index of hte axis for which to set the dead zone
* @param zone The dead zone to use for the specified axis
*/
public void setDeadZone(int index, float zone) {
}
/**
* Retrieve the number of axes available on this controller.
*
* @return The number of axes available on this controller.
*/
public int getAxisCount() {
return 0;
}
/**
* Get the name that's given to the specified axis
*
* @param index The index of the axis whose name should be retrieved
* @return The name of the specified axis.
*/
public String getAxisName(int index) {
return "axis n/a";
}
/**
* Retrieve the value thats currently available on a specified axis. The
* value will always be between 1.0 and -1.0 and will calibrate as values
* are passed read. It may be useful to get the player to wiggle the
* joystick from side to side to get the calibration right.
*
* @param index The index of axis to be read
* @return The value from the specified axis.
*/
public float getAxisValue(int index) {
return 0f;
}
/**
* Get the value from the X axis if there is one. If no X axis is defined a
* zero value will be returned.
*
* @return The value from the X axis
*/
public float getXAxisValue() {
return 0f;
}
/**
* Get the dead zone for the X axis.
*
* @return The dead zone for the X axis
*/
public float getXAxisDeadZone() {
return 0f;
}
/**
* Set the dead zone for the X axis
*
* @param zone The dead zone to use for the X axis
*/
public void setXAxisDeadZone(float zone) {
}
/**
* Get the value from the Y axis if there is one. If no Y axis is defined a
* zero value will be returned.
*
* @return The value from the Y axis
*/
public float getYAxisValue() {
return 0f;
}
/**
* Get the dead zone for the Y axis.
*
* @return The dead zone for the Y axis
*/
public float getYAxisDeadZone() {
return 0f;
}
/**
* Set the dead zone for the Y axis
*
* @param zone The dead zone to use for the Y axis
*/
public void setYAxisDeadZone(float zone) {
}
/**
* Get the value from the Z axis if there is one. If no Z axis is defined a
* zero value will be returned.
*
* @return The value from the Z axis
*/
public float getZAxisValue() {
return 0f;
}
/**
* Get the dead zone for the Z axis.
*
* @return The dead zone for the Z axis
*/
public float getZAxisDeadZone() {
return 0f;
}
/**
* Set the dead zone for the Z axis
*
* @param zone The dead zone to use for the Z axis
*/
public void setZAxisDeadZone(float zone) {
}
/**
* Get the value from the RX axis if there is one. If no RX axis is defined
* a zero value will be returned.
*
* @return The value from the RX axis
*/
public float getRXAxisValue() {
return 0f;
}
/**
* Get the dead zone for the RX axis.
*
* @return The dead zone for the RX axis
*/
public float getRXAxisDeadZone() {
return 0f;
}
/**
* Set the dead zone for the RX axis
*
* @param zone The dead zone to use for the RX axis
*/
public void setRXAxisDeadZone(float zone) {
}
/**
* Get the value from the RY axis if there is one. If no RY axis is defined
* a zero value will be returned.
*
* @return The value from the RY axis
*/
public float getRYAxisValue() {
return 0f;
}
/**
* Get the dead zone for the RY axis.
*
* @return The dead zone for the RY axis
*/
public float getRYAxisDeadZone() {
return 0f;
}
/**
* Set the dead zone for the RY axis
*
* @param zone The dead zone to use for the RY axis
*/
public void setRYAxisDeadZone(float zone) {
}
/**
* Get the value from the RZ axis if there is one. If no RZ axis is defined
* a zero value will be returned.
*
* @return The value from the RZ axis
*/
public float getRZAxisValue() {
return 0f;
}
/**
* Get the dead zone for the RZ axis.
*
* @return The dead zone for the RZ axis
*/
public float getRZAxisDeadZone() {
return 0f;
}
/**
* Set the dead zone for the RZ axis
*
* @param zone The dead zone to use for the RZ axis
*/
public void setRZAxisDeadZone(float zone) {
}
} lwjgl-2.7.1/src/java/org/lwjgl/util/WaveData.java 0000644 0001750 0001750 00000017200 11543426510 020653 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.ShortBuffer;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import org.lwjgl.openal.AL10;
import com.sun.media.sound.WaveFileReader;
/**
*
* Utitlity class for loading wavefiles.
*
* @author Brian Matzon
* @version $Revision: 3438 $
* $Id: WaveData.java 3438 2010-10-12 15:34:26Z matzon $
*/
public class WaveData {
/** actual wave data */
public final ByteBuffer data;
/** format type of data */
public final int format;
/** sample rate of data */
public final int samplerate;
/**
* Creates a new WaveData
*
* @param data actual wavedata
* @param format format of wave data
* @param samplerate sample rate of data
*/
private WaveData(ByteBuffer data, int format, int samplerate) {
this.data = data;
this.format = format;
this.samplerate = samplerate;
}
/**
* Disposes the wavedata
*/
public void dispose() {
data.clear();
}
/**
* Creates a WaveData container from the specified url
*
* @param path URL to file
* @return WaveData containing data, or null if a failure occured
*/
public static WaveData create(URL path) {
try {
// due to an issue with AudioSystem.getAudioInputStream
// and mixing unsigned and signed code
// we will use the reader directly
WaveFileReader wfr = new WaveFileReader();
return create(wfr.getAudioInputStream(new BufferedInputStream(path.openStream())));
} catch (Exception e) {
org.lwjgl.LWJGLUtil.log("Unable to create from: " + path + ", " + e.getMessage());
return null;
}
}
/**
* Creates a WaveData container from the specified in the classpath
*
* @param path path to file (relative, and in classpath)
* @return WaveData containing data, or null if a failure occured
*/
public static WaveData create(String path) {
return create(Thread.currentThread().getContextClassLoader().getResource(path));
}
/**
* Creates a WaveData container from the specified inputstream
*
* @param is InputStream to read from
* @return WaveData containing data, or null if a failure occured
*/
public static WaveData create(InputStream is) {
try {
return create(
AudioSystem.getAudioInputStream(is));
} catch (Exception e) {
org.lwjgl.LWJGLUtil.log("Unable to create from inputstream, " + e.getMessage());
return null;
}
}
/**
* Creates a WaveData container from the specified bytes
*
* @param buffer array of bytes containing the complete wave file
* @return WaveData containing data, or null if a failure occured
*/
public static WaveData create(byte[] buffer) {
try {
return create(
AudioSystem.getAudioInputStream(
new BufferedInputStream(new ByteArrayInputStream(buffer))));
} catch (Exception e) {
org.lwjgl.LWJGLUtil.log("Unable to create from byte array, " + e.getMessage());
return null;
}
}
/**
* Creates a WaveData container from the specified ByetBuffer.
* If the buffer is backed by an array, it will be used directly,
* else the contents of the buffer will be copied using get(byte[]).
*
* @param buffer ByteBuffer containing sound file
* @return WaveData containing data, or null if a failure occured
*/
public static WaveData create(ByteBuffer buffer) {
try {
byte[] bytes = null;
if(buffer.hasArray()) {
bytes = buffer.array();
} else {
bytes = new byte[buffer.capacity()];
buffer.get(bytes);
}
return create(bytes);
} catch (Exception e) {
org.lwjgl.LWJGLUtil.log("Unable to create from ByteBuffer, " + e.getMessage());
return null;
}
}
/**
* Creates a WaveData container from the specified stream
*
* @param ais AudioInputStream to read from
* @return WaveData containing data, or null if a failure occured
*/
public static WaveData create(AudioInputStream ais) {
//get format of data
AudioFormat audioformat = ais.getFormat();
// get channels
int channels = 0;
if (audioformat.getChannels() == 1) {
if (audioformat.getSampleSizeInBits() == 8) {
channels = AL10.AL_FORMAT_MONO8;
} else if (audioformat.getSampleSizeInBits() == 16) {
channels = AL10.AL_FORMAT_MONO16;
} else {
assert false : "Illegal sample size";
}
} else if (audioformat.getChannels() == 2) {
if (audioformat.getSampleSizeInBits() == 8) {
channels = AL10.AL_FORMAT_STEREO8;
} else if (audioformat.getSampleSizeInBits() == 16) {
channels = AL10.AL_FORMAT_STEREO16;
} else {
assert false : "Illegal sample size";
}
} else {
assert false : "Only mono or stereo is supported";
}
//read data into buffer
ByteBuffer buffer = null;
try {
int available = ais.available();
if(available <= 0) {
available = ais.getFormat().getChannels() * (int) ais.getFrameLength() * ais.getFormat().getSampleSizeInBits() / 8;
}
byte[] buf = new byte[ais.available()];
int read = 0, total = 0;
while ((read = ais.read(buf, total, buf.length - total)) != -1
&& total < buf.length) {
total += read;
}
buffer = convertAudioBytes(buf, audioformat.getSampleSizeInBits() == 16);
} catch (IOException ioe) {
return null;
}
//create our result
WaveData wavedata =
new WaveData(buffer, channels, (int) audioformat.getSampleRate());
//close stream
try {
ais.close();
} catch (IOException ioe) {
}
return wavedata;
}
private static ByteBuffer convertAudioBytes(byte[] audio_bytes, boolean two_bytes_data) {
ByteBuffer dest = ByteBuffer.allocateDirect(audio_bytes.length);
dest.order(ByteOrder.nativeOrder());
ByteBuffer src = ByteBuffer.wrap(audio_bytes);
src.order(ByteOrder.LITTLE_ENDIAN);
if (two_bytes_data) {
ShortBuffer dest_short = dest.asShortBuffer();
ShortBuffer src_short = src.asShortBuffer();
while (src_short.hasRemaining())
dest_short.put(src_short.get());
} else {
while (src.hasRemaining())
dest.put(src.get());
}
dest.rewind();
return dest;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/WritableDimension.java 0000644 0001750 0001750 00000004003 11543426510 022573 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util;
/**
* Write interface for Dimensions
* @author $Author: spasi $
* @version $Revision: 3418 $
* $Id: WritableDimension.java 3418 2010-09-28 21:11:35Z spasi $
*/
public interface WritableDimension {
void setSize(int w, int h);
void setSize(ReadableDimension d);
/**
* Sets the height.
* @param height The height to set
*/
void setHeight(int height);
/**
* Sets the width.
* @param width The width to set
*/
void setWidth(int width);
} lwjgl-2.7.1/src/java/org/lwjgl/util/vector/ 0000755 0001750 0001750 00000000000 11543426510 017616 5 ustar zero79 zero79 lwjgl-2.7.1/src/java/org/lwjgl/util/vector/ReadableVector3f.java 0000644 0001750 0001750 00000003276 11543426510 023604 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.vector;
/**
* @author foo
*/
public interface ReadableVector3f extends ReadableVector2f {
/**
* @return z
*/
float getZ();
} lwjgl-2.7.1/src/java/org/lwjgl/util/vector/Matrix4f.java 0000644 0001750 0001750 00000060022 11543426510 022157 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.vector;
import java.io.Serializable;
import java.nio.FloatBuffer;
/**
* Holds a 4x4 float matrix.
*
* @author foo
*/
public class Matrix4f extends Matrix implements Serializable {
private static final long serialVersionUID = 1L;
public float m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33;
/**
* Construct a new matrix, initialized to the identity.
*/
public Matrix4f() {
super();
setIdentity();
}
/**
* Returns a string representation of this matrix
*/
public String toString() {
StringBuilder buf = new StringBuilder();
buf.append(m00).append(' ').append(m10).append(' ').append(m20).append(' ').append(m30).append('\n');
buf.append(m01).append(' ').append(m11).append(' ').append(m21).append(' ').append(m31).append('\n');
buf.append(m02).append(' ').append(m12).append(' ').append(m22).append(' ').append(m32).append('\n');
buf.append(m03).append(' ').append(m13).append(' ').append(m23).append(' ').append(m33).append('\n');
return buf.toString();
}
/**
* Set this matrix to be the identity matrix.
* @return this
*/
public Matrix setIdentity() {
return setIdentity(this);
}
/**
* Set the given matrix to be the identity matrix.
* @param m The matrix to set to the identity
* @return m
*/
public static Matrix4f setIdentity(Matrix4f m) {
m.m00 = 1.0f;
m.m01 = 0.0f;
m.m02 = 0.0f;
m.m03 = 0.0f;
m.m10 = 0.0f;
m.m11 = 1.0f;
m.m12 = 0.0f;
m.m13 = 0.0f;
m.m20 = 0.0f;
m.m21 = 0.0f;
m.m22 = 1.0f;
m.m23 = 0.0f;
m.m30 = 0.0f;
m.m31 = 0.0f;
m.m32 = 0.0f;
m.m33 = 1.0f;
return m;
}
/**
* Set this matrix to 0.
* @return this
*/
public Matrix setZero() {
return setZero(this);
}
/**
* Set the given matrix to 0.
* @param m The matrix to set to 0
* @return m
*/
public static Matrix4f setZero(Matrix4f m) {
m.m00 = 0.0f;
m.m01 = 0.0f;
m.m02 = 0.0f;
m.m03 = 0.0f;
m.m10 = 0.0f;
m.m11 = 0.0f;
m.m12 = 0.0f;
m.m13 = 0.0f;
m.m20 = 0.0f;
m.m21 = 0.0f;
m.m22 = 0.0f;
m.m23 = 0.0f;
m.m30 = 0.0f;
m.m31 = 0.0f;
m.m32 = 0.0f;
m.m33 = 0.0f;
return m;
}
/**
* Load from another matrix4f
* @param src The source matrix
* @return this
*/
public Matrix4f load(Matrix4f src) {
return load(src, this);
}
/**
* Copy the source matrix to the destination matrix
* @param src The source matrix
* @param dest The destination matrix, or null of a new one is to be created
* @return The copied matrix
*/
public static Matrix4f load(Matrix4f src, Matrix4f dest) {
if (dest == null)
dest = new Matrix4f();
dest.m00 = src.m00;
dest.m01 = src.m01;
dest.m02 = src.m02;
dest.m03 = src.m03;
dest.m10 = src.m10;
dest.m11 = src.m11;
dest.m12 = src.m12;
dest.m13 = src.m13;
dest.m20 = src.m20;
dest.m21 = src.m21;
dest.m22 = src.m22;
dest.m23 = src.m23;
dest.m30 = src.m30;
dest.m31 = src.m31;
dest.m32 = src.m32;
dest.m33 = src.m33;
return dest;
}
/**
* Load from a float buffer. The buffer stores the matrix in column major
* (OpenGL) order.
*
* @param buf A float buffer to read from
* @return this
*/
public Matrix load(FloatBuffer buf) {
m00 = buf.get();
m01 = buf.get();
m02 = buf.get();
m03 = buf.get();
m10 = buf.get();
m11 = buf.get();
m12 = buf.get();
m13 = buf.get();
m20 = buf.get();
m21 = buf.get();
m22 = buf.get();
m23 = buf.get();
m30 = buf.get();
m31 = buf.get();
m32 = buf.get();
m33 = buf.get();
return this;
}
/**
* Load from a float buffer. The buffer stores the matrix in row major
* (maths) order.
*
* @param buf A float buffer to read from
* @return this
*/
public Matrix loadTranspose(FloatBuffer buf) {
m00 = buf.get();
m10 = buf.get();
m20 = buf.get();
m30 = buf.get();
m01 = buf.get();
m11 = buf.get();
m21 = buf.get();
m31 = buf.get();
m02 = buf.get();
m12 = buf.get();
m22 = buf.get();
m32 = buf.get();
m03 = buf.get();
m13 = buf.get();
m23 = buf.get();
m33 = buf.get();
return this;
}
/**
* Store this matrix in a float buffer. The matrix is stored in column
* major (openGL) order.
* @param buf The buffer to store this matrix in
*/
public Matrix store(FloatBuffer buf) {
buf.put(m00);
buf.put(m01);
buf.put(m02);
buf.put(m03);
buf.put(m10);
buf.put(m11);
buf.put(m12);
buf.put(m13);
buf.put(m20);
buf.put(m21);
buf.put(m22);
buf.put(m23);
buf.put(m30);
buf.put(m31);
buf.put(m32);
buf.put(m33);
return this;
}
/**
* Store this matrix in a float buffer. The matrix is stored in row
* major (maths) order.
* @param buf The buffer to store this matrix in
*/
public Matrix storeTranspose(FloatBuffer buf) {
buf.put(m00);
buf.put(m10);
buf.put(m20);
buf.put(m30);
buf.put(m01);
buf.put(m11);
buf.put(m21);
buf.put(m31);
buf.put(m02);
buf.put(m12);
buf.put(m22);
buf.put(m32);
buf.put(m03);
buf.put(m13);
buf.put(m23);
buf.put(m33);
return this;
}
/**
* Add two matrices together and place the result in a third matrix.
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix
*/
public static Matrix4f add(Matrix4f left, Matrix4f right, Matrix4f dest) {
if (dest == null)
dest = new Matrix4f();
dest.m00 = left.m00 + right.m00;
dest.m01 = left.m01 + right.m01;
dest.m02 = left.m02 + right.m02;
dest.m03 = left.m03 + right.m03;
dest.m10 = left.m10 + right.m10;
dest.m11 = left.m11 + right.m11;
dest.m12 = left.m12 + right.m12;
dest.m13 = left.m13 + right.m13;
dest.m20 = left.m20 + right.m20;
dest.m21 = left.m21 + right.m21;
dest.m22 = left.m22 + right.m22;
dest.m23 = left.m23 + right.m23;
dest.m30 = left.m30 + right.m30;
dest.m31 = left.m31 + right.m31;
dest.m32 = left.m32 + right.m32;
dest.m33 = left.m33 + right.m33;
return dest;
}
/**
* Subtract the right matrix from the left and place the result in a third matrix.
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix
*/
public static Matrix4f sub(Matrix4f left, Matrix4f right, Matrix4f dest) {
if (dest == null)
dest = new Matrix4f();
dest.m00 = left.m00 - right.m00;
dest.m01 = left.m01 - right.m01;
dest.m02 = left.m02 - right.m02;
dest.m03 = left.m03 - right.m03;
dest.m10 = left.m10 - right.m10;
dest.m11 = left.m11 - right.m11;
dest.m12 = left.m12 - right.m12;
dest.m13 = left.m13 - right.m13;
dest.m20 = left.m20 - right.m20;
dest.m21 = left.m21 - right.m21;
dest.m22 = left.m22 - right.m22;
dest.m23 = left.m23 - right.m23;
dest.m30 = left.m30 - right.m30;
dest.m31 = left.m31 - right.m31;
dest.m32 = left.m32 - right.m32;
dest.m33 = left.m33 - right.m33;
return dest;
}
/**
* Multiply the right matrix by the left and place the result in a third matrix.
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix
*/
public static Matrix4f mul(Matrix4f left, Matrix4f right, Matrix4f dest) {
if (dest == null)
dest = new Matrix4f();
float m00 = left.m00 * right.m00 + left.m10 * right.m01 + left.m20 * right.m02 + left.m30 * right.m03;
float m01 = left.m01 * right.m00 + left.m11 * right.m01 + left.m21 * right.m02 + left.m31 * right.m03;
float m02 = left.m02 * right.m00 + left.m12 * right.m01 + left.m22 * right.m02 + left.m32 * right.m03;
float m03 = left.m03 * right.m00 + left.m13 * right.m01 + left.m23 * right.m02 + left.m33 * right.m03;
float m10 = left.m00 * right.m10 + left.m10 * right.m11 + left.m20 * right.m12 + left.m30 * right.m13;
float m11 = left.m01 * right.m10 + left.m11 * right.m11 + left.m21 * right.m12 + left.m31 * right.m13;
float m12 = left.m02 * right.m10 + left.m12 * right.m11 + left.m22 * right.m12 + left.m32 * right.m13;
float m13 = left.m03 * right.m10 + left.m13 * right.m11 + left.m23 * right.m12 + left.m33 * right.m13;
float m20 = left.m00 * right.m20 + left.m10 * right.m21 + left.m20 * right.m22 + left.m30 * right.m23;
float m21 = left.m01 * right.m20 + left.m11 * right.m21 + left.m21 * right.m22 + left.m31 * right.m23;
float m22 = left.m02 * right.m20 + left.m12 * right.m21 + left.m22 * right.m22 + left.m32 * right.m23;
float m23 = left.m03 * right.m20 + left.m13 * right.m21 + left.m23 * right.m22 + left.m33 * right.m23;
float m30 = left.m00 * right.m30 + left.m10 * right.m31 + left.m20 * right.m32 + left.m30 * right.m33;
float m31 = left.m01 * right.m30 + left.m11 * right.m31 + left.m21 * right.m32 + left.m31 * right.m33;
float m32 = left.m02 * right.m30 + left.m12 * right.m31 + left.m22 * right.m32 + left.m32 * right.m33;
float m33 = left.m03 * right.m30 + left.m13 * right.m31 + left.m23 * right.m32 + left.m33 * right.m33;
dest.m00 = m00;
dest.m01 = m01;
dest.m02 = m02;
dest.m03 = m03;
dest.m10 = m10;
dest.m11 = m11;
dest.m12 = m12;
dest.m13 = m13;
dest.m20 = m20;
dest.m21 = m21;
dest.m22 = m22;
dest.m23 = m23;
dest.m30 = m30;
dest.m31 = m31;
dest.m32 = m32;
dest.m33 = m33;
return dest;
}
/**
* Transform a Vector by a matrix and return the result in a destination
* vector.
* @param left The left matrix
* @param right The right vector
* @param dest The destination vector, or null if a new one is to be created
* @return the destination vector
*/
public static Vector4f transform(Matrix4f left, Vector4f right, Vector4f dest) {
if (dest == null)
dest = new Vector4f();
float x = left.m00 * right.x + left.m10 * right.y + left.m20 * right.z + left.m30 * right.w;
float y = left.m01 * right.x + left.m11 * right.y + left.m21 * right.z + left.m31 * right.w;
float z = left.m02 * right.x + left.m12 * right.y + left.m22 * right.z + left.m32 * right.w;
float w = left.m03 * right.x + left.m13 * right.y + left.m23 * right.z + left.m33 * right.w;
dest.x = x;
dest.y = y;
dest.z = z;
dest.w = w;
return dest;
}
/**
* Transpose this matrix
* @return this
*/
public Matrix transpose() {
return transpose(this);
}
/**
* Translate this matrix
* @param vec The vector to translate by
* @return this
*/
public Matrix4f translate(Vector2f vec) {
return translate(vec, this);
}
/**
* Translate this matrix
* @param vec The vector to translate by
* @return this
*/
public Matrix4f translate(Vector3f vec) {
return translate(vec, this);
}
/**
* Scales this matrix
* @param vec The vector to scale by
* @return this
*/
public Matrix4f scale(Vector3f vec) {
return scale(vec, this, this);
}
/**
* Scales the source matrix and put the result in the destination matrix
* @param vec The vector to scale by
* @param src The source matrix
* @param dest The destination matrix, or null if a new matrix is to be created
* @return The scaled matrix
*/
public static Matrix4f scale(Vector3f vec, Matrix4f src, Matrix4f dest) {
if (dest == null)
dest = new Matrix4f();
dest.m00 = src.m00 * vec.x;
dest.m01 = src.m01 * vec.x;
dest.m02 = src.m02 * vec.x;
dest.m03 = src.m03 * vec.x;
dest.m10 = src.m10 * vec.y;
dest.m11 = src.m11 * vec.y;
dest.m12 = src.m12 * vec.y;
dest.m13 = src.m13 * vec.y;
dest.m20 = src.m20 * vec.z;
dest.m21 = src.m21 * vec.z;
dest.m22 = src.m22 * vec.z;
dest.m23 = src.m23 * vec.z;
return dest;
}
/**
* Rotates the matrix around the given axis the specified angle
* @param angle the angle, in radians.
* @param axis The vector representing the rotation axis. Must be normalized.
* @return this
*/
public Matrix4f rotate(float angle, Vector3f axis) {
return rotate(angle, axis, this);
}
/**
* Rotates the matrix around the given axis the specified angle
* @param angle the angle, in radians.
* @param axis The vector representing the rotation axis. Must be normalized.
* @param dest The matrix to put the result, or null if a new matrix is to be created
* @return The rotated matrix
*/
public Matrix4f rotate(float angle, Vector3f axis, Matrix4f dest) {
return rotate(angle, axis, this, dest);
}
/**
* Rotates the source matrix around the given axis the specified angle and
* put the result in the destination matrix.
* @param angle the angle, in radians.
* @param axis The vector representing the rotation axis. Must be normalized.
* @param src The matrix to rotate
* @param dest The matrix to put the result, or null if a new matrix is to be created
* @return The rotated matrix
*/
public static Matrix4f rotate(float angle, Vector3f axis, Matrix4f src, Matrix4f dest) {
if (dest == null)
dest = new Matrix4f();
float c = (float) Math.cos(angle);
float s = (float) Math.sin(angle);
float oneminusc = 1.0f - c;
float xy = axis.x*axis.y;
float yz = axis.y*axis.z;
float xz = axis.x*axis.z;
float xs = axis.x*s;
float ys = axis.y*s;
float zs = axis.z*s;
float f00 = axis.x*axis.x*oneminusc+c;
float f01 = xy*oneminusc+zs;
float f02 = xz*oneminusc-ys;
// n[3] not used
float f10 = xy*oneminusc-zs;
float f11 = axis.y*axis.y*oneminusc+c;
float f12 = yz*oneminusc+xs;
// n[7] not used
float f20 = xz*oneminusc+ys;
float f21 = yz*oneminusc-xs;
float f22 = axis.z*axis.z*oneminusc+c;
float t00 = src.m00 * f00 + src.m10 * f01 + src.m20 * f02;
float t01 = src.m01 * f00 + src.m11 * f01 + src.m21 * f02;
float t02 = src.m02 * f00 + src.m12 * f01 + src.m22 * f02;
float t03 = src.m03 * f00 + src.m13 * f01 + src.m23 * f02;
float t10 = src.m00 * f10 + src.m10 * f11 + src.m20 * f12;
float t11 = src.m01 * f10 + src.m11 * f11 + src.m21 * f12;
float t12 = src.m02 * f10 + src.m12 * f11 + src.m22 * f12;
float t13 = src.m03 * f10 + src.m13 * f11 + src.m23 * f12;
dest.m20 = src.m00 * f20 + src.m10 * f21 + src.m20 * f22;
dest.m21 = src.m01 * f20 + src.m11 * f21 + src.m21 * f22;
dest.m22 = src.m02 * f20 + src.m12 * f21 + src.m22 * f22;
dest.m23 = src.m03 * f20 + src.m13 * f21 + src.m23 * f22;
dest.m00 = t00;
dest.m01 = t01;
dest.m02 = t02;
dest.m03 = t03;
dest.m10 = t10;
dest.m11 = t11;
dest.m12 = t12;
dest.m13 = t13;
return dest;
}
/**
* Translate this matrix and stash the result in another matrix
* @param vec The vector to translate by
* @param dest The destination matrix or null if a new matrix is to be created
* @return the translated matrix
*/
public Matrix4f translate(Vector3f vec, Matrix4f dest) {
return translate(vec, this, dest);
}
/**
* Translate the source matrix and stash the result in the destination matrix
* @param vec The vector to translate by
* @param src The source matrix
* @param dest The destination matrix or null if a new matrix is to be created
* @return The translated matrix
*/
public static Matrix4f translate(Vector3f vec, Matrix4f src, Matrix4f dest) {
if (dest == null)
dest = new Matrix4f();
dest.m30 += src.m00 * vec.x + src.m10 * vec.y + src.m20 * vec.z;
dest.m31 += src.m01 * vec.x + src.m11 * vec.y + src.m21 * vec.z;
dest.m32 += src.m02 * vec.x + src.m12 * vec.y + src.m22 * vec.z;
dest.m33 += src.m03 * vec.x + src.m13 * vec.y + src.m23 * vec.z;
return dest;
}
/**
* Translate this matrix and stash the result in another matrix
* @param vec The vector to translate by
* @param dest The destination matrix or null if a new matrix is to be created
* @return the translated matrix
*/
public Matrix4f translate(Vector2f vec, Matrix4f dest) {
return translate(vec, this, dest);
}
/**
* Translate the source matrix and stash the result in the destination matrix
* @param vec The vector to translate by
* @param src The source matrix
* @param dest The destination matrix or null if a new matrix is to be created
* @return The translated matrix
*/
public static Matrix4f translate(Vector2f vec, Matrix4f src, Matrix4f dest) {
if (dest == null)
dest = new Matrix4f();
dest.m30 += src.m00 * vec.x + src.m10 * vec.y;
dest.m31 += src.m01 * vec.x + src.m11 * vec.y;
dest.m32 += src.m02 * vec.x + src.m12 * vec.y;
dest.m33 += src.m03 * vec.x + src.m13 * vec.y;
return dest;
}
/**
* Transpose this matrix and place the result in another matrix
* @param dest The destination matrix or null if a new matrix is to be created
* @return the transposed matrix
*/
public Matrix4f transpose(Matrix4f dest) {
return transpose(this, dest);
}
/**
* Transpose the source matrix and place the result in the destination matrix
* @param src The source matrix
* @param dest The destination matrix or null if a new matrix is to be created
* @return the transposed matrix
*/
public static Matrix4f transpose(Matrix4f src, Matrix4f dest) {
if (dest == null)
dest = new Matrix4f();
float m00 = src.m00;
float m01 = src.m10;
float m02 = src.m20;
float m03 = src.m30;
float m10 = src.m01;
float m11 = src.m11;
float m12 = src.m21;
float m13 = src.m31;
float m20 = src.m02;
float m21 = src.m12;
float m22 = src.m22;
float m23 = src.m32;
float m30 = src.m03;
float m31 = src.m13;
float m32 = src.m23;
float m33 = src.m33;
dest.m00 = m00;
dest.m01 = m01;
dest.m02 = m02;
dest.m03 = m03;
dest.m10 = m10;
dest.m11 = m11;
dest.m12 = m12;
dest.m13 = m13;
dest.m20 = m20;
dest.m21 = m21;
dest.m22 = m22;
dest.m23 = m23;
dest.m30 = m30;
dest.m31 = m31;
dest.m32 = m32;
dest.m33 = m33;
return dest;
}
/**
* @return the determinant of the matrix
*/
public float determinant() {
float f =
m00
* ((m11 * m22 * m33 + m12 * m23 * m31 + m13 * m21 * m32)
- m13 * m22 * m31
- m11 * m23 * m32
- m12 * m21 * m33);
f -= m01
* ((m10 * m22 * m33 + m12 * m23 * m30 + m13 * m20 * m32)
- m13 * m22 * m30
- m10 * m23 * m32
- m12 * m20 * m33);
f += m02
* ((m10 * m21 * m33 + m11 * m23 * m30 + m13 * m20 * m31)
- m13 * m21 * m30
- m10 * m23 * m31
- m11 * m20 * m33);
f -= m03
* ((m10 * m21 * m32 + m11 * m22 * m30 + m12 * m20 * m31)
- m12 * m21 * m30
- m10 * m22 * m31
- m11 * m20 * m32);
return f;
}
/**
* Calculate the determinant of a 3x3 matrix
* @return result
*/
private static float determinant3x3(float t00, float t01, float t02,
float t10, float t11, float t12,
float t20, float t21, float t22)
{
return t00 * (t11 * t22 - t12 * t21)
+ t01 * (t12 * t20 - t10 * t22)
+ t02 * (t10 * t21 - t11 * t20);
}
/**
* Invert this matrix
* @return this if successful, null otherwise
*/
public Matrix invert() {
return invert(this, this);
}
/**
* Invert the source matrix and put the result in the destination
* @param src The source matrix
* @param dest The destination matrix, or null if a new matrix is to be created
* @return The inverted matrix if successful, null otherwise
*/
public static Matrix4f invert(Matrix4f src, Matrix4f dest) {
float determinant = src.determinant();
if (determinant != 0) {
/*
* m00 m01 m02 m03
* m10 m11 m12 m13
* m20 m21 m22 m23
* m30 m31 m32 m33
*/
if (dest == null)
dest = new Matrix4f();
float determinant_inv = 1f/determinant;
// first row
float t00 = determinant3x3(src.m11, src.m12, src.m13, src.m21, src.m22, src.m23, src.m31, src.m32, src.m33);
float t01 = -determinant3x3(src.m10, src.m12, src.m13, src.m20, src.m22, src.m23, src.m30, src.m32, src.m33);
float t02 = determinant3x3(src.m10, src.m11, src.m13, src.m20, src.m21, src.m23, src.m30, src.m31, src.m33);
float t03 = -determinant3x3(src.m10, src.m11, src.m12, src.m20, src.m21, src.m22, src.m30, src.m31, src.m32);
// second row
float t10 = -determinant3x3(src.m01, src.m02, src.m03, src.m21, src.m22, src.m23, src.m31, src.m32, src.m33);
float t11 = determinant3x3(src.m00, src.m02, src.m03, src.m20, src.m22, src.m23, src.m30, src.m32, src.m33);
float t12 = -determinant3x3(src.m00, src.m01, src.m03, src.m20, src.m21, src.m23, src.m30, src.m31, src.m33);
float t13 = determinant3x3(src.m00, src.m01, src.m02, src.m20, src.m21, src.m22, src.m30, src.m31, src.m32);
// third row
float t20 = determinant3x3(src.m01, src.m02, src.m03, src.m11, src.m12, src.m13, src.m31, src.m32, src.m33);
float t21 = -determinant3x3(src.m00, src.m02, src.m03, src.m10, src.m12, src.m13, src.m30, src.m32, src.m33);
float t22 = determinant3x3(src.m00, src.m01, src.m03, src.m10, src.m11, src.m13, src.m30, src.m31, src.m33);
float t23 = -determinant3x3(src.m00, src.m01, src.m02, src.m10, src.m11, src.m12, src.m30, src.m31, src.m32);
// fourth row
float t30 = -determinant3x3(src.m01, src.m02, src.m03, src.m11, src.m12, src.m13, src.m21, src.m22, src.m23);
float t31 = determinant3x3(src.m00, src.m02, src.m03, src.m10, src.m12, src.m13, src.m20, src.m22, src.m23);
float t32 = -determinant3x3(src.m00, src.m01, src.m03, src.m10, src.m11, src.m13, src.m20, src.m21, src.m23);
float t33 = determinant3x3(src.m00, src.m01, src.m02, src.m10, src.m11, src.m12, src.m20, src.m21, src.m22);
// transpose and divide by the determinant
dest.m00 = t00*determinant_inv;
dest.m11 = t11*determinant_inv;
dest.m22 = t22*determinant_inv;
dest.m33 = t33*determinant_inv;
dest.m01 = t10*determinant_inv;
dest.m10 = t01*determinant_inv;
dest.m20 = t02*determinant_inv;
dest.m02 = t20*determinant_inv;
dest.m12 = t21*determinant_inv;
dest.m21 = t12*determinant_inv;
dest.m03 = t30*determinant_inv;
dest.m30 = t03*determinant_inv;
dest.m13 = t31*determinant_inv;
dest.m31 = t13*determinant_inv;
dest.m32 = t23*determinant_inv;
dest.m23 = t32*determinant_inv;
return dest;
} else
return null;
}
/**
* Negate this matrix
* @return this
*/
public Matrix negate() {
return negate(this);
}
/**
* Negate this matrix and place the result in a destination matrix.
* @param dest The destination matrix, or null if a new matrix is to be created
* @return the negated matrix
*/
public Matrix4f negate(Matrix4f dest) {
return negate(this, this);
}
/**
* Negate this matrix and place the result in a destination matrix.
* @param src The source matrix
* @param dest The destination matrix, or null if a new matrix is to be created
* @return The negated matrix
*/
public static Matrix4f negate(Matrix4f src, Matrix4f dest) {
if (dest == null)
dest = new Matrix4f();
dest.m00 = -src.m00;
dest.m01 = -src.m01;
dest.m02 = -src.m02;
dest.m03 = -src.m03;
dest.m10 = -src.m10;
dest.m11 = -src.m11;
dest.m12 = -src.m12;
dest.m13 = -src.m13;
dest.m20 = -src.m20;
dest.m21 = -src.m21;
dest.m22 = -src.m22;
dest.m23 = -src.m23;
dest.m30 = -src.m30;
dest.m31 = -src.m31;
dest.m32 = -src.m32;
dest.m33 = -src.m33;
return dest;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/vector/ReadableVector4f.java 0000644 0001750 0001750 00000003301 11543426510 023572 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.vector;
/**
* @author foo
*/
public interface ReadableVector4f extends ReadableVector3f {
/**
* @return w
*/
float getW();
}
lwjgl-2.7.1/src/java/org/lwjgl/util/vector/Matrix3f.java 0000644 0001750 0001750 00000031657 11543426510 022172 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.vector;
import java.io.Serializable;
import java.nio.FloatBuffer;
/**
*
* Holds a 3x3 matrix.
*
* @author cix_foo
* @version $Revision: 3418 $
* $Id: Matrix3f.java 3418 2010-09-28 21:11:35Z spasi $
*/
public class Matrix3f extends Matrix implements Serializable {
private static final long serialVersionUID = 1L;
public float m00,
m01,
m02,
m10,
m11,
m12,
m20,
m21,
m22;
/**
* Constructor for Matrix3f. Matrix is initialised to the identity.
*/
public Matrix3f() {
super();
setIdentity();
}
/**
* Load from another matrix
* @param src The source matrix
* @return this
*/
public Matrix3f load(Matrix3f src) {
return load(src, this);
}
/**
* Copy source matrix to destination matrix
* @param src The source matrix
* @param dest The destination matrix, or null of a new matrix is to be created
* @return The copied matrix
*/
public static Matrix3f load(Matrix3f src, Matrix3f dest) {
if (dest == null)
dest = new Matrix3f();
dest.m00 = src.m00;
dest.m10 = src.m10;
dest.m20 = src.m20;
dest.m01 = src.m01;
dest.m11 = src.m11;
dest.m21 = src.m21;
dest.m02 = src.m02;
dest.m12 = src.m12;
dest.m22 = src.m22;
return dest;
}
/**
* Load from a float buffer. The buffer stores the matrix in column major
* (OpenGL) order.
*
* @param buf A float buffer to read from
* @return this
*/
public Matrix load(FloatBuffer buf) {
m00 = buf.get();
m01 = buf.get();
m02 = buf.get();
m10 = buf.get();
m11 = buf.get();
m12 = buf.get();
m20 = buf.get();
m21 = buf.get();
m22 = buf.get();
return this;
}
/**
* Load from a float buffer. The buffer stores the matrix in row major
* (maths) order.
*
* @param buf A float buffer to read from
* @return this
*/
public Matrix loadTranspose(FloatBuffer buf) {
m00 = buf.get();
m10 = buf.get();
m20 = buf.get();
m01 = buf.get();
m11 = buf.get();
m21 = buf.get();
m02 = buf.get();
m12 = buf.get();
m22 = buf.get();
return this;
}
/**
* Store this matrix in a float buffer. The matrix is stored in column
* major (openGL) order.
* @param buf The buffer to store this matrix in
*/
public Matrix store(FloatBuffer buf) {
buf.put(m00);
buf.put(m01);
buf.put(m02);
buf.put(m10);
buf.put(m11);
buf.put(m12);
buf.put(m20);
buf.put(m21);
buf.put(m22);
return this;
}
/**
* Store this matrix in a float buffer. The matrix is stored in row
* major (maths) order.
* @param buf The buffer to store this matrix in
*/
public Matrix storeTranspose(FloatBuffer buf) {
buf.put(m00);
buf.put(m10);
buf.put(m20);
buf.put(m01);
buf.put(m11);
buf.put(m21);
buf.put(m02);
buf.put(m12);
buf.put(m22);
return this;
}
/**
* Add two matrices together and place the result in a third matrix.
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix
*/
public static Matrix3f add(Matrix3f left, Matrix3f right, Matrix3f dest) {
if (dest == null)
dest = new Matrix3f();
dest.m00 = left.m00 + right.m00;
dest.m01 = left.m01 + right.m01;
dest.m02 = left.m02 + right.m02;
dest.m10 = left.m10 + right.m10;
dest.m11 = left.m11 + right.m11;
dest.m12 = left.m12 + right.m12;
dest.m20 = left.m20 + right.m20;
dest.m21 = left.m21 + right.m21;
dest.m22 = left.m22 + right.m22;
return dest;
}
/**
* Subtract the right matrix from the left and place the result in a third matrix.
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix
*/
public static Matrix3f sub(Matrix3f left, Matrix3f right, Matrix3f dest) {
if (dest == null)
dest = new Matrix3f();
dest.m00 = left.m00 - right.m00;
dest.m01 = left.m01 - right.m01;
dest.m02 = left.m02 - right.m02;
dest.m10 = left.m10 - right.m10;
dest.m11 = left.m11 - right.m11;
dest.m12 = left.m12 - right.m12;
dest.m20 = left.m20 - right.m20;
dest.m21 = left.m21 - right.m21;
dest.m22 = left.m22 - right.m22;
return dest;
}
/**
* Multiply the right matrix by the left and place the result in a third matrix.
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix
*/
public static Matrix3f mul(Matrix3f left, Matrix3f right, Matrix3f dest) {
if (dest == null)
dest = new Matrix3f();
float m00 =
left.m00 * right.m00 + left.m10 * right.m01 + left.m20 * right.m02;
float m01 =
left.m01 * right.m00 + left.m11 * right.m01 + left.m21 * right.m02;
float m02 =
left.m02 * right.m00 + left.m12 * right.m01 + left.m22 * right.m02;
float m10 =
left.m00 * right.m10 + left.m10 * right.m11 + left.m20 * right.m12;
float m11 =
left.m01 * right.m10 + left.m11 * right.m11 + left.m21 * right.m12;
float m12 =
left.m02 * right.m10 + left.m12 * right.m11 + left.m22 * right.m12;
float m20 =
left.m00 * right.m20 + left.m10 * right.m21 + left.m20 * right.m22;
float m21 =
left.m01 * right.m20 + left.m11 * right.m21 + left.m21 * right.m22;
float m22 =
left.m02 * right.m20 + left.m12 * right.m21 + left.m22 * right.m22;
dest.m00 = m00;
dest.m01 = m01;
dest.m02 = m02;
dest.m10 = m10;
dest.m11 = m11;
dest.m12 = m12;
dest.m20 = m20;
dest.m21 = m21;
dest.m22 = m22;
return dest;
}
/**
* Transform a Vector by a matrix and return the result in a destination
* vector.
* @param left The left matrix
* @param right The right vector
* @param dest The destination vector, or null if a new one is to be created
* @return the destination vector
*/
public static Vector3f transform(Matrix3f left, Vector3f right, Vector3f dest) {
if (dest == null)
dest = new Vector3f();
float x = left.m00 * right.x + left.m10 * right.y + left.m20 * right.z;
float y = left.m01 * right.x + left.m11 * right.y + left.m21 * right.z;
float z = left.m02 * right.x + left.m12 * right.y + left.m22 * right.z;
dest.x = x;
dest.y = y;
dest.z = z;
return dest;
}
/**
* Transpose this matrix
* @return this
*/
public Matrix transpose() {
return transpose(this, this);
}
/**
* Transpose this matrix and place the result in another matrix
* @param dest The destination matrix or null if a new matrix is to be created
* @return the transposed matrix
*/
public Matrix3f transpose(Matrix3f dest) {
return transpose(this, dest);
}
/**
* Transpose the source matrix and place the result into the destination matrix
* @param src The source matrix to be transposed
* @param dest The destination matrix or null if a new matrix is to be created
* @return the transposed matrix
*/
public static Matrix3f transpose(Matrix3f src, Matrix3f dest) {
if (dest == null)
dest = new Matrix3f();
float m00 = src.m00;
float m01 = src.m10;
float m02 = src.m20;
float m10 = src.m01;
float m11 = src.m11;
float m12 = src.m21;
float m20 = src.m02;
float m21 = src.m12;
float m22 = src.m22;
dest.m00 = m00;
dest.m01 = m01;
dest.m02 = m02;
dest.m10 = m10;
dest.m11 = m11;
dest.m12 = m12;
dest.m20 = m20;
dest.m21 = m21;
dest.m22 = m22;
return dest;
}
/**
* @return the determinant of the matrix
*/
public float determinant() {
float f =
m00 * (m11 * m22 - m12 * m21)
+ m01 * (m12 * m20 - m10 * m22)
+ m02 * (m10 * m21 - m11 * m20);
return f;
}
/**
* Returns a string representation of this matrix
*/
public String toString() {
StringBuilder buf = new StringBuilder();
buf.append(m00).append(' ').append(m10).append(' ').append(m20).append(' ').append('\n');
buf.append(m01).append(' ').append(m11).append(' ').append(m21).append(' ').append('\n');
buf.append(m02).append(' ').append(m12).append(' ').append(m22).append(' ').append('\n');
return buf.toString();
}
/**
* Invert this matrix
* @return this if successful, null otherwise
*/
public Matrix invert() {
return invert(this, this);
}
/**
* Invert the source matrix and put the result into the destination matrix
* @param src The source matrix to be inverted
* @param dest The destination matrix, or null if a new one is to be created
* @return The inverted matrix if successful, null otherwise
*/
public static Matrix3f invert(Matrix3f src, Matrix3f dest) {
float determinant = src.determinant();
if (determinant != 0) {
if (dest == null)
dest = new Matrix3f();
/* do it the ordinary way
*
* inv(A) = 1/det(A) * adj(T), where adj(T) = transpose(Conjugate Matrix)
*
* m00 m01 m02
* m10 m11 m12
* m20 m21 m22
*/
float determinant_inv = 1f/determinant;
// get the conjugate matrix
float t00 = src.m11 * src.m22 - src.m12* src.m21;
float t01 = - src.m10 * src.m22 + src.m12 * src.m20;
float t02 = src.m10 * src.m21 - src.m11 * src.m20;
float t10 = - src.m01 * src.m22 + src.m02 * src.m21;
float t11 = src.m00 * src.m22 - src.m02 * src.m20;
float t12 = - src.m00 * src.m21 + src.m01 * src.m20;
float t20 = src.m01 * src.m12 - src.m02 * src.m11;
float t21 = -src.m00 * src.m12 + src.m02 * src.m10;
float t22 = src.m00 * src.m11 - src.m01 * src.m10;
dest.m00 = t00*determinant_inv;
dest.m11 = t11*determinant_inv;
dest.m22 = t22*determinant_inv;
dest.m01 = t10*determinant_inv;
dest.m10 = t01*determinant_inv;
dest.m20 = t02*determinant_inv;
dest.m02 = t20*determinant_inv;
dest.m12 = t21*determinant_inv;
dest.m21 = t12*determinant_inv;
return dest;
} else
return null;
}
/**
* Negate this matrix
* @return this
*/
public Matrix negate() {
return negate(this);
}
/**
* Negate this matrix and place the result in a destination matrix.
* @param dest The destination matrix, or null if a new matrix is to be created
* @return the negated matrix
*/
public Matrix3f negate(Matrix3f dest) {
return negate(this, this);
}
/**
* Negate the source matrix and place the result in the destination matrix.
* @param src The source matrix
* @param dest The destination matrix, or null if a new matrix is to be created
* @return the negated matrix
*/
public static Matrix3f negate(Matrix3f src, Matrix3f dest) {
if (dest == null)
dest = new Matrix3f();
dest.m00 = -src.m00;
dest.m01 = -src.m02;
dest.m02 = -src.m01;
dest.m10 = -src.m10;
dest.m11 = -src.m12;
dest.m12 = -src.m11;
dest.m20 = -src.m20;
dest.m21 = -src.m22;
dest.m22 = -src.m21;
return dest;
}
/**
* Set this matrix to be the identity matrix.
* @return this
*/
public Matrix setIdentity() {
return setIdentity(this);
}
/**
* Set the matrix to be the identity matrix.
* @param m The matrix to be set to the identity
* @return m
*/
public static Matrix3f setIdentity(Matrix3f m) {
m.m00 = 1.0f;
m.m01 = 0.0f;
m.m02 = 0.0f;
m.m10 = 0.0f;
m.m11 = 1.0f;
m.m12 = 0.0f;
m.m20 = 0.0f;
m.m21 = 0.0f;
m.m22 = 1.0f;
return m;
}
/**
* Set this matrix to 0.
* @return this
*/
public Matrix setZero() {
return setZero(this);
}
/**
* Set the matrix matrix to 0.
* @param m The matrix to be set to 0
* @return m
*/
public static Matrix3f setZero(Matrix3f m) {
m.m00 = 0.0f;
m.m01 = 0.0f;
m.m02 = 0.0f;
m.m10 = 0.0f;
m.m11 = 0.0f;
m.m12 = 0.0f;
m.m20 = 0.0f;
m.m21 = 0.0f;
m.m22 = 0.0f;
return m;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/vector/Matrix2f.java 0000644 0001750 0001750 00000023654 11543426510 022167 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.vector;
import java.io.Serializable;
import java.nio.FloatBuffer;
/**
*
* Holds a 2x2 matrix
*
* @author cix_foo
* @version $Revision: 3418 $
* $Id: Matrix2f.java 3418 2010-09-28 21:11:35Z spasi $
*/
public class Matrix2f extends Matrix implements Serializable {
private static final long serialVersionUID = 1L;
public float m00, m01, m10, m11;
/**
* Constructor for Matrix2f. The matrix is initialised to the identity.
*/
public Matrix2f() {
setIdentity();
}
/**
* Constructor
*/
public Matrix2f(Matrix2f src) {
load(src);
}
/**
* Load from another matrix
* @param src The source matrix
* @return this
*/
public Matrix2f load(Matrix2f src) {
return load(src, this);
}
/**
* Copy the source matrix to the destination matrix.
* @param src The source matrix
* @param dest The destination matrix, or null if a new one should be created.
* @return The copied matrix
*/
public static Matrix2f load(Matrix2f src, Matrix2f dest) {
if (dest == null)
dest = new Matrix2f();
dest.m00 = src.m00;
dest.m01 = src.m01;
dest.m10 = src.m10;
dest.m11 = src.m11;
return dest;
}
/**
* Load from a float buffer. The buffer stores the matrix in column major
* (OpenGL) order.
*
* @param buf A float buffer to read from
* @return this
*/
public Matrix load(FloatBuffer buf) {
m00 = buf.get();
m01 = buf.get();
m10 = buf.get();
m11 = buf.get();
return this;
}
/**
* Load from a float buffer. The buffer stores the matrix in row major
* (mathematical) order.
*
* @param buf A float buffer to read from
* @return this
*/
public Matrix loadTranspose(FloatBuffer buf) {
m00 = buf.get();
m10 = buf.get();
m01 = buf.get();
m11 = buf.get();
return this;
}
/**
* Store this matrix in a float buffer. The matrix is stored in column
* major (openGL) order.
* @param buf The buffer to store this matrix in
*/
public Matrix store(FloatBuffer buf) {
buf.put(m00);
buf.put(m01);
buf.put(m10);
buf.put(m11);
return this;
}
/**
* Store this matrix in a float buffer. The matrix is stored in row
* major (maths) order.
* @param buf The buffer to store this matrix in
*/
public Matrix storeTranspose(FloatBuffer buf) {
buf.put(m00);
buf.put(m10);
buf.put(m01);
buf.put(m11);
return this;
}
/**
* Add two matrices together and place the result in a third matrix.
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix
*/
public static Matrix2f add(Matrix2f left, Matrix2f right, Matrix2f dest) {
if (dest == null)
dest = new Matrix2f();
dest.m00 = left.m00 + right.m00;
dest.m01 = left.m01 + right.m01;
dest.m10 = left.m10 + right.m10;
dest.m11 = left.m11 + right.m11;
return dest;
}
/**
* Subtract the right matrix from the left and place the result in a third matrix.
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix
*/
public static Matrix2f sub(Matrix2f left, Matrix2f right, Matrix2f dest) {
if (dest == null)
dest = new Matrix2f();
dest.m00 = left.m00 - right.m00;
dest.m01 = left.m01 - right.m01;
dest.m10 = left.m10 - right.m10;
dest.m11 = left.m11 - right.m11;
return dest;
}
/**
* Multiply the right matrix by the left and place the result in a third matrix.
* @param left The left source matrix
* @param right The right source matrix
* @param dest The destination matrix, or null if a new one is to be created
* @return the destination matrix
*/
public static Matrix2f mul(Matrix2f left, Matrix2f right, Matrix2f dest) {
if (dest == null)
dest = new Matrix2f();
float m00 = left.m00 * right.m00 + left.m10 * right.m01;
float m01 = left.m01 * right.m00 + left.m11 * right.m01;
float m10 = left.m00 * right.m10 + left.m10 * right.m11;
float m11 = left.m01 * right.m10 + left.m11 * right.m11;
dest.m00 = m00;
dest.m01 = m01;
dest.m10 = m10;
dest.m11 = m11;
return dest;
}
/**
* Transform a Vector by a matrix and return the result in a destination
* vector.
* @param left The left matrix
* @param right The right vector
* @param dest The destination vector, or null if a new one is to be created
* @return the destination vector
*/
public static Vector2f transform(Matrix2f left, Vector2f right, Vector2f dest) {
if (dest == null)
dest = new Vector2f();
float x = left.m00 * right.x + left.m10 * right.y;
float y = left.m01 * right.x + left.m11 * right.y;
dest.x = x;
dest.y = y;
return dest;
}
/**
* Transpose this matrix
* @return this
*/
public Matrix transpose() {
return transpose(this);
}
/**
* Transpose this matrix and place the result in another matrix.
* @param dest The destination matrix or null if a new matrix is to be created
* @return the transposed matrix
*/
public Matrix2f transpose(Matrix2f dest) {
return transpose(this, dest);
}
/**
* Transpose the source matrix and place the result in the destination matrix.
* @param src The source matrix or null if a new matrix is to be created
* @param dest The destination matrix or null if a new matrix is to be created
* @return the transposed matrix
*/
public static Matrix2f transpose(Matrix2f src, Matrix2f dest) {
if (dest == null)
dest = new Matrix2f();
float m01 = src.m10;
float m10 = src.m01;
dest.m01 = m01;
dest.m10 = m10;
return dest;
}
/**
* Invert this matrix
* @return this if successful, null otherwise
*/
public Matrix invert() {
return invert(this, this);
}
/**
* Invert the source matrix and place the result in the destination matrix.
* @param src The source matrix to be inverted
* @param dest The destination matrix or null if a new matrix is to be created
* @return The inverted matrix, or null if source can't be reverted.
*/
public static Matrix2f invert(Matrix2f src, Matrix2f dest) {
/*
*inv(A) = 1/det(A) * adj(A);
*/
float determinant = src.determinant();
if (determinant != 0) {
if (dest == null)
dest = new Matrix2f();
float determinant_inv = 1f/determinant;
float t00 = src.m11*determinant_inv;
float t01 = -src.m01*determinant_inv;
float t11 = src.m00*determinant_inv;
float t10 = -src.m10*determinant_inv;
dest.m00 = t00;
dest.m01 = t01;
dest.m10 = t10;
dest.m11 = t11;
return dest;
} else
return null;
}
/**
* Returns a string representation of this matrix
*/
public String toString() {
StringBuilder buf = new StringBuilder();
buf.append(m00).append(' ').append(m10).append(' ').append('\n');
buf.append(m01).append(' ').append(m11).append(' ').append('\n');
return buf.toString();
}
/**
* Negate this matrix
* @return this
*/
public Matrix negate() {
return negate(this);
}
/**
* Negate this matrix and stash the result in another matrix.
* @param dest The destination matrix, or null if a new matrix is to be created
* @return the negated matrix
*/
public Matrix2f negate(Matrix2f dest) {
return negate(this, this);
}
/**
* Negate the source matrix and stash the result in the destination matrix.
* @param src The source matrix to be negated
* @param dest The destination matrix, or null if a new matrix is to be created
* @return the negated matrix
*/
public static Matrix2f negate(Matrix2f src, Matrix2f dest) {
if (dest == null)
dest = new Matrix2f();
dest.m00 = -src.m00;
dest.m01 = -src.m01;
dest.m10 = -src.m10;
dest.m11 = -src.m11;
return dest;
}
/**
* Set this matrix to be the identity matrix.
* @return this
*/
public Matrix setIdentity() {
return setIdentity(this);
}
/**
* Set the source matrix to be the identity matrix.
* @param src The matrix to set to the identity.
* @return The source matrix
*/
public static Matrix2f setIdentity(Matrix2f src) {
src.m00 = 1.0f;
src.m01 = 0.0f;
src.m10 = 0.0f;
src.m11 = 1.0f;
return src;
}
/**
* Set this matrix to 0.
* @return this
*/
public Matrix setZero() {
return setZero(this);
}
public static Matrix2f setZero(Matrix2f src) {
src.m00 = 0.0f;
src.m01 = 0.0f;
src.m10 = 0.0f;
src.m11 = 0.0f;
return src;
}
/* (non-Javadoc)
* @see org.lwjgl.vector.Matrix#determinant()
*/
public float determinant() {
return m00 * m11 - m01*m10;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/vector/ReadableVector.java 0000644 0001750 0001750 00000003715 11543426510 023351 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.vector;
import java.nio.FloatBuffer;
/**
* @author foo
*/
public interface ReadableVector {
/**
* @return the length of the vector
*/
float length();
/**
* @return the length squared of the vector
*/
float lengthSquared();
/**
* Store this vector in a FloatBuffer
* @param buf The buffer to store it in, at the current position
* @return this
*/
Vector store(FloatBuffer buf);
} lwjgl-2.7.1/src/java/org/lwjgl/util/vector/Vector3f.java 0000644 0001750 0001750 00000017024 11543426510 022160 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.vector;
import java.io.Serializable;
import java.nio.FloatBuffer;
/**
*
* Holds a 3-tuple vector.
*
* @author cix_foo
* @version $Revision: 3418 $
* $Id: Vector3f.java 3418 2010-09-28 21:11:35Z spasi $
*/
public class Vector3f extends Vector implements Serializable, ReadableVector3f, WritableVector3f {
private static final long serialVersionUID = 1L;
public float x, y, z;
/**
* Constructor for Vector3f.
*/
public Vector3f() {
super();
}
/**
* Constructor
*/
public Vector3f(ReadableVector3f src) {
set(src);
}
/**
* Constructor
*/
public Vector3f(float x, float y, float z) {
set(x, y, z);
}
/* (non-Javadoc)
* @see org.lwjgl.util.vector.WritableVector2f#set(float, float)
*/
public void set(float x, float y) {
this.x = x;
this.y = y;
}
/* (non-Javadoc)
* @see org.lwjgl.util.vector.WritableVector3f#set(float, float, float)
*/
public void set(float x, float y, float z) {
this.x = x;
this.y = y;
this.z = z;
}
/**
* Load from another Vector3f
* @param src The source vector
* @return this
*/
public Vector3f set(ReadableVector3f src) {
x = src.getX();
y = src.getY();
z = src.getZ();
return this;
}
/**
* @return the length squared of the vector
*/
public float lengthSquared() {
return x * x + y * y + z * z;
}
/**
* Translate a vector
* @param x The translation in x
* @param y the translation in y
* @return this
*/
public Vector3f translate(float x, float y, float z) {
this.x += x;
this.y += y;
this.z += z;
return this;
}
/**
* Add a vector to another vector and place the result in a destination
* vector.
* @param left The LHS vector
* @param right The RHS vector
* @param dest The destination vector, or null if a new vector is to be created
* @return the sum of left and right in dest
*/
public static Vector3f add(Vector3f left, Vector3f right, Vector3f dest) {
if (dest == null)
return new Vector3f(left.x + right.x, left.y + right.y, left.z + right.z);
else {
dest.set(left.x + right.x, left.y + right.y, left.z + right.z);
return dest;
}
}
/**
* Subtract a vector from another vector and place the result in a destination
* vector.
* @param left The LHS vector
* @param right The RHS vector
* @param dest The destination vector, or null if a new vector is to be created
* @return left minus right in dest
*/
public static Vector3f sub(Vector3f left, Vector3f right, Vector3f dest) {
if (dest == null)
return new Vector3f(left.x - right.x, left.y - right.y, left.z - right.z);
else {
dest.set(left.x - right.x, left.y - right.y, left.z - right.z);
return dest;
}
}
/**
* The cross product of two vectors.
*
* @param left The LHS vector
* @param right The RHS vector
* @param dest The destination result, or null if a new vector is to be created
* @return left cross right
*/
public static Vector3f cross(
Vector3f left,
Vector3f right,
Vector3f dest)
{
if (dest == null)
dest = new Vector3f();
dest.set(
left.y * right.z - left.z * right.y,
right.x * left.z - right.z * left.x,
left.x * right.y - left.y * right.x
);
return dest;
}
/**
* Negate a vector
* @return this
*/
public Vector negate() {
x = -x;
y = -y;
z = -z;
return this;
}
/**
* Negate a vector and place the result in a destination vector.
* @param dest The destination vector or null if a new vector is to be created
* @return the negated vector
*/
public Vector3f negate(Vector3f dest) {
if (dest == null)
dest = new Vector3f();
dest.x = -x;
dest.y = -y;
dest.z = -z;
return dest;
}
/**
* Normalise this vector and place the result in another vector.
* @param dest The destination vector, or null if a new vector is to be created
* @return the normalised vector
*/
public Vector3f normalise(Vector3f dest) {
float l = length();
if (dest == null)
dest = new Vector3f(x / l, y / l, z / l);
else
dest.set(x / l, y / l, z / l);
return dest;
}
/**
* The dot product of two vectors is calculated as
* v1.x * v2.x + v1.y * v2.y + v1.z * v2.z
* @param left The LHS vector
* @param right The RHS vector
* @return left dot right
*/
public static float dot(Vector3f left, Vector3f right) {
return left.x * right.x + left.y * right.y + left.z * right.z;
}
/**
* Calculate the angle between two vectors, in radians
* @param a A vector
* @param b The other vector
* @return the angle between the two vectors, in radians
*/
public static float angle(Vector3f a, Vector3f b) {
float dls = dot(a, b) / (a.length() * b.length());
if (dls < -1f)
dls = -1f;
else if (dls > 1.0f)
dls = 1.0f;
return (float)Math.acos(dls);
}
/* (non-Javadoc)
* @see org.lwjgl.vector.Vector#load(FloatBuffer)
*/
public Vector load(FloatBuffer buf) {
x = buf.get();
y = buf.get();
z = buf.get();
return this;
}
/* (non-Javadoc)
* @see org.lwjgl.vector.Vector#scale(float)
*/
public Vector scale(float scale) {
x *= scale;
y *= scale;
z *= scale;
return this;
}
/* (non-Javadoc)
* @see org.lwjgl.vector.Vector#store(FloatBuffer)
*/
public Vector store(FloatBuffer buf) {
buf.put(x);
buf.put(y);
buf.put(z);
return this;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
public String toString() {
StringBuilder sb = new StringBuilder(64);
sb.append("Vector3f[");
sb.append(x);
sb.append(", ");
sb.append(y);
sb.append(", ");
sb.append(z);
sb.append(']');
return sb.toString();
}
/**
* @return x
*/
public final float getX() {
return x;
}
/**
* @return y
*/
public final float getY() {
return y;
}
/**
* Set X
* @param x
*/
public final void setX(float x) {
this.x = x;
}
/**
* Set Y
* @param y
*/
public final void setY(float y) {
this.y = y;
}
/**
* Set Z
* @param z
*/
public void setZ(float z) {
this.z = z;
}
/* (Overrides)
* @see org.lwjgl.vector.ReadableVector3f#getZ()
*/
public float getZ() {
return z;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/vector/WritableVector2f.java 0000644 0001750 0001750 00000003732 11543426510 023652 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.vector;
/**
* Writable interface to Vector2fs
* @author $author$
* @version $revision$
* $Id: WritableVector2f.java 3418 2010-09-28 21:11:35Z spasi $
*/
public interface WritableVector2f {
/**
* Set the X value
* @param x
*/
void setX(float x);
/**
* Set the Y value
* @param y
*/
void setY(float y);
/**
* Set the X,Y values
* @param x
* @param y
*/
void set(float x, float y);
} lwjgl-2.7.1/src/java/org/lwjgl/util/vector/WritableVector3f.java 0000644 0001750 0001750 00000003713 11543426510 023652 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.vector;
/**
* Writable interface to Vector3fs
* @author $author$
* @version $revision$
* $Id: WritableVector3f.java 3418 2010-09-28 21:11:35Z spasi $
*/
public interface WritableVector3f extends WritableVector2f {
/**
* Set the Z value
* @param z
*/
void setZ(float z);
/**
* Set the X,Y,Z values
* @param x
* @param y
* @param z
*/
void set(float x, float y, float z);
} lwjgl-2.7.1/src/java/org/lwjgl/util/vector/Vector2f.java 0000644 0001750 0001750 00000014757 11543426510 022171 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.vector;
import java.io.Serializable;
import java.nio.FloatBuffer;
/**
*
* Holds a 2-tuple vector.
*
* @author cix_foo
* @version $Revision: 3418 $
* $Id: Vector2f.java 3418 2010-09-28 21:11:35Z spasi $
*/
public class Vector2f extends Vector implements Serializable, ReadableVector2f, WritableVector2f {
private static final long serialVersionUID = 1L;
public float x, y;
/**
* Constructor for Vector3f.
*/
public Vector2f() {
super();
}
/**
* Constructor
*/
public Vector2f(ReadableVector2f src) {
set(src);
}
/**
* Constructor
*/
public Vector2f(float x, float y) {
set(x, y);
}
/* (non-Javadoc)
* @see org.lwjgl.util.vector.WritableVector2f#set(float, float)
*/
public void set(float x, float y) {
this.x = x;
this.y = y;
}
/**
* Load from another Vector2f
* @param src The source vector
* @return this
*/
public Vector2f set(ReadableVector2f src) {
x = src.getX();
y = src.getY();
return this;
}
/**
* @return the length squared of the vector
*/
public float lengthSquared() {
return x * x + y * y;
}
/**
* Translate a vector
* @param x The translation in x
* @param y the translation in y
* @return this
*/
public Vector2f translate(float x, float y) {
this.x += x;
this.y += y;
return this;
}
/**
* Negate a vector
* @return this
*/
public Vector negate() {
x = -x;
y = -y;
return this;
}
/**
* Negate a vector and place the result in a destination vector.
* @param dest The destination vector or null if a new vector is to be created
* @return the negated vector
*/
public Vector2f negate(Vector2f dest) {
if (dest == null)
dest = new Vector2f();
dest.x = -x;
dest.y = -y;
return dest;
}
/**
* Normalise this vector and place the result in another vector.
* @param dest The destination vector, or null if a new vector is to be created
* @return the normalised vector
*/
public Vector2f normalise(Vector2f dest) {
float l = length();
if (dest == null)
dest = new Vector2f(x / l, y / l);
else
dest.set(x / l, y / l);
return dest;
}
/**
* The dot product of two vectors is calculated as
* v1.x * v2.x + v1.y * v2.y + v1.z * v2.z
* @param left The LHS vector
* @param right The RHS vector
* @return left dot right
*/
public static float dot(Vector2f left, Vector2f right) {
return left.x * right.x + left.y * right.y;
}
/**
* Calculate the angle between two vectors, in radians
* @param a A vector
* @param b The other vector
* @return the angle between the two vectors, in radians
*/
public static float angle(Vector2f a, Vector2f b) {
float dls = dot(a, b) / (a.length() * b.length());
if (dls < -1f)
dls = -1f;
else if (dls > 1.0f)
dls = 1.0f;
return (float)Math.acos(dls);
}
/**
* Add a vector to another vector and place the result in a destination
* vector.
* @param left The LHS vector
* @param right The RHS vector
* @param dest The destination vector, or null if a new vector is to be created
* @return the sum of left and right in dest
*/
public static Vector2f add(Vector2f left, Vector2f right, Vector2f dest) {
if (dest == null)
return new Vector2f(left.x + right.x, left.y + right.y);
else {
dest.set(left.x + right.x, left.y + right.y);
return dest;
}
}
/**
* Subtract a vector from another vector and place the result in a destination
* vector.
* @param left The LHS vector
* @param right The RHS vector
* @param dest The destination vector, or null if a new vector is to be created
* @return left minus right in dest
*/
public static Vector2f sub(Vector2f left, Vector2f right, Vector2f dest) {
if (dest == null)
return new Vector2f(left.x - right.x, left.y - right.y);
else {
dest.set(left.x - right.x, left.y - right.y);
return dest;
}
}
/**
* Store this vector in a FloatBuffer
* @param buf The buffer to store it in, at the current position
* @return this
*/
public Vector store(FloatBuffer buf) {
buf.put(x);
buf.put(y);
return this;
}
/**
* Load this vector from a FloatBuffer
* @param buf The buffer to load it from, at the current position
* @return this
*/
public Vector load(FloatBuffer buf) {
x = buf.get();
y = buf.get();
return this;
}
/* (non-Javadoc)
* @see org.lwjgl.vector.Vector#scale(float)
*/
public Vector scale(float scale) {
x *= scale;
y *= scale;
return this;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
public String toString() {
StringBuilder sb = new StringBuilder(64);
sb.append("Vector2f[");
sb.append(x);
sb.append(", ");
sb.append(y);
sb.append(']');
return sb.toString();
}
/**
* @return x
*/
public final float getX() {
return x;
}
/**
* @return y
*/
public final float getY() {
return y;
}
/**
* Set X
* @param x
*/
public final void setX(float x) {
this.x = x;
}
/**
* Set Y
* @param y
*/
public final void setY(float y) {
this.y = y;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/vector/WritableVector4f.java 0000644 0001750 0001750 00000003744 11543426510 023657 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.vector;
/**
* Writable interface to Vector4fs
* @author $author$
* @version $revision$
* $Id: WritableVector4f.java 3418 2010-09-28 21:11:35Z spasi $
*/
public interface WritableVector4f extends WritableVector3f {
/**
* Set the W value
* @param w
*/
void setW(float w);
/**
* Set the X,Y,Z,W values
* @param x
* @param y
* @param z
* @param w
*/
void set(float x, float y, float z, float w);
} lwjgl-2.7.1/src/java/org/lwjgl/util/vector/Matrix.java 0000644 0001750 0001750 00000006703 11543426510 021733 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.vector;
import java.io.Serializable;
import java.nio.FloatBuffer;
/**
*
* Base class for matrices. When a matrix is constructed it will be the identity
* matrix unless otherwise stated.
*
* @author cix_foo
* @version $Revision: 3418 $
* $Id: Matrix.java 3418 2010-09-28 21:11:35Z spasi $
*/
public abstract class Matrix implements Serializable {
/**
* Constructor for Matrix.
*/
protected Matrix() {
super();
}
/**
* Set this matrix to be the identity matrix.
* @return this
*/
public abstract Matrix setIdentity();
/**
* Invert this matrix
* @return this
*/
public abstract Matrix invert();
/**
* Load from a float buffer. The buffer stores the matrix in column major
* (OpenGL) order.
*
* @param buf A float buffer to read from
* @return this
*/
public abstract Matrix load(FloatBuffer buf);
/**
* Load from a float buffer. The buffer stores the matrix in row major
* (mathematical) order.
*
* @param buf A float buffer to read from
* @return this
*/
public abstract Matrix loadTranspose(FloatBuffer buf);
/**
* Negate this matrix
* @return this
*/
public abstract Matrix negate();
/**
* Store this matrix in a float buffer. The matrix is stored in column
* major (openGL) order.
* @param buf The buffer to store this matrix in
* @return this
*/
public abstract Matrix store(FloatBuffer buf);
/**
* Store this matrix in a float buffer. The matrix is stored in row
* major (maths) order.
* @param buf The buffer to store this matrix in
* @return this
*/
public abstract Matrix storeTranspose(FloatBuffer buf);
/**
* Transpose this matrix
* @return this
*/
public abstract Matrix transpose();
/**
* Set this matrix to 0.
* @return this
*/
public abstract Matrix setZero();
/**
* @return the determinant of the matrix
*/
public abstract float determinant();
}
lwjgl-2.7.1/src/java/org/lwjgl/util/vector/Vector.java 0000644 0001750 0001750 00000005735 11543426510 021735 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.vector;
import java.io.Serializable;
import java.nio.FloatBuffer;
/**
*
* Base class for vectors.
*
* @author cix_foo
* @version $Revision: 3418 $
* $Id: Vector.java 3418 2010-09-28 21:11:35Z spasi $
*/
public abstract class Vector implements Serializable, ReadableVector {
/**
* Constructor for Vector.
*/
protected Vector() {
super();
}
/**
* @return the length of the vector
*/
public final float length() {
return (float) Math.sqrt(lengthSquared());
}
/**
* @return the length squared of the vector
*/
public abstract float lengthSquared();
/**
* Load this vector from a FloatBuffer
* @param buf The buffer to load it from, at the current position
* @return this
*/
public abstract Vector load(FloatBuffer buf);
/**
* Negate a vector
* @return this
*/
public abstract Vector negate();
/**
* Normalise this vector
* @return this
*/
public final Vector normalise() {
float len = length();
if (len != 0.0f) {
float l = 1.0f / len;
return scale(l);
} else
throw new IllegalStateException("Zero length vector");
}
/**
* Store this vector in a FloatBuffer
* @param buf The buffer to store it in, at the current position
* @return this
*/
public abstract Vector store(FloatBuffer buf);
/**
* Scale this vector
* @param scale The scale factor
* @return this
*/
public abstract Vector scale(float scale);
}
lwjgl-2.7.1/src/java/org/lwjgl/util/vector/ReadableVector2f.java 0000644 0001750 0001750 00000003343 11543426510 023576 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.vector;
/**
* @author foo
*/
public interface ReadableVector2f extends ReadableVector {
/**
* @return x
*/
float getX();
/**
* @return y
*/
float getY();
} lwjgl-2.7.1/src/java/org/lwjgl/util/vector/Vector4f.java 0000644 0001750 0001750 00000016743 11543426510 022170 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.vector;
import java.io.Serializable;
import java.nio.FloatBuffer;
/**
*
* Holds a 4-tuple vector.
*
* @author cix_foo
* @version $Revision: 2983 $
* $Id: Vector4f.java 2983 2008-04-07 18:36:09Z matzon $
*/
public class Vector4f extends Vector implements Serializable, ReadableVector4f, WritableVector4f {
private static final long serialVersionUID = 1L;
public float x, y, z, w;
/**
* Constructor for Vector4f.
*/
public Vector4f() {
super();
}
/**
* Constructor
*/
public Vector4f(ReadableVector4f src) {
set(src);
}
/**
* Constructor
*/
public Vector4f(float x, float y, float z, float w) {
set(x, y, z, w);
}
/* (non-Javadoc)
* @see org.lwjgl.util.vector.WritableVector2f#set(float, float)
*/
public void set(float x, float y) {
this.x = x;
this.y = y;
}
/* (non-Javadoc)
* @see org.lwjgl.util.vector.WritableVector3f#set(float, float, float)
*/
public void set(float x, float y, float z) {
this.x = x;
this.y = y;
this.z = z;
}
/* (non-Javadoc)
* @see org.lwjgl.util.vector.WritableVector4f#set(float, float, float, float)
*/
public void set(float x, float y, float z, float w) {
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
/**
* Load from another Vector4f
* @param src The source vector
* @return this
*/
public Vector4f set(ReadableVector4f src) {
x = src.getX();
y = src.getY();
z = src.getZ();
w = src.getW();
return this;
}
/**
* @return the length squared of the vector
*/
public float lengthSquared() {
return x * x + y * y + z * z + w * w;
}
/**
* Translate a vector
* @param x The translation in x
* @param y the translation in y
* @return this
*/
public Vector4f translate(float x, float y, float z, float w) {
this.x += x;
this.y += y;
this.z += z;
this.w += w;
return this;
}
/**
* Add a vector to another vector and place the result in a destination
* vector.
* @param left The LHS vector
* @param right The RHS vector
* @param dest The destination vector, or null if a new vector is to be created
* @return the sum of left and right in dest
*/
public static Vector4f add(Vector4f left, Vector4f right, Vector4f dest) {
if (dest == null)
return new Vector4f(left.x + right.x, left.y + right.y, left.z + right.z, left.w + right.w);
else {
dest.set(left.x + right.x, left.y + right.y, left.z + right.z, left.w + right.w);
return dest;
}
}
/**
* Subtract a vector from another vector and place the result in a destination
* vector.
* @param left The LHS vector
* @param right The RHS vector
* @param dest The destination vector, or null if a new vector is to be created
* @return left minus right in dest
*/
public static Vector4f sub(Vector4f left, Vector4f right, Vector4f dest) {
if (dest == null)
return new Vector4f(left.x - right.x, left.y - right.y, left.z - right.z, left.w - right.w);
else {
dest.set(left.x - right.x, left.y - right.y, left.z - right.z, left.w - right.w);
return dest;
}
}
/**
* Negate a vector
* @return this
*/
public Vector negate() {
x = -x;
y = -y;
z = -z;
w = -w;
return this;
}
/**
* Negate a vector and place the result in a destination vector.
* @param dest The destination vector or null if a new vector is to be created
* @return the negated vector
*/
public Vector4f negate(Vector4f dest) {
if (dest == null)
dest = new Vector4f();
dest.x = -x;
dest.y = -y;
dest.z = -z;
dest.w = -w;
return dest;
}
/**
* Normalise this vector and place the result in another vector.
* @param dest The destination vector, or null if a new vector is to be created
* @return the normalised vector
*/
public Vector4f normalise(Vector4f dest) {
float l = length();
if (dest == null)
dest = new Vector4f(x / l, y / l, z / l, w / l);
else
dest.set(x / l, y / l, z / l, w / l);
return dest;
}
/**
* The dot product of two vectors is calculated as
* v1.x * v2.x + v1.y * v2.y + v1.z * v2.z + v1.w * v2.w
* @param left The LHS vector
* @param right The RHS vector
* @return left dot right
*/
public static float dot(Vector4f left, Vector4f right) {
return left.x * right.x + left.y * right.y + left.z * right.z + left.w * right.w;
}
/**
* Calculate the angle between two vectors, in radians
* @param a A vector
* @param b The other vector
* @return the angle between the two vectors, in radians
*/
public static float angle(Vector4f a, Vector4f b) {
float dls = dot(a, b) / (a.length() * b.length());
if (dls < -1f)
dls = -1f;
else if (dls > 1.0f)
dls = 1.0f;
return (float)Math.acos(dls);
}
/* (non-Javadoc)
* @see org.lwjgl.vector.Vector#load(FloatBuffer)
*/
public Vector load(FloatBuffer buf) {
x = buf.get();
y = buf.get();
z = buf.get();
w = buf.get();
return this;
}
/* (non-Javadoc)
* @see org.lwjgl.vector.Vector#scale(float)
*/
public Vector scale(float scale) {
x *= scale;
y *= scale;
z *= scale;
w *= scale;
return this;
}
/* (non-Javadoc)
* @see org.lwjgl.vector.Vector#store(FloatBuffer)
*/
public Vector store(FloatBuffer buf) {
buf.put(x);
buf.put(y);
buf.put(z);
buf.put(w);
return this;
}
public String toString() {
return "Vector4f: " + x + " " + y + " " + z + " " + w;
}
/**
* @return x
*/
public final float getX() {
return x;
}
/**
* @return y
*/
public final float getY() {
return y;
}
/**
* Set X
* @param x
*/
public final void setX(float x) {
this.x = x;
}
/**
* Set Y
* @param y
*/
public final void setY(float y) {
this.y = y;
}
/**
* Set Z
* @param z
*/
public void setZ(float z) {
this.z = z;
}
/* (Overrides)
* @see org.lwjgl.vector.ReadableVector3f#getZ()
*/
public float getZ() {
return z;
}
/**
* Set W
* @param w
*/
public void setW(float w) {
this.w = w;
}
/* (Overrides)
* @see org.lwjgl.vector.ReadableVector3f#getZ()
*/
public float getW() {
return w;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/vector/Quaternion.java 0000644 0001750 0001750 00000030046 11543426510 022611 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.vector;
/**
*
* Quaternions for LWJGL!
*
* @author fbi
* @version $Revision: 3418 $
* $Id: Quaternion.java 3418 2010-09-28 21:11:35Z spasi $
*/
import java.nio.FloatBuffer;
public class Quaternion extends Vector implements ReadableVector4f {
private static final long serialVersionUID = 1L;
public float x, y, z, w;
/**
* C'tor. The quaternion will be initialized to the identity.
*/
public Quaternion() {
super();
setIdentity();
}
/**
* C'tor
*
* @param src
*/
public Quaternion(ReadableVector4f src) {
set(src);
}
/**
* C'tor
*
*/
public Quaternion(float x, float y, float z, float w) {
set(x, y, z, w);
}
/*
* (non-Javadoc)
*
* @see org.lwjgl.util.vector.WritableVector2f#set(float, float)
*/
public void set(float x, float y) {
this.x = x;
this.y = y;
}
/*
* (non-Javadoc)
*
* @see org.lwjgl.util.vector.WritableVector3f#set(float, float, float)
*/
public void set(float x, float y, float z) {
this.x = x;
this.y = y;
this.z = z;
}
/*
* (non-Javadoc)
*
* @see org.lwjgl.util.vector.WritableVector4f#set(float, float, float,
* float)
*/
public void set(float x, float y, float z, float w) {
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
/**
* Load from another Vector4f
*
* @param src
* The source vector
* @return this
*/
public Quaternion set(ReadableVector4f src) {
x = src.getX();
y = src.getY();
z = src.getZ();
w = src.getW();
return this;
}
/**
* Set this quaternion to the multiplication identity.
* @return this
*/
public Quaternion setIdentity() {
return setIdentity(this);
}
/**
* Set the given quaternion to the multiplication identity.
* @param q The quaternion
* @return q
*/
public static Quaternion setIdentity(Quaternion q) {
q.x = 0;
q.y = 0;
q.z = 0;
q.w = 1;
return q;
}
/**
* @return the length squared of the quaternion
*/
public float lengthSquared() {
return x * x + y * y + z * z + w * w;
}
/**
* Normalise the source quaternion and place the result in another quaternion.
*
* @param src
* The source quaternion
* @param dest
* The destination quaternion, or null if a new quaternion is to be
* created
* @return The normalised quaternion
*/
public static Quaternion normalise(Quaternion src, Quaternion dest) {
float inv_l = 1f/src.length();
if (dest == null)
dest = new Quaternion();
dest.set(src.x * inv_l, src.y * inv_l, src.z * inv_l, src.w * inv_l);
return dest;
}
/**
* Normalise this quaternion and place the result in another quaternion.
*
* @param dest
* The destination quaternion, or null if a new quaternion is to be
* created
* @return the normalised quaternion
*/
public Quaternion normalise(Quaternion dest) {
return normalise(this, dest);
}
/**
* The dot product of two quaternions
*
* @param left
* The LHS quat
* @param right
* The RHS quat
* @return left dot right
*/
public static float dot(Quaternion left, Quaternion right) {
return left.x * right.x + left.y * right.y + left.z * right.z + left.w
* right.w;
}
/**
* Calculate the conjugate of this quaternion and put it into the given one
*
* @param dest
* The quaternion which should be set to the conjugate of this
* quaternion
*/
public Quaternion negate(Quaternion dest) {
return negate(this, dest);
}
/**
* Calculate the conjugate of this quaternion and put it into the given one
*
* @param src
* The source quaternion
* @param dest
* The quaternion which should be set to the conjugate of this
* quaternion
*/
public static Quaternion negate(Quaternion src, Quaternion dest) {
if (dest == null)
dest = new Quaternion();
dest.x = -src.x;
dest.y = -src.y;
dest.z = -src.z;
dest.w = src.w;
return dest;
}
/**
* Calculate the conjugate of this quaternion
*/
public Vector negate() {
return negate(this, this);
}
/* (non-Javadoc)
* @see org.lwjgl.util.vector.Vector#load(java.nio.FloatBuffer)
*/
public Vector load(FloatBuffer buf) {
x = buf.get();
y = buf.get();
z = buf.get();
w = buf.get();
return this;
}
/*
* (non-Javadoc)
*
* @see org.lwjgl.vector.Vector#scale(float)
*/
public Vector scale(float scale) {
return scale(scale, this, this);
}
/**
* Scale the source quaternion by scale and put the result in the destination
* @param scale The amount to scale by
* @param src The source quaternion
* @param dest The destination quaternion, or null if a new quaternion is to be created
* @return The scaled quaternion
*/
public static Quaternion scale(float scale, Quaternion src, Quaternion dest) {
if (dest == null)
dest = new Quaternion();
dest.x = src.x * scale;
dest.y = src.y * scale;
dest.z = src.z * scale;
dest.w = src.w * scale;
return dest;
}
/* (non-Javadoc)
* @see org.lwjgl.util.vector.ReadableVector#store(java.nio.FloatBuffer)
*/
public Vector store(FloatBuffer buf) {
buf.put(x);
buf.put(y);
buf.put(z);
buf.put(w);
return this;
}
/**
* @return x
*/
public final float getX() {
return x;
}
/**
* @return y
*/
public final float getY() {
return y;
}
/**
* Set X
*
* @param x
*/
public final void setX(float x) {
this.x = x;
}
/**
* Set Y
*
* @param y
*/
public final void setY(float y) {
this.y = y;
}
/**
* Set Z
*
* @param z
*/
public void setZ(float z) {
this.z = z;
}
/*
* (Overrides)
*
* @see org.lwjgl.vector.ReadableVector3f#getZ()
*/
public float getZ() {
return z;
}
/**
* Set W
*
* @param w
*/
public void setW(float w) {
this.w = w;
}
/*
* (Overrides)
*
* @see org.lwjgl.vector.ReadableVector3f#getW()
*/
public float getW() {
return w;
}
public String toString() {
return "Quaternion: " + x + " " + y + " " + z + " " + w;
}
/**
* Sets the value of this quaternion to the quaternion product of
* quaternions left and right (this = left * right). Note that this is safe
* for aliasing (e.g. this can be left or right).
*
* @param left
* the first quaternion
* @param right
* the second quaternion
*/
public static Quaternion mul(Quaternion left, Quaternion right,
Quaternion dest) {
if (dest == null)
dest = new Quaternion();
dest.set(left.x * right.w + left.w * right.x + left.y * right.z
- left.z * right.y, left.y * right.w + left.w * right.y
+ left.z * right.x - left.x * right.z, left.z * right.w
+ left.w * right.z + left.x * right.y - left.y * right.x,
left.w * right.w - left.x * right.x - left.y * right.y
- left.z * right.z);
return dest;
}
/**
*
* Multiplies quaternion left by the inverse of quaternion right and places
* the value into this quaternion. The value of both argument quaternions is
* preservered (this = left * right^-1).
*
* @param left
* the left quaternion
* @param right
* the right quaternion
*/
public static Quaternion mulInverse(Quaternion left, Quaternion right,
Quaternion dest) {
float n = right.lengthSquared();
// zero-div may occur.
n = (n == 0.0 ? n : 1 / n);
// store on stack once for aliasing-safty
if (dest == null)
dest = new Quaternion();
dest
.set((left.x * right.w - left.w * right.x - left.y
* right.z + left.z * right.y)
* n, (left.y * right.w - left.w * right.y - left.z
* right.x + left.x * right.z)
* n, (left.z * right.w - left.w * right.z - left.x
* right.y + left.y * right.x)
* n, (left.w * right.w + left.x * right.x + left.y
* right.y + left.z * right.z)
* n);
return dest;
}
/**
* Sets the value of this quaternion to the equivalent rotation of the
* Axis-Angle argument.
*
* @param a1
* the axis-angle: (x,y,z) is the axis and w is the angle
*/
public final void setFromAxisAngle(Vector4f a1) {
x = a1.x;
y = a1.y;
z = a1.z;
float n = (float) Math.sqrt(x * x + y * y + z * z);
// zero-div may occur.
float s = (float) (Math.sin(0.5 * a1.w) / n);
x *= s;
y *= s;
z *= s;
w = (float) Math.cos(0.5 * a1.w);
}
/**
* Sets the value of this quaternion using the rotational component of the
* passed matrix.
*
* @param m
* The matrix
* @return this
*/
public final Quaternion setFromMatrix(Matrix4f m) {
return setFromMatrix(m, this);
}
/**
* Sets the value of the source quaternion using the rotational component of the
* passed matrix.
*
* @param m
* The source matrix
* @param q
* The destination quaternion, or null if a new quaternion is to be created
* @return q
*/
public static Quaternion setFromMatrix(Matrix4f m, Quaternion q) {
return q.setFromMat(m.m00, m.m01, m.m02, m.m10, m.m11, m.m12, m.m20,
m.m21, m.m22);
}
/**
* Sets the value of this quaternion using the rotational component of the
* passed matrix.
*
* @param m
* The source matrix
*/
public final Quaternion setFromMatrix(Matrix3f m) {
return setFromMatrix(m, this);
}
/**
* Sets the value of the source quaternion using the rotational component of the
* passed matrix.
*
* @param m
* The source matrix
* @param q
* The destination quaternion, or null if a new quaternion is to be created
* @return q
*/
public static Quaternion setFromMatrix(Matrix3f m, Quaternion q) {
return q.setFromMat(m.m00, m.m01, m.m02, m.m10, m.m11, m.m12, m.m20,
m.m21, m.m22);
}
/**
* Private method to perform the matrix-to-quaternion conversion
*/
private Quaternion setFromMat(float m00, float m01, float m02, float m10,
float m11, float m12, float m20, float m21, float m22) {
float s;
float tr = m00 + m11 + m22;
if (tr >= 0.0) {
s = (float) Math.sqrt(tr + 1.0);
w = s * 0.5f;
s = 0.5f / s;
x = (m21 - m12) * s;
y = (m02 - m20) * s;
z = (m10 - m01) * s;
} else {
float max = Math.max(Math.max(m00, m11), m22);
if (max == m00) {
s = (float) Math.sqrt(m00 - (m11 + m22) + 1.0);
x = s * 0.5f;
s = 0.5f / s;
y = (m01 + m10) * s;
z = (m20 + m02) * s;
w = (m21 - m12) * s;
} else if (max == m11) {
s = (float) Math.sqrt(m11 - (m22 + m00) + 1.0);
y = s * 0.5f;
s = 0.5f / s;
z = (m12 + m21) * s;
x = (m01 + m10) * s;
w = (m02 - m20) * s;
} else {
s = (float) Math.sqrt(m22 - (m00 + m11) + 1.0);
z = s * 0.5f;
s = 0.5f / s;
x = (m20 + m02) * s;
y = (m12 + m21) * s;
w = (m10 - m01) * s;
}
}
return this;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/WritableRectangle.java 0000644 0001750 0001750 00000004471 11543426510 022563 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util;
/**
* Write interface for Rectangles
* @author $Author: spasi $
* @version $Revision: 3418 $
* $Id: WritableRectangle.java 3418 2010-09-28 21:11:35Z spasi $
*/
public interface WritableRectangle extends WritablePoint, WritableDimension {
/**
* Sets the bounds of the rectangle
* @param x Position of rectangle on x axis
* @param y Position of rectangle on y axis
* @param width Width of rectangle
* @param height Height of rectangle
*/
void setBounds(int x, int y, int width, int height);
/**
* Sets the bounds of the rectangle
* @param location
* @param size
*/
void setBounds(ReadablePoint location, ReadableDimension size);
/**
* Sets the bounds of the rectangle
* @param src
*/
void setBounds(ReadableRectangle src);
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/ 0000755 0001750 0001750 00000000000 11543426510 020302 5 ustar zero79 zero79 lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Indirect.java 0000644 0001750 0001750 00000003742 11543426510 022714 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* Implies that a parameter is indirect, and forces the native
* stub to use the indirection operator '&' on it.
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: Indirect.java 2983 2008-04-07 18:36:09Z matzon $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target(ElementType.PARAMETER)
public @interface Indirect {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/ 0000755 0001750 0001750 00000000000 11543426510 021562 5 ustar zero79 zero79 lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/CLCapabilitiesGenerator.java 0000644 0001750 0001750 00000014146 11543426510 027112 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import org.lwjgl.util.generator.*;
import java.io.PrintWriter;
import java.util.Collection;
import java.util.Iterator;
import com.sun.mirror.declaration.InterfaceDeclaration;
import com.sun.mirror.declaration.MethodDeclaration;
import com.sun.mirror.declaration.TypeDeclaration;
/**
* CLCapabilities generator.
*
* @author Spasi
*/
public class CLCapabilitiesGenerator {
static void generateClassPrologue(final PrintWriter writer) {
writer.println("public final class " + CLGeneratorProcessorFactory.CLCAPS_CLASS_NAME + " {");
writer.println();
}
static void generateSymbolAddresses(final PrintWriter writer, final InterfaceDeclaration d) {
final Alias alias_annotation = d.getAnnotation(Alias.class);
final boolean aliased = alias_annotation != null && alias_annotation.postfix().length() > 0;
boolean foundNative = false;
for ( final MethodDeclaration method : d.getMethods() ) {
if ( method.getAnnotation(Alternate.class) != null || method.getAnnotation(Reuse.class) != null )
continue;
if ( !foundNative ) {
//writer.println("\t// " + d.getSimpleName());
writer.println("\tstatic final boolean " + CLGeneratorProcessorFactory.getExtensionName(d.getSimpleName()) + ";");
foundNative = true;
}
writer.print("\tstatic final long " + Utils.getFunctionAddressName(d, method) + " = CL.getFunctionAddress(");
if ( aliased )
writer.println("new String [] {\"" + Utils.getFunctionAddressName(d, method) + "\",\"" + method.getSimpleName() + alias_annotation.postfix() + "\"});");
else
writer.println("\"" + Utils.getFunctionAddressName(d, method) + "\");");
}
if ( foundNative )
writer.println();
}
static void generateConstructor(final PrintWriter writer, final Collection interface_decls) {
writer.println("\tprivate " + CLGeneratorProcessorFactory.CLCAPS_CLASS_NAME + "() {}");
writer.println();
writer.println("\tstatic {");
for ( final TypeDeclaration d : interface_decls ) {
if ( d.getMethods().isEmpty() )
continue;
//writer.println("\t\tif ( " + getExtensionSupportedName(d.getSimpleName()) + "() )");
//writer.println("\t\t\t" + SUPPORTED_EXTS + ".add(\"" + CLGeneratorProcessorFactory.getExtensionName(d.getSimpleName()) + "\");");
writer.println("\t\t" + CLGeneratorProcessorFactory.getExtensionName(d.getSimpleName()) + " = " + getExtensionSupportedName(d.getSimpleName()) + "();");
}
writer.println("\t}\n");
}
static void generateExtensionChecks(final PrintWriter writer, final InterfaceDeclaration d) {
Iterator methods = d.getMethods().iterator();
if ( !methods.hasNext() )
return;
writer.println("\tprivate static boolean " + getExtensionSupportedName(d.getSimpleName()) + "() {");
writer.println("\t\treturn ");
boolean first = true;
while ( methods.hasNext() ) {
MethodDeclaration method = methods.next();
if ( method.getAnnotation(Alternate.class) != null )
continue;
if ( !first )
writer.println(" &");
else
first = false;
final boolean optional = method.getAnnotation(Optional.class) != null;
writer.print("\t\t\t");
if ( optional )
writer.print('(');
writer.print(Utils.getFunctionAddressName(d, method) + " != 0");
if ( optional )
writer.print(" || true)");
}
writer.println(";");
writer.println("\t}");
writer.println();
}
private static String getExtensionSupportedName(final String class_name) {
return "is" + class_name + "Supported";
}
public static void generateCapabilitiesGetters(final PrintWriter writer) {
writer.println("\tpublic static CLPlatformCapabilities getPlatformCapabilities(final CLPlatform platform) {\n" +
"\t\tplatform.checkValid();\n" +
"\n" +
"\t\tCLPlatformCapabilities caps = (CLPlatformCapabilities)platform.getCapabilities();\n" +
"\t\tif ( caps == null )\n" +
"\t\t\tplatform.setCapabilities(caps = new CLPlatformCapabilities(platform));\n" +
"\n" +
"\t\treturn caps;\n" +
"\t}\n");
writer.println("\tpublic static CLDeviceCapabilities getDeviceCapabilities(final CLDevice device) {\n" +
"\t\tdevice.checkValid();\n" +
"\n" +
"\t\tCLDeviceCapabilities caps = (CLDeviceCapabilities)device.getCapabilities();\n" +
"\t\tif ( caps == null )\n" +
"\t\t\tdevice.setCapabilities(caps = new CLDeviceCapabilities(device));\n" +
"\n" +
"\t\treturn caps;\n" +
"\t}\n");
}
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/cl_double.java 0000644 0001750 0001750 00000003452 11543426510 024361 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@NativeType
@Target({ ElementType.PARAMETER, ElementType.METHOD })
public @interface cl_double {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/cl_void.java 0000644 0001750 0001750 00000003617 11543426510 024053 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
import com.sun.mirror.type.PrimitiveType;
@NativeType
@Target({ ElementType.PARAMETER, ElementType.METHOD })
public @interface cl_void {
PrimitiveType.Kind value() default PrimitiveType.Kind.BYTE;
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/cl_char.java 0000644 0001750 0001750 00000003424 11543426510 024023 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@NativeType
@Target({ ElementType.PARAMETER })
public @interface cl_char {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/cl_float.java 0000644 0001750 0001750 00000003451 11543426510 024213 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@NativeType
@Target({ ElementType.PARAMETER, ElementType.METHOD })
public @interface cl_float {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/cl_uint.java 0000644 0001750 0001750 00000003447 11543426510 024072 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@NativeType
@Target({ ElementType.PARAMETER, ElementType.METHOD })
public @interface cl_uint {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/cl_int.java 0000644 0001750 0001750 00000003446 11543426510 023704 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@NativeType
@Target({ ElementType.PARAMETER, ElementType.METHOD })
public @interface cl_int {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/cl_byte.java 0000644 0001750 0001750 00000003450 11543426510 024050 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@NativeType
@Target({ ElementType.PARAMETER, ElementType.METHOD })
public @interface cl_byte {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/CLGeneratorProcessorFactory.java 0000644 0001750 0001750 00000015375 11543426510 030035 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import org.lwjgl.PointerWrapper;
import org.lwjgl.opencl.CLDevice;
import org.lwjgl.opencl.CLPlatform;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.annotation.Annotation;
import java.util.Arrays;
import java.util.Collection;
import java.util.Set;
import com.sun.mirror.apt.*;
import com.sun.mirror.declaration.AnnotationTypeDeclaration;
import com.sun.mirror.declaration.InterfaceDeclaration;
import com.sun.mirror.declaration.TypeDeclaration;
import com.sun.mirror.util.DeclarationFilter;
import static java.util.Collections.*;
/**
* Generator tool for creating the OpenCL capabilities classes
*
* @author Spasi
*/
public class CLGeneratorProcessorFactory implements AnnotationProcessorFactory, RoundCompleteListener {
public static final String CLCAPS_CLASS_NAME = "CLCapabilities";
public static final String PLATFORM_CAPS_CLASS_NAME = "CLPlatformCapabilities";
public static final String DEVICE_CAPS_CLASS_NAME = "CLDeviceCapabilities";
private static final String EXTENSION_PREFIX = "CL_";
private static final String CORE_PREFIX = "Open";
private static boolean first_round = true;
// Process any set of annotations
private static final Collection supportedAnnotations = unmodifiableCollection(Arrays.asList("*"));
public Collection supportedAnnotationTypes() {
return supportedAnnotations;
}
public Collection supportedOptions() {
return unmodifiableCollection(Arrays.asList("-Acontextspecific"));
}
public void roundComplete(RoundCompleteEvent event) {
first_round = false;
}
public AnnotationProcessor getProcessorFor(Set atds, AnnotationProcessorEnvironment env) {
// Only process the initial types, not the generated ones
if ( first_round ) {
env.addListener(this);
return new GeneratorProcessor(env);
} else
return AnnotationProcessors.NO_OP;
}
static String getExtensionName(String interface_name) {
if ( interface_name.startsWith("CL") )
return CORE_PREFIX + interface_name;
else
return EXTENSION_PREFIX + interface_name;
}
private static class GeneratorProcessor implements AnnotationProcessor {
private final AnnotationProcessorEnvironment env;
GeneratorProcessor(AnnotationProcessorEnvironment env) {
this.env = env;
}
public void process() {
try {
generateCLCapabilitiesSource();
generateCLPDCapabilitiesSource(CLPlatformExtension.class, PLATFORM_CAPS_CLASS_NAME, CLPlatform.class, "platform");
generateCLPDCapabilitiesSource(CLDeviceExtension.class, DEVICE_CAPS_CLASS_NAME, CLDevice.class, "device");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private static void printHeader(final PrintWriter writer) {
writer.println("/* MACHINE GENERATED FILE, DO NOT EDIT */");
writer.println();
writer.println("package org.lwjgl.opencl;");
writer.println();
}
private void generateCLCapabilitiesSource() throws IOException {
final PrintWriter writer = env.getFiler().createTextFile(Filer.Location.SOURCE_TREE, "org.lwjgl.opencl", new File(CLCAPS_CLASS_NAME + ".java"), null);
printHeader(writer);
CLCapabilitiesGenerator.generateClassPrologue(writer);
final Collection templates = DeclarationFilter.getFilter(InterfaceDeclaration.class).filter(env.getSpecifiedTypeDeclarations());
for ( final TypeDeclaration t : templates ) {
if ( t.getAnnotation(CLPlatformExtension.class) == null && t.getAnnotation(CLDeviceExtension.class) == null && !t.getSimpleName().startsWith("CL") )
throw new RuntimeException("An OpenCL extension is missing an extension type annotation: " + t.getSimpleName());
CLCapabilitiesGenerator.generateSymbolAddresses(writer, (InterfaceDeclaration)t);
}
writer.println();
CLCapabilitiesGenerator.generateConstructor(writer, templates);
CLCapabilitiesGenerator.generateCapabilitiesGetters(writer);
for ( final TypeDeclaration template : templates )
CLCapabilitiesGenerator.generateExtensionChecks(writer, (InterfaceDeclaration)template);
writer.println("}");
writer.close();
}
private void generateCLPDCapabilitiesSource(final Class capsType, final String capsName, final Class objectType, final String objectName) throws IOException {
final PrintWriter writer = env.getFiler().createTextFile(Filer.Location.SOURCE_TREE, "org.lwjgl.opencl", new File(capsName + ".java"), null);
printHeader(writer);
writer.println("import java.util.*;");
writer.println();
CLPDCapabilitiesGenerator.generateClassPrologue(writer, capsName);
final Collection templates = DeclarationFilter.getFilter(InterfaceDeclaration.class).filter(env.getSpecifiedTypeDeclarations());
for ( final TypeDeclaration t : templates ) {
if ( t.getAnnotation(capsType) != null )
CLPDCapabilitiesGenerator.generateExtensions(writer, (InterfaceDeclaration)t);
}
writer.println();
CLPDCapabilitiesGenerator.generateConstructor(writer, templates, capsType, capsName, objectType, objectName);
CLPDCapabilitiesGenerator.generateGetters(writer);
CLPDCapabilitiesGenerator.generateToString(writer, templates, capsType);
writer.println("}");
writer.close();
}
}
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/cl_bool.java 0000644 0001750 0001750 00000003424 11543426510 024041 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@NativeType
@Target({ ElementType.PARAMETER })
public @interface cl_bool {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/size_t.java 0000644 0001750 0001750 00000003423 11543426510 023724 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@NativeType
@Target({ ElementType.PARAMETER })
public @interface size_t {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/cl_uchar.java 0000644 0001750 0001750 00000003425 11543426510 024211 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@NativeType
@Target({ ElementType.PARAMETER })
public @interface cl_uchar {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/cl_long.java 0000644 0001750 0001750 00000003424 11543426510 024045 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@NativeType
@Target({ ElementType.PARAMETER })
public @interface cl_long {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/CLDeviceExtension.java 0000644 0001750 0001750 00000003477 11543426510 025753 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
/** Extension templates marked with @CLDeviceExtension will be considered CL device extensions. */
@Target(ElementType.TYPE)
public @interface CLDeviceExtension {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/cl_bitfield.java 0000644 0001750 0001750 00000003463 11543426510 024673 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@NativeType
@Target({ ElementType.PARAMETER })
public @interface cl_bitfield {
String alias() default "";
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/CLTypeMap.java 0000644 0001750 0001750 00000021713 11543426510 024227 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
/**
*
* OpenCL specific generator behaviour
*
* @author Spasi
*/
import org.lwjgl.PointerBuffer;
import org.lwjgl.util.generator.*;
import org.lwjgl.util.generator.opengl.GLreturn;
import java.io.PrintWriter;
import java.lang.annotation.Annotation;
import java.nio.*;
import java.util.HashMap;
import java.util.Map;
import com.sun.mirror.declaration.AnnotationMirror;
import com.sun.mirror.declaration.MethodDeclaration;
import com.sun.mirror.declaration.ParameterDeclaration;
import com.sun.mirror.type.PrimitiveType;
public class CLTypeMap implements TypeMap {
private static final Map native_types_to_primitive;
static {
native_types_to_primitive = new HashMap();
native_types_to_primitive.put(cl_void.class, PrimitiveType.Kind.BYTE);
native_types_to_primitive.put(cl_byte.class, PrimitiveType.Kind.BYTE);
native_types_to_primitive.put(cl_char.class, PrimitiveType.Kind.BYTE);
native_types_to_primitive.put(cl_uchar.class, PrimitiveType.Kind.BYTE);
native_types_to_primitive.put(cl_short.class, PrimitiveType.Kind.SHORT);
native_types_to_primitive.put(cl_bool.class, PrimitiveType.Kind.INT);
native_types_to_primitive.put(cl_int.class, PrimitiveType.Kind.INT);
native_types_to_primitive.put(cl_uint.class, PrimitiveType.Kind.INT);
native_types_to_primitive.put(cl_long.class, PrimitiveType.Kind.LONG);
native_types_to_primitive.put(size_t.class, PrimitiveType.Kind.LONG);
native_types_to_primitive.put(cl_bitfield.class, PrimitiveType.Kind.LONG);
native_types_to_primitive.put(cl_float.class, PrimitiveType.Kind.FLOAT);
native_types_to_primitive.put(cl_double.class, PrimitiveType.Kind.DOUBLE);
}
public PrimitiveType.Kind getPrimitiveTypeFromNativeType(Class native_type) {
PrimitiveType.Kind kind = native_types_to_primitive.get(native_type);
if ( kind == null )
throw new RuntimeException("Unsupported type " + native_type);
return kind;
}
public void printCapabilitiesInit(final PrintWriter writer) {
}
public String getCapabilities() {
return "CLCapabilities";
}
public void printErrorCheckMethod(final PrintWriter writer, final MethodDeclaration method, final String tabs) {
final Check check = method.getAnnotation(Check.class);
if ( check != null ) // Get the error code from an IntBuffer output parameter
writer.println(tabs + "Util.checkCLError(" + check.value() + ".get(" + check.value() + ".position()));");
else {
final Class return_type = Utils.getJavaType(method.getReturnType());
if ( return_type == int.class )
writer.println(tabs + "Util.checkCLError(__result);");
else {
boolean hasErrCodeParam = false;
for ( final ParameterDeclaration param : method.getParameters() ) {
if ( "errcode_ret".equals(param.getSimpleName()) && Utils.getJavaType(param.getType()) == IntBuffer.class ) {
hasErrCodeParam = true;
break;
}
}
if ( hasErrCodeParam )
throw new RuntimeException("A method is missing the @Check annotation: " + method.toString());
}
}
}
public String getRegisterNativesFunctionName() {
return "extcl_InitializeClass";
}
public Signedness getSignednessFromType(Class type) {
if ( cl_uint.class.equals(type) )
return Signedness.UNSIGNED;
else if ( cl_int.class.equals(type) )
return Signedness.SIGNED;
else
return Signedness.NONE;
}
public String translateAnnotation(Class annotation_type) {
if ( annotation_type.equals(cl_uint.class) || annotation_type.equals(cl_int.class) )
return "i";
else if ( annotation_type.equals(cl_short.class) )
return "s";
else if ( annotation_type.equals(cl_byte.class) )
return "b";
else if ( annotation_type.equals(cl_float.class) )
return "f";
else if ( annotation_type.equals(cl_double.class) )
return "d";
else
throw new RuntimeException(annotation_type + " is not allowed");
}
public Class getNativeTypeFromPrimitiveType(PrimitiveType.Kind kind) {
Class type;
switch ( kind ) {
case INT:
type = cl_int.class;
break;
case DOUBLE:
type = cl_double.class;
break;
case FLOAT:
type = cl_float.class;
break;
case SHORT:
type = cl_short.class;
break;
case BYTE:
type = cl_byte.class;
break;
case LONG:
type = cl_long.class;
break;
case BOOLEAN:
type = cl_bool.class;
break;
default:
throw new RuntimeException(kind + " is not allowed");
}
return type;
}
public Class getVoidType() {
return cl_void.class;
}
public Class getStringElementType() {
return cl_char.class;
}
public Class getStringArrayType() {
return cl_char.class;
}
public Class getByteBufferArrayType() {
return cl_uchar.class;
}
private static Class[] getValidBufferTypes(Class type) {
if ( type.equals(IntBuffer.class) )
return new Class[] { cl_int.class, cl_uint.class };
else if ( type.equals(FloatBuffer.class) )
return new Class[] { cl_float.class };
else if ( type.equals(ByteBuffer.class) )
return new Class[] { cl_byte.class, cl_char.class, cl_uchar.class, cl_void.class };
else if ( type.equals(ShortBuffer.class) )
return new Class[] { cl_short.class };
else if ( type.equals(DoubleBuffer.class) )
return new Class[] { cl_double.class };
else if ( type.equals(LongBuffer.class) )
return new Class[] { cl_long.class };
else if ( type.equals(PointerBuffer.class) )
return new Class[] { size_t.class };
else
return new Class[] { };
}
private static Class[] getValidPrimitiveTypes(Class type) {
if ( type.equals(long.class) )
return new Class[] { cl_long.class, size_t.class, cl_bitfield.class };
else if ( type.equals(int.class) )
return new Class[] { cl_int.class, cl_uint.class, cl_bool.class };
else if ( type.equals(double.class) )
return new Class[] { cl_double.class };
else if ( type.equals(float.class) )
return new Class[] { cl_float.class };
else if ( type.equals(short.class) )
return new Class[] { cl_short.class };
else if ( type.equals(byte.class) )
return new Class[] { cl_byte.class, cl_char.class, cl_uchar.class };
else if ( type.equals(boolean.class) )
return new Class[] { cl_bool.class };
else if ( type.equals(void.class) )
return new Class[] { cl_void.class };
else
return new Class[] { };
}
public String getTypedefPostfix() {
return "CL_API_ENTRY ";
}
public String getFunctionPrefix() {
return "CL_API_CALL";
}
public void printNativeIncludes(PrintWriter writer) {
writer.println("#include \"extcl.h\"");
}
public Class[] getValidAnnotationTypes(Class type) {
Class[] valid_types;
if ( Buffer.class.isAssignableFrom(type) || PointerBuffer.class.isAssignableFrom(type) )
valid_types = getValidBufferTypes(type);
else if ( type.isPrimitive() )
valid_types = getValidPrimitiveTypes(type);
else if ( String.class.equals(type) )
valid_types = new Class[] { cl_byte.class };
else if ( org.lwjgl.PointerWrapper.class.isAssignableFrom(type) )
valid_types = new Class[] { PointerWrapper.class };
else if ( ByteBuffer[].class == type )
valid_types = new Class[] { cl_char.class, cl_uchar.class };
else if ( void.class.equals(type) )
valid_types = new Class[] { GLreturn.class };
else
valid_types = new Class[] { };
return valid_types;
}
public Class getInverseType(Class type) {
return null;
}
public String getAutoTypeFromAnnotation(AnnotationMirror annotation) {
return null;
}
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/CLPDCapabilitiesGenerator.java 0000644 0001750 0001750 00000014471 11543426510 027337 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import org.lwjgl.PointerWrapper;
import org.lwjgl.util.generator.Private;
import java.io.PrintWriter;
import java.lang.annotation.Annotation;
import java.util.Collection;
import com.sun.mirror.declaration.InterfaceDeclaration;
import com.sun.mirror.declaration.TypeDeclaration;
/**
* CL platform/device capabilities generator.
*
* @author Spasi
*/
public class CLPDCapabilitiesGenerator {
// TODO: Add future versions here
private static final int[][] CL_VERSIONS = {
{ 1 }, // OpenCL 1
};
static void generateClassPrologue(final PrintWriter writer, final String name) {
writer.println("public class " + name + " {");
writer.println();
writer.println("\tpublic final int majorVersion;");
writer.println("\tpublic final int minorVersion;");
writer.println();
for ( int major = 1; major <= CL_VERSIONS.length; major++ ) {
for ( final int minor : CL_VERSIONS[major - 1] )
writer.println("\tpublic final boolean OpenCL" + Integer.toString(major) + Integer.toString(minor) + ";");
}
writer.println();
}
static void generateExtensions(final PrintWriter writer, final InterfaceDeclaration d) {
writer.print("\t");
if ( d.getAnnotation(Private.class) == null )
writer.print("public ");
writer.println("final boolean " + CLGeneratorProcessorFactory.getExtensionName(d.getSimpleName()) + ";");
}
static void generateConstructor(final PrintWriter writer, final Collection templates,
final Class capsType, final String capsName,
final Class objectType, final String objectName) {
writer.println("\tpublic " + capsName + "(final " + objectType.getSimpleName() + ' ' + objectName + ") {");
writer.println("\t\tfinal String extensionList = " + objectName + ".getInfoString(CL10.CL_" + objectName.toUpperCase() + "_EXTENSIONS);\n" +
"\t\tfinal String version = " + objectName + ".getInfoString(CL10.CL_" + objectName.toUpperCase() + "_VERSION);\n" +
"\t\tif ( !version.startsWith(\"OpenCL \") )\n" +
"\t\t\tthrow new RuntimeException(\"Invalid OpenCL version string: \" + version);\n\n" +
"\t\ttry {\n" +
"\t\t\tfinal StringTokenizer tokenizer = new StringTokenizer(version.substring(7), \". \");\n" +
"\n" +
"\t\t\tmajorVersion = Integer.parseInt(tokenizer.nextToken());\n" +
"\t\t\tminorVersion = Integer.parseInt(tokenizer.nextToken());\n");
for ( int major = 1; major <= CL_VERSIONS.length; major++ ) {
for ( final int minor : CL_VERSIONS[major - 1] )
writer.println("\t\t\tOpenCL" + Integer.toString(major) + Integer.toString(minor) + " = " + major + " < majorVersion || (" + major + " == majorVersion && " + minor + " <= minorVersion);");
}
writer.println("\t\t} catch (RuntimeException e) {\n" +
"\t\t\tthrow new RuntimeException(\"The major and/or minor OpenCL version \\\"\" + version + \"\\\" is malformed: \" + e.getMessage());\n" +
"\t\t}\n");
writer.println("\t\tfinal Set extensions = APIUtil.getExtensions(extensionList);");
for ( final TypeDeclaration t : templates ) {
if ( t.getAnnotation(capsType) == null )
continue;
final String extName = CLGeneratorProcessorFactory.getExtensionName(t.getSimpleName());
writer.print("\t\t" + extName + " = extensions.contains(\"" + extName.toLowerCase() + "\")");
if ( !t.getMethods().isEmpty() )
writer.print(" && CLCapabilities." + extName);
writer.println(";");
}
writer.println("\t}\n");
}
public static void generateGetters(final PrintWriter writer) {
writer.println("\tpublic int getMajorVersion() {");
writer.println("\t\treturn majorVersion;");
writer.println("\t}\n");
writer.println("\tpublic int getMinorVersion() {");
writer.println("\t\treturn minorVersion;");
writer.println("\t}\n");
}
public static void generateToString(final PrintWriter writer, final Collection templates, final Class capsType) {
writer.println("\tpublic String toString() {");
writer.println("\t\tfinal StringBuilder buf = new StringBuilder();\n");
writer.println("\t\tbuf.append(\"OpenCL \").append(majorVersion).append('.').append(minorVersion);");
writer.println();
writer.println("\t\tbuf.append(\" - Extensions: \");");
for ( final TypeDeclaration t : templates ) {
if ( t.getAnnotation(capsType) == null )
continue;
writer.println("\t\tif ( " + CLGeneratorProcessorFactory.getExtensionName(t.getSimpleName()) + " ) buf.append(\"" + CLGeneratorProcessorFactory.getExtensionName(t.getSimpleName()).toLowerCase() + " \");");
}
writer.println("\n\t\treturn buf.toString();");
writer.println("\t}\n");
}
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/cl_short.java 0000644 0001750 0001750 00000003451 11543426510 024245 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@NativeType
@Target({ ElementType.PARAMETER, ElementType.METHOD })
public @interface cl_short {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opencl/CLPlatformExtension.java 0000644 0001750 0001750 00000003505 11543426510 026330 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opencl;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
/** Extension templates marked with @CLPlatformExtension will be considered CL platform extensions. */
@Target(ElementType.TYPE)
public @interface CLPlatformExtension {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/PointerWrapper.java 0000644 0001750 0001750 00000004143 11543426510 024130 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
* @author spasi
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface PointerWrapper {
String value(); // The native pointer type.
boolean canBeNull() default false; // Whether the pointer may be null.
String params() default ""; // Pass these extra parameters when constructing PointerWrapper objects.
String factory() default ""; // Use this factory method call instead of normal object construction.
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/BufferObject.java 0000644 0001750 0001750 00000003745 11543426510 023516 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* This annotation implies that a Buffer parameter can be an
* integer VBO/PBO offset.
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: BufferObject.java 2983 2008-04-07 18:36:09Z matzon $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target(ElementType.PARAMETER)
public @interface BufferObject {
BufferKind value();
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/TypedefsGenerator.java 0000644 0001750 0001750 00000007456 11543426510 024613 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* A TypeVisitor that generates the native typedefs.
*
* @author elias_naur
* @version $Revision: 3412 $
* $Id: TypedefsGenerator.java 3412 2010-09-26 23:43:24Z spasi $
*/
import com.sun.mirror.declaration.*;
import com.sun.mirror.type.*;
import java.io.*;
import java.util.*;
public class TypedefsGenerator {
private static void generateNativeTypedefs(TypeMap type_map, PrintWriter writer, MethodDeclaration method) {
TypeMirror return_type = method.getReturnType();
writer.print("typedef ");
writer.print(type_map.getTypedefPostfix());
NativeTypeTranslator translator = new NativeTypeTranslator(type_map, method);
return_type.accept(translator);
writer.print(translator.getSignature());
writer.print(" (");
writer.print(type_map.getFunctionPrefix());
writer.print(" *" + Utils.getTypedefName(method) + ") (");
generateNativeTypedefsParameters(type_map, writer, method.getParameters());
writer.println(");");
}
private static void generateNativeTypedefsParameters(TypeMap type_map, PrintWriter writer, Collection params) {
if (params.size() > 0) {
boolean first = true;
for ( ParameterDeclaration param : params ) {
if ( param.getAnnotation(Helper.class) != null )
continue;
if ( first )
first = false;
else
writer.print(", ");
generateNativeTypedefsParameter(type_map, writer, param);
}
}
}
private static void generateNativeTypedefsParameter(TypeMap type_map, PrintWriter writer, ParameterDeclaration param) {
NativeTypeTranslator translator = new NativeTypeTranslator(type_map, param);
param.getType().accept(translator);
writer.print(translator.getSignature());
if (param.getAnnotation(Result.class) != null || param.getAnnotation(Indirect.class) != null || param.getAnnotation(PointerArray.class) != null)
writer.print("*");
writer.print(" " + param.getSimpleName());
}
public static void generateNativeTypedefs(TypeMap type_map, PrintWriter writer, Collection methods) {
for (MethodDeclaration method : methods) {
if ( method.getAnnotation(Alternate.class) == null && method.getAnnotation(Reuse.class) == null )
generateNativeTypedefs(type_map, writer, method);
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/StripPostfix.java 0000644 0001750 0001750 00000004214 11543426510 023624 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* This annotation implies that a method have its postfix stripped
* according to a specified Buffer parameter.
*
* @author elias_naur
* @version $Revision: 3256 $
* $Id: StripPostfix.java 3256 2009-12-01 03:37:27Z spasi $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target(ElementType.METHOD)
public @interface StripPostfix {
String value(); // The parameter to deduce the postfix from
String extension() default "NULL";
boolean hasPostfix() default true;
String postfix() default "NULL";
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/JavaTypeTranslator.java 0000644 0001750 0001750 00000011325 11543426510 024744 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
import org.lwjgl.opencl.CLMem;
import java.nio.ByteBuffer;
import com.sun.mirror.type.*;
import com.sun.mirror.util.*;
/**
* A TypeVisitor that translates (annotated) TypeMirrors to
* java types (represented by a Class)
*
* @author elias_naur
* @version $Revision: 3430 $
* $Id: JavaTypeTranslator.java 3430 2010-10-04 17:04:46Z spasi $
*/
public class JavaTypeTranslator implements TypeVisitor {
private Class type;
public Class getType() {
return type;
}
public void visitAnnotationType(AnnotationType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitArrayType(ArrayType t) {
final TypeMirror componentType = t.getComponentType();
if ( componentType instanceof PrimitiveType ) {
type = getPrimitiveArrayClassFromKind(((PrimitiveType)componentType).getKind());
} else {
try {
final Class c = Class.forName(t.getComponentType().toString());
if ( CharSequence.class.isAssignableFrom(c) || ByteBuffer.class.isAssignableFrom(c) || org.lwjgl.PointerWrapper.class.isAssignableFrom(c) )
type = Class.forName("[L" + t.getComponentType() + ";");
else {
throw new RuntimeException(t + " is not allowed");
}
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
}
public static Class getPrimitiveClassFromKind(PrimitiveType.Kind kind) {
switch ( kind ) {
case LONG:
return long.class;
case INT:
return int.class;
case DOUBLE:
return double.class;
case FLOAT:
return float.class;
case SHORT:
return short.class;
case BYTE:
return byte.class;
case BOOLEAN:
return boolean.class;
default:
throw new RuntimeException(kind + " is not allowed");
}
}
private static Class getPrimitiveArrayClassFromKind(PrimitiveType.Kind kind) {
switch ( kind ) {
case LONG:
return long[].class;
case INT:
return int[].class;
case DOUBLE:
return double[].class;
case FLOAT:
return float[].class;
case SHORT:
return short[].class;
case BYTE:
return byte[].class;
case BOOLEAN:
return boolean[].class;
default:
throw new RuntimeException(kind + " is not allowed");
}
}
public void visitPrimitiveType(PrimitiveType t) {
type = getPrimitiveClassFromKind(t.getKind());
}
public void visitDeclaredType(DeclaredType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitEnumType(EnumType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitClassType(ClassType t) {
type = NativeTypeTranslator.getClassFromType(t);
}
public void visitInterfaceType(InterfaceType t) {
type = NativeTypeTranslator.getClassFromType(t);
}
public void visitReferenceType(ReferenceType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitTypeMirror(TypeMirror t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitTypeVariable(TypeVariable t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitVoidType(VoidType t) {
type = void.class;
}
public void visitWildcardType(WildcardType t) {
throw new RuntimeException(t + " is not allowed");
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Optional.java 0000644 0001750 0001750 00000004015 11543426510 022732 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
* A function annotated with @Optional will allow the extension to be available even if the driver does not expose that function.
* This is useful when certain buggy drivers miss some functionality.
*
* @author spasi
*/
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)
public @interface Optional {
String reason(); // No default value to force documentation
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Constant.java 0000644 0001750 0001750 00000004102 11543426510 022733 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* @author elias_naur
* @version $Revision: 3412 $
* $Id: Constant.java 3412 2010-09-26 23:43:24Z spasi $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target(ElementType.PARAMETER)
public @interface Constant {
String value();
/** If true, the original parameter will not be removed from the method. */
boolean keepParam() default false;
/** If true, this is a native code constant. */
boolean isNative() default false;
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/openal/ 0000755 0001750 0001750 00000000000 11543426510 021560 5 ustar zero79 zero79 lwjgl-2.7.1/src/java/org/lwjgl/util/generator/openal/ALuint.java 0000644 0001750 0001750 00000003677 11543426510 023634 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.openal;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: ALuint.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface ALuint {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/openal/ALenum.java 0000644 0001750 0001750 00000003677 11543426510 023621 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.openal;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: ALenum.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface ALenum {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/openal/ALboolean.java 0000644 0001750 0001750 00000003705 11543426510 024264 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.openal;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: ALboolean.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface ALboolean {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/openal/ALdouble.java 0000644 0001750 0001750 00000003703 11543426510 024115 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.openal;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: ALdouble.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface ALdouble {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/openal/ALTypeMap.java 0000644 0001750 0001750 00000017121 11543426510 024221 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.openal;
/**
*
* The OpenAL specific generator behaviour
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: ALTypeMap.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.Signedness;
import org.lwjgl.util.generator.TypeMap;
import com.sun.mirror.declaration.*;
import com.sun.mirror.type.*;
import java.io.*;
import java.lang.annotation.Annotation;
import java.util.*;
import java.nio.*;
public class ALTypeMap implements TypeMap {
private static final Map native_types_to_primitive;
static {
native_types_to_primitive = new HashMap();
native_types_to_primitive.put(ALboolean.class, PrimitiveType.Kind.BOOLEAN);
native_types_to_primitive.put(ALbyte.class, PrimitiveType.Kind.BYTE);
native_types_to_primitive.put(ALenum.class, PrimitiveType.Kind.INT);
native_types_to_primitive.put(ALfloat.class, PrimitiveType.Kind.FLOAT);
native_types_to_primitive.put(ALdouble.class, PrimitiveType.Kind.DOUBLE);
native_types_to_primitive.put(ALint.class, PrimitiveType.Kind.INT);
native_types_to_primitive.put(ALshort.class, PrimitiveType.Kind.SHORT);
native_types_to_primitive.put(ALsizei.class, PrimitiveType.Kind.INT);
native_types_to_primitive.put(ALubyte.class, PrimitiveType.Kind.BYTE);
native_types_to_primitive.put(ALuint.class, PrimitiveType.Kind.INT);
native_types_to_primitive.put(ALvoid.class, PrimitiveType.Kind.BYTE);
}
public PrimitiveType.Kind getPrimitiveTypeFromNativeType(Class native_type) {
PrimitiveType.Kind kind = native_types_to_primitive.get(native_type);
if (kind == null)
throw new RuntimeException("Unsupported type " + native_type);
return kind;
}
public Signedness getSignednessFromType(Class type) {
if (ALuint.class.equals(type))
return Signedness.UNSIGNED;
else if (ALint.class.equals(type))
return Signedness.SIGNED;
else if (ALshort.class.equals(type))
return Signedness.SIGNED;
else if (ALbyte.class.equals(type))
return Signedness.SIGNED;
else
return Signedness.NONE;
}
public String translateAnnotation(Class annotation_type) {
if (annotation_type.equals(ALuint.class))
return "i";
else if (annotation_type.equals(ALint.class))
return "i";
else if (annotation_type.equals(ALshort.class))
return "s";
else if (annotation_type.equals(ALbyte.class))
return "b";
else if (annotation_type.equals(ALfloat.class))
return "f";
else if (annotation_type.equals(ALdouble.class))
return "d";
else if (annotation_type.equals(ALboolean.class) || annotation_type.equals(ALvoid.class))
return "";
else
throw new RuntimeException(annotation_type + " is not allowed");
}
public Class getNativeTypeFromPrimitiveType(PrimitiveType.Kind kind) {
Class type;
switch (kind) {
case INT:
type = ALint.class;
break;
case FLOAT:
type = ALfloat.class;
break;
case DOUBLE:
type = ALdouble.class;
break;
case SHORT:
type = ALshort.class;
break;
case BYTE:
type = ALbyte.class;
break;
case BOOLEAN:
type = ALboolean.class;
break;
default:
throw new RuntimeException(kind + " is not allowed");
}
return type;
}
private static Class[] getValidBufferTypes(Class type) {
if (type.equals(IntBuffer.class))
return new Class[]{ALenum.class, ALint.class, ALsizei.class, ALuint.class};
else if (type.equals(FloatBuffer.class))
return new Class[]{ALfloat.class};
else if (type.equals(ByteBuffer.class))
return new Class[]{ALboolean.class, ALbyte.class, ALvoid.class};
else if (type.equals(ShortBuffer.class))
return new Class[]{ALshort.class};
else if (type.equals(DoubleBuffer.class))
return new Class[]{ALdouble.class};
else
return new Class[]{};
}
private static Class[] getValidPrimitiveTypes(Class type) {
if (type.equals(int.class))
return new Class[]{ALenum.class, ALint.class, ALsizei.class, ALuint.class};
else if (type.equals(double.class))
return new Class[]{ALdouble.class};
else if (type.equals(float.class))
return new Class[]{ALfloat.class};
else if (type.equals(short.class))
return new Class[]{ALshort.class};
else if (type.equals(byte.class))
return new Class[]{ALbyte.class};
else if (type.equals(boolean.class))
return new Class[]{ALboolean.class};
else if (type.equals(void.class))
return new Class[]{ALvoid.class};
else
return new Class[]{};
}
public void printCapabilitiesInit(final PrintWriter writer) {
throw new UnsupportedOperationException();
}
public String getCapabilities() {
throw new UnsupportedOperationException();
}
public void printErrorCheckMethod(final PrintWriter writer, final MethodDeclaration method, final String tabs) {
writer.println(tabs + "Util.checkALError();");
}
public String getRegisterNativesFunctionName() {
return "extal_InitializeClass";
}
public String getTypedefPostfix() {
return "";
}
public String getFunctionPrefix() {
return "ALAPIENTRY";
}
public void printNativeIncludes(PrintWriter writer) {
writer.println("#include \"extal.h\"");
}
public Class getStringElementType() {
return ALubyte.class;
}
public Class getStringArrayType() {
return ALubyte.class;
}
public Class getByteBufferArrayType() {
return ALubyte.class;
}
public Class[] getValidAnnotationTypes(Class type) {
Class[] valid_types;
if (Buffer.class.isAssignableFrom(type))
valid_types = getValidBufferTypes(type);
else if (type.isPrimitive())
valid_types = getValidPrimitiveTypes(type);
else if (type.equals(String.class))
valid_types = new Class[]{ALubyte.class};
else
valid_types = new Class[]{};
return valid_types;
}
public Class getVoidType() {
return ALvoid.class;
}
public Class getInverseType(Class type) {
if (ALuint.class.equals(type))
return ALint.class;
else if (ALint.class.equals(type))
return ALuint.class;
else
return null;
}
public String getAutoTypeFromAnnotation(AnnotationMirror annotation) {
return null;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/openal/ALbyte.java 0000644 0001750 0001750 00000003677 11543426510 023620 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.openal;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: ALbyte.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface ALbyte {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/openal/ALfloat.java 0000644 0001750 0001750 00000003701 11543426510 023746 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.openal;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: ALfloat.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface ALfloat {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/openal/ALubyte.java 0000644 0001750 0001750 00000003701 11543426510 023771 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.openal;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: ALubyte.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface ALubyte {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/openal/ALshort.java 0000644 0001750 0001750 00000003701 11543426510 024000 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.openal;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: ALshort.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface ALshort {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/openal/ALint.java 0000644 0001750 0001750 00000003675 11543426510 023445 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.openal;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: ALint.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface ALint {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/openal/ALsizei.java 0000644 0001750 0001750 00000003701 11543426510 023764 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.openal;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: ALsizei.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface ALsizei {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/openal/ALvoid.java 0000644 0001750 0001750 00000003677 11543426510 023616 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.openal;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: ALvoid.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface ALvoid {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/PlatformDependent.java 0000644 0001750 0001750 00000004047 11543426510 024565 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* This annotation implies that the corresponding native
* function symbol is named after the platform specific
* window system (glX, wgl, ...)
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: PlatformDependent.java 2983 2008-04-07 18:36:09Z matzon $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target(ElementType.METHOD)
public @interface PlatformDependent {
Platform[] value();
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/AutoSize.java 0000644 0001750 0001750 00000004521 11543426510 022712 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* AutoSize specifies that a parameter should be pre-computed
* according to the remaining() of a Buffer parameter.
*
* @author elias_naur
* @version $Revision: 3412 $
* $Id: AutoSize.java 3412 2010-09-26 23:43:24Z spasi $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Auto
@Target({ElementType.METHOD,ElementType.PARAMETER})
public @interface AutoSize {
String value(); // The name of the Buffer parameter
String expression() default ""; // This value is added after the argument
boolean canBeNull() default false; // When this is true and the Buffer parameter is null, 0 will be used.
boolean isNative() default false; // When this is true, auto-sizing will be performed in native code.
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/NativeTypeTranslator.java 0000644 0001750 0001750 00000020554 11543426510 025315 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* A TypeVisitor that translates types (and optional native type
* annotations) to the native type string.
*
* @author elias_naur
* @version $Revision: 3412 $
* $Id: NativeTypeTranslator.java 3412 2010-09-26 23:43:24Z spasi $
*/
import org.lwjgl.PointerBuffer;
import java.lang.annotation.Annotation;
import java.nio.*;
import java.util.ArrayList;
import java.util.Collection;
import com.sun.mirror.declaration.AnnotationMirror;
import com.sun.mirror.declaration.Declaration;
import com.sun.mirror.type.*;
import com.sun.mirror.util.TypeVisitor;
/**
* $Id: NativeTypeTranslator.java 3412 2010-09-26 23:43:24Z spasi $
*
* A TypeVisitor that translates (annotated) TypeMirrors to
* native types
*
* @author elias_naur
* @version $Revision: 3412 $
*/
public class NativeTypeTranslator implements TypeVisitor {
private Collection native_types;
private boolean is_indirect;
private final Declaration declaration;
private final TypeMap type_map;
public NativeTypeTranslator(TypeMap type_map, Declaration declaration) {
this.declaration = declaration;
this.type_map = type_map;
}
public String getSignature() {
return getSignature(false);
}
public String getSignature(final boolean skipConst) {
StringBuilder signature = new StringBuilder();
if ( !skipConst && declaration.getAnnotation(Const.class) != null )
signature.append("const ");
if ( declaration.getAnnotation(PointerWrapper.class) != null ) {
signature.append(declaration.getAnnotation(PointerWrapper.class).value());
} else if ( declaration.getAnnotation(NativeType.class) != null ) {
signature.append(declaration.getAnnotation(NativeType.class).value());
} else {
// Use the name of the native type annotation as the C type name
signature.append(getAnnotationType().getSimpleName());
}
if ( is_indirect )
signature.append(" *");
return signature.toString();
}
public Class getAnnotationType() {
if ( native_types.size() != 1 )
throw new RuntimeException("Expected only one native type for declaration " + declaration +
", but got " + native_types.size());
return native_types.iterator().next();
}
public void visitAnnotationType(AnnotationType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitArrayType(ArrayType t) {
final Class type = Utils.getJavaType(t).getComponentType();
if ( CharSequence.class.isAssignableFrom(type) ) {
is_indirect = true;
native_types = new ArrayList();
native_types.add(type_map.getStringArrayType());
} else if ( Buffer.class.isAssignableFrom(type) ) {
is_indirect = true;
native_types = new ArrayList();
native_types.add(type_map.getByteBufferArrayType());
} else if ( org.lwjgl.PointerWrapper.class.isAssignableFrom(type) ) {
is_indirect = false;
} else
throw new RuntimeException(t + " is not allowed");
}
public static PrimitiveType.Kind getPrimitiveKindFromBufferClass(Class c) {
if ( IntBuffer.class.equals(c) )
return PrimitiveType.Kind.INT;
else if ( DoubleBuffer.class.equals(c) )
return PrimitiveType.Kind.DOUBLE;
else if ( ShortBuffer.class.equals(c) )
return PrimitiveType.Kind.SHORT;
else if ( ByteBuffer.class.equals(c) || PointerBuffer.class.equals(c) )
return PrimitiveType.Kind.BYTE;
else if ( FloatBuffer.class.equals(c) )
return PrimitiveType.Kind.FLOAT;
else if ( LongBuffer.class.equals(c) )
return PrimitiveType.Kind.LONG;
else
throw new RuntimeException(c + " is not allowed");
}
@SuppressWarnings("unchecked")
public static Class getClassFromType(DeclaredType t) {
try {
return (Class)Class.forName(t.getDeclaration().getQualifiedName());
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
private void getNativeTypeFromAnnotatedPrimitiveType(PrimitiveType.Kind kind) {
native_types = translateAnnotations();
if ( native_types.size() == 0 )
native_types.add(type_map.getNativeTypeFromPrimitiveType(kind));
}
public void visitClassType(ClassType t) {
is_indirect = true;
Class c = getClassFromType(t);
if ( String.class.equals(c) ) {
native_types = new ArrayList();
native_types.add(type_map.getStringElementType());
} else if ( Buffer.class.equals(c) ) {
native_types = new ArrayList();
native_types.add(type_map.getVoidType());
} else if ( Buffer.class.isAssignableFrom(c) ) {
PrimitiveType.Kind kind = getPrimitiveKindFromBufferClass(c);
getNativeTypeFromAnnotatedPrimitiveType(kind);
} else if ( PointerBuffer.class.isAssignableFrom(c) ) {
native_types = new ArrayList();
native_types.add(PointerBuffer.class);
} else if ( org.lwjgl.PointerWrapper.class.isAssignableFrom(c) ) {
native_types = new ArrayList();
native_types.add(PointerWrapper.class);
is_indirect = false;
} else
throw new RuntimeException(t + " is not allowed");
}
public void visitPrimitiveType(PrimitiveType t) {
getNativeTypeFromAnnotatedPrimitiveType(t.getKind());
}
public void visitDeclaredType(DeclaredType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitEnumType(EnumType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitInterfaceType(InterfaceType t) {
throw new RuntimeException(t + " is not allowed");
}
// Check if the annotation is itself annotated with a certain annotation type
public static T getAnnotation(AnnotationMirror annotation, Class type) {
return annotation.getAnnotationType().getDeclaration().getAnnotation(type);
}
private static Class translateAnnotation(AnnotationMirror annotation) {
NativeType native_type = getAnnotation(annotation, NativeType.class);
if ( native_type != null ) {
return getClassFromType(annotation.getAnnotationType());
} else
return null;
}
private Collection translateAnnotations() {
Collection result = new ArrayList();
for ( AnnotationMirror annotation : Utils.getSortedAnnotations(declaration.getAnnotationMirrors()) ) {
Class translated_result = translateAnnotation(annotation);
if ( translated_result != null ) {
result.add(translated_result);
}
}
return result;
}
public void visitReferenceType(ReferenceType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitTypeMirror(TypeMirror t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitTypeVariable(TypeVariable t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitVoidType(VoidType t) {
native_types = translateAnnotations();
if ( native_types.size() == 0 )
native_types.add(void.class);
}
public void visitWildcardType(WildcardType t) {
throw new RuntimeException(t + " is not allowed");
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/ 0000755 0001750 0001750 00000000000 11543426510 021566 5 ustar zero79 zero79 lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLushort.java 0000644 0001750 0001750 00000003703 11543426510 024203 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLushort.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLushort {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLsizei.java 0000644 0001750 0001750 00000003701 11543426510 024000 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLsizei.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLsizei {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLint64EXT.java 0000644 0001750 0001750 00000003450 11543426510 024203 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLint64EXT {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLTypeMap.java 0000644 0001750 0001750 00000030206 11543426510 024234 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* OpenGL sepcific generator behaviour
*
* @author elias_naur
* @version $Revision: 3392 $
* $Id: GLTypeMap.java 3392 2010-07-27 15:33:22Z spasi $
*/
import org.lwjgl.util.generator.NativeTypeTranslator;
import org.lwjgl.util.generator.PointerWrapper;
import org.lwjgl.util.generator.Signedness;
import org.lwjgl.util.generator.TypeMap;
import java.io.PrintWriter;
import java.lang.annotation.Annotation;
import java.nio.*;
import java.util.HashMap;
import java.util.Map;
import com.sun.mirror.declaration.AnnotationMirror;
import com.sun.mirror.declaration.MethodDeclaration;
import com.sun.mirror.type.PrimitiveType;
public class GLTypeMap implements TypeMap {
private static final Map native_types_to_primitive;
static {
native_types_to_primitive = new HashMap();
native_types_to_primitive.put(GLbitfield.class, PrimitiveType.Kind.INT);
native_types_to_primitive.put(GLcharARB.class, PrimitiveType.Kind.BYTE);
native_types_to_primitive.put(GLclampf.class, PrimitiveType.Kind.FLOAT);
native_types_to_primitive.put(GLfloat.class, PrimitiveType.Kind.FLOAT);
native_types_to_primitive.put(GLint.class, PrimitiveType.Kind.INT);
native_types_to_primitive.put(GLshort.class, PrimitiveType.Kind.SHORT);
native_types_to_primitive.put(GLsizeiptr.class, PrimitiveType.Kind.LONG);
native_types_to_primitive.put(GLuint.class, PrimitiveType.Kind.INT);
native_types_to_primitive.put(GLboolean.class, PrimitiveType.Kind.BOOLEAN);
native_types_to_primitive.put(GLchar.class, PrimitiveType.Kind.BYTE);
native_types_to_primitive.put(GLdouble.class, PrimitiveType.Kind.DOUBLE);
native_types_to_primitive.put(GLhalf.class, PrimitiveType.Kind.SHORT);
native_types_to_primitive.put(GLintptrARB.class, PrimitiveType.Kind.LONG);
native_types_to_primitive.put(GLsizei.class, PrimitiveType.Kind.INT);
native_types_to_primitive.put(GLushort.class, PrimitiveType.Kind.SHORT);
native_types_to_primitive.put(GLbyte.class, PrimitiveType.Kind.BYTE);
native_types_to_primitive.put(GLclampd.class, PrimitiveType.Kind.DOUBLE);
native_types_to_primitive.put(GLenum.class, PrimitiveType.Kind.INT);
native_types_to_primitive.put(GLhandleARB.class, PrimitiveType.Kind.INT);
native_types_to_primitive.put(GLintptr.class, PrimitiveType.Kind.LONG);
native_types_to_primitive.put(GLsizeiptrARB.class, PrimitiveType.Kind.LONG);
native_types_to_primitive.put(GLubyte.class, PrimitiveType.Kind.BYTE);
native_types_to_primitive.put(GLvoid.class, PrimitiveType.Kind.BYTE);
native_types_to_primitive.put(GLint64EXT.class, PrimitiveType.Kind.LONG);
native_types_to_primitive.put(GLuint64EXT.class, PrimitiveType.Kind.LONG);
native_types_to_primitive.put(GLint64.class, PrimitiveType.Kind.LONG);
native_types_to_primitive.put(GLuint64.class, PrimitiveType.Kind.LONG);
}
public PrimitiveType.Kind getPrimitiveTypeFromNativeType(Class native_type) {
PrimitiveType.Kind kind = native_types_to_primitive.get(native_type);
if ( kind == null )
throw new RuntimeException("Unsupported type " + native_type);
return kind;
}
public void printCapabilitiesInit(final PrintWriter writer) {
writer.println("\t\tContextCapabilities caps = GLContext.getCapabilities();");
}
public String getCapabilities() {
return "caps";
}
public void printErrorCheckMethod(final PrintWriter writer, final MethodDeclaration method, final String tabs) {
writer.println(tabs + "Util.checkGLError();");
}
public String getRegisterNativesFunctionName() {
return "extgl_InitializeClass";
}
public Signedness getSignednessFromType(Class type) {
if ( GLuint.class.equals(type) )
return Signedness.UNSIGNED;
else if ( GLint.class.equals(type) )
return Signedness.SIGNED;
else if ( GLushort.class.equals(type) )
return Signedness.UNSIGNED;
else if ( GLshort.class.equals(type) )
return Signedness.SIGNED;
else if ( GLubyte.class.equals(type) )
return Signedness.UNSIGNED;
else if ( GLbyte.class.equals(type) )
return Signedness.SIGNED;
else if ( GLuint64EXT.class.equals(type) )
return Signedness.UNSIGNED;
else if ( GLint64EXT.class.equals(type) )
return Signedness.SIGNED;
else if ( GLuint64.class.equals(type) )
return Signedness.UNSIGNED;
else if ( GLint64.class.equals(type) )
return Signedness.SIGNED;
else
return Signedness.NONE;
}
public String translateAnnotation(Class annotation_type) {
if ( annotation_type.equals(GLuint.class) || annotation_type.equals(GLint.class) )
return "i";
else if ( annotation_type.equals(GLushort.class) || annotation_type.equals(GLshort.class) )
return "s";
else if ( annotation_type.equals(GLubyte.class) || annotation_type.equals(GLbyte.class) )
return "b";
else if ( annotation_type.equals(GLfloat.class) || annotation_type.equals(GLclampf.class) )
return "f";
else if ( annotation_type.equals(GLdouble.class) || annotation_type.equals(GLclampd.class) )
return "d";
else if ( annotation_type.equals(GLhalf.class) )
return "h";
else if ( annotation_type.equals(GLuint64EXT.class) || annotation_type.equals(GLint64EXT.class) || annotation_type.equals(GLuint64.class) || annotation_type.equals(GLint64.class) )
return "i64";
else if ( annotation_type.equals(GLboolean.class) || annotation_type.equals(GLvoid.class) )
return "";
else
throw new RuntimeException(annotation_type + " is not allowed");
}
public Class getNativeTypeFromPrimitiveType(PrimitiveType.Kind kind) {
Class type;
switch ( kind ) {
case INT:
type = GLint.class;
break;
case DOUBLE:
type = GLdouble.class;
break;
case FLOAT:
type = GLfloat.class;
break;
case SHORT:
type = GLshort.class;
break;
case BYTE:
type = GLbyte.class;
break;
case LONG:
type = GLint64EXT.class;
break;
case BOOLEAN:
type = GLboolean.class;
break;
default:
throw new RuntimeException(kind + " is not allowed");
}
return type;
}
public Class getVoidType() {
return GLvoid.class;
}
public Class getStringElementType() {
return GLubyte.class;
}
public Class getStringArrayType() {
return GLchar.class;
}
public Class getByteBufferArrayType() {
return GLchar.class;
}
private static Class[] getValidBufferTypes(Class type) {
if ( type.equals(IntBuffer.class) )
return new Class[] { GLbitfield.class, GLenum.class, GLhandleARB.class, GLint.class,
GLsizei.class, GLuint.class, GLvoid.class };
else if ( type.equals(FloatBuffer.class) )
return new Class[] { GLclampf.class, GLfloat.class };
else if ( type.equals(ByteBuffer.class) )
return new Class[] { GLboolean.class, GLbyte.class, GLcharARB.class, GLchar.class, GLubyte.class, GLvoid.class };
else if ( type.equals(ShortBuffer.class) )
return new Class[] { GLhalf.class, GLshort.class, GLushort.class };
else if ( type.equals(DoubleBuffer.class) )
return new Class[] { GLclampd.class, GLdouble.class };
else if ( type.equals(LongBuffer.class) )
return new Class[] { GLint64EXT.class, GLuint64EXT.class, GLint64.class, GLuint64.class };
else
return new Class[] { };
}
private static Class[] getValidPrimitiveTypes(Class type) {
if ( type.equals(long.class) )
return new Class[] { GLintptrARB.class, GLuint.class, GLintptr.class, GLsizeiptrARB.class, GLsizeiptr.class, GLint64EXT.class, GLuint64EXT.class, GLint64.class, GLuint64.class };
else if ( type.equals(int.class) )
return new Class[] { GLbitfield.class, GLenum.class, GLhandleARB.class, GLint.class, GLuint.class,
GLsizei.class };
else if ( type.equals(double.class) )
return new Class[] { GLclampd.class, GLdouble.class };
else if ( type.equals(float.class) )
return new Class[] { GLclampf.class, GLfloat.class };
else if ( type.equals(short.class) )
return new Class[] { GLhalf.class, GLshort.class, GLushort.class };
else if ( type.equals(byte.class) )
return new Class[] { GLbyte.class, GLcharARB.class, GLchar.class, GLubyte.class };
else if ( type.equals(boolean.class) )
return new Class[] { GLboolean.class };
else if ( type.equals(void.class) )
return new Class[] { GLvoid.class, GLreturn.class };
else
return new Class[] { };
}
public String getTypedefPostfix() {
return "";
}
public String getFunctionPrefix() {
return "APIENTRY";
}
public void printNativeIncludes(PrintWriter writer) {
writer.println("#include \"extgl.h\"");
}
public Class[] getValidAnnotationTypes(Class type) {
Class[] valid_types;
if ( Buffer.class.isAssignableFrom(type) )
valid_types = getValidBufferTypes(type);
else if ( type.isPrimitive() )
valid_types = getValidPrimitiveTypes(type);
else if ( String.class.equals(type) )
valid_types = new Class[] { GLubyte.class };
else if ( org.lwjgl.PointerWrapper.class.isAssignableFrom(type) )
valid_types = new Class[] { PointerWrapper.class };
else if (void.class.equals(type) )
valid_types = new Class[] { GLreturn.class };
else
valid_types = new Class[] { };
return valid_types;
}
public Class getInverseType(Class type) {
if ( GLuint.class.equals(type) )
return GLint.class;
else if ( GLint.class.equals(type) )
return GLuint.class;
else if ( GLushort.class.equals(type) )
return GLshort.class;
else if ( GLshort.class.equals(type) )
return GLushort.class;
else if ( GLubyte.class.equals(type) )
return GLbyte.class;
else if ( GLbyte.class.equals(type) )
return GLubyte.class;
else if ( GLuint64EXT.class.equals(type) )
return GLint64EXT.class;
else if ( GLint64EXT.class.equals(type) )
return GLuint64EXT.class;
else if ( GLuint64.class.equals(type) )
return GLint64.class;
else if ( GLint64.class.equals(type) )
return GLuint64.class;
else
return null;
}
public String getAutoTypeFromAnnotation(AnnotationMirror annotation) {
Class annotation_class = NativeTypeTranslator.getClassFromType(annotation.getAnnotationType());
if ( annotation_class.equals(GLint.class) )
return "GL11.GL_INT";
else if ( annotation_class.equals(GLbyte.class) )
return "GL11.GL_BYTE";
else if ( annotation_class.equals(GLshort.class) )
return "GL11.GL_SHORT";
if ( annotation_class.equals(GLuint.class) )
return "GL11.GL_UNSIGNED_INT";
else if ( annotation_class.equals(GLubyte.class) )
return "GL11.GL_UNSIGNED_BYTE";
else if ( annotation_class.equals(GLushort.class) )
return "GL11.GL_UNSIGNED_SHORT";
else if ( annotation_class.equals(GLfloat.class) )
return "GL11.GL_FLOAT";
else if ( annotation_class.equals(GLdouble.class) )
return "GL11.GL_DOUBLE";
else
return null;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLint64.java 0000644 0001750 0001750 00000003445 11543426510 023626 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLint64 {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLclampf.java 0000644 0001750 0001750 00000003703 11543426510 024121 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLclampf.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLclampf {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLint.java 0000644 0001750 0001750 00000003675 11543426510 023461 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLint.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLint {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLenum.java 0000644 0001750 0001750 00000003677 11543426510 023635 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLenum.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLenum {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLhandleARB.java 0000644 0001750 0001750 00000003711 11543426510 024436 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLhandleARB.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLhandleARB {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLintptrARB.java 0000644 0001750 0001750 00000003711 11543426510 024523 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLintptrARB.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLintptrARB {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLhalf.java 0000644 0001750 0001750 00000003677 11543426510 023603 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLhalf.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLhalf {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLdouble.java 0000644 0001750 0001750 00000003703 11543426510 024131 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLdouble.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLdouble {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLsizeiptr.java 0000644 0001750 0001750 00000003707 11543426510 024534 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLsizeiptr.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLsizeiptr {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLtime.java 0000644 0001750 0001750 00000003765 11543426510 023625 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
* Unsigned binary representing an absolute absolute or relative time interval.
* Precision is nanoseconds but accuracy is implementation-dependent.
*
* @author spasi
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLtime {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLGeneratorProcessorFactory.java 0000644 0001750 0001750 00000017254 11543426510 030043 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
import org.lwjgl.util.generator.Utils;
import static java.util.Collections.unmodifiableCollection;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import com.sun.mirror.apt.AnnotationProcessor;
import com.sun.mirror.apt.AnnotationProcessorEnvironment;
import com.sun.mirror.apt.AnnotationProcessorFactory;
import com.sun.mirror.apt.AnnotationProcessors;
import com.sun.mirror.apt.Filer;
import com.sun.mirror.apt.RoundCompleteEvent;
import com.sun.mirror.apt.RoundCompleteListener;
import com.sun.mirror.declaration.AnnotationTypeDeclaration;
import com.sun.mirror.declaration.InterfaceDeclaration;
import com.sun.mirror.declaration.TypeDeclaration;
import com.sun.mirror.util.DeclarationFilter;
/**
*
* Generator tool for creating the ContexCapabilities class
*
* @author elias_naur
* @version $Revision: 3316 $
* $Id: ContextGeneratorProcessorFactory.java 3316 2010-04-09 23:57:40Z spasi $
*/
public class GLGeneratorProcessorFactory implements AnnotationProcessorFactory, RoundCompleteListener {
private static boolean first_round = true;
// Process any set of annotations
private static final Collection supportedAnnotations =
unmodifiableCollection(Arrays.asList("*"));
public Collection supportedAnnotationTypes() {
return supportedAnnotations;
}
public Collection supportedOptions() {
return unmodifiableCollection(Arrays.asList("-Acontextspecific", "-Ageneratechecks"));
}
public void roundComplete(RoundCompleteEvent event) {
first_round = false;
}
public AnnotationProcessor getProcessorFor(Set atds, AnnotationProcessorEnvironment env) {
// Only process the initial types, not the generated ones
if (first_round) {
env.addListener(this);
return new GeneratorProcessor(env);
} else
return AnnotationProcessors.NO_OP;
}
private static class GeneratorProcessor implements AnnotationProcessor {
private final AnnotationProcessorEnvironment env;
GeneratorProcessor(AnnotationProcessorEnvironment env) {
this.env = env;
}
public void process() {
Map options = env.getOptions();
boolean generate_error_checks = options.containsKey("-Ageneratechecks");
boolean context_specific = options.containsKey("-Acontextspecific");
try {
generateContextCapabilitiesSource(context_specific, generate_error_checks);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private void generateContextCapabilitiesSource(boolean context_specific, boolean generate_error_checks) throws IOException {
PrintWriter writer = env.getFiler().createTextFile(Filer.Location.SOURCE_TREE, "org.lwjgl.opengl", new File(Utils.CONTEXT_CAPS_CLASS_NAME + ".java"), null);
writer.println("/* MACHINE GENERATED FILE, DO NOT EDIT */");
writer.println();
writer.println("package org.lwjgl.opengl;");
writer.println();
writer.println("import org.lwjgl.LWJGLException;");
writer.println("import org.lwjgl.LWJGLUtil;");
writer.println("import java.util.Set;");
writer.println("import java.util.HashSet;");
writer.println();
GLCapabilitiesGenerator.generateClassPrologue(writer, context_specific, generate_error_checks);
DeclarationFilter filter = DeclarationFilter.getFilter(InterfaceDeclaration.class);
Collection interface_decls = filter.filter(env.getSpecifiedTypeDeclarations());
for (TypeDeclaration typedecl : interface_decls) {
InterfaceDeclaration interface_decl = (InterfaceDeclaration)typedecl;
if (Utils.isFinal(interface_decl))
GLCapabilitiesGenerator.generateField(writer, interface_decl);
}
writer.println();
for (TypeDeclaration typedecl : interface_decls) {
InterfaceDeclaration interface_decl = (InterfaceDeclaration)typedecl;
GLCapabilitiesGenerator.generateSymbolAddresses(writer, interface_decl);
}
writer.println();
if (context_specific) {
for (TypeDeclaration typedecl : interface_decls) {
InterfaceDeclaration interface_decl = (InterfaceDeclaration)typedecl;
GLCapabilitiesGenerator.generateAddressesInitializers(writer, interface_decl);
}
writer.println();
}
writer.println("\tprivate static void remove(Set supported_extensions, String extension) {");
writer.println("\t\tLWJGLUtil.log(extension + \" was reported as available but an entry point is missing\");");
writer.println("\t\tsupported_extensions.remove(extension);");
writer.println("\t}\n");
GLCapabilitiesGenerator.generateInitStubsPrologue(writer, context_specific);
for (TypeDeclaration typedecl : interface_decls) {
InterfaceDeclaration interface_decl = (InterfaceDeclaration)typedecl;
GLCapabilitiesGenerator.generateSuperClassAdds(writer, interface_decl);
}
for (TypeDeclaration typedecl : interface_decls) {
InterfaceDeclaration interface_decl = (InterfaceDeclaration)typedecl;
String simple_name = interface_decl.getSimpleName();
if ( "GL11".equals(simple_name) )
continue;
GLCapabilitiesGenerator.generateInitStubs(writer, interface_decl, context_specific);
}
GLCapabilitiesGenerator.generateInitStubsEpilogue(writer, context_specific);
writer.println();
writer.println("\tstatic void unloadAllStubs() {");
if (!context_specific) {
writer.println("\t\tif (!loaded_stubs)");
writer.println("\t\t\treturn;");
for (TypeDeclaration typedecl : interface_decls) {
InterfaceDeclaration interface_decl = (InterfaceDeclaration)typedecl;
GLCapabilitiesGenerator.generateUnloadStubs(writer, interface_decl);
}
writer.println("\t\tloaded_stubs = false;");
}
writer.println("\t}");
writer.println();
GLCapabilitiesGenerator.generateInitializerPrologue(writer);
for (TypeDeclaration typedecl : interface_decls) {
InterfaceDeclaration interface_decl = (InterfaceDeclaration)typedecl;
if (Utils.isFinal(interface_decl))
GLCapabilitiesGenerator.generateInitializer(writer, interface_decl);
}
writer.println("\t\ttracker.init();");
writer.println("\t}");
writer.println("}");
writer.close();
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLvoid.java 0000644 0001750 0001750 00000004046 11543426510 023621 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 3279 $
* $Id: GLvoid.java 3279 2010-03-11 21:06:49Z spasi $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
import com.sun.mirror.type.PrimitiveType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLvoid {
PrimitiveType.Kind value() default PrimitiveType.Kind.BYTE;
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLreturn.java 0000644 0001750 0001750 00000004754 11543426510 024205 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
* When a method is annonated with @GLreturn, the specified output Buffer parameter
* will be used to return a single value. The primitive type will match the Buffer type.
* String will be returned if the Buffer is a ByteBuffer annotated with @GLchar.
*
* @author spasi
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@NativeType
@Target({ ElementType.METHOD })
public @interface GLreturn {
/** The Buffer parameter to use as the method result. */
String value();
/** The argument that specifies the maximum number of bytes that may be read (String results only). */
String maxLength() default "";
/** If true, the maxLength value is going to be used when creating the String. */
boolean forceMaxLength() default false;
///** If we use the byte buffer for another parameter, an offset must be used. */
//String offset() default "";
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLboolean.java 0000644 0001750 0001750 00000003705 11543426510 024300 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLboolean.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLboolean {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLclampd.java 0000644 0001750 0001750 00000003703 11543426510 024117 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLclampd.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLclampd {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLbyte.java 0000644 0001750 0001750 00000003677 11543426510 023634 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLbyte.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLbyte {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLintptr.java 0000644 0001750 0001750 00000003703 11543426510 024177 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLintptr.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLintptr {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLcharARB.java 0000644 0001750 0001750 00000003705 11543426510 024123 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLcharARB.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLcharARB {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLuint64EXT.java 0000644 0001750 0001750 00000003451 11543426510 024371 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLuint64EXT {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLshort.java 0000644 0001750 0001750 00000003701 11543426510 024014 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLshort.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLshort {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLuint64.java 0000644 0001750 0001750 00000003446 11543426510 024014 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLuint64 {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLCapabilitiesGenerator.java 0000644 0001750 0001750 00000033370 11543426510 027122 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
import org.lwjgl.util.generator.*;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Collection;
import java.util.EnumSet;
import java.util.Iterator;
import com.sun.mirror.declaration.InterfaceDeclaration;
import com.sun.mirror.declaration.MethodDeclaration;
import com.sun.mirror.type.InterfaceType;
/**
* Generator visitor for the context capabilities generator tool
*
* @author elias_naur
* @version $Revision: 3355 $
* $Id: ContextCapabilitiesGenerator.java 3355 2010-05-27 22:56:29Z spasi $
*/
public class GLCapabilitiesGenerator {
private static final String STUBS_LOADED_NAME = "loaded_stubs";
private static final String ALL_INIT_METHOD_NAME = "initAllStubs";
private static final String POINTER_INITIALIZER_POSTFIX = "_initNativeFunctionAddresses";
private static final String CACHED_EXTS_VAR_NAME = "supported_extensions";
private static final String PROFILE_MASK_VAR_NAME = "profileMask";
private static final String EXTENSION_PREFIX = "GL_";
private static final String CORE_PREFIX = "Open";
public static void generateClassPrologue(PrintWriter writer, boolean context_specific, boolean generate_error_checks) {
writer.println("public class " + Utils.CONTEXT_CAPS_CLASS_NAME + " {");
writer.println("\tstatic final boolean DEBUG = " + Boolean.toString(generate_error_checks) + ";");
writer.println("\tfinal StateTracker tracker = new StateTracker();");
writer.println();
if ( !context_specific ) {
writer.println("\tprivate static boolean " + STUBS_LOADED_NAME + " = false;");
}
}
public static void generateInitializerPrologue(PrintWriter writer) {
writer.println("\t" + Utils.CONTEXT_CAPS_CLASS_NAME + "(boolean forwardCompatible) throws LWJGLException {");
writer.println("\t\tSet " + CACHED_EXTS_VAR_NAME + " = " + ALL_INIT_METHOD_NAME + "(forwardCompatible);");
}
private static String translateFieldName(String interface_name) {
if ( interface_name.startsWith("GL") )
return CORE_PREFIX + interface_name;
else
return EXTENSION_PREFIX + interface_name;
}
public static void generateSuperClassAdds(PrintWriter writer, InterfaceDeclaration d) {
Collection super_interfaces = d.getSuperinterfaces();
if ( super_interfaces.size() > 1 )
throw new RuntimeException(d + " extends more than one other interface");
if ( super_interfaces.size() == 1 ) {
InterfaceType super_interface = super_interfaces.iterator().next();
writer.print("\t\tif (" + CACHED_EXTS_VAR_NAME + ".contains(\"");
writer.println(translateFieldName(d.getSimpleName()) + "\"))");
writer.print("\t\t\t");
generateAddExtension(writer, super_interface.getDeclaration());
}
}
public static void generateInitializer(PrintWriter writer, InterfaceDeclaration d) {
String translated_field_name = translateFieldName(d.getSimpleName());
writer.print("\t\tthis." + translated_field_name + " = ");
writer.print(CACHED_EXTS_VAR_NAME + ".contains(\"");
writer.print(translated_field_name + "\")");
Collection super_interfaces = d.getSuperinterfaces();
if ( super_interfaces.size() > 1 )
throw new RuntimeException(d + " extends more than one other interface");
if ( super_interfaces.size() == 1 ) {
InterfaceType super_interface = super_interfaces.iterator().next();
writer.println();
writer.print("\t\t\t&& " + CACHED_EXTS_VAR_NAME + ".contains(\"");
writer.print(translateFieldName(super_interface.getDeclaration().getSimpleName()) + "\")");
}
Alias alias_annotation = d.getAnnotation(Alias.class);
if ( alias_annotation != null ) {
writer.println();
writer.print("\t\t\t|| " + CACHED_EXTS_VAR_NAME + ".contains(\"");
writer.print(translateFieldName(alias_annotation.value()) + "\")");
}
writer.println(";");
}
private static String getAddressesInitializerName(String class_name) {
return class_name + POINTER_INITIALIZER_POSTFIX;
}
public static void generateInitStubsPrologue(PrintWriter writer, boolean context_specific) {
writer.println("\tprivate Set " + ALL_INIT_METHOD_NAME + "(boolean forwardCompatible) throws LWJGLException {");
// Load the basic pointers we need to detect OpenGL version and supported extensions.
writer.println("\t\tglGetError = GLContext.getFunctionAddress(\"glGetError\");");
writer.println("\t\tglGetString = GLContext.getFunctionAddress(\"glGetString\");");
// Initialize GL11.glGetIntegerv and GL30.glGetStringi here, in case we have created an OpenGL 3.0 context.
// (they will be used in GLContext.getSupportedExtensions)
writer.println("\t\tglGetIntegerv = GLContext.getFunctionAddress(\"glGetIntegerv\");");
writer.println("\t\tglGetStringi = GLContext.getFunctionAddress(\"glGetStringi\");");
// Get the supported extensions set.
writer.println("\t\tGLContext.setCapabilities(this);");
writer.println("\t\tSet " + CACHED_EXTS_VAR_NAME + " = new HashSet(256);");
writer.println("\t\tint " + PROFILE_MASK_VAR_NAME + " = GLContext.getSupportedExtensions(" + CACHED_EXTS_VAR_NAME + ");");
// Force forward compatible mode when OpenGL version is 3.1 or higher and ARB_compatibility is not available.
writer.println("\t\tif ( supported_extensions.contains(\"OpenGL31\") && !(supported_extensions.contains(\"GL_ARB_compatibility\") || (profileMask & GL32.GL_CONTEXT_COMPATIBILITY_PROFILE_BIT) != 0) )");
writer.println("\t\t\tforwardCompatible = true;");
if ( !context_specific ) {
writer.println("\t\tif (" + STUBS_LOADED_NAME + ")");
writer.println("\t\t\treturn GLContext.getSupportedExtensions();");
writer.println("\t\torg.lwjgl.opengl.GL11." + Utils.STUB_INITIALIZER_NAME + "();");
} else {
writer.println("\t\tif (!" + getAddressesInitializerName("GL11") + "(forwardCompatible))");
writer.println("\t\t\tthrow new LWJGLException(\"GL11 not supported\");");
}
}
public static void generateInitStubsEpilogue(PrintWriter writer, boolean context_specific) {
if ( !context_specific ) {
writer.println("\t\t" + STUBS_LOADED_NAME + " = true;");
}
writer.println("\t\treturn " + CACHED_EXTS_VAR_NAME + ";");
writer.println("\t}");
}
public static void generateUnloadStubs(PrintWriter writer, InterfaceDeclaration d) {
if ( d.getMethods().size() > 0 ) {
writer.print("\t\tGLContext.resetNativeStubs(" + Utils.getSimpleClassName(d));
writer.println(".class);");
}
}
public static void generateInitStubs(PrintWriter writer, InterfaceDeclaration d, boolean context_specific) {
if ( d.getMethods().size() > 0 ) {
if ( context_specific ) {
final Alias alias_annotation = d.getAnnotation(Alias.class);
if ( d.getAnnotation(ForceInit.class) != null )
writer.println("\t\t" + CACHED_EXTS_VAR_NAME + ".add(\"" + translateFieldName(d.getSimpleName()) + "\");");
writer.print("\t\tif (");
if ( alias_annotation != null )
writer.print("(");
writer.print(CACHED_EXTS_VAR_NAME + ".contains(\"");
writer.print(translateFieldName(d.getSimpleName()) + "\")");
if ( alias_annotation != null ) {
writer.print(" || " + CACHED_EXTS_VAR_NAME + ".contains(\"");
writer.print(translateFieldName(alias_annotation.value()) + "\"))");
}
writer.print(" && !" + getAddressesInitializerName(d.getSimpleName()) + "(");
if ( d.getAnnotation(DeprecatedGL.class) != null )
writer.print("forwardCompatible");
if ( d.getAnnotation(Dependent.class) != null ) {
if ( d.getAnnotation(DeprecatedGL.class) != null )
writer.print(",");
writer.print("supported_extensions");
}
if ( alias_annotation != null ) {
writer.println(")) {");
writer.print("\t\t\tremove(" + CACHED_EXTS_VAR_NAME + ", \"");
writer.println(translateFieldName(alias_annotation.value()) + "\");");
} else
writer.println("))");
writer.print("\t\t\tremove(" + CACHED_EXTS_VAR_NAME + ", \"");
writer.println(translateFieldName(d.getSimpleName()) + "\");");
if ( alias_annotation != null )
writer.println("\t\t}");
} else {
writer.print("\t\tGLContext." + Utils.STUB_INITIALIZER_NAME + "(" + Utils.getSimpleClassName(d));
writer.println(".class, " + CACHED_EXTS_VAR_NAME + ", \"" + translateFieldName(d.getSimpleName()) + "\");");
}
}
}
private static void generateAddExtension(PrintWriter writer, InterfaceDeclaration d) {
writer.print(CACHED_EXTS_VAR_NAME + ".add(\"");
writer.println(translateFieldName(d.getSimpleName()) + "\");");
}
public static void generateAddressesInitializers(PrintWriter writer, InterfaceDeclaration d) {
Iterator methods = d.getMethods().iterator();
if ( !methods.hasNext() )
return;
writer.print("\tprivate boolean " + getAddressesInitializerName(d.getSimpleName()) + "(");
boolean optional;
boolean deprecated = d.getAnnotation(DeprecatedGL.class) != null;
Dependent dependent = d.getAnnotation(Dependent.class);
if ( deprecated )
writer.print("boolean forwardCompatible");
if ( dependent != null ) {
if ( deprecated )
writer.print(",");
writer.print("Set supported_extensions");
}
Alias alias_annotation = d.getAnnotation(Alias.class);
boolean aliased = alias_annotation != null && alias_annotation.postfix().length() > 0;
writer.println(") {");
writer.println("\t\treturn ");
boolean first = true;
while ( methods.hasNext() ) {
MethodDeclaration method = methods.next();
if ( method.getAnnotation(Alternate.class) != null )
continue;
if ( !first )
writer.println(" &");
else
first = false;
optional = method.getAnnotation(Optional.class) != null;
deprecated = method.getAnnotation(DeprecatedGL.class) != null;
dependent = method.getAnnotation(Dependent.class);
writer.print("\t\t\t(");
if ( optional )
writer.print('(');
if ( deprecated )
writer.print("forwardCompatible || ");
if ( dependent != null ) {
if ( dependent.value().indexOf(',') == -1 )
writer.print("!supported_extensions.contains(\"" + dependent.value() + "\") || ");
else {
writer.print("!(false");
for ( String extension : dependent.value().split(",") )
writer.print(" || supported_extensions.contains(\"" + extension + "\")");
writer.print(") || ");
}
}
if ( deprecated || dependent != null )
writer.print('(');
writer.print(Utils.getFunctionAddressName(d, method) + " = ");
PlatformDependent platform_dependent = method.getAnnotation(PlatformDependent.class);
if ( platform_dependent != null ) {
EnumSet platform_set = EnumSet.copyOf(Arrays.asList(platform_dependent.value()));
writer.print("GLContext.getPlatformSpecificFunctionAddress(\"");
writer.print(Platform.ALL.getPrefix() + "\", ");
writer.print("new String[]{");
Iterator platforms = platform_set.iterator();
while ( platforms.hasNext() ) {
writer.print("\"" + platforms.next().getOSPrefix() + "\"");
if ( platforms.hasNext() )
writer.print(", ");
}
writer.print("}, new String[]{");
platforms = platform_set.iterator();
while ( platforms.hasNext() ) {
writer.print("\"" + platforms.next().getPrefix() + "\"");
if ( platforms.hasNext() )
writer.print(", ");
}
writer.print("}, ");
} else if ( aliased ) {
writer.print("GLContext.getFunctionAddress(new String[] {\"" + method.getSimpleName() + "\",\"" + method.getSimpleName() + alias_annotation.postfix() + "\"})) != 0");
} else
writer.print("GLContext.getFunctionAddress(");
if ( !aliased )
writer.print("\"" + method.getSimpleName() + "\")) != 0");
if ( deprecated || dependent != null )
writer.print(')');
if ( optional )
writer.print(" || true)");
}
writer.println(";");
writer.println("\t}");
writer.println();
}
public static void generateSymbolAddresses(PrintWriter writer, InterfaceDeclaration d) {
boolean first = true;
for ( final MethodDeclaration method : d.getMethods() ) {
if ( method.getAnnotation(Alternate.class) != null || method.getAnnotation(Reuse.class) != null )
continue;
if ( first ) {
writer.println("\t// " + d.getSimpleName());
first = false;
}
writer.println("\tlong " + Utils.getFunctionAddressName(d, method) + ";");
}
}
public static void generateField(PrintWriter writer, InterfaceDeclaration d) {
writer.println("\tpublic final boolean " + translateFieldName(d.getSimpleName()) + ";");
}
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLbitfield.java 0000644 0001750 0001750 00000003707 11543426510 024445 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLbitfield.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLbitfield {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLchar.java 0000644 0001750 0001750 00000003677 11543426510 023606 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLchar.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLchar {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLubyte.java 0000644 0001750 0001750 00000003701 11543426510 024005 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLubyte.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLubyte {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLsizeiptrARB.java 0000644 0001750 0001750 00000003715 11543426510 025060 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLsizeiptrARB.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLsizeiptrARB {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLReferencesGeneratorProcessorFactory.java 0000644 0001750 0001750 00000021555 11543426510 032044 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
import org.lwjgl.util.generator.CachedReference;
import org.lwjgl.util.generator.Utils;
import static java.util.Collections.emptyList;
import static java.util.Collections.unmodifiableCollection;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Collection;
import java.util.Set;
import com.sun.mirror.apt.AnnotationProcessor;
import com.sun.mirror.apt.AnnotationProcessorEnvironment;
import com.sun.mirror.apt.AnnotationProcessorFactory;
import com.sun.mirror.apt.AnnotationProcessors;
import com.sun.mirror.apt.Filer;
import com.sun.mirror.apt.RoundCompleteEvent;
import com.sun.mirror.apt.RoundCompleteListener;
import com.sun.mirror.declaration.AnnotationTypeDeclaration;
import com.sun.mirror.declaration.InterfaceDeclaration;
import com.sun.mirror.declaration.MethodDeclaration;
import com.sun.mirror.declaration.ParameterDeclaration;
import com.sun.mirror.declaration.TypeDeclaration;
import com.sun.mirror.util.DeclarationFilter;
/**
*
* Generator tool for creating the References class
*
* @author elias_naur
* @version $Revision: 3237 $
* $Id: ReferencesGeneratorProcessorFactory.java 3237 2009-09-08 15:07:15Z spasi $
*/
public class GLReferencesGeneratorProcessorFactory implements AnnotationProcessorFactory, RoundCompleteListener {
private static final String REFERENCES_CLASS_NAME = "References";
private static final String REFERENCES_PARAMETER_NAME = "references";
private static boolean first_round = true;
// Process any set of annotations
private static final Collection supportedAnnotations =
unmodifiableCollection(Arrays.asList("*"));
public Collection supportedAnnotationTypes() {
return supportedAnnotations;
}
public Collection supportedOptions() {
return emptyList();
}
public void roundComplete(RoundCompleteEvent event) {
first_round = false;
}
public AnnotationProcessor getProcessorFor(Set atds, AnnotationProcessorEnvironment env) {
// Only process the initial types, not the generated ones
if (first_round) {
env.addListener(this);
return new GeneratorProcessor(env);
} else
return AnnotationProcessors.NO_OP;
}
private static class GeneratorProcessor implements AnnotationProcessor {
private final AnnotationProcessorEnvironment env;
GeneratorProcessor(AnnotationProcessorEnvironment env) {
this.env = env;
}
public void process() {
try {
generateReferencesSource();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private static void generateClearsFromParameters(PrintWriter writer, InterfaceDeclaration interface_decl, MethodDeclaration method) {
for (ParameterDeclaration param : method.getParameters()) {
CachedReference cached_reference_annotation = param.getAnnotation(CachedReference.class);
if (cached_reference_annotation != null && cached_reference_annotation.name().length() == 0) {
Class nio_type = Utils.getNIOBufferType(param.getType());
String reference_name = Utils.getReferenceName(interface_decl, method, param);
writer.println("\t\tthis." + reference_name + " = null;");
}
}
}
private static void generateCopiesFromParameters(PrintWriter writer, InterfaceDeclaration interface_decl, MethodDeclaration method) {
for (ParameterDeclaration param : method.getParameters()) {
CachedReference cached_reference_annotation = param.getAnnotation(CachedReference.class);
if (cached_reference_annotation != null && cached_reference_annotation.name().length() == 0) {
Class nio_type = Utils.getNIOBufferType(param.getType());
String reference_name = Utils.getReferenceName(interface_decl, method, param);
writer.print("\t\t\tthis." + reference_name + " = ");
writer.println(REFERENCES_PARAMETER_NAME + "." + reference_name + ";");
}
}
}
private static void generateClearsFromMethods(PrintWriter writer, InterfaceDeclaration interface_decl) {
for (MethodDeclaration method : interface_decl.getMethods()) {
generateClearsFromParameters(writer, interface_decl, method);
}
}
private static void generateCopiesFromMethods(PrintWriter writer, InterfaceDeclaration interface_decl) {
for (MethodDeclaration method : interface_decl.getMethods()) {
generateCopiesFromParameters(writer, interface_decl, method);
}
}
private static void generateReferencesFromParameters(PrintWriter writer, InterfaceDeclaration interface_decl, MethodDeclaration method) {
for (ParameterDeclaration param : method.getParameters()) {
CachedReference cached_reference_annotation = param.getAnnotation(CachedReference.class);
if (cached_reference_annotation != null && cached_reference_annotation.name().length() == 0) {
Class nio_type = Utils.getNIOBufferType(param.getType());
if (nio_type == null)
throw new RuntimeException(param + " in method " + method + " in " + interface_decl + " is annotated with "
+ cached_reference_annotation.annotationType().getSimpleName() + " but the parameter is not a NIO buffer");
writer.print("\t" + nio_type.getName() + " " + Utils.getReferenceName(interface_decl, method, param));
writer.println(";");
}
}
}
private static void generateReferencesFromMethods(PrintWriter writer, InterfaceDeclaration interface_decl) {
for (MethodDeclaration method : interface_decl.getMethods()) {
generateReferencesFromParameters(writer, interface_decl, method);
}
}
private void generateReferencesSource() throws IOException {
PrintWriter writer = env.getFiler().createTextFile(Filer.Location.SOURCE_TREE, "org.lwjgl.opengl", new File(REFERENCES_CLASS_NAME + ".java"), null);
writer.println("/* MACHINE GENERATED FILE, DO NOT EDIT */");
writer.println();
writer.println("package org.lwjgl.opengl;");
writer.println();
writer.println("class " + REFERENCES_CLASS_NAME + " extends BaseReferences {");
writer.println("\t" + REFERENCES_CLASS_NAME + "(ContextCapabilities caps) {");
writer.println("\t\tsuper(caps);");
writer.println("\t}");
DeclarationFilter filter = DeclarationFilter.getFilter(InterfaceDeclaration.class);
Collection interface_decls = filter.filter(env.getSpecifiedTypeDeclarations());
for (TypeDeclaration typedecl : interface_decls) {
InterfaceDeclaration interface_decl = (InterfaceDeclaration)typedecl;
generateReferencesFromMethods(writer, interface_decl);
}
writer.println();
writer.println("\tvoid copy(" + REFERENCES_CLASS_NAME + " " + REFERENCES_PARAMETER_NAME + ", int mask) {");
writer.println("\t\tsuper.copy(" + REFERENCES_PARAMETER_NAME + ", mask);");
writer.println("\t\tif ( (mask & GL11.GL_CLIENT_VERTEX_ARRAY_BIT) != 0 ) {");
for (TypeDeclaration typedecl : interface_decls) {
InterfaceDeclaration interface_decl = (InterfaceDeclaration)typedecl;
generateCopiesFromMethods(writer, interface_decl);
}
writer.println("\t\t}");
writer.println("\t}");
writer.println("\tvoid clear() {");
writer.println("\t\tsuper.clear();");
for (TypeDeclaration typedecl : interface_decls) {
InterfaceDeclaration interface_decl = (InterfaceDeclaration)typedecl;
generateClearsFromMethods(writer, interface_decl);
}
writer.println("\t}");
writer.println("}");
writer.close();
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLfloat.java 0000644 0001750 0001750 00000003701 11543426510 023762 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLfloat.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLfloat {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/opengl/GLuint.java 0000644 0001750 0001750 00000003677 11543426510 023650 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator.opengl;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: GLuint.java 2983 2008-04-07 18:36:09Z matzon $
*/
import org.lwjgl.util.generator.NativeType;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@NativeType
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface GLuint {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/FieldsGenerator.java 0000644 0001750 0001750 00000012111 11543426510 024216 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
import java.io.PrintWriter;
import java.util.Collection;
import com.sun.mirror.declaration.FieldDeclaration;
import com.sun.mirror.declaration.Modifier;
import com.sun.mirror.type.PrimitiveType;
import com.sun.mirror.type.TypeMirror;
public class FieldsGenerator {
private static void validateField(FieldDeclaration field) {
// Check if field is "public static final"
Collection modifiers = field.getModifiers();
if ( modifiers.size() != 3
|| !modifiers.contains(Modifier.PUBLIC)
|| !modifiers.contains(Modifier.STATIC)
|| !modifiers.contains(Modifier.FINAL) ) {
throw new RuntimeException("Field " + field.getSimpleName() + " is not declared public static final");
}
// Check suported types (int, long, float, String)
TypeMirror field_type = field.getType();
if ( field_type instanceof PrimitiveType ) {
PrimitiveType field_type_prim = (PrimitiveType)field_type;
PrimitiveType.Kind field_kind = field_type_prim.getKind();
if ( field_kind != PrimitiveType.Kind.INT
&& field_kind != PrimitiveType.Kind.LONG
&& field_kind != PrimitiveType.Kind.FLOAT ) {
throw new RuntimeException("Field " + field.getSimpleName() + " is not of type 'int', 'long' or 'float'");
}
} else if ( "java.lang.String".equals(field_type.toString()) ) {
} else {
throw new RuntimeException("Field " + field.getSimpleName() + " is not a primitive type or String");
}
Object field_value = field.getConstantValue();
if ( field_value == null ) {
throw new RuntimeException("Field " + field.getSimpleName() + " has no initial value");
}
}
private static void generateField(PrintWriter writer, FieldDeclaration field, FieldDeclaration prev_field) {
validateField(field);
Object value = field.getConstantValue();
String field_value_string;
Class field_value_class = value.getClass();
if ( field_value_class.equals(Integer.class) ) {
field_value_string = "0x" + Integer.toHexString((Integer)field.getConstantValue()).toUpperCase();
} else if ( field_value_class.equals(Long.class) ) {
field_value_string = "0x" + Long.toHexString((Long)field.getConstantValue()).toUpperCase() + 'L';
} else if ( field_value_class.equals(Float.class) ) {
field_value_string = field.getConstantValue() + "f";
} else if ( field_value_class.equals(String.class) ) {
field_value_string = "\"" + field.getConstantValue() + "\"";
} else {
throw new RuntimeException("Field is of unexpected type. This means there is a bug in validateField().");
}
boolean hadDoc = prev_field != null && prev_field.getDocComment() != null;
boolean hasDoc = field.getDocComment() != null;
boolean newBatch = prev_field == null || !prev_field.getType().equals(field.getType()) || (!hadDoc && field.getDocComment() != null) || (hadDoc && hasDoc && !prev_field.getDocComment().equals(field.getDocComment()));
// Print field declaration
if ( newBatch ) {
if ( prev_field != null )
writer.println(";\n");
Utils.printDocComment(writer, field);
writer.print("\tpublic static final " + field.getType().toString() + " " + field.getSimpleName() + " = " + field_value_string);
} else
writer.print(",\n\t\t" + field.getSimpleName() + " = " + field_value_string);
}
public static void generateFields(PrintWriter writer, Collection fields) {
if ( 0 < fields.size() ) {
writer.println();
FieldDeclaration prev_field = null;
for ( FieldDeclaration field : fields ) {
generateField(writer, field, prev_field);
prev_field = field;
}
writer.println(";");
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/CachedResult.java 0000644 0001750 0001750 00000003623 11543426510 023517 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* @author elias_naur
* @version $Revision: 3262 $
* $Id: CachedResult.java 3262 2010-01-04 18:47:49Z spasi $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target(ElementType.METHOD)
public @interface CachedResult {
boolean isRange() default false;
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Dependent.java 0000644 0001750 0001750 00000004034 11543426510 023054 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
* Use this annotation on extensions with functionality that depends on the presence of other extensions.
* Functions in such extensions marked with this annotation will only be loaded if the specified extension is present.
*
* @author spasi
*/
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target({ ElementType.TYPE, ElementType.METHOD })
public @interface Dependent {
String value() default "";
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/PointerArray.java 0000644 0001750 0001750 00000003737 11543426510 023576 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* @author spasi
*/
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface PointerArray {
/** Number of values in the string list (name of native-side parameter) */
String value();
/** List of string lengths (name of native-side parameter) */
String lengths() default "";
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Reuse.java 0000644 0001750 0001750 00000004064 11543426510 022234 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
/**
* Reuse can be used to annotate methods that duplicate functionality that has been already
* defined somewhere else. For example, this can be applied to OpenGL core functionality that
* exists as an ARB extension as well, but with the exact same entry points.
*
* @author Spasi
*/
@Target(ElementType.METHOD)
public @interface Reuse {
/** The extension Class that defines the method. */
String value();
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Code.java 0000644 0001750 0001750 00000004577 11543426510 022034 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* @author elias_naur
* @version $Revision: 3412 $
* $Id: Code.java 3412 2010-09-26 23:43:24Z spasi $
*/
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)
public @interface Code {
String value() default ""; // Java, before everything
boolean tryBlock() default false; // Add a try/finally block around the native call and return statement
String javaBeforeNative() default ""; // Before the native call
String javaAfterNative() default ""; // After the native call
String javaFinally() default ""; // In the finally block
String nativeAfterVars() default ""; // After variable declaration
String nativeBeforeCall() default ""; // Before the API call
String nativeAfterCall() default ""; // After the API call
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/BufferKind.java 0000644 0001750 0001750 00000003504 11543426510 023166 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* @author elias_naur
* @version $Revision: 3279 $
* $Id: BufferKind.java 3279 2010-03-11 21:06:49Z spasi $
*/
public enum BufferKind {
UnpackPBO,
PackPBO,
ElementVBO,
ArrayVBO,
IndirectBO
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/TypeInfo.java 0000644 0001750 0001750 00000020421 11543426510 022701 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* This class represent a parameter configuration. There are multiple
* TypeInfos in case of multityped parameters.
*
* @author elias_naur
* @version $Revision: 3412 $
* $Id: TypeInfo.java 3412 2010-09-26 23:43:24Z spasi $
*/
import org.lwjgl.util.generator.opengl.GLvoid;
import com.sun.mirror.declaration.*;
import com.sun.mirror.type.*;
import java.lang.annotation.Annotation;
import java.util.*;
import java.nio.*;
public class TypeInfo {
public static final String UNSIGNED_PARAMETER_NAME = "unsigned";
private final Signedness signedness;
private final Class type;
private final String auto_type;
private TypeInfo(Class type, Signedness signedness, String auto_type) {
this.type = type;
this.signedness = signedness;
this.auto_type = auto_type;
}
public Class getType() {
return type;
}
public Signedness getSignedness() {
return signedness;
}
public String getAutoType() {
if (auto_type == null)
throw new RuntimeException("No auto type assigned");
return auto_type;
}
private static Class getTypeFromPrimitiveKind(PrimitiveType.Kind kind) {
Class type;
switch (kind) {
case LONG:
type = long.class;
break;
case INT:
type = int.class;
break;
case FLOAT:
type = float.class;
break;
case DOUBLE:
type = double.class;
break;
case SHORT:
type = short.class;
break;
case BYTE:
type = byte.class;
break;
case BOOLEAN:
type = boolean.class;
break;
default:
throw new RuntimeException(kind + " is not allowed");
}
return type;
}
private static Class getBufferTypeFromPrimitiveKind(PrimitiveType.Kind kind) {
Class type;
switch (kind) {
case INT:
type = IntBuffer.class;
break;
case FLOAT:
type = FloatBuffer.class;
break;
case DOUBLE:
type = DoubleBuffer.class;
break;
case SHORT:
type = ShortBuffer.class;
break;
case LONG:
type = LongBuffer.class;
break;
case BYTE: /* fall through */
case BOOLEAN:
type = ByteBuffer.class;
break;
default:
throw new RuntimeException(kind + " is not allowed");
}
return type;
}
private static TypeInfo getDefaultTypeInfo(TypeMirror t) {
Class java_type = Utils.getJavaType(t);
return new TypeInfo(java_type, Signedness.NONE, null);
}
public static Map getDefaultTypeInfoMap(MethodDeclaration method) {
Map map = new HashMap();
for (ParameterDeclaration param : method.getParameters()) {
TypeInfo type_info = getDefaultTypeInfo(param.getType());
map.put(param, type_info);
}
return map;
}
private static Collection getTypeInfos(TypeMap type_map, Declaration param, TypeMirror decl_type) {
Collection annotations = Utils.getSortedAnnotations(param.getAnnotationMirrors());
Map types = new HashMap();
Collection multityped_result = new ArrayList();
boolean add_default_type = true;
for (AnnotationMirror annotation : annotations) {
NativeType native_type_annotation = NativeTypeTranslator.getAnnotation(annotation, NativeType.class);
if (native_type_annotation != null) {
Class annotation_type = NativeTypeTranslator.getClassFromType(annotation.getAnnotationType());
Signedness signedness = type_map.getSignednessFromType(annotation_type);
Class inverse_type = type_map.getInverseType(annotation_type);
String auto_type = type_map.getAutoTypeFromAnnotation(annotation);
if (inverse_type != null) {
if (types.containsKey(inverse_type)) {
TypeInfo inverse_type_info = types.get(inverse_type);
String inverse_auto_type = inverse_type_info.getAutoType();
auto_type = signedness == Signedness.UNSIGNED ? auto_type + " : " + inverse_auto_type :
inverse_auto_type + " : " + auto_type;
auto_type = UNSIGNED_PARAMETER_NAME + " ? " + auto_type;
signedness = Signedness.BOTH;
types.remove(inverse_type);
multityped_result.remove(inverse_type_info);
}
}
Class type;
PrimitiveType.Kind kind;
GLvoid void_annotation = param.getAnnotation(GLvoid.class);
kind = void_annotation == null ? type_map.getPrimitiveTypeFromNativeType(annotation_type) : void_annotation.value();
if (Utils.getNIOBufferType(decl_type) != null)
type = getBufferTypeFromPrimitiveKind(kind);
else
type = getTypeFromPrimitiveKind(kind);
TypeInfo type_info = new TypeInfo(type, signedness, auto_type);
types.put(annotation_type, type_info);
multityped_result.add(type_info);
add_default_type = false;
}
}
if (add_default_type) {
TypeInfo default_type_info = getDefaultTypeInfo(decl_type);
Collection result = new ArrayList();
result.add(default_type_info);
return result;
} else
return multityped_result;
}
private static Map> getTypeInfoMap(TypeMap type_map, MethodDeclaration method) {
Map> map = new HashMap>();
for (ParameterDeclaration param : method.getParameters()) {
Collection types = getTypeInfos(type_map, param, param.getType());
map.put(param, types);
}
return map;
}
public static Collection> getTypeInfoCrossProduct(TypeMap type_map, MethodDeclaration method) {
Collection parameter_collection = method.getParameters();
ParameterDeclaration[] parameters = new ParameterDeclaration[parameter_collection.size()];
parameter_collection.toArray(parameters);
Collection> cross_product = new ArrayList>();
getCrossProductRecursive(0, parameters, getTypeInfoMap(type_map, method),
new HashMap(), cross_product);
return cross_product;
}
private static void getCrossProductRecursive(int index, ParameterDeclaration[] parameters, Map> typeinfos_map, Map current_instance,
Collection> cross_product) {
if (index == parameters.length) {
cross_product.add(current_instance);
return;
}
ParameterDeclaration param = parameters[index];
Collection typeinfos = typeinfos_map.get(param);
if (typeinfos != null) {
for (TypeInfo typeinfo : typeinfos) {
Map instance = new HashMap(current_instance);
instance.put(param, typeinfo);
getCrossProductRecursive(index + 1, parameters, typeinfos_map, instance, cross_product);
}
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/GeneratorVisitor.java 0000644 0001750 0001750 00000036257 11543426510 024470 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
import com.sun.mirror.apt.*;
import com.sun.mirror.declaration.*;
import com.sun.mirror.type.*;
import com.sun.mirror.util.*;
import java.io.*;
import java.lang.annotation.Annotation;
import java.nio.channels.FileChannel;
import java.util.*;
import java.nio.*;
/**
*
* Generator visitor for the generator tool
*
* @author elias_naur
* @version $Revision: 3430 $
* $Id: GeneratorVisitor.java 3430 2010-10-04 17:04:46Z spasi $
*/
public class GeneratorVisitor extends SimpleDeclarationVisitor {
private final AnnotationProcessorEnvironment env;
private final TypeMap type_map;
private final boolean generate_error_checks;
private final boolean context_specific;
private final long generatorLM;
public GeneratorVisitor(AnnotationProcessorEnvironment env, TypeMap type_map, boolean generate_error_checks, boolean context_specific, long generatorLM) {
this.env = env;
this.type_map = type_map;
this.generate_error_checks = generate_error_checks;
this.context_specific = context_specific;
this.generatorLM = generatorLM;
}
private void validateMethod(MethodDeclaration method) {
if (method.isVarArgs())
throw new RuntimeException("Method " + method.getSimpleName() + " is variadic");
Collection modifiers = method.getModifiers();
if (!modifiers.contains(Modifier.PUBLIC))
throw new RuntimeException("Method " + method.getSimpleName() + " is not public");
if (method.getThrownTypes().size() > 0)
throw new RuntimeException("Method " + method.getSimpleName() + " throws checked exceptions");
validateParameters(method);
StripPostfix strip_annotation = method.getAnnotation(StripPostfix.class);
if (strip_annotation != null && method.getAnnotation(Alternate.class) == null) {
String postfix_param_name = strip_annotation.value();
ParameterDeclaration postfix_param = Utils.findParameter(method, postfix_param_name);
if (Utils.isParameterMultiTyped(postfix_param))
throw new RuntimeException("Postfix parameter can't be the same as a multityped parameter in method " + method);
if (Utils.getNIOBufferType(postfix_param.getType()) == null)
throw new RuntimeException("Postfix parameter type must be a nio Buffer");
}
if (Utils.getResultParameter(method) != null && !method.getReturnType().equals(env.getTypeUtils().getVoidType()))
throw new RuntimeException(method + " return type is not void but a parameter is annotated with Result");
if (method.getAnnotation(CachedResult.class) != null) {
if (Utils.getNIOBufferType(Utils.getMethodReturnType(method)) == null)
throw new RuntimeException(method + " return type is not a Buffer, but is annotated with CachedResult");
if (method.getAnnotation(AutoSize.class) == null)
throw new RuntimeException(method + " is annotated with CachedResult but misses an AutoSize annotation");
}
validateTypes(method, method.getAnnotationMirrors(), method.getReturnType());
}
private void validateType(MethodDeclaration method, Class annotation_type, Class type) {
Class[] valid_types = type_map.getValidAnnotationTypes(type);
for ( Class valid_type : valid_types )
if ( valid_type.equals(annotation_type) )
return;
throw new RuntimeException(type + " is annotated with invalid native type " + annotation_type +
" in method " + method);
}
private void validateTypes(MethodDeclaration method, Collection annotations, TypeMirror type_mirror) {
for (AnnotationMirror annotation : annotations) {
NativeType native_type_annotation = NativeTypeTranslator.getAnnotation(annotation, NativeType.class);
if (native_type_annotation != null) {
Class annotation_type = NativeTypeTranslator.getClassFromType(annotation.getAnnotationType());
Class type = Utils.getJavaType(type_mirror);
if (Buffer.class.equals(type))
continue;
validateType(method, annotation_type, type);
}
}
}
private void validateParameters(MethodDeclaration method) {
for (ParameterDeclaration param : method.getParameters()) {
validateTypes(method, param.getAnnotationMirrors(), param.getType());
Class param_type = Utils.getJavaType(param.getType());
if (Utils.getNIOBufferType(param.getType()) != null && param_type != CharSequence.class && param_type != CharSequence[].class) {
Check parameter_check_annotation = param.getAnnotation(Check.class);
NullTerminated null_terminated_annotation = param.getAnnotation(NullTerminated.class);
if (parameter_check_annotation == null && null_terminated_annotation == null) {
boolean found_auto_size_param = false;
for (ParameterDeclaration inner_param : method.getParameters()) {
AutoSize auto_size_annotation = inner_param.getAnnotation(AutoSize.class);
if (auto_size_annotation != null &&
auto_size_annotation.value().equals(param.getSimpleName())) {
found_auto_size_param = true;
break;
}
}
if (!found_auto_size_param
&& param.getAnnotation(Result.class) == null
&& param.getAnnotation(Constant.class) == null
&& !Utils.isReturnParameter(method, param)
)
throw new RuntimeException(param + " has no Check, Result nor Constant annotation, is not the return parameter and no other parameter has" +
" an @AutoSize annotation on it in method " + method);
}
if (param.getAnnotation(CachedReference.class) != null && param.getAnnotation(Result.class) != null)
throw new RuntimeException(param + " can't be annotated with both CachedReference and Result");
if (param.getAnnotation(BufferObject.class) != null && param.getAnnotation(Result.class) != null)
throw new RuntimeException(param + " can't be annotated with both BufferObject and Result");
//if (param.getAnnotation(Constant.class) != null)
//throw new RuntimeException("Buffer parameter " + param + " cannot be Constant");
} else {
if (param.getAnnotation(BufferObject.class) != null)
throw new RuntimeException(param + " type is not a buffer, but annotated as a BufferObject");
if (param.getAnnotation(CachedReference.class) != null)
throw new RuntimeException(param + " type is not a buffer, but annotated as a CachedReference");
}
}
}
private static void generateMethodsNativePointers(PrintWriter writer, Collection methods) {
for (MethodDeclaration method : methods) {
if ( method.getAnnotation(Alternate.class) == null )
generateMethodNativePointers(writer, method);
}
}
private static void generateMethodNativePointers(PrintWriter writer, MethodDeclaration method) {
if ( method.getAnnotation(Extern.class) == null )
writer.print("static ");
writer.println(Utils.getTypedefName(method) + " " + method.getSimpleName() + ";");
}
private void generateJavaSource(InterfaceDeclaration d, PrintWriter java_writer) throws IOException {
java_writer.println("/* MACHINE GENERATED FILE, DO NOT EDIT */");
java_writer.println();
java_writer.println("package " + d.getPackage().getQualifiedName() + ";");
java_writer.println();
java_writer.println("import org.lwjgl.*;");
java_writer.println("import java.nio.*;");
Imports imports = d.getAnnotation(Imports.class);
if ( imports != null ) {
for ( String i : imports.value() )
java_writer.println("import " + i + ";");
}
java_writer.println();
Utils.printDocComment(java_writer, d);
if ( d.getAnnotation(Private.class) == null )
java_writer.print("public ");
boolean is_final = Utils.isFinal(d);
if (is_final)
java_writer.write("final ");
java_writer.print("class " + Utils.getSimpleClassName(d));
Collection super_interfaces = d.getSuperinterfaces();
if (super_interfaces.size() > 1)
throw new RuntimeException(d + " extends more than one interface");
if (super_interfaces.size() == 1) {
InterfaceDeclaration super_interface = super_interfaces.iterator().next().getDeclaration();
java_writer.print(" extends " + Utils.getSimpleClassName(super_interface));
}
java_writer.println(" {");
FieldsGenerator.generateFields(java_writer, d.getFields());
java_writer.println();
if (is_final) {
// Write private constructor to avoid instantiation
java_writer.println("\tprivate " + Utils.getSimpleClassName(d) + "() {}");
}
if (d.getMethods().size() > 0 && !context_specific) {
java_writer.println();
java_writer.println("\tstatic native void " + Utils.STUB_INITIALIZER_NAME + "() throws LWJGLException;");
}
JavaMethodsGenerator.generateMethodsJava(env, type_map, java_writer, d, generate_error_checks, context_specific);
java_writer.println("}");
java_writer.close();
String qualified_interface_name = Utils.getQualifiedClassName(d);
env.getMessager().printNotice("Generated class " + qualified_interface_name);
}
private void generateNativeSource(InterfaceDeclaration d) throws IOException {
String qualified_interface_name = Utils.getQualifiedClassName(d);
String qualified_native_name = Utils.getNativeQualifiedName(qualified_interface_name)+ ".c";
PrintWriter native_writer = env.getFiler().createTextFile(Filer.Location.CLASS_TREE, "", new File(qualified_native_name), "UTF-8");
native_writer.println("/* MACHINE GENERATED FILE, DO NOT EDIT */");
native_writer.println();
native_writer.println("#include ");
type_map.printNativeIncludes(native_writer);
native_writer.println();
TypedefsGenerator.generateNativeTypedefs(type_map, native_writer, d.getMethods());
native_writer.println();
if (!context_specific) {
generateMethodsNativePointers(native_writer, d.getMethods());
native_writer.println();
}
NativeMethodStubsGenerator.generateNativeMethodStubs(env, type_map, native_writer, d, generate_error_checks, context_specific);
if (!context_specific) {
native_writer.print("JNIEXPORT void JNICALL " + Utils.getQualifiedNativeMethodName(qualified_interface_name, Utils.STUB_INITIALIZER_NAME));
native_writer.println("(JNIEnv *env, jclass clazz) {");
native_writer.println("\tJavaMethodAndExtFunction functions[] = {");
RegisterStubsGenerator.generateMethodsNativeStubBind(native_writer, d, generate_error_checks, context_specific);
native_writer.println("\t};");
native_writer.println("\tint num_functions = NUMFUNCTIONS(functions);");
native_writer.print("\t");
native_writer.print(type_map.getRegisterNativesFunctionName());
native_writer.println("(env, clazz, num_functions, functions);");
native_writer.println("}");
}
native_writer.close();
env.getMessager().printNotice("Generated C source " + qualified_interface_name);
}
public void visitInterfaceDeclaration(InterfaceDeclaration d) {
final File input = d.getPosition().file();
final File outputJava = new File(env.getOptions().get("-s") + '/' + d.getPackage().getQualifiedName().replace('.', '/'), Utils.getSimpleClassName(d) + ".java");
PrintWriter java_writer = null;
try {
final Collection methods = d.getMethods();
if ( methods.size() == 0 && d.getFields().size() == 0 )
return;
// Skip this class if the output exists and the input has not been modified.
if ( outputJava.exists() && Math.max(input.lastModified(), generatorLM) < outputJava.lastModified() )
return;
for ( final MethodDeclaration method : methods )
validateMethod(method);
java_writer = env.getFiler().createTextFile(Filer.Location.SOURCE_TREE, d.getPackage().getQualifiedName(), new File(Utils.getSimpleClassName(d) + ".java"), null);
generateJavaSource(d, java_writer);
if ( methods.size() > 0 ) {
boolean hasNative = false;
for ( final MethodDeclaration method : methods ) {
Alternate alt_annotation = method.getAnnotation(Alternate.class);
if ( (alt_annotation == null || alt_annotation.nativeAlt()) && method.getAnnotation(Reuse.class) == null ) {
hasNative = true;
break;
}
}
if ( !hasNative )
return;
final String outputPath = env.getOptions().get("-d") + '/' + Utils.getNativeQualifiedName(Utils.getQualifiedClassName(d));
final File outputNative = new File(outputPath + ".c");
final File outputBackup = new File(outputPath + "_backup.c");
// If the native file exists, rename.
final ByteBuffer nativeBefore;
if ( outputNative.exists() ) {
nativeBefore = readFile(outputNative);
outputNative.renameTo(outputBackup);
} else
nativeBefore = null;
try {
generateNativeSource(d);
// If the native file did exist, compare with the new file. If they're the same,
// reset the last modified time to avoid ridiculous C compilation times.
if ( nativeBefore != null && outputNative.length() == nativeBefore.capacity() ) {
final ByteBuffer nativeAfter = readFile(outputNative);
boolean same = true;
for ( int i = nativeBefore.position(); i < nativeBefore.limit(); i++ ) {
if ( nativeBefore.get(i) != nativeAfter.get(i) ) {
same = false;
break;
}
}
if ( same ) {
outputNative.delete();
outputBackup.renameTo(outputNative);
}
}
} finally {
if ( outputBackup.exists() )
outputBackup.delete();
}
}
} catch (Exception e) {
// If anything goes wrong mid-gen, delete output to allow regen next time we run.
if ( java_writer != null ) java_writer.close();
if ( outputJava.exists() ) outputJava.delete();
throw new RuntimeException(e);
}
}
private static ByteBuffer readFile(final File file) throws IOException {
final FileChannel channel = new FileInputStream(file).getChannel();
final long bytesTotal = channel.size();
final ByteBuffer buffer = ByteBuffer.allocateDirect((int)bytesTotal);
long bytesRead = 0;
do {
bytesRead += channel.read(buffer);
} while ( bytesRead < bytesTotal );
buffer.flip();
channel.close();
return buffer;
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/NoErrorCheck.java 0000644 0001750 0001750 00000003732 11543426510 023476 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* This annotation implies that a method should not include
* error checking even if it is enabled.
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: NoErrorCheck.java 2983 2008-04-07 18:36:09Z matzon $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target(ElementType.METHOD)
public @interface NoErrorCheck {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/NativeMethodStubsGenerator.java 0000644 0001750 0001750 00000046323 11543426510 026434 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* This class generates the functions in the native source files.
*
* @author elias_naur
* @version $Revision: 3418 $
* $Id: NativeMethodStubsGenerator.java 3418 2010-09-28 21:11:35Z spasi $
*/
import org.lwjgl.PointerBuffer;
import com.sun.mirror.apt.*;
import com.sun.mirror.declaration.*;
import com.sun.mirror.type.*;
import java.io.*;
import java.util.*;
import java.nio.*;
public class NativeMethodStubsGenerator {
private static final String BUFFER_ADDRESS_POSTFIX = "_address";
public static final String BUFFER_POSITION_POSTFIX = "_position";
private static final String STRING_LIST_NAME = "_str";
private static final String POINTER_LIST_NAME = "_ptr";
public static void generateNativeMethodStubs(AnnotationProcessorEnvironment env, TypeMap type_map, PrintWriter writer, InterfaceDeclaration d, boolean generate_error_checks, boolean context_specific) {
for (MethodDeclaration method : d.getMethods()) {
Alternate alt_annotation = method.getAnnotation(Alternate.class);
if ( (alt_annotation != null && (!alt_annotation.nativeAlt() || alt_annotation.skipNative())) || method.getAnnotation(Reuse.class) != null )
continue;
generateMethodStub(env, type_map, writer, Utils.getQualifiedClassName(d), method, Mode.NORMAL, generate_error_checks, context_specific);
if (Utils.hasMethodBufferObjectParameter(method))
generateMethodStub(env, type_map, writer, Utils.getQualifiedClassName(d), method, Mode.BUFFEROBJECT, generate_error_checks, context_specific);
}
}
private static void generateParameters(PrintWriter writer, Collection params, Mode mode) {
for (ParameterDeclaration param : params) {
if ( param.getAnnotation(Result.class) != null || (param.getAnnotation(Helper.class) != null && !param.getAnnotation(Helper.class).passToNative()) )
continue;
final Constant constant_annotation = param.getAnnotation(Constant.class);
if ( constant_annotation == null || !constant_annotation.isNative() )
generateParameter(writer, param, mode);
}
}
private static void generateParameter(PrintWriter writer, ParameterDeclaration param, Mode mode) {
writer.print(", ");
if (mode == Mode.BUFFEROBJECT && param.getAnnotation(BufferObject.class) != null) {
writer.print("jlong " + param.getSimpleName() + Utils.BUFFER_OBJECT_PARAMETER_POSTFIX);
} else if ( param.getAnnotation(PointerWrapper.class) != null ) {
writer.print("jlong " + param.getSimpleName());
} else {
JNITypeTranslator translator = new JNITypeTranslator();
param.getType().accept(translator);
writer.print(translator.getSignature() + " " + param.getSimpleName());
if (Utils.getNIOBufferType(param.getType()) != null)
writer.print(", jint " + param.getSimpleName() + BUFFER_POSITION_POSTFIX);
}
}
private static void generateMethodStub(AnnotationProcessorEnvironment env, TypeMap type_map, PrintWriter writer, String interface_name, MethodDeclaration method, Mode mode, boolean generate_error_checks, boolean context_specific) {
if ( !context_specific && method.getAnnotation(Alternate.class) == null )
writer.print("static ");
else
writer.print("JNIEXPORT ");
final TypeMirror result_type = Utils.getMethodReturnType(method);
final CachedResult cached_result_annotation = method.getAnnotation(CachedResult.class);
final AutoSize auto_size_annotation = method.getAnnotation(AutoSize.class);
if ( method.getAnnotation(PointerWrapper.class) != null ) {
writer.print("jlong");
} else {
JNITypeTranslator translator = new JNITypeTranslator();
result_type.accept(translator);
writer.print(translator.getSignature());
}
writer.print(" JNICALL ");
writer.print(Utils.getQualifiedNativeMethodName(interface_name, method, generate_error_checks, context_specific));
if (mode == Mode.BUFFEROBJECT)
writer.print(Utils.BUFFER_OBJECT_METHOD_POSTFIX);
writer.print("(JNIEnv *env, jclass clazz");
generateParameters(writer, method.getParameters(), mode);
if (Utils.getNIOBufferType(result_type) != null) {
if ( (cached_result_annotation == null || !cached_result_annotation.isRange()) && (auto_size_annotation == null || !auto_size_annotation.isNative()) )
writer.print(", jlong " + Utils.RESULT_SIZE_NAME);
if (cached_result_annotation != null)
writer.print(", jobject " + Utils.CACHED_BUFFER_NAME);
}
if (context_specific) {
writer.print(", jlong " + Utils.FUNCTION_POINTER_VAR_NAME);
}
writer.println(") {");
generateBufferParameterAddresses(type_map, writer, method, mode);
Alternate alt_annotation = method.getAnnotation(Alternate.class);
if (context_specific) {
String typedef_name = Utils.getTypedefName(method);
writer.print("\t" + typedef_name + " " + (alt_annotation == null ? method.getSimpleName() : alt_annotation.value()));
writer.print(" = (" + typedef_name + ")((intptr_t)");
writer.println(Utils.FUNCTION_POINTER_VAR_NAME + ");");
}
final Code code_annotation = method.getAnnotation(Code.class);
final boolean hasResult = !result_type.equals(env.getTypeUtils().getVoidType());
final boolean resultPreDeclare = hasResult && (hasPointerArrayInits(method.getParameters()) || (code_annotation != null && (code_annotation.nativeAfterVars().length() > 0 || code_annotation.nativeBeforeCall().length() > 0)));
if ( resultPreDeclare )
printResultParam(type_map, writer, method, result_type, true);
if ( code_annotation != null && code_annotation.nativeAfterVars().length() > 0 )
writer.println(code_annotation.nativeAfterVars());
generatePointerArrayInits(type_map, writer, method.getParameters());
if ( code_annotation != null && code_annotation.nativeBeforeCall().length() > 0 )
writer.println(code_annotation.nativeBeforeCall());
writer.print("\t");
if ( resultPreDeclare )
writer.print(Utils.RESULT_VAR_NAME + " = ");
else if ( hasResult )
printResultParam(type_map, writer, method, result_type, false);
writer.print((alt_annotation == null ? method.getSimpleName() : alt_annotation.value()) + "(");
generateCallParameters(writer, type_map, method.getParameters());
writer.print(")");
writer.println(";");
if ( code_annotation != null && code_annotation.nativeAfterCall().length() > 0 )
writer.println(code_annotation.nativeAfterCall());
generateStringDeallocations(writer, method.getParameters());
if (!result_type.equals(env.getTypeUtils().getVoidType())) {
writer.print("\treturn ");
Class java_result_type = Utils.getJavaType(result_type);
if (Buffer.class.isAssignableFrom(java_result_type)) {
if (cached_result_annotation != null)
writer.print("safeNewBufferCached(env, ");
else
writer.print("safeNewBuffer(env, ");
} else if (String.class.equals(java_result_type)) {
writer.print("NewStringNativeUnsigned(env, ");
} else if ( method.getAnnotation(PointerWrapper.class) != null ) {
writer.print("(intptr_t)");
}
writer.print(Utils.RESULT_VAR_NAME);
if (Buffer.class.isAssignableFrom(java_result_type)) {
final String size_parameter_name;
if ( auto_size_annotation != null && (auto_size_annotation.isNative() || (cached_result_annotation != null && cached_result_annotation.isRange())) )
size_parameter_name = auto_size_annotation.value();
else
size_parameter_name = Utils.RESULT_SIZE_NAME;
writer.print(", ");
Utils.printExtraCallArguments(writer, method, size_parameter_name);
}
if (Buffer.class.isAssignableFrom(java_result_type) ||
String.class.equals(java_result_type))
writer.print(")");
writer.println(";");
}
writer.println("}");
writer.println();
}
private static void printResultParam(final TypeMap type_map, final PrintWriter writer, final MethodDeclaration method, final TypeMirror result_type, final boolean preDeclare) {
final ParameterDeclaration result_param = Utils.getResultParameter(method);
final Declaration return_declaration = result_param == null ? method : result_param;
final NativeTypeTranslator result_translator = new NativeTypeTranslator(type_map, return_declaration);
result_type.accept(result_translator);
if ( preDeclare )
writer.print("\t");
writer.print(result_translator.getSignature() + " " + Utils.RESULT_VAR_NAME);
if ( preDeclare)
writer.println(";");
else
writer.print(result_param == null ? " = " : ";\n\t");
}
private static void generateCallParameters(PrintWriter writer, TypeMap type_map, Collection params) {
if (params.size() > 0) {
boolean first = true;
for ( ParameterDeclaration param : params ) {
if ( param.getAnnotation(Helper.class) != null )
continue;
if ( first )
first = false;
else
writer.print(", ");
generateCallParameter(writer, type_map, param);
}
}
}
private static void generateCallParameter(PrintWriter writer, TypeMap type_map, ParameterDeclaration param) {
if ( param.getAnnotation(Helper.class) != null )
return;
final Constant constant_annotation = param.getAnnotation(Constant.class);
if ( constant_annotation != null && constant_annotation.isNative() ) {
writer.print(constant_annotation.value());
return;
}
boolean is_indirect = param.getAnnotation(Indirect.class) != null;
if (is_indirect || param.getAnnotation(PointerArray.class) != null) {
writer.print("(");
final NativeTypeTranslator translator = new NativeTypeTranslator(type_map, param);
param.getType().accept(translator);
writer.print(translator.getSignature());
writer.print("*)");
}
if ( param.getAnnotation(PointerWrapper.class) != null )
writer.print("(" + param.getAnnotation(PointerWrapper.class).value() + ")(intptr_t)");
if (param.getAnnotation(Result.class) != null || is_indirect)
writer.print("&");
if ( param.getAnnotation(Result.class) != null ) {
writer.print(Utils.RESULT_VAR_NAME);
} else {
writer.print(param.getSimpleName());
if ( param.getAnnotation(PointerArray.class) != null )
writer.print(getPointerArrayName(Utils.getJavaType(param.getType())));
else if ( Utils.isAddressableType(param.getType()) )
writer.print(BUFFER_ADDRESS_POSTFIX);
}
}
private static void generateStringDeallocations(PrintWriter writer, Collection params) {
for (ParameterDeclaration param : params) {
final Class java_type = Utils.getJavaType(param.getType());
if ( java_type.equals(String.class) && param.getAnnotation(Result.class) == null )
writer.println("\tfree(" + param.getSimpleName() + BUFFER_ADDRESS_POSTFIX + ");");
else if (param.getAnnotation(PointerArray.class) != null ) // Free the string array mem
writer.println("\tfree(" + param.getSimpleName() + getPointerArrayName(java_type) + ");");
}
}
private static void generateBufferParameterAddresses(TypeMap type_map, PrintWriter writer, MethodDeclaration method, Mode mode) {
strLoopDeclared = false;
ptrLoopDeclared = false;
for ( ParameterDeclaration param : method.getParameters() ) {
final Constant constant_annotation = param.getAnnotation(Constant.class);
if ( param.getAnnotation(Result.class) == null && (constant_annotation == null || !constant_annotation.isNative()) && Utils.isAddressableType(param.getType()))
generateBufferParameterAddress(type_map, writer, method, param, mode);
}
}
private static boolean strLoopDeclared;
private static boolean ptrLoopDeclared;
private static void generateBufferParameterAddress(TypeMap type_map, PrintWriter writer, MethodDeclaration method, ParameterDeclaration param, Mode mode) {
final Check check_annotation = param.getAnnotation(Check.class);
final PointerArray array_annotation = param.getAnnotation(PointerArray.class);
final Class java_type = Utils.getJavaType(param.getType());
final NativeTypeTranslator translator = new NativeTypeTranslator(type_map, param);
param.getType().accept(translator);
final String native_type = translator.getSignature();
if ( !java_type.isArray() || CharSequence.class.isAssignableFrom(java_type.getComponentType()) ) {
writer.print("\t" + native_type + param.getSimpleName());
writer.print(BUFFER_ADDRESS_POSTFIX + " = ((");
writer.print(native_type);
writer.print(")");
if (mode == Mode.BUFFEROBJECT && param.getAnnotation(BufferObject.class) != null) {
writer.print("offsetToPointer(" + param.getSimpleName() + Utils.BUFFER_OBJECT_PARAMETER_POSTFIX + "))");
} else {
if (Buffer.class.isAssignableFrom(java_type) || java_type.equals(CharSequence.class) || java_type.equals(CharSequence[].class) || PointerBuffer.class.isAssignableFrom(java_type) ) {
boolean explicitly_byte_sized = java_type.equals(Buffer.class) ||
translator.getAnnotationType().equals(type_map.getVoidType()) ||
param.getAnnotation(NativeType.class) != null;
if (explicitly_byte_sized)
writer.print("(((char *)");
if (method.getAnnotation(GenerateAutos.class) != null || (check_annotation != null && check_annotation.canBeNull())) {
writer.print("safeGetBufferAddress(env, " + param.getSimpleName());
} else {
writer.print("(*env)->GetDirectBufferAddress(env, " + param.getSimpleName());
}
writer.print("))");
writer.print(" + " + param.getSimpleName() + BUFFER_POSITION_POSTFIX);
if (explicitly_byte_sized)
writer.print("))");
} else if (java_type.equals(String.class)) {
writer.print("GetStringNativeChars(env, " + param.getSimpleName() + "))");
} else if ( array_annotation == null )
throw new RuntimeException("Illegal type " + java_type);
}
writer.println(";");
}
if ( array_annotation != null ) {
final String n = getPointerArrayName(java_type);
final String arrayType;
if ( POINTER_LIST_NAME.equals(n) ) {
if ( n.equals(param.getSimpleName()) )
throw new RuntimeException("The name '" + n + "' is not valid for object array arguments annotated with PointerArray");
arrayType = translator.getSignature(true) + (org.lwjgl.PointerWrapper.class.isAssignableFrom(java_type.getComponentType()) ? " " : "");
// Declare loop counters and allocate object array
if ( !ptrLoopDeclared ) {
writer.println("\tunsigned int " + n + "_i;");
writer.println("\tjobject " + n + "_object;");
ptrLoopDeclared = true;
}
} else {
if ( n.equals(param.getSimpleName()) )
throw new RuntimeException("The name '" + n + "' is not valid for arguments annotated with PointerArray");
arrayType = translator.getSignature(true);
// Declare loop counters and allocate string array
if ( !strLoopDeclared ) {
writer.println("\tunsigned int " + n + "_i;");
writer.println("\t" + arrayType + n + "_address;");
strLoopDeclared = true;
}
}
writer.print("\t" + arrayType + "*" + param.getSimpleName() + n + " = ");
if ( check_annotation != null && check_annotation.canBeNull() )
writer.print(array_annotation.value() + " == 0 ? NULL : ");
writer.println("(" + arrayType + "*) malloc(" + array_annotation.value() + " * sizeof(" + arrayType + "));");
}
}
private static String getPointerArrayName(final Class java_type) {
final Class component_type = java_type.getComponentType();
if ( component_type != null && (Buffer.class.isAssignableFrom(component_type) || org.lwjgl.PointerWrapper.class.isAssignableFrom(component_type)) )
return POINTER_LIST_NAME;
else
return STRING_LIST_NAME;
}
private static boolean hasPointerArrayInits(Collection params) {
for ( ParameterDeclaration param : params ) {
PointerArray pointerArray_annotation = param.getAnnotation(PointerArray.class);
if ( pointerArray_annotation != null )
return true;
}
return false;
}
private static void generatePointerArrayInits(TypeMap type_map, PrintWriter writer, Collection params) {
for ( ParameterDeclaration param : params ) {
PointerArray pointerArray_annotation = param.getAnnotation(PointerArray.class);
if ( pointerArray_annotation != null ) {
final Class java_type = Utils.getJavaType(param.getType());
final Class component_type = java_type.isArray() ? java_type.getComponentType() : null;
final NativeTypeTranslator translator = new NativeTypeTranslator(type_map, param);
param.getType().accept(translator);
final String n = getPointerArrayName(java_type);
if ( POINTER_LIST_NAME.equals(n) ) {
// Init vars
writer.println("\t" + n + "_i = 0;");
// Fill pointer array with the buffer pointers
writer.println("\twhile ( " + n + "_i < " + pointerArray_annotation.value() + " ) {");
if ( component_type.isAssignableFrom(Buffer.class) )
writer.println("\t\t" + n + "_object = (*env)->GetObjectArrayElement(env, " + param.getSimpleName() + ", " + n + "_i);");
else
writer.println("\t\t" + n + "_object = (*env)->GetObjectArrayElement(env, " + param.getSimpleName() + ", " + n + "_i);");
writer.println("\t\t" + param.getSimpleName() + n + "[" + n + "_i++] = (" + translator.getSignature(true) + ")(intptr_t)getPointerWrapperAddress(env, " + n + "_object);");
writer.println("\t}");
} else {
final String lengths = pointerArray_annotation.lengths();
// Init vars
writer.println("\t" + n + "_i = 0;");
writer.println("\t" + n + "_address = (" + translator.getSignature(true) + ")" + param.getSimpleName() + BUFFER_ADDRESS_POSTFIX + ";");
// Fill string array with the string pointers
writer.println("\twhile ( " + n + "_i < " + pointerArray_annotation.value() + " ) {");
if ( lengths.length() == 0 ) {
writer.println("\t\t" + param.getSimpleName() + n + "[" + n + "_i++] = " + n + "_address;");
writer.println("\t\t" + n + "_address += strlen(" + n + "_address) + 1;");
} else {
writer.println("\t\t" + param.getSimpleName() + n + "[" + n + "_i] = " + n + "_address;");
writer.println("\t\t" + n + "_address += " + lengths + BUFFER_ADDRESS_POSTFIX + "[" + n + "_i++];");
}
writer.println("\t}");
}
}
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Extern.java 0000644 0001750 0001750 00000003613 11543426510 022415 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
/**
* Functions marked with @Extern will not be declared as static in the C implementation.
* This allows other source files to call them.
*
* @author Spasi
*/
@Target(ElementType.METHOD)
public @interface Extern {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Check.java 0000644 0001750 0001750 00000003674 11543426510 022174 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* @author elias_naur
* @version $Revision: 3412 $
* $Id: Check.java 3412 2010-09-26 23:43:24Z spasi $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface Check {
String value() default "";
boolean canBeNull() default false;
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Utils.java 0000644 0001750 0001750 00000044547 11543426510 022263 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* Various utility methods to the generator.
*
* @author elias_naur
* @version $Revision: 3443 $
* $Id: Utils.java 3443 2010-10-12 21:13:03Z spasi $
*/
import org.lwjgl.PointerBuffer;
import org.lwjgl.util.generator.opengl.GLboolean;
import org.lwjgl.util.generator.opengl.GLchar;
import org.lwjgl.util.generator.opengl.GLcharARB;
import org.lwjgl.util.generator.opengl.GLreturn;
import java.io.PrintWriter;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.util.*;
import com.sun.mirror.declaration.*;
import com.sun.mirror.type.PrimitiveType;
import com.sun.mirror.type.TypeMirror;
public class Utils {
public static final String TYPEDEF_POSTFIX = "PROC";
public static final String FUNCTION_POINTER_VAR_NAME = "function_pointer";
public static final String FUNCTION_POINTER_POSTFIX = "_pointer";
public static final String CHECKS_CLASS_NAME = "GLChecks";
public static final String CONTEXT_CAPS_CLASS_NAME = "ContextCapabilities";
public static final String STUB_INITIALIZER_NAME = "initNativeStubs";
public static final String BUFFER_OBJECT_METHOD_POSTFIX = "BO";
public static final String BUFFER_OBJECT_PARAMETER_POSTFIX = "_buffer_offset";
public static final String RESULT_SIZE_NAME = "result_size";
public static final String RESULT_VAR_NAME = "__result";
public static final String CACHED_BUFFER_LENGTH_NAME = "length";
public static final String CACHED_BUFFER_NAME = "old_buffer";
private static final String OVERLOADED_METHOD_PREFIX = "n";
public static String getTypedefName(MethodDeclaration method) {
Alternate alt_annotation = method.getAnnotation(Alternate.class);
return (alt_annotation == null ? method.getSimpleName() : alt_annotation.value()) + TYPEDEF_POSTFIX;
}
public static String getFunctionAddressName(InterfaceDeclaration interface_decl, MethodDeclaration method) {
return getFunctionAddressName(interface_decl, method, false);
}
public static String getFunctionAddressName(InterfaceDeclaration interface_decl, MethodDeclaration method, boolean forceAlt) {
final Alternate alt_annotation = method.getAnnotation(Alternate.class);
/* Removed prefix so that we can identify reusable entry points, removed postfix because it's not needed and looks nicer.
String interfaceName = interface_decl.getSimpleName(); // If we add this back, we need to fix @Reuse (add a param for the template name)
if ( alt_annotation == null || (alt_annotation.nativeAlt() && !forceAlt) )
return interfaceName + "_" + method.getSimpleName() + FUNCTION_POINTER_POSTFIX;
else
return interfaceName + "_" + alt_annotation.value() + FUNCTION_POINTER_POSTFIX;
*/
if ( alt_annotation == null || (alt_annotation.nativeAlt() && !forceAlt) )
return method.getSimpleName();
else
return alt_annotation.value();
}
public static boolean isFinal(InterfaceDeclaration d) {
Extension extension_annotation = d.getAnnotation(Extension.class);
return extension_annotation == null || extension_annotation.isFinal();
}
private static class AnnotationMirrorComparator implements Comparator {
public int compare(AnnotationMirror a1, AnnotationMirror a2) {
String n1 = a1.getAnnotationType().getDeclaration().getQualifiedName();
String n2 = a2.getAnnotationType().getDeclaration().getQualifiedName();
int result = n1.compareTo(n2);
return result;
}
public boolean equals(AnnotationMirror a1, AnnotationMirror a2) {
return compare(a1, a2) == 0;
}
}
public static Collection getSortedAnnotations(Collection annotations) {
List annotation_list = new ArrayList(annotations);
Collections.sort(annotation_list, new AnnotationMirrorComparator());
return annotation_list;
}
public static String getReferenceName(InterfaceDeclaration interface_decl, MethodDeclaration method, ParameterDeclaration param) {
return interface_decl.getSimpleName() + "_" + method.getSimpleName() + "_" + param.getSimpleName();
}
public static boolean isAddressableType(TypeMirror type) {
return isAddressableType(getJavaType(type));
}
public static boolean isAddressableType(Class type) {
if ( type.isArray() ) {
final Class component_type = type.getComponentType();
return isAddressableTypeImpl(component_type) || org.lwjgl.PointerWrapper.class.isAssignableFrom(component_type);
}
return isAddressableTypeImpl(type);
}
private static boolean isAddressableTypeImpl(Class type) {
return Buffer.class.isAssignableFrom(type) || PointerBuffer.class.isAssignableFrom(type) || CharSequence.class.isAssignableFrom(type);
}
public static Class getJavaType(TypeMirror type_mirror) {
JavaTypeTranslator translator = new JavaTypeTranslator();
type_mirror.accept(translator);
return translator.getType();
}
private static boolean hasParameterMultipleTypes(ParameterDeclaration param) {
int num_native_annotations = 0;
for (AnnotationMirror annotation : param.getAnnotationMirrors())
if (NativeTypeTranslator.getAnnotation(annotation, NativeType.class) != null)
num_native_annotations++;
return num_native_annotations > 1;
}
public static boolean isParameterMultiTyped(ParameterDeclaration param) {
boolean result = Buffer.class.equals(Utils.getJavaType(param.getType()));
if (!result && hasParameterMultipleTypes(param))
throw new RuntimeException(param + " not defined as java.nio.Buffer but has multiple types");
return result;
}
public static ParameterDeclaration findParameter(MethodDeclaration method, String name) {
for (ParameterDeclaration param : method.getParameters())
if (param.getSimpleName().equals(name))
return param;
throw new RuntimeException("Parameter " + name + " not found");
}
public static void printDocComment(PrintWriter writer, Declaration decl) {
final String overloadsComment;
if ( (decl instanceof MethodDeclaration) && decl.getAnnotation(Alternate.class) != null )
overloadsComment = "Overloads " + decl.getAnnotation(Alternate.class).value() + ".";
else
overloadsComment = null;
String doc_comment = decl.getDocComment();
if (doc_comment != null) {
final String tab = decl instanceof InterfaceDeclaration ? "" : "\t";
writer.println(tab + "/**");
if ( overloadsComment != null ) {
writer.println("\t * " + overloadsComment);
writer.println("\t * ");
}
final StringTokenizer doc_lines = new StringTokenizer(doc_comment, "\n", true);
boolean lastWasNL = false;
while (doc_lines.hasMoreTokens()) {
final String t = doc_lines.nextToken();
if ( "\n".equals(t) ) {
if ( lastWasNL )
writer.println(tab + " *
");
lastWasNL = true;
} else {
writer.println(tab + " * " + t);
lastWasNL = false;
}
}
writer.println(tab + " */");
} else if ( overloadsComment != null )
writer.println("\t/** " + overloadsComment + " */");
}
public static AnnotationMirror getParameterAutoAnnotation(ParameterDeclaration param) {
for (AnnotationMirror annotation : param.getAnnotationMirrors())
if (NativeTypeTranslator.getAnnotation(annotation, Auto.class) != null)
return annotation;
return null;
}
// DISABLED: We always generate indirect methods. (affects OpenAL only at the time of this change)
public static boolean isMethodIndirect(boolean generate_error_checks, boolean context_specific, MethodDeclaration method) {
/*
for (ParameterDeclaration param : method.getParameters()) {
if (isAddressableType(param.getType()) || getParameterAutoAnnotation(param) != null ||
param.getAnnotation(Constant.class) != null)
return true;
}
return hasMethodBufferObjectParameter(method) || method.getAnnotation(Code.class) != null ||
method.getAnnotation(CachedResult.class) != null ||
(generate_error_checks && method.getAnnotation(NoErrorCheck.class) == null) ||
context_specific;
*/
return true;
}
public static String getNativeQualifiedName(String qualified_name) {
return qualified_name.replaceAll("\\.", "_");
}
public static String getQualifiedNativeMethodName(String qualified_class_name, String method_name) {
return "Java_" + getNativeQualifiedName(qualified_class_name) + "_" + method_name;
}
public static String getQualifiedNativeMethodName(String qualified_class_name, MethodDeclaration method, boolean generate_error_checks, boolean context_specific) {
String method_name = getSimpleNativeMethodName(method, generate_error_checks, context_specific);
return getQualifiedNativeMethodName(qualified_class_name, method_name);
}
public static ParameterDeclaration getResultParameter(MethodDeclaration method) {
ParameterDeclaration result_param = null;
for (ParameterDeclaration param : method.getParameters()) {
if (param.getAnnotation(Result.class) != null) {
if (result_param != null)
throw new RuntimeException("Multiple parameters annotated with Result in method " + method);
result_param = param;
}
}
return result_param;
}
public static TypeMirror getMethodReturnType(MethodDeclaration method) {
TypeMirror result_type;
ParameterDeclaration result_param = getResultParameter(method);
if (result_param != null) {
result_type = result_param.getType();
} else
result_type = method.getReturnType();
return result_type;
}
public static String getMethodReturnType(MethodDeclaration method, GLreturn return_annotation, boolean buffer) {
ParameterDeclaration return_param = null;
for ( ParameterDeclaration param : method.getParameters() ) {
if ( param.getSimpleName().equals(return_annotation.value()) ) {
return_param = param;
break;
}
}
if ( return_param == null )
throw new RuntimeException("The @GLreturn parameter \"" + return_annotation.value() + "\" could not be found in method: " + method);
PrimitiveType.Kind kind = NativeTypeTranslator.getPrimitiveKindFromBufferClass(Utils.getJavaType(return_param.getType()));
if ( return_param.getAnnotation(GLboolean.class) != null )
kind = PrimitiveType.Kind.BOOLEAN;
if ( kind == PrimitiveType.Kind.BYTE && (return_param.getAnnotation(GLchar.class) != null || return_param.getAnnotation(GLcharARB.class) != null) )
return "String";
else {
final String type = JavaTypeTranslator.getPrimitiveClassFromKind(kind).getName();
return buffer ? Character.toUpperCase(type.charAt(0)) + type.substring(1) : type;
}
}
public static boolean needResultSize(MethodDeclaration method) {
return getNIOBufferType(getMethodReturnType(method)) != null && method.getAnnotation(AutoSize.class) == null;
}
public static void printExtraCallArguments(PrintWriter writer, MethodDeclaration method, String size_parameter_name) {
writer.print(size_parameter_name);
if (method.getAnnotation(CachedResult.class) != null) {
writer.print(", " + CACHED_BUFFER_NAME);
}
}
private static String getClassName(InterfaceDeclaration interface_decl, String opengl_name) {
Extension extension_annotation = interface_decl.getAnnotation(Extension.class);
if (extension_annotation != null && !"".equals(extension_annotation.className())) {
return extension_annotation.className();
}
StringBuilder result = new StringBuilder();
for (int i = 0; i < opengl_name.length(); i++) {
int ch = opengl_name.codePointAt(i);
if (ch == '_') {
i++;
result.appendCodePoint(Character.toUpperCase(opengl_name.codePointAt(i)));
} else
result.appendCodePoint(ch);
}
return result.toString();
}
public static boolean hasMethodBufferObjectParameter(MethodDeclaration method) {
for (ParameterDeclaration param : method.getParameters()) {
if (param.getAnnotation(BufferObject.class) != null) {
return true;
}
}
return false;
}
public static String getQualifiedClassName(InterfaceDeclaration interface_decl) {
return interface_decl.getPackage().getQualifiedName() + "." + getSimpleClassName(interface_decl);
}
public static String getSimpleClassName(InterfaceDeclaration interface_decl) {
return getClassName(interface_decl, interface_decl.getSimpleName());
}
public static Class getNIOBufferType(TypeMirror t) {
Class param_type = getJavaType(t);
if (Buffer.class.isAssignableFrom(param_type))
return param_type;
else if ( param_type == CharSequence.class || param_type == CharSequence[].class || param_type == PointerBuffer.class )
return ByteBuffer.class;
else
return null;
}
public static String getSimpleNativeMethodName(MethodDeclaration method, boolean generate_error_checks, boolean context_specific) {
String method_name;
Alternate alt_annotation = method.getAnnotation(Alternate.class);
method_name = alt_annotation == null || alt_annotation.nativeAlt() ? method.getSimpleName() : alt_annotation.value();
if (isMethodIndirect(generate_error_checks, context_specific, method))
method_name = OVERLOADED_METHOD_PREFIX + method_name;
return method_name;
}
static boolean isReturnParameter(MethodDeclaration method, ParameterDeclaration param) {
GLreturn string_annotation = method.getAnnotation(GLreturn.class);
if ( string_annotation == null || !string_annotation.value().equals(param.getSimpleName()) )
return false;
if ( param.getAnnotation(OutParameter.class) == null )
throw new RuntimeException("The parameter specified in @GLreturn is not annotated with @OutParameter in method: " + method);
if ( param.getAnnotation(Check.class) != null )
throw new RuntimeException("The parameter specified in @GLreturn is annotated with @Check in method: " + method);
if ( param.getAnnotation(GLchar.class) != null && Utils.getJavaType(param.getType()).equals(ByteBuffer.class) && string_annotation.maxLength().length() == 0 )
throw new RuntimeException("The @GLreturn annotation is missing a maxLength parameter in method: " + method);
return true;
}
static String getStringOffset(MethodDeclaration method, ParameterDeclaration param) {
String offset = null;
for ( ParameterDeclaration p : method.getParameters() ) {
if ( param != null && p.getSimpleName().equals(param.getSimpleName()) )
break;
final Class type = Utils.getJavaType(p.getType());
if ( type.equals(CharSequence.class) ) {
if ( offset == null )
offset = p.getSimpleName() + ".length()";
else
offset += " + " + p.getSimpleName() + ".length()";
if ( p.getAnnotation(NullTerminated.class) != null ) offset += " + 1";
} else if ( type.equals(CharSequence[].class) ) {
if ( offset == null )
offset = "APIUtil.getTotalLength(" + p.getSimpleName() + ")";
else
offset += " + APIUtil.getTotalLength(" + p.getSimpleName() + ")";
if ( p.getAnnotation(NullTerminated.class) != null ) offset += " + " + p.getSimpleName() + ".length";
}
}
return offset;
}
static void printGLReturnPre(PrintWriter writer, MethodDeclaration method, GLreturn return_annotation) {
final String return_type = getMethodReturnType(method, return_annotation, true);
if ( "String".equals(return_type) ) {
if ( !return_annotation.forceMaxLength() ) {
writer.println("IntBuffer " + return_annotation.value() + "_length = APIUtil.getLengths();");
writer.print("\t\t");
}
writer.print("ByteBuffer " + return_annotation.value() + " = APIUtil.getBufferByte(" + return_annotation.maxLength());
/*
Params that use the return buffer will advance its position while filling it. When we return, the position will be
at the right spot for grabbing the returned string bytes. We only have to make sure that the original buffer was
large enough to hold everything, so that no re-allocations happen while filling.
*/
final String offset = getStringOffset(method, null);
if ( offset != null )
writer.print(" + " + offset);
writer.println(");");
} else {
final String buffer_type = "Boolean".equals(return_type) ? "Byte" : return_type;
writer.print(buffer_type + "Buffer " + return_annotation.value() + " = APIUtil.getBuffer" + buffer_type + "(");
if ( "Byte".equals(buffer_type) )
writer.print('1');
writer.println(");");
}
final Code code_annotation = method.getAnnotation(Code.class);
if ( code_annotation != null && code_annotation.tryBlock() ) {
writer.println("\t\ttry {");
writer.print("\t\t\t");
} else
writer.print("\t\t");
}
static void printGLReturnPost(PrintWriter writer, MethodDeclaration method, GLreturn return_annotation) {
final String return_type = getMethodReturnType(method, return_annotation, true);
if ( "String".equals(return_type) ) {
writer.print("\t\t" + return_annotation.value() + ".limit(");
final String offset = getStringOffset(method, null);
if ( offset != null)
writer.print(offset + " + ");
if ( return_annotation.forceMaxLength() )
writer.print(return_annotation.maxLength());
else
writer.print(return_annotation.value() + "_length.get(0)");
writer.println(");");
writer.println("\t\treturn APIUtil.getString(" + return_annotation.value() + ");");
} else {
writer.print("\t\treturn " + return_annotation.value() + ".get(0)");
if ( "Boolean".equals(return_type) )
writer.print(" == 1");
writer.println(";");
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Helper.java 0000644 0001750 0001750 00000003650 11543426510 022370 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
* Method parameters marked with @Helper will be considered Java-API
* parameters and will be ignored when generating native stubs/code.
*
* @author Spasi
*/
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target(ElementType.PARAMETER)
public @interface Helper {
boolean passToNative() default false;
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/AutoType.java 0000644 0001750 0001750 00000004022 11543426510 022715 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* Indicates that a parameter should be pre-computed according
* to the type of a Buffer parameter.
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: AutoType.java 2983 2008-04-07 18:36:09Z matzon $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Auto
@Target(ElementType.PARAMETER)
public @interface AutoType {
String value(); // The parameter to get the type from
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Result.java 0000644 0001750 0001750 00000003702 11543426510 022425 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* This annotation indicates that the method result is in the
* specified parameter.
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: Result.java 2983 2008-04-07 18:36:09Z matzon $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target(ElementType.PARAMETER)
public @interface Result {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Alternate.java 0000644 0001750 0001750 00000005035 11543426510 023067 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
/**
* When a method is annonated with @Alternate, no native stub will be created and the Java method will be renamed to value().
* This can be useful when we want to provide an alternate GL call with different arguments (created by different annotations)
*
* @author spasi
*/
@Target({ ElementType.METHOD })
public @interface Alternate {
/** This must match an existing GL method name. */
String value();
/** If true, an alternate Java->native call will be created. Useful when the alternate implementation uses different types. */
boolean nativeAlt() default false;
/** Applicable when nativeAlt is true. If true, no extra native call will be generated. Useful when there's another nativeAlt already defined. */
boolean skipNative() default false;
/** If true, the alternate method's name will be used for the Java call. */
boolean javaAlt() default false;
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Auto.java 0000644 0001750 0001750 00000003640 11543426510 022060 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* AutoType and AutoSize is annotated with @Auto.
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: Auto.java 2983 2008-04-07 18:36:09Z matzon $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target(ElementType.ANNOTATION_TYPE)
public @interface Auto {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/GeneratorProcessorFactory.java 0000644 0001750 0001750 00000013645 11543426510 026334 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
import java.io.File;
import java.io.FileFilter;
import java.util.Arrays;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import com.sun.mirror.apt.*;
import com.sun.mirror.declaration.AnnotationTypeDeclaration;
import com.sun.mirror.declaration.TypeDeclaration;
import static com.sun.mirror.util.DeclarationVisitors.*;
import static java.util.Collections.*;
/**
* Generator tool for creating the java classes and native code
* from an annotated template java interface.
*
* @author elias_naur
* @version $Revision: 3430 $
* $Id: GeneratorProcessorFactory.java 3430 2010-10-04 17:04:46Z spasi $
*/
public class GeneratorProcessorFactory implements AnnotationProcessorFactory, RoundCompleteListener {
private static boolean first_round = true;
// Process any set of annotations
private static final Collection supportedAnnotations =
unmodifiableCollection(Arrays.asList("*"));
private static final Collection supportedOptions =
unmodifiableCollection(Arrays.asList("-Atypemap", "-Ageneratechecks", "-Acontextspecific"));
public Collection supportedAnnotationTypes() {
return supportedAnnotations;
}
public Collection supportedOptions() {
return supportedOptions;
}
public void roundComplete(RoundCompleteEvent event) {
first_round = false;
}
public AnnotationProcessor getProcessorFor(Set atds, AnnotationProcessorEnvironment env) {
// Only process the initial types, not the generated ones
if ( first_round ) {
env.addListener(this);
return new GeneratorProcessor(env);
} else
return AnnotationProcessors.NO_OP;
}
private static class GeneratorProcessor implements AnnotationProcessor {
private final AnnotationProcessorEnvironment env;
GeneratorProcessor(AnnotationProcessorEnvironment env) {
this.env = env;
}
public void process() {
Map options = env.getOptions();
String typemap_classname = null;
boolean generate_error_checks = options.containsKey("-Ageneratechecks");
boolean context_specific = options.containsKey("-Acontextspecific");
for ( String k : options.keySet() ) {
int delimiter = k.indexOf('=');
if ( delimiter != -1 ) {
if ( k.startsWith("-Atypemap") ) {
typemap_classname = k.substring(delimiter + 1);
}
}
}
if ( typemap_classname == null )
throw new RuntimeException("No TypeMap class name specified with -Atypemap=");
TypeDeclaration lastFile = null;
try {
long generatorLM = getGeneratorLastModified();
TypeMap type_map = (TypeMap)(Class.forName(typemap_classname).newInstance());
for ( TypeDeclaration typedecl : env.getSpecifiedTypeDeclarations() ) {
lastFile = typedecl;
typedecl.accept(getDeclarationScanner(new GeneratorVisitor(env, type_map, generate_error_checks, context_specific, generatorLM), NO_OP));
}
} catch (Exception e) {
if ( lastFile == null )
throw new RuntimeException(e);
else
throw new RuntimeException("\n-- Failed to process template: " + lastFile.getQualifiedName() + " --", e);
}
}
/**
* Gets the time of the latest change on the Generator classes.
*
* @return time of the latest change
*/
private static long getGeneratorLastModified() {
long lastModified = getDirectoryLastModified("/bin/org/lwjgl/util/generator");
lastModified = Math.max(lastModified, getDirectoryLastModified("/bin/org/lwjgl/util/generator/openal"));
lastModified = Math.max(lastModified, getDirectoryLastModified("/bin/org/lwjgl/util/generator/opengl"));
lastModified = Math.max(lastModified, getDirectoryLastModified("/bin/org/lwjgl/util/generator/opencl"));
return lastModified;
}
private static long getDirectoryLastModified(final String path) {
final File pck = new File(System.getProperty("user.dir") + path);
if ( !pck.exists() || !pck.isDirectory() )
return Long.MAX_VALUE;
final File[] classes = pck.listFiles(new FileFilter() {
public boolean accept(final File pathname) {
return pathname.isFile() && pathname.getName().endsWith(".class");
}
});
if ( classes == null || classes.length == 0 )
return Long.MAX_VALUE;
long lastModified = 0;
for ( File clazz : classes ) {
long lm = clazz.lastModified();
if ( lastModified < lm )
lastModified = lm;
}
return lastModified;
}
}
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/DeprecatedGL.java 0000644 0001750 0001750 00000003726 11543426510 023440 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
* Use this annotation on extensions with deprecated functionality.
* Functions in such extensions marked with this annotation will not be loaded in a forward compatible context.
*
* @author spasi
*/
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target({ ElementType.TYPE, ElementType.METHOD })
public @interface DeprecatedGL {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/CachedReference.java 0000644 0001750 0001750 00000004347 11543426510 024143 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* This annotation indicates that a buffer parameter is cached by
* OpenGL.
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: CachedReference.java 2983 2008-04-07 18:36:09Z matzon $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target(ElementType.PARAMETER)
public @interface CachedReference {
/** If set then this will be used as array index for accessing the stored reference. */
String index() default "";
/** If set then this name will be used for the reference and the reference field will not be auto generated in References. */
String name() default "";
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/NativeType.java 0000644 0001750 0001750 00000003770 11543426510 023244 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* This annotation indicates that another annotation is
* a native type.
*
* @author elias_naur
* @version $Revision: 3412 $
* $Id: NativeType.java 3412 2010-09-26 23:43:24Z spasi $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target({ElementType.ANNOTATION_TYPE, ElementType.PARAMETER})
public @interface NativeType {
String value() default "";
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/NullTerminated.java 0000644 0001750 0001750 00000003762 11543426510 024104 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* This annotation implies that a Buffer argument should be
* checked for a trailing '\0'
*
* @author elias_naur
* @version $Revision: 3260 $
* $Id: NullTerminated.java 3260 2009-12-04 04:49:19Z spasi $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target(ElementType.PARAMETER)
public @interface NullTerminated {
String value() default "";
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Alias.java 0000644 0001750 0001750 00000004126 11543426510 022201 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
* This annotation can be used for extensions that have aliases
* with the exact same functionality.
*
* This is currently only implemented for context-specific functionality.
*
* @author Spasi
*/
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
public @interface Alias {
/** The aliased extension name. */
String value();
/** The function name postfix for the aliased version. (optional) */
String postfix() default "";
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Mode.java 0000644 0001750 0001750 00000003327 11543426510 022036 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
public enum Mode {
BUFFEROBJECT,
AUTOS,
CACHEDRESULT, // Used for generating a CachedResult method with an explicit length argument.
NORMAL
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/GenerateAutos.java 0000644 0001750 0001750 00000003715 11543426510 023721 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* @author elias_naur
* @version $Revision: 3412 $
* $Id: GenerateAutos.java 3412 2010-09-26 23:43:24Z spasi $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target(ElementType.METHOD)
public @interface GenerateAutos {
/** If true, a size variable will be generated. */
String[] sizeVariables() default {};
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Private.java 0000644 0001750 0001750 00000003567 11543426510 022572 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2010 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
* Extension templates marked with @Private will result in classes without the public keyword.
*
* @author Spasi
*/
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Private {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/RegisterStubsGenerator.java 0000644 0001750 0001750 00000013622 11543426510 025625 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* This class generates the initNatives native function.
*
* @author elias_naur
* @version $Revision: 3418 $
* $Id: RegisterStubsGenerator.java 3418 2010-09-28 21:11:35Z spasi $
*/
import org.lwjgl.opencl.CLMem;
import com.sun.mirror.declaration.*;
import com.sun.mirror.type.*;
import java.io.*;
import java.util.*;
public class RegisterStubsGenerator {
public static void generateMethodsNativeStubBind(PrintWriter writer, InterfaceDeclaration d, boolean generate_error_checks, boolean context_specific) {
Iterator it = d.getMethods().iterator();
while (it.hasNext()) {
MethodDeclaration method = it.next();
Alternate alt_annotation = method.getAnnotation(Alternate.class);
if ( (alt_annotation != null && (!alt_annotation.nativeAlt() || alt_annotation.skipNative())) || method.getAnnotation(Reuse.class) != null )
continue;
EnumSet platforms;
PlatformDependent platform_annotation = method.getAnnotation(PlatformDependent.class);
if (platform_annotation != null)
platforms = EnumSet.copyOf(Arrays.asList(platform_annotation.value()));
else
platforms = EnumSet.of(Platform.ALL);
for (Platform platform : platforms) {
platform.printPrologue(writer);
boolean has_buffer_parameter = Utils.hasMethodBufferObjectParameter(method);
printMethodNativeStubBind(writer, d, method, platform, Mode.NORMAL, it.hasNext() || has_buffer_parameter, generate_error_checks, context_specific);
if (has_buffer_parameter) {
printMethodNativeStubBind(writer, d, method, platform, Mode.BUFFEROBJECT, it.hasNext(), generate_error_checks, context_specific);
}
platform.printEpilogue(writer);
}
}
writer.println();
}
private static String getTypeSignature(TypeMirror type, boolean add_position_signature) {
SignatureTranslator v = new SignatureTranslator(add_position_signature);
type.accept(v);
return v.getSignature();
}
private static String getMethodSignature(MethodDeclaration method, Mode mode) {
Collection params = method.getParameters();
String signature = "(";
for (ParameterDeclaration param : params) {
if ( param.getAnnotation(Result.class) != null || (param.getAnnotation(Helper.class) != null && !param.getAnnotation(Helper.class).passToNative()) )
continue;
final Constant constant_annotation = param.getAnnotation(Constant.class);
if ( constant_annotation != null && constant_annotation.isNative() )
continue;
if (mode == Mode.BUFFEROBJECT && param.getAnnotation(BufferObject.class) != null)
signature += "I";
else
signature += getTypeSignature(param.getType(), true);
}
final TypeMirror result_type = Utils.getMethodReturnType(method);
final CachedResult cached_result_annotation = method.getAnnotation(CachedResult.class);
final AutoSize auto_size_annotation = method.getAnnotation(AutoSize.class);
if ( Utils.getNIOBufferType(result_type) != null && (auto_size_annotation == null || !auto_size_annotation.isNative()) )
signature += "J";
String result_type_signature = getTypeSignature(result_type, false);
if ( cached_result_annotation != null )
signature += result_type_signature;
signature += ")";
signature += result_type_signature;
return signature;
}
private static void printMethodNativeStubBind(PrintWriter writer, InterfaceDeclaration d, MethodDeclaration method, Platform platform, Mode mode, boolean has_more, boolean generate_error_checks, boolean context_specific) {
writer.print("\t\t{\"" + Utils.getSimpleNativeMethodName(method, generate_error_checks, context_specific));
if (mode == Mode.BUFFEROBJECT)
writer.print(Utils.BUFFER_OBJECT_METHOD_POSTFIX);
writer.print("\", \"" + getMethodSignature(method, mode) + "\", (void *)&");
writer.print(Utils.getQualifiedNativeMethodName(Utils.getQualifiedClassName(d), method, generate_error_checks, context_specific));
if (mode == Mode.BUFFEROBJECT)
writer.print(Utils.BUFFER_OBJECT_METHOD_POSTFIX);
final Alternate alt_annotation = method.getAnnotation(Alternate.class);
final String methodName = alt_annotation == null ? method.getSimpleName() : alt_annotation.value();
String opengl_handle_name = methodName.replaceFirst("gl", platform.getPrefix());
writer.print(", \"" + opengl_handle_name + "\", (void *)&" + methodName + "}");
if (has_more)
writer.println(",");
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/ForceInit.java 0000644 0001750 0001750 00000003537 11543426510 023037 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
* Extensions marked with ForceInit will be initialized by LWJGL even if not exposed in the GL_EXTENSIONS string.
*
* @author spasi
*/
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target({ ElementType.TYPE })
public @interface ForceInit {
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Imports.java 0000644 0001750 0001750 00000003542 11543426510 022606 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
/**
* This annotation can be used when an extension template needs
* extra imports in its generated class.
*
* @author Spasi
*/
@Target(ElementType.TYPE)
public @interface Imports {
String[] value();
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/TypeMap.java 0000644 0001750 0001750 00000005655 11543426510 022537 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* The interface to the OpenAL/OpenGL specific generator behaviour
*
* @author elias_naur
* @version $Revision: 3412 $
* $Id: TypeMap.java 3412 2010-09-26 23:43:24Z spasi $
*/
import com.sun.mirror.declaration.*;
import com.sun.mirror.type.*;
import java.io.*;
import java.lang.annotation.Annotation;
public interface TypeMap {
void printCapabilitiesInit(PrintWriter writer);
String getCapabilities();
void printErrorCheckMethod(PrintWriter writer, MethodDeclaration method, String tabs);
String getRegisterNativesFunctionName();
PrimitiveType.Kind getPrimitiveTypeFromNativeType(Class native_type);
String getTypedefPostfix();
String getFunctionPrefix();
void printNativeIncludes(PrintWriter writer);
Class getStringElementType();
Class getStringArrayType();
Class getByteBufferArrayType();
Class[] getValidAnnotationTypes(Class type);
Class getVoidType();
String translateAnnotation(Class annotation_type);
Class getNativeTypeFromPrimitiveType(PrimitiveType.Kind kind);
String getAutoTypeFromAnnotation(AnnotationMirror annotation);
Class getInverseType(Class type);
Signedness getSignednessFromType(Class type);
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/PostfixTranslator.java 0000644 0001750 0001750 00000013236 11543426510 024660 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* A TypeVisitor that translates (annotated) TypeMirrors to
* postfixes.
*
* @author elias_naur
* @version $Revision: 3412 $
* $Id: PostfixTranslator.java 3412 2010-09-26 23:43:24Z spasi $
*/
import com.sun.mirror.declaration.*;
import com.sun.mirror.type.*;
import com.sun.mirror.util.*;
import java.lang.annotation.Annotation;
import java.nio.*;
public class PostfixTranslator implements TypeVisitor {
private final StringBuilder signature = new StringBuilder();
private final Declaration declaration;
private final TypeMap type_map;
public PostfixTranslator(TypeMap type_map, Declaration declaration) {
this.declaration = declaration;
this.type_map = type_map;
}
public String getSignature() {
return signature.toString();
}
public void visitAnnotationType(AnnotationType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitArrayType(ArrayType t) {
throw new RuntimeException(t + " is not allowed");
}
private static PrimitiveType.Kind getPrimitiveKindFromBufferClass(Class c) {
if (IntBuffer.class.equals(c) || int.class.equals(c) )
return PrimitiveType.Kind.INT;
else if (DoubleBuffer.class.equals(c) || double.class.equals(c) )
return PrimitiveType.Kind.DOUBLE;
else if (ShortBuffer.class.equals(c) || short.class.equals(c) )
return PrimitiveType.Kind.SHORT;
else if (ByteBuffer.class.equals(c) || byte.class.equals(c) )
return PrimitiveType.Kind.BYTE;
else if (FloatBuffer.class.equals(c) || float.class.equals(c))
return PrimitiveType.Kind.FLOAT;
else if (LongBuffer.class.equals(c) || long.class.equals(c) )
return PrimitiveType.Kind.LONG;
else
throw new RuntimeException(c + " is not allowed");
}
public void visitClassType(ClassType t) {
Class c = NativeTypeTranslator.getClassFromType(t);
PrimitiveType.Kind kind = getPrimitiveKindFromBufferClass(c);
visitPrimitiveTypeKind(kind);
}
public void visitDeclaredType(DeclaredType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitEnumType(EnumType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitInterfaceType(InterfaceType t) {
throw new RuntimeException(t + " is not allowed");
}
private boolean translateAnnotation(AnnotationMirror annotation) {
NativeType native_type = NativeTypeTranslator.getAnnotation(annotation, NativeType.class);
if (native_type != null) {
Class annotation_class = NativeTypeTranslator.getClassFromType(annotation.getAnnotationType());
signature.append(type_map.translateAnnotation(annotation_class));
return true;
} else
return false;
}
private boolean translateAnnotations() {
boolean result = false;
for (AnnotationMirror annotation : Utils.getSortedAnnotations(declaration.getAnnotationMirrors()))
if (translateAnnotation(annotation)) {
if (result)
throw new RuntimeException("Multiple native types");
result = true;
}
return result;
}
public void visitPrimitiveType(PrimitiveType t) {
visitPrimitiveTypeKind(t.getKind());
}
private void visitPrimitiveTypeKind(PrimitiveType.Kind kind) {
boolean annotated_translation = translateAnnotations();
if (annotated_translation)
return;
// No annotation type was specified, fall back to default
String type;
switch (kind) {
case INT:
type = "i";
break;
case DOUBLE:
type = "d";
break;
case FLOAT:
type = "f";
break;
case SHORT:
type = "s";
break;
case BYTE:
type = "b";
break;
case LONG:
type = "i64";
break;
default:
throw new RuntimeException(kind + " is not allowed");
}
signature.append(type);
}
public void visitReferenceType(ReferenceType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitTypeMirror(TypeMirror t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitTypeVariable(TypeVariable t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitVoidType(VoidType t) {
}
public void visitWildcardType(WildcardType t) {
throw new RuntimeException(t + " is not allowed");
}
} lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Extension.java 0000644 0001750 0001750 00000003676 11543426510 023135 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: Extension.java 2983 2008-04-07 18:36:09Z matzon $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target(ElementType.TYPE)
public @interface Extension {
String className() default "";
boolean isFinal() default true;
String postfix();
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/JNITypeTranslator.java 0000644 0001750 0001750 00000007716 11543426510 024514 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
import com.sun.mirror.type.*;
import com.sun.mirror.util.*;
/**
*
* A TypeVisitor that translates TypeMirrors to JNI
* type strings.
*
* @author elias_naur
* @version $Revision: 3412 $
* $Id: JNITypeTranslator.java 3412 2010-09-26 23:43:24Z spasi $
*/
public class JNITypeTranslator implements TypeVisitor {
private final StringBuilder signature = new StringBuilder();
public String getSignature() {
return signature.toString();
}
public void visitAnnotationType(AnnotationType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitArrayType(ArrayType t) {
final String className = t.getComponentType().toString();
if ( "java.lang.CharSequence".equals(className) )
signature.append("jobject");
else if ( "java.nio.ByteBuffer".equals(className) )
signature.append("jobjectArray");
else if ( "org.lwjgl.opencl.CLMem".equals(className) )
signature.append("jobjectArray");
else
throw new RuntimeException(t + " is not allowed");
}
public void visitClassType(ClassType t) {
signature.append("jobject");
}
public void visitDeclaredType(DeclaredType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitEnumType(EnumType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitInterfaceType(InterfaceType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitPrimitiveType(PrimitiveType t) {
String type;
switch (t.getKind()) {
case LONG:
type = "jlong";
break;
case INT:
type = "jint";
break;
case FLOAT:
type = "jfloat";
break;
case SHORT:
type = "jshort";
break;
case BYTE:
type = "jbyte";
break;
case DOUBLE:
type = "jdouble";
break;
case BOOLEAN:
type = "jboolean";
break;
default:
throw new RuntimeException(t + " is not allowed");
}
signature.append(type);
}
public void visitReferenceType(ReferenceType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitTypeMirror(TypeMirror t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitTypeVariable(TypeVariable t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitVoidType(VoidType t) {
signature.append(t.toString());
}
public void visitWildcardType(WildcardType t) {
throw new RuntimeException(t + " is not allowed");
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Platform.java 0000644 0001750 0001750 00000005207 11543426510 022735 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: Platform.java 2983 2008-04-07 18:36:09Z matzon $
*/
import java.io.PrintWriter;
public enum Platform {
WGL,
GLX,
ALL;
public void printPrologue(PrintWriter writer) {
if (this == ALL)
return;
writer.print("#ifdef ");
switch (this) {
case WGL:
writer.println("_WIN32");
break;
case GLX:
writer.println("_X11");
break;
default:
throw new RuntimeException(this + " is not supported");
}
}
public void printEpilogue(PrintWriter writer) {
if (this == ALL)
return;
writer.println("#endif");
}
public String getOSPrefix() {
switch (this) {
case WGL:
return "Windows";
case GLX:
return "Linux";
default:
throw new RuntimeException(this + " has no OS specific prefix");
}
}
public String getPrefix() {
switch (this) {
case WGL:
return "wgl";
case GLX:
return "glX";
case ALL:
return "gl";
default:
throw new RuntimeException(this + " is not supported");
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/JavaMethodsGenerator.java 0000644 0001750 0001750 00000107207 11543426510 025230 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* This class generates the methods in the generated java source files.
*
* @author elias_naur
* @version $Revision: 3460 $
* $Id: JavaMethodsGenerator.java 3460 2010-11-29 18:25:28Z spasi $
*/
import org.lwjgl.PointerBuffer;
import org.lwjgl.util.generator.opengl.GLreturn;
import com.sun.mirror.apt.*;
import com.sun.mirror.declaration.*;
import com.sun.mirror.type.*;
import java.io.*;
import java.util.*;
import java.nio.*;
public class JavaMethodsGenerator {
private static final String SAVED_PARAMETER_POSTFIX = "_saved";
public static void generateMethodsJava(AnnotationProcessorEnvironment env, TypeMap type_map, PrintWriter writer, InterfaceDeclaration interface_decl, boolean generate_error_checks, boolean context_specific) {
for (MethodDeclaration method : interface_decl.getMethods())
generateMethodJava(env, type_map, writer, interface_decl, method, generate_error_checks, context_specific);
}
private static void generateMethodJava(AnnotationProcessorEnvironment env, TypeMap type_map, PrintWriter writer, InterfaceDeclaration interface_decl, MethodDeclaration method, boolean generate_error_checks, boolean context_specific) {
writer.println();
if (Utils.isMethodIndirect(generate_error_checks, context_specific, method)) {
if (method.getAnnotation(GenerateAutos.class) != null) {
printMethodWithMultiType(env, type_map, writer, interface_decl, method, TypeInfo.getDefaultTypeInfoMap(method), Mode.AUTOS, generate_error_checks, context_specific);
}
Collection> cross_product = TypeInfo.getTypeInfoCrossProduct(type_map, method);
for (Map typeinfos_instance : cross_product) {
printMethodWithMultiType(env, type_map, writer, interface_decl, method, typeinfos_instance, Mode.NORMAL, generate_error_checks, context_specific);
}
}
if ( method.getAnnotation(CachedResult.class) != null && !method.getAnnotation(CachedResult.class).isRange() ) {
printMethodWithMultiType(env, type_map, writer, interface_decl, method, TypeInfo.getDefaultTypeInfoMap(method), Mode.CACHEDRESULT, generate_error_checks, context_specific);
}
Reuse reuse_annotation = method.getAnnotation(Reuse.class);
Alternate alt_annotation = method.getAnnotation(Alternate.class);
if ( alt_annotation == null || (alt_annotation.nativeAlt() && !alt_annotation.skipNative()) ) {
if ( alt_annotation != null && method.getSimpleName().equals(alt_annotation.value()) )
throw new RuntimeException("An alternate function with native code should have a different name than the main function.");
if ( reuse_annotation == null )
printJavaNativeStub(writer, method, Mode.NORMAL, generate_error_checks, context_specific);
if (Utils.hasMethodBufferObjectParameter(method)) {
printMethodWithMultiType(env, type_map, writer, interface_decl, method, TypeInfo.getDefaultTypeInfoMap(method), Mode.BUFFEROBJECT, generate_error_checks, context_specific);
if ( reuse_annotation == null )
printJavaNativeStub(writer, method, Mode.BUFFEROBJECT, generate_error_checks, context_specific);
}
}
}
private static void printJavaNativeStub(PrintWriter writer, MethodDeclaration method, Mode mode, boolean generate_error_checks, boolean context_specific) {
if (Utils.isMethodIndirect(generate_error_checks, context_specific, method)) {
writer.print("\tstatic native ");
} else {
Utils.printDocComment(writer, method);
writer.print("\tpublic static native ");
}
writer.print(getResultType(method, true));
writer.print(" " + Utils.getSimpleNativeMethodName(method, generate_error_checks, context_specific));
if (mode == Mode.BUFFEROBJECT)
writer.print(Utils.BUFFER_OBJECT_METHOD_POSTFIX);
writer.print("(");
boolean first_parameter = generateParametersJava(writer, method, TypeInfo.getDefaultTypeInfoMap(method), true, true, mode);
if (context_specific) {
if (!first_parameter)
writer.print(", ");
writer.print("long " + Utils.FUNCTION_POINTER_VAR_NAME);
}
writer.println(");");
}
private static boolean generateParametersJava(PrintWriter writer, MethodDeclaration method, Map typeinfos_instance, boolean native_stub, final boolean printTypes, Mode mode) {
boolean first_parameter = true;
for (ParameterDeclaration param : method.getParameters()) {
if ( native_stub && (param.getAnnotation(Helper.class) != null && !param.getAnnotation(Helper.class).passToNative()) )
continue;
final Constant constant_annotation = param.getAnnotation(Constant.class);
if ( constant_annotation != null && constant_annotation.isNative() )
continue;
AnnotationMirror auto_annotation_mirror = Utils.getParameterAutoAnnotation(param);
boolean hide_auto_parameter = mode == Mode.NORMAL && !native_stub && auto_annotation_mirror != null;
if (hide_auto_parameter) {
AutoType auto_type_annotation = param.getAnnotation(AutoType.class);
if (auto_type_annotation != null) {
ParameterDeclaration auto_parameter = Utils.findParameter(method, auto_type_annotation.value());
TypeInfo auto_param_type_info = typeinfos_instance.get(auto_parameter);
if (auto_param_type_info.getSignedness() == Signedness.BOTH) {
if (!first_parameter)
writer.print(", ");
first_parameter = false;
if ( printTypes )
writer.print("boolean ");
writer.print(TypeInfo.UNSIGNED_PARAMETER_NAME);
}
}
} else if (
param.getAnnotation(Result.class) == null
&& (native_stub || ((param.getAnnotation(Constant.class) == null || param.getAnnotation(Constant.class).keepParam()) && !Utils.isReturnParameter(method, param)))
&& (mode != Mode.AUTOS || getAutoTypeParameter(method, param) == null)
) {
first_parameter = generateParameterJava(writer, param, typeinfos_instance.get(param), native_stub, printTypes, first_parameter, mode);
}
}
CachedResult cached_result_annotation = method.getAnnotation(CachedResult.class);
TypeMirror result_type = Utils.getMethodReturnType(method);
if ((native_stub && Utils.getNIOBufferType(result_type) != null) || Utils.needResultSize(method)) {
AutoSize auto_size_annotation = method.getAnnotation(AutoSize.class);
if ( auto_size_annotation == null || !auto_size_annotation.isNative() ) {
if (cached_result_annotation == null || !cached_result_annotation.isRange()) {
if (!first_parameter)
writer.print(", ");
first_parameter = false;
if ( printTypes )
writer.print("long ");
writer.print(Utils.RESULT_SIZE_NAME);
}
}
}
if (cached_result_annotation != null) {
if (!first_parameter)
writer.print(", ");
if ( mode == Mode.CACHEDRESULT ) {
if ( printTypes )
writer.print("long ");
writer.print(Utils.CACHED_BUFFER_LENGTH_NAME + ", ");
}
first_parameter = false;
if ( printTypes )
writer.print(getResultType(method, native_stub));
writer.print(" " + Utils.CACHED_BUFFER_NAME);
}
return first_parameter;
}
private static boolean generateParameterJava(PrintWriter writer, ParameterDeclaration param, TypeInfo type_info, boolean native_stub, final boolean printTypes, boolean first_parameter, Mode mode) {
Class buffer_type = Utils.getNIOBufferType(param.getType());
if (!first_parameter)
writer.print(", ");
BufferObject bo_annotation = param.getAnnotation(BufferObject.class);
if (bo_annotation != null && mode == Mode.BUFFEROBJECT) {
if (buffer_type == null)
throw new RuntimeException("type of " + param + " is not a nio Buffer parameter but is annotated as buffer object");
if ( printTypes )
writer.print("long ");
writer.print(param.getSimpleName() + Utils.BUFFER_OBJECT_PARAMETER_POSTFIX);
} else {
if ( native_stub && param.getAnnotation(PointerWrapper.class) != null )
writer.print("long ");
else {
Class type = type_info.getType();
if ( native_stub && (type == CharSequence.class || type == CharSequence[].class || type == PointerBuffer.class) )
writer.print("ByteBuffer ");
else if ( printTypes )
writer.print(type_info.getType().getSimpleName() + " ");
}
AutoSize auto_size_annotation = param.getAnnotation(AutoSize.class);
if ( auto_size_annotation != null )
writer.print(auto_size_annotation.value() + "_");
writer.print(param.getSimpleName());
if ( native_stub && buffer_type != null )
writer.print(", int " + param.getSimpleName() + NativeMethodStubsGenerator.BUFFER_POSITION_POSTFIX);
}
return false;
}
private static void printBufferObjectCheck(PrintWriter writer, BufferKind kind, Mode mode) {
String bo_check_method_name = kind.toString();
writer.print("\t\t" + Utils.CHECKS_CLASS_NAME + ".ensure" + bo_check_method_name);
if (mode == Mode.BUFFEROBJECT)
writer.print("enabled");
else
writer.print("disabled");
writer.println("(caps);");
}
private static void printBufferObjectChecks(PrintWriter writer, MethodDeclaration method, Mode mode) {
EnumSet check_set = EnumSet.noneOf(BufferKind.class);
for (ParameterDeclaration param : method.getParameters()) {
BufferObject bo_annotation = param.getAnnotation(BufferObject.class);
if (bo_annotation != null)
check_set.add(bo_annotation.value());
}
for (BufferKind kind : check_set)
printBufferObjectCheck(writer, kind, mode);
}
private static void printMethodWithMultiType(AnnotationProcessorEnvironment env, TypeMap type_map, PrintWriter writer, InterfaceDeclaration interface_decl, MethodDeclaration method, Map typeinfos_instance, Mode mode, boolean generate_error_checks, boolean context_specific) {
Utils.printDocComment(writer, method);
if ( interface_decl.getAnnotation(Private.class) == null && method.getAnnotation(Private.class) == null )
writer.print("\tpublic static ");
else
writer.print("\tstatic ");
writer.print(getResultType(method, false));
StripPostfix strip_annotation = method.getAnnotation(StripPostfix.class);
String method_name;
Alternate alt_annotation = method.getAnnotation(Alternate.class);
method_name = alt_annotation == null || alt_annotation.javaAlt() ? method.getSimpleName() : alt_annotation.value();
if (strip_annotation != null && mode == Mode.NORMAL)
method_name = getPostfixStrippedName(type_map, interface_decl, method);
writer.print(" " + method_name + "(");
generateParametersJava(writer, method, typeinfos_instance, false, true, mode);
writer.println(") {");
final TypeMirror result_type = Utils.getMethodReturnType(method);
boolean has_result = !result_type.equals(env.getTypeUtils().getVoidType());
final Reuse reuse_annotation = method.getAnnotation(Reuse.class);
if ( reuse_annotation != null ) {
writer.print("\t\t");
if ( has_result || method.getAnnotation(GLreturn.class) != null )
writer.print("return ");
writer.print(reuse_annotation.value() + "." + method_name + "(");
generateParametersJava(writer, method, typeinfos_instance, false, false, mode);
writer.println(");\n\t}");
return;
}
if (context_specific) {
type_map.printCapabilitiesInit(writer);
writer.print("\t\tlong " + Utils.FUNCTION_POINTER_VAR_NAME + " = " + type_map.getCapabilities() + ".");
writer.println(Utils.getFunctionAddressName(interface_decl, method, true) + ";");
writer.print("\t\tBufferChecks.checkFunctionAddress(");
writer.println(Utils.FUNCTION_POINTER_VAR_NAME + ");");
}
final Code code_annotation = method.getAnnotation(Code.class);
if (code_annotation != null && code_annotation.value().length() > 0)
writer.println(code_annotation.value());
printBufferObjectChecks(writer, method, mode);
printParameterChecks(writer, method, typeinfos_instance, mode, generate_error_checks);
printParameterCaching(writer, interface_decl, method, mode);
if ( code_annotation != null && code_annotation.javaBeforeNative().length() > 0 )
writer.println(code_annotation.javaBeforeNative());
writer.print("\t\t");
final PointerWrapper pointer_wrapper_annotation = method.getAnnotation(PointerWrapper.class);
if (has_result) {
writer.print(getResultType(method, false) + " " + Utils.RESULT_VAR_NAME);
if ( code_annotation != null && code_annotation.tryBlock() ) {
writer.print(" = " + getDefaultResultValue(method));
writer.println(";\n\t\ttry {");
writer.print("\t\t\t" + Utils.RESULT_VAR_NAME);
}
writer.print(" = ");
if ( pointer_wrapper_annotation != null ) {
if ( pointer_wrapper_annotation.factory().length() > 0 )
writer.print(pointer_wrapper_annotation.factory() + "(");
else
writer.print("new " + getResultType(method, false) + "(");
}
} else if ( method.getAnnotation(GLreturn.class) != null ) {
has_result = true;
Utils.printGLReturnPre(writer, method, method.getAnnotation(GLreturn.class));
}
writer.print(Utils.getSimpleNativeMethodName(method, generate_error_checks, context_specific));
if (mode == Mode.BUFFEROBJECT)
writer.print(Utils.BUFFER_OBJECT_METHOD_POSTFIX);
writer.print("(");
boolean first_parameter = printMethodCallArguments(writer, method, typeinfos_instance, mode);
if (context_specific) {
if (!first_parameter)
writer.print(", ");
writer.print(Utils.FUNCTION_POINTER_VAR_NAME);
}
if ( has_result && pointer_wrapper_annotation != null ) {
writer.print(")");
if ( pointer_wrapper_annotation.params().length() > 0 )
writer.print(", " + pointer_wrapper_annotation.params());
}
writer.println(");");
if ( code_annotation != null && code_annotation.javaAfterNative().length() > 0 )
writer.println(code_annotation.javaAfterNative());
final String tabs = code_annotation != null && code_annotation.tryBlock() ? "\t\t\t" : "\t\t";
if (generate_error_checks && method.getAnnotation(NoErrorCheck.class) == null)
type_map.printErrorCheckMethod(writer, method, tabs);
// DISABLED: indirect buffer support
//printNondirectParameterCopies(writer, method, mode);
if (has_result) {
if ( method.getAnnotation(GLreturn.class) == null ) {
if ( ByteBuffer.class.equals(Utils.getJavaType(result_type)) )
writer.println(tabs + "return LWJGLUtil.CHECKS && " + Utils.RESULT_VAR_NAME + " == null ? null : " + Utils.RESULT_VAR_NAME + ".order(ByteOrder.nativeOrder());"); // safeNewBuffer returns a direct ByteBuffer with BIG_ENDIAN order.
else
writer.println(tabs + "return " + Utils.RESULT_VAR_NAME + ";");
} else
Utils.printGLReturnPost(writer, method, method.getAnnotation(GLreturn.class));
}
if ( code_annotation != null && code_annotation.tryBlock() ) {
writer.println("\t\t} finally {");
writer.println(code_annotation.javaFinally());
writer.println("\t\t}");
}
writer.println("\t}");
}
private static String getExtensionPostfix(InterfaceDeclaration interface_decl) {
String interface_simple_name = interface_decl.getSimpleName();
Extension extension_annotation = interface_decl.getAnnotation(Extension.class);
if (extension_annotation == null) {
int underscore_index = interface_simple_name.indexOf("_");
if (underscore_index != -1)
return interface_simple_name.substring(0, underscore_index);
else
return "";
} else
return extension_annotation.postfix();
}
private static ParameterDeclaration getAutoTypeParameter(MethodDeclaration method, ParameterDeclaration target_parameter) {
for (ParameterDeclaration param : method.getParameters()) {
AnnotationMirror auto_annotation = Utils.getParameterAutoAnnotation(param);
if (auto_annotation != null) {
Class annotation_type = NativeTypeTranslator.getClassFromType(auto_annotation.getAnnotationType());
String parameter_name;
if (annotation_type.equals(AutoType.class))
parameter_name = param.getAnnotation(AutoType.class).value();
else if (annotation_type.equals(AutoSize.class))
parameter_name = param.getAnnotation(AutoSize.class).value();
else
throw new RuntimeException("Unknown annotation type " + annotation_type);
if (target_parameter.getSimpleName().equals(parameter_name))
return param;
}
}
return null;
}
private static boolean hasAnyParameterAutoTypeAnnotation(MethodDeclaration method, ParameterDeclaration target_param) {
for (ParameterDeclaration param : method.getParameters()) {
AutoType auto_type_annotation = param.getAnnotation(AutoType.class);
if (auto_type_annotation != null) {
ParameterDeclaration type_target_param = Utils.findParameter(method, auto_type_annotation.value());
if (target_param.equals(type_target_param))
return true;
}
}
return false;
}
private static String getPostfixStrippedName(TypeMap type_map, InterfaceDeclaration interface_decl, MethodDeclaration method) {
StripPostfix strip_annotation = method.getAnnotation(StripPostfix.class);
ParameterDeclaration postfix_parameter = Utils.findParameter(method, strip_annotation.value());
String postfix = strip_annotation.postfix();
if ( "NULL".equals(postfix) ) {
PostfixTranslator translator = new PostfixTranslator(type_map, postfix_parameter);
postfix_parameter.getType().accept(translator);
postfix = translator.getSignature();
}
String method_name;
Alternate alt_annotation = method.getAnnotation(Alternate.class);
method_name = alt_annotation == null || alt_annotation.javaAlt() ? method.getSimpleName() : alt_annotation.value();
String extension_postfix = "NULL".equals(strip_annotation.extension()) ? getExtensionPostfix(interface_decl) : strip_annotation.extension();
String result;
if ( strip_annotation.hasPostfix() && method_name.endsWith(postfix + "v" + extension_postfix))
result = method_name.substring(0, method_name.length() - (postfix.length() + 1 + extension_postfix.length()));
else if ( strip_annotation.hasPostfix() && method_name.endsWith(postfix + extension_postfix))
result = method_name.substring(0, method_name.length() - (postfix.length() + extension_postfix.length()));
else if ( strip_annotation.hasPostfix() && method_name.endsWith(postfix + "i_v" + extension_postfix) )
result = method_name.substring(0, method_name.length() - (postfix.length() + 3 + extension_postfix.length()));
else if ( method_name.endsWith("i_v" + extension_postfix) )
result = method_name.substring(0, method_name.length() - (3 + extension_postfix.length()));
else if (method_name.endsWith("v" + extension_postfix))
result = method_name.substring(0, method_name.length() - (1 + extension_postfix.length()));
else
throw new RuntimeException(method + " is specified as being postfix stripped on parameter " + postfix_parameter + ", but it's postfix is not '" + postfix + "' nor 'v'");
return result + extension_postfix;
}
private static int getBufferElementSizeExponent(Class c) {
if (IntBuffer.class.equals(c))
return 2;
else if (LongBuffer.class.equals(c))
return 3;
else if (DoubleBuffer.class.equals(c))
return 3;
else if (ShortBuffer.class.equals(c))
return 1;
else if (ByteBuffer.class.equals(c))
return 0;
else if (FloatBuffer.class.equals(c))
return 2;
else
throw new RuntimeException(c + " is not allowed");
}
private static boolean printMethodCallArgument(PrintWriter writer, MethodDeclaration method, ParameterDeclaration param, Map typeinfos_instance, Mode mode, boolean first_parameter) {
if (!first_parameter)
writer.print(", ");
AnnotationMirror auto_annotation = Utils.getParameterAutoAnnotation(param);
Constant constant_annotation = param.getAnnotation(Constant.class);
if (constant_annotation != null) {
writer.print(constant_annotation.value());
} else if (auto_annotation != null && mode == Mode.NORMAL) {
Class param_type = NativeTypeTranslator.getClassFromType(auto_annotation.getAnnotationType());
if (AutoType.class.equals(param_type)) {
final AutoType auto_type_annotation = param.getAnnotation(AutoType.class);
final ParameterDeclaration auto_parameter = Utils.findParameter(method, auto_type_annotation.value());
final String auto_type = typeinfos_instance.get(auto_parameter).getAutoType();
if ( auto_type == null )
throw new RuntimeException("No auto type for parameter " + param.getSimpleName() + " in method " + method);
writer.print(auto_type);
} else if (AutoSize.class.equals(param_type)) {
final AutoSize auto_size_annotation = param.getAnnotation(AutoSize.class);
final String auto_parameter_name = auto_size_annotation.value();
final ParameterDeclaration auto_target_param = Utils.findParameter(method, auto_parameter_name);
final TypeInfo auto_target_type_info = typeinfos_instance.get(auto_target_param);
final boolean shift_remaining = !hasAnyParameterAutoTypeAnnotation(method, auto_target_param) && Utils.isParameterMultiTyped(auto_target_param);
int shifting = 0;
if ( shift_remaining ) {
shifting = getBufferElementSizeExponent(auto_target_type_info.getType());
if ( shifting > 0 )
writer.print("(");
}
if ( auto_size_annotation.canBeNull() )
writer.print("(" + auto_parameter_name + " == null ? 0 : " + auto_parameter_name + ".remaining())");
else
writer.print(auto_parameter_name + ".remaining()");
// Shift the remaining if the target parameter is multityped and there's no AutoType to track type
if (shift_remaining && shifting > 0) {
writer.print(" << " + shifting);
writer.print(")");
}
writer.print(auto_size_annotation.expression());
} else
throw new RuntimeException("Unknown auto annotation " + param_type);
} else {
if (mode == Mode.BUFFEROBJECT && param.getAnnotation(BufferObject.class) != null) {
writer.print(param.getSimpleName() + Utils.BUFFER_OBJECT_PARAMETER_POSTFIX);
} else {
Class type = typeinfos_instance.get(param).getType();
Check check_annotation = param.getAnnotation(Check.class);
boolean hide_buffer = mode == Mode.AUTOS && getAutoTypeParameter(method, param) != null;
if (hide_buffer) {
writer.print("null");
} else {
if ( type == CharSequence.class || type == CharSequence[].class ) {
final String offset = Utils.getStringOffset(method, param);
writer.print("APIUtil.getBuffer");
if ( param.getAnnotation(NullTerminated.class) != null )
writer.print("NT");
writer.print("(" + param.getSimpleName());
if ( offset != null )
writer.print(", " + offset);
writer.print(")");
hide_buffer = true;
} else {
final AutoSize auto_size_annotation = param.getAnnotation(AutoSize.class);
if ( auto_size_annotation != null )
writer.print(auto_size_annotation.value() + "_");
writer.print(param.getSimpleName());
if ( PointerBuffer.class.isAssignableFrom(type) ) {
if ( check_annotation != null && check_annotation.canBeNull() )
writer.print(" != null ? " + param.getSimpleName());
writer.print(".getBuffer()");
if ( check_annotation != null && check_annotation.canBeNull() )
writer.print(" : null");
}
}
}
Class buffer_type = Utils.getNIOBufferType(param.getType());
if (buffer_type != null) {
writer.print(", ");
if (!hide_buffer) {
int shifting;
if (Utils.getNIOBufferType(param.getType()).equals(Buffer.class)) {
shifting = getBufferElementSizeExponent(type == Buffer.class ? ByteBuffer.class : type); // TODO: This will always throw an exception
//shifting = 0;
} else
shifting = 0;
writer.print(param.getSimpleName());
if (check_annotation != null && check_annotation.canBeNull())
writer.print(" != null ? " + param.getSimpleName());
if ( type == PointerBuffer.class )
writer.print(".positionByte()");
else
writer.print(".position()");
if (shifting > 0)
writer.print(" << " + shifting);
if (check_annotation != null && check_annotation.canBeNull())
writer.print(" : 0");
} else if ( type == CharSequence.class || type == CharSequence[].class ) {
final String offset = Utils.getStringOffset(method, param);
writer.print(offset == null ? "0" : offset);
} else
writer.print("0");
} else if ( type != long.class ) {
PointerWrapper pointer_annotation = param.getAnnotation(PointerWrapper.class);
if ( pointer_annotation != null ) {
if ( pointer_annotation.canBeNull() )
writer.print(" == null ? 0 : " + param.getSimpleName());
writer.print(".getPointer()");
}
}
}
}
return false;
}
private static boolean printMethodCallArguments(PrintWriter writer, MethodDeclaration method, Map typeinfos_instance, Mode mode) {
boolean first_parameter = true;
for ( ParameterDeclaration param : method.getParameters() ) {
if ( param.getAnnotation(Result.class) != null || (param.getAnnotation(Helper.class) != null && !param.getAnnotation(Helper.class).passToNative()) )
continue;
final Constant constant_annotation = param.getAnnotation(Constant.class);
if ( constant_annotation== null || !constant_annotation.isNative() )
first_parameter = printMethodCallArgument(writer, method, param, typeinfos_instance, mode, first_parameter);
}
if (Utils.getNIOBufferType(Utils.getMethodReturnType(method)) != null) {
if (method.getAnnotation(CachedResult.class) != null && method.getAnnotation(CachedResult.class).isRange()) {
first_parameter = false;
Utils.printExtraCallArguments(writer, method, "");
} else {
AutoSize auto_size_annotation = method.getAnnotation(AutoSize.class);
if ( auto_size_annotation == null || !auto_size_annotation.isNative() ) {
if (!first_parameter)
writer.print(", ");
first_parameter = false;
String result_size_expression;
if ( mode == Mode.CACHEDRESULT )
result_size_expression = Utils.CACHED_BUFFER_LENGTH_NAME;
else if ( auto_size_annotation == null )
result_size_expression = Utils.RESULT_SIZE_NAME;
else
result_size_expression = auto_size_annotation.value();
Utils.printExtraCallArguments(writer, method, result_size_expression);
}
}
}
return first_parameter;
}
private static void printParameterCaching(PrintWriter writer, InterfaceDeclaration interface_decl, MethodDeclaration method, Mode mode) {
for (ParameterDeclaration param : method.getParameters()) {
Class java_type = Utils.getJavaType(param.getType());
CachedReference cachedReference = param.getAnnotation(CachedReference.class);
if (Buffer.class.isAssignableFrom(java_type) &&
cachedReference != null &&
(mode != Mode.BUFFEROBJECT || param.getAnnotation(BufferObject.class) == null) &&
param.getAnnotation(Result.class) == null) {
writer.print("\t\tif ( LWJGLUtil.CHECKS ) " + "StateTracker.getReferences(caps).");
if(cachedReference.name().length() > 0) {
writer.print(cachedReference.name());
} else {
writer.print(Utils.getReferenceName(interface_decl, method, param));
}
if(cachedReference.index().length() > 0) {
writer.print("[" + cachedReference.index() + "]");
}
writer.println(" = " + param.getSimpleName() + ";");
}
}
}
private static void printNondirectParameterCopies(PrintWriter writer, MethodDeclaration method, Mode mode) {
for (ParameterDeclaration param : method.getParameters()) {
Class java_type = Utils.getJavaType(param.getType());
if (Utils.isAddressableType(java_type) &&
(mode != Mode.BUFFEROBJECT || param.getAnnotation(BufferObject.class) == null) &&
(mode != Mode.AUTOS || getAutoTypeParameter(method, param) == null) &&
param.getAnnotation(Result.class) == null) {
if (Buffer.class.isAssignableFrom(java_type)) {
boolean out_parameter = param.getAnnotation(OutParameter.class) != null;
if (out_parameter)
writer.println("\t\tNondirectBufferWrapper.copy(" + param.getSimpleName() + ", " + param.getSimpleName() + SAVED_PARAMETER_POSTFIX + ");");
}
}
}
}
private static void printParameterChecks(PrintWriter writer, MethodDeclaration method, Map typeinfos, Mode mode, final boolean generate_error_checks) {
if ( mode == Mode.NORMAL ) {
final GenerateAutos gen_autos_annotation = method.getAnnotation(GenerateAutos.class);
if ( gen_autos_annotation != null && gen_autos_annotation.sizeVariables().length > 0 ) {
// For the auto-generated parameters, declare and init a size variable (that can be reused by @Code)
for ( final ParameterDeclaration param : method.getParameters() ) {
if ( Arrays.binarySearch(gen_autos_annotation.sizeVariables(), param.getSimpleName()) >= 0 ) {
final int shifting = getBufferElementSizeExponent(typeinfos.get(param).getType());
final Check check_annotation = param.getAnnotation(Check.class);
writer.print("\t\tlong " + param.getSimpleName() + "_size = ");
if ( check_annotation == null || !check_annotation.canBeNull() )
writer.println(param.getSimpleName() + ".remaining() << " + shifting + ";");
else
writer.println(param.getSimpleName() + " == null ? 0 : " + param.getSimpleName() + ".remaining() << " + shifting + ";");
}
}
}
}
for (ParameterDeclaration param : method.getParameters()) {
Class java_type = Utils.getJavaType(param.getType());
if ( java_type.isArray() || (Utils.isAddressableType(java_type) &&
(mode != Mode.BUFFEROBJECT || param.getAnnotation(BufferObject.class) == null) &&
(mode != Mode.AUTOS || getAutoTypeParameter(method, param) == null) &&
param.getAnnotation(Result.class) == null &&
!Utils.isReturnParameter(method, param)) ) {
String check_value = null;
boolean can_be_null = false;
Check check_annotation = param.getAnnotation(Check.class);
if (check_annotation != null) {
check_value = check_annotation.value();
can_be_null = check_annotation.canBeNull();
}
if ((Buffer.class.isAssignableFrom(java_type) || PointerBuffer.class.isAssignableFrom(java_type)) && param.getAnnotation(Constant.class) == null) {
boolean indirect_buffer_allowed = false && param.getAnnotation(CachedReference.class) == null; // DISABLED: indirect buffer support
boolean out_parameter = param.getAnnotation(OutParameter.class) != null;
TypeInfo typeinfo = typeinfos.get(param);
printParameterCheck(writer, method, param.getSimpleName(), typeinfo.getType().getSimpleName(), check_value, can_be_null, param.getAnnotation(NullTerminated.class), indirect_buffer_allowed, out_parameter, generate_error_checks);
} else if ( String.class.equals(java_type)) {
if (!can_be_null)
writer.println("\t\tBufferChecks.checkNotNull(" + param.getSimpleName() + ");");
} else if ( java_type.isArray() ) {
final TypeInfo typeinfo = typeinfos.get(param);
printArrayParameterCheck(writer, param.getSimpleName(), typeinfo.getType().getSimpleName(), check_value, can_be_null);
}
}
}
if (method.getAnnotation(CachedResult.class) != null)
printParameterCheck(writer, method, Utils.CACHED_BUFFER_NAME, null, null, true, null, false, false, generate_error_checks);
}
private static void printParameterCheck(PrintWriter writer, MethodDeclaration method, String name, String type, String check_value, boolean can_be_null, NullTerminated null_terminated, boolean indirect_buffer_allowed, boolean out_parameter, final boolean generate_error_checks) {
if (indirect_buffer_allowed && out_parameter) {
writer.println("\t\t" + type + " " + name + SAVED_PARAMETER_POSTFIX + " = " + name + ";");
}
String tabs;
if (can_be_null) {
writer.print("\t\tif (" + name + " != null)");
if ( null_terminated != null )
writer.println(" {");
else
writer.println();
tabs = "\t\t\t";
} else
tabs = "\t\t";
if (indirect_buffer_allowed) {
writer.print(tabs + name + " = NondirectBufferWrapper.wrap");
if (out_parameter)
writer.print("NoCopy");
} else
writer.print(tabs + "BufferChecks.check");
if (check_value != null && check_value.length() > 0) {
writer.print("Buffer");
if ( "Buffer".equals(type) )
writer.print("Size"); // Check size only, Buffer.isDirect() was added in 1.6, cannot use yet. TODO: Remove?
writer.print("(" + name + ", " + check_value);
} else {
writer.print("Direct(" + name);
}
writer.println(");");
if ( can_be_null && generate_error_checks ) {
final Check check_annotation = method.getAnnotation(Check.class);
if ( check_annotation != null && check_annotation.value().equals(name) ) {
writer.println("\t\telse");
writer.println("\t\t\t" + name + " = APIUtil.getBufferIntDebug();"); // Use an exclusive buffer here
}
}
if (null_terminated != null) {
writer.print(tabs + "BufferChecks.checkNullTerminated(");
writer.print(name);
if ( null_terminated.value().length() > 0 ) {
writer.print(", ");
writer.print(null_terminated.value());
}
writer.println(");");
if ( can_be_null )
writer.println("\t\t}");
}
}
private static void printArrayParameterCheck(PrintWriter writer, String name, String type, String check_value, boolean can_be_null) {
String tabs;
if ( can_be_null ) {
writer.println("\t\tif (" + name + " != null)");
tabs = "\t\t\t";
} else
tabs = "\t\t";
writer.print(tabs + "BufferChecks.checkArray(" + name);
if ( check_value != null && check_value.length() > 0)
writer.print(", " + check_value);
writer.println(");");
}
private static String getResultType(MethodDeclaration method, boolean native_stub) {
if ( native_stub && method.getAnnotation(PointerWrapper.class) != null )
return "long";
else if ( !native_stub && method.getAnnotation(GLreturn.class) != null )
return Utils.getMethodReturnType(method, method.getAnnotation(GLreturn.class), false);
else
return Utils.getJavaType(Utils.getMethodReturnType(method)).getSimpleName();
}
private static String getDefaultResultValue(MethodDeclaration method) {
if ( method.getAnnotation(GLreturn.class) != null ) {
final String type = Utils.getMethodReturnType(method, method.getAnnotation(GLreturn.class), false);
if ( "boolean".equals(type) )
return "false";
else if ( Character.isLowerCase(type.charAt(0)) )
return "0";
else
return "null";
} else {
final Class type = Utils.getJavaType(Utils.getMethodReturnType(method));
if ( type.isPrimitive() ) {
if ( type == boolean.class )
return "false";
else
return "0";
} else
return "null";
}
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Signedness.java 0000644 0001750 0001750 00000003454 11543426510 023255 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: Signedness.java 2983 2008-04-07 18:36:09Z matzon $
*/
public enum Signedness {
SIGNED,
UNSIGNED,
NONE,
BOTH
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/OutParameter.java 0000644 0001750 0001750 00000003666 11543426510 023570 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
* This annotation indicates that a parameter is written,
* not read.
*
* @author elias_naur
* @version $Revision: 2286 $
* $Id: Check.java 2286 2006-03-23 19:32:21Z matzon $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target(ElementType.PARAMETER)
public @interface OutParameter {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/Const.java 0000644 0001750 0001750 00000003575 11543426510 022245 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* @author elias_naur
* @version $Revision: 2983 $
* $Id: Const.java 2983 2008-04-07 18:36:09Z matzon $
*/
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
@Target({ElementType.PARAMETER, ElementType.METHOD})
public @interface Const {
}
lwjgl-2.7.1/src/java/org/lwjgl/util/generator/SignatureTranslator.java 0000644 0001750 0001750 00000011756 11543426510 025172 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util.generator;
/**
*
* A TypeVisitor that translates types to JNI signatures.
*
* @author elias_naur
* @version $Revision: 3443 $
* $Id: SignatureTranslator.java 3443 2010-10-12 21:13:03Z spasi $
*/
import org.lwjgl.PointerBuffer;
import com.sun.mirror.type.*;
import com.sun.mirror.util.*;
import java.nio.*;
class SignatureTranslator implements TypeVisitor {
private final boolean add_position_signature;
private final StringBuilder signature = new StringBuilder();
SignatureTranslator(boolean add_position_signature) {
this.add_position_signature = add_position_signature;
}
private static String getNativeNameFromClassName(String class_name) {
return class_name.replaceAll("\\.", "/");
}
public String getSignature() {
return signature.toString();
}
public void visitAnnotationType(AnnotationType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitArrayType(ArrayType t) {
final Class type = Utils.getJavaType(t.getComponentType());
if ( CharSequence.class.isAssignableFrom(type) )
signature.append("Ljava/nio/ByteBuffer;I");
else if ( Buffer.class.isAssignableFrom(type) )
signature.append("[Ljava/nio/ByteBuffer;");
else if ( org.lwjgl.PointerWrapper.class.isAssignableFrom(type) )
signature.append("[L" + getNativeNameFromClassName(type.getName()) + ";");
else
throw new RuntimeException(t + " is not allowed");
}
public void visitClassType(ClassType t) {
Class type = NativeTypeTranslator.getClassFromType(t);
String type_name;
if ( (CharSequence.class.isAssignableFrom(type) && !String.class.equals(type)) || CharSequence[].class.isAssignableFrom(type) || PointerBuffer.class.isAssignableFrom(type) )
type_name = ByteBuffer.class.getName();
else if ( org.lwjgl.PointerWrapper.class.isAssignableFrom(type) ) {
signature.append("J");
return;
} else
type_name = t.getDeclaration().getQualifiedName();
signature.append("L");
signature.append(getNativeNameFromClassName(type_name));
signature.append(";");
if ( add_position_signature && Utils.isAddressableType(type) && !String.class.equals(type) )
signature.append("I");
}
public void visitDeclaredType(DeclaredType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitEnumType(EnumType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitInterfaceType(InterfaceType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitPrimitiveType(PrimitiveType t) {
switch (t.getKind()) {
case BOOLEAN:
signature.append("Z");
break;
case INT:
signature.append("I");
break;
case FLOAT:
signature.append("F");
break;
case SHORT:
signature.append("S");
break;
case DOUBLE:
signature.append("D");
break;
case BYTE:
signature.append("B");
break;
case LONG:
signature.append("J");
break;
default:
throw new RuntimeException("Unsupported type " + t);
}
}
public void visitReferenceType(ReferenceType t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitTypeMirror(TypeMirror t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitTypeVariable(TypeVariable t) {
throw new RuntimeException(t + " is not allowed");
}
public void visitVoidType(VoidType t) {
signature.append("V");
}
public void visitWildcardType(WildcardType t) {
throw new RuntimeException(t + " is not allowed");
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/Display.java 0000644 0001750 0001750 00000020243 11543426510 020565 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import org.lwjgl.LWJGLException;
import org.lwjgl.LWJGLUtil;
import org.lwjgl.opengl.DisplayMode;
/**
* Display initialization utility, that can be used to find display modes and pick
* one for you based on your criteria.
* @author $Author: spasi $
* @version $Revision: 3418 $
* $Id: Display.java 3418 2010-09-28 21:11:35Z spasi $
*/
public final class Display {
private static final boolean DEBUG = false;
/**
* Determine the available display modes that match the specified minimum and maximum criteria.
* If any given criterium is specified as -1 then it is ignored.
*
* @param minWidth the minimum display resolution in pixels
* @param minHeight the minimum display resolution in pixels
* @param maxWidth the maximum display resolution in pixels
* @param maxHeight the maximum display resolution in pixels
* @param minBPP the minimum bit depth per pixel
* @param maxBPP the maximum bit depth per pixel
* @param minFreq the minimum display frequency in Hz
* @param maxFreq the maximum display frequency in Hz
* @return an array of matching display modes
*/
public static DisplayMode[] getAvailableDisplayModes(int minWidth, int minHeight, int maxWidth, int maxHeight, int minBPP, int maxBPP,
int minFreq, int maxFreq) throws LWJGLException
{
// First get the available display modes
DisplayMode[] modes = org.lwjgl.opengl.Display.getAvailableDisplayModes();
if (LWJGLUtil.DEBUG || DEBUG) {
System.out.println("Available screen modes:");
for ( DisplayMode mode : modes ) {
System.out.println(mode);
}
}
ArrayList matches = new ArrayList(modes.length);
for (int i = 0; i < modes.length; i ++) {
assert modes[i] != null : ""+i+" "+modes.length;
if (minWidth != -1 && modes[i].getWidth() < minWidth)
continue;
if (maxWidth != -1 && modes[i].getWidth() > maxWidth)
continue;
if (minHeight != -1 && modes[i].getHeight() < minHeight)
continue;
if (maxHeight != -1 && modes[i].getHeight() > maxHeight)
continue;
if (minBPP != -1 && modes[i].getBitsPerPixel() < minBPP)
continue;
if (maxBPP != -1 && modes[i].getBitsPerPixel() > maxBPP)
continue;
//if (modes[i].bpp == 24)
// continue;
if (modes[i].getFrequency() != 0) {
if (minFreq != -1 && modes[i].getFrequency() < minFreq)
continue;
if (maxFreq != -1 && modes[i].getFrequency() > maxFreq)
continue;
}
matches.add(modes[i]);
}
DisplayMode[] ret = new DisplayMode[matches.size()];
matches.toArray(ret);
if (LWJGLUtil.DEBUG && DEBUG) {
System.out.println("Filtered screen modes:");
for ( DisplayMode mode : ret ) {
System.out.println(mode);
}
}
return ret;
}
/**
* Create the display by choosing from a list of display modes based on an order of preference.
* You must supply a list of allowable display modes, probably by calling getAvailableDisplayModes(),
* and an array with the order in which you would like them sorted in descending order.
* This method attempts to create the topmost display mode; if that fails, it will try the next one,
* and so on, until there are no modes left. If no mode is set at the end, an exception is thrown.
* @param dm a list of display modes to choose from
* @param param the names of the DisplayMode fields in the order in which you would like them sorted.
* @return the chosen display mode
* @throws NoSuchFieldException if one of the params is not a field in DisplayMode
* @throws Exception if no display mode could be set
* @see org.lwjgl.opengl.DisplayMode
*/
public static DisplayMode setDisplayMode(DisplayMode[] dm, final String[] param) throws Exception {
class FieldAccessor {
final String fieldName;
final int order;
final int preferred;
final boolean usePreferred;
FieldAccessor(String fieldName, int order, int preferred, boolean usePreferred) {
this.fieldName = fieldName;
this.order = order;
this.preferred = preferred;
this.usePreferred = usePreferred;
}
int getInt(DisplayMode mode) {
if ("width".equals(fieldName)) {
return mode.getWidth();
}
if ("height".equals(fieldName)) {
return mode.getHeight();
}
if ("freq".equals(fieldName)) {
return mode.getFrequency();
}
if ("bpp".equals(fieldName)) {
return mode.getBitsPerPixel();
}
throw new IllegalArgumentException("Unknown field "+fieldName);
}
}
class Sorter implements Comparator {
final FieldAccessor[] accessors;
Sorter() {
accessors = new FieldAccessor[param.length];
for (int i = 0; i < accessors.length; i ++) {
int idx = param[i].indexOf('=');
if (idx > 0) {
accessors[i] = new FieldAccessor(param[i].substring(0, idx), 0, Integer.parseInt(param[i].substring(idx + 1, param[i].length())), true);
} else if (param[i].charAt(0) == '-') {
accessors[i] = new FieldAccessor(param[i].substring(1), -1, 0, false);
} else {
accessors[i] = new FieldAccessor(param[i], 1, 0, false);
}
}
}
/**
* @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
*/
public int compare(DisplayMode dm1, DisplayMode dm2) {
for ( FieldAccessor accessor : accessors ) {
int f1 = accessor.getInt(dm1);
int f2 = accessor.getInt(dm2);
if ( accessor.usePreferred && f1 != f2 ) {
if ( f1 == accessor.preferred )
return -1;
else if ( f2 == accessor.preferred )
return 1;
else {
// Score according to the difference between the values
int absf1 = Math.abs(f1 - accessor.preferred);
int absf2 = Math.abs(f2 - accessor.preferred);
if ( absf1 < absf2 )
return -1;
else if ( absf1 > absf2 )
return 1;
else
continue;
}
} else if ( f1 < f2 )
return accessor.order;
else if ( f1 == f2 )
continue;
else
return -accessor.order;
}
return 0;
}
}
// Sort the display modes
Arrays.sort(dm, new Sorter());
// Try them out in the appropriate order
if (LWJGLUtil.DEBUG || DEBUG) {
System.out.println("Sorted display modes:");
for ( DisplayMode aDm : dm ) {
System.out.println(aDm);
}
}
for ( DisplayMode aDm : dm ) {
try {
if ( LWJGLUtil.DEBUG || DEBUG )
System.out.println("Attempting to set displaymode: " + aDm);
org.lwjgl.opengl.Display.setDisplayMode(aDm);
return aDm;
} catch (Exception e) {
if ( LWJGLUtil.DEBUG || DEBUG ) {
System.out.println("Failed to set display mode to " + aDm);
e.printStackTrace();
}
}
}
throw new Exception("Failed to set display mode.");
}
}
lwjgl-2.7.1/src/java/org/lwjgl/util/Rectangle.java 0000644 0001750 0001750 00000041056 11543426510 021071 0 ustar zero79 zero79 /*
* Copyright (c) 2002-2008 LWJGL Project
* 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 'LWJGL' 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 org.lwjgl.util;
import java.io.Serializable;
/**
* A 2D integer Rectangle class which looks remarkably like an AWT one.
* @author $Author: matzon $
* @version $Revision: 2983 $
* $Id: Rectangle.java 2983 2008-04-07 18:36:09Z matzon $
*/
public final class Rectangle implements ReadableRectangle, WritableRectangle, Serializable {
static final long serialVersionUID = 1L;
/** Rectangle's bounds */
private int x, y, width, height;
/**
* Constructor for Rectangle.
*/
public Rectangle() {
super();
}
/**
* Constructor for Rectangle.
*/
public Rectangle(int x, int y, int w, int h) {
this.x = x;
this.y = y;
this.width = w;
this.height = h;
}
/**
* Constructor for Rectangle.
*/
public Rectangle(ReadablePoint p, ReadableDimension d) {
x = p.getX();
y = p.getY();
width = d.getWidth();
height = d.getHeight();
}
/**
* Constructor for Rectangle.
*/
public Rectangle(ReadableRectangle r) {
x = r.getX();
y = r.getY();
width = r.getWidth();
height = r.getHeight();
}
public void setLocation(int x, int y) {
this.x = x;
this.y = y;
}
public void setLocation(ReadablePoint p) {
this.x = p.getX();
this.y = p.getY();
}
public void setSize(int w, int h) {
this.width = w;
this.height = h;
}
public void setSize(ReadableDimension d) {
this.width = d.getWidth();
this.height = d.getHeight();
}
public void setBounds(int x, int y, int w, int h) {
this.x = x;
this.y = y;
this.width = w;
this.height = h;
}
public void setBounds(ReadablePoint p, ReadableDimension d) {
x = p.getX();
y = p.getY();
width = d.getWidth();
height = d.getHeight();
}
public void setBounds(ReadableRectangle r) {
x = r.getX();
y = r.getY();
width = r.getWidth();
height = r.getHeight();
}
/* (Overrides)
* @see com.shavenpuppy.jglib.ReadableRectangle#getBounds(com.shavenpuppy.jglib.Rectangle)
*/
public void getBounds(WritableRectangle dest) {
dest.setBounds(x, y, width, height);
}
/* (Overrides)
* @see com.shavenpuppy.jglib.ReadablePoint#getLocation(com.shavenpuppy.jglib.Point)
*/
public void getLocation(WritablePoint dest) {
dest.setLocation(x, y);
}
/* (Overrides)
* @see com.shavenpuppy.jglib.ReadableDimension#getSize(com.shavenpuppy.jglib.Dimension)
*/
public void getSize(WritableDimension dest) {
dest.setSize(width, height);
}
/**
* Translate the rectangle by an amount.
* @param x The translation amount on the x axis
* @param y The translation amount on the y axis
*/
public void translate(int x, int y) {
this.x += x;
this.y += y;
}
/**
* Translate the rectangle by an amount.
* @param point The translation amount
*/
public void translate(ReadablePoint point) {
this.x += point.getX();
this.y += point.getY();
}
/**
* Un-translate the rectangle by an amount.
* @param point The translation amount
*/
public void untranslate(ReadablePoint point) {
this.x -= point.getX();
this.y -= point.getY();
}
/**
* Checks whether or not this