Add Dominik's ElektronenMultiplizierer (GL2ES2, NEWT) version

3 files changed, 1227 insertions, 0 deletions

diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/ElektronenMultiplizierer.java b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/ElektronenMultiplizierer.java
new file mode 100644
index 000000000..f484dbf72
--- /dev/null
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/ElektronenMultiplizierer.java
@@ -0,0 +1,515 @@
+/**
+ * Copyright 2011 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+
+package com.jogamp.opengl.test.junit.jogl.demos.es2;
+
+import java.nio.*;
+
+import javax.media.opengl.*;
+import javax.media.opengl.glu.*;
+
+import com.jogamp.common.nio.*;
+import com.jogamp.newt.opengl.*;
+import com.jogamp.opengl.util.*;
+import com.jogamp.opengl.util.glsl.ShaderCode;
+import com.jogamp.opengl.util.glsl.ShaderProgram;
+import com.jogamp.opengl.util.glsl.ShaderState;
+
+import static javax.media.opengl.GL2ES2.*;
+
+/**
+ **   __ __|_  ___________________________________________________________________________  ___|__ __
+ **  //    /\                                           _                                  /\    \\  
+ ** //____/  \__     __ _____ _____ _____ _____ _____  | |     __ _____ _____ __        __/  \____\\ 
+ **  \    \  / /  __|  |     |   __|  _  |     |  _  | | |  __|  |     |   __|  |      /\ \  /    /  
+ **   \____\/_/  |  |  |  |  |  |  |     | | | |   __| | | |  |  |  |  |  |  |  |__   "  \_\/____/   
+ **  /\    \     |_____|_____|_____|__|__|_|_|_|__|    | | |_____|_____|_____|_____|  _  /    /\     
+ ** /  \____\                       http://jogamp.org  |_|                              /____/  \    
+ ** \  /   "' _________________________________________________________________________ `"   \  /    
+ **  \/____.                                                                             .____\/     
+ **
+ ** JOGL2 port of my PC 4k intro competition entry for Revision 2011. Sure it got a little bigger 
+ ** while porting but the shader and control code remained more or less untouched. The intro renders
+ ** a fullscreen billboard using a single fragment shader. The shader encapsulates basically two 
+ ** different routines: A sphere-tracing based raymarcher for a single fractal formula and a bitmap
+ ** orbit trap julia+mandelbrot fractal renderer. Additionally an inline-processing analog-distortion
+ ** filter is applied to all rendered fragments to make the overall look more interesting.
+ **
+ ** The different intro parts are all parameter variations of the two routines in the fragment shader 
+ ** synched to the music: Parts 3+5 are obviously the mandelbrot and julia bitmap orbit traps, and parts
+ ** 1,2,4 and 6 are pure fractal sphere tracing.
+ **
+ ** During the development of the intro it turned out that perfectly raymarching every pixel of the orbit
+ ** trapped julia+mandelbrot fractal was way to slow even on highend hardware. So I inserted a lowres 
+ ** intermediate FBO to be used by the bitmap based orbit trap routine wich was ofcourse way faster, but
+ ** had the obvious upscaling artefacts. Maybe I'll produce a perfect quality version for very patient 
+ ** people with insane hardware :)
+ **
+ ** Papers and articles you should be familiar with before trying to understand the code:
+ **
+ ** Distance rendering for fractals: http://www.iquilezles.org/www/articles/distancefractals/distancefractals.htm
+ ** Geometric orbit traps: http://www.iquilezles.org/www/articles/ftrapsgeometric/ftrapsgeometric.htm
+ ** Bitmap orbit traps: http://www.iquilezles.org/www/articles/ftrapsbitmap/ftrapsbitmap.htm
+ ** Ambient occlusion techniques: http://www.iquilezles.org/www/articles/ao/ao.htm
+ ** Sphere tracing: A geometric method for the antialiased ray tracing of implicit surfaces: http://graphics.cs.uiuc.edu/~jch/papers/zeno.pdf
+ ** Rendering fractals with distance estimation function: http://www.iquilezles.org/www/articles/mandelbulb/mandelbulb.htm
+ **
+ ** For an impression how this routine looks like see here: http://www.youtube.com/watch?v=lvC8maVHh8Q
+ ** Original release from the Revision can be found here: http://www.pouet.net/prod.php?which=56860
+ **/
+public class ElektronenMultiplizierer implements GLEventListener {
+
+//BEGIN --- BaseGlobalEnvironment replacement ---
+
+    private final GLCapabilities mCaps; 
+    private final GLU mGlu;
+
+    private String      mCommandLineParameter_BaseRoutineClassName;
+    private boolean     mCommandLineParameter_MultiSampling;
+    private int         mCommandLineParameter_NumberOfSampleBuffers;
+    private boolean     mCommandLineParameter_AnisotropicFiltering;
+    private float       mCommandLineParameter_AnisotropyLevel;
+    private boolean     mCommandLineParameter_FrameCapture;
+    private boolean     mCommandLineParameter_FrameSkip;
+    private boolean     mUsesFullScreenMode;
+    private int         mFrameCounter;
+    private int         mCommandLineParameter_FrameRate;
+    private long        mFrameSkipAverageFramerateTimeStart;
+    private boolean     mFrameSkipAverageFrameStartTimeInitialized;
+    private long        mFrameSkipAverageFramerateTimeEnd; 
+    private double      mFrameCounterDifference;
+    private double      mFrameCounterTargetValue;
+    private int         mSkippedFramesCounter;
+//    private BaseMusic mBaseMusic;
+    boolean             mMusicSyncStartTimeInitialized = false;
+
+    private ShaderState st;
+    private PMVMatrix pmvMatrix;
+    private GLUniformData pmvMatrixUniform;
+    private GLUniformData mScreenDimensionUniform;
+    private GLArrayDataServer vertices0;
+    private GLArrayDataServer texCoords0;
+    
+    public String   getBaseRoutineClassName()       { return mCommandLineParameter_BaseRoutineClassName; }
+    public boolean  preferMultiSampling()           { return mCommandLineParameter_MultiSampling; }
+    public int      getNumberOfSamplingBuffers()    { return mCommandLineParameter_NumberOfSampleBuffers; }
+    public boolean  preferAnisotropicFiltering()    { return mCommandLineParameter_AnisotropicFiltering; }
+    public float    getAnisotropyLevel()            { return mCommandLineParameter_AnisotropyLevel; }
+    public boolean  wantsFrameCapture()             { return mCommandLineParameter_FrameCapture; }
+    public int      getDesiredFramerate()           { return mCommandLineParameter_FrameRate; }
+    public boolean  wantsFrameSkip()                { return mCommandLineParameter_FrameSkip; }
+    public boolean  usesFullScreenMode()            { return mUsesFullScreenMode; }
+
+    public ElektronenMultiplizierer (
+            String inBaseRoutineClassName,
+            boolean inMultiSampling,
+            int inNumberOfSampleBuffers,
+            boolean inAnisotropicFiltering,
+            float inAnisotropyLevel,
+            boolean inFrameCapture,
+            boolean inFrameSkip, int desiredFrameRate
+    ) {
+        mGlu = new GLU();
+        mCommandLineParameter_BaseRoutineClassName = inBaseRoutineClassName;
+        mCommandLineParameter_MultiSampling = inMultiSampling;
+        mCommandLineParameter_NumberOfSampleBuffers = (inNumberOfSampleBuffers==-1) ? 2 : inNumberOfSampleBuffers;
+        mCommandLineParameter_AnisotropicFiltering = inAnisotropicFiltering;
+        mCommandLineParameter_AnisotropyLevel = (inAnisotropyLevel==-1.0f) ? 2.0f : inAnisotropyLevel;
+        mCommandLineParameter_FrameCapture = inFrameCapture;
+        mCommandLineParameter_FrameSkip = inFrameSkip;
+        mCommandLineParameter_FrameRate = desiredFrameRate;
+        mCaps = new GLCapabilities(GLProfile.get(GLProfile.GL2ES2));
+        if (preferMultiSampling()) {
+            // enable/configure multisampling support ...
+            mCaps.setSampleBuffers(true);
+            mCaps.setNumSamples(getNumberOfSamplingBuffers());
+            mCaps.setAccumAlphaBits(1);
+            mCaps.setAccumBlueBits(1);
+            mCaps.setAccumGreenBits(1);
+            mCaps.setAccumRedBits(1);
+            // turns out we need to have alpha, otherwise no AA will be visible
+            mCaps.setAlphaBits(1); 
+        }
+    }
+    
+    public GLCapabilitiesImmutable getGLCapabilities() {
+        return mCaps;
+    }
+
+    public void init(GLAutoDrawable drawable) {
+        GL2ES2 gl = drawable.getGL().getGL2ES2();
+        gl.setSwapInterval(1);
+        mFrameCounter = 0;        
+
+        st = new ShaderState();        
+        final ShaderCode vp0 = ShaderCode.create(gl, GL2ES2.GL_VERTEX_SHADER, 1, this.getClass(),
+                "shader", "shader/bin", "default");
+        final ShaderCode fp0 = ShaderCode.create(gl, GL2ES2.GL_FRAGMENT_SHADER, 1, this.getClass(),
+           //   "shader", "shader/bin", "elektronenmultiplizierer_development");
+                "shader", "shader/bin", "elektronenmultiplizierer_port");
+        final ShaderProgram sp0 = new ShaderProgram();
+        sp0.add(gl, vp0, System.err);
+        sp0.add(gl, fp0, System.err);       
+        st.attachShaderProgram(gl, sp0);
+        st.useProgram(gl, true);
+                
+        final float XRESf = (float) drawable.getWidth();
+        final float YRESf = (float) drawable.getHeight();
+
+        mScreenDimensionUniform = new GLUniformData("resolution", 2, Buffers.newDirectFloatBuffer(2));
+        final FloatBuffer mScreenDimensionV = (FloatBuffer) mScreenDimensionUniform.getBuffer();
+        mScreenDimensionV.put(0, XRESf);
+        mScreenDimensionV.put(1, YRESf);
+        st.ownUniform(mScreenDimensionUniform);       
+        st.uniform(gl, mScreenDimensionUniform);        
+        
+        pmvMatrix = new PMVMatrix();
+        pmvMatrixUniform = new GLUniformData("gcu_PMVMatrix", 4, 4, pmvMatrix.glGetPMvMatrixf());
+        st.ownUniform(pmvMatrixUniform);
+        st.uniform(gl, pmvMatrixUniform);
+                 
+        vertices0 = GLArrayDataServer.createGLSL(st, "gca_Vertices", 2, GL.GL_FLOAT, false, 4, GL.GL_STATIC_DRAW);
+        vertices0.putf(0);     vertices0.putf(YRESf);
+        vertices0.putf(XRESf); vertices0.putf(YRESf);
+        vertices0.putf(0);     vertices0.putf(0);
+        vertices0.putf(XRESf); vertices0.putf(0);
+        vertices0.seal(gl, true);        
+        st.ownAttribute(vertices0, true);
+        vertices0.enableBuffer(gl, false);
+        
+        texCoords0 = GLArrayDataServer.createGLSL(st, "gca_TexCoords", 2, GL.GL_FLOAT, false, 4, GL.GL_STATIC_DRAW);
+        texCoords0.putf(0f); texCoords0.putf(1f);
+        texCoords0.putf(1f);  texCoords0.putf(1f);
+        texCoords0.putf(0f);  texCoords0.putf(0f);        
+        texCoords0.putf(1f); texCoords0.putf(0f);
+        texCoords0.seal(gl, true);
+        st.ownAttribute(texCoords0, true);
+        texCoords0.enableBuffer(gl, false);
+
+        //generate framebufferobject
+        int[] result = new int[1];
+        gl.glGenTextures(1, result, 0);
+        mFrameBufferTextureID = result[0];
+        gl.glBindTexture(GL_TEXTURE_2D, mFrameBufferTextureID);
+        gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        gl.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 384, 384, 0, GL_RGBA, GL_UNSIGNED_BYTE, null);
+
+        //allocate the framebuffer object ...
+        gl.glGenFramebuffers(1, result, 0);
+        mFrameBufferObjectID = result[0];
+        gl.glBindFramebuffer(GL_FRAMEBUFFER, mFrameBufferObjectID);
+        gl.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mFrameBufferTextureID, 0);
+        gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+        gl.glBindFramebuffer(GL_FRAMEBUFFER, 0);
+        st.uniform(gl, new GLUniformData("fb", 0));
+
+        // will be changed in display(..)
+        st.uniform(gl, new GLUniformData("en", 0));
+        st.uniform(gl, new GLUniformData("tm", 0.0f));
+        st.uniform(gl, new GLUniformData("br", 0.0f));
+        st.uniform(gl, new GLUniformData("et", 0.0f));
+
+        gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+
+//        mBaseMusic = new BaseMusic(BaseGlobalEnvironment.getInstance().getMusicFileName());
+//        mBaseMusic.init();
+//        mBaseMusic.play();
+    }
+
+    public void display(GLAutoDrawable drawable) {
+        GL2ES2 gl = drawable.getGL().getGL2ES2();
+        
+        final int XRES = drawable.getWidth();
+        final int YRES = drawable.getHeight();
+
+        //if NO music is used sync to mainloop start ...
+        if (!mFrameSkipAverageFrameStartTimeInitialized) {
+            mFrameSkipAverageFrameStartTimeInitialized = true;
+            mFrameSkipAverageFramerateTimeStart = System.nanoTime();
+        }
+//        if (!getBaseMusic().isOffline()) {
+//            //if music IS used sync to first second of music ...
+//            if (BaseRoutineRuntime.getInstance().getBaseMusic().getPositionInMilliseconds()>0 && !mMusicSyncStartTimeInitialized) {
+//                BaseLogging.getInstance().info("Synching to BaseMusic ...");
+//                mFrameSkipAverageFramerateTimeStart = (long)(System.nanoTime()-((double)BaseRoutineRuntime.getInstance().getBaseMusic().getPositionInMilliseconds()*1000000.0d));
+//                mMusicSyncStartTimeInitialized = true;
+//            }
+//        }
+        //allow music DSP's to synchronize with framerate ...
+//        mBaseMusic.synchonizeMusic();
+
+        //use this for offline rendering/capture ...
+        int MMTime_u_ms = (int)((((double)mFrameCounter)*44100.0f)/60.0f);
+        //use this for music synched rendering ...
+        //int MMTime_u_ms = (int)(BaseRoutineRuntime.getInstance().getBaseMusic().getPositionInMilliseconds()*(44100.0f/1000.0f));
+        //dedicated sync variable for each event ... kinda lame but who cares X-)
+        if (MMTime_u_ms>=522240  && !mSyncEvent_01) { mSyncEvent_01 = true; handleSyncEvent(MMTime_u_ms); }
+        if (MMTime_u_ms>=1305480 && !mSyncEvent_02) { mSyncEvent_02 = true; handleSyncEvent(MMTime_u_ms); }
+        if (MMTime_u_ms>=1827720 && !mSyncEvent_03) { mSyncEvent_03 = true; handleSyncEvent(MMTime_u_ms); }
+        if (MMTime_u_ms>=2349960 && !mSyncEvent_04) { mSyncEvent_04 = true; handleSyncEvent(MMTime_u_ms); }
+        if (MMTime_u_ms>=3394440 && !mSyncEvent_05) { mSyncEvent_05 = true; handleSyncEvent(MMTime_u_ms); }
+        if (MMTime_u_ms>=3916680 && !mSyncEvent_06) { mSyncEvent_06 = true; handleSyncEvent(MMTime_u_ms); }
+        if (MMTime_u_ms>=4438408 && !mSyncEvent_07) { mSyncEvent_07 = true; handleSyncEvent(MMTime_u_ms); }
+        if (MMTime_u_ms>=5482831 && !mSyncEvent_08) { mSyncEvent_08 = true; handleSyncEvent(MMTime_u_ms); }
+        //calculate current time based on 60fps reference framerate ...
+        MMTime_u_ms = (int)((((double)mFrameCounter)*44100.0)/60.0);
+        gl.glDisable(GL_CULL_FACE);
+        gl.glDisable(GL_DEPTH_TEST);
+
+        st.useProgram(gl, true);
+
+        vertices0.enableBuffer(gl, true);
+        texCoords0.enableBuffer(gl, true);
+
+        pmvMatrix.glMatrixMode(PMVMatrix.GL_PROJECTION);
+        pmvMatrix.glLoadIdentity();
+        pmvMatrix.glOrthof(0f, XRES, YRES, 0f, -1f, 1f);
+        pmvMatrix.glMatrixMode(PMVMatrix.GL_MODELVIEW);
+        pmvMatrix.glLoadIdentity();
+        st.uniform(gl, pmvMatrixUniform);
+        
+        gl.glActiveTexture(GL_TEXTURE0);
+
+        //gogogo! O-)
+        float tBrightnessSync = 40.0f-((MMTime_u_ms-mSyncTime)/1000.0f);
+        if (tBrightnessSync<1) {
+            tBrightnessSync=1;
+        }
+        mEffectTime = (float)((MMTime_u_ms-mEffectSyncTime)/100000.0f);
+        
+        if (mSyncEventNumber==0 && mEffectTime<4.0f) {
+            //fadein and fullscreen rotate
+            tBrightnessSync = mEffectTime/4.0f;
+        } else if (mSyncEventNumber==8 && mEffectTime>12.0f) {
+             //fullscrenn mushroom transform
+             tBrightnessSync = 1.0f-((mEffectTime-12.0f)/3.5f);
+        }
+        
+        if (mSyncEventNumber==0 || mSyncEventNumber==1) {
+             //zoomin from fog
+             mEffectNumber = 3;
+             mEffectTime *= 1.75;
+             float tEffectTimeMax = 9.3f; 
+             if (mEffectTime>=tEffectTimeMax) {
+                 mEffectTime=tEffectTimeMax;
+             }
+        } else if(mSyncEventNumber==2 || mSyncEventNumber==3) {
+             //transform big after zoomin
+             mEffectNumber = 4;
+             mEffectTime *= 0.25f;
+        } else if(mSyncEventNumber==4) {
+             //mandelbrot orbit-trap zoomout
+             mEffectNumber = 1;
+             mEffectTime *= 0.0002f;
+        } else if(mSyncEventNumber==5 || mSyncEventNumber==6) {
+             //inside fractal
+             mEffectNumber = 5;
+             mEffectTime *= 0.02f;
+        } else if(mSyncEventNumber==7) {
+             //spiral orbit-trap
+             mEffectNumber = 0;
+             mEffectTime *= 0.02f;
+        } else if(mSyncEventNumber==8) {
+             //fadeout fractal
+             mEffectNumber = 6;
+             mEffectTime *= 0.364f;
+        }
+         
+        gl.glBindFramebuffer(GL_FRAMEBUFFER, mFrameBufferObjectID);
+        // gl.glViewport(0, 0, drawable.getWidth(), drawable.getHeight());                
+        GLUniformData en = st.getUniform("en");
+        if(mSyncEventNumber==7) {
+             en.setData(2);
+        }
+        if(mSyncEventNumber==4) {
+             en.setData(7);
+        } else {
+             en.setData(0);
+        }
+        st.uniform(gl, en);
+         
+        GLUniformData et = st.getUniform("et");
+        st.uniform(gl, et.setData(9.1f));
+
+        st.uniform(gl, st.getUniform("tm").setData(MMTime_u_ms/40000.0f));
+        st.uniform(gl, st.getUniform("br").setData(tBrightnessSync));
+
+        if(mSyncEventNumber==4 || mSyncEventNumber==7) {
+           //render to fbo only when using julia/mandel orbittrap ...
+           // gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+           gl.glDrawArrays(GL.GL_TRIANGLE_STRIP, 0, 4);        
+        }
+        gl.glBindFramebuffer(GL_FRAMEBUFFER, 0);
+        st.uniform(gl, en.setData(mEffectNumber));
+        st.uniform(gl, et.setData(mEffectTime));
+
+        gl.glEnable(GL_TEXTURE_2D);
+        gl.glBindTexture(GL_TEXTURE_2D, mFrameBufferTextureID);
+
+        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
+        gl.glDrawArrays(GL.GL_TRIANGLE_STRIP, 0, 4);        
+
+        vertices0.enableBuffer(gl, false);
+        texCoords0.enableBuffer(gl, false);         
+        st.useProgram(gl, false);
+
+        //---
+        mFrameCounter++;
+        if (wantsFrameSkip()) {
+            mFrameSkipAverageFramerateTimeEnd = System.nanoTime();
+            double tDesiredFrameRate = (float)getDesiredFramerate();
+            double tSingleFrameTime = 1000000000.0f/tDesiredFrameRate;
+            double tElapsedTime = mFrameSkipAverageFramerateTimeEnd - mFrameSkipAverageFramerateTimeStart;
+            mFrameCounterTargetValue = tElapsedTime/tSingleFrameTime;
+            mFrameCounterDifference = mFrameCounterTargetValue-mFrameCounter;
+            if (mFrameCounterDifference>2) {
+                mFrameCounter+=mFrameCounterDifference;
+                mSkippedFramesCounter+=mFrameCounterDifference;
+            } else if (mFrameCounterDifference<-2) {
+                //hold framecounter advance ...
+                mFrameCounter--;
+            }
+        }
+       
+    }
+
+    public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
+        GL2ES2 gl = drawable.getGL().getGL2ES2();
+        
+        st.useProgram(gl, true);
+        vertices0.seal(false);
+        vertices0.rewind();
+        vertices0.putf(0);     vertices0.putf(height);
+        vertices0.putf(width); vertices0.putf(height);
+        vertices0.putf(0);     vertices0.putf(0);
+        vertices0.putf(width); vertices0.putf(0);
+        vertices0.seal(gl, true);        
+        st.ownAttribute(vertices0, true);
+        vertices0.enableBuffer(gl, false);
+        
+        final FloatBuffer mScreenDimensionV = (FloatBuffer) mScreenDimensionUniform.getBuffer();
+        mScreenDimensionV.put(0, (float) width);
+        mScreenDimensionV.put(1, (float) height);
+        st.uniform(gl, mScreenDimensionUniform);
+
+        st.useProgram(gl, false);
+        gl.glViewport(0, 0, width, height);                
+    }
+
+    public void dispose(GLAutoDrawable inDrawable) {
+        GL2ES2 gl = inDrawable.getGL().getGL2ES2();
+        gl.glDeleteFramebuffers(1, new int[] { mFrameBufferObjectID }, 0);
+        gl.glDeleteTextures(1, new int[] { mFrameBufferTextureID }, 0);
+        st.destroy(gl);
+    }
+
+//    public BaseMusic getBaseMusic() {
+//        return mBaseMusic;
+//    }
+    
+    public void resetFrameCounter() {
+        mFrameCounter = 0;
+    }
+
+//END --- BaseRoutineRuntime ---
+
+    protected int mFrameBufferTextureID;
+    protected int mFrameBufferObjectID;
+    protected int mSyncTime;
+    protected int mSyncEventNumber;
+    protected float mEffectTime;
+    protected int mEffectNumber;
+    protected int mEffectSyncTime;
+
+    protected boolean mSyncEvent_01;
+    protected boolean mSyncEvent_02;
+    protected boolean mSyncEvent_03;
+    protected boolean mSyncEvent_04;
+    protected boolean mSyncEvent_05;
+    protected boolean mSyncEvent_06;
+    protected boolean mSyncEvent_07;
+    protected boolean mSyncEvent_08;
+
+    public void handleSyncEvent(int inMMTime_u_ms) {
+        mSyncTime = inMMTime_u_ms;
+        mSyncEventNumber++;
+        System.out.println("NEW SYNC EVENT! tSyncEventNumber="+mSyncEventNumber+" tSyncTime="+mSyncTime);
+        if (mSyncEventNumber==0 || mSyncEventNumber==2 || mSyncEventNumber==5 || mSyncEventNumber==8) {
+            mEffectSyncTime = inMMTime_u_ms;
+        }
+    }
+
+
+//BEGIN --- main entry point ---
+
+    static {
+        //stg dirty I dont wanna think about any further X-) ...
+        GLProfile.initSingleton(true);
+    }
+
+    public static void main(String args[]) throws Exception {
+        String tRoutineClassName = null;
+        boolean tMultiSampling = false;
+        int tNumberOfSampleBuffers = -1;
+        boolean tAnisotropicFiltering = false;
+        float tAnisotropyLevel = -1.0f;
+        boolean tFrameCapture = false;
+        boolean tFrameSkip = true;
+        int desiredFrameRate = 30;
+        
+        final ElektronenMultiplizierer demo = new ElektronenMultiplizierer(
+                tRoutineClassName,
+                tMultiSampling,tNumberOfSampleBuffers,
+                tAnisotropicFiltering,tAnisotropyLevel,
+                tFrameCapture,
+                tFrameSkip, desiredFrameRate
+        );
+        GLCapabilitiesImmutable caps = demo.getGLCapabilities();
+        
+        GLWindow glWindow = GLWindow.create(caps);
+        glWindow.setSize(640, 480);
+        glWindow.setTitle("Jogamp.org - ElektronenMultiplizierer - GL2ES2/NEWT");   
+        glWindow.addGLEventListener(demo);
+        final Animator animator = new Animator(glWindow);
+        animator.setUpdateFPSFrames(60, System.err);
+        glWindow.addWindowListener(new com.jogamp.newt.event.WindowAdapter() {
+            public void windowDestroyNotify(com.jogamp.newt.event.WindowEvent e) {
+                animator.stop();
+                System.exit(0);
+            }
+        });
+        glWindow.setVisible(true);
+        animator.start();
+    }
+    
+//END --- main entry point ---
+    
+}
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/shader/elektronenmultiplizierer_development.fp b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/shader/elektronenmultiplizierer_development.fp
new file mode 100644
index 000000000..6b89e6670
--- /dev/null
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/shader/elektronenmultiplizierer_development.fp
@@ -0,0 +1,432 @@
+/**
+ * Copyright 2011 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+/**
+ **   __ __|_  ___________________________________________________________________________  ___|__ __
+ **  //    /\                                           _                                  /\    \\  
+ ** //____/  \__     __ _____ _____ _____ _____ _____  | |     __ _____ _____ __        __/  \____\\ 
+ **  \    \  / /  __|  |     |   __|  _  |     |  _  | | |  __|  |     |   __|  |      /\ \  /    /  
+ **   \____\/_/  |  |  |  |  |  |  |     | | | |   __| | | |  |  |  |  |  |  |  |__   "  \_\/____/   
+ **  /\    \     |_____|_____|_____|__|__|_|_|_|__|    | | |_____|_____|_____|_____|  _  /    /\     
+ ** /  \____\                       http://jogamp.org  |_|                              /____/  \    
+ ** \  /   "' _________________________________________________________________________ `"   \  /    
+ **  \/____.                                                                             .____\/     
+ **
+ ** JOGL2 port of my PC 4k intro competition entry for Revision 2011. The shader encapsulates basically 
+ ** two different routines: A sphere-tracing based raymarcher for a single fractal formula and a bitmap
+ ** orbit trap julia+mandelbrot fractal renderer. Additionally an inline-processing analog-distortion
+ ** filter is applied to all rendered fragments to make the overall look more interesting.
+ ** 
+ ** Papers and articles you should be familiar with before trying to understand the code:
+ **
+ ** Distance rendering for fractals: http://www.iquilezles.org/www/articles/distancefractals/distancefractals.htm
+ ** Geometric orbit traps: http://www.iquilezles.org/www/articles/ftrapsgeometric/ftrapsgeometric.htm
+ ** Bitmap orbit traps: http://www.iquilezles.org/www/articles/ftrapsbitmap/ftrapsbitmap.htm
+ ** Ambient occlusion techniques: http://www.iquilezles.org/www/articles/ao/ao.htm
+ ** Sphere tracing: A geometric method for the antialiased ray tracing of implicit surfaces: http://graphics.cs.uiuc.edu/~jch/papers/zeno.pdf
+ ** Rendering fractals with distance estimation function: http://www.iquilezles.org/www/articles/mandelbulb/mandelbulb.htm
+ **
+ ** For an impression how this routine looks like see here: http://www.youtube.com/watch?v=lvC8maVHh8Q
+ ** Original release from the Revision can be found here: http://www.pouet.net/prod.php?which=56860
+ **/
+
+//When I wrote this, only God and I understood what I was doing ...
+// ... now only God knows! X-)
+
+#ifdef GL_ES
+  #define MEDIUMP mediump
+  #define HIGHP highp
+  #define LOWP  lowp
+#else
+  #define MEDIUMP
+  #define HIGHP
+  #define LOWP
+#endif
+
+uniform HIGHP int en;         //effectnumber
+uniform HIGHP float et;       //effecttime
+uniform HIGHP sampler2D fb;   //fbotexture
+uniform HIGHP float br;       //brightness
+uniform HIGHP float tm;       //time
+uniform HIGHP vec2 resolution;//screen resolution/fbo resolution
+ 
+float camerafocallengthdode;
+vec3 camerapositiondode;
+vec2 sizedode;
+vec3 backgroundcolor = vec3(0,0.6,0.46);
+mat3 worldrotationxyz;
+mat3 fractalplanerotationx;
+mat3 fractalplanerotationy;
+mat3 camerarotationdode;
+vec2 oglFragCoord;
+
+//fractal formula used for sphreretracing/distance-estimation
+//dodecahedron serpinski (knighty)
+//http://www.fractalforums.com/index.php?topic=3158.msg16982#msg16982
+//normal vectors for the dodecahedra-siepinski folding planes are:
+//(phi^2, 1, -phi), (-phi, phi^2, 1), (1, -phi, phi^2), (-phi*(1+phi), phi^2-1, 1+phi), (1+phi, -phi*(1+phi), phi^2-1) and x=0, y=0, z=0 planes.
+
+//const pre-calc
+const float phi = 1.618;
+const float _IKVNORM_ = 1.0 / sqrt(pow(phi * (1.0 + phi), 2.0) + pow(phi * phi - 1.0, 2.0) + pow(1.0 + phi, 2.0));
+const float _C1_ = phi * (1.0 + phi) * _IKVNORM_;
+const float _C2_ = (phi * phi - 1.0) * _IKVNORM_;
+const float _1C_ = (1.0 + phi) * _IKVNORM_;
+const vec3 phi3 = vec3(0.5, 0.5 / phi, 0.5 * phi);
+const vec3 c3   = vec3(_C1_, _C2_, _1C_);
+
+vec3 distancefunction(vec3 w) {
+//!P center scale offset ...   
+    vec3 offset;
+    if (en==6) {
+        offset = vec3(0.61,0.1*et,0.99);
+    } else {
+        offset = vec3(0.61,0.0,0.99);
+    } 
+//!P center scale \0/ this is awesome for fadeins !!!
+    float scale = 2.;
+    w *= worldrotationxyz;
+    float d, t;
+    float md = 1000.0, cd = 0.0;
+//!P iterations (8) ... 2x see below
+    for (int i = 0; i < 8; i++) {
+        w *= fractalplanerotationx;
+        w = abs(w);        
+        t = w.x * phi3.z + w.y * phi3.y - w.z * phi3.x;
+        if (t < 0.0) { w += vec3(-2.0, -2.0, 2.0) * t * phi3.zyx; }
+        t = -w.x * phi3.x + w.y * phi3.z + w.z * phi3.y;
+        if (t < 0.0) { w += vec3(2.0, -2.0, -2.0) * t * phi3.xzy; }
+        t = w.x * phi3.y - w.y * phi3.x + w.z * phi3.z;
+        if (t < 0.0) { w += vec3(-2.0, 2.0, -2.0) * t * phi3.yxz; } 
+        t = -w.x * c3.x + w.y * c3.y + w.z * c3.z;
+        if (t < 0.0) { w += vec3(2.0, -2.0, -2.0) * t * c3.xyz; }
+        t = w.x * c3.z - w.y * c3.x + w.z * c3.y;
+        if (t < 0.0) { w += vec3(-2.0, 2.0, -2.0) * t * c3.zxy; }     
+        w *= fractalplanerotationy;
+        w *= scale;
+        w -= offset * (scale - 1.0);
+        //accumulate minimum orbit for coloring ... 
+        d = dot(w, w);
+//!P iterations for coloring (4)        
+        if (i < 4) {
+            md = min(md, d);
+            cd = d;
+        }
+    }
+//!P max iterations (8)        
+    return vec3((length(w) - 2.0) * pow(scale, -8.0), md, cd);
+}
+
+//calculate ray direction fragment coordinates
+vec3 raydirection(vec2 pixel) {
+    vec2 p = (0.5*sizedode-pixel)/vec2(sizedode.x,-sizedode.y);
+//!P aspect ratio of dode
+    p.x *= sizedode.x/sizedode.y;
+//!P vec3 w = vec3(0, 0, 1), vec3 v = vec3(0, 1, 0), vec3 u = vec3(1, 0, 0);   
+    vec3 d = (p.x * vec3(1, 0, 0)+p.y * vec3(0, 1, 0)-camerafocallengthdode * vec3(0, 0, 1));   
+    return normalize(camerarotationdode * d);
+}
+
+//iq's fake ambient occlusion
+//http://www.iquilezles.org/www/material/nvscene2008/rwwtt.pdf
+//http://www.iquilezles.org/www/articles/ao/ao.htm
+float ambientocclusion(vec3 p, vec3 n, float eps) {
+    float o = 1.0;
+//!P ao spread (10.6)
+//   spreads the output color intensity 
+    eps *= 10.6;
+//!P ao intensity (0.16)
+    float k = 0.16 / eps;
+    //add little start distance to the surface
+    float d = 2.0 * eps;
+//!P ao iterations (5) ...    
+    for (int i = 0; i < 5; ++i) {
+        o -= (d - distancefunction(p + n * d).x) * k;
+        d += eps;
+        //fade ao when distance to the surface increases
+        k *= 0.5;
+    }
+    return clamp(o, 0.0, 1.0);
+}
+
+vec4 render(vec2 pixel) {
+    vec3  ray_direction = raydirection(pixel);
+//!P minimum ray length (6e-5)    
+    float ray_length = 6e-5;
+    vec3  ray = camerapositiondode + ray_length * ray_direction;
+//!P minimum epsilon (6e-7) ...
+    float eps = 6e-7;
+    vec3  dist;
+    vec3  normal = vec3(0);
+    int   steps = 0;
+    bool  hit = false;
+    float minmarch = 0.0;
+//!P maxmarch = 10000.0;
+    float maxmarch = 25.0;
+//!P field of view scale = (1.0 / sqrt(1.0 + camerafocallengthdode * camerafocallengthdode))   
+//!P detail of surface approximation =  1.22
+//!P pixelscale = (1.0 / min(sizedode.x, sizedode.y))
+    float epsfactor = 2.0 * (1.0 / sqrt(1.0 + camerafocallengthdode * camerafocallengthdode)) * (1.0 / min(sizedode.x, sizedode.y)) * 1.22;    
+    ray_length = minmarch;
+    ray = camerapositiondode + ray_length * ray_direction;
+//!P max number of raymarching steps (90);
+    for (int i = 0; i < 90; i++) {
+        steps = i;
+        dist = distancefunction(ray);
+//!P X-) questionable surface smoothing (0.53)            
+        dist.x *= 0.53;            
+        //backtrack previous step and check if it was only a "fussel"
+        if (hit && dist.x < eps || ray_length > maxmarch || ray_length < minmarch) {
+            steps--;
+            break;
+         }
+         hit = false;
+         ray_length += dist.x;
+         ray = camerapositiondode + ray_length * ray_direction;
+         eps = ray_length * epsfactor;
+         if (dist.x < eps || ray_length < minmarch) {
+             hit = true;
+         }
+    }
+    //\0/ there is a hit!
+    vec4 color = vec4(backgroundcolor,0.5);
+    if (hit) {
+        float aof = 1.0;
+        if (steps < 1 || ray_length < minmarch) {
+            normal = normalize(ray);
+        } else {
+            //gradient in x,y and z direction for intersection point 
+            //!P minimum normal (1.5e-7)
+            float e = max(eps * 0.5, 1.5e-7);
+            normal = normalize(vec3(
+                distancefunction(ray + vec3(e, 0, 0)).x - distancefunction(ray - vec3(e, 0, 0)).x, 
+                distancefunction(ray + vec3(0, e, 0)).x - distancefunction(ray - vec3(0, e, 0)).x, 
+                distancefunction(ray + vec3(0, 0, e)).x - distancefunction(ray - vec3(0, 0, e)).x
+            ));
+            aof = ambientocclusion(ray, normal, eps);
+        }        
+//!P hardcoded light position vec3(-50,150,-25)
+        float diffuse = max(dot(normal, normalize(vec3(-50,150,-25) - ray)), 0.0);
+//blinn/phong specular stuff ...
+//!P specular exponent (4)
+//!P specularity (0.8)
+//!P diffuse color vec3(0.45) 2x in one line ...
+//!P ambient color vec2 ambientcolor = vec2(0.5,0.3)
+        color.rgb = (mix(vec3(0.5), backgroundcolor, 0.3) * vec3(0.45) + vec3(0.45) * diffuse + pow(diffuse, 4.) * 0.8)*aof;
+        color.a = 1.0;
+    }  
+//!P fog factor = 0.01   
+    color.rgb = mix(backgroundcolor, color.rgb, exp(-pow(ray_length, 2.0) * 0.01));
+    return color;
+}
+
+mat3 xmatrixrotation(float angle) {
+    return mat3(
+        vec3(1.0,         0.0,        0.0),
+        vec3(0.0,  cos(angle), sin(angle)),
+        vec3(0.0, -sin(angle), cos(angle))
+    );
+}
+
+mat3 ymatrixrotation(float angle) {
+    return mat3(
+        vec3(cos(angle), 0.0, -sin(angle)),
+        vec3(       0.0, 1.0,         0.0),
+        vec3(sin(angle), 0.0,  cos(angle))
+    );
+}
+
+vec4 raymarch_orbittrap_image(vec2 fragcoord) {    
+    //do the matrix calculations by hand X-)
+    //as mat4 constructor and arithmetic assignments are 
+    //currently broken (2010-09-21) on ATI cards i found
+    //a workaround using vec4 constructors wich works on
+    //both NVIDIA+ATI --- MAGIC. DO NOT TOUCH! -=#:-)     
+    mat3  identitymatrix = mat3(1,0,0,0,1,0,0,0,1);    
+    float sin_phi = sin(0.1*tm);
+    float cos_phi = cos(0.1*tm);
+    mat3 zrot = mat3(
+        vec3( cos_phi, sin_phi, 0.0),
+        vec3(-sin_phi, cos_phi, 0.0),
+        vec3(     0.0,     0.0, 1.0)
+    );
+    vec2 position;
+    float fractalplanex_var;
+    float fractalplaney_var;
+    position = oglFragCoord.xy;
+    camerafocallengthdode = 1.0;      
+    if (en==2) {
+        sizedode = vec2(384,384);        
+        camerapositiondode = vec3(0.0,0.0,-2.7);
+    } else if (en==3) {
+        camerapositiondode = vec3(0.0,0.0,-2.7*(10.-et));
+    } else if (en==4) {
+        camerapositiondode = vec3(0.0,0.0,-2.7*(10.-9.3));
+        fractalplanex_var = et;
+        fractalplaney_var = 0.0;
+    } else if (en==5) {
+        //inside effect
+        camerapositiondode = vec3(0.0,0.0,-0.05);
+        fractalplanex_var = 1.06;
+        fractalplaney_var = -1.0-et;          
+    } else if (en==6) {
+        camerapositiondode = vec3(0.0,0.0,-2.7*(10.-9.5));
+        fractalplanex_var = et;
+        fractalplaney_var = sin(et*0.03)-1.0;   
+    } else if (en==7) {
+        sizedode = vec2(384,384);        
+        fractalplanex_var = et;
+        fractalplaney_var = sin(et*0.93)-1.0;
+        camerapositiondode = vec3(0.0,0.0,-2.7);
+    } 
+    worldrotationxyz = xmatrixrotation(0.1*tm)*ymatrixrotation(0.1*tm)*zrot*identitymatrix;
+    fractalplanerotationx = xmatrixrotation(fractalplanex_var)*identitymatrix;
+    fractalplanerotationy = xmatrixrotation(fractalplaney_var)*identitymatrix;
+    camerarotationdode = ymatrixrotation(3.14)*identitymatrix;                             
+    vec4 color = render(position);
+    return color;
+}
+
+//----------------------------------------------------------------------------------------------------------
+
+vec4 orbitmapping(vec4 c, vec2 w) {
+//!P orbit trap scale and offset    
+    vec2 orbittrapoffset = vec2(0.24,-0.24);
+    float orbittrapscale;
+    if (en==0) {
+        //julia set ...
+        orbittrapscale = 0.625;
+    } else {
+        //mandlebrot ...
+        orbittrapscale = 0.325;
+    }
+    vec2 sp = 0.5 + (w / orbittrapscale - orbittrapoffset);    
+    vec4 s = texture2D(fb, sp);
+    if (s.a > 0.0) {
+        c = mix(c, s, s.a);
+    }
+    return c;
+}
+
+vec4 orbittrap(vec2 z) {
+    float powerjulia = 2.;
+    vec3  colorjulia = vec3(1.0);
+    vec4  color = vec4(colorjulia, 0.0);
+    float n = 0.0;
+    vec2 c;
+    if (en==0) {    
+        //julia mode ...
+//!P use offset-julia from 2.25 to 2.5
+        c = vec2(sin(et+2.07)*0.05,cos(et+2.07));
+    } else {
+        //mandelbrot mode ...
+        c = z;
+    }
+//!P max iterations for julia (128) ... 2x parameter - see below!     
+    for (int i = 0; i<128; i++) {
+        n += 1.0;        
+        float r = pow(length(z), powerjulia);
+        float a = powerjulia * atan(z.y, z.x);
+        z = vec2(cos(a) * r, sin(a) * r) +c;
+//!P min iterations for julia (1.0) ...         
+        if (n >= 1.0) {
+            color = orbitmapping(color, z);
+//!P orbit trap alpha precision (0.6) ...
+            if (color.a >= 0.6) {
+                break;
+            }
+        }
+    }
+//!P max iterations for julia (128.0) ...
+    float blend = clamp(1.0 - (n / 128.0) * 2.0, 0.0, 1.0);
+    color.rgb = mix(colorjulia, color.rgb, blend);
+    return color;
+}
+
+void main() {
+    vec2 sizejulia = resolution;
+    sizedode = sizejulia;
+    oglFragCoord = gl_FragCoord.xy;
+    vec4 color;
+    if (en==0 || en==1) {
+        //render 2d julia/mandelbrot
+//!P camera position for julia ...
+        vec3 camerapositionjulia;
+        if (en==0) {
+            //julia
+            camerapositionjulia = vec3(-0.2,-0.515,0.095347+(et*1.75));
+        } else {
+            //mandelbrot
+            camerapositionjulia = vec3(0.325895,0.049551,0.0005+et);
+        }
+//!P absolute output size of julia orbit trap ...
+        vec2  z = ((oglFragCoord.xy - (sizejulia * 0.5)) / sizejulia) *
+                    vec2(sizejulia.x/sizejulia.y, 1.0) * //aspect ratio 
+                         camerapositionjulia.z + 
+                         camerapositionjulia.xy;
+        color = orbittrap(z);
+    } else {
+        color = raymarch_orbittrap_image(oglFragCoord.xy);
+    } 
+    if (en==2 || en==7) {
+        gl_FragColor = color;
+    } else {
+        //do normal rendering ...    
+        //analog-tv distortion ...
+        vec2 position = oglFragCoord.xy / sizejulia.xy;
+        position.y *=-1.0;
+        vec3 color_tv = color.rgb;
+        //contrast
+        color_tv = clamp(color_tv*0.5+0.5*color_tv*color_tv*1.2,0.0,1.0);
+        //circular vignette fade
+        color_tv *= 0.5 + 0.5*16.0*position.x*position.y*(1.0-position.x)*(-1.0-position.y);                
+        //color shift
+        if (en==0 || en==3) {
+            color_tv *= vec3(0.8,1.0,0.7); //green
+        }
+        if (en==1 || en==4) {
+            color_tv *= vec3(0.95,0.85,1.0); //blue
+        }
+        if (en==5) {
+            color_tv *= vec3(1.0,0.7,1.0); //purple
+        }
+        
+        if (en==6) {
+            color_tv *= vec3(0.7,1.0,1.0); //cyan
+        }        
+        if (en==2) {
+            color_tv *= vec3(1.0,1.0,0.7); //yellow
+        }
+        //tvlines effect
+        color_tv *= 0.9+0.1*sin(1.5*tm+position.y*1000.0);
+        //tv flicker effect
+        color_tv *= 0.97+0.13*sin(2.5*tm);
+        color_tv *= br;
+        gl_FragColor = vec4(color_tv,1.0);
+    }       
+}
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/shader/elektronenmultiplizierer_port.fp b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/shader/elektronenmultiplizierer_port.fp
new file mode 100644
index 000000000..fdd159616
--- /dev/null
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/shader/elektronenmultiplizierer_port.fp
@@ -0,0 +1,280 @@
+/**
+ * Copyright 2011 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+/**
+ **   __ __|_  ___________________________________________________________________________  ___|__ __
+ **  //    /\                                           _                                  /\    \\  
+ ** //____/  \__     __ _____ _____ _____ _____ _____  | |     __ _____ _____ __        __/  \____\\ 
+ **  \    \  / /  __|  |     |   __|  _  |     |  _  | | |  __|  |     |   __|  |      /\ \  /    /  
+ **   \____\/_/  |  |  |  |  |  |  |     | | | |   __| | | |  |  |  |  |  |  |  |__   "  \_\/____/   
+ **  /\    \     |_____|_____|_____|__|__|_|_|_|__|    | | |_____|_____|_____|_____|  _  /    /\     
+ ** /  \____\                       http://jogamp.org  |_|                              /____/  \    
+ ** \  /   "' _________________________________________________________________________ `"   \  /    
+ **  \/____.                                                                             .____\/     
+ **
+ ** JOGL2 port of my PC 4k intro competition entry for Revision 2011. The shader encapsulates basically 
+ ** two different routines: A sphere-tracing based raymarcher for a single fractal formula and a bitmap
+ ** orbit trap julia+mandelbrot fractal renderer. Additionally an inline-processing analog-distortion
+ ** filter is applied to all rendered fragments to make the overall look more interesting.
+ ** 
+ ** Papers and articles you should be familiar with before trying to understand the code:
+ **
+ ** Distance rendering for fractals: http://www.iquilezles.org/www/articles/distancefractals/distancefractals.htm
+ ** Geometric orbit traps: http://www.iquilezles.org/www/articles/ftrapsgeometric/ftrapsgeometric.htm
+ ** Bitmap orbit traps: http://www.iquilezles.org/www/articles/ftrapsbitmap/ftrapsbitmap.htm
+ ** Ambient occlusion techniques: http://www.iquilezles.org/www/articles/ao/ao.htm
+ ** Sphere tracing: A geometric method for the antialiased ray tracing of implicit surfaces: http://graphics.cs.uiuc.edu/~jch/papers/zeno.pdf
+ ** Rendering fractals with distance estimation function: http://www.iquilezles.org/www/articles/mandelbulb/mandelbulb.htm
+ **
+ ** For an impression how this routine looks like see here: http://www.youtube.com/watch?v=lvC8maVHh8Q
+ ** Original release from the Revision can be found here: http://www.pouet.net/prod.php?which=56860
+ **/
+
+//When I wrote this, only God and I understood what I was doing ...
+// ... now only God knows! X-)
+
+uniform int en;
+uniform float et;
+uniform sampler2D fb;
+uniform float br,tm;
+uniform vec2 resolution;
+float v;
+vec3 n;
+vec2 e;
+vec3 f=vec3(0,.6,.46);
+mat3 i,m,r,y;
+vec2 c;
+const float x=1.618,t=1./sqrt(pow(x*(1.+x),2.)+pow(x*x-1.,2.)+pow(1.+x,2.)),z=x*(1.+x)*t,s=(x*x-1.)*t,w=(1.+x)*t;
+const vec3 a=vec3(.5,.5/x,.5*x),p=vec3(z,s,w);
+vec3 l(vec3 v) {
+    vec3 n;
+    if(en==6)
+        n=vec3(.61,.1*et,.99);
+    else
+      n=vec3(.61,0.,.99);
+    float e=2.;
+    v*=i;
+    float f,x,c=1000.,y=0.;
+    for(int z=0;z<8;z++) {
+        v*=m;
+        v=abs(v);
+        x=v.x*a.z+v.y*a.y-v.z*a.x;
+        if(x<0.)
+            v+=vec3(-2.,-2.,2.)*x*a.zyx;
+        x=-v.x*a.x+v.y*a.z+v.z*a.y;
+        if(x<0.)
+            v+=vec3(2.,-2.,-2.)*x*a.xzy;
+        x=v.x*a.y-v.y*a.x+v.z*a.z;
+        if(x<0.)
+            v+=vec3(-2.,2.,-2.)*x*a.yxz;
+        x=-v.x*p.x+v.y*p.y+v.z*p.z;
+        if(x<0.)
+            v+=vec3(2.,-2.,-2.)*x*p.xyz;
+        x=v.x*p.z-v.y*p.x+v.z*p.y;
+        if(x<0.)
+            v+=vec3(-2.,2.,-2.)*x*p.zxy;
+        v*=r;
+        v*=e;
+        v-=n*(e-1.);
+        f=dot(v,v);
+        if(z<4)
+            c=min(c,f),y=f;
+    }
+    return vec3((length(v)-2.)*pow(e,-8.),c,y);
+}
+vec3 b(vec2 x) {
+    vec2 n=(.5*e-x)/vec2(e.x,-e.y);
+    n.x*=e.x/e.y;
+    vec3 a=n.x*vec3(1,0,0)+n.y*vec3(0,1,0)-v*vec3(0,0,1);
+    return normalize(y*a);
+}
+float b(vec3 e,vec3 x,float v) {
+    float n=1.;
+    v*=10.6;
+    float t=.16/v,y=2.*v;
+    for(int i=0;i<5;++i)
+        n-=(y-l(e+x*y).x)*t,y+=v,t*=.5;
+    return clamp(n,0.,1.);
+}
+vec4 h(vec2 x) {
+    vec3 a=b(x);
+    float i=6e-05;
+    vec3 y=n+i*a;
+    float c=6e-07;
+    vec3 m,z=vec3(0);
+    int r=0;
+    bool t=false;
+    float s=0.,w=25.,p=2.*(1./sqrt(1.+v*v))*(1./min(e.x,e.y))*1.22;
+    i=s;
+    y=n+i*a;
+    for(int g=0;g<90;g++) {
+        r=g;
+        m=l(y);
+        m.x*=.53;
+        if(t&&m.x<c||i>w||i<s) {
+            r--;
+            break;
+        }
+        t=false;
+        i+=m.x;
+        y=n+i*a;
+        c=i*p;
+        if(m.x<c||i<s)
+            t=true;
+    }
+    vec4 g=vec4(f,.5);
+    if(t) {
+        float d=1.;
+        if(r<1||i<s)
+            z=normalize(y);
+        else {
+            float h=max(c*.5,1.5e-07);
+            z=normalize(vec3(l(y+vec3(h,0,0)).x-l(y-vec3(h,0,0)).x,l(y+vec3(0,h,0)).x-l(y-vec3(0,h,0)).x,l(y+vec3(0,0,h)).x-l(y-vec3(0,0,h)).x));
+            d=b(y,z,c);
+        }
+        float h=max(dot(z,normalize(vec3(-66,162,-30)-y)),0.);
+        g.xyz=(mix(vec3(.5),f,.3)*vec3(.45)+vec3(.45)*h+pow(h,4.)*.8)*d;
+        g.w=1.;
+    }
+    g.xyz=mix(f,g.xyz,exp(-pow(i,2.)*.01));
+    return g;
+}
+mat3 g(float e) {
+    return mat3(vec3(1.,0.,0.),vec3(0.,cos(e),sin(e)),vec3(0.,-sin(e),cos(e)));
+}
+mat3 d(float e) {
+    return mat3(vec3(cos(e),0.,-sin(e)),vec3(0.,1.,0.),vec3(sin(e),0.,cos(e)));
+}
+vec4 D(vec2 x) {
+    mat3 a=mat3(1,0,0,0,1,0,0,0,1);
+    float t=sin(.1*tm),z=cos(.1*tm);
+    mat3 p=mat3(vec3(z,t,0.),vec3(-t,z,0.),vec3(0.,0.,1.));
+    vec2 f;
+    float s,w;
+    f=c.xy;
+    v=1.;
+    if(en==2)
+        e=vec2(384,384),n=vec3(0.,0.,-2.7);
+    if(en==3)
+        n=vec3(0.,0.,-2.7*(10.-et));
+    if(en==4)
+        n=vec3(0.,0.,-1.89),s=et,w=0.;
+    if(en==5)
+        n=vec3(0.,0.,-.05),s=1.06,w=-1.-et;
+    if(en==6)
+        n=vec3(0.,0.,-1.35),s=et,w=sin(et*.03)-1.;
+    if(en==7)
+        e=vec2(384,384),s=et,w=sin(et*.93)-1.,n=vec3(0.,0.,-2.7);
+    i=g(.1*tm)*d(.1*tm)*p*a;
+    m=g(s)*a;
+    r=g(w)*a;
+    y=d(3.14)*a;
+    vec4 l=h(f);
+    if(l.w<.00392) {
+        discard;
+    }
+    return l;
+}
+vec4 D(vec4 e,vec2 x) {
+    vec2 n=vec2(.24,-.24);
+    float y;
+    if(en==0)
+        y=.625;
+    else
+     y=.325;
+    vec2 v=.5+(x/y-n);
+    vec4 c=texture2D(fb,v);
+    if(c.w>0.)
+        e=mix(e,c,c.w);
+    return e;
+}
+vec4 o(vec2 v) {
+    float n=2.;
+    vec3 e=vec3(1.);
+    vec4 i=vec4(e,0.);
+    float y=0.;
+    vec2 x;
+    if(en==0)
+        x=vec2(sin(et+2.07)*.05,cos(et+2.07));
+    else
+        x=v;
+    for(int f=0;f<128;f++) {
+        y+=1.;
+        float t=pow(length(v),n),c=n*atan(v.y,v.x);
+        v=vec2(cos(c)*t,sin(c)*t)+x;
+        if(y>=1.) {
+            i=D(i,v);
+            if(i.w>=.6) {
+                break;
+            }
+        }
+    }
+    float c=clamp(1.-y/128.*2.,0.,1.);
+    i.xyz=mix(e,i.xyz,c);
+    return i;
+}
+void main() {
+    //vec2 v=vec2(640.0,480.0);
+    vec2 v =resolution;
+    e=v;
+    c=gl_FragCoord.xy;
+    vec4 n;
+    if(en==0||en==1) {
+        vec3 a;
+        if(en==0)
+            a=vec3(-.2,-.515,.095347+et*1.75);
+        else
+            a=vec3(.325895,.049551,.0005+et);
+        vec2 x=(c.xy-v*.5)/v*vec2(v.x/v.y,1.)*a.z+a.xy;
+        n=o(x);
+    } else
+        n=D(c.xy);
+    if(en==2||en==7)
+        gl_FragColor=n;
+    else {
+        vec2 i=c.xy/v.xy;
+        i.y*=-1.;
+        vec3 x=n.xyz;
+        x=clamp(x*.5+.5*x*x*1.2,0.,1.);
+        x*=.5+8.*i.x*i.y*(1.-i.x)*(-1.-i.y);
+        if(en==0||en==3)
+            x*=vec3(.8,1.,.7);
+        if(en==1||en==4)
+            x*=vec3(.95,.85,1.);
+        if(en==5)
+            x*=vec3(1.,.7,1.);
+        if(en==6)
+            x*=vec3(.7,1.,1.);
+        if(en==2)
+            x*=vec3(1.,1.,.7);
+        x*=.9+.1*sin(1.5*tm+i.y*1000.);
+        x*=.97+.13*sin(2.5*tm);
+        x*=br;
+        gl_FragColor=vec4(x,1.);
+    }
+}