package drawing;
 
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
 
import javax.media.opengl.GL;
 
import org.mt4j.MTApplication;
import org.mt4j.components.TransformSpace;
import org.mt4j.components.visibleComponents.shapes.MTRoundRectangle;
import org.mt4j.components.visibleComponents.widgets.MTSceneWindow;
import org.mt4j.components.visibleComponents.widgets.buttons.MTImageButton;
import org.mt4j.input.inputProcessors.componentProcessors.tapProcessor.TapEvent;
import org.mt4j.sceneManagement.AbstractScene;
import org.mt4j.sceneManagement.IPreDrawAction;
import org.mt4j.util.ConstantsAndSettings;
import org.mt4j.util.math.Vector3D;
import org.mt4j.util.opengl.GLFBO;
 
import processing.core.PImage;
import processing.opengl.PGraphicsOpenGL;
 
public class StartExample extends MTApplication{
        /**
         * 
         */
        private static final long serialVersionUID = 1L;
 
 
        public static void main(String args[]){
                initialize();
        }
 
        
        public void startUp(){
                this.addScene(new MainDrawingScene(this, "Main drawing scene"));
        }
 
 
        private class MainDrawingScene extends AbstractScene {
                private MTApplication pa;
 
                public MainDrawingScene(MTApplication mtApplication, String name) {
                        super(mtApplication, name);
                        this.pa = mtApplication;
 
                        //Create window frame
                MTRoundRectangle windowRect4 = new MTRoundRectangle(-50,-50, 0, pa.width+100, pa.height+100, 25,25, pa);
                this.getCanvas().addChild(windowRect4);
                DrawingScene drawingScene = new DrawingScene(pa, "drawingScene Scene");
                drawingScene.setClear(false);
                //Create the drawing scene as a window
                final MTSceneWindow lws4 = new MTSceneWindow(0,0, pa, drawingScene);
                lws4.setStrokeColor(new MTColor(155,155,155));
                windowRect4.scale(0.5f, 0.5f, 1, new Vector3D(pa.width/2f, pa.height/2f, 0), TransformSpace.RELATIVE_TO_PARENT);
                windowRect4.addChild(lws4);
 
                //Create eraser button
                PImage eraser = pa.loadImage(System.getProperty("user.dir")+File.separator + "examples"+ File.separator +"drawing"+ File.separator + File.separator +"data"+ File.separator + "Kde_crystalsvg_eraser.png");
                MTImageButton b = new MTImageButton(eraser, pa);
                b.setNoStroke(true);
                b.translate(new Vector3D(-50,0,0));
                b.addActionListener(new ActionListener(){
                                
                                public void actionPerformed(ActionEvent ae) {
                                        switch (ae.getID()) {
                                        case TapEvent.BUTTON_CLICKED:{
                                                //As we are messing with opengl here, we make sure it happens in the rendering thread
                                                pa.invokeLater(new Runnable() {
                                                        
                                                        public void run() {
                                                           //Clear the framebuffer (FBO)
                                                           lws4.getFbo().clear(true, 0, 0, 0, 0, true);                                            
                                                        }
                                                });
                                        }break;
                                        default:
                                                break;
                                        }
                                }
                });
                windowRect4.addChild(b);
                }
 
                
                public void init() {  }
 
                
                public void shutDown() {      }
        }
 
}

package drawing;
 
import org.mt4j.MTApplication;
import org.mt4j.components.MTComponent;
import org.mt4j.components.visibleComponents.shapes.MTEllipse;
import org.mt4j.input.ComponentInputProcessorHandler;
import org.mt4j.input.IMTInputEventListener;
import org.mt4j.input.inputData.InputMotion;
import org.mt4j.input.inputData.MTInputEvent;
import org.mt4j.input.inputData.MTCursorInputEvt;
import org.mt4j.sceneManagement.AbstractScene;
import org.mt4j.util.math.Vector3D;
 
import processing.core.PGraphics;
 
 
public class DrawingScene extends AbstractScene {
 
        private MTApplication mtApp;
 
        public DrawingScene(MTApplication mtApplication, String name) {
                super(mtApplication, name);
                this.mtApp = mtApplication;
 
                this.getCanvas().addInputListener(new IMTInputEventListener() {
                        
                public boolean processInputEvent(MTInputEvent inEvt){
                        if(inEvt instanceof MTCursorInputEvt){
                                MTCursorInputEvt posEvt = (MTCursorInputEvt)inEvt;
                                InputMotion m = posEvt.getMotion();
                                MTCursorInputEvt prev = m.getPreviousEventOf(posEvt);
 
                                Vector3D pos = new Vector3D(posEvt.getPosX(), posEvt.getPosY(), 0);
 
                                if (prev == null){
                                        prev = posEvt;
                                }else{
                                        Vector3D prevPos = new Vector3D(prev.getPosX(), prev.getPosY(), 0);
                                        Vector3D moveVect = prevPos.getSubtracted(pos);
 
                                        Vector3D betweenA = moveVect.getScaled(0.25f);
                                        Vector3D betweenB = moveVect.getScaled(0.5f);
                                        Vector3D betweenC = moveVect.getScaled(0.75f);
 
                                        Vector3D betweenVectA = pos.getAdded(betweenA);
                                        Vector3D betweenVectB = pos.getAdded(betweenB);
                                        Vector3D betweenVectC = pos.getAdded(betweenC);
 
                                        addNewPoint(betweenVectA);
                                        addNewPoint(betweenVectB);
                                        addNewPoint(betweenVectC);
                                }
 
                                addNewPoint(pos);
                        }
                        return true;
                }
                });
 
 
        }
 
        private void addNewPoint(Vector3D where){
                MTEllipse fingerCircle = new MTEllipse(mtApp, where, 12, 12, 10);
                fingerCircle.setPickable(false);
                fingerCircle.setNoFill(false);
                fingerCircle.setNoStroke(true);
                fingerCircle.setDrawSmooth(true);
                fingerCircle.setFillColor(new MTColor(40, 130, 250, 255));
                fingerCircle.setDepthBufferDisabled(true);
                getCanvas().addChild(fingerCircle);
        }
 
        
        public void init() {
 
        }
 
        
        public void drawAndUpdate(PGraphics graphics, long timeDelta) {
                super.drawAndUpdate(graphics, timeDelta);
 
                //As we dont clear the background each frame its enough to draw each shape once
                //and then remove it afterwards
                MTComponent[] children = this.getCanvas().getChildren();
                for (int i = 0; i < children.length; i++) {
                        children[i].destroy();
                }
        }
 
 
        
        public void shutDown() {
 
        }
}