/*******************************************************************************
* Copyright 2011 See AUTHORS file.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.badlogic.gdx.tools.flame;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.EventQueue;
import java.awt.FileDialog;
import java.awt.Graphics;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;
import java.io.Writer;
import javax.swing.BorderFactory;
import javax.swing.DefaultComboBoxModel;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.UIManager;
import javax.swing.UIManager.LookAndFeelInfo;
import javax.swing.border.CompoundBorder;
import javax.swing.plaf.basic.BasicSplitPaneUI;
import com.badlogic.gdx.ApplicationListener;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.InputMultiplexer;
import com.badlogic.gdx.assets.AssetDescriptor;
import com.badlogic.gdx.assets.AssetErrorListener;
import com.badlogic.gdx.assets.AssetLoaderParameters;
import com.badlogic.gdx.assets.AssetManager;
import com.badlogic.gdx.assets.loaders.AssetLoader;
import com.badlogic.gdx.assets.loaders.resolvers.AbsoluteFileHandleResolver;
import com.badlogic.gdx.assets.loaders.resolvers.InternalFileHandleResolver;
import com.badlogic.gdx.backends.lwjgl.LwjglCanvas;
import com.badlogic.gdx.files.FileHandle;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.PerspectiveCamera;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.VertexAttributes.Usage;
import com.badlogic.gdx.graphics.g2d.TextureAtlas;
import com.badlogic.gdx.graphics.g3d.Environment;
import com.badlogic.gdx.graphics.g3d.Material;
import com.badlogic.gdx.graphics.g3d.Model;
import com.badlogic.gdx.graphics.g3d.ModelBatch;
import com.badlogic.gdx.graphics.g3d.ModelInstance;
import com.badlogic.gdx.graphics.g3d.attributes.BlendingAttribute;
import com.badlogic.gdx.graphics.g3d.attributes.ColorAttribute;
import com.badlogic.gdx.graphics.g3d.environment.DirectionalLight;
import com.badlogic.gdx.graphics.g3d.particles.ParticleController;
import com.badlogic.gdx.graphics.g3d.particles.ParticleEffect;
import com.badlogic.gdx.graphics.g3d.particles.ParticleEffectLoader;
import com.badlogic.gdx.graphics.g3d.particles.ParticleEffectLoader.ParticleEffectSaveParameter;
import com.badlogic.gdx.graphics.g3d.particles.ParticleSystem;
import com.badlogic.gdx.graphics.g3d.particles.batches.BillboardParticleBatch;
import com.badlogic.gdx.graphics.g3d.particles.batches.ModelInstanceParticleBatch;
import com.badlogic.gdx.graphics.g3d.particles.batches.ParticleBatch;
import com.badlogic.gdx.graphics.g3d.particles.batches.PointSpriteParticleBatch;
import com.badlogic.gdx.graphics.g3d.particles.emitters.Emitter;
import com.badlogic.gdx.graphics.g3d.particles.emitters.RegularEmitter;
import com.badlogic.gdx.graphics.g3d.particles.influencers.ColorInfluencer;
import com.badlogic.gdx.graphics.g3d.particles.influencers.DynamicsInfluencer;
import com.badlogic.gdx.graphics.g3d.particles.influencers.Influencer;
import com.badlogic.gdx.graphics.g3d.particles.influencers.ModelInfluencer;
import com.badlogic.gdx.graphics.g3d.particles.influencers.ParticleControllerFinalizerInfluencer;
import com.badlogic.gdx.graphics.g3d.particles.influencers.ParticleControllerInfluencer;
import com.badlogic.gdx.graphics.g3d.particles.influencers.RegionInfluencer;
import com.badlogic.gdx.graphics.g3d.particles.influencers.ScaleInfluencer;
import com.badlogic.gdx.graphics.g3d.particles.influencers.SpawnInfluencer;
import com.badlogic.gdx.graphics.g3d.particles.renderers.BillboardRenderer;
import com.badlogic.gdx.graphics.g3d.particles.renderers.ModelInstanceRenderer;
import com.badlogic.gdx.graphics.g3d.particles.renderers.ParticleControllerControllerRenderer;
import com.badlogic.gdx.graphics.g3d.particles.renderers.PointSpriteRenderer;
import com.badlogic.gdx.graphics.g3d.particles.values.GradientColorValue;
import com.badlogic.gdx.graphics.g3d.particles.values.NumericValue;
import com.badlogic.gdx.graphics.g3d.utils.CameraInputController;
import com.badlogic.gdx.graphics.g3d.utils.ModelBuilder;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.RandomXS128;
import com.badlogic.gdx.scenes.scene2d.InputEvent;
import com.badlogic.gdx.scenes.scene2d.Stage;
import com.badlogic.gdx.scenes.scene2d.ui.Label;
import com.badlogic.gdx.scenes.scene2d.ui.Skin;
import com.badlogic.gdx.scenes.scene2d.ui.Table;
import com.badlogic.gdx.scenes.scene2d.ui.TextButton;
import com.badlogic.gdx.scenes.scene2d.utils.ClickListener;
import com.badlogic.gdx.utils.Array;
import com.badlogic.gdx.utils.StreamUtils;
import com.badlogic.gdx.utils.StringBuilder;
/** @author Inferno */
public class FlameMain extends JFrame implements AssetErrorListener {
public static final String DEFAULT_FONT = "default.fnt",
DEFAULT_BILLBOARD_PARTICLE = "pre_particle.png",
DEFAULT_MODEL_PARTICLE = "monkey.g3db",
//DEFAULT_PFX = "default.pfx",
DEFAULT_TEMPLATE_PFX = "defaultTemplate.pfx",
DEFAULT_SKIN = "uiskin.json";
public static final int EVT_ASSET_RELOADED = 0;
static class ControllerData {
public boolean enabled = true;
public ParticleController controller;
public ControllerData (ParticleController emitter) {
controller = emitter;
}
}
private static class InfluencerWrapper<T>{
String string;
Class<Influencer> type;
public InfluencerWrapper(String string, Class<Influencer> type){
this.string = string;
this.type = type;
}
@Override
public String toString () {
return string;
}
}
public enum ControllerType{
Billboard( "Billboard", new InfluencerWrapper[]{
new InfluencerWrapper("Single Color", ColorInfluencer.Single.class),
new InfluencerWrapper("Random Color", ColorInfluencer.Random.class),
new InfluencerWrapper("Single Region", RegionInfluencer.Single.class),
new InfluencerWrapper("Random Region", RegionInfluencer.Random.class),
new InfluencerWrapper("Animated Region", RegionInfluencer.Animated.class),
new InfluencerWrapper("Scale", ScaleInfluencer.class),
new InfluencerWrapper("Spawn", SpawnInfluencer.class),
new InfluencerWrapper("Dynamics", DynamicsInfluencer.class)}),
PointSprite("Point Sprite", new InfluencerWrapper[]{
new InfluencerWrapper("Single Color", ColorInfluencer.Single.class),
new InfluencerWrapper("Random Color", ColorInfluencer.Random.class),
new InfluencerWrapper("Single Region", RegionInfluencer.Single.class),
new InfluencerWrapper("Random Region", RegionInfluencer.Random.class),
new InfluencerWrapper("Animated Region", RegionInfluencer.Animated.class),
new InfluencerWrapper("Scale", ScaleInfluencer.class),
new InfluencerWrapper("Spawn", SpawnInfluencer.class),
new InfluencerWrapper("Dynamics", DynamicsInfluencer.class)}),
ModelInstance( "Model Instance", new InfluencerWrapper[]{
new InfluencerWrapper("Single Color", ColorInfluencer.Single.class),
new InfluencerWrapper("Random Color", ColorInfluencer.Random.class),
new InfluencerWrapper("Single Model", ModelInfluencer.Single.class),
new InfluencerWrapper("Random Model", ModelInfluencer.Random.class),
new InfluencerWrapper("Scale", ScaleInfluencer.class),
new InfluencerWrapper("Spawn", SpawnInfluencer.class),
new InfluencerWrapper("Dynamics", DynamicsInfluencer.class)}),
ParticleController("Particle Controller", new InfluencerWrapper[]{
new InfluencerWrapper("Single Particle Controller", ParticleControllerInfluencer.Single.class),
new InfluencerWrapper("Random Particle Controller", ParticleControllerInfluencer.Random.class),
new InfluencerWrapper("Scale", ScaleInfluencer.class),
new InfluencerWrapper("Spawn", SpawnInfluencer.class),
new InfluencerWrapper("Dynamics", DynamicsInfluencer.class)});
public String desc;
public InfluencerWrapper[] wrappers;
private ControllerType(String desc, InfluencerWrapper[] wrappers){
this.desc = desc;
this.wrappers = wrappers;
}
}
LwjglCanvas lwjglCanvas;
JPanel controllerPropertiesPanel;
JPanel editorPropertiesPanel;
EffectPanel effectPanel;
JSplitPane splitPane;
NumericValue fovValue;
NumericValue deltaMultiplier;
GradientColorValue backgroundColor;
AppRenderer renderer;
AssetManager assetManager;
JComboBox influencerBox;
private ParticleEffect effect;
/** READ only */
public Array<ControllerData> controllersData;
ParticleSystem particleSystem;
public FlameMain () {
super("Flame");
MathUtils.random = new RandomXS128();
particleSystem = ParticleSystem.get();
effect = new ParticleEffect();
particleSystem.add(effect);
assetManager = new AssetManager();
assetManager.setErrorListener(this);
assetManager.setLoader(ParticleEffect.class, new ParticleEffectLoader(new InternalFileHandleResolver()));
controllersData = new Array<ControllerData>();
lwjglCanvas = new LwjglCanvas(renderer = new AppRenderer());
addWindowListener(new WindowAdapter() {
public void windowClosed (WindowEvent event) {
//System.exit(0);
Gdx.app.exit();
}
});
initializeComponents();
setSize(1280, 950);
setLocationRelativeTo(null);
setDefaultCloseOperation(DISPOSE_ON_CLOSE);
setVisible(true);
}
public ControllerType getControllerType () {
ParticleController controller = getEmitter();
ControllerType type = null;
if(controller.renderer instanceof BillboardRenderer)
type = ControllerType.Billboard;
else if(controller.renderer instanceof PointSpriteRenderer)
type = ControllerType.PointSprite;
else if(controller.renderer instanceof ModelInstanceRenderer)
type = ControllerType.ModelInstance;
else if(controller.renderer instanceof ParticleControllerControllerRenderer)
type = ControllerType.ParticleController;
return type;
}
void reloadRows () {
EventQueue.invokeLater(new Runnable() {
public void run () {
//Ensure no listener is left watching for events
EventManager.get().clear();
//Clear
editorPropertiesPanel.removeAll();
influencerBox.removeAllItems();
controllerPropertiesPanel.removeAll();
//Editor props
addRow(editorPropertiesPanel, new NumericPanel(FlameMain.this, fovValue, "Field of View", ""));
addRow(editorPropertiesPanel, new NumericPanel(FlameMain.this, deltaMultiplier, "Delta multiplier", ""));
addRow(editorPropertiesPanel, new GradientPanel(FlameMain.this,backgroundColor, "Background color", "", true));
addRow(editorPropertiesPanel, new DrawPanel(FlameMain.this, "Draw", ""));
addRow(editorPropertiesPanel, new TextureLoaderPanel(FlameMain.this, "Texture", ""));
addRow(editorPropertiesPanel, new BillboardBatchPanel(FlameMain.this, renderer.billboardBatch), 1, 1);
editorPropertiesPanel.repaint();
//Controller props
ParticleController controller = getEmitter();
if(controller != null){
//Reload available influencers
DefaultComboBoxModel model = (DefaultComboBoxModel)influencerBox.getModel();
ControllerType type = getControllerType();
if(type != null){
for(Object value : type.wrappers)
model.addElement(value);
}
JPanel panel = null;
addRow(controllerPropertiesPanel, getPanel(controller.emitter));
for(int i=0, c = controller.influencers.size; i < c; ++i){
Influencer influencer = (Influencer)controller.influencers.get(i);
panel = getPanel(influencer);
if(panel != null)
addRow(controllerPropertiesPanel, panel, 1, i == c-1 ? 1 : 0);
}
for (Component component : controllerPropertiesPanel.getComponents())
if (component instanceof EditorPanel)
((EditorPanel)component).update(FlameMain.this);
}
controllerPropertiesPanel.repaint();
}
});
}
protected JPanel getPanel (Emitter emitter) {
if(emitter instanceof RegularEmitter){
return new RegularEmitterPanel(this, (RegularEmitter) emitter);
}
return null;
}
protected JPanel getPanel (Influencer influencer) {
if(influencer instanceof ColorInfluencer.Single){
return new ColorInfluencerPanel(this, (ColorInfluencer.Single) influencer);
}
if(influencer instanceof ColorInfluencer.Random){
return new InfluencerPanel<ColorInfluencer.Random>(this, (ColorInfluencer.Random) influencer,
"Random Color Influencer", "Assign a random color to the particles") {};
}
else if(influencer instanceof ScaleInfluencer){
return new ScaleInfluencerPanel(this, (ScaleInfluencer)influencer);
}
else if(influencer instanceof SpawnInfluencer){
return new SpawnInfluencerPanel(this, (SpawnInfluencer)influencer);
}
else if(influencer instanceof DynamicsInfluencer){
return new DynamicsInfluencerPanel(this, (DynamicsInfluencer)influencer);
}
else if(influencer instanceof ModelInfluencer){
boolean single = influencer instanceof ModelInfluencer.Single;
String name = single ? "Model Single Influencer" : "Model Random Influencer";
return new ModelInfluencerPanel(this, (ModelInfluencer)influencer, single, name, "Defines what model will be used for the particles");
}
else if(influencer instanceof ParticleControllerInfluencer){
boolean single = influencer instanceof ParticleControllerInfluencer.Single;
String name = single ? "Particle Controller Single Influencer" : "Particle Controller Random Influencer";
return new ParticleControllerInfluencerPanel(this, (ParticleControllerInfluencer)influencer, single, name, "Defines what controller will be used for the particles");
}
else if(influencer instanceof RegionInfluencer.Single){
return new RegionInfluencerPanel(this, "Billboard Single Region Influencer",
"Assign the chosen region to the particles", (RegionInfluencer.Single)influencer);
}
else if(influencer instanceof RegionInfluencer.Animated){
return new RegionInfluencerPanel(this, "Billboard Animated Region Influencer",
"Animates the region of the particles", (RegionInfluencer.Animated)influencer);
}
else if(influencer instanceof RegionInfluencer.Random){
return new RegionInfluencerPanel(this, "Billboard Random Region Influencer",
"Assigns a randomly picked (among those selected) region to the particles", (RegionInfluencer.Random)influencer);
}
else if(influencer instanceof ParticleControllerFinalizerInfluencer){
return new InfluencerPanel<ParticleControllerFinalizerInfluencer>(this, (ParticleControllerFinalizerInfluencer) influencer,
"ParticleControllerFinalizer Influencer", "This is required when dealing with a controller of controllers, it will update the controller assigned to each particle, it MUST be the last influencer always.",
true, false) {};
}
return null;
}
protected JPanel getPanel (ParticleBatch renderer) {
if(renderer instanceof PointSpriteParticleBatch){
return new EmptyPanel(this, "Point Sprite Batch", "It renders particles as point sprites.");
}
if(renderer instanceof BillboardParticleBatch){
return new BillboardBatchPanel(this, (BillboardParticleBatch) renderer);
}
else if(renderer instanceof ModelInstanceParticleBatch){
return new EmptyPanel(this, "Model Instance Batch", "It renders particles as model instances.");
}
return null;
}
void addRow(JPanel panel, JPanel row) {
addRow(panel, row, 1, 0);
}
void addRow(JPanel panel, JPanel row, float wx, float wy) {
row.setBorder(BorderFactory.createMatteBorder(0, 0, 2, 0, java.awt.Color.black));
panel.add(row, new GridBagConstraints(0, -1, 1, 1, wx, wy, GridBagConstraints.NORTH, GridBagConstraints.HORIZONTAL,
new Insets(0, 0, 0, 0), 0, 0));
}
public void setVisible (String name, boolean visible) {
for (Component component : controllerPropertiesPanel.getComponents())
if (component instanceof EditorPanel && ((EditorPanel)component).getName().equals(name)) component.setVisible(visible);
}
private void rebuildActiveControllers () {
//rebuild list
Array<ParticleController> effectControllers = effect.getControllers();
effectControllers.clear();
for(ControllerData controllerData : controllersData){
if(controllerData.enabled)
effectControllers.add(controllerData.controller);
}
//System.out.println("rebuilding active controllers");
effect.init();
effect.start();
}
public ParticleController getEmitter () {
return effectPanel.editIndex >=0 ? controllersData.get(effectPanel.editIndex).controller : null;
}
public void addEmitter (ParticleController emitter) {
controllersData.add(new ControllerData(emitter));
rebuildActiveControllers();
}
public void removeEmitter (int row) {
controllersData.removeIndex(row).controller.dispose();
rebuildActiveControllers();
}
public void setEnabled (int emitterIndex, boolean enabled) {
ControllerData data = controllersData.get(emitterIndex);
data.enabled = enabled;
rebuildActiveControllers();
}
public boolean isEnabled (int emitterIndex) {
return controllersData.get(emitterIndex).enabled;
}
private void initializeComponents () {
splitPane = new JSplitPane();
splitPane.setUI(new BasicSplitPaneUI() {
public void paint (Graphics g, JComponent jc) {
}
});
splitPane.setDividerSize(4);
getContentPane().add(splitPane, BorderLayout.CENTER);
{
JSplitPane rightSplit = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
rightSplit.setUI(new BasicSplitPaneUI() {
public void paint (Graphics g, JComponent jc) {
}
});
rightSplit.setDividerSize(4);
splitPane.add(rightSplit, JSplitPane.RIGHT);
{
JPanel propertiesPanel = new JPanel(new GridBagLayout());
rightSplit.add(propertiesPanel, JSplitPane.TOP);
propertiesPanel.setBorder(new CompoundBorder(BorderFactory.createEmptyBorder(3, 0, 6, 6), BorderFactory
.createTitledBorder("Editor Properties")));
{
JScrollPane scroll = new JScrollPane();
propertiesPanel.add(scroll, new GridBagConstraints(0, 0, 1, 1, 1, 1, GridBagConstraints.NORTH,
GridBagConstraints.BOTH, new Insets(0, 0, 0, 0), 0, 0));
scroll.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
{
editorPropertiesPanel = new JPanel(new GridBagLayout());
scroll.setViewportView(editorPropertiesPanel);
scroll.getVerticalScrollBar().setUnitIncrement(70);
}
}
}
{
JSplitPane rightSplitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
rightSplitPane.setUI(new BasicSplitPaneUI() {
public void paint (Graphics g, JComponent jc) {
}
});
rightSplitPane.setDividerSize(4);
rightSplitPane.setDividerLocation(100);
rightSplit.add(rightSplitPane, JSplitPane.BOTTOM);
JPanel propertiesPanel = new JPanel(new GridBagLayout());
rightSplitPane.add(propertiesPanel, JSplitPane.TOP);
propertiesPanel.setBorder(new CompoundBorder(BorderFactory.createEmptyBorder(3, 0, 6, 6), BorderFactory
.createTitledBorder("Influencers")));
{
JScrollPane scroll = new JScrollPane();
propertiesPanel.add(scroll, new GridBagConstraints(0, 0, 1, 1, 1, 1, GridBagConstraints.NORTH,
GridBagConstraints.BOTH, new Insets(0, 0, 0, 0), 0, 0));
scroll.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
{
JPanel influencersPanel = new JPanel(new GridBagLayout());
influencerBox = new JComboBox(new DefaultComboBoxModel());
JButton addInfluencerButton = new JButton("Add");
addInfluencerButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed (ActionEvent e) {
InfluencerWrapper wrapper = (InfluencerWrapper)influencerBox.getSelectedItem();
ParticleController controller = getEmitter();
if(controller != null)
addInfluencer(wrapper.type, controller);
}
});
influencersPanel.add(influencerBox, new GridBagConstraints(0, 0, 1, 1, 0, 1, GridBagConstraints.NORTHWEST,
GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
influencersPanel.add(addInfluencerButton, new GridBagConstraints(1, 0, 1, 1, 1, 1, GridBagConstraints.NORTHWEST,
GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
scroll.setViewportView(influencersPanel);
scroll.getVerticalScrollBar().setUnitIncrement(70);
}
}
propertiesPanel = new JPanel(new GridBagLayout());
rightSplitPane.add(propertiesPanel, JSplitPane.BOTTOM);
propertiesPanel.setBorder(new CompoundBorder(BorderFactory.createEmptyBorder(3, 0, 6, 6), BorderFactory
.createTitledBorder("Particle Controller Components")));
{
JScrollPane scroll = new JScrollPane();
propertiesPanel.add(scroll, new GridBagConstraints(0, 0, 1, 1, 1, 1, GridBagConstraints.NORTH,
GridBagConstraints.BOTH, new Insets(0, 0, 0, 0), 0, 0));
scroll.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
{
controllerPropertiesPanel = new JPanel(new GridBagLayout());
scroll.setViewportView(controllerPropertiesPanel);
scroll.getVerticalScrollBar().setUnitIncrement(70);
}
}
}
rightSplit.setDividerLocation(250);
}
{
JSplitPane leftSplit = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
leftSplit.setUI(new BasicSplitPaneUI() {
public void paint (Graphics g, JComponent jc) {
}
});
leftSplit.setDividerSize(4);
splitPane.add(leftSplit, JSplitPane.LEFT);
{
JPanel spacer = new JPanel(new BorderLayout());
leftSplit.add(spacer, JSplitPane.TOP);
spacer.add(lwjglCanvas.getCanvas());
spacer.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 4));
}
{
JPanel emittersPanel = new JPanel(new BorderLayout());
leftSplit.add(emittersPanel, JSplitPane.BOTTOM);
emittersPanel.setBorder(new CompoundBorder(BorderFactory.createEmptyBorder(0, 6, 6, 0), BorderFactory
.createTitledBorder("Particle Controllers")));
{
effectPanel = new EffectPanel(this);
emittersPanel.add(effectPanel);
}
}
leftSplit.setDividerLocation(625);
}
splitPane.setDividerLocation(500);
}
protected void addInfluencer (Class<Influencer> type, ParticleController controller) {
if(controller.findInfluencer(type) != null) return;
try {
controller.end();
Influencer newInfluencer = type.newInstance();
boolean replaced = false;
if(ColorInfluencer.class.isAssignableFrom(type)){
replaced = controller.replaceInfluencer(ColorInfluencer.class, (ColorInfluencer)newInfluencer);
}
else if(RegionInfluencer.class.isAssignableFrom(type)){
replaced = controller.replaceInfluencer(RegionInfluencer.class, (RegionInfluencer)newInfluencer);
}
else if(ModelInfluencer.class.isAssignableFrom(type)){
ModelInfluencer newModelInfluencer = (ModelInfluencer) newInfluencer;
ModelInfluencer currentInfluencer = (ModelInfluencer)controller.findInfluencer(ModelInfluencer.class);
if(currentInfluencer != null){
newModelInfluencer.models.add(currentInfluencer.models.first());
}
replaced = controller.replaceInfluencer(ModelInfluencer.class, (ModelInfluencer)newInfluencer);
}
else if(ParticleControllerInfluencer.class.isAssignableFrom(type)){
ParticleControllerInfluencer newModelInfluencer = (ParticleControllerInfluencer) newInfluencer;
ParticleControllerInfluencer currentInfluencer = (ParticleControllerInfluencer)controller.findInfluencer(ParticleControllerInfluencer.class);
if(currentInfluencer != null){
newModelInfluencer.templates.add(currentInfluencer.templates.first());
}
replaced = controller.replaceInfluencer(ParticleControllerInfluencer.class, (ParticleControllerInfluencer)newInfluencer);
}
if(!replaced){
if(getControllerType() != ControllerType.ParticleController)
controller.influencers.add(newInfluencer);
else{
Influencer finalizer = controller.influencers.pop();
controller.influencers.add(newInfluencer);
controller.influencers.add(finalizer);
}
}
controller.init();
effect.start();
reloadRows();
} catch (Exception e1) {
e1.printStackTrace();
}
}
protected boolean canAddInfluencer (Class influencerType, ParticleController controller) {
boolean hasSameInfluencer = controller.findInfluencer(influencerType) != null;
if(!hasSameInfluencer){
if( (ColorInfluencer.Single.class.isAssignableFrom(influencerType) && controller.findInfluencer(ColorInfluencer.Random.class) != null) ||
(ColorInfluencer.Random.class.isAssignableFrom(influencerType) && controller.findInfluencer(ColorInfluencer.Single.class) != null) ){
return false;
}
if(RegionInfluencer.class.isAssignableFrom(influencerType)){
return controller.findInfluencer(RegionInfluencer.class) == null;
}
else if(ModelInfluencer.class.isAssignableFrom(influencerType)){
return controller.findInfluencer(ModelInfluencer.class) == null;
}
else if(ParticleControllerInfluencer.class.isAssignableFrom(influencerType)){
return controller.findInfluencer(ParticleControllerInfluencer.class) == null;
}
}
return !hasSameInfluencer;
}
class AppRenderer implements ApplicationListener {
//Stats
private float maxActiveTimer;
private int maxActive, lastMaxActive;
boolean isUpdate = true;
//Controls
private CameraInputController cameraInputController;
//UI
private Stage ui;
TextButton playPauseButton;
private Label fpsLabel, pointCountLabel, billboardCountLabel, modelInstanceCountLabel, maxLabel;
StringBuilder stringBuilder;
//Render
public PerspectiveCamera worldCamera;
private boolean isDrawXYZ, isDrawXZPlane, isDrawXYPlane;
private Array<Model> models;
private ModelInstance xyzInstance, xzPlaneInstance, xyPlaneInstance;
private Environment environment;
private ModelBatch modelBatch;
PointSpriteParticleBatch pointSpriteBatch;
BillboardParticleBatch billboardBatch;
ModelInstanceParticleBatch modelInstanceParticleBatch;
public void create () {
if (ui != null) return;
int w = Gdx.graphics.getWidth(), h = Gdx.graphics.getHeight();
modelBatch = new ModelBatch();
environment = new Environment();
environment.add(new DirectionalLight().set(Color.WHITE, 0,0,-1));
worldCamera = new PerspectiveCamera(67, w, h);
worldCamera.position.set(10, 10, 10);
worldCamera.lookAt(0,0,0);
worldCamera.near = 0.1f;
worldCamera.far = 300f;
worldCamera.update();
cameraInputController = new CameraInputController(worldCamera);
//Batches
pointSpriteBatch = new PointSpriteParticleBatch();
pointSpriteBatch.setCamera(worldCamera);
billboardBatch = new BillboardParticleBatch();
billboardBatch.setCamera(worldCamera);
modelInstanceParticleBatch = new ModelInstanceParticleBatch();
particleSystem.add(billboardBatch);
particleSystem.add(pointSpriteBatch);
particleSystem.add(modelInstanceParticleBatch);
fovValue = new NumericValue();
fovValue.setValue(67);
fovValue.setActive(true);
deltaMultiplier = new NumericValue();
deltaMultiplier.setValue(1.0f);
deltaMultiplier.setActive(true);
backgroundColor = new GradientColorValue();
Color color = Color.valueOf("878787");
backgroundColor.setColors(new float[] { color.r, color.g, color.b});
models = new Array<Model>();
ModelBuilder builder = new ModelBuilder();
Model xyzModel = builder.createXYZCoordinates(10, new Material(), Usage.Position|Usage.ColorPacked),
planeModel = builder.createLineGrid(10, 10, 1, 1, new Material(ColorAttribute.createDiffuse(Color.WHITE)), Usage.Position);
models.add(xyzModel);
models.add(planeModel);
xyzInstance = new ModelInstance(xyzModel);
xzPlaneInstance = new ModelInstance(planeModel);
xyPlaneInstance = new ModelInstance(planeModel);
xyPlaneInstance.transform.rotate(1f, 0f, 0f, 90f);
setDrawXYZ(true);
setDrawXZPlane(true);
//Load default resources
ParticleEffectLoader.ParticleEffectLoadParameter params = new ParticleEffectLoader.ParticleEffectLoadParameter(particleSystem.getBatches());
assetManager.load(DEFAULT_BILLBOARD_PARTICLE, Texture.class);
assetManager.load(DEFAULT_MODEL_PARTICLE, Model.class);
assetManager.load(DEFAULT_SKIN, Skin.class);
assetManager.load(DEFAULT_TEMPLATE_PFX, ParticleEffect.class, params);
assetManager.finishLoading();
assetManager.setLoader(ParticleEffect.class, new ParticleEffectLoader(new AbsoluteFileHandleResolver()));
assetManager.get(DEFAULT_MODEL_PARTICLE, Model.class).materials.get(0).set(new BlendingAttribute(GL20.GL_ONE, GL20.GL_ONE_MINUS_SRC_ALPHA, 1));
//Ui
stringBuilder = new StringBuilder();
Skin skin = assetManager.get(DEFAULT_SKIN, Skin.class);
ui = new Stage();
fpsLabel = new Label("", skin);
pointCountLabel = new Label("", skin);
billboardCountLabel = new Label("", skin);
modelInstanceCountLabel = new Label("", skin);
maxLabel = new Label("", skin);
playPauseButton = new TextButton("Pause", skin);
playPauseButton.addListener(new ClickListener(){
@Override
public void clicked (InputEvent event, float x, float y) {
isUpdate = !isUpdate;
playPauseButton.setText(isUpdate ? "Pause" : "Play");
}
});
Table table = new Table(skin);
table.setFillParent(true);
table.pad(5);
table.add(fpsLabel).expandX().left().row();
table.add(pointCountLabel).expandX().left().row();
table.add(billboardCountLabel).expandX().left().row();
table.add(modelInstanceCountLabel).expandX().left().row();
table.add(maxLabel).expandX().left().row();
table.add(playPauseButton).expand().bottom().left().row();
ui.addActor(table);
setTexture((Texture)assetManager.get(DEFAULT_BILLBOARD_PARTICLE));
effectPanel.createDefaultEmitter(ControllerType.Billboard, true, true);
}
@Override
public void resize (int width, int height) {
Gdx.input.setInputProcessor(new InputMultiplexer(ui, cameraInputController));
Gdx.gl.glViewport(0, 0, width, height);
worldCamera.viewportWidth = width;
worldCamera.viewportHeight = height;
worldCamera.update();
ui.getViewport().setWorldSize(width, height);
ui.getViewport().update(width, height, true);
}
public void render () {
//float delta = Math.max(0, Gdx.graphics.getDeltaTime() * deltaMultiplier.getValue());
update();
renderWorld();
}
private void update () {
worldCamera.fieldOfView = fovValue.getValue();
worldCamera.update();
cameraInputController.update();
if(isUpdate){
particleSystem.update();
//Update ui
stringBuilder.delete(0, stringBuilder.length);
stringBuilder.append("Point Sprites : ").append(pointSpriteBatch.getBufferedCount());
pointCountLabel.setText(stringBuilder);
stringBuilder.delete(0, stringBuilder.length);
stringBuilder.append("Billboards : ").append(billboardBatch.getBufferedCount());
billboardCountLabel.setText(stringBuilder);
stringBuilder.delete(0, stringBuilder.length);
stringBuilder.append("Model Instances : ").append(modelInstanceParticleBatch.getBufferedCount());
modelInstanceCountLabel.setText(stringBuilder);
}
stringBuilder.delete(0, stringBuilder.length);
stringBuilder.append("FPS : ").append(Gdx.graphics.getFramesPerSecond());
fpsLabel.setText(stringBuilder);
ui.act(Gdx.graphics.getDeltaTime());
}
private void renderWorld () {
float[] colors = backgroundColor.getColors();
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT | GL20.GL_DEPTH_BUFFER_BIT);
Gdx.gl.glClearColor(colors[0], colors[1], colors[2], 0);
modelBatch.begin(worldCamera);
if(isDrawXYZ) modelBatch.render(xyzInstance);
if(isDrawXZPlane) modelBatch.render(xzPlaneInstance);
if(isDrawXYPlane) modelBatch.render(xyPlaneInstance);
particleSystem.begin();
particleSystem.draw();
particleSystem.end();
//Draw
modelBatch.render(particleSystem, environment);
modelBatch.end();
ui.draw();
}
@Override
public void dispose () {}
@Override
public void pause () {}
@Override
public void resume () {}
public void setDrawXYZ(boolean isDraw)
{
isDrawXYZ = isDraw;
}
public boolean IsDrawXYZ()
{
return isDrawXYZ;
}
public void setDrawXZPlane(boolean isDraw)
{
isDrawXZPlane = isDraw;
}
public boolean IsDrawXZPlane()
{
return isDrawXZPlane;
}
public void setDrawXYPlane(boolean isDraw)
{
isDrawXYPlane = isDraw;
}
public boolean IsDrawXYPlane()
{
return isDrawXYPlane;
}
}
public static void main (String[] args) {
for (LookAndFeelInfo info : UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
try {
UIManager.setLookAndFeel(info.getClassName());
} catch (Throwable ignored) {
}
break;
}
}
EventQueue.invokeLater(new Runnable() {
public void run () {
new FlameMain();
}
});
}
public AppRenderer getRenderer() {
return renderer;
}
String lastDir;
public File showFileLoadDialog () {
return showFileDialog("Open", FileDialog.LOAD);
}
public File showFileSaveDialog () {
return showFileDialog("Save", FileDialog.SAVE);
}
private File showFileDialog (String title, int mode ) {
FileDialog dialog = new FileDialog(this, title, mode);
if (lastDir != null) dialog.setDirectory(lastDir);
dialog.setVisible(true);
final String file = dialog.getFile();
final String dir = dialog.getDirectory();
if (dir == null || file == null || file.trim().length() == 0)
return null;
lastDir = dir;
return new File(dir, file);
}
@Override
public void error (AssetDescriptor asset, Throwable throwable) {
throwable.printStackTrace();
}
public PointSpriteParticleBatch getPointSpriteBatch () {
return renderer.pointSpriteBatch;
}
public BillboardParticleBatch getBillboardBatch () {
return renderer.billboardBatch;
}
public ModelInstanceParticleBatch getModelInstanceParticleBatch () {
return renderer.modelInstanceParticleBatch;
}
public void setAtlas(TextureAtlas atlas){
//currentAtlas = atlas;
setTexture(atlas.getTextures().first());
}
public void setTexture(Texture texture){
renderer.billboardBatch.setTexture(texture);
renderer.pointSpriteBatch.setTexture(texture);
}
public Texture getTexture(){
return renderer.billboardBatch.getTexture();
}
public TextureAtlas getAtlas(Texture texture){
Array<TextureAtlas> atlases = assetManager.getAll(TextureAtlas.class, new Array<TextureAtlas>());
for(TextureAtlas atlas : atlases){
if(atlas.getTextures().contains(texture))
return atlas;
}
return null;
}
public TextureAtlas getAtlas(){
return getAtlas(renderer.billboardBatch.getTexture());
}
public boolean isUsingDefaultTexture () {
return renderer.billboardBatch.getTexture() == assetManager.get(DEFAULT_BILLBOARD_PARTICLE, Texture.class);
}
public Array<ParticleEffect> getParticleEffects (Array<ParticleController> controllers, Array<ParticleEffect> out) {
out.clear();
assetManager.getAll(ParticleEffect.class, out);
for(int i=0; i < out.size;){
ParticleEffect effect = out.get(i);
Array<ParticleController> effectControllers = effect.getControllers();
boolean remove = true;
for(ParticleController controller : controllers){
if(effectControllers.contains(controller, true)){
remove = false;
break;
}
}
if(remove){
out.removeIndex(i);
continue;
}
++i;
}
return out;
}
public void saveEffect (File file) {
Writer fileWriter = null;
try {
ParticleEffectLoader loader = (ParticleEffectLoader)assetManager.getLoader(ParticleEffect.class);
loader.save(effect, new ParticleEffectSaveParameter(new FileHandle(file.getAbsolutePath()), assetManager, particleSystem.getBatches()));
} catch (Exception ex) {
System.out.println("Error saving effect: " + file.getAbsolutePath());
ex.printStackTrace();
JOptionPane.showMessageDialog(this, "Error saving effect.");
} finally {
StreamUtils.closeQuietly(fileWriter);
}
}
public ParticleEffect openEffect (File file, boolean replaceCurrentWorkspace) {
try {
ParticleEffect loadedEffect = load(file.getAbsolutePath(), ParticleEffect.class, null,
new ParticleEffectLoader.ParticleEffectLoadParameter(particleSystem.getBatches()));
loadedEffect = loadedEffect.copy();
loadedEffect.init();
if(replaceCurrentWorkspace){
effect = loadedEffect;
controllersData.clear();
particleSystem.removeAll();
particleSystem.add(effect);
for(ParticleController controller : effect.getControllers())
controllersData.add(new ControllerData(controller));
rebuildActiveControllers();
}
reloadRows();
return loadedEffect;
} catch (Exception ex) {
System.out.println("Error loading effect: " + file.getAbsolutePath());
ex.printStackTrace();
JOptionPane.showMessageDialog(this, "Error opening effect.");
}
return null;
}
public <T> T load (String resource, Class<T> type, AssetLoader loader, AssetLoaderParameters<T> params) {
String resolvedPath = new String(resource).replaceAll("\\\\", "/");
boolean exist = assetManager.isLoaded(resolvedPath, type);
T oldAsset = null;
if(exist){
oldAsset = assetManager.get(resolvedPath, type);
for(int i=assetManager.getReferenceCount(resolvedPath); i > 0; --i)
assetManager.unload(resolvedPath);
}
AssetLoader<T, AssetLoaderParameters<T>> currentLoader = assetManager.getLoader(type);
if(loader != null)
assetManager.setLoader(type, loader);
assetManager.load(resource, type, params);
assetManager.finishLoading();
T res = assetManager.get(resolvedPath);
if(currentLoader != null)
assetManager.setLoader(type, currentLoader);
if(exist)
EventManager.get().fire(EVT_ASSET_RELOADED, new Object[]{oldAsset, res});
return res;
}
public void restart () {
effect.init();
effect.start();
}
}