gdx-studio

package gdxstudio.panel;

import gdxstudio.Content;
import gdxstudio.Frame;
import gdxstudio.GdxStudio;
import gdxstudio.Style;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Insets;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.dnd.DnDConstants;
import java.awt.dnd.DropTarget;
import java.awt.dnd.DropTargetDropEvent;
import java.io.File;
import java.nio.ByteBuffer;

import javax.swing.JPanel;
import javax.swing.JScrollPane;

import org.lwjgl.LWJGLException;
import org.lwjgl.opengl.GLContext;

import scene2d.Asset;
import scene2d.Effect;
import scene2d.EffectType;
import scene2d.ImageJson;
import scene2d.InterpolationType;
import scene2d.Map;
import scene2d.Scene;
import scene2d.Sprite;
import web.laf.lite.layout.HorizontalFlowLayout;
import web.laf.lite.layout.VerticalFlowLayout;
import web.laf.lite.utils.UIUtils;
import web.laf.lite.widget.CenterPanel;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.backends.lwjgl.LwjglAWTCanvas;
import com.badlogic.gdx.backends.lwjgl.LwjglApplicationConfiguration;
import com.badlogic.gdx.backends.lwjgl.LwjglCanvas;
import com.badlogic.gdx.files.FileHandle;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.Pixmap;
import com.badlogic.gdx.graphics.Pixmap.Format;
import com.badlogic.gdx.graphics.PixmapIO;
import com.badlogic.gdx.scenes.scene2d.Actor;
import com.badlogic.gdx.scenes.scene2d.ui.Button;
import com.badlogic.gdx.scenes.scene2d.ui.CheckBox;
import com.badlogic.gdx.scenes.scene2d.ui.Dialog;
import com.badlogic.gdx.scenes.scene2d.ui.Label;
import com.badlogic.gdx.scenes.scene2d.ui.Label.LabelStyle;
import com.badlogic.gdx.scenes.scene2d.ui.List;
import com.badlogic.gdx.scenes.scene2d.ui.SelectBox;
import com.badlogic.gdx.scenes.scene2d.ui.Slider;
import com.badlogic.gdx.scenes.scene2d.ui.Table;
import com.badlogic.gdx.scenes.scene2d.ui.TextButton;
import com.badlogic.gdx.scenes.scene2d.ui.TextField;
import com.badlogic.gdx.scenes.scene2d.ui.Touchpad;
import com.badlogic.gdx.tools.hiero.HieroPanel;
import com.badlogic.gdx.tools.particleeditor.ParticlePanel;
import com.badlogic.gdx.tools.particleeditor.ParticleRenderer;
import com.badlogic.gdx.utils.Timer.Task;


final public class StudioPanel extends JPanel  {
	private static final long serialVersionUID = 1L;
	LwjglCanvas can;
	public LwjglAWTCanvas canvas;
	JPanel hbox;
	CenterPanel centerPanel;
	JScrollPane scrollPane;
	LwjglApplicationConfiguration config2 = new LwjglApplicationConfiguration();
	
	Image img;
	public StudioPanel(){
		super(new VerticalFlowLayout());
		hbox = new JPanel(new HorizontalFlowLayout());
		hbox.add(new HeaderLabel("Screen Size"));
		hbox.add(new HeaderLabel("Target Size"));
		UIUtils.setMargin(this, new Insets(15,15,15,15));
		config2.width = 640;
		config2.height = 320;
		config2.fullscreen = false;
		config2.useGL20 = false;
	}

	
	
	@Override
	public void paint(Graphics g){
		if(!isOpaque())
			Style.drawScreen(g, getWidth(), getHeight());
		super.paint(g);	
		
	}
	
	String config = "{"
		+"title: GdxStudio,"
		+"keepAspectRatio: false,"
		+"showFPS: false,"
		+"loggingEnabled: true,"
		+"}";
	
	public void createHieroCanvas(){
		setOpaque(true);
		removeAll();
		HieroPanel panel = new HieroPanel();
		canvas = new  LwjglAWTCanvas(new HieroPanel.FontRenderer() , false);
		HieroPanel.gamePanel.add(canvas.getCanvas());
		JScrollPane scrollPane = new JScrollPane(panel);
		scrollPane.setPreferredSize(new Dimension(860, 650));
		UIUtils.setDrawBorder(scrollPane, false);
		add(scrollPane);
	}
	
	public void createParticleCanvas(){
		setOpaque(true);
		removeAll();
		ParticlePanel panel = new ParticlePanel();
		canvas = new  LwjglAWTCanvas(new ParticleRenderer(panel) , false);
		panel.initializeComponents(canvas);
		JScrollPane scrollPane = new JScrollPane(panel);
		scrollPane.setPreferredSize(new Dimension(860, 650));
		UIUtils.setDrawBorder(scrollPane, false);
		add(scrollPane);
	}
	
	public void createStudioCanvas(){
		removeAll();
		GdxStudio.log("Creating Studio Canvas");
		try{
			Scene.configJson = Scene.jsonReader.parse(config);
			Scene.debug = true;
			Scene.scenesMap.clear();
			Scene.scenesMap.put("gdxstudio.SceneEditor", "");
			setOpaque(false);
			canvas = new  LwjglAWTCanvas(Scene.app , false);
			scrollPane = new JScrollPane(canvas.getCanvas());
			scrollPane.setPreferredSize(new Dimension(800, 480));
			UIUtils.setDrawBorder(scrollPane, false);
			Style.setScreenSize(scrollPane.getPreferredSize().width, scrollPane.getPreferredSize().height);
			centerPanel = new CenterPanel(scrollPane, true, false);
			centerPanel.setBackground(Color.black);
			UIUtils.setUndecorated(centerPanel, true);
			UIUtils.setMargin(centerPanel, new Insets(0,0,0,0));
			add(centerPanel);
			validate();
			Style.setScreenPosition(scrollPane.getLocation().x, scrollPane.getLocation().y);
			canvas.getCanvas().setDropTarget(new DropTarget() {
				private static final long serialVersionUID = 1L;
				public synchronized void drop(DropTargetDropEvent event) {
					try{
						Transferable transferable = event.getTransferable();
						if( transferable.isDataFlavorSupported(DataFlavor.stringFlavor )){
							event.acceptDrop( DnDConstants.ACTION_MOVE );
							String s = (String)transferable.getTransferData(DataFlavor.stringFlavor);
							createActor(s);
							event.getDropTargetContext().dropComplete(true);
						}
						else{
							event.rejectDrop();
						}
					}
					catch( Exception exception ){
						System.err.println( "Exception" + exception.getMessage() );
						event.rejectDrop();
					}
				}
			});
			Asset.save();
		}catch(Exception ex){
			ex.printStackTrace();
		}
	}
	
	public void setGdxScreenSize(int width, int height){
		removeAll();
		canvas.getCanvas().setSize(width, height);
		scrollPane = new JScrollPane(canvas.getCanvas());
		scrollPane.setPreferredSize(new Dimension(width, height));
		UIUtils.setDrawBorder(scrollPane, false);
		Style.setScreenSize(scrollPane.getPreferredSize().width, scrollPane.getPreferredSize().height);
		scrollPane.setPreferredSize(new Dimension(width, height));
		centerPanel = new CenterPanel(scrollPane, true, false);
		centerPanel.setBackground(Color.black);
		UIUtils.setUndecorated(centerPanel, true);
		UIUtils.setMargin(centerPanel, new Insets(0,0,0,0));
		add(centerPanel);
		validate();
		Style.setScreenPosition(scrollPane.getLocation().x, scrollPane.getLocation().y);
		canvas.makeCurrent();
        try {
			GLContext.useContext(canvas);
		} catch (LWJGLException e) {
			e.printStackTrace();
		}
	}
	
	public void revalidateScreenPosition(){
		if(scrollPane != null){
			validate();
			Style.setScreenPosition(canvas.getCanvas().getLocation().x, canvas.getCanvas().getLocation().y);
		}
	}
	
	public void destroyCanvas(){
		GdxStudio.log("Destroying Scene Canvas");
		if(canvas != null){
			remove(canvas.getCanvas());
			canvas.stop();
			canvas = null;
		}
	}
	
	private int getNameCount(Actor actor){
		int count = 1;
		for(Actor child: Scene.getCurrentScene().getChildren())
			if(actor.getClass().equals(child.getClass())) count++;
		return count;
	}
	
	
	public void setName(final Actor actor){
		com.badlogic.gdx.utils.Timer.schedule(new Task(){
			@Override
			public void run() {
				String name = actor.getClass().getSimpleName()+getNameCount(actor);
				if(Scene.getCurrentScene().findActor(name) == null)
					actor.setName(name);
				else
					actor.setName(name+"_1");
				actor.setX(Scene.mouse.x-actor.getWidth()/2);
				actor.setY(Scene.mouse.y-actor.getHeight()/2);
				Scene.getCurrentScene().addActor(actor);
				Frame.actorPanel.addActor(actor.getName());
				Scene.isDirty = true;
				Effect.createEffect(actor, EffectType.ScaleInOut, 1.5f, 0.5f, InterpolationType.Linear);
			}
		}, 0.1f);
	}
	
	public void createActor(String type){
		switch(type){
			case "Label":
				if(Asset.fontMap.size != 0){
					LabelStyle ls = new LabelStyle();
					ls.font = Asset.fontMap.firstValue();
					Label label = new Label("Text", ls);
					setName(label);
				}
				break;
			case "Image":
				if(Asset.texMap.size != 0){
					setName(new ImageJson(Asset.texMap.firstKey()));
				}
				break;
			case "Texture":setName(new ImageJson(Content.assetPanel.list.getSelectedValue()));break;
			case "Sprite":setName(new Sprite(1f, Asset.texMap.firstKey()));break;
			case "Particle":
				//ParticleEffect pe = new ParticleEffect();
				//pe.load(effectFile, imagesDir);
				break;
	
			case "Button":setName(new Button(Asset.skin));break;
			case "TextButton":setName(new TextButton("Text", Asset.skin));break;
			case "TextField":setName(new TextField("", Asset.skin));break;
			case "Table":setName(new Table(Asset.skin));break;
			case "CheckBox":setName(new CheckBox("Check", Asset.skin));break;
			case "SelectBox":setName(new SelectBox(new String[]{"First","Second","Third"}, Asset.skin));break;
			case "List":setName(new List(new String[]{"First","Second","Third"}, Asset.skin));break;
			case "Slider":setName(new Slider(0, 10, 1, false, Asset.skin));break;
			case "Dialog":setName(new Dialog("Title", Asset.skin));break;
			case "Touchpad":setName(new Touchpad(5, Asset.skin));break;
			case "Map":setName(new Map(1, 24));break;
			case "None":break;
			default:break;
		}
	}
	
	public static void updateAssets(){
		StringBuilder sb = new StringBuilder();
		for(String filename: new File(Asset.basePath+"font").list()){
			if(filename.endsWith(".fnt")){
				GdxStudio.log("Loading :"+filename);
				sb.append(filename);
				sb.append(",");
			}
		}
		Asset.assetMap.put("font", sb.toString());
		sb = new StringBuilder();
		for(String filename: new File(Asset.basePath+"atlas").list()){
			if(filename.endsWith(".atlas")){
				GdxStudio.log("Loading :"+filename);
				sb.append(filename);
				sb.append(",");
			}
		}
		Asset.assetMap.put("atlas", sb.toString());
		sb = new StringBuilder();
		for(String filename: new File(Asset.basePath+"sound").list()){
			if(filename.endsWith(".mp3")){
				GdxStudio.log("Loading :"+filename);
				sb.append(filename);
				sb.append(",");
			}
		}
		Asset.assetMap.put("sound", sb.toString());
		sb = new StringBuilder();
		for(String filename: new File(Asset.basePath+"music").list()){
			if(filename.endsWith(".mp3")){
				GdxStudio.log("Loading :"+filename);
				sb.append(filename);
				sb.append(",");
			}
		}
		Asset.assetMap.put("music", sb.toString());
		sb = new StringBuilder();
		for(String filename: new File(Asset.basePath+"model").list()){
			if(filename.endsWith(".obj") || filename.endsWith(".g3db")){
				GdxStudio.log("Loading :"+filename);
				Asset.modelMap.add(filename);
			}
		}
	}
	
	private static int counter = 1;
    public static void saveScreenshot(){
        try{
            FileHandle fh;
            do{
                fh = new FileHandle("shots/shot" + counter++ + ".png");
            }while (fh.exists());
            Pixmap pixmap = getScreenshot(0, 0, Gdx.graphics.getWidth(), Gdx.graphics.getHeight(), false);
            PixmapIO.writePNG(fh, pixmap);
            pixmap.dispose();
        }catch (Exception e){           
        }
    }

    private static Pixmap getScreenshot(int x, int y, int w, int h, boolean flipY){
        Gdx.gl.glPixelStorei(GL20.GL_PACK_ALIGNMENT, 1);

        final Pixmap pixmap = new Pixmap(w, h, Format.RGBA8888);
        ByteBuffer pixels = pixmap.getPixels();
        Gdx.gl.glReadPixels(x, y, w, h, GL20.GL_RGBA, GL20.GL_UNSIGNED_BYTE, pixels);

        final int numBytes = w * h * 4;
        byte[] lines = new byte[numBytes];
        if (flipY){
            pixels.clear();
            pixels.get(lines);
        }else{
            final int numBytesPerLine = w * 4;
            for (int i = 0; i < h; i++){
                pixels.position((h - i - 1) * numBytesPerLine);
                pixels.get(lines, i * numBytesPerLine, numBytesPerLine);
            }
            pixels.clear();
            pixels.put(lines);
        }
        return pixmap;
    }
}