Kirill Vainer
9 years ago
commit
a8fca2bcf6
@ -0,0 +1,774 @@ |
|||||||
|
/* |
||||||
|
* Copyright (c) 2009-2012 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 com.jme3.app; |
||||||
|
|
||||||
|
import com.jme3.app.state.AppStateManager; |
||||||
|
import com.jme3.asset.AssetManager; |
||||||
|
import com.jme3.audio.AudioContext; |
||||||
|
import com.jme3.audio.AudioRenderer; |
||||||
|
import com.jme3.audio.Listener; |
||||||
|
import com.jme3.input.*; |
||||||
|
import com.jme3.math.Vector3f; |
||||||
|
import com.jme3.profile.AppProfiler; |
||||||
|
import com.jme3.profile.AppStep; |
||||||
|
import com.jme3.renderer.Camera; |
||||||
|
import com.jme3.renderer.RenderManager; |
||||||
|
import com.jme3.renderer.Renderer; |
||||||
|
import com.jme3.renderer.ViewPort; |
||||||
|
import com.jme3.system.*; |
||||||
|
import com.jme3.system.JmeContext.Type; |
||||||
|
import java.net.MalformedURLException; |
||||||
|
import java.net.URL; |
||||||
|
import java.util.concurrent.Callable; |
||||||
|
import java.util.concurrent.ConcurrentLinkedQueue; |
||||||
|
import java.util.concurrent.Future; |
||||||
|
import java.util.logging.Level; |
||||||
|
import java.util.logging.Logger; |
||||||
|
|
||||||
|
/** |
||||||
|
* The <code>LegacyApplication</code> class represents an instance of a |
||||||
|
* real-time 3D rendering jME application. |
||||||
|
* |
||||||
|
* An <code>LegacyApplication</code> provides all the tools that are commonly used in jME3 |
||||||
|
* applications. |
||||||
|
* |
||||||
|
* jME3 applications *SHOULD NOT EXTEND* this class but extend {@link com.jme3.app.SimpleApplication} instead. |
||||||
|
* |
||||||
|
*/ |
||||||
|
public class LegacyApplication implements Application, SystemListener { |
||||||
|
|
||||||
|
private static final Logger logger = Logger.getLogger(LegacyApplication.class.getName()); |
||||||
|
|
||||||
|
protected AssetManager assetManager; |
||||||
|
|
||||||
|
protected AudioRenderer audioRenderer; |
||||||
|
protected Renderer renderer; |
||||||
|
protected RenderManager renderManager; |
||||||
|
protected ViewPort viewPort; |
||||||
|
protected ViewPort guiViewPort; |
||||||
|
|
||||||
|
protected JmeContext context; |
||||||
|
protected AppSettings settings; |
||||||
|
protected Timer timer = new NanoTimer(); |
||||||
|
protected Camera cam; |
||||||
|
protected Listener listener; |
||||||
|
|
||||||
|
protected boolean inputEnabled = true; |
||||||
|
protected LostFocusBehavior lostFocusBehavior = LostFocusBehavior.ThrottleOnLostFocus; |
||||||
|
protected float speed = 1f; |
||||||
|
protected boolean paused = false; |
||||||
|
protected MouseInput mouseInput; |
||||||
|
protected KeyInput keyInput; |
||||||
|
protected JoyInput joyInput; |
||||||
|
protected TouchInput touchInput; |
||||||
|
protected InputManager inputManager; |
||||||
|
protected AppStateManager stateManager; |
||||||
|
|
||||||
|
protected AppProfiler prof; |
||||||
|
|
||||||
|
private final ConcurrentLinkedQueue<AppTask<?>> taskQueue = new ConcurrentLinkedQueue<AppTask<?>>(); |
||||||
|
|
||||||
|
/** |
||||||
|
* Create a new instance of <code>LegacyApplication</code>. |
||||||
|
*/ |
||||||
|
public LegacyApplication(){ |
||||||
|
initStateManager(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Determine the application's behavior when unfocused. |
||||||
|
* |
||||||
|
* @return The lost focus behavior of the application. |
||||||
|
*/ |
||||||
|
public LostFocusBehavior getLostFocusBehavior() { |
||||||
|
return lostFocusBehavior; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Change the application's behavior when unfocused. |
||||||
|
* |
||||||
|
* By default, the application will |
||||||
|
* {@link LostFocusBehavior#ThrottleOnLostFocus throttle the update loop} |
||||||
|
* so as to not take 100% CPU usage when it is not in focus, e.g. |
||||||
|
* alt-tabbed, minimized, or obstructed by another window. |
||||||
|
* |
||||||
|
* @param lostFocusBehavior The new lost focus behavior to use. |
||||||
|
* |
||||||
|
* @see LostFocusBehavior |
||||||
|
*/ |
||||||
|
public void setLostFocusBehavior(LostFocusBehavior lostFocusBehavior) { |
||||||
|
this.lostFocusBehavior = lostFocusBehavior; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns true if pause on lost focus is enabled, false otherwise. |
||||||
|
* |
||||||
|
* @return true if pause on lost focus is enabled |
||||||
|
* |
||||||
|
* @see #getLostFocusBehavior() |
||||||
|
*/ |
||||||
|
public boolean isPauseOnLostFocus() { |
||||||
|
return getLostFocusBehavior() == LostFocusBehavior.PauseOnLostFocus; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Enable or disable pause on lost focus. |
||||||
|
* <p> |
||||||
|
* By default, pause on lost focus is enabled. |
||||||
|
* If enabled, the application will stop updating |
||||||
|
* when it loses focus or becomes inactive (e.g. alt-tab). |
||||||
|
* For online or real-time applications, this might not be preferable, |
||||||
|
* so this feature should be set to disabled. For other applications, |
||||||
|
* it is best to keep it on so that CPU usage is not used when |
||||||
|
* not necessary. |
||||||
|
* |
||||||
|
* @param pauseOnLostFocus True to enable pause on lost focus, false |
||||||
|
* otherwise. |
||||||
|
* |
||||||
|
* @see #setLostFocusBehavior(com.jme3.app.LostFocusBehavior) |
||||||
|
*/ |
||||||
|
public void setPauseOnLostFocus(boolean pauseOnLostFocus) { |
||||||
|
if (pauseOnLostFocus) { |
||||||
|
setLostFocusBehavior(LostFocusBehavior.PauseOnLostFocus); |
||||||
|
} else { |
||||||
|
setLostFocusBehavior(LostFocusBehavior.Disabled); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
@Deprecated |
||||||
|
public void setAssetManager(AssetManager assetManager){ |
||||||
|
if (this.assetManager != null) |
||||||
|
throw new IllegalStateException("Can only set asset manager" |
||||||
|
+ " before initialization."); |
||||||
|
|
||||||
|
this.assetManager = assetManager; |
||||||
|
} |
||||||
|
|
||||||
|
private void initAssetManager(){ |
||||||
|
URL assetCfgUrl = null; |
||||||
|
|
||||||
|
if (settings != null){ |
||||||
|
String assetCfg = settings.getString("AssetConfigURL"); |
||||||
|
if (assetCfg != null){ |
||||||
|
try { |
||||||
|
assetCfgUrl = new URL(assetCfg); |
||||||
|
} catch (MalformedURLException ex) { |
||||||
|
} |
||||||
|
if (assetCfgUrl == null) { |
||||||
|
assetCfgUrl = LegacyApplication.class.getClassLoader().getResource(assetCfg); |
||||||
|
if (assetCfgUrl == null) { |
||||||
|
logger.log(Level.SEVERE, "Unable to access AssetConfigURL in asset config:{0}", assetCfg); |
||||||
|
return; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
if (assetCfgUrl == null) { |
||||||
|
assetCfgUrl = JmeSystem.getPlatformAssetConfigURL(); |
||||||
|
} |
||||||
|
if (assetManager == null){ |
||||||
|
assetManager = JmeSystem.newAssetManager(assetCfgUrl); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Set the display settings to define the display created. |
||||||
|
* <p> |
||||||
|
* Examples of display parameters include display pixel width and height, |
||||||
|
* color bit depth, z-buffer bits, anti-aliasing samples, and update frequency. |
||||||
|
* If this method is called while the application is already running, then |
||||||
|
* {@link #restart() } must be called to apply the settings to the display. |
||||||
|
* |
||||||
|
* @param settings The settings to set. |
||||||
|
*/ |
||||||
|
public void setSettings(AppSettings settings){ |
||||||
|
this.settings = settings; |
||||||
|
if (context != null && settings.useInput() != inputEnabled){ |
||||||
|
// may need to create or destroy input based
|
||||||
|
// on settings change
|
||||||
|
inputEnabled = !inputEnabled; |
||||||
|
if (inputEnabled){ |
||||||
|
initInput(); |
||||||
|
}else{ |
||||||
|
destroyInput(); |
||||||
|
} |
||||||
|
}else{ |
||||||
|
inputEnabled = settings.useInput(); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Sets the Timer implementation that will be used for calculating |
||||||
|
* frame times. By default, Application will use the Timer as returned |
||||||
|
* by the current JmeContext implementation. |
||||||
|
*/ |
||||||
|
public void setTimer(Timer timer){ |
||||||
|
this.timer = timer; |
||||||
|
|
||||||
|
if (timer != null) { |
||||||
|
timer.reset(); |
||||||
|
} |
||||||
|
|
||||||
|
if (renderManager != null) { |
||||||
|
renderManager.setTimer(timer); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
public Timer getTimer(){ |
||||||
|
return timer; |
||||||
|
} |
||||||
|
|
||||||
|
private void initDisplay(){ |
||||||
|
// aquire important objects
|
||||||
|
// from the context
|
||||||
|
settings = context.getSettings(); |
||||||
|
|
||||||
|
// Only reset the timer if a user has not already provided one
|
||||||
|
if (timer == null) { |
||||||
|
timer = context.getTimer(); |
||||||
|
} |
||||||
|
|
||||||
|
renderer = context.getRenderer(); |
||||||
|
} |
||||||
|
|
||||||
|
private void initAudio(){ |
||||||
|
if (settings.getAudioRenderer() != null && context.getType() != Type.Headless){ |
||||||
|
audioRenderer = JmeSystem.newAudioRenderer(settings); |
||||||
|
audioRenderer.initialize(); |
||||||
|
AudioContext.setAudioRenderer(audioRenderer); |
||||||
|
|
||||||
|
listener = new Listener(); |
||||||
|
audioRenderer.setListener(listener); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates the camera to use for rendering. Default values are perspective |
||||||
|
* projection with 45° field of view, with near and far values 1 and 1000 |
||||||
|
* units respectively. |
||||||
|
*/ |
||||||
|
private void initCamera(){ |
||||||
|
cam = new Camera(settings.getWidth(), settings.getHeight()); |
||||||
|
|
||||||
|
cam.setFrustumPerspective(45f, (float)cam.getWidth() / cam.getHeight(), 1f, 1000f); |
||||||
|
cam.setLocation(new Vector3f(0f, 0f, 10f)); |
||||||
|
cam.lookAt(new Vector3f(0f, 0f, 0f), Vector3f.UNIT_Y); |
||||||
|
|
||||||
|
renderManager = new RenderManager(renderer); |
||||||
|
//Remy - 09/14/2010 setted the timer in the renderManager
|
||||||
|
renderManager.setTimer(timer); |
||||||
|
|
||||||
|
if (prof != null) { |
||||||
|
renderManager.setAppProfiler(prof); |
||||||
|
} |
||||||
|
|
||||||
|
viewPort = renderManager.createMainView("Default", cam); |
||||||
|
viewPort.setClearFlags(true, true, true); |
||||||
|
|
||||||
|
// Create a new cam for the gui
|
||||||
|
Camera guiCam = new Camera(settings.getWidth(), settings.getHeight()); |
||||||
|
guiViewPort = renderManager.createPostView("Gui Default", guiCam); |
||||||
|
guiViewPort.setClearFlags(false, false, false); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Initializes mouse and keyboard input. Also |
||||||
|
* initializes joystick input if joysticks are enabled in the |
||||||
|
* AppSettings. |
||||||
|
*/ |
||||||
|
private void initInput(){ |
||||||
|
mouseInput = context.getMouseInput(); |
||||||
|
if (mouseInput != null) |
||||||
|
mouseInput.initialize(); |
||||||
|
|
||||||
|
keyInput = context.getKeyInput(); |
||||||
|
if (keyInput != null) |
||||||
|
keyInput.initialize(); |
||||||
|
|
||||||
|
touchInput = context.getTouchInput(); |
||||||
|
if (touchInput != null) |
||||||
|
touchInput.initialize(); |
||||||
|
|
||||||
|
if (!settings.getBoolean("DisableJoysticks")){ |
||||||
|
joyInput = context.getJoyInput(); |
||||||
|
if (joyInput != null) |
||||||
|
joyInput.initialize(); |
||||||
|
} |
||||||
|
|
||||||
|
inputManager = new InputManager(mouseInput, keyInput, joyInput, touchInput); |
||||||
|
} |
||||||
|
|
||||||
|
private void initStateManager(){ |
||||||
|
stateManager = new AppStateManager(this); |
||||||
|
|
||||||
|
// Always register a ResetStatsState to make sure
|
||||||
|
// that the stats are cleared every frame
|
||||||
|
stateManager.attach(new ResetStatsState()); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @return The {@link AssetManager asset manager} for this application. |
||||||
|
*/ |
||||||
|
public AssetManager getAssetManager(){ |
||||||
|
return assetManager; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @return the {@link InputManager input manager}. |
||||||
|
*/ |
||||||
|
public InputManager getInputManager(){ |
||||||
|
return inputManager; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @return the {@link AppStateManager app state manager} |
||||||
|
*/ |
||||||
|
public AppStateManager getStateManager() { |
||||||
|
return stateManager; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @return the {@link RenderManager render manager} |
||||||
|
*/ |
||||||
|
public RenderManager getRenderManager() { |
||||||
|
return renderManager; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @return The {@link Renderer renderer} for the application |
||||||
|
*/ |
||||||
|
public Renderer getRenderer(){ |
||||||
|
return renderer; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @return The {@link AudioRenderer audio renderer} for the application |
||||||
|
*/ |
||||||
|
public AudioRenderer getAudioRenderer() { |
||||||
|
return audioRenderer; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @return The {@link Listener listener} object for audio |
||||||
|
*/ |
||||||
|
public Listener getListener() { |
||||||
|
return listener; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @return The {@link JmeContext display context} for the application |
||||||
|
*/ |
||||||
|
public JmeContext getContext(){ |
||||||
|
return context; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @return The {@link Camera camera} for the application |
||||||
|
*/ |
||||||
|
public Camera getCamera(){ |
||||||
|
return cam; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Starts the application in {@link Type#Display display} mode. |
||||||
|
* |
||||||
|
* @see #start(com.jme3.system.JmeContext.Type) |
||||||
|
*/ |
||||||
|
public void start(){ |
||||||
|
start(JmeContext.Type.Display, false); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Starts the application in {@link Type#Display display} mode. |
||||||
|
* |
||||||
|
* @see #start(com.jme3.system.JmeContext.Type) |
||||||
|
*/ |
||||||
|
public void start(boolean waitFor){ |
||||||
|
start(JmeContext.Type.Display, waitFor); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Starts the application. |
||||||
|
* Creating a rendering context and executing |
||||||
|
* the main loop in a separate thread. |
||||||
|
*/ |
||||||
|
public void start(JmeContext.Type contextType) { |
||||||
|
start(contextType, false); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Starts the application. |
||||||
|
* Creating a rendering context and executing |
||||||
|
* the main loop in a separate thread. |
||||||
|
*/ |
||||||
|
public void start(JmeContext.Type contextType, boolean waitFor){ |
||||||
|
if (context != null && context.isCreated()){ |
||||||
|
logger.warning("start() called when application already created!"); |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
if (settings == null){ |
||||||
|
settings = new AppSettings(true); |
||||||
|
} |
||||||
|
|
||||||
|
logger.log(Level.FINE, "Starting application: {0}", getClass().getName()); |
||||||
|
context = JmeSystem.newContext(settings, contextType); |
||||||
|
context.setSystemListener(this); |
||||||
|
context.create(waitFor); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Sets an AppProfiler hook that will be called back for |
||||||
|
* specific steps within a single update frame. Value defaults |
||||||
|
* to null. |
||||||
|
*/ |
||||||
|
public void setAppProfiler(AppProfiler prof) { |
||||||
|
this.prof = prof; |
||||||
|
if (renderManager != null) { |
||||||
|
renderManager.setAppProfiler(prof); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns the current AppProfiler hook, or null if none is set. |
||||||
|
*/ |
||||||
|
public AppProfiler getAppProfiler() { |
||||||
|
return prof; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Initializes the application's canvas for use. |
||||||
|
* <p> |
||||||
|
* After calling this method, cast the {@link #getContext() context} to |
||||||
|
* {@link JmeCanvasContext}, |
||||||
|
* then acquire the canvas with {@link JmeCanvasContext#getCanvas() } |
||||||
|
* and attach it to an AWT/Swing Frame. |
||||||
|
* The rendering thread will start when the canvas becomes visible on |
||||||
|
* screen, however if you wish to start the context immediately you |
||||||
|
* may call {@link #startCanvas() } to force the rendering thread |
||||||
|
* to start. |
||||||
|
* |
||||||
|
* @see JmeCanvasContext |
||||||
|
* @see Type#Canvas |
||||||
|
*/ |
||||||
|
public void createCanvas(){ |
||||||
|
if (context != null && context.isCreated()){ |
||||||
|
logger.warning("createCanvas() called when application already created!"); |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
if (settings == null){ |
||||||
|
settings = new AppSettings(true); |
||||||
|
} |
||||||
|
|
||||||
|
logger.log(Level.FINE, "Starting application: {0}", getClass().getName()); |
||||||
|
context = JmeSystem.newContext(settings, JmeContext.Type.Canvas); |
||||||
|
context.setSystemListener(this); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Starts the rendering thread after createCanvas() has been called. |
||||||
|
* <p> |
||||||
|
* Same as calling startCanvas(false) |
||||||
|
* |
||||||
|
* @see #startCanvas(boolean) |
||||||
|
*/ |
||||||
|
public void startCanvas(){ |
||||||
|
startCanvas(false); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Starts the rendering thread after createCanvas() has been called. |
||||||
|
* <p> |
||||||
|
* Calling this method is optional, the canvas will start automatically |
||||||
|
* when it becomes visible. |
||||||
|
* |
||||||
|
* @param waitFor If true, the current thread will block until the |
||||||
|
* rendering thread is running |
||||||
|
*/ |
||||||
|
public void startCanvas(boolean waitFor){ |
||||||
|
context.create(waitFor); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Internal use only. |
||||||
|
*/ |
||||||
|
public void reshape(int w, int h){ |
||||||
|
renderManager.notifyReshape(w, h); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Restarts the context, applying any changed settings. |
||||||
|
* <p> |
||||||
|
* Changes to the {@link AppSettings} of this Application are not |
||||||
|
* applied immediately; calling this method forces the context |
||||||
|
* to restart, applying the new settings. |
||||||
|
*/ |
||||||
|
public void restart(){ |
||||||
|
context.setSettings(settings); |
||||||
|
context.restart(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Requests the context to close, shutting down the main loop |
||||||
|
* and making necessary cleanup operations. |
||||||
|
* |
||||||
|
* Same as calling stop(false) |
||||||
|
* |
||||||
|
* @see #stop(boolean) |
||||||
|
*/ |
||||||
|
public void stop(){ |
||||||
|
stop(false); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Requests the context to close, shutting down the main loop |
||||||
|
* and making necessary cleanup operations. |
||||||
|
* After the application has stopped, it cannot be used anymore. |
||||||
|
*/ |
||||||
|
public void stop(boolean waitFor){ |
||||||
|
logger.log(Level.FINE, "Closing application: {0}", getClass().getName()); |
||||||
|
context.destroy(waitFor); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Do not call manually. |
||||||
|
* Callback from ContextListener. |
||||||
|
* <p> |
||||||
|
* Initializes the <code>Application</code>, by creating a display and |
||||||
|
* default camera. If display settings are not specified, a default |
||||||
|
* 640x480 display is created. Default values are used for the camera; |
||||||
|
* perspective projection with 45° field of view, with near |
||||||
|
* and far values 1 and 1000 units respectively. |
||||||
|
*/ |
||||||
|
public void initialize(){ |
||||||
|
if (assetManager == null){ |
||||||
|
initAssetManager(); |
||||||
|
} |
||||||
|
|
||||||
|
initDisplay(); |
||||||
|
initCamera(); |
||||||
|
|
||||||
|
if (inputEnabled){ |
||||||
|
initInput(); |
||||||
|
} |
||||||
|
initAudio(); |
||||||
|
|
||||||
|
// update timer so that the next delta is not too large
|
||||||
|
// timer.update();
|
||||||
|
timer.reset(); |
||||||
|
|
||||||
|
// user code here..
|
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Internal use only. |
||||||
|
*/ |
||||||
|
public void handleError(String errMsg, Throwable t){ |
||||||
|
// Print error to log.
|
||||||
|
logger.log(Level.SEVERE, errMsg, t); |
||||||
|
// Display error message on screen if not in headless mode
|
||||||
|
if (context.getType() != JmeContext.Type.Headless) { |
||||||
|
if (t != null) { |
||||||
|
JmeSystem.showErrorDialog(errMsg + "\n" + t.getClass().getSimpleName() + |
||||||
|
(t.getMessage() != null ? ": " + t.getMessage() : "")); |
||||||
|
} else { |
||||||
|
JmeSystem.showErrorDialog(errMsg); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
stop(); // stop the application
|
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Internal use only. |
||||||
|
*/ |
||||||
|
public void gainFocus(){ |
||||||
|
if (lostFocusBehavior != LostFocusBehavior.Disabled) { |
||||||
|
if (lostFocusBehavior == LostFocusBehavior.PauseOnLostFocus) { |
||||||
|
paused = false; |
||||||
|
} |
||||||
|
context.setAutoFlushFrames(true); |
||||||
|
if (inputManager != null) { |
||||||
|
inputManager.reset(); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Internal use only. |
||||||
|
*/ |
||||||
|
public void loseFocus(){ |
||||||
|
if (lostFocusBehavior != LostFocusBehavior.Disabled){ |
||||||
|
if (lostFocusBehavior == LostFocusBehavior.PauseOnLostFocus) { |
||||||
|
paused = true; |
||||||
|
} |
||||||
|
context.setAutoFlushFrames(false); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Internal use only. |
||||||
|
*/ |
||||||
|
public void requestClose(boolean esc){ |
||||||
|
context.destroy(false); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Enqueues a task/callable object to execute in the jME3 |
||||||
|
* rendering thread. |
||||||
|
* <p> |
||||||
|
* Callables are executed right at the beginning of the main loop. |
||||||
|
* They are executed even if the application is currently paused |
||||||
|
* or out of focus. |
||||||
|
* |
||||||
|
* @param callable The callable to run in the main jME3 thread |
||||||
|
*/ |
||||||
|
public <V> Future<V> enqueue(Callable<V> callable) { |
||||||
|
AppTask<V> task = new AppTask<V>(callable); |
||||||
|
taskQueue.add(task); |
||||||
|
return task; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Enqueues a runnable object to execute in the jME3 |
||||||
|
* rendering thread. |
||||||
|
* <p> |
||||||
|
* Runnables are executed right at the beginning of the main loop. |
||||||
|
* They are executed even if the application is currently paused |
||||||
|
* or out of focus. |
||||||
|
* |
||||||
|
* @param runnable The runnable to run in the main jME3 thread |
||||||
|
*/ |
||||||
|
public void enqueue(Runnable runnable){ |
||||||
|
enqueue(new RunnableWrapper(runnable)); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Runs tasks enqueued via {@link #enqueue(Callable)} |
||||||
|
*/ |
||||||
|
protected void runQueuedTasks() { |
||||||
|
AppTask<?> task; |
||||||
|
while( (task = taskQueue.poll()) != null ) { |
||||||
|
if (!task.isCancelled()) { |
||||||
|
task.invoke(); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Do not call manually. |
||||||
|
* Callback from ContextListener. |
||||||
|
*/ |
||||||
|
public void update(){ |
||||||
|
// Make sure the audio renderer is available to callables
|
||||||
|
AudioContext.setAudioRenderer(audioRenderer); |
||||||
|
|
||||||
|
if (prof!=null) prof.appStep(AppStep.QueuedTasks); |
||||||
|
runQueuedTasks(); |
||||||
|
|
||||||
|
if (speed == 0 || paused) |
||||||
|
return; |
||||||
|
|
||||||
|
timer.update(); |
||||||
|
|
||||||
|
if (inputEnabled){ |
||||||
|
if (prof!=null) prof.appStep(AppStep.ProcessInput); |
||||||
|
inputManager.update(timer.getTimePerFrame()); |
||||||
|
} |
||||||
|
|
||||||
|
if (audioRenderer != null){ |
||||||
|
if (prof!=null) prof.appStep(AppStep.ProcessAudio); |
||||||
|
audioRenderer.update(timer.getTimePerFrame()); |
||||||
|
} |
||||||
|
|
||||||
|
// user code here..
|
||||||
|
} |
||||||
|
|
||||||
|
protected void destroyInput(){ |
||||||
|
if (mouseInput != null) |
||||||
|
mouseInput.destroy(); |
||||||
|
|
||||||
|
if (keyInput != null) |
||||||
|
keyInput.destroy(); |
||||||
|
|
||||||
|
if (joyInput != null) |
||||||
|
joyInput.destroy(); |
||||||
|
|
||||||
|
if (touchInput != null) |
||||||
|
touchInput.destroy(); |
||||||
|
|
||||||
|
inputManager = null; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Do not call manually. |
||||||
|
* Callback from ContextListener. |
||||||
|
*/ |
||||||
|
public void destroy(){ |
||||||
|
stateManager.cleanup(); |
||||||
|
|
||||||
|
destroyInput(); |
||||||
|
if (audioRenderer != null) |
||||||
|
audioRenderer.cleanup(); |
||||||
|
|
||||||
|
timer.reset(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* @return The GUI viewport. Which is used for the on screen |
||||||
|
* statistics and FPS. |
||||||
|
*/ |
||||||
|
public ViewPort getGuiViewPort() { |
||||||
|
return guiViewPort; |
||||||
|
} |
||||||
|
|
||||||
|
public ViewPort getViewPort() { |
||||||
|
return viewPort; |
||||||
|
} |
||||||
|
|
||||||
|
private class RunnableWrapper implements Callable{ |
||||||
|
private final Runnable runnable; |
||||||
|
|
||||||
|
public RunnableWrapper(Runnable runnable){ |
||||||
|
this.runnable = runnable; |
||||||
|
} |
||||||
|
|
||||||
|
@Override |
||||||
|
public Object call(){ |
||||||
|
runnable.run(); |
||||||
|
return null; |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
@ -0,0 +1,81 @@ |
|||||||
|
/* |
||||||
|
* Copyright (c) 2016 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 com.jme3.util.clone; |
||||||
|
|
||||||
|
|
||||||
|
/** |
||||||
|
* Provides custom cloning for a particular object type. Once |
||||||
|
* registered with the Cloner, this function object will be called twice |
||||||
|
* for any cloned object that matches the class for which it was registered. |
||||||
|
* It will first call cloneObject() to shallow clone the object and then call |
||||||
|
* cloneFields() to deep clone the object's values. |
||||||
|
* |
||||||
|
* <p>This two step process is important because this is what allows |
||||||
|
* circular references in the cloned object graph.</p> |
||||||
|
* |
||||||
|
* @author Paul Speed |
||||||
|
*/ |
||||||
|
public interface CloneFunction<T> { |
||||||
|
|
||||||
|
/** |
||||||
|
* Performs a shallow clone of the specified object. This is similar |
||||||
|
* to the JmeCloneable.clone() method in semantics and is the first part |
||||||
|
* of a two part cloning process. Once the shallow clone is created, it |
||||||
|
* is cached and CloneFunction.cloneFields() is called. In this way, |
||||||
|
* the CloneFunction interface can completely take over the JmeCloneable |
||||||
|
* style cloning for an object that doesn't otherwise implement that interface. |
||||||
|
* |
||||||
|
* @param cloner The cloner performing the cloning operation. |
||||||
|
* @param original The original object that needs to be cloned. |
||||||
|
*/ |
||||||
|
public T cloneObject( Cloner cloner, T original ); |
||||||
|
|
||||||
|
|
||||||
|
/** |
||||||
|
* Performs a deep clone of the specified clone's fields. This is similar |
||||||
|
* to the JmeCloneable.cloneFields() method in semantics and is the second part |
||||||
|
* of a two part cloning process. Once the shallow clone is created, it |
||||||
|
* is cached and CloneFunction.cloneFields() is called. In this way, |
||||||
|
* the CloneFunction interface can completely take over the JmeCloneable |
||||||
|
* style cloning for an object that doesn't otherwise implement that interface. |
||||||
|
* |
||||||
|
* @param cloner The cloner performing the cloning operation. |
||||||
|
* @param clone The clone previously returned from cloneObject(). |
||||||
|
* @param original The original object that was cloned. This is provided for |
||||||
|
* the very special case where field cloning needs to refer to |
||||||
|
* the original object. Mostly the necessary fields should already |
||||||
|
* be on the clone. |
||||||
|
*/ |
||||||
|
public void cloneFields( Cloner cloner, T clone, T original ); |
||||||
|
|
||||||
|
} |
||||||
@ -0,0 +1,412 @@ |
|||||||
|
/* |
||||||
|
* Copyright (c) 2016 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 com.jme3.util.clone; |
||||||
|
|
||||||
|
import java.lang.reflect.Array; |
||||||
|
import java.lang.reflect.InvocationTargetException; |
||||||
|
import java.lang.reflect.Method; |
||||||
|
import java.util.HashMap; |
||||||
|
import java.util.IdentityHashMap; |
||||||
|
import java.util.logging.Logger; |
||||||
|
import java.util.logging.Level; |
||||||
|
import java.util.Map; |
||||||
|
import java.util.concurrent.ConcurrentHashMap; |
||||||
|
|
||||||
|
/** |
||||||
|
* A deep clone utility that provides similar object-graph-preserving |
||||||
|
* qualities to typical serialization schemes. An internal registry |
||||||
|
* of cloned objects is kept to be used by other objects in the deep |
||||||
|
* clone process that implement JmeCloneable. |
||||||
|
* |
||||||
|
* <p>By default, objects that do not implement JmeCloneable will |
||||||
|
* be treated like normal Java Cloneable objects. If the object does |
||||||
|
* not implement the JmeCloneable or the regular JDK Cloneable interfaces |
||||||
|
* AND has no special handling defined then an IllegalArgumentException |
||||||
|
* will be thrown.</p> |
||||||
|
* |
||||||
|
* <p>Enhanced object cloning is done in a two step process. First, |
||||||
|
* the object is cloned using the normal Java clone() method and stored |
||||||
|
* in the clone registry. After that, if it implements JmeCloneable then |
||||||
|
* its cloneFields() method is called to deep clone any of the fields. |
||||||
|
* This two step process has a few benefits. First, it means that objects |
||||||
|
* can easily have a regular shallow clone implementation just like any |
||||||
|
* normal Java objects. Second, the deep cloning of fields happens after |
||||||
|
* creation wich means that the clone is available to future field cloning |
||||||
|
* to resolve circular references.</p> |
||||||
|
* |
||||||
|
* <p>Similar to Java serialization, the handling of specific object |
||||||
|
* types can be customized. This allows certain objects to be cloned gracefully |
||||||
|
* even if they aren't normally Cloneable. This can also be used as a |
||||||
|
* sort of filter to keep certain types of objects from being cloned. |
||||||
|
* (For example, adding the IdentityCloneFunction for Mesh.class would cause |
||||||
|
* all mesh instances to be shared with the original object graph.)</p> |
||||||
|
* |
||||||
|
* <p>By default, the Cloner registers serveral default clone functions |
||||||
|
* as follows:</p> |
||||||
|
* <ul> |
||||||
|
* <li>java.util.ArrayList: ListCloneFunction |
||||||
|
* <li>java.util.LinkedList: ListCloneFunction |
||||||
|
* <li>java.util.concurrent.CopyOnWriteArrayList: ListCloneFunction |
||||||
|
* <li>java.util.Vector: ListCloneFunction |
||||||
|
* <li>java.util.Stack: ListCloneFunction |
||||||
|
* <li>com.jme3.util.SafeArrayList: ListCloneFunction |
||||||
|
* </ul> |
||||||
|
* |
||||||
|
* <p>Usage:</p> |
||||||
|
* <pre> |
||||||
|
* // Example 1: using an instantiated, reusable cloner.
|
||||||
|
* Cloner cloner = new Cloner(); |
||||||
|
* Foo fooClone = cloner.clone(foo); |
||||||
|
* cloner.clearIndex(); // prepare it for reuse
|
||||||
|
* Foo fooClone2 = cloner.clone(foo); |
||||||
|
* |
||||||
|
* // Example 2: using the utility method that self-instantiates a temporary cloner.
|
||||||
|
* Foo fooClone = Cloner.deepClone(foo); |
||||||
|
* |
||||||
|
* </pre> |
||||||
|
* |
||||||
|
* @author Paul Speed |
||||||
|
*/ |
||||||
|
public class Cloner { |
||||||
|
|
||||||
|
static Logger log = Logger.getLogger(Cloner.class.getName()); |
||||||
|
|
||||||
|
/** |
||||||
|
* Keeps track of the objects that have been cloned so far. |
||||||
|
*/ |
||||||
|
private IdentityHashMap<Object, Object> index = new IdentityHashMap<Object, Object>(); |
||||||
|
|
||||||
|
/** |
||||||
|
* Custom functions for cloning objects. |
||||||
|
*/ |
||||||
|
private Map<Class, CloneFunction> functions = new HashMap<Class, CloneFunction>(); |
||||||
|
|
||||||
|
/** |
||||||
|
* Cache the clone methods once for all cloners. |
||||||
|
*/ |
||||||
|
private static final Map<Class, Method> methodCache = new ConcurrentHashMap<>(); |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a new cloner with only default clone functions and an empty |
||||||
|
* object index. |
||||||
|
*/ |
||||||
|
public Cloner() { |
||||||
|
// Register some standard types
|
||||||
|
ListCloneFunction listFunction = new ListCloneFunction(); |
||||||
|
functions.put(java.util.ArrayList.class, listFunction); |
||||||
|
functions.put(java.util.LinkedList.class, listFunction); |
||||||
|
functions.put(java.util.concurrent.CopyOnWriteArrayList.class, listFunction); |
||||||
|
functions.put(java.util.Vector.class, listFunction); |
||||||
|
functions.put(java.util.Stack.class, listFunction); |
||||||
|
functions.put(com.jme3.util.SafeArrayList.class, listFunction); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Convenience utility function that creates a new Cloner, uses it to |
||||||
|
* deep clone the object, and then returns the result. |
||||||
|
*/ |
||||||
|
public static <T> T deepClone( T object ) { |
||||||
|
return new Cloner().clone(object); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Deeps clones the specified object, reusing previous clones when possible. |
||||||
|
* |
||||||
|
* <p>Object cloning priority works as follows:</p> |
||||||
|
* <ul> |
||||||
|
* <li>If the object has already been cloned then its clone is returned. |
||||||
|
* <li>If there is a custom CloneFunction then it is called to clone the object. |
||||||
|
* <li>If the object implements Cloneable then its clone() method is called, arrays are |
||||||
|
* deep cloned with entries passing through clone(). |
||||||
|
* <li>If the object implements JmeCloneable then its cloneFields() method is called on the |
||||||
|
* clone. |
||||||
|
* <li>Else an IllegalArgumentException is thrown. |
||||||
|
* </ul> |
||||||
|
* |
||||||
|
* Note: objects returned by this method may not have yet had their cloneField() |
||||||
|
* method called. |
||||||
|
*/ |
||||||
|
public <T> T clone( T object ) { |
||||||
|
return clone(object, true); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Internal method to work around a Java generics typing issue by |
||||||
|
* isolating the 'bad' case into a method with suppressed warnings. |
||||||
|
*/ |
||||||
|
@SuppressWarnings("unchecked") |
||||||
|
private <T> Class<T> objectClass( T object ) { |
||||||
|
// This should be 100% allowed without a cast but Java generics
|
||||||
|
// is not that smart sometimes.
|
||||||
|
// Wrapping it in a method at least isolates the warning suppression
|
||||||
|
return (Class<T>)object.getClass(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Deeps clones the specified object, reusing previous clones when possible. |
||||||
|
* |
||||||
|
* <p>Object cloning priority works as follows:</p> |
||||||
|
* <ul> |
||||||
|
* <li>If the object has already been cloned then its clone is returned. |
||||||
|
* <li>If useFunctions is true and there is a custom CloneFunction then it is |
||||||
|
* called to clone the object. |
||||||
|
* <li>If the object implements Cloneable then its clone() method is called, arrays are |
||||||
|
* deep cloned with entries passing through clone(). |
||||||
|
* <li>If the object implements JmeCloneable then its cloneFields() method is called on the |
||||||
|
* clone. |
||||||
|
* <li>Else an IllegalArgumentException is thrown. |
||||||
|
* </ul> |
||||||
|
* |
||||||
|
* <p>The abililty to selectively use clone functions is useful when |
||||||
|
* being called from a clone function.</p> |
||||||
|
* |
||||||
|
* Note: objects returned by this method may not have yet had their cloneField() |
||||||
|
* method called. |
||||||
|
*/ |
||||||
|
public <T> T clone( T object, boolean useFunctions ) { |
||||||
|
|
||||||
|
if( object == null ) { |
||||||
|
return null; |
||||||
|
} |
||||||
|
|
||||||
|
if( log.isLoggable(Level.FINER) ) { |
||||||
|
log.finer("cloning:" + object.getClass() + "@" + System.identityHashCode(object)); |
||||||
|
} |
||||||
|
|
||||||
|
Class<T> type = objectClass(object); |
||||||
|
|
||||||
|
// Check the index to see if we already have it
|
||||||
|
Object clone = index.get(object); |
||||||
|
if( clone != null ) { |
||||||
|
if( log.isLoggable(Level.FINER) ) { |
||||||
|
log.finer("cloned:" + object.getClass() + "@" + System.identityHashCode(object) |
||||||
|
+ " as cached:" + clone.getClass() + "@" + System.identityHashCode(clone)); |
||||||
|
} |
||||||
|
return type.cast(clone); |
||||||
|
} |
||||||
|
|
||||||
|
// See if there is a custom function... that trumps everything.
|
||||||
|
CloneFunction<T> f = getCloneFunction(type); |
||||||
|
if( f != null ) { |
||||||
|
T result = f.cloneObject(this, object); |
||||||
|
|
||||||
|
// Store the object in the identity map so that any circular references
|
||||||
|
// are resolvable.
|
||||||
|
index.put(object, result); |
||||||
|
|
||||||
|
// Now call the function again to deep clone the fields
|
||||||
|
f.cloneFields(this, result, object); |
||||||
|
|
||||||
|
if( log.isLoggable(Level.FINER) ) { |
||||||
|
if( result == null ) { |
||||||
|
log.finer("cloned:" + object.getClass() + "@" + System.identityHashCode(object) |
||||||
|
+ " as transformed:null"); |
||||||
|
} else { |
||||||
|
log.finer("clone:" + object.getClass() + "@" + System.identityHashCode(object) |
||||||
|
+ " as transformed:" + result.getClass() + "@" + System.identityHashCode(result)); |
||||||
|
} |
||||||
|
} |
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
if( object.getClass().isArray() ) { |
||||||
|
// Perform an array clone
|
||||||
|
clone = arrayClone(object); |
||||||
|
|
||||||
|
// Array clone already indexes the clone
|
||||||
|
} else if( object instanceof JmeCloneable ) { |
||||||
|
// Use the two-step cloning semantics
|
||||||
|
clone = ((JmeCloneable)object).jmeClone(); |
||||||
|
|
||||||
|
// Store the object in the identity map so that any circular references
|
||||||
|
// are resolvable
|
||||||
|
index.put(object, clone); |
||||||
|
|
||||||
|
((JmeCloneable)clone).cloneFields(this, object); |
||||||
|
} else if( object instanceof Cloneable ) { |
||||||
|
|
||||||
|
// Perform a regular Java shallow clone
|
||||||
|
try { |
||||||
|
clone = javaClone(object); |
||||||
|
} catch( CloneNotSupportedException e ) { |
||||||
|
throw new IllegalArgumentException("Object is not cloneable, type:" + type, e); |
||||||
|
} |
||||||
|
|
||||||
|
// Store the object in the identity map so that any circular references
|
||||||
|
// are resolvable
|
||||||
|
index.put(object, clone); |
||||||
|
} else { |
||||||
|
throw new IllegalArgumentException("Object is not cloneable, type:" + type); |
||||||
|
} |
||||||
|
|
||||||
|
if( log.isLoggable(Level.FINER) ) { |
||||||
|
log.finer("cloned:" + object.getClass() + "@" + System.identityHashCode(object) |
||||||
|
+ " as " + clone.getClass() + "@" + System.identityHashCode(clone)); |
||||||
|
} |
||||||
|
return type.cast(clone); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Sets a custom CloneFunction for implementations of the specified Java type. Some |
||||||
|
* inheritance checks are made but no disambiguation is performed. |
||||||
|
* <p>Note: in the general case, it is better to register against specific classes and |
||||||
|
* not super-classes or super-interfaces unless you know specifically that they are cloneable.</p> |
||||||
|
* <p>By default ListCloneFunction is registered for ArrayList, LinkedList, CopyOnWriteArrayList, |
||||||
|
* Vector, Stack, and JME's SafeArrayList.</p> |
||||||
|
*/ |
||||||
|
public <T> void setCloneFunction( Class<T> type, CloneFunction<T> function ) { |
||||||
|
if( function == null ) { |
||||||
|
functions.remove(type); |
||||||
|
} else { |
||||||
|
functions.put(type, function); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns a previously registered clone function for the specified type or null |
||||||
|
* if there is no custom clone function for the type. |
||||||
|
*/ |
||||||
|
@SuppressWarnings("unchecked") |
||||||
|
public <T> CloneFunction<T> getCloneFunction( Class<T> type ) { |
||||||
|
CloneFunction<T> result = (CloneFunction<T>)functions.get(type); |
||||||
|
if( result == null ) { |
||||||
|
// Do a more exhaustive search
|
||||||
|
for( Map.Entry<Class, CloneFunction> e : functions.entrySet() ) { |
||||||
|
if( e.getKey().isAssignableFrom(type) ) { |
||||||
|
result = e.getValue(); |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
if( result != null ) { |
||||||
|
// Cache it for later
|
||||||
|
functions.put(type, result); |
||||||
|
} |
||||||
|
} |
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Forces an object to be added to the indexing cache such that attempts |
||||||
|
* to clone the 'original' will always result in the 'clone' being returned. |
||||||
|
* This can be used to stub out specific values from being cloned or to |
||||||
|
* force global shared instances to be used even if the object is cloneable |
||||||
|
* normally. |
||||||
|
*/ |
||||||
|
public <T> void setClonedValue( T original, T clone ) { |
||||||
|
index.put(original, clone); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns true if the specified object has already been cloned |
||||||
|
* by this cloner during this session. Cloned objects are cached |
||||||
|
* for later use and it's sometimes convenient to know if some |
||||||
|
* objects have already been cloned. |
||||||
|
*/ |
||||||
|
public boolean isCloned( Object o ) { |
||||||
|
return index.containsKey(o); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Clears the object index allowing the cloner to be reused for a brand new |
||||||
|
* cloning operation. |
||||||
|
*/ |
||||||
|
public void clearIndex() { |
||||||
|
index.clear(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Performs a raw shallow Java clone using reflection. This call does NOT |
||||||
|
* check against the clone index and so will return new objects every time |
||||||
|
* it is called. That's because these are shallow clones and have not (and may |
||||||
|
* not ever, depending on the caller) get resolved. |
||||||
|
* |
||||||
|
* <p>This method is provided as a convenient way for CloneFunctions to call |
||||||
|
* clone() and objects without necessarily knowing their real type.</p> |
||||||
|
*/ |
||||||
|
public <T> T javaClone( T object ) throws CloneNotSupportedException { |
||||||
|
Method m = methodCache.get(object.getClass()); |
||||||
|
if( m == null ) { |
||||||
|
try { |
||||||
|
// Lookup the method and cache it
|
||||||
|
m = object.getClass().getMethod("clone"); |
||||||
|
} catch( NoSuchMethodException e ) { |
||||||
|
throw new CloneNotSupportedException("No public clone method found for:" + object.getClass()); |
||||||
|
} |
||||||
|
methodCache.put(object.getClass(), m); |
||||||
|
|
||||||
|
// Note: yes we might cache the method twice... but so what?
|
||||||
|
} |
||||||
|
|
||||||
|
try { |
||||||
|
Class<? extends T> type = objectClass(object); |
||||||
|
return type.cast(m.invoke(object)); |
||||||
|
} catch( IllegalAccessException | InvocationTargetException e ) { |
||||||
|
throw new RuntimeException("Error cloning object of type:" + object.getClass(), e); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Clones a primitive array by coping it and clones an object |
||||||
|
* array by coping it and then running each of its values through |
||||||
|
* Cloner.clone(). |
||||||
|
*/ |
||||||
|
protected <T> T arrayClone( T object ) { |
||||||
|
|
||||||
|
// Java doesn't support the cloning of arrays through reflection unless
|
||||||
|
// you open access to Object's protected clone array... which requires
|
||||||
|
// elevated privileges. So we will do a work-around that is slightly less
|
||||||
|
// elegant.
|
||||||
|
// This should be 100% allowed without a case but Java generics
|
||||||
|
// is not that smart
|
||||||
|
Class<T> type = objectClass(object); |
||||||
|
Class elementType = type.getComponentType(); |
||||||
|
int size = Array.getLength(object); |
||||||
|
Object clone = Array.newInstance(elementType, size); |
||||||
|
|
||||||
|
// Store the clone for later lookups
|
||||||
|
index.put(object, clone); |
||||||
|
|
||||||
|
if( elementType.isPrimitive() ) { |
||||||
|
// Then our job is a bit easier
|
||||||
|
System.arraycopy(object, 0, clone, 0, size); |
||||||
|
} else { |
||||||
|
// Else it's an object array so we'll clone it and its children
|
||||||
|
for( int i = 0; i < size; i++ ) { |
||||||
|
Object element = clone(Array.get(object, i)); |
||||||
|
Array.set(clone, i, element); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return type.cast(clone); |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,58 @@ |
|||||||
|
/* |
||||||
|
* Copyright (c) 2016 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 com.jme3.util.clone; |
||||||
|
|
||||||
|
|
||||||
|
/** |
||||||
|
* A CloneFunction implementation that simply returns the |
||||||
|
* the passed object without cloning it. This is useful for |
||||||
|
* forcing some object types (like Meshes) to be shared between |
||||||
|
* the original and cloned object graph. |
||||||
|
* |
||||||
|
* @author Paul Speed |
||||||
|
*/ |
||||||
|
public class IdentityCloneFunction<T> implements CloneFunction<T> { |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns the object directly. |
||||||
|
*/ |
||||||
|
public T cloneObject( Cloner cloner, T object ) { |
||||||
|
return object; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Does nothing. |
||||||
|
*/ |
||||||
|
public void cloneFields( Cloner cloner, T clone, T object ) { |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,99 @@ |
|||||||
|
/* |
||||||
|
* Copyright (c) 2016 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 com.jme3.util.clone; |
||||||
|
|
||||||
|
|
||||||
|
/** |
||||||
|
* Indicates an object that wishes to more actively participate in the |
||||||
|
* two-part deep copying process provided by the Cloner. Objects implementing |
||||||
|
* this interface can access the already cloned object graph to resolve |
||||||
|
* their local dependencies in a way that will be equivalent to the |
||||||
|
* original object graph. In other words, if two objects in the graph |
||||||
|
* share the same target reference then the cloned version will share |
||||||
|
* the cloned reference. |
||||||
|
* |
||||||
|
* <p>For example, if an object wishes to deep clone one of its fields |
||||||
|
* then it will call cloner.clone(object) instead of object.clone(). |
||||||
|
* The cloner will keep track of any clones already created for 'object' |
||||||
|
* and return that instead of a new clone.</p> |
||||||
|
* |
||||||
|
* <p>Cloning of a JmeCloneable object is done in two parts. First, |
||||||
|
* the standard Java clone() method is called to create a shallow clone |
||||||
|
* of the object. Second, the cloner wil lcall the cloneFields() method |
||||||
|
* to let the object deep clone any of its fields that should be cloned.</p> |
||||||
|
* |
||||||
|
* <p>This two part process is necessary to facilitate circular references. |
||||||
|
* When an object calls cloner.clone() during its cloneFields() method, it |
||||||
|
* may get only a shallow copy that will be filled in later.</p> |
||||||
|
* |
||||||
|
* @author Paul Speed |
||||||
|
*/ |
||||||
|
public interface JmeCloneable extends Cloneable { |
||||||
|
|
||||||
|
/** |
||||||
|
* Performs a regular shallow clone of the object. Some fields |
||||||
|
* may also be cloned but generally only if they will never be |
||||||
|
* shared with other objects. (For example, local Vector3fs and so on.) |
||||||
|
* |
||||||
|
* <p>This method is separate from the regular clone() method |
||||||
|
* so that objects might still maintain their own regular java clone() |
||||||
|
* semantics (perhaps even using Cloner for those methods). However, |
||||||
|
* because Java's clone() has specific features in the sense of Object's |
||||||
|
* clone() implementation, it's usually best to have some path for |
||||||
|
* subclasses to bypass the public clone() method that might be cloning |
||||||
|
* fields and instead get at the superclass protected clone() methods. |
||||||
|
* For example, through super.jmeClone() or another protected clone |
||||||
|
* method that some base class eventually calls super.clone() in.</p> |
||||||
|
*/ |
||||||
|
public Object jmeClone(); |
||||||
|
|
||||||
|
/** |
||||||
|
* Implemented to perform deep cloning for this object, resolving |
||||||
|
* local cloned references using the specified cloner. The object |
||||||
|
* can call cloner.clone(fieldValue) to deep clone any of its fields. |
||||||
|
* |
||||||
|
* <p>Note: during normal clone operations the original object |
||||||
|
* will not be needed as the clone has already had all of the fields |
||||||
|
* shallow copied.</p> |
||||||
|
* |
||||||
|
* @param cloner The cloner that is performing the cloning operation. The |
||||||
|
* cloneFields method can call back into the cloner to make |
||||||
|
* clones if its subordinate fields. |
||||||
|
* @param original The original object from which this object was cloned. |
||||||
|
* This is provided for the very rare case that this object needs |
||||||
|
* to refer to its original for some reason. In general, all of |
||||||
|
* the relevant values should have been transferred during the |
||||||
|
* shallow clone and this object need merely clone what it wants. |
||||||
|
*/ |
||||||
|
public void cloneFields( Cloner cloner, Object original ); |
||||||
|
} |
||||||
@ -0,0 +1,70 @@ |
|||||||
|
/* |
||||||
|
* Copyright (c) 2016 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 com.jme3.util.clone; |
||||||
|
|
||||||
|
import java.util.List; |
||||||
|
|
||||||
|
/** |
||||||
|
* A CloneFunction implementation that deep clones a list by |
||||||
|
* creating a new list and cloning its values using the cloner. |
||||||
|
* |
||||||
|
* @author Paul Speed |
||||||
|
*/ |
||||||
|
public class ListCloneFunction<T extends List> implements CloneFunction<T> { |
||||||
|
|
||||||
|
public T cloneObject( Cloner cloner, T object ) { |
||||||
|
try { |
||||||
|
T clone = cloner.javaClone(object); |
||||||
|
return clone; |
||||||
|
} catch( CloneNotSupportedException e ) { |
||||||
|
throw new IllegalArgumentException("Clone not supported for type:" + object.getClass(), e); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Clones the elements of the list. |
||||||
|
*/ |
||||||
|
@SuppressWarnings("unchecked") |
||||||
|
public void cloneFields( Cloner cloner, T clone, T object ) { |
||||||
|
for( int i = 0; i < clone.size(); i++ ) { |
||||||
|
// Need to clone the clones... because T might
|
||||||
|
// have done something special in its clone method that
|
||||||
|
// we will have to adhere to. For example, clone may have nulled
|
||||||
|
// out some things or whatever that might be implementation specific.
|
||||||
|
// At any rate, if it's a proper clone then the clone will already
|
||||||
|
// have shallow versions of the elements that we can clone.
|
||||||
|
clone.set(i, cloner.clone(clone.get(i))); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
@ -1,80 +0,0 @@ |
|||||||
#import "Common/ShaderLib/Shadows15.glsllib" |
|
||||||
|
|
||||||
out vec4 outFragColor; |
|
||||||
|
|
||||||
#if defined(PSSM) || defined(FADE) |
|
||||||
in float shadowPosition; |
|
||||||
#endif |
|
||||||
|
|
||||||
in vec4 projCoord0; |
|
||||||
in vec4 projCoord1; |
|
||||||
in vec4 projCoord2; |
|
||||||
in vec4 projCoord3; |
|
||||||
|
|
||||||
#ifdef POINTLIGHT |
|
||||||
in vec4 projCoord4; |
|
||||||
in vec4 projCoord5; |
|
||||||
in vec4 worldPos; |
|
||||||
uniform vec3 m_LightPos; |
|
||||||
#else |
|
||||||
#ifndef PSSM |
|
||||||
in float lightDot; |
|
||||||
#endif |
|
||||||
#endif |
|
||||||
|
|
||||||
#ifdef DISCARD_ALPHA |
|
||||||
#ifdef COLOR_MAP |
|
||||||
uniform sampler2D m_ColorMap; |
|
||||||
#else |
|
||||||
uniform sampler2D m_DiffuseMap; |
|
||||||
#endif |
|
||||||
uniform float m_AlphaDiscardThreshold; |
|
||||||
varying vec2 texCoord; |
|
||||||
#endif |
|
||||||
|
|
||||||
#ifdef FADE |
|
||||||
uniform vec2 m_FadeInfo; |
|
||||||
#endif |
|
||||||
|
|
||||||
void main(){ |
|
||||||
|
|
||||||
#ifdef DISCARD_ALPHA |
|
||||||
#ifdef COLOR_MAP |
|
||||||
float alpha = texture2D(m_ColorMap,texCoord).a; |
|
||||||
#else |
|
||||||
float alpha = texture2D(m_DiffuseMap,texCoord).a; |
|
||||||
#endif |
|
||||||
|
|
||||||
if(alpha < m_AlphaDiscardThreshold){ |
|
||||||
discard; |
|
||||||
} |
|
||||||
#endif |
|
||||||
|
|
||||||
float shadow = 1.0; |
|
||||||
#ifdef POINTLIGHT |
|
||||||
shadow = getPointLightShadows(worldPos, m_LightPos, |
|
||||||
m_ShadowMap0,m_ShadowMap1,m_ShadowMap2,m_ShadowMap3,m_ShadowMap4,m_ShadowMap5, |
|
||||||
projCoord0, projCoord1, projCoord2, projCoord3, projCoord4, projCoord5); |
|
||||||
#else |
|
||||||
#ifdef PSSM |
|
||||||
shadow = getDirectionalLightShadows(m_Splits, shadowPosition, |
|
||||||
m_ShadowMap0,m_ShadowMap1,m_ShadowMap2,m_ShadowMap3, |
|
||||||
projCoord0, projCoord1, projCoord2, projCoord3); |
|
||||||
#else |
|
||||||
//spotlight |
|
||||||
if(lightDot < 0){ |
|
||||||
outFragColor = vec4(1.0); |
|
||||||
return; |
|
||||||
} |
|
||||||
shadow = getSpotLightShadows(m_ShadowMap0,projCoord0); |
|
||||||
#endif |
|
||||||
#endif |
|
||||||
|
|
||||||
#ifdef FADE |
|
||||||
shadow = max(0.0,mix(shadow,1.0,(shadowPosition - m_FadeInfo.x) * m_FadeInfo.y)); |
|
||||||
#endif |
|
||||||
|
|
||||||
shadow = shadow * m_ShadowIntensity + (1.0 - m_ShadowIntensity); |
|
||||||
outFragColor = vec4(shadow, shadow, shadow, 1.0); |
|
||||||
} |
|
||||||
|
|
||||||
@ -1,82 +0,0 @@ |
|||||||
#import "Common/ShaderLib/Instancing.glsllib" |
|
||||||
#import "Common/ShaderLib/Skinning.glsllib" |
|
||||||
uniform mat4 m_LightViewProjectionMatrix0; |
|
||||||
uniform mat4 m_LightViewProjectionMatrix1; |
|
||||||
uniform mat4 m_LightViewProjectionMatrix2; |
|
||||||
uniform mat4 m_LightViewProjectionMatrix3; |
|
||||||
|
|
||||||
|
|
||||||
out vec4 projCoord0; |
|
||||||
out vec4 projCoord1; |
|
||||||
out vec4 projCoord2; |
|
||||||
out vec4 projCoord3; |
|
||||||
|
|
||||||
#ifdef POINTLIGHT |
|
||||||
uniform mat4 m_LightViewProjectionMatrix4; |
|
||||||
uniform mat4 m_LightViewProjectionMatrix5; |
|
||||||
out vec4 projCoord4; |
|
||||||
out vec4 projCoord5; |
|
||||||
out vec4 worldPos; |
|
||||||
#else |
|
||||||
#ifndef PSSM |
|
||||||
uniform vec3 m_LightPos; |
|
||||||
uniform vec3 m_LightDir; |
|
||||||
out float lightDot; |
|
||||||
#endif |
|
||||||
#endif |
|
||||||
|
|
||||||
#if defined(PSSM) || defined(FADE) |
|
||||||
out float shadowPosition; |
|
||||||
#endif |
|
||||||
out vec3 lightVec; |
|
||||||
|
|
||||||
out vec2 texCoord; |
|
||||||
|
|
||||||
in vec3 inPosition; |
|
||||||
|
|
||||||
#ifdef DISCARD_ALPHA |
|
||||||
in vec2 inTexCoord; |
|
||||||
#endif |
|
||||||
|
|
||||||
const mat4 biasMat = mat4(0.5, 0.0, 0.0, 0.0, |
|
||||||
0.0, 0.5, 0.0, 0.0, |
|
||||||
0.0, 0.0, 0.5, 0.0, |
|
||||||
0.5, 0.5, 0.5, 1.0); |
|
||||||
|
|
||||||
|
|
||||||
void main(){ |
|
||||||
vec4 modelSpacePos = vec4(inPosition, 1.0); |
|
||||||
|
|
||||||
#ifdef NUM_BONES |
|
||||||
Skinning_Compute(modelSpacePos); |
|
||||||
#endif |
|
||||||
gl_Position = TransformWorldViewProjection(modelSpacePos); |
|
||||||
|
|
||||||
#if defined(PSSM) || defined(FADE) |
|
||||||
shadowPosition = gl_Position.z; |
|
||||||
#endif |
|
||||||
|
|
||||||
#ifndef POINTLIGHT |
|
||||||
vec4 worldPos=vec4(0.0); |
|
||||||
#endif |
|
||||||
// get the vertex in world space |
|
||||||
worldPos = TransformWorld(modelSpacePos); |
|
||||||
|
|
||||||
#ifdef DISCARD_ALPHA |
|
||||||
texCoord = inTexCoord; |
|
||||||
#endif |
|
||||||
// populate the light view matrices array and convert vertex to light viewProj space |
|
||||||
projCoord0 = biasMat * m_LightViewProjectionMatrix0 * worldPos; |
|
||||||
projCoord1 = biasMat * m_LightViewProjectionMatrix1 * worldPos; |
|
||||||
projCoord2 = biasMat * m_LightViewProjectionMatrix2 * worldPos; |
|
||||||
projCoord3 = biasMat * m_LightViewProjectionMatrix3 * worldPos; |
|
||||||
#ifdef POINTLIGHT |
|
||||||
projCoord4 = biasMat * m_LightViewProjectionMatrix4 * worldPos; |
|
||||||
projCoord5 = biasMat * m_LightViewProjectionMatrix5 * worldPos; |
|
||||||
#else |
|
||||||
#ifndef PSSM |
|
||||||
vec3 lightDir = worldPos.xyz - m_LightPos; |
|
||||||
lightDot = dot(m_LightDir,lightDir); |
|
||||||
#endif |
|
||||||
#endif |
|
||||||
} |
|
||||||
@ -1,242 +0,0 @@ |
|||||||
// Because gpu_shader5 is actually where those |
|
||||||
// gather functions are declared to work on shadowmaps |
|
||||||
#extension GL_ARB_gpu_shader5 : enable |
|
||||||
|
|
||||||
#ifdef HARDWARE_SHADOWS |
|
||||||
#define SHADOWMAP sampler2DShadow |
|
||||||
#define SHADOWCOMPAREOFFSET(tex,coord,offset) textureProjOffset(tex, coord, offset) |
|
||||||
#define SHADOWCOMPARE(tex,coord) textureProj(tex, coord) |
|
||||||
#define SHADOWGATHER(tex,coord) textureGather(tex, coord.xy, coord.z) |
|
||||||
#else |
|
||||||
#define SHADOWMAP sampler2D |
|
||||||
#define SHADOWCOMPAREOFFSET(tex,coord,offset) step(coord.z, textureProjOffset(tex, coord, offset).r) |
|
||||||
#define SHADOWCOMPARE(tex,coord) step(coord.z, textureProj(tex, coord).r) |
|
||||||
#define SHADOWGATHER(tex,coord) step(coord.z, textureGather(tex, coord.xy)) |
|
||||||
#endif |
|
||||||
|
|
||||||
|
|
||||||
#if FILTER_MODE == 0 |
|
||||||
#define GETSHADOW Shadow_Nearest |
|
||||||
#define KERNEL 1.0 |
|
||||||
#elif FILTER_MODE == 1 |
|
||||||
#ifdef HARDWARE_SHADOWS |
|
||||||
#define GETSHADOW Shadow_Nearest |
|
||||||
#else |
|
||||||
#define GETSHADOW Shadow_DoBilinear_2x2 |
|
||||||
#endif |
|
||||||
#define KERNEL 1.0 |
|
||||||
#elif FILTER_MODE == 2 |
|
||||||
#define GETSHADOW Shadow_DoDither_2x2 |
|
||||||
#define KERNEL 1.0 |
|
||||||
#elif FILTER_MODE == 3 |
|
||||||
#define GETSHADOW Shadow_DoPCF |
|
||||||
#define KERNEL 4.0 |
|
||||||
#elif FILTER_MODE == 4 |
|
||||||
#define GETSHADOW Shadow_DoPCFPoisson |
|
||||||
#define KERNEL 4.0 |
|
||||||
#elif FILTER_MODE == 5 |
|
||||||
#define GETSHADOW Shadow_DoPCF |
|
||||||
#define KERNEL 8.0 |
|
||||||
#endif |
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
uniform SHADOWMAP m_ShadowMap0; |
|
||||||
uniform SHADOWMAP m_ShadowMap1; |
|
||||||
uniform SHADOWMAP m_ShadowMap2; |
|
||||||
uniform SHADOWMAP m_ShadowMap3; |
|
||||||
#ifdef POINTLIGHT |
|
||||||
uniform SHADOWMAP m_ShadowMap4; |
|
||||||
uniform SHADOWMAP m_ShadowMap5; |
|
||||||
#endif |
|
||||||
|
|
||||||
#ifdef PSSM |
|
||||||
uniform vec4 m_Splits; |
|
||||||
#endif |
|
||||||
uniform float m_ShadowIntensity; |
|
||||||
|
|
||||||
const vec2 pixSize2 = vec2(1.0 / SHADOWMAP_SIZE); |
|
||||||
float shadowBorderScale = 1.0; |
|
||||||
|
|
||||||
float Shadow_BorderCheck(in vec2 coord){ |
|
||||||
// Fastest, "hack" method (uses 4-5 instructions) |
|
||||||
vec4 t = vec4(coord.xy, 0.0, 1.0); |
|
||||||
t = step(t.wwxy, t.xyzz); |
|
||||||
return dot(t,t); |
|
||||||
} |
|
||||||
|
|
||||||
float Shadow_Nearest(in SHADOWMAP tex, in vec4 projCoord){ |
|
||||||
float border = Shadow_BorderCheck(projCoord.xy); |
|
||||||
if (border > 0.0){ |
|
||||||
return 1.0; |
|
||||||
} |
|
||||||
return SHADOWCOMPARE(tex,projCoord); |
|
||||||
} |
|
||||||
|
|
||||||
float Shadow_DoDither_2x2(in SHADOWMAP tex, in vec4 projCoord){ |
|
||||||
float border = Shadow_BorderCheck(projCoord.xy); |
|
||||||
if (border > 0.0) |
|
||||||
return 1.0; |
|
||||||
|
|
||||||
vec2 pixSize = pixSize2 * shadowBorderScale; |
|
||||||
|
|
||||||
float shadow = 0.0; |
|
||||||
ivec2 o = ivec2(mod(floor(gl_FragCoord.xy), 2.0)); |
|
||||||
shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy+pixSize*(vec2(-1.5, 1.5)+o), projCoord.zw)); |
|
||||||
shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy+pixSize*(vec2( 0.5, 1.5)+o), projCoord.zw)); |
|
||||||
shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy+pixSize*(vec2(-1.5, -0.5)+o), projCoord.zw)); |
|
||||||
shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy+pixSize*(vec2( 0.5, -0.5)+o), projCoord.zw)); |
|
||||||
shadow *= 0.25; |
|
||||||
return shadow; |
|
||||||
} |
|
||||||
|
|
||||||
float Shadow_DoBilinear_2x2(in SHADOWMAP tex, in vec4 projCoord){ |
|
||||||
float border = Shadow_BorderCheck(projCoord.xy); |
|
||||||
if (border > 0.0) |
|
||||||
return 1.0; |
|
||||||
|
|
||||||
#ifdef GL_ARB_gpu_shader5 |
|
||||||
vec4 coord = vec4(projCoord.xyz / projCoord.www,0.0); |
|
||||||
vec4 gather = SHADOWGATHER(tex, coord); |
|
||||||
#else |
|
||||||
vec4 gather = vec4(0.0); |
|
||||||
gather.x = SHADOWCOMPAREOFFSET(tex, projCoord, ivec2(0, 1)); |
|
||||||
gather.y = SHADOWCOMPAREOFFSET(tex, projCoord, ivec2(1, 1)); |
|
||||||
gather.z = SHADOWCOMPAREOFFSET(tex, projCoord, ivec2(1, 0)); |
|
||||||
gather.w = SHADOWCOMPAREOFFSET(tex, projCoord, ivec2(0, 0)); |
|
||||||
#endif |
|
||||||
|
|
||||||
vec2 f = fract( projCoord.xy * SHADOWMAP_SIZE ); |
|
||||||
vec2 mx = mix( gather.wx, gather.zy, f.x ); |
|
||||||
return mix( mx.x, mx.y, f.y ); |
|
||||||
} |
|
||||||
|
|
||||||
float Shadow_DoPCF(in SHADOWMAP tex, in vec4 projCoord){ |
|
||||||
|
|
||||||
vec2 pixSize = pixSize2 * shadowBorderScale; |
|
||||||
float shadow = 0.0; |
|
||||||
float border = Shadow_BorderCheck(projCoord.xy); |
|
||||||
if (border > 0.0) |
|
||||||
return 1.0; |
|
||||||
|
|
||||||
float bound = KERNEL * 0.5 - 0.5; |
|
||||||
bound *= PCFEDGE; |
|
||||||
for (float y = -bound; y <= bound; y += PCFEDGE){ |
|
||||||
for (float x = -bound; x <= bound; x += PCFEDGE){ |
|
||||||
vec4 coord = vec4(projCoord.xy + vec2(x,y) * pixSize, projCoord.zw); |
|
||||||
shadow += SHADOWCOMPARE(tex, coord); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
shadow = shadow / (KERNEL * KERNEL); |
|
||||||
return shadow; |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
//12 tap poisson disk |
|
||||||
const vec2 poissonDisk0 = vec2(-0.1711046, -0.425016); |
|
||||||
const vec2 poissonDisk1 = vec2(-0.7829809, 0.2162201); |
|
||||||
const vec2 poissonDisk2 = vec2(-0.2380269, -0.8835521); |
|
||||||
const vec2 poissonDisk3 = vec2(0.4198045, 0.1687819); |
|
||||||
const vec2 poissonDisk4 = vec2(-0.684418, -0.3186957); |
|
||||||
const vec2 poissonDisk5 = vec2(0.6026866, -0.2587841); |
|
||||||
const vec2 poissonDisk6 = vec2(-0.2412762, 0.3913516); |
|
||||||
const vec2 poissonDisk7 = vec2(0.4720655, -0.7664126); |
|
||||||
const vec2 poissonDisk8 = vec2(0.9571564, 0.2680693); |
|
||||||
const vec2 poissonDisk9 = vec2(-0.5238616, 0.802707); |
|
||||||
const vec2 poissonDisk10 = vec2(0.5653144, 0.60262); |
|
||||||
const vec2 poissonDisk11 = vec2(0.0123658, 0.8627419); |
|
||||||
|
|
||||||
|
|
||||||
float Shadow_DoPCFPoisson(in SHADOWMAP tex, in vec4 projCoord){ |
|
||||||
|
|
||||||
float shadow = 0.0; |
|
||||||
float border = Shadow_BorderCheck(projCoord.xy); |
|
||||||
if (border > 0.0){ |
|
||||||
return 1.0; |
|
||||||
} |
|
||||||
|
|
||||||
vec2 texelSize = pixSize2 * 4.0 * PCFEDGE * shadowBorderScale; |
|
||||||
|
|
||||||
shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk0 * texelSize, projCoord.zw)); |
|
||||||
shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk1 * texelSize, projCoord.zw)); |
|
||||||
shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk2 * texelSize, projCoord.zw)); |
|
||||||
shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk3 * texelSize, projCoord.zw)); |
|
||||||
shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk4 * texelSize, projCoord.zw)); |
|
||||||
shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk5 * texelSize, projCoord.zw)); |
|
||||||
shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk6 * texelSize, projCoord.zw)); |
|
||||||
shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk7 * texelSize, projCoord.zw)); |
|
||||||
shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk8 * texelSize, projCoord.zw)); |
|
||||||
shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk9 * texelSize, projCoord.zw)); |
|
||||||
shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk10 * texelSize, projCoord.zw)); |
|
||||||
shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk11 * texelSize, projCoord.zw)); |
|
||||||
|
|
||||||
//this is divided by 12 |
|
||||||
return shadow * 0.08333333333; |
|
||||||
} |
|
||||||
|
|
||||||
#ifdef POINTLIGHT |
|
||||||
float getPointLightShadows(in vec4 worldPos,in vec3 lightPos, |
|
||||||
in SHADOWMAP shadowMap0,in SHADOWMAP shadowMap1,in SHADOWMAP shadowMap2,in SHADOWMAP shadowMap3,in SHADOWMAP shadowMap4,in SHADOWMAP shadowMap5, |
|
||||||
in vec4 projCoord0,in vec4 projCoord1,in vec4 projCoord2,in vec4 projCoord3,in vec4 projCoord4,in vec4 projCoord5){ |
|
||||||
float shadow = 1.0; |
|
||||||
vec3 vect = worldPos.xyz - lightPos; |
|
||||||
vec3 absv= abs(vect); |
|
||||||
float maxComp = max(absv.x,max(absv.y,absv.z)); |
|
||||||
if(maxComp == absv.y){ |
|
||||||
if(vect.y < 0.0){ |
|
||||||
shadow = GETSHADOW(shadowMap0, projCoord0 / projCoord0.w); |
|
||||||
}else{ |
|
||||||
shadow = GETSHADOW(shadowMap1, projCoord1 / projCoord1.w); |
|
||||||
} |
|
||||||
}else if(maxComp == absv.z){ |
|
||||||
if(vect.z < 0.0){ |
|
||||||
shadow = GETSHADOW(shadowMap2, projCoord2 / projCoord2.w); |
|
||||||
}else{ |
|
||||||
shadow = GETSHADOW(shadowMap3, projCoord3 / projCoord3.w); |
|
||||||
} |
|
||||||
}else if(maxComp == absv.x){ |
|
||||||
if(vect.x < 0.0){ |
|
||||||
shadow = GETSHADOW(shadowMap4, projCoord4 / projCoord4.w); |
|
||||||
}else{ |
|
||||||
shadow = GETSHADOW(shadowMap5, projCoord5 / projCoord5.w); |
|
||||||
} |
|
||||||
} |
|
||||||
return shadow; |
|
||||||
} |
|
||||||
#else |
|
||||||
#ifdef PSSM |
|
||||||
float getDirectionalLightShadows(in vec4 splits,in float shadowPosition, |
|
||||||
in SHADOWMAP shadowMap0,in SHADOWMAP shadowMap1,in SHADOWMAP shadowMap2,in SHADOWMAP shadowMap3, |
|
||||||
in vec4 projCoord0,in vec4 projCoord1,in vec4 projCoord2,in vec4 projCoord3){ |
|
||||||
float shadow = 1.0; |
|
||||||
if(shadowPosition < splits.x){ |
|
||||||
shadow = GETSHADOW(shadowMap0, projCoord0 ); |
|
||||||
}else if( shadowPosition < splits.y){ |
|
||||||
shadowBorderScale = 0.5; |
|
||||||
shadow = GETSHADOW(shadowMap1, projCoord1); |
|
||||||
}else if( shadowPosition < splits.z){ |
|
||||||
shadowBorderScale = 0.25; |
|
||||||
shadow = GETSHADOW(shadowMap2, projCoord2); |
|
||||||
}else if( shadowPosition < splits.w){ |
|
||||||
shadowBorderScale = 0.125; |
|
||||||
shadow = GETSHADOW(shadowMap3, projCoord3); |
|
||||||
} |
|
||||||
return shadow; |
|
||||||
} |
|
||||||
#else |
|
||||||
float getSpotLightShadows(in SHADOWMAP shadowMap,in vec4 projCoord){ |
|
||||||
float shadow = 1.0; |
|
||||||
projCoord /= projCoord.w; |
|
||||||
shadow = GETSHADOW(shadowMap,projCoord); |
|
||||||
|
|
||||||
//a small falloff to make the shadow blend nicely into the not lighten |
|
||||||
//we translate the texture coordinate value to a -1,1 range so the length |
|
||||||
//of the texture coordinate vector is actually the radius of the lighten area on the ground |
|
||||||
projCoord = projCoord * 2.0 - 1.0; |
|
||||||
float fallOff = ( length(projCoord.xy) - 0.9 ) / 0.1; |
|
||||||
return mix(shadow,1.0,clamp(fallOff,0.0,1.0)); |
|
||||||
|
|
||||||
} |
|
||||||
#endif |
|
||||||
#endif |
|
||||||
@ -0,0 +1 @@ |
|||||||
|
version.properties |
||||||
@ -1,11 +0,0 @@ |
|||||||
# THIS IS AN AUTO-GENERATED FILE.. |
|
||||||
# DO NOT MODIFY! |
|
||||||
build.date=1900-01-01 |
|
||||||
git.revision=0 |
|
||||||
git.branch=unknown |
|
||||||
git.hash= |
|
||||||
git.hash.short= |
|
||||||
git.tag= |
|
||||||
name.full=jMonkeyEngine 3.1.0-UNKNOWN |
|
||||||
version.number=3.1.0 |
|
||||||
version.tag=SNAPSHOT |
|
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue