|
@@ -1,535 +0,0 @@
|
|
|
-/*
|
|
|
- * Copyright (c) 2009-2021 jMonkeyEngine
|
|
|
- * 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 'jMonkeyEngine' 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 jme3test.games;
|
|
|
-
|
|
|
-import com.jme3.app.Application;
|
|
|
-import com.jme3.app.SimpleApplication;
|
|
|
-import com.jme3.app.state.AbstractAppState;
|
|
|
-import com.jme3.app.state.AppStateManager;
|
|
|
-import com.jme3.bullet.BulletAppState;
|
|
|
-import com.jme3.bullet.collision.shapes.CollisionShape;
|
|
|
-import com.jme3.bullet.collision.shapes.MeshCollisionShape;
|
|
|
-import com.jme3.bullet.collision.shapes.SphereCollisionShape;
|
|
|
-import com.jme3.bullet.control.RigidBodyControl;
|
|
|
-import com.jme3.bullet.debug.DebugTools;
|
|
|
-import com.jme3.font.BitmapText;
|
|
|
-import com.jme3.input.KeyInput;
|
|
|
-import com.jme3.input.controls.AnalogListener;
|
|
|
-import com.jme3.input.controls.KeyTrigger;
|
|
|
-import com.jme3.material.Material;
|
|
|
-import com.jme3.math.ColorRGBA;
|
|
|
-import com.jme3.math.FastMath;
|
|
|
-import com.jme3.math.Ray;
|
|
|
-import com.jme3.math.Vector3f;
|
|
|
-import com.jme3.post.FilterPostProcessor;
|
|
|
-import com.jme3.post.filters.FogFilter;
|
|
|
-import com.jme3.scene.Geometry;
|
|
|
-import com.jme3.scene.Mesh;
|
|
|
-import com.jme3.scene.Node;
|
|
|
-import com.jme3.scene.Spatial;
|
|
|
-import com.jme3.scene.shape.Sphere;
|
|
|
-import java.util.Random;
|
|
|
-import java.util.logging.Level;
|
|
|
-import java.util.logging.Logger;
|
|
|
-
|
|
|
-/**
|
|
|
- * WorldOfInception - Find the galaxy center ;)
|
|
|
- *
|
|
|
- * @author normenhansen
|
|
|
- */
|
|
|
-public class WorldOfInception extends SimpleApplication implements AnalogListener {
|
|
|
-
|
|
|
- //Assumptions: POI radius in world == 1, only one player, vector3f hash describes enough worlds
|
|
|
- private static final Logger logger = Logger.getLogger(WorldOfInception.class.getName());
|
|
|
- private static final Random random = new Random(System.currentTimeMillis());
|
|
|
- private static final float scaleDist = 10;
|
|
|
- private static final float poiRadius = 100;
|
|
|
- private static final int poiCount = 30;
|
|
|
- private static Material poiMaterial;
|
|
|
- private static Mesh poiMesh;
|
|
|
- private static Material ballMaterial;
|
|
|
- private static Mesh ballMesh;
|
|
|
- private static CollisionShape poiHorizonCollisionShape;
|
|
|
- private static CollisionShape poiCollisionShape;
|
|
|
- private static CollisionShape ballCollisionShape;
|
|
|
- private InceptionLevel currentLevel;
|
|
|
- private final Vector3f walkDirection = new Vector3f();
|
|
|
- private static DebugTools debugTools;
|
|
|
-
|
|
|
- public WorldOfInception() {
|
|
|
- //base level vector position hash == seed
|
|
|
- super(new InceptionLevel(null, Vector3f.ZERO));
|
|
|
- currentLevel = super.getStateManager().getState(InceptionLevel.class);
|
|
|
- currentLevel.takeOverParent();
|
|
|
- currentLevel.getRootNode().setLocalScale(Vector3f.UNIT_XYZ);
|
|
|
- currentLevel.getRootNode().setLocalTranslation(Vector3f.ZERO);
|
|
|
- }
|
|
|
-
|
|
|
- public static void main(String[] args) {
|
|
|
- WorldOfInception app = new WorldOfInception();
|
|
|
- app.start();
|
|
|
- }
|
|
|
-
|
|
|
- @Override
|
|
|
- public void simpleInitApp() {
|
|
|
- //set far frustum only so we see the outer world longer
|
|
|
- cam.setFrustumFar(10000);
|
|
|
- cam.setLocation(Vector3f.ZERO);
|
|
|
- debugTools = new DebugTools(assetManager);
|
|
|
- rootNode.attachChild(debugTools.debugNode);
|
|
|
- poiMaterial = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
|
|
|
- poiMaterial.setTexture("ColorMap", assetManager.loadTexture("Interface/Logo/Monkey.jpg"));
|
|
|
- poiMesh = new Sphere(16, 16, 1f);
|
|
|
-
|
|
|
- ballMaterial = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
|
|
|
- ballMaterial.setTexture("ColorMap", assetManager.loadTexture("Interface/Logo/Monkey.jpg"));
|
|
|
- ballMaterial.setColor("Color", ColorRGBA.Red);
|
|
|
- ballMesh = new Sphere(16, 16, 1.0f);
|
|
|
-
|
|
|
- poiHorizonCollisionShape = new MeshCollisionShape(new Sphere(128, 128, poiRadius));
|
|
|
- poiCollisionShape = new SphereCollisionShape(1f);
|
|
|
- ballCollisionShape = new SphereCollisionShape(1f);
|
|
|
- setupKeys();
|
|
|
- setupDisplay();
|
|
|
- setupFog();
|
|
|
- }
|
|
|
-
|
|
|
- private void setupKeys() {
|
|
|
- inputManager.addMapping("StrafeLeft", new KeyTrigger(KeyInput.KEY_A));
|
|
|
- inputManager.addMapping("StrafeRight", new KeyTrigger(KeyInput.KEY_D));
|
|
|
- inputManager.addMapping("Forward", new KeyTrigger(KeyInput.KEY_W));
|
|
|
- inputManager.addMapping("Back", new KeyTrigger(KeyInput.KEY_S));
|
|
|
- inputManager.addMapping("StrafeUp", new KeyTrigger(KeyInput.KEY_Q));
|
|
|
- inputManager.addMapping("StrafeDown", new KeyTrigger(KeyInput.KEY_Z), new KeyTrigger(KeyInput.KEY_Y));
|
|
|
- inputManager.addMapping("Space", new KeyTrigger(KeyInput.KEY_SPACE));
|
|
|
- inputManager.addMapping("Return", new KeyTrigger(KeyInput.KEY_RETURN));
|
|
|
- inputManager.addMapping("Esc", new KeyTrigger(KeyInput.KEY_ESCAPE));
|
|
|
- inputManager.addMapping("Up", new KeyTrigger(KeyInput.KEY_UP));
|
|
|
- inputManager.addMapping("Down", new KeyTrigger(KeyInput.KEY_DOWN));
|
|
|
- inputManager.addMapping("Left", new KeyTrigger(KeyInput.KEY_LEFT));
|
|
|
- inputManager.addMapping("Right", new KeyTrigger(KeyInput.KEY_RIGHT));
|
|
|
- inputManager.addListener(this, "StrafeLeft", "StrafeRight", "Forward", "Back", "StrafeUp", "StrafeDown", "Space", "Reset", "Esc", "Up", "Down", "Left", "Right");
|
|
|
- }
|
|
|
-
|
|
|
- private void setupDisplay() {
|
|
|
- if (fpsText == null) {
|
|
|
- fpsText = new BitmapText(guiFont);
|
|
|
- }
|
|
|
- fpsText.setLocalScale(0.7f, 0.7f, 0.7f);
|
|
|
- fpsText.setLocalTranslation(0, fpsText.getLineHeight(), 0);
|
|
|
- fpsText.setText("");
|
|
|
- fpsText.setCullHint(Spatial.CullHint.Never);
|
|
|
- guiNode.attachChild(fpsText);
|
|
|
- }
|
|
|
-
|
|
|
- private void setupFog() {
|
|
|
- // use fog to give more sense of depth
|
|
|
- FilterPostProcessor fpp;
|
|
|
- FogFilter fog;
|
|
|
- fpp=new FilterPostProcessor(assetManager);
|
|
|
- fog=new FogFilter();
|
|
|
- fog.setFogColor(new ColorRGBA(0.0f, 0.0f, 0.0f, 1.0f));
|
|
|
- fog.setFogDistance(poiRadius);
|
|
|
- fog.setFogDensity(2.0f);
|
|
|
- fpp.addFilter(fog);
|
|
|
- viewPort.addProcessor(fpp);
|
|
|
- }
|
|
|
-
|
|
|
- @Override
|
|
|
- public void onAnalog(String name, float value, float tpf) {
|
|
|
- Vector3f left = rootNode.getLocalRotation().mult(Vector3f.UNIT_X.negate());
|
|
|
- Vector3f forward = rootNode.getLocalRotation().mult(Vector3f.UNIT_Z.negate());
|
|
|
- Vector3f up = rootNode.getLocalRotation().mult(Vector3f.UNIT_Y);
|
|
|
- //TODO: properly scale input based on current scaling level
|
|
|
- tpf = tpf * (10 - (9.0f * currentLevel.getCurrentScaleAmount()));
|
|
|
- if (name.equals("StrafeLeft") && value > 0) {
|
|
|
- walkDirection.addLocal(left.mult(tpf));
|
|
|
- } else if (name.equals("StrafeRight") && value > 0) {
|
|
|
- walkDirection.addLocal(left.negate().multLocal(tpf));
|
|
|
- } else if (name.equals("Forward") && value > 0) {
|
|
|
- walkDirection.addLocal(forward.mult(tpf));
|
|
|
- } else if (name.equals("Back") && value > 0) {
|
|
|
- walkDirection.addLocal(forward.negate().multLocal(tpf));
|
|
|
- } else if (name.equals("StrafeUp") && value > 0) {
|
|
|
- walkDirection.addLocal(up.mult(tpf));
|
|
|
- } else if (name.equals("StrafeDown") && value > 0) {
|
|
|
- walkDirection.addLocal(up.negate().multLocal(tpf));
|
|
|
- } else if (name.equals("Up") && value > 0) {
|
|
|
- //TODO: rotate rootNode, needs to be global
|
|
|
- } else if (name.equals("Down") && value > 0) {
|
|
|
- } else if (name.equals("Left") && value > 0) {
|
|
|
- } else if (name.equals("Right") && value > 0) {
|
|
|
- } else if (name.equals("Esc")) {
|
|
|
- stop();
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- @Override
|
|
|
- public void simpleUpdate(float tpf) {
|
|
|
- currentLevel = currentLevel.getCurrentLevel();
|
|
|
- currentLevel.move(walkDirection);
|
|
|
- fpsText.setText("Location: " + currentLevel.getCoordinates());
|
|
|
- walkDirection.set(Vector3f.ZERO);
|
|
|
- }
|
|
|
-
|
|
|
- public static class InceptionLevel extends AbstractAppState {
|
|
|
-
|
|
|
- private final InceptionLevel parent;
|
|
|
- private final Vector3f inParentPosition;
|
|
|
- private SimpleApplication application;
|
|
|
- private BulletAppState physicsState;
|
|
|
- private Node rootNode;
|
|
|
- private Vector3f playerPos;
|
|
|
- private InceptionLevel currentActiveChild;
|
|
|
- private InceptionLevel currentReturnLevel;
|
|
|
- private float curScaleAmount = 0;
|
|
|
-
|
|
|
- public InceptionLevel(InceptionLevel parent, Vector3f inParentPosition) {
|
|
|
- this.parent = parent;
|
|
|
- this.inParentPosition = inParentPosition;
|
|
|
- }
|
|
|
-
|
|
|
- @Override
|
|
|
- public void update(float tpf) {
|
|
|
- super.update(tpf);
|
|
|
- if (currentReturnLevel != this) {
|
|
|
- return;
|
|
|
- }
|
|
|
- debugTools.setYellowArrow(new Vector3f(0, 0, -2), playerPos.divide(poiRadius));
|
|
|
- float curLocalDist = getPlayerPosition().length();
|
|
|
- // If we are outside the range of one point of interest, move out to
|
|
|
- // the next upper level
|
|
|
- if (curLocalDist > poiRadius + FastMath.ZERO_TOLERANCE) { //DAFUQ normalize?
|
|
|
- if (parent == null) {
|
|
|
- //TODO: could add new nodes coming in instead for literally endless space
|
|
|
- logger.log(Level.INFO, "Hit event horizon");
|
|
|
- currentReturnLevel = this;
|
|
|
- return;
|
|
|
- }
|
|
|
- //give to parent
|
|
|
- logger.log(Level.INFO, "give to parent");
|
|
|
- parent.takeOverChild(inParentPosition.add(playerPos.normalize()));
|
|
|
- application.getStateManager().attach(parent);
|
|
|
- currentReturnLevel = parent;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- AppStateManager stateManager = application.getStateManager();
|
|
|
- // We create child positions based on the parent position hash, so we
|
|
|
- // should in practice get the same galaxy w/o too many doubles
|
|
|
- // with each run with the same root vector.
|
|
|
- Vector3f[] vectors = getPositions(poiCount, inParentPosition.hashCode());
|
|
|
- for (int i = 0; i < vectors.length; i++) {
|
|
|
- Vector3f vector3f = vectors[i];
|
|
|
- //negative rootNode location is our actual player position
|
|
|
- Vector3f distVect = vector3f.subtract(playerPos);
|
|
|
- float distance = distVect.length();
|
|
|
- if (distance <= 1) {
|
|
|
- checkActiveChild(vector3f);
|
|
|
- float percent = 0;
|
|
|
- curScaleAmount = 0;
|
|
|
- this.scaleAsParent(percent, playerPos, distVect);
|
|
|
- currentActiveChild.scaleAsChild(percent, distVect);
|
|
|
- logger.log(Level.INFO, "Give over to child {0}", currentActiveChild);
|
|
|
- currentActiveChild.takeOverParent();
|
|
|
- stateManager.detach(this);
|
|
|
- currentReturnLevel = currentActiveChild;
|
|
|
- return;
|
|
|
- } else if (distance <= 1 + scaleDist) {
|
|
|
- debugTools.setRedArrow(Vector3f.ZERO, distVect);
|
|
|
- checkActiveChild(vector3f);
|
|
|
- //TODO: scale percent nicer for less of an "explosion" effect
|
|
|
- float percent = 1 - mapValue(distance - 1, 0, scaleDist, 0, 1);
|
|
|
- curScaleAmount = percent;
|
|
|
- rootNode.getChild(i).setCullHint(Spatial.CullHint.Always);
|
|
|
- this.scaleAsParent(percent, playerPos, distVect);
|
|
|
- currentActiveChild.scaleAsChild(percent, distVect);
|
|
|
- currentReturnLevel = this;
|
|
|
- return;
|
|
|
- } else if (currentActiveChild != null && currentActiveChild.getPositionInParent().equals(vector3f)) {
|
|
|
- //TODO: doing this here causes problems when close to multiple POIs
|
|
|
- rootNode.getChild(i).setCullHint(Spatial.CullHint.Inherit);
|
|
|
- }
|
|
|
- }
|
|
|
- checkActiveChild(null);
|
|
|
- curScaleAmount = 0;
|
|
|
- rootNode.setLocalScale(1);
|
|
|
- rootNode.setLocalTranslation(playerPos.negate());
|
|
|
- debugTools.setRedArrow(Vector3f.ZERO, Vector3f.ZERO);
|
|
|
- debugTools.setBlueArrow(Vector3f.ZERO, Vector3f.ZERO);
|
|
|
- debugTools.setGreenArrow(Vector3f.ZERO, Vector3f.ZERO);
|
|
|
- }
|
|
|
-
|
|
|
- private void checkActiveChild(Vector3f vector3f) {
|
|
|
- AppStateManager stateManager = application.getStateManager();
|
|
|
- if(vector3f == null){
|
|
|
- if(currentActiveChild != null){
|
|
|
- logger.log(Level.INFO, "Detach child {0}", currentActiveChild);
|
|
|
- stateManager.detach(currentActiveChild);
|
|
|
- currentActiveChild = null;
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- if (currentActiveChild == null) {
|
|
|
- currentActiveChild = new InceptionLevel(this, vector3f);
|
|
|
- stateManager.attach(currentActiveChild);
|
|
|
- logger.log(Level.INFO, "Attach child {0}", currentActiveChild);
|
|
|
- } else if (!currentActiveChild.getPositionInParent().equals(vector3f)) {
|
|
|
- logger.log(Level.INFO, "Switching from child {0}", currentActiveChild);
|
|
|
- stateManager.detach(currentActiveChild);
|
|
|
- currentActiveChild = new InceptionLevel(this, vector3f);
|
|
|
- stateManager.attach(currentActiveChild);
|
|
|
- logger.log(Level.INFO, "Attach child {0}", currentActiveChild);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- private void scaleAsChild(float percent, Vector3f dist) {
|
|
|
- float childScale = mapValue(percent, 1.0f / poiRadius, 1);
|
|
|
- Vector3f distToHorizon = dist.normalize();
|
|
|
- Vector3f scaledDistToHorizon = distToHorizon.mult(childScale * poiRadius);
|
|
|
- Vector3f rootOff = dist.add(scaledDistToHorizon);
|
|
|
- debugTools.setBlueArrow(Vector3f.ZERO, rootOff);
|
|
|
- getRootNode().setLocalScale(childScale);
|
|
|
- getRootNode().setLocalTranslation(rootOff);
|
|
|
- //prepare player position already
|
|
|
- Vector3f playerPosition = dist.normalize().mult(-poiRadius);
|
|
|
- setPlayerPosition(playerPosition);
|
|
|
- }
|
|
|
-
|
|
|
- private void scaleAsParent(float percent, Vector3f playerPos, Vector3f dist) {
|
|
|
- float scale = mapValue(percent, 1.0f, poiRadius);
|
|
|
- Vector3f distToHorizon = dist.subtract(dist.normalize());
|
|
|
- Vector3f offLocation = playerPos.add(distToHorizon);
|
|
|
- Vector3f rootOff = offLocation.mult(scale).negate();
|
|
|
- rootOff.addLocal(dist);
|
|
|
- debugTools.setGreenArrow(Vector3f.ZERO, offLocation);
|
|
|
- getRootNode().setLocalScale(scale);
|
|
|
- getRootNode().setLocalTranslation(rootOff);
|
|
|
- }
|
|
|
-
|
|
|
- public void takeOverParent() {
|
|
|
- //got playerPos from scaleAsChild before
|
|
|
- getPlayerPosition().normalizeLocal().multLocal(poiRadius);
|
|
|
- currentReturnLevel = this;
|
|
|
- }
|
|
|
-
|
|
|
- public void takeOverChild(Vector3f playerPos) {
|
|
|
- this.playerPos.set(playerPos);
|
|
|
- currentReturnLevel = this;
|
|
|
- }
|
|
|
-
|
|
|
- public InceptionLevel getLastLevel(Ray pickRay) {
|
|
|
- // TODO: get a level based on positions getting ever more accurate,
|
|
|
- // from any given position
|
|
|
- return null;
|
|
|
- }
|
|
|
-
|
|
|
- public InceptionLevel getLevel(Vector3f... location) {
|
|
|
- // TODO: get a level based on positions getting ever more accurate,
|
|
|
- // from any given position
|
|
|
- return null;
|
|
|
- }
|
|
|
-
|
|
|
- private void initData() {
|
|
|
- getRootNode();
|
|
|
- physicsState = new BulletAppState();
|
|
|
- physicsState.startPhysics();
|
|
|
- physicsState.getPhysicsSpace().setGravity(Vector3f.ZERO);
|
|
|
- //horizon
|
|
|
- physicsState.getPhysicsSpace().add(new RigidBodyControl(poiHorizonCollisionShape, 0));
|
|
|
- int hashCode = inParentPosition.hashCode();
|
|
|
- Vector3f[] positions = getPositions(poiCount, hashCode);
|
|
|
- for (int i = 0; i < positions.length; i++) {
|
|
|
- Vector3f vector3f = positions[i];
|
|
|
- Geometry poiGeom = new Geometry("poi", poiMesh);
|
|
|
- poiGeom.setLocalTranslation(vector3f);
|
|
|
- poiGeom.setMaterial(poiMaterial);
|
|
|
- RigidBodyControl control = new RigidBodyControl(poiCollisionShape, 0);
|
|
|
- //!!! Important
|
|
|
- control.setApplyPhysicsLocal(true);
|
|
|
- poiGeom.addControl(control);
|
|
|
- physicsState.getPhysicsSpace().add(poiGeom);
|
|
|
- rootNode.attachChild(poiGeom);
|
|
|
-
|
|
|
- }
|
|
|
- //add balls after so first 10 geoms == locations
|
|
|
- for (int i = 0; i < positions.length; i++) {
|
|
|
- Vector3f vector3f = positions[i];
|
|
|
- Geometry ball = getRandomBall(vector3f);
|
|
|
- physicsState.getPhysicsSpace().add(ball);
|
|
|
- rootNode.attachChild(ball);
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- private Geometry getRandomBall(Vector3f location) {
|
|
|
- Vector3f localLocation = new Vector3f();
|
|
|
- localLocation.set(location);
|
|
|
- localLocation.addLocal(new Vector3f(random.nextFloat() - 0.5f, random.nextFloat() - 0.5f, random.nextFloat() - 0.5f).normalize().mult(3));
|
|
|
- Geometry poiGeom = new Geometry("ball", ballMesh);
|
|
|
- poiGeom.setLocalTranslation(localLocation);
|
|
|
- poiGeom.setMaterial(ballMaterial);
|
|
|
- RigidBodyControl control = new RigidBodyControl(ballCollisionShape, 1);
|
|
|
- //!!! Important
|
|
|
- control.setApplyPhysicsLocal(true);
|
|
|
- poiGeom.addControl(control);
|
|
|
- float x = (random.nextFloat() - 0.5f) * 100;
|
|
|
- float y = (random.nextFloat() - 0.5f) * 100;
|
|
|
- float z = (random.nextFloat() - 0.5f) * 100;
|
|
|
- control.setLinearVelocity(new Vector3f(x, y, z));
|
|
|
- return poiGeom;
|
|
|
- }
|
|
|
-
|
|
|
- private void cleanupData() {
|
|
|
- physicsState.stopPhysics();
|
|
|
- //TODO: remove all objects?
|
|
|
- physicsState = null;
|
|
|
- rootNode = null;
|
|
|
- }
|
|
|
-
|
|
|
- @Override
|
|
|
- public void initialize(AppStateManager stateManager, Application app) {
|
|
|
- super.initialize(stateManager, app);
|
|
|
- //only generate data and attach node when we are actually attached (or picking)
|
|
|
- initData();
|
|
|
- application = (SimpleApplication) app;
|
|
|
- application.getRootNode().attachChild(getRootNode());
|
|
|
- application.getStateManager().attach(physicsState);
|
|
|
- }
|
|
|
-
|
|
|
- @Override
|
|
|
- public void cleanup() {
|
|
|
- super.cleanup();
|
|
|
- //detach everything when we are detached
|
|
|
- application.getRootNode().detachChild(rootNode);
|
|
|
- application.getStateManager().detach(physicsState);
|
|
|
- cleanupData();
|
|
|
- }
|
|
|
-
|
|
|
- public Node getRootNode() {
|
|
|
- if (rootNode == null) {
|
|
|
- rootNode = new Node("ZoomLevel");
|
|
|
- if (parent != null) {
|
|
|
- rootNode.setLocalScale(1.0f / poiRadius);
|
|
|
- }
|
|
|
- }
|
|
|
- return rootNode;
|
|
|
- }
|
|
|
-
|
|
|
- public Vector3f getPositionInParent() {
|
|
|
- return inParentPosition;
|
|
|
- }
|
|
|
-
|
|
|
- public Vector3f getPlayerPosition() {
|
|
|
- if (playerPos == null) {
|
|
|
- playerPos = new Vector3f();
|
|
|
- }
|
|
|
- return playerPos;
|
|
|
- }
|
|
|
-
|
|
|
- public void setPlayerPosition(Vector3f vec) {
|
|
|
- if (playerPos == null) {
|
|
|
- playerPos = new Vector3f();
|
|
|
- }
|
|
|
- playerPos.set(vec);
|
|
|
- }
|
|
|
-
|
|
|
- public void move(Vector3f dir) {
|
|
|
- if (playerPos == null) {
|
|
|
- playerPos = new Vector3f();
|
|
|
- }
|
|
|
- playerPos.addLocal(dir);
|
|
|
- }
|
|
|
-
|
|
|
- public float getCurrentScaleAmount() {
|
|
|
- return curScaleAmount;
|
|
|
- }
|
|
|
-
|
|
|
- public InceptionLevel getParent() {
|
|
|
- return parent;
|
|
|
- }
|
|
|
-
|
|
|
- public InceptionLevel getCurrentLevel() {
|
|
|
- return currentReturnLevel;
|
|
|
- }
|
|
|
-
|
|
|
- public String getCoordinates() {
|
|
|
- InceptionLevel cur = this;
|
|
|
- StringBuilder stringBuilder = new StringBuilder();
|
|
|
- stringBuilder.insert(0, this.getPlayerPosition());
|
|
|
- stringBuilder.insert(0, this.getPositionInParent() + " / ");
|
|
|
- cur = cur.getParent();
|
|
|
- while (cur != null) {
|
|
|
- stringBuilder.insert(0, cur.getPositionInParent() + " / ");
|
|
|
- cur = cur.getParent();
|
|
|
- }
|
|
|
- return stringBuilder.toString();
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- public static Vector3f[] getPositions(int count, long seed) {
|
|
|
- Random rnd = new Random(seed);
|
|
|
- Vector3f[] vectors = new Vector3f[count];
|
|
|
- for (int i = 0; i < count; i++) {
|
|
|
- vectors[i] = new Vector3f((rnd.nextFloat() - 0.5f) * poiRadius,
|
|
|
- (rnd.nextFloat() - 0.5f) * poiRadius,
|
|
|
- (rnd.nextFloat() - 0.5f) * poiRadius);
|
|
|
- }
|
|
|
- return vectors;
|
|
|
- }
|
|
|
-
|
|
|
- /**
|
|
|
- * Maps a value from 0-1 to a range from min to max.
|
|
|
- *
|
|
|
- * @param x
|
|
|
- * @param min
|
|
|
- * @param max
|
|
|
- * @return the mapped value
|
|
|
- */
|
|
|
- private static float mapValue(float x, float min, float max) {
|
|
|
- return mapValue(x, 0, 1, min, max);
|
|
|
- }
|
|
|
-
|
|
|
- /**
|
|
|
- * Maps a value from inputMin to inputMax to a range from min to max.
|
|
|
- *
|
|
|
- * @param x
|
|
|
- * @param inputMin
|
|
|
- * @param inputMax
|
|
|
- * @param min
|
|
|
- * @param max
|
|
|
- * @return the mapped value
|
|
|
- */
|
|
|
- private static float mapValue(float x, float inputMin, float inputMax, float min, float max) {
|
|
|
- return (x - inputMin) * (max - min) / (inputMax - inputMin) + min;
|
|
|
- }
|
|
|
-}
|