import com.jme3.math.Vector3f;
import com.jme3.asset.AssetLoader;
import com.jme3.asset.AssetManager;
+import com.jme3.asset.MaterialKey;
import com.jme3.asset.TextureKey;
import com.jme3.material.RenderState.BlendMode;
import com.jme3.material.RenderState.FaceCullMode;
private AssetManager owner;
private Scanner scan;
- private String fileName;
+ private AssetKey key;
private MaterialDef materialDef;
private Material material;
throw new IOException("Extended material "+extendedMat+" cannot be found.");
material = new Material(def);
- material.setAssetName(fileName);
+ material.setKey(key);
+// material.setAssetName(fileName);
}else if (scan.hasNext("\\{")){
if (extending){
throw new IOException("Expected ':', got '{'");
}
materialDef = new MaterialDef(owner, name);
// NOTE: pass file name for defs so they can be loaded later
- materialDef.setAssetName(fileName);
+ materialDef.setAssetName(key.getName());
}
scan.next(); // skip {
try {
scan = new Scanner(in);
scan.useLocale(Locale.US);
- this.fileName = info.getKey().getName();
+ key = info.getKey();
loadFromScanner();
} finally {
if (in != null)
}
if (material != null){
+ if (!(info.getKey() instanceof MaterialKey)){
+ throw new IOException("Material instances must be loaded via MaterialKey");
+ }
// material implementation
return material;
}else{
--- /dev/null
+package com.jme3.asset;
+
+import com.jme3.material.Material;
+
+/**
+ * Used for loading {@link Material materials} only (not material definitions).
+ *
+ * @author Kirill Vainer
+ */
+public class MaterialKey extends AssetKey {
+ public MaterialKey(String name){
+ super(name);
+ }
+
+ public MaterialKey(){
+ super();
+ }
+
+ @Override
+ public boolean useSmartCache(){
+ return true;
+ }
+
+ @Override
+ public Object createClonedInstance(Object asset){
+ Material mat = (Material) asset;
+ return mat.clone();
+ }
+}
* @param name The filename of the audio file
* @param stream If true, the audio will be streamed gradually from disk,
* otherwise, it will be buffered.
- *
- * @deprecated AudioRenderer parameter is ignored.
*/
public AudioNode(AssetManager assetManager, String name, boolean stream) {
this(assetManager, name, stream, false);
* @param audioRenderer The audio renderer to use for playing. Cannot be null.
* @param assetManager The asset manager to use to load the audio file
* @param name The filename of the audio file
+ *
+ * @deprecated AudioRenderer parameter is ignored.
*/
public AudioNode(AudioRenderer audioRenderer, AssetManager assetManager, String name) {
this(assetManager, name, false);
BufferUtils.setInBuffer(tempC, points, j + ap);\r
BufferUtils.setInBuffer(tempB, points, j - 1 + ap);\r
}\r
- vars.release();\r
recurseMini(points, i, b + 1, ap + 1);\r
\r
}\r
private static final EmitterShape DEFAULT_SHAPE = new EmitterPointShape(Vector3f.ZERO);
private static final ParticleInfluencer DEFAULT_INFLUENCER = new DefaultParticleInfluencer();
- private ParticleEmitterControl control = new ParticleEmitterControl(this);
+
+ private ParticleEmitterControl control;
private EmitterShape shape = DEFAULT_SHAPE;
private ParticleMesh particleMesh;
private ParticleInfluencer particleInfluencer = DEFAULT_INFLUENCER;
//variable that helps with computations
private transient Vector3f temp = new Vector3f();
- private static class ParticleEmitterControl implements Control {
+ public static class ParticleEmitterControl implements Control {
- private ParticleEmitter parentEmitter;
+ ParticleEmitter parentEmitter;
+
+ public ParticleEmitterControl(){
+ }
public ParticleEmitterControl(ParticleEmitter parentEmitter){
this.parentEmitter = parentEmitter;
return this; // WARNING: Sets wrong control on spatial. Will be
// fixed automatically by ParticleEmitter.clone() method.
}
-
+
public void setSpatial(Spatial spatial) {
}
}
public void write(JmeExporter ex) throws IOException {
- // the data is not written here
}
public void read(JmeImporter im) throws IOException {
- // the data is not written here
}
}
shape = shape.deepClone();
particleInfluencer = particleInfluencer.clone();
+ control = new ParticleEmitterControl(this);
controls.add(control);
switch (meshType) {
throw new IllegalStateException("Unrecognized particle type: " + meshType);
}
particleMesh.initParticleData(this, particles.length);
+ particleMesh.setImagesXY(imagesX, imagesY);
particleInfluencer = (ParticleInfluencer) ic.readSavable("influencer", DEFAULT_INFLUENCER);
if (particleInfluencer == DEFAULT_INFLUENCER){
particleInfluencer = particleInfluencer.clone();
}
-
+
if (im.getFormatVersion() == 0){
// compatibility before the control inside particle emitter
// was changed:
if (obj instanceof ParticleEmitter){
controls.remove(i);
// now add the proper one in
- controls.add(control);
+ controls.add(new ParticleEmitterControl(this));
break;
}
}
gravity = new Vector3f();
gravity.y = ic.readFloat("gravity", 0);
}
+ }else{
+ // since the parentEmitter is not loaded, it must be
+ // loaded separately
+ control = getControl(ParticleEmitterControl.class);
+ control.parentEmitter = this;
}
}
}
*/
package com.jme3.material;
+import com.jme3.asset.Asset;
import com.jme3.asset.AssetKey;
import com.jme3.math.ColorRGBA;
import com.jme3.math.Matrix4f;
/**
* <code>Material</code> describes the rendering style for a given
- * {
- * <p/>
- * @link Geometry}.
- * <p/>
+ * {@link Geometry}.
* <p>A material is essentially a list of {
* @link MatParam parameters}, those parameters map to uniforms which are
* defined in a shader. Setting the parameters can modify the behavior of a
* <p/>
* @author Kirill Vainer
*/
-public class Material implements Cloneable, Savable, Comparable<Material> {
+public class Material implements Asset, Cloneable, Savable, Comparable<Material> {
private static final Logger logger = Logger.getLogger(Material.class.getName());
private static final RenderState additiveLight = new RenderState();
additiveLight.setBlendMode(RenderState.BlendMode.AlphaAdditive);
additiveLight.setDepthWrite(false);
}
- private String assetName;
+
+ private AssetKey key;
private MaterialDef def;
private ListMap<String, MatParam> paramValues = new ListMap<String, MatParam>();
private Technique technique;
* @return Asset key name of the j3m file
*/
public String getAssetName() {
- return assetName;
+ return key != null ? key.getName() : null;
}
- /**
- * Set the asset key name. This is used internally by the j3m material loader.
- *
- * @param assetName the asset key name
- */
- public void setAssetName(String assetName) {
- this.assetName = assetName;
+ public void setKey(AssetKey key){
+ this.key = key;
}
-
+
+ public AssetKey getKey(){
+ return key;
+ }
+
/**
* Returns the sorting ID or sorting index for this material.
*
}\r
\r
public Material loadMaterial(String name){\r
- return (Material) loadAsset(new AssetKey(name));\r
+ return (Material) loadAsset(new MaterialKey(name));\r
}\r
\r
/**\r
import com.jme3.math.Vector3f;\r
import com.jme3.util.BufferUtils;\r
import java.nio.ByteBuffer;\r
-import java.nio.ByteOrder;\r
import java.nio.FloatBuffer;\r
import java.nio.IntBuffer;\r
import java.util.ArrayList;\r
return;\r
}\r
\r
+ // stop any playing channels\r
+ for (int i = 0; i < chanSrcs.length; i++){\r
+ if (chanSrcs[i] != null){\r
+ clearChannel(i);\r
+ }\r
+ }\r
+ \r
// delete channel-based sources\r
ib.clear();\r
ib.put(channels);\r
EFX10.alDeleteAuxiliaryEffectSlots(ib);\r
}\r
\r
- // XXX: Delete other buffers/sources\r
+ // TODO: Cleanup buffers allocated for audio buffers and streams\r
+ \r
AL.destroy();\r
}\r
\r
freeChannel(chan);\r
\r
if (src.getAudioData() instanceof AudioStream) {\r
- \r
AudioStream stream = (AudioStream)src.getAudioData();\r
if (stream.isOpen()) {\r
stream.close();\r
}
if (mat == null) {
logger.log(Level.WARNING, "Material {0} not found. Applying default material", matName);
- mat = (Material) assetManager.loadAsset(new AssetKey("Common/Materials/RedColor.j3m"));
+ mat = (Material) assetManager.loadMaterial("Common/Materials/RedColor.j3m");
}
}
Thread.sleep(3000);
System.out.println("Destroying offscreen buffer");
app.stop();
-
- System.out.println("Creating JOGL application..");
- settings = new AppSettings(true);
- settings.setRenderer(AppSettings.JOGL);
- app = new Application();
- app.setSettings(settings);
- app.start();
- Thread.sleep(5000);
- app.stop();
}
}
import com.jme3.audio.AudioRenderer;
import com.jme3.asset.AssetManager;
import com.jme3.asset.DesktopAssetManager;
+import com.jme3.audio.AudioContext;
import com.jme3.audio.Listener;
import com.jme3.system.AppSettings;
import com.jme3.system.JmeSystem;
}
public void initAudioApp(){
+ AudioContext.setAudioRenderer(audioRenderer);
}
public void updateAudioApp(float tpf){
@Override
public void initAudioApp(){
- waves = new AudioNode(audioRenderer, assetManager, "Sound/Environment/Ocean Waves.ogg", false);
+ waves = new AudioNode(assetManager, "Sound/Environment/Ocean Waves.ogg", false);
waves.setPositional(true);
- nature = new AudioNode(audioRenderer, assetManager, "Sound/Environment/Nature.ogg", true);
+ nature = new AudioNode(assetManager, "Sound/Environment/Nature.ogg", true);
// river = new AudioSource(manager, "sounds/river.ogg");
// float[] eax = new float[]
@Override
public void initAudioApp(){
- assetManager.registerLocator("C:\\", FileLocator.class);
-
Quaternion q = new Quaternion();
q.lookAt(new Vector3f(0, 0, -1f), Vector3f.UNIT_Y);
listener.setRotation(q);
audioRenderer.setEnvironment(Environment.Dungeon);
AL10.alDistanceModel(AL11.AL_EXPONENT_DISTANCE);
- ufo = new AudioNode(audioRenderer, assetManager, "test.ogg", false);
+ ufo = new AudioNode(assetManager, "Sound/Effects/Beep.ogg", false);
ufo.setPositional(true);
ufo.setLooping(true);
ufo.setReverbEnabled(true);
@Override
public void initAudioApp(){
assetManager.registerLocator("http://www.vorbis.com/music/", UrlLocator.class);
- AudioNode src = new AudioNode(audioRenderer, assetManager, "Lumme-Badloop.ogg", true);
+ AudioNode src = new AudioNode(assetManager, "Lumme-Badloop.ogg", true);
audioRenderer.playSource(src);
}
}
\ No newline at end of file
rock.setWrap(WrapMode.Repeat);
matRock.setTexture("DiffuseMap_2", rock);
matRock.setFloat("DiffuseMap_2_scale", 128);
- Texture normalMap0 = assetManager.loadTexture("Textures/Terrain/splat/grass_normal.png");
+ Texture normalMap0 = assetManager.loadTexture("Textures/Terrain/splat/grass_normal.jpg");
normalMap0.setWrap(WrapMode.Repeat);
Texture normalMap1 = assetManager.loadTexture("Textures/Terrain/splat/dirt_normal.png");
normalMap1.setWrap(WrapMode.Repeat);
// flyCam.setEnabled(false);
// load material
- Material mat = (Material) assetManager.loadAsset(new AssetKey("Interface/Logo/Logo.j3m"));
+ Material mat = (Material) assetManager.loadMaterial("Interface/Logo/Logo.j3m");
Mesh q = new Mesh();
q.setBuffer(Type.Position, 3, new float[]
}
public void setupFloor(){
- Material mat = assetManager.loadMaterial("Textures/Terrain/Cobblestone/Cobblestone.j3m");
+ Material mat = assetManager.loadMaterial("Textures/Terrain/BrickWall/BrickWall.j3m");
mat.getTextureParam("DiffuseMap").getTextureValue().setWrap(WrapMode.Repeat);
mat.getTextureParam("NormalMap").getTextureValue().setWrap(WrapMode.Repeat);
mat.getTextureParam("ParallaxMap").getTextureValue().setWrap(WrapMode.Repeat);
import com.jme3.effect.ParticleEmitter;
import com.jme3.effect.ParticleMesh.Type;
import com.jme3.effect.shapes.EmitterSphereShape;
+import com.jme3.export.binary.BinaryExporter;
+import com.jme3.export.binary.BinaryImporter;
import com.jme3.material.Material;
import com.jme3.math.Vector3f;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
-public class TestParticleEmitter extends SimpleApplication {
+public class TestParticleExportingCloning extends SimpleApplication {
public static void main(String[] args){
- TestParticleEmitter app = new TestParticleEmitter();
+ TestParticleExportingCloning app = new TestParticleExportingCloning();
app.start();
}
mat.setTexture("Texture", assetManager.loadTexture("Effects/Smoke/Smoke.png"));
emit.setMaterial(mat);
+ ParticleEmitter emit2 = emit.clone();
+ emit2.move(3, 0, 0);
+
rootNode.attachChild(emit);
+ rootNode.attachChild(emit2);
+
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+ try {
+ BinaryExporter.getInstance().save(emit, out);
+
+ BinaryImporter imp = new BinaryImporter();
+ imp.setAssetManager(assetManager);
+ ParticleEmitter emit3 = (ParticleEmitter) imp.load(out.toByteArray());
+
+ emit3.move(-3, 0, 0);
+ rootNode.attachChild(emit3);
+ } catch (IOException ex) {
+ ex.printStackTrace();
+ }
-// Camera cam2 = cam.clone();
-// cam.setViewPortTop(0.5f);
-// cam2.setViewPortBottom(0.5f);
-// ViewPort vp = renderManager.createMainView("SecondView", cam2);
-// viewPort.setClearEnabled(false);
-// vp.attachScene(rootNode);
-
+ // Camera cam2 = cam.clone();
+ // cam.setViewPortTop(0.5f);
+ // cam2.setViewPortBottom(0.5f);
+ // ViewPort vp = renderManager.createMainView("SecondView", cam2);
+ // viewPort.setClearEnabled(false);
+ // vp.attachScene(rootNode);
}
}