public static void findCollisions(
final Spatial spatial, final Spatial scene, final CollisionResults results) {
if (spatial == scene
|| spatial.getWorldBound() == null
|| !spatial.getSceneHints().isPickingHintEnabled(PickingHint.Collidable)
|| !scene.getSceneHints().isPickingHintEnabled(PickingHint.Collidable)) {
return;
}
if (spatial instanceof Node) {
final Node node = (Node) spatial;
if (node.getWorldBound().intersects(scene.getWorldBound())) {
// further checking needed.
for (int i = 0; i < node.getNumberOfChildren(); i++) {
PickingUtil.findCollisions(node.getChild(i), scene, results);
}
}
} else if (spatial instanceof Mesh) {
final Mesh mesh = (Mesh) spatial;
if (mesh.getWorldBound().intersects(scene.getWorldBound())) {
if (scene instanceof Node) {
final Node parent = (Node) scene;
for (int i = 0; i < parent.getNumberOfChildren(); i++) {
PickingUtil.findCollisions(mesh, parent.getChild(i), results);
}
} else {
results.addCollision(mesh, (Mesh) scene);
}
}
}
}
public static boolean hasCollision(
final Spatial spatial, final Spatial scene, final boolean checkPrimitives) {
if (spatial == scene
|| spatial.getWorldBound() == null
|| !spatial.getSceneHints().isPickingHintEnabled(PickingHint.Collidable)
|| !scene.getSceneHints().isPickingHintEnabled(PickingHint.Collidable)) {
return false;
}
if (spatial instanceof Node) {
final Node node = (Node) spatial;
if (node.getWorldBound().intersects(scene.getWorldBound())) {
if (node.getNumberOfChildren() == 0 && !checkPrimitives) {
return true;
}
// further checking needed.
for (int i = 0; i < node.getNumberOfChildren(); i++) {
if (PickingUtil.hasCollision(node.getChild(i), scene, checkPrimitives)) {
return true;
}
}
}
} else if (spatial instanceof Mesh) {
final Mesh mesh = (Mesh) spatial;
if (mesh.getWorldBound().intersects(scene.getWorldBound())) {
if (scene instanceof Node) {
final Node parent = (Node) scene;
for (int i = 0; i < parent.getNumberOfChildren(); i++) {
if (PickingUtil.hasCollision(mesh, parent.getChild(i), checkPrimitives)) {
return true;
}
}
return false;
}
if (!checkPrimitives) {
return true;
}
return PickingUtil.hasTriangleCollision(mesh, (Mesh) scene);
}
return false;
}
return false;
}
public static void findPick(final Spatial spatial, final Ray3 ray, final PickResults results) {
if (!spatial.getSceneHints().isPickingHintEnabled(PickingHint.Pickable)) {
return;
}
if (spatial instanceof Node) {
final Node node = (Node) spatial;
if (node.getNumberOfChildren() == 0 || node.getWorldBound() == null) {
return;
}
if (node.getWorldBound().intersects(ray)) {
// further checking needed.
for (int i = 0; i < node.getNumberOfChildren(); i++) {
PickingUtil.findPick(node.getChild(i), ray, results);
}
}
} else if (spatial instanceof Mesh) {
final Mesh mesh = (Mesh) spatial;
if (mesh.getWorldBound() == null) {
return;
}
if (mesh.getWorldBound().intersects(ray)) {
// find the primitive that is being hit.
// add this node and the primitive to the PickResults list.
results.addPick(ray, mesh);
}
}
}
/**
* Sets a spatial up for being rendered with the watereffect
*
* @param spatial Spatial to use as base for the watereffect
*/
public void setWaterEffectOnSpatial(final Spatial spatial) {
spatial.setRenderState(cullBackFace);
if (isSupported()) {
// spatial.setRenderBucketType(RenderBucketType.Skip);
spatial.setRenderState(waterShader);
spatial.setRenderState(textureState);
} else {
spatial.getSceneHints().setRenderBucketType(RenderBucketType.Transparent);
spatial.getSceneHints().setLightCombineMode(LightCombineMode.Off);
spatial.setRenderState(fallbackTextureState);
spatial.setRenderState(as1);
}
}
public void valueChanged(final TreeSelectionEvent e) {
if (e.getNewLeadSelectionPath() == null
|| e.getNewLeadSelectionPath().getLastPathComponent() == null) {
return;
}
final Spatial spatial = (Spatial) e.getNewLeadSelectionPath().getLastPathComponent();
final StringBuilder str = new StringBuilder();
str.append(spatial.getName());
str.append(" - ");
str.append(spatial.getClass().getName()).append('\n');
if (spatial instanceof Mesh) {
final Mesh mesh = (Mesh) spatial;
str.append("Primitives: ");
str.append(mesh.getMeshData().getTotalPrimitiveCount()).append('\n');
str.append("Index mode: ");
str.append(mesh.getMeshData().getIndexMode(0)).append('\n');
}
str.append(spatial.getTransform()).append('\n');
if (spatial.getWorldBound() != null) {
str.append(spatial.getWorldBound()).append('\n');
}
str.append('\n');
final SceneHints sceneHints = spatial.getSceneHints();
str.append("Cull hint: ");
str.append(sceneHints.getCullHint()).append('\n');
str.append("Bucket: ");
str.append(sceneHints.getRenderBucketType()).append('\n');
textArea.setText(str.toString());
}
@Override
public void render(final Renderer renderer) {
// Grab our render context - used to enforce renderstates
final RenderContext context = ContextManager.getCurrentContext();
// go through our bucket contents
Spatial spatial;
for (int i = 0; i < _currentListSize; i++) {
spatial = _currentList[i];
// make sure we have a real spatial
if (spatial == null) {
continue;
}
// we only care about altering the Mesh... perhaps could be altered later to some interface
// shared by Mesh
// and other leaf nodes.
if (spatial instanceof Mesh) {
// get our transparency rendering type.
final TransparencyType renderType = spatial.getSceneHints().getTransparencyType();
// check for one of the two pass types...
if (renderType != TransparencyType.OnePass) {
// get handle to Mesh
final Mesh mesh = (Mesh) spatial;
// check if we have a Cull state set or enforced. If one is explicitly set and is not
// Face.None,
// we'll not do two-pass transparency.
RenderState setState =
context.hasEnforcedStates() ? context.getEnforcedState(StateType.Cull) : null;
if (setState == null) {
setState = mesh.getWorldRenderState(RenderState.StateType.Cull);
}
// Do the described check.
if (setState == null || ((CullState) setState).getCullFace() == Face.None) {
// pull any currently enforced cull or zstate. We'll put them back afterwards
final RenderState oldCullState = context.getEnforcedState(StateType.Cull);
final RenderState oldZState = context.getEnforcedState(StateType.ZBuffer);
// enforce our cull and zstate. The zstate is setup to respect depth, but not write to
// it.
context.enforceState(_tranparentCull);
context.enforceState(_transparentZBuff);
// first render back-facing tris only
_tranparentCull.setCullFace(CullState.Face.Front);
mesh.draw(renderer);
// revert z state
context.clearEnforcedState(StateType.ZBuffer);
if (oldZState != null) {
context.enforceState(oldZState);
}
// render front-facing tris
_tranparentCull.setCullFace(CullState.Face.Back);
mesh.draw(renderer);
// revert cull state
if (oldCullState != null) {
context.enforceState(oldCullState);
} else {
context.clearEnforcedState(StateType.Cull);
}
continue;
}
}
}
// go ahead and draw as usual
spatial.draw(renderer);
}
}