/*
* Java port of Bullet (c) 2008 Martin Dvorak <jezek2@advel.cz>
*
* Bullet Continuous Collision Detection and Physics Library
* Copyright (c) 2003-2008 Erwin Coumans http://www.bulletphysics.com/
*
* This software is provided 'as-is', without any express or implied warranty.
* In no event will the authors be held liable for any damages arising from
* the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/
package com.bulletphysics.collision.shapes;
import java.io.Serializable;
/**
* QuantizedBvhNodes is array of compressed AABB nodes, each of 16 bytes.
* Node can be used for leaf node or internal node. Leaf nodes can point to 32-bit
* triangle index (non-negative range).<p>
*
* <i>Implementation note:</i> the nodes are internally stored in int[] array
* and bit packed. The actual structure is:
*
* <pre>
* unsigned short quantizedAabbMin[3]
* unsigned short quantizedAabbMax[3]
* signed int escapeIndexOrTriangleIndex
* </pre>
*
* @author jezek2
*/
public class QuantizedBvhNodes implements Serializable {
private static final long serialVersionUID = 1L;
private static final int STRIDE = 4; // 16 bytes
private int[] buf;
private int size = 0;
public QuantizedBvhNodes() {
resize(16);
}
public int add() {
while (size+1 >= capacity()) {
resize(capacity()*2);
}
return size++;
}
public int size() {
return size;
}
public int capacity() {
return buf.length / STRIDE;
}
public void clear() {
size = 0;
}
public void resize(int num) {
int[] oldBuf = buf;
buf = new int[num*STRIDE];
if (oldBuf != null) {
System.arraycopy(oldBuf, 0, buf, 0, Math.min(oldBuf.length, buf.length));
}
}
public static int getNodeSize() {
return STRIDE*4;
}
public void set(int destId, QuantizedBvhNodes srcNodes, int srcId) {
assert (STRIDE == 4);
// save field access:
int[] buf = this.buf;
int[] srcBuf = srcNodes.buf;
buf[destId*STRIDE+0] = srcBuf[srcId*STRIDE+0];
buf[destId*STRIDE+1] = srcBuf[srcId*STRIDE+1];
buf[destId*STRIDE+2] = srcBuf[srcId*STRIDE+2];
buf[destId*STRIDE+3] = srcBuf[srcId*STRIDE+3];
}
public void swap(int id1, int id2) {
assert (STRIDE == 4);
// save field access:
int[] buf = this.buf;
int temp0 = buf[id1*STRIDE+0];
int temp1 = buf[id1*STRIDE+1];
int temp2 = buf[id1*STRIDE+2];
int temp3 = buf[id1*STRIDE+3];
buf[id1*STRIDE+0] = buf[id2*STRIDE+0];
buf[id1*STRIDE+1] = buf[id2*STRIDE+1];
buf[id1*STRIDE+2] = buf[id2*STRIDE+2];
buf[id1*STRIDE+3] = buf[id2*STRIDE+3];
buf[id2*STRIDE+0] = temp0;
buf[id2*STRIDE+1] = temp1;
buf[id2*STRIDE+2] = temp2;
buf[id2*STRIDE+3] = temp3;
}
public int getQuantizedAabbMin(int nodeId, int index) {
switch (index) {
default:
case 0: return (buf[nodeId*STRIDE+0]) & 0xFFFF;
case 1: return (buf[nodeId*STRIDE+0] >>> 16) & 0xFFFF;
case 2: return (buf[nodeId*STRIDE+1]) & 0xFFFF;
}
}
public long getQuantizedAabbMin(int nodeId) {
return (buf[nodeId*STRIDE+0] & 0xFFFFFFFFL) | ((buf[nodeId*STRIDE+1] & 0xFFFFL) << 32);
}
public void setQuantizedAabbMin(int nodeId, long value) {
buf[nodeId*STRIDE+0] = (int)value;
setQuantizedAabbMin(nodeId, 2, (short)((value & 0xFFFF00000000L) >>> 32));
}
public void setQuantizedAabbMax(int nodeId, long value) {
setQuantizedAabbMax(nodeId, 0, (short)value);
buf[nodeId*STRIDE+2] = (int)(value >>> 16);
}
public void setQuantizedAabbMin(int nodeId, int index, int value) {
switch (index) {
case 0: buf[nodeId*STRIDE+0] = (buf[nodeId*STRIDE+0] & 0xFFFF0000) | (value & 0xFFFF); break;
case 1: buf[nodeId*STRIDE+0] = (buf[nodeId*STRIDE+0] & 0x0000FFFF) | ((value & 0xFFFF) << 16); break;
case 2: buf[nodeId*STRIDE+1] = (buf[nodeId*STRIDE+1] & 0xFFFF0000) | (value & 0xFFFF); break;
}
}
public int getQuantizedAabbMax(int nodeId, int index) {
switch (index) {
default:
case 0: return (buf[nodeId*STRIDE+1] >>> 16) & 0xFFFF;
case 1: return (buf[nodeId*STRIDE+2]) & 0xFFFF;
case 2: return (buf[nodeId*STRIDE+2] >>> 16) & 0xFFFF;
}
}
public long getQuantizedAabbMax(int nodeId) {
return ((buf[nodeId*STRIDE+1] & 0xFFFF0000L) >>> 16) | ((buf[nodeId*STRIDE+2] & 0xFFFFFFFFL) << 16);
}
public void setQuantizedAabbMax(int nodeId, int index, int value) {
switch (index) {
case 0: buf[nodeId*STRIDE+1] = (buf[nodeId*STRIDE+1] & 0x0000FFFF) | ((value & 0xFFFF) << 16); break;
case 1: buf[nodeId*STRIDE+2] = (buf[nodeId*STRIDE+2] & 0xFFFF0000) | (value & 0xFFFF); break;
case 2: buf[nodeId*STRIDE+2] = (buf[nodeId*STRIDE+2] & 0x0000FFFF) | ((value & 0xFFFF) << 16); break;
}
}
public int getEscapeIndexOrTriangleIndex(int nodeId) {
return buf[nodeId*STRIDE+3];
}
public void setEscapeIndexOrTriangleIndex(int nodeId, int value) {
buf[nodeId*STRIDE+3] = value;
}
public boolean isLeafNode(int nodeId) {
// skipindex is negative (internal node), triangleindex >=0 (leafnode)
return (getEscapeIndexOrTriangleIndex(nodeId) >= 0);
}
public int getEscapeIndex(int nodeId) {
assert (!isLeafNode(nodeId));
return -getEscapeIndexOrTriangleIndex(nodeId);
}
public int getTriangleIndex(int nodeId) {
assert (isLeafNode(nodeId));
// Get only the lower bits where the triangle index is stored
return (getEscapeIndexOrTriangleIndex(nodeId) & ~((~0) << (31 - OptimizedBvh.MAX_NUM_PARTS_IN_BITS)));
}
public int getPartId(int nodeId) {
assert (isLeafNode(nodeId));
// Get only the highest bits where the part index is stored
return (getEscapeIndexOrTriangleIndex(nodeId) >>> (31 - OptimizedBvh.MAX_NUM_PARTS_IN_BITS));
}
public static int getCoord(long vec, int index) {
switch (index) {
default:
case 0: return (int)((vec & 0x00000000FFFFL)) & 0xFFFF;
case 1: return (int)((vec & 0x0000FFFF0000L) >>> 16) & 0xFFFF;
case 2: return (int)((vec & 0xFFFF00000000L) >>> 32) & 0xFFFF;
}
}
}