Here is a somewhat basic version with working Tracking.
and I plan on having a additionalswitch to store EVERY stacktrace to the allocated buffers, and allow to print out wich function has how much currently alive directmemorybuffers allocated. This will help everyone trying to find directmemory leaks.
[java]/*
*/
public static FloatBuffer createFloatBuffer(final Vector3f… data) {
if (data == null) {
return null;
}
final FloatBuffer buff = createFloatBuffer(3 * data.length);
for (int x = 0; x < data.length; x++) {
if (data[x] != null) {
buff.put(data[x].x).put(data[x].y).put(data[x].z);
} else {
buff.put(0).put(0).put(0);
}
}
buff.flip();
return buff;
}
/**
*/
public static FloatBuffer createFloatBuffer(final Quaternion… data) {
if (data == null) {
return null;
}
final FloatBuffer buff = createFloatBuffer(4 * data.length);
for (int x = 0; x < data.length; x++) {
if (data[x] != null) {
buff.put(data[x].getX()).put(data[x].getY()).put(data[x].getZ()).put(data[x].getW());
} else {
buff.put(0).put(0).put(0);
}
}
buff.flip();
return buff;
}
/**
*/
public static FloatBuffer createFloatBuffer(final float… data) {
if (data == null) {
return null;
}
final FloatBuffer buff = createFloatBuffer(data.length);
buff.clear();
buff.put(data);
buff.flip();
return buff;
}
/**
- Create a new FloatBuffer of an appropriate size to hold the specified
- number of Vector3f object data.
*
-
@param vertices
-
number of vertices that need to be held by the newly created<br />
-
buffer<br />
-
@return the requested new FloatBuffer
*/
public static FloatBuffer createVector3Buffer(final int vertices) {
final FloatBuffer vBuff = createFloatBuffer(3 * vertices);
return vBuff;
}
/**
- Create a new FloatBuffer of an appropriate size to hold the specified
- number of Vector3f object data only if the given buffer if not already
- the right size.
*
-
@param buf
-
the buffer to first check and rewind<br />
-
@param vertices
-
number of vertices that need to be held by the newly created<br />
-
buffer<br />
-
@return the requested new FloatBuffer
*/
public static FloatBuffer createVector3Buffer(final FloatBuffer buf, final int vertices) {
if (buf != null && buf.limit() == 3 * vertices) {
buf.rewind();
return buf;
}
return createFloatBuffer(3 * vertices);
}
/**
- Sets the data contained in the given color into the FloatBuffer at the
- specified index.
*
-
@param color
-
the data to insert<br />
-
@param buf
-
the buffer to insert into<br />
-
@param index
-
the postion to place the data; in terms of colors not floats<br />
*/
public static void setInBuffer(final ColorRGBA color, final FloatBuffer buf, final int index) {
buf.position(index * 4);
buf.put(color.r);
buf.put(color.g);
buf.put(color.b);
buf.put(color.a);
}
/**
- Sets the data contained in the given quaternion into the FloatBuffer at
- the specified index.
*
-
@param quat
-
the {@link Quaternion} to insert<br />
-
@param buf
-
the buffer to insert into<br />
-
@param index
-
the postion to place the data; in terms of quaternions not<br />
-
floats<br />
*/
public static void setInBuffer(final Quaternion quat, final FloatBuffer buf, final int index) {
buf.position(index * 4);
buf.put(quat.getX());
buf.put(quat.getY());
buf.put(quat.getZ());
buf.put(quat.getW());
}
/**
*/
public static void setInBuffer(final Vector3f vector, final FloatBuffer buf, final int index) {
if (buf == null) {
return;
}
if (vector == null) {
buf.put(index * 3, 0);
buf.put((index * 3) + 1, 0);
buf.put((index * 3) + 2, 0);
} else {
buf.put(index * 3, vector.x);
buf.put((index * 3) + 1, vector.y);
buf.put((index * 3) + 2, vector.z);
}
}
/**
- Updates the values of the given vector from the specified buffer at the
- index provided.
*
-
@param vector
-
the vector to set data on<br />
-
@param buf
-
the buffer to read from<br />
-
@param index
-
the position (in terms of vectors, not floats) to read from<br />
-
the buf<br />
*/
public static void populateFromBuffer(final Vector3f vector, final FloatBuffer buf, final int index) {
vector.x = buf.get(index * 3);
vector.y = buf.get(index * 3 + 1);
vector.z = buf.get(index * 3 + 2);
}
/**
- Generates a Vector3f array from the given FloatBuffer.
*
-
@param buff
-
the FloatBuffer to read from<br />
-
@return a newly generated array of Vector3f objects
*/
public static Vector3f[] getVector3Array(final FloatBuffer buff) {
buff.clear();
final Vector3f[] verts = new Vector3f[buff.limit() / 3];
for (int x = 0; x < verts.length; x++) {
final Vector3f v = new Vector3f(buff.get(), buff.get(), buff.get());
verts[x] = v;
}
return verts;
}
/**
- Copies a Vector3f from one position in the buffer to another. The index
- values are in terms of vector number (eg, vector number 0 is postions 0-2
- in the FloatBuffer.)
*
-
@param buf
-
the buffer to copy from/to<br />
-
@param fromPos
-
the index of the vector to copy<br />
-
@param toPos
-
the index to copy the vector to<br />
*/
public static void copyInternalVector3(final FloatBuffer buf, final int fromPos, final int toPos) {
copyInternal(buf, fromPos * 3, toPos * 3, 3);
}
/**
- Normalize a Vector3f in-buffer.
*
-
@param buf
-
the buffer to find the Vector3f within<br />
-
@param index
-
the position (in terms of vectors, not floats) of the vector<br />
-
to normalize<br />
*/
public static void normalizeVector3(final FloatBuffer buf, final int index) {
final TempVars vars = TempVars.get();
final Vector3f tempVec3 = vars.vect1;
populateFromBuffer(tempVec3, buf, index);
tempVec3.normalizeLocal();
setInBuffer(tempVec3, buf, index);
vars.release();
}
/**
- Add to a Vector3f in-buffer.
*
-
@param toAdd
-
the vector to add from<br />
-
@param buf
-
the buffer to find the Vector3f within<br />
-
@param index
-
the position (in terms of vectors, not floats) of the vector<br />
-
to add to<br />
*/
public static void addInBuffer(final Vector3f toAdd, final FloatBuffer buf, final int index) {
final TempVars vars = TempVars.get();
final Vector3f tempVec3 = vars.vect1;
populateFromBuffer(tempVec3, buf, index);
tempVec3.addLocal(toAdd);
setInBuffer(tempVec3, buf, index);
vars.release();
}
/**
- Multiply and store a Vector3f in-buffer.
*
-
@param toMult
-
the vector to multiply against<br />
-
@param buf
-
the buffer to find the Vector3f within<br />
-
@param index
-
the position (in terms of vectors, not floats) of the vector<br />
-
to multiply<br />
*/
public static void multInBuffer(final Vector3f toMult, final FloatBuffer buf, final int index) {
final TempVars vars = TempVars.get();
final Vector3f tempVec3 = vars.vect1;
populateFromBuffer(tempVec3, buf, index);
tempVec3.multLocal(toMult);
setInBuffer(tempVec3, buf, index);
vars.release();
}
/**
- Checks to see if the given Vector3f is equals to the data stored in the
- buffer at the given data index.
*
-
@param check
-
the vector to check against - null will return false.<br />
-
@param buf
-
the buffer to compare data with<br />
-
@param index
-
the position (in terms of vectors, not floats) of the vector<br />
-
in the buffer to check against<br />
-
@return
*/
public static boolean equals(final Vector3f check, final FloatBuffer buf, final int index) {
final TempVars vars = TempVars.get();
final Vector3f tempVec3 = vars.vect1;
populateFromBuffer(tempVec3, buf, index);
final boolean eq = tempVec3.equals(check);
vars.release();
return eq;
}
// // – VECTOR2F METHODS – ////
/**
- Generate a new FloatBuffer using the given array of Vector2f objects. The
- FloatBuffer will be 2 * data.length long and contain the vector data as
- data[0].x, data[0].y, data[1].x… etc.
*
-
@param data
-
array of Vector2f objects to place into a new FloatBuffer<br />
*/
public static FloatBuffer createFloatBuffer(final Vector2f… data) {
if (data == null) {
return null;
}
final FloatBuffer buff = createFloatBuffer(2 * data.length);
for (int x = 0; x < data.length; x++) {
if (data[x] != null) {
buff.put(data[x].x).put(data[x].y);
} else {
buff.put(0).put(0);
}
}
buff.flip();
return buff;
}
/**
- Create a new FloatBuffer of an appropriate size to hold the specified
- number of Vector2f object data.
*
-
@param vertices
-
number of vertices that need to be held by the newly created<br />
-
buffer<br />
-
@return the requested new FloatBuffer
*/
public static FloatBuffer createVector2Buffer(final int vertices) {
final FloatBuffer vBuff = createFloatBuffer(2 * vertices);
return vBuff;
}
/**
- Create a new FloatBuffer of an appropriate size to hold the specified
- number of Vector2f object data only if the given buffer if not already
- the right size.
*
-
@param buf
-
the buffer to first check and rewind<br />
-
@param vertices
-
number of vertices that need to be held by the newly created<br />
-
buffer<br />
-
@return the requested new FloatBuffer
*/
public static FloatBuffer createVector2Buffer(final FloatBuffer buf, final int vertices) {
if (buf != null && buf.limit() == 2 * vertices) {
buf.rewind();
return buf;
}
return createFloatBuffer(2 * vertices);
}
/**
- Sets the data contained in the given Vector2F into the FloatBuffer at the
- specified index.
*
-
@param vector
-
the data to insert<br />
-
@param buf
-
the buffer to insert into<br />
-
@param index
-
the postion to place the data; in terms of vectors not floats<br />
*/
public static void setInBuffer(final Vector2f vector, final FloatBuffer buf, final int index) {
buf.put(index * 2, vector.x);
buf.put((index * 2) + 1, vector.y);
}
/**
- Updates the values of the given vector from the specified buffer at the
- index provided.
*
-
@param vector
-
the vector to set data on<br />
-
@param buf
-
the buffer to read from<br />
-
@param index
-
the position (in terms of vectors, not floats) to read from<br />
-
the buf<br />
*/
public static void populateFromBuffer(final Vector2f vector, final FloatBuffer buf, final int index) {
vector.x = buf.get(index * 2);
vector.y = buf.get(index * 2 + 1);
}
/**
- Generates a Vector2f array from the given FloatBuffer.
*
-
@param buff
-
the FloatBuffer to read from<br />
-
@return a newly generated array of Vector2f objects
*/
public static Vector2f[] getVector2Array(final FloatBuffer buff) {
buff.clear();
final Vector2f[] verts = new Vector2f[buff.limit() / 2];
for (int x = 0; x < verts.length; x++) {
final Vector2f v = new Vector2f(buff.get(), buff.get());
verts[x] = v;
}
return verts;
}
/**
- Copies a Vector2f from one position in the buffer to another. The index
- values are in terms of vector number (eg, vector number 0 is postions 0-1
- in the FloatBuffer.)
*
-
@param buf
-
the buffer to copy from/to<br />
-
@param fromPos
-
the index of the vector to copy<br />
-
@param toPos
-
the index to copy the vector to<br />
*/
public static void copyInternalVector2(final FloatBuffer buf, final int fromPos, final int toPos) {
copyInternal(buf, fromPos * 2, toPos * 2, 2);
}
/**
- Normalize a Vector2f in-buffer.
*
-
@param buf
-
the buffer to find the Vector2f within<br />
-
@param index
-
the position (in terms of vectors, not floats) of the vector<br />
-
to normalize<br />
*/
public static void normalizeVector2(final FloatBuffer buf, final int index) {
final TempVars vars = TempVars.get();
final Vector2f tempVec2 = vars.vect2d;
populateFromBuffer(tempVec2, buf, index);
tempVec2.normalizeLocal();
setInBuffer(tempVec2, buf, index);
vars.release();
}
/**
- Add to a Vector2f in-buffer.
*
-
@param toAdd
-
the vector to add from<br />
-
@param buf
-
the buffer to find the Vector2f within<br />
-
@param index
-
the position (in terms of vectors, not floats) of the vector<br />
-
to add to<br />
*/
public static void addInBuffer(final Vector2f toAdd, final FloatBuffer buf, final int index) {
final TempVars vars = TempVars.get();
final Vector2f tempVec2 = vars.vect2d;
populateFromBuffer(tempVec2, buf, index);
tempVec2.addLocal(toAdd);
setInBuffer(tempVec2, buf, index);
vars.release();
}
/**
- Multiply and store a Vector2f in-buffer.
*
-
@param toMult
-
the vector to multiply against<br />
-
@param buf
-
the buffer to find the Vector2f within<br />
-
@param index
-
the position (in terms of vectors, not floats) of the vector<br />
-
to multiply<br />
*/
public static void multInBuffer(final Vector2f toMult, final FloatBuffer buf, final int index) {
final TempVars vars = TempVars.get();
final Vector2f tempVec2 = vars.vect2d;
populateFromBuffer(tempVec2, buf, index);
tempVec2.multLocal(toMult);
setInBuffer(tempVec2, buf, index);
vars.release();
}
/**
- Checks to see if the given Vector2f is equals to the data stored in the
- buffer at the given data index.
*
-
@param check
-
the vector to check against - null will return false.<br />
-
@param buf
-
the buffer to compare data with<br />
-
@param index
-
the position (in terms of vectors, not floats) of the vector<br />
-
in the buffer to check against<br />
-
@return
*/
public static boolean equals(final Vector2f check, final FloatBuffer buf, final int index) {
final TempVars vars = TempVars.get();
final Vector2f tempVec2 = vars.vect2d;
populateFromBuffer(tempVec2, buf, index);
final boolean eq = tempVec2.equals(check);
vars.release();
return eq;
}
// // – INT METHODS – ////
/**
- Generate a new IntBuffer using the given array of ints. The IntBuffer
- will be data.length long and contain the int data as data[0], data[1]…
- etc.
*
-
@param data
-
array of ints to place into a new IntBuffer<br />
*/
public static IntBuffer createIntBuffer(final int… data) {
if (data == null) {
return null;
}
final IntBuffer buff = createIntBuffer(data.length);
buff.clear();
buff.put(data);
buff.flip();
return buff;
}
/**
- Create a new int[] array and populate it with the given IntBuffer’s
- contents.
*
-
@param buff
-
the IntBuffer to read from<br />
-
@return a new int array populated from the IntBuffer
*/
public static int[] getIntArray(final IntBuffer buff) {
if (buff == null) {
return null;
}
buff.clear();
final int[] inds = new int[buff.limit()];
for (int x = 0; x < inds.length; x++) {
inds[x] = buff.get();
}
return inds;
}
/**
- Create a new float[] array and populate it with the given FloatBuffer’s
- contents.
*
-
@param buff
-
the FloatBuffer to read from<br />
-
@return a new float array populated from the FloatBuffer
*/
public static float[] getFloatArray(final FloatBuffer buff) {
if (buff == null) {
return null;
}
buff.clear();
final float[] inds = new float[buff.limit()];
for (int x = 0; x < inds.length; x++) {
inds[x] = buff.get();
}
return inds;
}
// // – GENERAL DOUBLE ROUTINES – ////
/**
- Create a new DoubleBuffer of the specified size.
*
-
@param size
-
required number of double to store.<br />
-
@return the new DoubleBuffer
*/
public static DoubleBuffer createDoubleBuffer(final int size) {
final DoubleBuffer buf = ByteBuffer.allocateDirect(8 * size).order(ByteOrder.nativeOrder()).asDoubleBuffer();
buf.clear();
onBufferAllocated(buf);
return buf;
}
/**
- Create a new DoubleBuffer of an appropriate size to hold the specified
- number of doubles only if the given buffer if not already the right size.
*
-
@param buf
-
the buffer to first check and rewind<br />
-
@param size
-
number of doubles that need to be held by the newly created<br />
-
buffer<br />
-
@return the requested new DoubleBuffer
*/
public static DoubleBuffer createDoubleBuffer(DoubleBuffer buf, final int size) {
if (buf != null && buf.limit() == size) {
buf.rewind();
return buf;
}
buf = createDoubleBuffer(size);
return buf;
}
/**
- Creates a new DoubleBuffer with the same contents as the given
- DoubleBuffer. The new DoubleBuffer is seperate from the old one and
- changes are not reflected across. If you want to reflect changes,
- consider using Buffer.duplicate().
*
-
@param buf
-
the DoubleBuffer to copy<br />
-
@return the copy
*/
public static DoubleBuffer clone(final DoubleBuffer buf) {
if (buf == null) {
return null;
}
buf.rewind();
DoubleBuffer copy;
if (buf.isDirect()) {
copy = createDoubleBuffer(buf.limit());
} else {
copy = DoubleBuffer.allocate(buf.limit());
}
copy.put(buf);
return copy;
}
// // – GENERAL FLOAT ROUTINES – ////
/**
- Create a new FloatBuffer of the specified size.
*
-
@param size
-
required number of floats to store.<br />
-
@return the new FloatBuffer
*/
public static FloatBuffer createFloatBuffer(final int size) {
final FloatBuffer buf = ByteBuffer.allocateDirect(4 * size).order(ByteOrder.nativeOrder()).asFloatBuffer();
buf.clear();
onBufferAllocated(buf);
return buf;
}
/**
- Copies floats from one position in the buffer to another.
*
-
@param buf
-
the buffer to copy from/to<br />
-
@param fromPos
-
the starting point to copy from<br />
-
@param toPos
-
the starting point to copy to<br />
-
@param length
-
the number of floats to copy<br />
*/
public static void copyInternal(final FloatBuffer buf, final int fromPos, final int toPos, final int length) {
final float[] data = new float[length];
buf.position(fromPos);
buf.get(data);
buf.position(toPos);
buf.put(data);
}
/**
- Creates a new FloatBuffer with the same contents as the given
- FloatBuffer. The new FloatBuffer is seperate from the old one and changes
- are not reflected across. If you want to reflect changes, consider using
- Buffer.duplicate().
*
-
@param buf
-
the FloatBuffer to copy<br />
-
@return the copy
*/
public static FloatBuffer clone(final FloatBuffer buf) {
if (buf == null) {
return null;
}
buf.rewind();
FloatBuffer copy;
if (buf.isDirect()) {
copy = createFloatBuffer(buf.limit());
} else {
copy = FloatBuffer.allocate(buf.limit());
}
copy.put(buf);
return copy;
}
// // – GENERAL INT ROUTINES – ////
/**
- Create a new IntBuffer of the specified size.
*
-
@param size
-
required number of ints to store.<br />
-
@return the new IntBuffer
*/
public static IntBuffer createIntBuffer(final int size) {
final IntBuffer buf = ByteBuffer.allocateDirect(4 * size).order(ByteOrder.nativeOrder()).asIntBuffer();
buf.clear();
onBufferAllocated(buf);
return buf;
}
/**
- Create a new IntBuffer of an appropriate size to hold the specified
- number of ints only if the given buffer if not already the right size.
*
-
@param buf
-
the buffer to first check and rewind<br />
-
@param size
-
number of ints that need to be held by the newly created<br />
-
buffer<br />
-
@return the requested new IntBuffer
*/
public static IntBuffer createIntBuffer(IntBuffer buf, final int size) {
if (buf != null && buf.limit() == size) {
buf.rewind();
return buf;
}
buf = createIntBuffer(size);
return buf;
}
/**
- Creates a new IntBuffer with the same contents as the given IntBuffer.
- The new IntBuffer is seperate from the old one and changes are not
- reflected across. If you want to reflect changes, consider using
- Buffer.duplicate().
*
-
@param buf
-
the IntBuffer to copy<br />
-
@return the copy
*/
public static IntBuffer clone(final IntBuffer buf) {
if (buf == null) {
return null;
}
buf.rewind();
IntBuffer copy;
if (buf.isDirect()) {
copy = createIntBuffer(buf.limit());
} else {
copy = IntBuffer.allocate(buf.limit());
}
copy.put(buf);
return copy;
}
// // – GENERAL BYTE ROUTINES – ////
/**
- Create a new ByteBuffer of the specified size.
*
-
@param size
-
required number of ints to store.<br />
-
@return the new IntBuffer
*/
public static ByteBuffer createByteBuffer(final int size) {
final ByteBuffer buf = ByteBuffer.allocateDirect(size).order(ByteOrder.nativeOrder());
buf.clear();
onBufferAllocated(buf);
return buf;
}
/**
- Create a new ByteBuffer of an appropriate size to hold the specified
- number of ints only if the given buffer if not already the right size.
*
-
@param buf
-
the buffer to first check and rewind<br />
-
@param size
-
number of bytes that need to be held by the newly created<br />
-
buffer<br />
-
@return the requested new IntBuffer
*/
public static ByteBuffer createByteBuffer(ByteBuffer buf, final int size) {
if (buf != null && buf.limit() == size) {
buf.rewind();
return buf;
}
buf = createByteBuffer(size);
return buf;
}
public static ByteBuffer createByteBuffer(final byte… data) {
final ByteBuffer bb = createByteBuffer(data.length);
bb.put(data);
bb.flip();
return bb;
}
public static ByteBuffer createByteBuffer(final String data) {
final byte[] bytes = data.getBytes();
final ByteBuffer bb = createByteBuffer(bytes.length);
bb.put(bytes);
bb.flip();
return bb;
}
/**
- Creates a new ByteBuffer with the same contents as the given ByteBuffer.
- The new ByteBuffer is seperate from the old one and changes are not
- reflected across. If you want to reflect changes, consider using
- Buffer.duplicate().
*
-
@param buf
-
the ByteBuffer to copy<br />
-
@return the copy
*/
public static ByteBuffer clone(final ByteBuffer buf) {
if (buf == null) {
return null;
}
buf.rewind();
ByteBuffer copy;
if (buf.isDirect()) {
copy = createByteBuffer(buf.limit());
} else {
copy = ByteBuffer.allocate(buf.limit());
}
copy.put(buf);
return copy;
}
// // – GENERAL SHORT ROUTINES – ////
/**
- Create a new ShortBuffer of the specified size.
*
-
@param size
-
required number of shorts to store.<br />
-
@return the new ShortBuffer
*/
public static ShortBuffer createShortBuffer(final int size) {
final ShortBuffer buf = ByteBuffer.allocateDirect(2 * size).order(ByteOrder.nativeOrder()).asShortBuffer();
buf.clear();
onBufferAllocated(buf);
return buf;
}
/**
- Create a new ShortBuffer of an appropriate size to hold the specified
- number of shorts only if the given buffer if not already the right size.
*
-
@param buf
-
the buffer to first check and rewind<br />
-
@param size
-
number of shorts that need to be held by the newly created<br />
-
buffer<br />
-
@return the requested new ShortBuffer
*/
public static ShortBuffer createShortBuffer(ShortBuffer buf, final int size) {
if (buf != null && buf.limit() == size) {
buf.rewind();
return buf;
}
buf = createShortBuffer(size);
return buf;
}
public static ShortBuffer createShortBuffer(final short… data) {
if (data == null) {
return null;
}
final ShortBuffer buff = createShortBuffer(data.length);
buff.clear();
buff.put(data);
buff.flip();
return buff;
}
/**
- Creates a new ShortBuffer with the same contents as the given
- ShortBuffer. The new ShortBuffer is seperate from the old one and changes
- are not reflected across. If you want to reflect changes, consider using
- Buffer.duplicate().
*
-
@param buf
-
the ShortBuffer to copy<br />
-
@return the copy
*/
public static ShortBuffer clone(final ShortBuffer buf) {
if (buf == null) {
return null;
}
buf.rewind();
ShortBuffer copy;
if (buf.isDirect()) {
copy = createShortBuffer(buf.limit());
} else {
copy = ShortBuffer.allocate(buf.limit());
}
copy.put(buf);
return copy;
}
/**
- Ensures there is at least the <code>required</code> number of entries
- left after the current position of the buffer. If the buffer is too small
- a larger one is created and the old one copied to the new buffer.
*
-
@param buffer
-
buffer that should be checked/copied (may be null)<br />
-
@param required
-
minimum number of elements that should be remaining in the<br />
-
returned buffer<br />
-
@return a buffer large enough to receive at least the
-
<code>required</code> number of entries, same position as the<br />
-
input buffer, not null<br />
*/
public static FloatBuffer ensureLargeEnough(FloatBuffer buffer, final int required) {
if (buffer == null || (buffer.remaining() < required)) {
final int position = (buffer != null ? buffer.position() : 0);
final FloatBuffer newVerts = createFloatBuffer(position + required);
if (buffer != null) {
buffer.rewind();
newVerts.put(buffer);
newVerts.position(position);
}
buffer = newVerts;
}
return buffer;
}
public static ShortBuffer ensureLargeEnough(ShortBuffer buffer, final int required) {
if (buffer == null || (buffer.remaining() < required)) {
final int position = (buffer != null ? buffer.position() : 0);
final ShortBuffer newVerts = createShortBuffer(position + required);
if (buffer != null) {
buffer.rewind();
newVerts.put(buffer);
newVerts.position(position);
}
buffer = newVerts;
}
return buffer;
}
public static ByteBuffer ensureLargeEnough(ByteBuffer buffer, final int required) {
if (buffer == null || (buffer.remaining() < required)) {
final int position = (buffer != null ? buffer.position() : 0);
final ByteBuffer newVerts = createByteBuffer(position + required);
if (buffer != null) {
buffer.rewind();
newVerts.put(buffer);
newVerts.position(position);
}
buffer = newVerts;
}
return buffer;
}
public static void printCurrentDirectMemory(StringBuilder store) {
try {
cleanupReferenceQueue();
// make a new set to hold the keys to prevent concurrency issues.
final int totalHeld = bytesAllocated.get();
final int fBufs = 0, bBufs = 0, iBufs = 0, sBufs = 0, dBufs = 0;
final long heapMem = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
final boolean printStout = store == null;
if (store == null) {
store = new StringBuilder();
}
store.append("(b: ").append(bBufs).append(" f: ").append(fBufs).append(" i: ").append(iBufs).append(" s: ").append(sBufs).append(" d: ").append(dBufs).append(")").append("n");
store.append("Total heap memory held: ").append(heapMem / 1024).append("kbn");
store.append("Total direct memory held: ").append(totalHeld / 1024).append("kbn");
final HashMap<String, Integer> bufferdata = new HashMap<String, Integer>();
for (final BufferReference b : referencetrash) {
Integer size = bufferdata.get(b.getType());
if (size == null) {
size = 0;
}
size += b.getSize();
bufferdata.put(b.getType(), size);
}
for (final Entry<String, Integer> typedata : bufferdata.entrySet()) {
store.append(typedata.getKey()).append(" ").append(typedata.getValue() / 1024 / 1024f).append("mbn");
}
if (printStout) {
System.out.println(store.toString());
}
} catch (final Exception e) {
e.printStackTrace();
}
}
/**
*
*/
public static void destroyByteBuffer(final ByteBuffer toBeDestroyed) {
try {
final Method cleanerMethod = toBeDestroyed.getClass().getMethod("cleaner");
cleanerMethod.setAccessible(true);
final Object cleaner = cleanerMethod.invoke(toBeDestroyed);
final Method cleanMethod = cleaner.getClass().getMethod("clean");
cleanMethod.setAccessible(true);
cleanMethod.invoke(cleaner);
} catch (final IllegalAccessException ex) {
Logger.getLogger(BufferUtils.class.getName()).log(Level.SEVERE, "{0}", ex);
} catch (final IllegalArgumentException ex) {
Logger.getLogger(BufferUtils.class.getName()).log(Level.SEVERE, "{0}", ex);
} catch (final InvocationTargetException ex) {
Logger.getLogger(BufferUtils.class.getName()).log(Level.SEVERE, "{0}", ex);
} catch (final NoSuchMethodException ex) {
Logger.getLogger(BufferUtils.class.getName()).log(Level.SEVERE, "{0}", ex);
} catch (final SecurityException ex) {
Logger.getLogger(BufferUtils.class.getName()).log(Level.SEVERE, "{0}", ex);
}
}
}
class BufferReference extends PhantomReference<Buffer> {
private final int size;
private final String type;
public BufferReference(final Buffer referent) {
super(referent, BufferUtils.collectedBuffers);
this.size = referent.capacity();
this.type = referent.getClass().getSimpleName();
}
public int getSize() {
return size;
}
public String getType() {
return type;
}
}
[/java]