mirror of
https://github.com/curioustorvald/Terrarum.git
synced 2026-03-10 13:51:53 +09:00
added sources for Slick
Former-commit-id: 1647fa32ef6894bd7db44f741f07c2f4dcdf9054 Former-commit-id: 0e5810dcfbe1fd59b13e7cabe9f1e93c5542da2d
This commit is contained in:
Song Minjae
817
lib/slick-source/org/newdawn/slick/particles/ParticleIO.java
Normal file
817
lib/slick-source/org/newdawn/slick/particles/ParticleIO.java
Normal file
@@ -0,0 +1,817 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user