mirror of
https://github.com/curioustorvald/Terrarum.git
synced 2026-03-08 12:51:51 +09:00
059abff814
Former-commit-id: 1647fa32ef6894bd7db44f741f07c2f4dcdf9054 Former-commit-id: 0e5810dcfbe1fd59b13e7cabe9f1e93c5542da2d
818 lines
26 KiB
Java
818 lines
26 KiB
Java
package org.newdawn.slick.particles;
|
|
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStream;
|
|
import java.io.OutputStreamWriter;
|
|
import java.util.ArrayList;
|
|
|
|
import javax.xml.parsers.DocumentBuilder;
|
|
import javax.xml.parsers.DocumentBuilderFactory;
|
|
import javax.xml.transform.OutputKeys;
|
|
import javax.xml.transform.Result;
|
|
import javax.xml.transform.Transformer;
|
|
import javax.xml.transform.TransformerFactory;
|
|
import javax.xml.transform.dom.DOMSource;
|
|
import javax.xml.transform.stream.StreamResult;
|
|
|
|
import org.newdawn.slick.Color;
|
|
import org.newdawn.slick.geom.Vector2f;
|
|
import org.newdawn.slick.particles.ConfigurableEmitter.ColorRecord;
|
|
import org.newdawn.slick.particles.ConfigurableEmitter.LinearInterpolator;
|
|
import org.newdawn.slick.particles.ConfigurableEmitter.RandomValue;
|
|
import org.newdawn.slick.particles.ConfigurableEmitter.SimpleValue;
|
|
import org.newdawn.slick.util.Log;
|
|
import org.newdawn.slick.util.ResourceLoader;
|
|
import org.w3c.dom.Document;
|
|
import org.w3c.dom.Element;
|
|
import org.w3c.dom.NodeList;
|
|
|
|
/**
|
|
* Utility methods to (de)serialize ConfigureEmitters to and from XML
|
|
*
|
|
* @author kevin
|
|
*/
|
|
public class ParticleIO {
|
|
|
|
/**
|
|
* Load a set of configured emitters into a single system
|
|
*
|
|
* @param ref
|
|
* The reference to the XML file (file or classpath)
|
|
* @param mask
|
|
* @return A configured particle system
|
|
* @throws IOException
|
|
* Indicates a failure to find, read or parse the XML file
|
|
*/
|
|
public static ParticleSystem loadConfiguredSystem(String ref, Color mask)
|
|
throws IOException {
|
|
return loadConfiguredSystem(ResourceLoader.getResourceAsStream(ref),
|
|
null, null, mask);
|
|
}
|
|
|
|
/**
|
|
* Load a set of configured emitters into a single system
|
|
*
|
|
* @param ref
|
|
* The reference to the XML file (file or classpath)
|
|
* @return A configured particle system
|
|
* @throws IOException
|
|
* Indicates a failure to find, read or parse the XML file
|
|
*/
|
|
public static ParticleSystem loadConfiguredSystem(String ref)
|
|
throws IOException {
|
|
return loadConfiguredSystem(ResourceLoader.getResourceAsStream(ref),
|
|
null, null, null);
|
|
}
|
|
|
|
/**
|
|
* Load a set of configured emitters into a single system
|
|
*
|
|
* @param ref
|
|
* The XML file to read
|
|
* @return A configured particle system
|
|
* @throws IOException
|
|
* Indicates a failure to find, read or parse the XML file
|
|
*/
|
|
public static ParticleSystem loadConfiguredSystem(File ref)
|
|
throws IOException {
|
|
return loadConfiguredSystem(new FileInputStream(ref), null, null, null);
|
|
}
|
|
|
|
/**
|
|
* Load a set of configured emitters into a single system
|
|
*
|
|
* @param ref
|
|
* The stream to read the XML from
|
|
* @param mask The mask used to make the particle image transparent
|
|
* @return A configured particle system
|
|
* @throws IOException
|
|
* Indicates a failure to find, read or parse the XML file
|
|
*/
|
|
public static ParticleSystem loadConfiguredSystem(InputStream ref, Color mask)
|
|
throws IOException {
|
|
return loadConfiguredSystem(ref, null, null, mask);
|
|
}
|
|
|
|
/**
|
|
* Load a set of configured emitters into a single system
|
|
*
|
|
* @param ref
|
|
* The stream to read the XML from
|
|
* @return A configured particle system
|
|
* @throws IOException
|
|
* Indicates a failure to find, read or parse the XML file
|
|
*/
|
|
public static ParticleSystem loadConfiguredSystem(InputStream ref)
|
|
throws IOException {
|
|
return loadConfiguredSystem(ref, null, null, null);
|
|
}
|
|
|
|
/**
|
|
* Load a set of configured emitters into a single system
|
|
*
|
|
* @param ref
|
|
* The reference to the XML file (file or classpath)
|
|
* @return A configured particle system
|
|
* @param factory
|
|
* The factory used to create the emitter than will be poulated
|
|
* with loaded data.
|
|
* @throws IOException
|
|
* Indicates a failure to find, read or parse the XML file
|
|
*/
|
|
public static ParticleSystem loadConfiguredSystem(String ref,
|
|
ConfigurableEmitterFactory factory) throws IOException {
|
|
return loadConfiguredSystem(ResourceLoader.getResourceAsStream(ref),
|
|
factory, null, null);
|
|
}
|
|
|
|
/**
|
|
* Load a set of configured emitters into a single system
|
|
*
|
|
* @param ref
|
|
* The XML file to read
|
|
* @return A configured particle system
|
|
* @param factory
|
|
* The factory used to create the emitter than will be poulated
|
|
* with loaded data.
|
|
* @throws IOException
|
|
* Indicates a failure to find, read or parse the XML file
|
|
*/
|
|
public static ParticleSystem loadConfiguredSystem(File ref,
|
|
ConfigurableEmitterFactory factory) throws IOException {
|
|
return loadConfiguredSystem(new FileInputStream(ref), factory, null, null);
|
|
}
|
|
|
|
/**
|
|
* Load a set of configured emitters into a single system
|
|
*
|
|
* @param ref
|
|
* The stream to read the XML from
|
|
* @return A configured particle system
|
|
* @param factory
|
|
* The factory used to create the emitter than will be poulated
|
|
* with loaded data.
|
|
* @throws IOException
|
|
* Indicates a failure to find, read or parse the XML file
|
|
*/
|
|
public static ParticleSystem loadConfiguredSystem(InputStream ref,
|
|
ConfigurableEmitterFactory factory) throws IOException {
|
|
return loadConfiguredSystem(ref, factory, null, null);
|
|
}
|
|
|
|
/**
|
|
* Load a set of configured emitters into a single system
|
|
*
|
|
* @param ref
|
|
* The stream to read the XML from
|
|
* @param factory
|
|
* The factory used to create the emitter than will be poulated
|
|
* with loaded data.
|
|
* @param system The particle system that will be loaded into
|
|
* @param mask The mask used to make the image background transparent
|
|
* @return A configured particle system
|
|
* @throws IOException
|
|
* Indicates a failure to find, read or parse the XML file
|
|
*/
|
|
public static ParticleSystem loadConfiguredSystem(InputStream ref,
|
|
ConfigurableEmitterFactory factory, ParticleSystem system, Color mask) throws IOException {
|
|
if (factory == null) {
|
|
factory = new ConfigurableEmitterFactory() {
|
|
public ConfigurableEmitter createEmitter(String name) {
|
|
return new ConfigurableEmitter(name);
|
|
}
|
|
};
|
|
}
|
|
try {
|
|
DocumentBuilder builder = DocumentBuilderFactory.newInstance()
|
|
.newDocumentBuilder();
|
|
Document document = builder.parse(ref);
|
|
|
|
Element element = document.getDocumentElement();
|
|
if (!element.getNodeName().equals("system")) {
|
|
throw new IOException("Not a particle system file");
|
|
}
|
|
|
|
if (system == null) {
|
|
system = new ParticleSystem("org/newdawn/slick/data/particle.tga",
|
|
2000, mask);
|
|
}
|
|
boolean additive = "true".equals(element.getAttribute("additive"));
|
|
if (additive) {
|
|
system.setBlendingMode(ParticleSystem.BLEND_ADDITIVE);
|
|
} else {
|
|
system.setBlendingMode(ParticleSystem.BLEND_COMBINE);
|
|
}
|
|
boolean points = "true".equals(element.getAttribute("points"));
|
|
system.setUsePoints(points);
|
|
|
|
NodeList list = element.getElementsByTagName("emitter");
|
|
for (int i = 0; i < list.getLength(); i++) {
|
|
Element em = (Element) list.item(i);
|
|
ConfigurableEmitter emitter = factory.createEmitter("new");
|
|
elementToEmitter(em, emitter);
|
|
|
|
system.addEmitter(emitter);
|
|
}
|
|
|
|
system.setRemoveCompletedEmitters(false);
|
|
return system;
|
|
} catch (IOException e) {
|
|
Log.error(e);
|
|
throw e;
|
|
} catch (Exception e) {
|
|
Log.error(e);
|
|
throw new IOException("Unable to load particle system config");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Save a particle system with only ConfigurableEmitters in to an XML file
|
|
*
|
|
* @param file
|
|
* The file to save to
|
|
* @param system
|
|
* The system to store
|
|
* @throws IOException
|
|
* Indicates a failure to save or encode the system XML.
|
|
*/
|
|
public static void saveConfiguredSystem(File file, ParticleSystem system)
|
|
throws IOException {
|
|
saveConfiguredSystem(new FileOutputStream(file), system);
|
|
}
|
|
|
|
/**
|
|
* Save a particle system with only ConfigurableEmitters in to an XML file
|
|
*
|
|
* @param out
|
|
* The location to which we'll save
|
|
* @param system
|
|
* The system to store
|
|
* @throws IOException
|
|
* Indicates a failure to save or encode the system XML.
|
|
*/
|
|
public static void saveConfiguredSystem(OutputStream out,
|
|
ParticleSystem system) throws IOException {
|
|
try {
|
|
DocumentBuilder builder = DocumentBuilderFactory.newInstance()
|
|
.newDocumentBuilder();
|
|
Document document = builder.newDocument();
|
|
|
|
Element root = document.createElement("system");
|
|
root
|
|
.setAttribute(
|
|
"additive",
|
|
""
|
|
+ (system.getBlendingMode() == ParticleSystem.BLEND_ADDITIVE));
|
|
root.setAttribute("points", "" + (system.usePoints()));
|
|
|
|
document.appendChild(root);
|
|
for (int i = 0; i < system.getEmitterCount(); i++) {
|
|
ParticleEmitter current = system.getEmitter(i);
|
|
if (current instanceof ConfigurableEmitter) {
|
|
Element element = emitterToElement(document,
|
|
(ConfigurableEmitter) current);
|
|
root.appendChild(element);
|
|
} else {
|
|
throw new RuntimeException(
|
|
"Only ConfigurableEmitter instances can be stored");
|
|
}
|
|
}
|
|
|
|
Result result = new StreamResult(new OutputStreamWriter(out,
|
|
"utf-8"));
|
|
DOMSource source = new DOMSource(document);
|
|
|
|
TransformerFactory factory = TransformerFactory.newInstance();
|
|
Transformer xformer = factory.newTransformer();
|
|
xformer.setOutputProperty(OutputKeys.INDENT, "yes");
|
|
|
|
xformer.transform(source, result);
|
|
} catch (Exception e) {
|
|
Log.error(e);
|
|
throw new IOException("Unable to save configured particle system");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load a single emitter from an XML file
|
|
*
|
|
* @param ref
|
|
* The reference to the emitter XML file to load (classpath or
|
|
* file)
|
|
* @return The configured emitter
|
|
* @throws IOException
|
|
* Indicates a failure to find, read or parse the XML file
|
|
*/
|
|
public static ConfigurableEmitter loadEmitter(String ref)
|
|
throws IOException {
|
|
return loadEmitter(ResourceLoader.getResourceAsStream(ref), null);
|
|
}
|
|
|
|
/**
|
|
* Load a single emitter from an XML file
|
|
*
|
|
* @param ref
|
|
* The XML file to read
|
|
* @return The configured emitter
|
|
* @throws IOException
|
|
* Indicates a failure to find, read or parse the XML file
|
|
*/
|
|
public static ConfigurableEmitter loadEmitter(File ref) throws IOException {
|
|
return loadEmitter(new FileInputStream(ref), null);
|
|
|
|
}
|
|
|
|
/**
|
|
* Load a single emitter from an XML file
|
|
*
|
|
* @param ref
|
|
* The stream to read the XML from
|
|
* @return The configured emitter
|
|
* @throws IOException
|
|
* Indicates a failure to find, read or parse the XML file
|
|
*/
|
|
public static ConfigurableEmitter loadEmitter(InputStream ref)
|
|
throws IOException {
|
|
return loadEmitter(ref, null);
|
|
}
|
|
|
|
/**
|
|
* Load a single emitter from an XML file
|
|
*
|
|
* @param ref
|
|
* The reference to the emitter XML file to load (classpath or
|
|
* file)
|
|
* @return The configured emitter
|
|
* @param factory
|
|
* The factory used to create the emitter than will be poulated
|
|
* with loaded data.
|
|
* @throws IOException
|
|
* Indicates a failure to find, read or parse the XML file
|
|
*/
|
|
public static ConfigurableEmitter loadEmitter(String ref,
|
|
ConfigurableEmitterFactory factory) throws IOException {
|
|
return loadEmitter(ResourceLoader.getResourceAsStream(ref), factory);
|
|
}
|
|
|
|
/**
|
|
* Load a single emitter from an XML file
|
|
*
|
|
* @param ref
|
|
* The XML file to read
|
|
* @return The configured emitter
|
|
* @param factory
|
|
* The factory used to create the emitter than will be poulated
|
|
* with loaded data.
|
|
* @throws IOException
|
|
* Indicates a failure to find, read or parse the XML file
|
|
*/
|
|
public static ConfigurableEmitter loadEmitter(File ref,
|
|
ConfigurableEmitterFactory factory) throws IOException {
|
|
return loadEmitter(new FileInputStream(ref), factory);
|
|
|
|
}
|
|
|
|
/**
|
|
* Load a single emitter from an XML file
|
|
*
|
|
* @param ref
|
|
* The stream to read the XML from
|
|
* @param factory
|
|
* The factory used to create the emitter than will be poulated
|
|
* with loaded data.
|
|
* @return The configured emitter
|
|
* @throws IOException
|
|
* Indicates a failure to find, read or parse the XML file
|
|
*/
|
|
public static ConfigurableEmitter loadEmitter(InputStream ref,
|
|
ConfigurableEmitterFactory factory) throws IOException {
|
|
if (factory == null) {
|
|
factory = new ConfigurableEmitterFactory() {
|
|
public ConfigurableEmitter createEmitter(String name) {
|
|
return new ConfigurableEmitter(name);
|
|
}
|
|
};
|
|
}
|
|
try {
|
|
DocumentBuilder builder = DocumentBuilderFactory.newInstance()
|
|
.newDocumentBuilder();
|
|
Document document = builder.parse(ref);
|
|
|
|
if (!document.getDocumentElement().getNodeName().equals("emitter")) {
|
|
throw new IOException("Not a particle emitter file");
|
|
}
|
|
|
|
ConfigurableEmitter emitter = factory.createEmitter("new");
|
|
elementToEmitter(document.getDocumentElement(), emitter);
|
|
|
|
return emitter;
|
|
} catch (IOException e) {
|
|
Log.error(e);
|
|
throw e;
|
|
} catch (Exception e) {
|
|
Log.error(e);
|
|
throw new IOException("Unable to load emitter");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Save a single emitter to the XML file
|
|
*
|
|
* @param file
|
|
* The file to save the emitter to
|
|
* @param emitter
|
|
* The emitter to store to the XML file
|
|
* @throws IOException
|
|
* Indicates a failure to write or encode the XML
|
|
*/
|
|
public static void saveEmitter(File file, ConfigurableEmitter emitter)
|
|
throws IOException {
|
|
saveEmitter(new FileOutputStream(file), emitter);
|
|
}
|
|
|
|
/**
|
|
* Save a single emitter to the XML file
|
|
*
|
|
* @param out
|
|
* The location to which we should save
|
|
* @param emitter
|
|
* The emitter to store to the XML file
|
|
* @throws IOException
|
|
* Indicates a failure to write or encode the XML
|
|
*/
|
|
public static void saveEmitter(OutputStream out, ConfigurableEmitter emitter)
|
|
throws IOException {
|
|
try {
|
|
DocumentBuilder builder = DocumentBuilderFactory.newInstance()
|
|
.newDocumentBuilder();
|
|
Document document = builder.newDocument();
|
|
|
|
document.appendChild(emitterToElement(document, emitter));
|
|
Result result = new StreamResult(new OutputStreamWriter(out,
|
|
"utf-8"));
|
|
DOMSource source = new DOMSource(document);
|
|
|
|
TransformerFactory factory = TransformerFactory.newInstance();
|
|
Transformer xformer = factory.newTransformer();
|
|
xformer.setOutputProperty(OutputKeys.INDENT, "yes");
|
|
|
|
xformer.transform(source, result);
|
|
} catch (Exception e) {
|
|
Log.error(e);
|
|
throw new IOException("Failed to save emitter");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the first child named as specified from the passed XML element
|
|
*
|
|
* @param element
|
|
* The element whose children are interogated
|
|
* @param name
|
|
* The name of the element to retrieve
|
|
* @return The requested element
|
|
*/
|
|
private static Element getFirstNamedElement(Element element, String name) {
|
|
NodeList list = element.getElementsByTagName(name);
|
|
if (list.getLength() == 0) {
|
|
return null;
|
|
}
|
|
|
|
return (Element) list.item(0);
|
|
}
|
|
|
|
/**
|
|
* Convert from an XML element to an configured emitter
|
|
*
|
|
* @param element
|
|
* The XML element to convert
|
|
* @param emitter
|
|
* The emitter that will be configured based on the XML
|
|
*/
|
|
private static void elementToEmitter(Element element,
|
|
ConfigurableEmitter emitter) {
|
|
emitter.name = element.getAttribute("name");
|
|
emitter.setImageName(element.getAttribute("imageName"));
|
|
|
|
String renderType = element.getAttribute("renderType");
|
|
emitter.usePoints = Particle.INHERIT_POINTS;
|
|
if (renderType.equals("quads")) {
|
|
emitter.usePoints = Particle.USE_QUADS;
|
|
}
|
|
if (renderType.equals("points")) {
|
|
emitter.usePoints = Particle.USE_POINTS;
|
|
}
|
|
|
|
String useOriented = element.getAttribute("useOriented");
|
|
if (useOriented != null)
|
|
emitter.useOriented = "true".equals(useOriented);
|
|
|
|
String useAdditive = element.getAttribute("useAdditive");
|
|
if (useAdditive != null)
|
|
emitter.useAdditive = "true".equals(useAdditive);
|
|
|
|
parseRangeElement(getFirstNamedElement(element, "spawnInterval"),
|
|
emitter.spawnInterval);
|
|
parseRangeElement(getFirstNamedElement(element, "spawnCount"),
|
|
emitter.spawnCount);
|
|
parseRangeElement(getFirstNamedElement(element, "initialLife"),
|
|
emitter.initialLife);
|
|
parseRangeElement(getFirstNamedElement(element, "initialSize"),
|
|
emitter.initialSize);
|
|
parseRangeElement(getFirstNamedElement(element, "xOffset"),
|
|
emitter.xOffset);
|
|
parseRangeElement(getFirstNamedElement(element, "yOffset"),
|
|
emitter.yOffset);
|
|
parseRangeElement(getFirstNamedElement(element, "initialDistance"),
|
|
emitter.initialDistance);
|
|
parseRangeElement(getFirstNamedElement(element, "speed"), emitter.speed);
|
|
parseRangeElement(getFirstNamedElement(element, "length"),
|
|
emitter.length);
|
|
parseRangeElement(getFirstNamedElement(element, "emitCount"),
|
|
emitter.emitCount);
|
|
|
|
parseValueElement(getFirstNamedElement(element, "spread"),
|
|
emitter.spread);
|
|
parseValueElement(getFirstNamedElement(element, "angularOffset"),
|
|
emitter.angularOffset);
|
|
parseValueElement(getFirstNamedElement(element, "growthFactor"),
|
|
emitter.growthFactor);
|
|
parseValueElement(getFirstNamedElement(element, "gravityFactor"),
|
|
emitter.gravityFactor);
|
|
parseValueElement(getFirstNamedElement(element, "windFactor"),
|
|
emitter.windFactor);
|
|
parseValueElement(getFirstNamedElement(element, "startAlpha"),
|
|
emitter.startAlpha);
|
|
parseValueElement(getFirstNamedElement(element, "endAlpha"),
|
|
emitter.endAlpha);
|
|
parseValueElement(getFirstNamedElement(element, "alpha"), emitter.alpha);
|
|
parseValueElement(getFirstNamedElement(element, "size"), emitter.size);
|
|
parseValueElement(getFirstNamedElement(element, "velocity"),
|
|
emitter.velocity);
|
|
parseValueElement(getFirstNamedElement(element, "scaleY"),
|
|
emitter.scaleY);
|
|
|
|
Element color = getFirstNamedElement(element, "color");
|
|
NodeList steps = color.getElementsByTagName("step");
|
|
emitter.colors.clear();
|
|
for (int i = 0; i < steps.getLength(); i++) {
|
|
Element step = (Element) steps.item(i);
|
|
float offset = Float.parseFloat(step.getAttribute("offset"));
|
|
float r = Float.parseFloat(step.getAttribute("r"));
|
|
float g = Float.parseFloat(step.getAttribute("g"));
|
|
float b = Float.parseFloat(step.getAttribute("b"));
|
|
|
|
emitter.addColorPoint(offset, new Color(r, g, b, 1));
|
|
}
|
|
|
|
// generate new random play length
|
|
emitter.replay();
|
|
}
|
|
|
|
/**
|
|
* Convert from an emitter to a XML element description
|
|
*
|
|
* @param document
|
|
* The document the element will be part of
|
|
* @param emitter
|
|
* The emitter to convert
|
|
* @return The XML element based on the configured emitter
|
|
*/
|
|
private static Element emitterToElement(Document document,
|
|
ConfigurableEmitter emitter) {
|
|
Element root = document.createElement("emitter");
|
|
root.setAttribute("name", emitter.name);
|
|
root.setAttribute("imageName", emitter.imageName == null ? ""
|
|
: emitter.imageName);
|
|
root
|
|
.setAttribute("useOriented", emitter.useOriented ? "true"
|
|
: "false");
|
|
root
|
|
.setAttribute("useAdditive", emitter.useAdditive ? "true"
|
|
: "false");
|
|
|
|
if (emitter.usePoints == Particle.INHERIT_POINTS) {
|
|
root.setAttribute("renderType", "inherit");
|
|
}
|
|
if (emitter.usePoints == Particle.USE_POINTS) {
|
|
root.setAttribute("renderType", "points");
|
|
}
|
|
if (emitter.usePoints == Particle.USE_QUADS) {
|
|
root.setAttribute("renderType", "quads");
|
|
}
|
|
|
|
root.appendChild(createRangeElement(document, "spawnInterval",
|
|
emitter.spawnInterval));
|
|
root.appendChild(createRangeElement(document, "spawnCount",
|
|
emitter.spawnCount));
|
|
root.appendChild(createRangeElement(document, "initialLife",
|
|
emitter.initialLife));
|
|
root.appendChild(createRangeElement(document, "initialSize",
|
|
emitter.initialSize));
|
|
root.appendChild(createRangeElement(document, "xOffset",
|
|
emitter.xOffset));
|
|
root.appendChild(createRangeElement(document, "yOffset",
|
|
emitter.yOffset));
|
|
root.appendChild(createRangeElement(document, "initialDistance",
|
|
emitter.initialDistance));
|
|
root.appendChild(createRangeElement(document, "speed", emitter.speed));
|
|
root
|
|
.appendChild(createRangeElement(document, "length",
|
|
emitter.length));
|
|
root.appendChild(createRangeElement(document, "emitCount",
|
|
emitter.emitCount));
|
|
|
|
root
|
|
.appendChild(createValueElement(document, "spread",
|
|
emitter.spread));
|
|
root.appendChild(createValueElement(document, "angularOffset",
|
|
emitter.angularOffset));
|
|
root.appendChild(createValueElement(document, "growthFactor",
|
|
emitter.growthFactor));
|
|
root.appendChild(createValueElement(document, "gravityFactor",
|
|
emitter.gravityFactor));
|
|
root.appendChild(createValueElement(document, "windFactor",
|
|
emitter.windFactor));
|
|
root.appendChild(createValueElement(document, "startAlpha",
|
|
emitter.startAlpha));
|
|
root.appendChild(createValueElement(document, "endAlpha",
|
|
emitter.endAlpha));
|
|
root.appendChild(createValueElement(document, "alpha", emitter.alpha));
|
|
root.appendChild(createValueElement(document, "size", emitter.size));
|
|
root.appendChild(createValueElement(document, "velocity",
|
|
emitter.velocity));
|
|
root
|
|
.appendChild(createValueElement(document, "scaleY",
|
|
emitter.scaleY));
|
|
|
|
Element color = document.createElement("color");
|
|
ArrayList list = emitter.colors;
|
|
for (int i = 0; i < list.size(); i++) {
|
|
ColorRecord record = (ColorRecord) list.get(i);
|
|
Element step = document.createElement("step");
|
|
step.setAttribute("offset", "" + record.pos);
|
|
step.setAttribute("r", "" + record.col.r);
|
|
step.setAttribute("g", "" + record.col.g);
|
|
step.setAttribute("b", "" + record.col.b);
|
|
|
|
color.appendChild(step);
|
|
}
|
|
|
|
root.appendChild(color);
|
|
|
|
return root;
|
|
}
|
|
|
|
/**
|
|
* Create an XML element based on a configured range
|
|
*
|
|
* @param document
|
|
* The document the element will be part of
|
|
* @param name
|
|
* The name to give the new element
|
|
* @param range
|
|
* The configured range
|
|
* @return A configured XML element on the range
|
|
*/
|
|
private static Element createRangeElement(Document document, String name,
|
|
ConfigurableEmitter.Range range) {
|
|
Element element = document.createElement(name);
|
|
element.setAttribute("min", "" + range.getMin());
|
|
element.setAttribute("max", "" + range.getMax());
|
|
element.setAttribute("enabled", "" + range.isEnabled());
|
|
|
|
return element;
|
|
}
|
|
|
|
/**
|
|
* Create an XML element based on a configured value
|
|
*
|
|
* @param document
|
|
* The document the element will be part of
|
|
* @param name
|
|
* The name to give the new element
|
|
* @param value
|
|
* The configured value
|
|
* @return A configure XML element based on the value
|
|
*/
|
|
private static Element createValueElement(Document document, String name,
|
|
ConfigurableEmitter.Value value) {
|
|
Element element = document.createElement(name);
|
|
|
|
// void: now writes the value type
|
|
if (value instanceof SimpleValue) {
|
|
element.setAttribute("type", "simple");
|
|
element.setAttribute("value", "" + value.getValue(0));
|
|
} else if (value instanceof RandomValue) {
|
|
element.setAttribute("type", "random");
|
|
element
|
|
.setAttribute("value", ""
|
|
+ ((RandomValue) value).getValue());
|
|
} else if (value instanceof LinearInterpolator) {
|
|
element.setAttribute("type", "linear");
|
|
element.setAttribute("min", ""
|
|
+ ((LinearInterpolator) value).getMin());
|
|
element.setAttribute("max", ""
|
|
+ ((LinearInterpolator) value).getMax());
|
|
element.setAttribute("active", ""
|
|
+ ((LinearInterpolator) value).isActive());
|
|
|
|
ArrayList curve = ((LinearInterpolator) value).getCurve();
|
|
for (int i = 0; i < curve.size(); i++) {
|
|
Vector2f point = (Vector2f) curve.get(i);
|
|
|
|
Element pointElement = document.createElement("point");
|
|
pointElement.setAttribute("x", "" + point.x);
|
|
pointElement.setAttribute("y", "" + point.y);
|
|
|
|
element.appendChild(pointElement);
|
|
}
|
|
} else {
|
|
Log.warn("unkown value type ignored: " + value.getClass());
|
|
}
|
|
|
|
return element;
|
|
}
|
|
|
|
/**
|
|
* Parse an XML element into a configured range
|
|
*
|
|
* @param element
|
|
* The XML element to parse
|
|
* @param range
|
|
* The range to configure based on the XML
|
|
*/
|
|
private static void parseRangeElement(Element element,
|
|
ConfigurableEmitter.Range range) {
|
|
if (element == null) {
|
|
return;
|
|
}
|
|
range.setMin(Float.parseFloat(element.getAttribute("min")));
|
|
range.setMax(Float.parseFloat(element.getAttribute("max")));
|
|
range.setEnabled("true".equals(element.getAttribute("enabled")));
|
|
}
|
|
|
|
/**
|
|
* Parse an XML element into a configured value
|
|
*
|
|
* @param element
|
|
* The XML element to parse
|
|
* @param value
|
|
* The value to configure based on the XML
|
|
*/
|
|
private static void parseValueElement(Element element,
|
|
ConfigurableEmitter.Value value) {
|
|
if (element == null) {
|
|
return;
|
|
}
|
|
|
|
String type = element.getAttribute("type");
|
|
String v = element.getAttribute("value");
|
|
|
|
if (type == null || type.length() == 0) {
|
|
// support for old style which did not write the type
|
|
if (value instanceof SimpleValue) {
|
|
((SimpleValue) value).setValue(Float.parseFloat(v));
|
|
} else if (value instanceof RandomValue) {
|
|
((RandomValue) value).setValue(Float.parseFloat(v));
|
|
} else {
|
|
Log.warn("problems reading element, skipping: " + element);
|
|
}
|
|
} else {
|
|
// type given: this is the new style
|
|
if (type.equals("simple")) {
|
|
((SimpleValue) value).setValue(Float.parseFloat(v));
|
|
} else if (type.equals("random")) {
|
|
((RandomValue) value).setValue(Float.parseFloat(v));
|
|
} else if (type.equals("linear")) {
|
|
String min = element.getAttribute("min");
|
|
String max = element.getAttribute("max");
|
|
String active = element.getAttribute("active");
|
|
|
|
NodeList points = element.getElementsByTagName("point");
|
|
|
|
ArrayList curve = new ArrayList();
|
|
for (int i = 0; i < points.getLength(); i++) {
|
|
Element point = (Element) points.item(i);
|
|
|
|
float x = Float.parseFloat(point.getAttribute("x"));
|
|
float y = Float.parseFloat(point.getAttribute("y"));
|
|
|
|
curve.add(new Vector2f(x, y));
|
|
}
|
|
|
|
((LinearInterpolator) value).setCurve(curve);
|
|
((LinearInterpolator) value).setMin(Integer.parseInt(min));
|
|
((LinearInterpolator) value).setMax(Integer.parseInt(max));
|
|
((LinearInterpolator) value).setActive("true".equals(active));
|
|
} else {
|
|
Log.warn("unkown type detected: " + type);
|
|
}
|
|
}
|
|
}
|
|
}
|