shadowfacts/lwjgl2-arm64
1
0
Fork 0
mirror of https://github.com/shadowfacts/lwjgl2-arm64.git synced 2026-04-05 22:45:50 +00:00
Code Issues Projects Releases Packages Wiki Activity

Tons more utils!

Browse source
This commit is contained in:
Caspian Rychlik-Prince 2004-04-21 18:11:00 +00:00
parent 2f77cb9604
commit c08c972bce
17 changed files with 2198 additions and 5 deletions
Download patch file Download diff file Expand all files Collapse all files

395
src/java/org/lwjgl/util/Color.java Normal file
View file

@ -0,0 +1,395 @@
/*
* Copyright (c) 2002 Shaven Puppy Ltd
* 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 'Shaven Puppy' 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;
/**
* $Id$
* A mutable Color class
* @author $Author$
* @version $Revision$
*/
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();
}
}

156
src/java/org/lwjgl/util/Dimension.java Normal file
View file

@ -0,0 +1,156 @@
/*
* Copyright (c) 2002 Shaven Puppy Ltd
* 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 'Shaven Puppy' 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;
/**
* $Id$
* A 2D integer Dimension class, which looks remarkably like an AWT one.
* @author $Author$
* @version $Revision$
*/
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 <code>Dimension</code>.
*
* @return a hash code for this <code>Dimension</code>
*/
public int hashCode() {
int sum = width + height;
return sum * (sum + 1) / 2 + width;
}
/**
* Returns a string representation of the values of this
* <code>Dimension</code> object's <code>height</code> and
* <code>width</code> 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 <code>null</code>.
*
* @return a string representation of this <code>Dimension</code>
* 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;
}
}

237
src/java/org/lwjgl/util/Display.java Normal file
View file

@ -0,0 +1,237 @@
/*
* Copyright (c) 2002 Shaven Puppy Ltd
* 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 'Shaven Puppy' 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.lang.reflect.Field;
import java.util.*;
import java.util.ArrayList;
import java.util.Comparator;
import org.lwjgl.DisplayMode;
import org.lwjgl.Sys;
/**
* $Id$
* Display initialization utility, that can be used to find display modes and pick
* one for you based on your criteria.
* @author $Author$
* @version $Revision$
*/
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)
{
// First get the available display modes
DisplayMode[] modes = org.lwjgl.Display.getAvailableDisplayModes();
if (Sys.DEBUG || DEBUG) {
System.out.println("Available screen modes:");
for (int i = 0; i < modes.length; i ++) {
System.out.println(modes[i]);
}
}
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].width < minWidth)
continue;
if (maxWidth != -1 && modes[i].width > maxWidth)
continue;
if (minHeight != -1 && modes[i].height < minHeight)
continue;
if (maxHeight != -1 && modes[i].height > maxHeight)
continue;
if (minBPP != -1 && modes[i].bpp < minBPP)
continue;
if (maxBPP != -1 && modes[i].bpp > maxBPP)
continue;
//if (modes[i].bpp == 24)
// continue;
if (modes[i].freq != 0) {
if (minFreq != -1 && modes[i].freq < minFreq)
continue;
if (maxFreq != -1 && modes[i].freq > maxFreq)
continue;
}
matches.add(modes[i]);
}
DisplayMode[] ret = new DisplayMode[matches.size()];
matches.toArray(ret);
if (Sys.DEBUG && DEBUG) {
System.out.println("Filtered screen modes:");
for (int i = 0; i < ret.length; i ++) {
System.out.println(ret[i]);
}
}
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.
* @param fullscreen whether to go fullscreen
* @param title The app title
* @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.lwjgj.DisplayMode
*/
public static DisplayMode setDisplayMode(DisplayMode[] dm, final String[] param) throws Exception {
class Sorter implements Comparator {
final Field[] field;
final int[] order;
final boolean[] usePreferred;
final int[] preferred;
Sorter() throws NoSuchFieldException {
field = new Field[param.length];
order = new int[param.length];
preferred = new int[param.length];
usePreferred = new boolean[param.length];
for (int i = 0; i < field.length; i ++) {
int idx = param[i].indexOf('=');
if (idx > 0) {
preferred[i] = Integer.parseInt(param[i].substring(idx + 1, param[i].length()));
usePreferred[i] = true;
param[i] = param[i].substring(0, idx);
field[i] = DisplayMode.class.getField(param[i]);
} else if (param[i].charAt(0) == '-') {
field[i] = DisplayMode.class.getField(param[i].substring(1));
order[i] = -1;
} else {
field[i] = DisplayMode.class.getField(param[i]);
order[i] = 1;
}
}
}
/**
* @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
*/
public int compare(Object o1, Object o2) {
DisplayMode dm1 = (DisplayMode) o1;
DisplayMode dm2 = (DisplayMode) o2;
for (int i = 0; i < field.length; i ++) {
try {
int f1 = field[i].getInt(dm1);
int f2 = field[i].getInt(dm2);
if (usePreferred[i] && f1 != f2) {
if (f1 == preferred[i])
return -1;
else if (f2 == preferred[i])
return 1;
else {
// Score according to the difference between the values
int absf1 = Math.abs(f1 - preferred[i]);
int absf2 = Math.abs(f2 - preferred[i]);
if (absf1 < absf2)
return -1;
else if (absf1 > absf2)
return 1;
else
continue;
}
} else if (f1 < f2)
return order[i];
else if (f1 == f2)
continue;
else
return -order[i];
} catch (Exception e) {
assert false : e.getMessage();
}
}
return 0;
}
}
// Sort the display modes
Arrays.sort(dm, new Sorter());
// Try them out in the appropriate order
if (Sys.DEBUG || DEBUG) {
System.out.println("Sorted display modes:");
for (int i = 0; i < dm.length; i ++) {
System.out.println(dm[i]);
}
}
for (int i = 0; i < dm.length; i ++) {
try {
if (Sys.DEBUG || DEBUG)
System.out.println("Attempting to set displaymode: "+dm[i]);
org.lwjgl.Display.setDisplayMode(dm[i]);
return dm[i];
} catch (Exception e) {
if (Sys.DEBUG || DEBUG) {
System.out.println("Failed to set display mode to "+dm[i]);
e.printStackTrace();
}
}
}
throw new Exception("Failed to set display mode.");
}
}

169
src/java/org/lwjgl/util/Point.java Normal file
View file

@ -0,0 +1,169 @@
/*
* Copyright (c) 2002 Shaven Puppy Ltd
* 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 'Shaven Puppy' 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;
/**
* $Id$
* A 2D integer point class, which looks remarkably like an AWT one.
* @author $Author$
* @version $Revision$
*/
public final class Point implements ReadablePoint, WritablePoint, Serializable {
static final long serialVersionUID = 1L;
/** The location */
private int x, y;
/**
* Constructor for Point.
*/
public Point() {
super();
}
/**
* Constructor for Point.
*/
public Point(int x, int y) {
setLocation(x, y);
}
/**
* Constructor for Point.
*/
public Point(ReadablePoint p) {
setLocation(p);
}
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 setX(int x) {
this.x = x;
}
public void setY(int y) {
this.y = y;
}
/**
* Translate a point.
* @param x, y The translation to apply
*/
public void translate(int dx, int dy) {
this.x += dx;
this.y += dy;
}
/**
* Translate a point.
* @param p The translation to apply
*/
public void translate(ReadablePoint p) {
this.x += p.getX();
this.y += p.getY();
}
/**
* Un-translate a point.
* @param p The translation to apply
*/
public void untranslate(ReadablePoint p) {
this.x -= p.getX();
this.y -= p.getY();
}
/**
* Determines whether an instance of <code>Point2D</code> is equal
* to this point. Two instances of <code>Point2D</code> are equal if
* the values of their <code>x</code> and <code>y</code> member
* fields, representing their position in the coordinate space, are
* the same.
* @param obj an object to be compared with this point
* @return <code>true</code> if the object to be compared is
* an instance of <code>Point</code> and has
* the same values; <code>false</code> otherwise
*/
public boolean equals(Object obj) {
if (obj instanceof Point) {
Point pt = (Point) obj;
return (x == pt.x) && (y == pt.y);
}
return super.equals(obj);
}
/**
* Returns a string representation of this point and its location
* in the (<i>x</i>,&nbsp;<i>y</i>) coordinate space. 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 <code>null</code>.
*
* @return a string representation of this point
*/
public String toString() {
return getClass().getName() + "[x=" + x + ",y=" + y + "]";
}
/**
* Returns the hash code for this <code>Point</code>.
*
* @return a hash code for this <code>Point</code>
*/
public int hashCode() {
int sum = x + y;
return sum * (sum + 1) / 2 + x;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public void getLocation(WritablePoint dest) {
dest.setLocation(x, y);
}
}

146
src/java/org/lwjgl/util/ReadableColor.java Normal file
View file

@ -0,0 +1,146 @@
/*
* Copyright (c) 2003 Shaven Puppy Ltd
* 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 'Shaven Puppy' 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;
/**
* $Id$
* Readonly interface for Colors
* @author $Author$
* @version $Revision$
*/
public interface ReadableColor {
/**
* Return the red component (0..255)
* @return int
*/
public int getRed();
/**
* Return the red component (0..255)
* @return int
*/
public int getGreen();
/**
* Return the red component (0..255)
* @return int
*/
public int getBlue();
/**
* Return the red component (0..255)
* @return int
*/
public int getAlpha();
/**
* Return the red component
* @return int
*/
public byte getRedByte();
/**
* Return the red component
* @return int
*/
public byte getGreenByte();
/**
* Return the red component
* @return int
*/
public byte getBlueByte();
/**
* Return the red component
* @return int
*/
public byte getAlphaByte();
/**
* Write the RGBA color directly out to a ByteBuffer
* @param dest the buffer to write to
*/
public void writeRGBA(ByteBuffer dest);
/**
* Write the RGB color directly out to a ByteBuffer
* @param dest the buffer to write to
*/
public void writeRGB(ByteBuffer dest);
/**
* Write the ABGR color directly out to a ByteBuffer
* @param dest the buffer to write to
*/
public void writeABGR(ByteBuffer dest);
/**
* Write the BGR color directly out to a ByteBuffer
* @param dest the buffer to write to
*/
public void writeBGR(ByteBuffer dest);
/**
* Write the BGRA color directly out to a ByteBuffer
* @param dest the buffer to write to
*/
public void writeBGRA(ByteBuffer dest);
/**
* Write the ARGB color directly out to a ByteBuffer
* @param dest the buffer to write to
*/
public void writeARGB(ByteBuffer dest);
/*
* Some standard colors
*/
public static final ReadableColor RED = new Color(255, 0, 0);
public static final ReadableColor ORANGE = new Color(255, 128, 0);
public static final ReadableColor YELLOW = new Color(255, 255, 0);
public static final ReadableColor GREEN = new Color(0, 255, 0);
public static final ReadableColor CYAN = new Color(0, 255, 255);
public static final ReadableColor BLUE = new Color(0, 0, 255);
public static final ReadableColor PURPLE = new Color(255, 0, 255);
public static final ReadableColor WHITE = new Color(255, 255, 255);
public static final ReadableColor BLACK = new Color(0, 0, 0);
public static final ReadableColor LTGREY = new Color(192, 192, 192);
public static final ReadableColor DKGREY = new Color(64, 64, 64);
public static final ReadableColor GREY = new Color(128, 128, 128);
}

61
src/java/org/lwjgl/util/ReadableDimension.java Normal file
View file

@ -0,0 +1,61 @@
/*
* Copyright (c) 2003 Shaven Puppy Ltd
* 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 'Shaven Puppy' 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;
/**
* $Id$
* Readonly interface for Dimensions
* @author $Author$
* @version $Revision$
*/
public interface ReadableDimension {
/**
* Get the width
* @return int
*/
public int getWidth();
/**
* Get the height
* @return int
*/
public int getHeight();
/**
* Copy this ReadableDimension into a destination Dimension
* @param dest The destination
*/
public void getSize(WritableDimension dest);
}

58
src/java/org/lwjgl/util/ReadablePoint.java Normal file
View file

@ -0,0 +1,58 @@
/*
* Copyright (c) 2003 Shaven Puppy Ltd
* 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 'Shaven Puppy' 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;
/**
* $Id$
* Readonly interface for Points
* @author $Author$
* @version $Revision$
*/
public interface ReadablePoint {
/**
* @return int
*/
public int getX();
/**
* @return int
*/
public int getY();
/**
* Copy this ReadablePoint into a destination Point
* @param dest The destination Point, or null, to create a new Point
*/
public void getLocation(WritablePoint dest);
}

49
src/java/org/lwjgl/util/ReadableRectangle.java Normal file
View file

@ -0,0 +1,49 @@
/*
* Copyright (c) 2003 Shaven Puppy Ltd
* 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 'Shaven Puppy' 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;
/**
* $Id$
* Readonly interface for Rectangles
* @author $Author$
* @version $Revision$
*/
public interface ReadableRectangle extends ReadableDimension, ReadablePoint {
/**
* Copy this readable rectangle's bounds into a destination Rectangle
* @param dest The destination Rectangle, or null, to create a new Rectangle
*/
public void getBounds(WritableRectangle dest);
}

578
src/java/org/lwjgl/util/Rectangle.java Normal file
View file

@ -0,0 +1,578 @@
/*
* Copyright (c) 2002 Shaven Puppy Ltd
* 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 'Shaven Puppy' 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;
/**
* $Id$
* A 2D integer Rectangle class which looks remarkably like an AWT one.
* @author $Author$
* @version $Revision$
*/
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, y The translation amount
*/
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 <code>Rectangle</code> contains the
* specified <code>Point</code>.
* @param p the <code>Point</code> to test
* @return <code>true</code> if the <code>Point</code>
* (<i>x</i>,&nbsp;<i>y</i>) is inside this
* <code>Rectangle</code>;
* <code>false</code> otherwise.
*/
public boolean contains(ReadablePoint p) {
return contains(p.getX(), p.getY());
}
/**
* Checks whether or not this <code>Rectangle</code> contains the
* point at the specified location
* (<i>x</i>,&nbsp;<i>y</i>).
* @param X,&nbsp;Y the specified coordinates
* @return <code>true</code> if the point
* (<i>x</i>,&nbsp;<i>y</i>) is inside this
* <code>Rectangle</code>;
* <code>false</code> otherwise.
*/
public boolean contains(int X, int Y) {
int w = this.width;
int h = this.height;
if ((w | h) < 0) {
// At least one of the dimensions is negative...
return false;
}
// Note: if either dimension is zero, tests below must return false...
int x = this.x;
int y = this.y;
if (X < x || Y < y) {
return false;
}
w += x;
h += y;
// overflow || intersect
return ((w < x || w > X) && (h < y || h > Y));
}
/**
* Checks whether or not this <code>Rectangle</code> entirely contains
* the specified <code>Rectangle</code>.
* @param r the specified <code>Rectangle</code>
* @return <code>true</code> if the <code>Rectangle</code>
* is contained entirely inside this <code>Rectangle</code>;
* <code>false</code> otherwise.
*/
public boolean contains(ReadableRectangle r) {
return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
}
/**
* Checks whether this <code>Rectangle</code> entirely contains
* the <code>Rectangle</code>
* at the specified location (<i>X</i>,&nbsp;<i>Y</i>) with the
* specified dimensions (<i>W</i>,&nbsp;<i>H</i>).
* @param X,&nbsp;Y the specified coordinates
* @param W the width of the <code>Rectangle</code>
* @param H the height of the <code>Rectangle</code>
* @return <code>true</code> if the <code>Rectangle</code> specified by
* (<i>X</i>,&nbsp;<i>Y</i>,&nbsp;<i>W</i>,&nbsp;<i>H</i>)
* is entirely enclosed inside this <code>Rectangle</code>;
* <code>false</code> otherwise.
*/
public boolean contains(int X, int Y, int W, int H) {
int w = this.width;
int h = this.height;
if ((w | h | W | H) < 0) {
// At least one of the dimensions is negative...
return false;
}
// Note: if any dimension is zero, tests below must return false...
int x = this.x;
int y = this.y;
if (X < x || Y < y) {
return false;
}
w += x;
W += X;
if (W <= X) {
// X+W overflowed or W was zero, return false if...
// either original w or W was zero or
// x+w did not overflow or
// the overflowed x+w is smaller than the overflowed X+W
if (w >= x || W > w)
return false;
} else {
// X+W did not overflow and W was not zero, return false if...
// original w was zero or
// x+w did not overflow and x+w is smaller than X+W
if (w >= x && W > w)
return false;
}
h += y;
H += Y;
if (H <= Y) {
if (h >= y || H > h)
return false;
} else {
if (h >= y && H > h)
return false;
}
return true;
}
/**
* Determines whether or not this <code>Rectangle</code> and the specified
* <code>Rectangle</code> intersect. Two rectangles intersect if
* their intersection is nonempty.
*
* @param r the specified <code>Rectangle</code>
* @return <code>true</code> if the specified <code>Rectangle</code>
* and this <code>Rectangle</code> intersect;
* <code>false</code> otherwise.
*/
public boolean intersects(ReadableRectangle r) {
int tw = this.width;
int th = this.height;
int rw = r.getWidth();
int rh = r.getHeight();
if (rw <= 0 || rh <= 0 || tw <= 0 || th <= 0) {
return false;
}
int tx = this.x;
int ty = this.y;
int rx = r.getX();
int ry = r.getY();
rw += rx;
rh += ry;
tw += tx;
th += ty;
// overflow || intersect
return ((rw < rx || rw > tx) && (rh < ry || rh > ty) && (tw < tx || tw > rx) && (th < ty || th > ry));
}
/**
* Computes the intersection of this <code>Rectangle</code> with the
* specified <code>Rectangle</code>. Returns a new <code>Rectangle</code>
* that represents the intersection of the two rectangles.
* If the two rectangles do not intersect, the result will be
* an empty rectangle.
*
* @param r the specified <code>Rectangle</code>
* @return the largest <code>Rectangle</code> contained in both the
* specified <code>Rectangle</code> and in
* this <code>Rectangle</code>; or if the rectangles
* do not intersect, an empty rectangle.
*/
public Rectangle intersection(ReadableRectangle r, Rectangle dest) {
int tx1 = this.x;
int ty1 = this.y;
int rx1 = r.getX();
int ry1 = r.getY();
long tx2 = tx1;
tx2 += this.width;
long ty2 = ty1;
ty2 += this.height;
long rx2 = rx1;
rx2 += r.getWidth();
long ry2 = ry1;
ry2 += r.getHeight();
if (tx1 < rx1)
tx1 = rx1;
if (ty1 < ry1)
ty1 = ry1;
if (tx2 > rx2)
tx2 = rx2;
if (ty2 > ry2)
ty2 = ry2;
tx2 -= tx1;
ty2 -= ty1;
// tx2,ty2 will never overflow (they will never be
// larger than the smallest of the two source w,h)
// they might underflow, though...
if (tx2 < Integer.MIN_VALUE)
tx2 = Integer.MIN_VALUE;
if (ty2 < Integer.MIN_VALUE)
ty2 = Integer.MIN_VALUE;
if (dest == null)
dest = new Rectangle(tx1, ty1, (int) tx2, (int) ty2);
else
dest.setBounds(tx1, ty1, (int) tx2, (int) ty2);
return dest;
}
/**
* Computes the union of this <code>Rectangle</code> with the
* specified <code>Rectangle</code>. Returns a new
* <code>Rectangle</code> that
* represents the union of the two rectangles
* @param r the specified <code>Rectangle</code>
* @return the smallest <code>Rectangle</code> containing both
* the specified <code>Rectangle</code> and this
* <code>Rectangle</code>.
*/
public WritableRectangle union(ReadableRectangle r, WritableRectangle dest) {
int x1 = Math.min(x, r.getX());
int x2 = Math.max(x + width, r.getX() + r.getWidth());
int y1 = Math.min(y, r.getY());
int y2 = Math.max(y + height, r.getY() + r.getHeight());
dest.setBounds(x1, y1, x2 - x1, y2 - y1);
return dest;
}
/**
* Adds a point, specified by the integer arguments <code>newx</code>
* and <code>newy</code>, to this <code>Rectangle</code>. The
* resulting <code>Rectangle</code> is
* the smallest <code>Rectangle</code> that contains both the
* original <code>Rectangle</code> and the specified point.
* <p>
* After adding a point, a call to <code>contains</code> with the
* added point as an argument does not necessarily return
* <code>true</code>. The <code>contains</code> method does not
* return <code>true</code> for points on the right or bottom
* edges of a <code>Rectangle</code>. Therefore, if the added point
* falls on the right or bottom edge of the enlarged
* <code>Rectangle</code>, <code>contains</code> returns
* <code>false</code> for that point.
* @param newx,&nbsp;newy the coordinates of the new point
*/
public void add(int newx, int newy) {
int x1 = Math.min(x, newx);
int x2 = Math.max(x + width, newx);
int y1 = Math.min(y, newy);
int y2 = Math.max(y + height, newy);
x = x1;
y = y1;
width = x2 - x1;
height = y2 - y1;
}
/**
* Adds the specified <code>Point</code> to this
* <code>Rectangle</code>. The resulting <code>Rectangle</code>
* is the smallest <code>Rectangle</code> that contains both the
* original <code>Rectangle</code> and the specified
* <code>Point</code>.
* <p>
* After adding a <code>Point</code>, a call to <code>contains</code>
* with the added <code>Point</code> as an argument does not
* necessarily return <code>true</code>. The <code>contains</code>
* method does not return <code>true</code> for points on the right
* or bottom edges of a <code>Rectangle</code>. Therefore if the added
* <code>Point</code> falls on the right or bottom edge of the
* enlarged <code>Rectangle</code>, <code>contains</code> returns
* <code>false</code> for that <code>Point</code>.
* @param pt the new <code>Point</code> to add to this
* <code>Rectangle</code>
*/
public void add(ReadablePoint pt) {
add(pt.getX(), pt.getY());
}
/**
* Adds a <code>Rectangle</code> to this <code>Rectangle</code>.
* The resulting <code>Rectangle</code> is the union of the two
* rectangles.
* @param r the specified <code>Rectangle</code>
*/
public void add(ReadableRectangle r) {
int x1 = Math.min(x, r.getX());
int x2 = Math.max(x + width, r.getX() + r.getWidth());
int y1 = Math.min(y, r.getY());
int y2 = Math.max(y + height, r.getY() + r.getHeight());
x = x1;
y = y1;
width = x2 - x1;
height = y2 - y1;
}
/**
* Resizes the <code>Rectangle</code> both horizontally and vertically.
* <p>
* This method modifies the <code>Rectangle</code> so that it is
* <code>h</code> units larger on both the left and right side,
* and <code>v</code> units larger at both the top and bottom.
* <p>
* The new <code>Rectangle</code> has (<code>x&nbsp;-&nbsp;h</code>,
* <code>y&nbsp;-&nbsp;v</code>) as its top-left corner, a
* width of
* <code>width</code>&nbsp;<code>+</code>&nbsp;<code>2h</code>,
* and a height of
* <code>height</code>&nbsp;<code>+</code>&nbsp;<code>2v</code>.
* <p>
* If negative values are supplied for <code>h</code> and
* <code>v</code>, the size of the <code>Rectangle</code>
* decreases accordingly.
* The <code>grow</code> method does not check whether the resulting
* values of <code>width</code> and <code>height</code> are
* non-negative.
* @param h the horizontal expansion
* @param v the vertical expansion
*/
public void grow(int h, int v) {
x -= h;
y -= v;
width += h * 2;
height += v * 2;
}
/**
* Determines whether or not this <code>Rectangle</code> is empty. A
* <code>Rectangle</code> is empty if its width or its height is less
* than or equal to zero.
* @return <code>true</code> if this <code>Rectangle</code> is empty;
* <code>false</code> otherwise.
*/
public boolean isEmpty() {
return (width <= 0) || (height <= 0);
}
/**
* Checks whether two rectangles are equal.
* <p>
* The result is <code>true</code> if and only if the argument is not
* <code>null</code> and is a <code>Rectangle</code> object that has the
* same top-left corner, width, and height as this <code>Rectangle</code>.
* @param obj the <code>Object</code> to compare with
* this <code>Rectangle</code>
* @return <code>true</code> if the objects are equal;
* <code>false</code> otherwise.
*/
public boolean equals(Object obj) {
if (obj instanceof Rectangle) {
Rectangle r = (Rectangle) obj;
return ((x == r.x) && (y == r.y) && (width == r.width) && (height == r.height));
}
return super.equals(obj);
}
/**
* Debugging
* @return a String
*/
public String toString() {
return getClass().getName() + "[x=" + x + ",y=" + y + ",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;
}
/**
* Gets the x.
* @return Returns a int
*/
public int getX() {
return x;
}
/**
* Sets the x.
* @param x The x to set
*/
public void setX(int x) {
this.x = x;
}
/**
* Gets the y.
* @return Returns a int
*/
public int getY() {
return y;
}
/**
* Sets the y.
* @param y The y to set
*/
public void setY(int y) {
this.y = y;
}
}

127
src/java/org/lwjgl/util/WritableColor.java Normal file
View file

@ -0,0 +1,127 @@
/*
* Copyright (c) 2003 Shaven Puppy Ltd
* 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 'Shaven Puppy' 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;
/**
* $Id$
* Write interface for Colors
* @author $Author$
* @version $Revision$
*/
public interface WritableColor {
/**
* Set a color
*/
public void set(int r, int g, int b, int a);
/**
* Set a color
*/
public void set(byte r, byte g, byte b, byte a);
/**
* Set a color
*/
public void set(int r, int g, int b);
/**
* Set a color
*/
public void set(byte r, byte g, byte b);
/**
* Set the Red component
*/
public void setRed(int red);
/**
* Set the Green component
*/
public void setGreen(int green);
/**
* Set the Blue component
*/
public void setBlue(int blue);
/**
* Set the Alpha component
*/
public void setAlpha(int alpha);
/**
* Set the Red component
*/
public void setRed(byte red);
/**
* Set the Green component
*/
public void setGreen(byte green);
/**
* Set the Blue component
*/
public void setBlue(byte blue);
/**
* Set the Alpha component
*/
public void setAlpha(byte alpha);
/**
* Read a color from a byte buffer
* @param src The source buffer
*/
public void readRGBA(ByteBuffer src);
/**
* Read a color from a byte buffer
* @param src The source buffer
*/
public void readRGB(ByteBuffer src);
/**
* Read a color from a byte buffer
* @param src The source buffer
*/
public void readARGB(ByteBuffer src);
/**
* Read a color from a byte buffer
* @param src The source buffer
*/
public void readBGRA(ByteBuffer src);
/**
* Read a color from a byte buffer
* @param src The source buffer
*/
public void readBGR(ByteBuffer src);
/**
* Read a color from a byte buffer
* @param src The source buffer
*/
public void readABGR(ByteBuffer src);
/**
* Set this color's color by copying another color
* @param src The source color
*/
public void setColor(ReadableColor src);
}

54
src/java/org/lwjgl/util/WritableDimension.java Normal file
View file

@ -0,0 +1,54 @@
/*
* Copyright (c) 2003 Shaven Puppy Ltd
* 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 'Shaven Puppy' 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;
/**
* $Id$
* Write interface for Dimensions
* @author $Author$
* @version $Revision$
*/
public interface WritableDimension {
public void setSize(int w, int h);
public void setSize(ReadableDimension d);
/**
* Sets the height.
* @param height The height to set
*/
public void setHeight(int height);
/**
* Sets the width.
* @param width The width to set
*/
public void setWidth(int width);
}

45
src/java/org/lwjgl/util/WritablePoint.java Normal file
View file

@ -0,0 +1,45 @@
/*
* Copyright (c) 2003 Shaven Puppy Ltd
* 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 'Shaven Puppy' 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;
/**
* $Id$
* Write interface for Points
* @author $Author$
* @version $Revision$
*/
public interface WritablePoint {
public void setLocation(int x, int y);
public void setLocation(ReadablePoint p);
public void setX(int x);
public void setY(int y);
}

60
src/java/org/lwjgl/util/WritableRectangle.java Normal file
View file

@ -0,0 +1,60 @@
/*
* Copyright (c) 2003 Shaven Puppy Ltd
* 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 'Shaven Puppy' 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;
/**
* $Id$
* Write interface for Rectangles
* @author $Author$
* @version $Revision$
*/
public interface WritableRectangle extends WritablePoint, WritableDimension {
/**
* Sets the bounds of the rectangle
* @param x, y, width, height
*/
public void setBounds(int x, int y, int width, int height);
/**
* Sets the bounds of the rectangle
* @param location
* @param size
*/
public void setBounds(ReadablePoint location, ReadableDimension size);
/**
* Sets the bounds of the rectangle
* @param src
*/
public void setBounds(ReadableRectangle src);
}

6
src/java/org/lwjgl/util/model/BonedModel.java
View file

@ -34,6 +34,7 @@ package org.lwjgl.util.model;
import java.util.Map;
import org.lwjgl.util.Color;
import org.lwjgl.util.vector.Vector2f;
@ -60,11 +61,12 @@ public class BonedModel extends Model {
* @param material
* @param triangle
* @param skin[]
* @param color[]
* @param animation
* @param vertex
*/
public BonedModel(String material, Triangle[] triangle, Vector2f[] skin, Map animation, BonedVertex[] vertex) {
super(material, triangle, skin, animation);
public BonedModel(String material, Triangle[] triangle, Vector2f[] skin, Color[] color, Map animation, BonedVertex[] vertex) {
super(material, triangle, skin, color, animation);
this.vertex = vertex;
}

6
src/java/org/lwjgl/util/model/MeshedModel.java
View file

@ -34,6 +34,7 @@ package org.lwjgl.util.model;
import java.util.Map;
import org.lwjgl.util.Color;
import org.lwjgl.util.vector.Vector2f;
@ -57,10 +58,11 @@ public class MeshedModel extends Model {
* @param material
* @param triangle
* @param skin[]
* @param color[]
* @param animation
*/
public MeshedModel(String material, Triangle[] triangle, Vector2f[] skin, Map animation) {
super(material, triangle, skin, animation);
public MeshedModel(String material, Triangle[] triangle, Vector2f[] skin, Color[] color, Map animation) {
super(material, triangle, skin, color, animation);
}
}

16
src/java/org/lwjgl/util/model/Model.java
View file

@ -35,6 +35,7 @@ package org.lwjgl.util.model;
import java.io.Serializable;
import java.util.Map;
import org.lwjgl.util.Color;
import org.lwjgl.util.vector.Vector2f;
@ -60,6 +61,9 @@ public abstract class Model implements Serializable {
/** Skin */
private final Vector2f[] skin;
/** Colour */
private final Color[] color;
/** The animations: a Map of string names to Frame[] arrays */
private final Map animation;
@ -68,12 +72,14 @@ public abstract class Model implements Serializable {
* @param material
* @param triangle
* @param skin[]
* @param color[]
* @param animation
*/
public Model(String material, Triangle[] triangle, Vector2f[] skin, Map animation) {
public Model(String material, Triangle[] triangle, Vector2f[] skin, Color[] color, Map animation) {
this.material = material;
this.triangle = triangle;
this.skin = skin;
this.color = color;
this.animation = animation;
}
@ -107,4 +113,12 @@ public abstract class Model implements Serializable {
return skin;
}
/**
* @return Returns the color
*/
public final Color[] getColor() {
return color;
}
}

40
src/java/org/lwjgl/util/model/loader/Loader.java
View file

@ -36,6 +36,7 @@ import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.lwjgl.util.Color;
import org.lwjgl.util.model.*;
import org.lwjgl.util.model.BoneFrame;
import org.lwjgl.util.model.BonedModel;
@ -92,6 +93,7 @@ public class Loader {
material,
loadTriangles(),
loadSkin(),
loadColor(),
loadBoneAnimations(),
loadBonedVertices()
);
@ -101,6 +103,7 @@ public class Loader {
material,
loadTriangles(),
loadSkin(),
loadColor(),
loadMeshAnimations()
);
} else {
@ -149,6 +152,28 @@ public class Loader {
return skins;
}
/**
* Load the colour
* @return Color[]
* @throws Exception
*/
private Color[] loadColor() throws Exception {
List colorElements = XMLUtil.getChildren(src.getDocumentElement(), "color");
if (colorElements.size() == 0) {
return null;
}
if (colorElements.size() != numVertices) {
throw new Exception("Color count incorrect, got "+colorElements.size()+", expected "+numVertices);
}
Color[] colors = new Color[colorElements.size()];
int colorCount = 0;
for (Iterator i = colorElements.iterator(); i.hasNext(); ) {
Element colorElement = (Element) i.next();
colors[colorCount++] = loadColor(colorElement);
}
return colors;
}
/**
* Load all the Triangles
* @return Triangle[]
@ -317,6 +342,21 @@ public class Loader {
);
}
/**
* Load a colour from XML
* @param element
* @return a Color
* @throws Exception
*/
private Color loadColor(Element element) throws Exception {
return new Color(
XMLUtil.getInt(element, "r"),
XMLUtil.getInt(element, "g"),
XMLUtil.getInt(element, "b"),
XMLUtil.getInt(element, "a", 255)
);
}
/**
* Load a boned Animation from XML
* @param element