- add GLSL editor to SDK by default

git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@8421 75d07b2b-3a1a-0410-a2c5-0572b91ccdca

sdk/jme3-glsl-support/build.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- You may freely edit this file. See harness/README in the NetBeans platform -->
+<!-- for some information on what you could do (e.g. targets to override). -->
+<!-- If you delete this file and reopen the project it will be recreated. -->
+<project name="net.java.nboglpack.glsleditor" default="netbeans" basedir=".">
+    <description>Builds, tests, and runs the project net.java.nboglpack.glsleditor.</description>
+    <!--property file="./../nbproject/global.properties"/>
+    <property file="./../nbproject/private/global_private.properties"/-->
+    <import file="nbproject/build-impl.xml"/>
+</project>

sdk/jme3-glsl-support/license.txt

@@ -0,0 +1,27 @@
+Copyright (c) 2007, Michael Bien, Mathias Henze
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * 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.
+    * Neither the name of the organization nor the names of its contributors may
+      be used to endorse or promote products derived from this software without
+      specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"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 THE COPYRIGHT OWNER 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.

sdk/jme3-glsl-support/manifest.mf

@@ -0,0 +1,15 @@
+Manifest-Version: 1.0
+OpenIDE-Module: net.java.nboglpack.glsleditor
+OpenIDE-Module-Implementation-Version: 0
+OpenIDE-Module-Layer: net/java/nboglpack/glsleditor/layer.xml
+OpenIDE-Module-Localizing-Bundle: net/java/nboglpack/glsleditor/Bundle.properties
+
+Name: net/java/nboglpack/glsleditor/dataobject/GlslGeometryShaderDataLoader.class
+OpenIDE-Module-Class: Loader
+
+Name: net/java/nboglpack/glsleditor/dataobject/GlslFragmentShaderDataLoader.class
+OpenIDE-Module-Class: Loader
+
+Name: net/java/nboglpack/glsleditor/dataobject/GlslVertexShaderDataLoader.class
+OpenIDE-Module-Class: Loader
+

sdk/jme3-glsl-support/nbproject/build-impl.xml

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+*** GENERATED FROM project.xml - DO NOT EDIT  ***
+***         EDIT ../build.xml INSTEAD         ***
+-->
+<project name="net.java.nboglpack.glsleditor-impl" basedir="..">
+    <fail message="Please build using Ant 1.7.1 or higher.">
+        <condition>
+            <not>
+                <antversion atleast="1.7.1"/>
+            </not>
+        </condition>
+    </fail>
+    <property file="nbproject/private/suite-private.properties"/>
+    <property file="nbproject/suite.properties"/>
+    <fail unless="suite.dir">You must set 'suite.dir' to point to your containing module suite</fail>
+    <property file="${suite.dir}/nbproject/private/platform-private.properties"/>
+    <property file="${suite.dir}/nbproject/platform.properties"/>
+    <macrodef name="property" uri="http://www.netbeans.org/ns/nb-module-project/2">
+        <attribute name="name"/>
+        <attribute name="value"/>
+        <sequential>
+            <property name="@{name}" value="${@{value}}"/>
+        </sequential>
+    </macrodef>
+    <macrodef name="evalprops" uri="http://www.netbeans.org/ns/nb-module-project/2">
+        <attribute name="property"/>
+        <attribute name="value"/>
+        <sequential>
+            <property name="@{property}" value="@{value}"/>
+        </sequential>
+    </macrodef>
+    <property file="${user.properties.file}"/>
+    <nbmproject2:property name="harness.dir" value="nbplatform.${nbplatform.active}.harness.dir" xmlns:nbmproject2="http://www.netbeans.org/ns/nb-module-project/2"/>
+    <nbmproject2:property name="nbplatform.active.dir" value="nbplatform.${nbplatform.active}.netbeans.dest.dir" xmlns:nbmproject2="http://www.netbeans.org/ns/nb-module-project/2"/>
+    <nbmproject2:evalprops property="cluster.path.evaluated" value="${cluster.path}" xmlns:nbmproject2="http://www.netbeans.org/ns/nb-module-project/2"/>
+    <fail message="Path to 'platform' cluster missing in $${cluster.path} property or using corrupt Netbeans Platform (missing harness).">
+        <condition>
+            <not>
+                <contains string="${cluster.path.evaluated}" substring="platform"/>
+            </not>
+        </condition>
+    </fail>
+    <import file="${harness.dir}/build.xml"/>
+</project>

sdk/jme3-glsl-support/nbproject/genfiles.properties

@@ -0,0 +1,8 @@
+build.xml.data.CRC32=a85cd232
+build.xml.script.CRC32=bcb3cbef
+build.xml.stylesheet.CRC32=79c3b980
+# This file is used by a NetBeans-based IDE to track changes in generated files such as build-impl.xml.
+# Do not edit this file. You may delete it but then the IDE will never regenerate such files for you.
+nbproject/build-impl.xml.data.CRC32=7f5f482a
+nbproject/build-impl.xml.script.CRC32=d103b190
+nbproject/build-impl.xml.stylesheet.CRC32=238281d1@1.46.2

sdk/jme3-glsl-support/nbproject/project.properties

@@ -0,0 +1,6 @@
+javac.compilerargs=-Xlint -Xlint:-serial
+javac.source=1.5
+license.file=license.txt
+nbm.homepage=http://kenai.com/projects/netbeans-opengl-pack
+nbm.module.author=Mathias Henze, Michael Bien
+spec.version.base=3.0.0

sdk/jme3-glsl-support/nbproject/project.xml

@@ -0,0 +1,103 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://www.netbeans.org/ns/project/1">
+    <type>org.netbeans.modules.apisupport.project</type>
+    <configuration>
+        <data xmlns="http://www.netbeans.org/ns/nb-module-project/3">
+            <code-name-base>net.java.nboglpack.glsleditor</code-name-base>
+            <suite-component/>
+            <module-dependencies>
+                <dependency>
+                    <code-name-base>org.netbeans.modules.editor.completion</code-name-base>
+                    <build-prerequisite/>
+                    <compile-dependency/>
+                    <run-dependency>
+                        <release-version>1</release-version>
+                        <specification-version>1.13.2</specification-version>
+                    </run-dependency>
+                </dependency>
+                <dependency>
+                    <code-name-base>org.netbeans.modules.editor.lib</code-name-base>
+                    <build-prerequisite/>
+                    <compile-dependency/>
+                    <run-dependency>
+                        <release-version>3</release-version>
+                        <specification-version>2.0</specification-version>
+                    </run-dependency>
+                </dependency>
+                <dependency>
+                    <code-name-base>org.netbeans.modules.languages</code-name-base>
+                    <build-prerequisite/>
+                    <compile-dependency/>
+                    <run-dependency>
+                        <release-version>0-1</release-version>
+                        <specification-version>1.84.0.1</specification-version>
+                    </run-dependency>
+                </dependency>
+                <dependency>
+                    <code-name-base>org.netbeans.modules.lexer</code-name-base>
+                    <build-prerequisite/>
+                    <compile-dependency/>
+                    <run-dependency>
+                        <release-version>2</release-version>
+                        <specification-version>1.20.0.1</specification-version>
+                    </run-dependency>
+                </dependency>
+                <dependency>
+                    <code-name-base>org.openide.filesystems</code-name-base>
+                    <build-prerequisite/>
+                    <compile-dependency/>
+                    <run-dependency>
+                        <specification-version>6.4.1</specification-version>
+                    </run-dependency>
+                </dependency>
+                <dependency>
+                    <code-name-base>org.openide.loaders</code-name-base>
+                    <build-prerequisite/>
+                    <compile-dependency/>
+                    <run-dependency>
+                        <specification-version>5.9.1</specification-version>
+                    </run-dependency>
+                </dependency>
+                <dependency>
+                    <code-name-base>org.openide.nodes</code-name-base>
+                    <build-prerequisite/>
+                    <compile-dependency/>
+                    <run-dependency>
+                        <specification-version>6.7.1</specification-version>
+                    </run-dependency>
+                </dependency>
+                <dependency>
+                    <code-name-base>org.openide.text</code-name-base>
+                    <build-prerequisite/>
+                    <compile-dependency/>
+                    <run-dependency>
+                        <specification-version>6.21.2</specification-version>
+                    </run-dependency>
+                </dependency>
+                <dependency>
+                    <code-name-base>org.openide.util</code-name-base>
+                    <build-prerequisite/>
+                    <compile-dependency/>
+                    <run-dependency>
+                        <specification-version>6.8.1</specification-version>
+                    </run-dependency>
+                </dependency>
+                <dependency>
+                    <code-name-base>org.openide.windows</code-name-base>
+                    <build-prerequisite/>
+                    <compile-dependency/>
+                    <run-dependency>
+                        <specification-version>6.16</specification-version>
+                    </run-dependency>
+                </dependency>
+            </module-dependencies>
+            <public-packages>
+                <package>net.java.nboglpack.glsleditor</package>
+                <package>net.java.nboglpack.glsleditor.dataobject</package>
+                <package>net.java.nboglpack.glsleditor.glsl</package>
+                <package>net.java.nboglpack.glsleditor.lexer</package>
+                <package>net.java.nboglpack.glsleditor.vocabulary</package>
+            </public-packages>
+        </data>
+    </configuration>
+</project>

sdk/jme3-glsl-support/nbproject/suite.properties

@@ -0,0 +1 @@
+suite.dir=${basedir}/..

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/Bundle.properties

@@ -0,0 +1,28 @@
+OpenIDE-Module-Display-Category=jMonkeyEngine
+OpenIDE-Module-Long-Description=\
+    Provides syntax highlighting and code completion with documentation for jME3 GLSL shader files.
+OpenIDE-Module-Name=GLSL Editor
+OpenIDE-Module-Short-Description=Editor for jME3 shader files
+
+text/x-glsl-fragment-shader=GLSL Fragment Shader
+text/x-glsl-vertex-shader=GLSL Vertex Shader
+text/x-glsl-geometry-shader=GLSL Geometry Shader
+
+#Layer.xml entries for fonts & colors in Options window:
+NetBeans=NetBeans
+glsl-keyword=Keyword
+glsl-name=Name
+glsl-brace=Brace
+glsl-value=Value
+glsl-curly-brace=Curly brace
+glsl-string-value=String value
+glsl-comment=Comment
+glsl-ml-comment=Multiline comment
+glsl-separator=Separator
+glsl-function=Function
+glsl-whitespace=Whitespace
+glsl-end-of-line=EOL
+glsl-build-in-var=Build in variable
+glsl-build-in-func=Build in function
+glsl-preprocessor=Preprocessor directive
+

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/GlslCompletionProvider.java

@@ -0,0 +1,327 @@
+package net.java.nboglpack.glsleditor;
+
+import java.util.Map.Entry;
+import java.util.Set;
+import org.netbeans.api.editor.completion.Completion;
+import org.openide.ErrorManager;
+import org.netbeans.editor.BaseDocument;
+import org.netbeans.spi.editor.completion.CompletionDocumentation;
+import org.netbeans.spi.editor.completion.CompletionItem;
+import org.netbeans.spi.editor.completion.CompletionProvider;
+import org.netbeans.spi.editor.completion.CompletionResultSet;
+import org.netbeans.spi.editor.completion.CompletionTask;
+import org.netbeans.spi.editor.completion.support.AsyncCompletionQuery;
+import org.netbeans.spi.editor.completion.support.AsyncCompletionTask;
+import javax.swing.Action;
+import javax.swing.text.BadLocationException;
+import javax.swing.text.Document;
+import javax.swing.text.Element;
+import javax.swing.text.JTextComponent;
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Graphics;
+import java.awt.event.KeyEvent;
+import java.net.URL;
+import java.util.Iterator;
+import java.util.Map;
+import net.java.nboglpack.glsleditor.dataobject.GlslFragmentShaderDataLoader;
+import net.java.nboglpack.glsleditor.dataobject.GlslGeometryShaderDataLoader;
+import net.java.nboglpack.glsleditor.dataobject.GlslVertexShaderDataLoader;
+import net.java.nboglpack.glsleditor.glsl.Glsl;
+import net.java.nboglpack.glsleditor.vocabulary.GLSLElementDescriptor;
+import org.netbeans.spi.editor.completion.support.CompletionUtilities;
+
+
+/**
+ * Completion provider for the OpenGL Shading Language editor.
+ *
+ * @author Mathias Henze
+ * @author Michael Bien
+ */
+public class GlslCompletionProvider implements CompletionProvider {
+
+    private static final ErrorManager LOGGER = ErrorManager.getDefault().getInstance(GlslCompletionProvider.class.getName());
+
+    private final String mimeType;
+    
+    private GlslCompletionProvider(String mimeType) {
+        this.mimeType = mimeType;
+    }
+
+    public CompletionTask createTask(int queryType, JTextComponent component) {
+        return new AsyncCompletionTask(new GlslCompletionQuery(mimeType), component);
+    }
+
+    public int getAutoQueryTypes(JTextComponent component, String typedText) {
+        return 0;
+    }
+    
+    public static GlslCompletionProvider createVSCompletionProvider(){
+        return new GlslCompletionProvider(GlslVertexShaderDataLoader.REQUIRED_MIME);
+    }
+    
+    public static GlslCompletionProvider createGSCompletionProvider(){
+        return new GlslCompletionProvider(GlslGeometryShaderDataLoader.REQUIRED_MIME);
+    }
+    
+    public static GlslCompletionProvider createFSCompletionProvider(){
+        return new GlslCompletionProvider(GlslFragmentShaderDataLoader.REQUIRED_MIME);
+    }
+
+    
+    private static class GlslCompletionQuery extends AsyncCompletionQuery {
+
+        private GlslVocabularyManager vocabulary;
+
+        public GlslCompletionQuery(String mimetype) {
+            vocabulary = GlslVocabularyManager.getInstance(mimetype);
+        }
+
+        protected void query(CompletionResultSet completionResultSet, Document document, int pos) {
+            
+            fillResultset(completionResultSet, document, pos);
+            completionResultSet.finish();
+        }
+
+        private void fillResultset(CompletionResultSet completionResultSet, Document doc, int pos) {
+            
+            Element paragraph = ((BaseDocument) doc).getParagraphElement(pos);
+            String prefix;
+            try {
+                prefix = doc.getText(paragraph.getStartOffset(), pos - paragraph.getStartOffset());
+                // daf<EFBFBD>r sorgen, dass wir in den meisten f<EFBFBD>llen einen korrekten prefix haben
+                // TODO: besser machen, ist ne hau-ruck-methode
+                // problem: bei leerzeichen in strings werden auch dort funktoren als autocomplete angeboten...
+                prefix = prefix.replaceAll(".*?([\\w-\"]*)$", "$1");
+            } catch (BadLocationException e) {
+                LOGGER.notify(e);
+                prefix = "";
+            }
+
+            // add user declared functions first
+            synchronized(Glsl.declaredFunctions) {
+                Set<Entry<String, GLSLElementDescriptor>> entrySet = Glsl.declaredFunctions.entrySet();
+
+                for (Entry<String, GLSLElementDescriptor> entry : entrySet) {
+
+                    String name = entry.getKey();
+                    GLSLElementDescriptor desc = entry.getValue();
+                    
+                    if (name.regionMatches(true, 0, prefix, 0, prefix.length())) {
+                        completionResultSet.addItem(new GlslCompletionItem(name.substring(0, name.indexOf('(')), desc, prefix, pos));
+                    }
+                }
+            }
+
+
+            // add core GLSL completion items
+            Iterator it = vocabulary.getKeys().iterator();
+            
+            while (it.hasNext()) {
+
+                String name = (String) it.next();
+                
+                if (name.regionMatches(true, 0, prefix, 0, prefix.length())) {
+
+                    GLSLElementDescriptor[] elements = vocabulary.getDesc(name);
+                    
+                    if (elements != null) {
+                        for (GLSLElementDescriptor element : elements) 
+                            completionResultSet.addItem(new GlslCompletionItem(name, element, prefix, pos));
+                    }
+                }
+                
+            }
+        }
+    }
+
+    private static class GlslCompletionItem implements CompletionItem {
+
+        private String key;
+        private GLSLElementDescriptor content;
+        private int carretPosition = 0;
+        private String prefix;
+
+        private String leftText;
+        private String rightText;
+
+        private String ARGUMENTS_COLOR = "<font color=#b28b00>";
+        private String BUILD_IN_VAR_COLOR = "<font color=#ce7b00>";
+        private String KEYWORD_COLOR = "<font color=#000099>";
+
+        private int priority;
+
+        public GlslCompletionItem(String key, GLSLElementDescriptor content, String prefix, int carretPosition) {
+
+            this.key = key;
+            this.content = content;
+            this.prefix = prefix;
+            this.carretPosition = carretPosition;
+
+            leftText = createLeftText();
+            rightText = content.type;
+
+            // low prority is first in completion list
+            switch (content.category) {
+                case TYPE:
+                    priority = 10;
+                    break;
+                case JUMP:
+                    priority = 9;
+                    break;
+                case SELECTION:
+                    priority = 8;
+                    break;
+                case ITERATION:
+                    priority = 7;
+                    break;
+                case KEYWORD:
+                    priority = 6;
+                    break;
+                case QUALIFIER:
+                    priority = 5;
+                    break;
+                case BUILD_IN_FUNC:
+                    priority = 4;
+                    break;
+                case BUILD_IN_VAR:
+                    priority = 3;
+                    break;
+            }
+        }
+
+        private String createLeftText() {
+
+            StringBuilder text = new StringBuilder();
+
+            switch (content.category) {
+                case TYPE:
+                case JUMP:
+                case SELECTION:
+                case ITERATION:
+                case KEYWORD:
+                case QUALIFIER:
+                    text.append(KEYWORD_COLOR);
+                    break;
+                case BUILD_IN_VAR:
+                    text.append(BUILD_IN_VAR_COLOR);
+                    break;
+            }
+            
+            text.append("<b>");
+            text.append(key);
+            text.append("</b></font>");
+
+            if (content.arguments != null) {
+                text.append(ARGUMENTS_COLOR);
+                text.append(content.arguments);
+                text.append("</font>");
+            }
+            return text.toString();
+        }
+
+        public void defaultAction(JTextComponent component) {
+            Completion.get().hideAll();
+            // replace prefix with key
+            try {
+                component.getDocument().remove(carretPosition-prefix.length(), prefix.length());
+                component.getDocument().insertString(carretPosition-prefix.length(), key, null);
+            } catch (BadLocationException e) {
+                LOGGER.notify(e);
+            }
+        }
+
+        public void processKeyEvent(KeyEvent evt) {
+            // TODO: if "." then Completion.get().showCompletion()
+        }
+
+        public int getPreferredWidth(Graphics g, Font defaultFont) {
+            return CompletionUtilities.getPreferredWidth(leftText, rightText, g, defaultFont);
+        }
+
+        public void render(Graphics g, Font defaultFont, Color defaultColor, Color backgroundColor, int width, int height, boolean selected) {
+            
+            CompletionUtilities.renderHtml(null, leftText, rightText, g, defaultFont, defaultColor, width, height, selected);
+            
+        }
+
+        public CompletionTask createDocumentationTask() {
+
+            if (content.doc == null) {
+                return null;
+            }
+            
+            return new AsyncCompletionTask(new AsyncCompletionQuery() {
+                private GlslDocItem item = new GlslDocItem(key, content);
+
+                protected void query(CompletionResultSet completionResultSet, Document document, int i) {
+                    completionResultSet.setDocumentation(item);
+                    completionResultSet.finish();
+                }
+            });
+        }
+
+        public CompletionTask createToolTipTask() {
+            return null;
+        }
+
+        public boolean instantSubstitution(JTextComponent component) {
+            defaultAction(component);
+            return true;
+        }
+
+        public int getSortPriority() {
+            return priority;
+        }
+
+        public CharSequence getSortText() {
+            return key;
+        }
+
+        public CharSequence getInsertPrefix() {
+            return prefix;
+        }
+    }
+
+    private static class GlslDocItem implements CompletionDocumentation {
+
+        private String text;
+
+        public GlslDocItem(String item, GLSLElementDescriptor content) {
+            
+            StringBuilder sb = new StringBuilder();
+            sb.append("<code>");
+            if(content.type != null) {
+                sb.append(content.type);
+                sb.append(" ");
+            }
+            sb.append("<b>");
+            sb.append(item);
+            sb.append("</b>");
+            if(content.arguments != null) {
+                sb.append(content.arguments);
+            }
+            sb.append("</code><p>");
+            sb.append(content.doc);
+            sb.append("</p>");
+            
+            text = sb.toString();
+        }
+
+        public String getText() {
+            return text;
+        }
+
+        public URL getURL() {
+            return null;
+        }
+
+        public CompletionDocumentation resolveLink(String link) {
+            return null;
+        }
+
+        public Action getGotoSourceAction() {
+            return null;
+        }
+    }
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/GlslShaderFileObserver.java

@@ -0,0 +1,65 @@
+package net.java.nboglpack.glsleditor;
+
+/**
+ * Created on 26. March 2007, 00:49
+ * 
+ */
+
+import javax.swing.event.DocumentEvent;
+import javax.swing.event.DocumentListener;
+//import net.java.nboglpack.glslcompiler.GLSLCompilerService;
+import org.openide.loaders.DataObject;
+import org.openide.util.Lookup;
+import org.openide.util.RequestProcessor;
+
+/**
+ * Observes an DataObject for document updates and starts compilation automatically.
+ * @author Michael Bien
+ */
+public class GlslShaderFileObserver implements DocumentListener {
+    
+ private final DataObject observedDao;
+ private final static RequestProcessor RP = new RequestProcessor("compiler");
+ private final RequestProcessor.Task compilerTask;
+ private boolean runOnDocUpdate = true;
+ private int compileDelay = 500;
+    
+    public GlslShaderFileObserver(DataObject dao) {
+        observedDao = dao;
+        
+        compilerTask = RP.create(new Runnable() {
+            public void run() {
+//                GLSLCompilerService compiler = Lookup.getDefault().lookup(GLSLCompilerService.class);
+//                compiler.compileShader(new DataObject[] {observedDao}, false);
+            }
+        });
+        compilerTask.setPriority(Thread.MIN_PRIORITY);
+    }
+
+    
+    // DocumentListener
+    public void insertUpdate(DocumentEvent arg0) {
+        if(runOnDocUpdate)
+            runCompileTask();
+    }
+    public void removeUpdate(DocumentEvent arg0) {
+        if(runOnDocUpdate)
+            runCompileTask();
+    }
+    public void changedUpdate(DocumentEvent arg0) {
+    }
+    
+    
+    public final void runCompileTask() {
+        compilerTask.schedule(compileDelay);
+    }
+
+    public void setCompileDelay(int compileDelay) {
+        this.compileDelay = compileDelay;
+    }
+
+    public void setRunOnDocUpdate(boolean runOnDocUpdate) {
+        this.runOnDocUpdate = runOnDocUpdate;
+    }
+    
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/GlslVocabularyManager.java

@@ -0,0 +1,172 @@
+/*
+ * GlslVocabularyManager.java
+ *
+ * Created on 12. Februar 2006, 03:37
+ *
+ */
+
+package net.java.nboglpack.glsleditor;
+
+import java.io.InputStream;
+import java.util.AbstractSet;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.Unmarshaller;
+import net.java.nboglpack.glsleditor.dataobject.GlslFragmentShaderDataLoader;
+import net.java.nboglpack.glsleditor.dataobject.GlslGeometryShaderDataLoader;
+import net.java.nboglpack.glsleditor.dataobject.GlslVertexShaderDataLoader;
+import net.java.nboglpack.glsleditor.vocabulary.GLSLElementDescriptor;
+import net.java.nboglpack.glsleditor.vocabulary.GLSLVocabulary;
+import org.openide.ErrorManager;
+import org.openide.filesystems.FileObject;
+import org.openide.filesystems.FileUtil;
+
+/**
+ *
+ * @author mhenze
+ * @author Michael Bien
+ */
+public class GlslVocabularyManager {
+    
+ private static final ErrorManager LOGGER = ErrorManager.getDefault().getInstance(GlslVocabularyManager.class.getName());
+ private static final HashMap<String, GlslVocabularyManager> instances = new HashMap<String, GlslVocabularyManager>();
+ private static GLSLVocabulary vocabulary = null;
+
+ private final String mimetype;
+ private final Set<String> keySet;
+ private final Map<String, GLSLElementDescriptor[]> vocabularyExtention;
+    
+    /** Creates a new instance of GlslVocabularyManager */
+    private GlslVocabularyManager(String mimetype) {
+        
+        if(    !mimetype.equals(GlslFragmentShaderDataLoader.REQUIRED_MIME)
+            && !mimetype.equals(GlslVertexShaderDataLoader.REQUIRED_MIME)
+            && !mimetype.equals(GlslGeometryShaderDataLoader.REQUIRED_MIME)) {
+            throw new IllegalArgumentException(mimetype+" is no GLSL mime type");
+        }
+        
+        
+        this.mimetype = mimetype;
+        
+        if(vocabulary == null)
+            loadVocabulary();
+        
+        if(mimetype.equals(GlslFragmentShaderDataLoader.REQUIRED_MIME)) {
+            vocabularyExtention = vocabulary.fragmentShaderVocabulary;
+        }else if(mimetype.equals(GlslVertexShaderDataLoader.REQUIRED_MIME)) {
+            vocabularyExtention = vocabulary.vertexShaderVocabulary;
+        }else {
+            vocabularyExtention = vocabulary.geometryShaderVocabulary;
+        }
+        
+        // merges two views
+        keySet = new AbstractSet<String>() {
+            
+            private final Set<String> mainSet = vocabulary.mainVocabulary.keySet();
+            private final Set<String> extSet = vocabularyExtention.keySet();
+            
+            
+            public Iterator<String> iterator() {
+                return new Iterator<String>(){
+                    
+                    Iterator<String> mainIt = mainSet.iterator();
+                    Iterator<String> extIt = extSet.iterator();
+                    
+                    public boolean hasNext() {
+                        return mainIt.hasNext() || extIt.hasNext();
+                    }
+                    
+                    public String next() {
+                        if(mainIt.hasNext())
+                            return mainIt.next();
+                        else
+                            return extIt.next();
+                    }
+                    
+                    public void remove() {
+                        throw new UnsupportedOperationException("Not supported yet.");
+                    }
+                    
+                };
+            }
+            
+            public int size() {
+                return mainSet.size()+extSet.size();
+            }
+            
+        };
+        
+    }
+    
+    public static GlslVocabularyManager getInstance(String mimetype) {
+        
+        GlslVocabularyManager instance = instances.get(mimetype);
+        
+        if(instance == null) {
+            instance = new GlslVocabularyManager(mimetype);
+            instances.put(mimetype,instance);
+        }
+        
+        return instance;
+    }
+    
+    private void loadVocabulary() {
+        
+        FileObject vocabularyfile = FileUtil.getConfigFile("Editors/"+mimetype+"/vocabulary.xml");
+        
+        if (vocabularyfile != null) {
+            
+            InputStream is = null;
+            
+            try {
+                
+                is = vocabularyfile.getInputStream();
+                
+                // workaround; nb does not allow usage of jdk's jaxb implementation
+                // => we have to provide JAXB as library wrapper module and load it via module classloader
+                JAXBContext jc = JAXBContext.newInstance("net.java.nboglpack.glsleditor.vocabulary", this.getClass().getClassLoader());
+
+                Unmarshaller unmarshaller = jc.createUnmarshaller();
+                vocabulary = (GLSLVocabulary)unmarshaller.unmarshal(is);
+
+            } catch (Exception ex) {
+                
+                // create empty vocab
+                vocabulary = new GLSLVocabulary();
+                LOGGER.notify(ex);
+                
+            } finally {
+                
+                if(is != null) {
+                    try {
+                        is.close();
+                    } catch (Exception e) {
+                        LOGGER.notify(e);
+                    }
+                }
+                
+            }
+            
+        }
+        
+    }
+    
+    public Set getKeys() {
+        return keySet;
+    }
+    
+    public GLSLElementDescriptor[] getDesc(String key) {
+        
+        GLSLElementDescriptor[] desc = vocabulary.mainVocabulary.get(key);
+        
+        if(desc == null)
+            desc = vocabularyExtention.get(key);
+        
+        return desc;
+    }
+    
+    
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/dataobject/Bundle.properties

@@ -0,0 +1,11 @@
+Services/MIMEResolver/GlslVertexShaderResolver.xml=GLSL Vertex Shader Files
+Services/MIMEResolver/GlslFragmentShaderResolver.xml=GLSL Fragment Shader Files
+Services/MIMEResolver/GlslGeometryShaderResolver.xml=GLSL Geometry Shader Files
+
+Templates/OpenGL/VertexShader.vert=GLSL Vertex Shader File
+Templates/OpenGL/FragmentShader.frag=GLSL Fragment Shader File
+Templates/OpenGL/GeometryShader.geom=GLSL Geometry Shader File
+
+LBL_glsl_vertex_shader_loader_name=GLSL Vertex Shader Files
+LBL_glsl_fragment_shader_loader_name=GLSL Fragment Shader Files
+LBL_glsl_geometry_shader_loader_name=GLSL Geometry Shader Files

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/dataobject/GlslFragmentShaderDataLoader.java

@@ -0,0 +1,40 @@
+package net.java.nboglpack.glsleditor.dataobject;
+
+import java.io.IOException;
+import org.openide.filesystems.FileObject;
+import org.openide.loaders.DataObjectExistsException;
+import org.openide.loaders.MultiDataObject;
+import org.openide.loaders.UniFileLoader;
+import org.openide.util.NbBundle;
+
+public class GlslFragmentShaderDataLoader extends UniFileLoader {
+
+    public static final String REQUIRED_MIME = "text/x-glsl-fragment-shader";
+
+    private static final long serialVersionUID = 1L;
+
+    public GlslFragmentShaderDataLoader() {
+        super("net.java.nboglpack.glsleditor.dataobject.GlslFragmentShaderDataObject");
+    }
+
+    @Override
+    protected String defaultDisplayName() {
+        return NbBundle.getMessage(GlslFragmentShaderDataLoader.class, "LBL_glsl_fragment_shader_loader_name");
+    }
+
+    @Override
+    protected void initialize() {
+        super.initialize();
+        getExtensions().addMimeType(REQUIRED_MIME);
+    }
+
+    protected MultiDataObject createMultiObject(FileObject primaryFile) throws DataObjectExistsException, IOException {
+        return new GlslFragmentShaderDataObject(primaryFile, this);
+    }
+
+    @Override
+    protected String actionsContext() {
+        return "Loaders/" + REQUIRED_MIME + "/Actions";
+    }
+
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/dataobject/GlslFragmentShaderDataLoaderBeanInfo.java

@@ -0,0 +1,32 @@
+package net.java.nboglpack.glsleditor.dataobject;
+
+import java.awt.Image;
+import java.beans.BeanInfo;
+import java.beans.IntrospectionException;
+import java.beans.Introspector;
+import java.beans.SimpleBeanInfo;
+import org.openide.loaders.UniFileLoader;
+import org.openide.util.ImageUtilities;
+
+public class GlslFragmentShaderDataLoaderBeanInfo extends SimpleBeanInfo {
+
+    public static final String IMAGE_ICON_BASE = "net/java/nboglpack/glsleditor/resources/FragmentShaderIcon.gif";
+
+    @Override
+    public BeanInfo[] getAdditionalBeanInfo() {
+        try {
+            return new BeanInfo[]{Introspector.getBeanInfo(UniFileLoader.class)};
+        } catch (IntrospectionException e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    @Override
+    public Image getIcon(int type) {
+        if (type == BeanInfo.ICON_COLOR_16x16 || type == BeanInfo.ICON_MONO_16x16) {
+            return ImageUtilities.loadImage(IMAGE_ICON_BASE);
+        } else {
+            return null;
+        }
+    }
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/dataobject/GlslFragmentShaderDataNode.java

@@ -0,0 +1,24 @@
+package net.java.nboglpack.glsleditor.dataobject;
+
+import org.openide.loaders.DataNode;
+import org.openide.nodes.Children;
+
+public class GlslFragmentShaderDataNode extends DataNode
+{
+	public GlslFragmentShaderDataNode(GlslFragmentShaderDataObject obj)
+	{
+		super(obj, Children.LEAF);
+		setIconBaseWithExtension(GlslFragmentShaderDataLoaderBeanInfo.IMAGE_ICON_BASE);
+	}
+//    /** Creates a property sheet. */
+//    protected Sheet createSheet() {
+//        Sheet s = super.createSheet();
+//        Sheet.Set ss = s.get(Sheet.PROPERTIES);
+//        if (ss == null) {
+//            ss = Sheet.createPropertiesSet();
+//            s.put(ss);
+//        }
+//        // TODO add some relevant properties: ss.put(...)
+//        return s;
+//    }
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/dataobject/GlslFragmentShaderDataObject.java

@@ -0,0 +1,57 @@
+package net.java.nboglpack.glsleditor.dataobject;
+
+import net.java.nboglpack.glsleditor.GlslShaderFileObserver;
+import java.beans.PropertyChangeEvent;
+import java.io.IOException;
+import java.beans.PropertyChangeListener;
+import javax.swing.text.Document;
+import org.openide.filesystems.FileObject;
+import org.openide.loaders.DataObjectExistsException;
+import org.openide.loaders.MultiDataObject;
+import org.openide.nodes.CookieSet;
+import org.openide.nodes.Node;
+import org.openide.text.CloneableEditorSupport;
+import org.openide.text.DataEditorSupport;
+
+
+
+public class GlslFragmentShaderDataObject extends MultiDataObject {
+    
+ private final GlslShaderFileObserver observer;
+    
+    public GlslFragmentShaderDataObject(FileObject pf, GlslFragmentShaderDataLoader loader) throws DataObjectExistsException, IOException {
+        
+        super(pf, loader);
+        
+        CookieSet cookies = getCookieSet();
+        observer= new GlslShaderFileObserver(this);
+        
+        final CloneableEditorSupport support= DataEditorSupport.create(this, getPrimaryEntry(), cookies);
+        support.addPropertyChangeListener(
+            new PropertyChangeListener(){
+                public void propertyChange(PropertyChangeEvent event) {
+                    if("document".equals(event.getPropertyName())){
+                        if(event.getNewValue()!=null)
+                        {
+                            support.getDocument().addDocumentListener(observer);
+                            observer.runCompileTask();
+                        }
+                        else if(event.getOldValue()!=null)
+                        {
+                            // cylab: I think this is never called.
+                            // But I don't know if unregistering the observer makes any difference...
+                            ((Document)event.getOldValue()).removeDocumentListener(observer);
+                        }
+                    }
+                }
+            }
+        );
+        cookies.add((Node.Cookie) support);
+    }
+    
+    @Override
+    protected Node createNodeDelegate() {
+        return new GlslFragmentShaderDataNode(this);
+    }
+
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/dataobject/GlslGeometryShaderDataLoader.java

@@ -0,0 +1,44 @@
+package net.java.nboglpack.glsleditor.dataobject;
+
+import java.io.IOException;
+import org.openide.filesystems.FileObject;
+import org.openide.loaders.DataObjectExistsException;
+import org.openide.loaders.MultiDataObject;
+import org.openide.loaders.UniFileLoader;
+import org.openide.util.NbBundle;
+
+
+/**
+ * @author Michael Bien
+ */
+public class GlslGeometryShaderDataLoader extends UniFileLoader {
+    
+    public static final String REQUIRED_MIME = "text/x-glsl-geometry-shader";
+    
+    private static final long serialVersionUID = 1L;
+    
+    public GlslGeometryShaderDataLoader() {
+        super("net.java.nboglpack.glsleditor.dataobject.GlslGeometryShaderDataObject");
+    }
+    
+    @Override
+    protected String defaultDisplayName() {
+        return NbBundle.getMessage(GlslGeometryShaderDataLoader.class, "LBL_glsl_geometry_shader_loader_name");
+    }
+    
+    @Override
+    protected void initialize() {
+        super.initialize();
+        getExtensions().addMimeType(REQUIRED_MIME);
+    }
+    
+    protected MultiDataObject createMultiObject(FileObject primaryFile) throws DataObjectExistsException, IOException {
+        return new GlslGeometryShaderDataObject(primaryFile, this);
+    }
+    
+    @Override
+    protected String actionsContext() {
+        return "Loaders/" + REQUIRED_MIME + "/Actions";
+    }
+    
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/dataobject/GlslGeometryShaderDataLoaderBeanInfo.java

@@ -0,0 +1,37 @@
+package net.java.nboglpack.glsleditor.dataobject;
+
+import java.awt.Image;
+import java.beans.BeanInfo;
+import java.beans.IntrospectionException;
+import java.beans.Introspector;
+import java.beans.SimpleBeanInfo;
+import org.openide.loaders.UniFileLoader;
+import org.openide.util.ImageUtilities;
+
+
+/**
+ * @author Michael Bien
+ */
+public class GlslGeometryShaderDataLoaderBeanInfo extends SimpleBeanInfo {
+    
+    public static final String IMAGE_ICON_BASE = "net/java/nboglpack/glsleditor/resources/GeometryShaderIcon.gif";
+
+    @Override
+    public BeanInfo[] getAdditionalBeanInfo() {
+        try {
+            return new BeanInfo[] {Introspector.getBeanInfo(UniFileLoader.class)};
+        } catch (IntrospectionException e) {
+            throw new AssertionError(e);
+        }
+    }
+    
+    @Override
+    public Image getIcon(int type) {
+        if (type == BeanInfo.ICON_COLOR_16x16 || type == BeanInfo.ICON_MONO_16x16) {
+            return ImageUtilities.loadImage(IMAGE_ICON_BASE);
+        } else {
+            return null;
+        }
+    }
+    
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/dataobject/GlslGeometryShaderDataNode.java

@@ -0,0 +1,34 @@
+package net.java.nboglpack.glsleditor.dataobject;
+
+import org.openide.loaders.DataNode;
+import org.openide.nodes.Children;
+import org.openide.util.Lookup;
+
+
+/**
+ * @author Michael Bien
+ */
+public class GlslGeometryShaderDataNode extends DataNode {
+    
+    public GlslGeometryShaderDataNode(GlslGeometryShaderDataObject obj) {
+        super(obj, Children.LEAF);
+        setIconBaseWithExtension(GlslGeometryShaderDataLoaderBeanInfo.IMAGE_ICON_BASE);
+    }
+    GlslGeometryShaderDataNode(GlslGeometryShaderDataObject obj, Lookup lookup) {
+        super(obj, Children.LEAF, lookup);
+        setIconBaseWithExtension(GlslGeometryShaderDataLoaderBeanInfo.IMAGE_ICON_BASE);
+    }
+    
+    //    /** Creates a property sheet. */
+    //    protected Sheet createSheet() {
+    //        Sheet s = super.createSheet();
+    //        Sheet.Set ss = s.get(Sheet.PROPERTIES);
+    //        if (ss == null) {
+    //            ss = Sheet.createPropertiesSet();
+    //            s.put(ss);
+    //        }
+    //        // TODO add some relevant properties: ss.put(...)
+    //        return s;
+    //    }
+    
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/dataobject/GlslGeometryShaderDataObject.java

@@ -0,0 +1,60 @@
+package net.java.nboglpack.glsleditor.dataobject;
+
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.io.IOException;
+import javax.swing.text.Document;
+import net.java.nboglpack.glsleditor.GlslShaderFileObserver;
+import org.openide.filesystems.FileObject;
+import org.openide.loaders.DataObjectExistsException;
+import org.openide.loaders.MultiDataObject;
+import org.openide.nodes.CookieSet;
+import org.openide.nodes.Node;
+import org.openide.text.CloneableEditorSupport;
+import org.openide.util.Lookup;
+import org.openide.text.DataEditorSupport;
+
+
+/**
+ * @author Michael Bien
+ */
+public class GlslGeometryShaderDataObject extends MultiDataObject {
+
+    private GlslShaderFileObserver observer;
+
+    public GlslGeometryShaderDataObject(FileObject pf, GlslGeometryShaderDataLoader loader) throws DataObjectExistsException, IOException {
+
+        super(pf, loader);
+
+        CookieSet cookies = getCookieSet();
+        observer = new GlslShaderFileObserver(this);
+
+        final CloneableEditorSupport support = DataEditorSupport.create(this, getPrimaryEntry(), cookies);
+        support.addPropertyChangeListener(new PropertyChangeListener() {
+
+            public void propertyChange(PropertyChangeEvent event) {
+                if ("document".equals(event.getPropertyName())) {
+                    if (event.getNewValue() != null) {
+                        support.getDocument().addDocumentListener(observer);
+                        observer.runCompileTask();
+                    } else if (event.getOldValue() != null) {
+                        // cylab: I think this is never called.
+                        // But I don't know if unregistering the observer makes any difference...
+                        ((Document) event.getOldValue()).removeDocumentListener(observer);
+                    }
+                }
+            }
+        });
+        cookies.add((Node.Cookie) support);
+    }
+
+    @Override
+    protected Node createNodeDelegate() {
+        return new GlslGeometryShaderDataNode(this, getLookup());
+    }
+
+    @Override
+    public Lookup getLookup() {
+        return getCookieSet().getLookup();
+    }
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/dataobject/GlslVertexShaderDataLoader.java

@@ -0,0 +1,40 @@
+package net.java.nboglpack.glsleditor.dataobject;
+
+import java.io.IOException;
+import org.openide.filesystems.FileObject;
+import org.openide.loaders.DataObjectExistsException;
+import org.openide.loaders.MultiDataObject;
+import org.openide.loaders.UniFileLoader;
+import org.openide.util.NbBundle;
+
+public class GlslVertexShaderDataLoader extends UniFileLoader {
+
+    public static final String REQUIRED_MIME = "text/x-glsl-vertex-shader";
+
+    private static final long serialVersionUID = 1L;
+
+    public GlslVertexShaderDataLoader() {
+        super("net.java.nboglpack.glsleditor.dataobject.GlslVertexShaderDataObject");
+    }
+
+    @Override
+    protected String defaultDisplayName() {
+        return NbBundle.getMessage(GlslFragmentShaderDataLoader.class, "LBL_glsl_vertex_shader_loader_name");
+    }
+
+    @Override
+    protected void initialize() {
+        super.initialize();
+        getExtensions().addMimeType(REQUIRED_MIME);
+    }
+
+    protected MultiDataObject createMultiObject(FileObject primaryFile) throws DataObjectExistsException, IOException {
+        return new GlslVertexShaderDataObject(primaryFile, this);
+    }
+
+    @Override
+    protected String actionsContext() {
+        return "Loaders/" + REQUIRED_MIME + "/Actions";
+    }
+
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/dataobject/GlslVertexShaderDataLoaderBeanInfo.java

@@ -0,0 +1,32 @@
+package net.java.nboglpack.glsleditor.dataobject;
+
+import java.awt.Image;
+import java.beans.BeanInfo;
+import java.beans.IntrospectionException;
+import java.beans.Introspector;
+import java.beans.SimpleBeanInfo;
+import org.openide.loaders.UniFileLoader;
+import org.openide.util.ImageUtilities;
+
+public class GlslVertexShaderDataLoaderBeanInfo extends SimpleBeanInfo {
+
+    public static final String IMAGE_ICON_BASE = "net/java/nboglpack/glsleditor/resources/VertexShaderIcon.gif";
+
+    @Override
+    public BeanInfo[] getAdditionalBeanInfo() {
+        try {
+            return new BeanInfo[]{Introspector.getBeanInfo(UniFileLoader.class)};
+        } catch (IntrospectionException e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    @Override
+    public Image getIcon(int type) {
+        if (type == BeanInfo.ICON_COLOR_16x16 || type == BeanInfo.ICON_MONO_16x16) {
+            return ImageUtilities.loadImage(IMAGE_ICON_BASE);
+        } else {
+            return null;
+        }
+    }
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/dataobject/GlslVertexShaderDataNode.java

@@ -0,0 +1,24 @@
+package net.java.nboglpack.glsleditor.dataobject;
+
+import org.openide.loaders.DataNode;
+import org.openide.nodes.Children;
+
+public class GlslVertexShaderDataNode extends DataNode
+{
+	public GlslVertexShaderDataNode(GlslVertexShaderDataObject obj)
+	{
+		super(obj, Children.LEAF);
+		setIconBaseWithExtension(GlslVertexShaderDataLoaderBeanInfo.IMAGE_ICON_BASE);
+	}
+//    /** Creates a property sheet. */
+//    protected Sheet createSheet() {
+//        Sheet s = super.createSheet();
+//        Sheet.Set ss = s.get(Sheet.PROPERTIES);
+//        if (ss == null) {
+//            ss = Sheet.createPropertiesSet();
+//            s.put(ss);
+//        }
+//        // TODO add some relevant properties: ss.put(...)
+//        return s;
+//    }
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/dataobject/GlslVertexShaderDataObject.java

@@ -0,0 +1,54 @@
+package net.java.nboglpack.glsleditor.dataobject;
+
+import net.java.nboglpack.glsleditor.GlslShaderFileObserver;
+import net.java.nboglpack.glsleditor.GlslShaderFileObserver;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.io.IOException;
+import javax.swing.text.Document;
+import org.openide.filesystems.FileObject;
+import org.openide.loaders.DataObjectExistsException;
+import org.openide.loaders.MultiDataObject;
+import org.openide.nodes.CookieSet;
+import org.openide.nodes.Node;
+import org.openide.text.CloneableEditorSupport;
+import org.openide.text.DataEditorSupport;
+
+public class GlslVertexShaderDataObject extends MultiDataObject {
+    
+ private GlslShaderFileObserver observer;
+
+    public GlslVertexShaderDataObject(FileObject pf, GlslVertexShaderDataLoader loader) throws DataObjectExistsException, IOException {
+        
+        super(pf, loader);
+        CookieSet cookies = getCookieSet();
+        observer= new GlslShaderFileObserver(this);
+        
+        final CloneableEditorSupport support= DataEditorSupport.create(this, getPrimaryEntry(), cookies);
+        support.addPropertyChangeListener(
+            new PropertyChangeListener(){
+                public void propertyChange(PropertyChangeEvent event) {
+                    if("document".equals(event.getPropertyName())){
+                        if(event.getNewValue()!=null)
+                        {
+                            support.getDocument().addDocumentListener(observer);
+                            observer.runCompileTask();
+                        }
+                        else if(event.getOldValue()!=null)
+                        {
+                            // cylab: I think this is never called.
+                            // But I don't know if unregistering the observer makes any difference...
+                            ((Document)event.getOldValue()).removeDocumentListener(observer);
+                        }
+                    }
+                }
+            }
+        );
+        cookies.add((Node.Cookie) support);
+    }
+    
+    @Override
+    protected Node createNodeDelegate() {
+        return new GlslVertexShaderDataNode(this);
+    }
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/glsl/Bundle.properties

@@ -0,0 +1,4 @@
+LBL_SYNTAX_ERROR=Syntax error.
+LBL_UNEXPECTED_CHARACTER=Unexpected character.
+LBL_RESERVED_KEYWORD=Reserved keyword.
+

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/glsl/GLSL_120.nbs

@@ -0,0 +1,316 @@
+################################################################################
+# OpenGL Shading Language 1.20 GLF file ########################################
+################################################################################
+# @date 10.09.2007                                                             #
+# @author Michael Bien                                                         #
+# @email mbien@fh-landshut.de                                                  #
+################################################################################
+
+BUNDLE "net.java.nboglpack.glsleditor.glsl.Bundle"
+
+SKIP:WHITESPACE
+SKIP:END_OF_LINE
+SKIP:COMMENT
+SKIP:ML_COMMENT
+
+## error highlighting ##########################################################
+MARK:ERROR: {
+    type:"Error";
+    message:"LBL_SYNTAX_ERROR";
+}
+MARK:error: {
+    type:"Error";
+    message:"LBL_UNEXPECTED_CHARACTER";
+}
+MARK:reserved: {
+    type:"Warning";
+    message:"LBL_RESERVED_KEYWORD";
+}
+
+FOLD:function_body: {
+    fold_display_name:"{...}";
+}
+FOLD:struct_body: {
+    fold_display_name:"{...}";
+}
+FOLD:ML_COMMENT: {
+    fold_display_name:"/*...*/";
+}
+
+BRACE "(:)"
+BRACE "{:}"
+BRACE "[:]"
+
+COMPLETE "(:)"
+COMPLETE "{:}"
+COMPLETE "[:]"
+
+INDENT "(:)"
+INDENT "{:}"
+INDENT "[:]"
+INDENT "\\s*(((if|while)\\s*\\(|else\\s*|else\\s+if\\s*\\(|for\\s*\\(.*\\))[^{;]*)"
+
+SELECTION ( ["a"-"z" "A"-"Z" "0"-"9" "_"] )
+
+NAVIGATOR:global_preprocessor: {
+    display_name: net.java.nboglpack.glsleditor.glsl.Glsl.createPreprocessorString;
+    icon: "net/java/nboglpack/glsleditor/resources/preprocessor.png";
+    isLeaf: "true";
+}
+NAVIGATOR:global_declared_identifier, struct_declarator: {
+    display_name: net.java.nboglpack.glsleditor.glsl.Glsl.createFieldDeclarationString;
+    icon: "net/java/nboglpack/glsleditor/resources/field.gif";
+    isLeaf: "true";
+}
+NAVIGATOR:function: {
+    display_name: net.java.nboglpack.glsleditor.glsl.Glsl.createFunctionDeclarationString;
+    icon: "net/java/nboglpack/glsleditor/resources/function.gif";
+    isLeaf: "true";
+}
+#AST {
+#    process: net.java.nboglpack.glsleditor.glsl.Glsl.process;
+#}
+#PROPERTIES {
+#    traceSteps:"true";
+#    printRules:"true";
+#    printFirst:"true";
+#}
+
+##### GLSL 1.2 grammar #########################################################
+
+S = declaration*;
+
+
+## constants ###################################################################
+type_specifier = "float"
+               | "int"
+               | "bool"
+               | "vec2"
+               | "vec3"
+               | "vec4"
+               | "bvec2"
+               | "bvec3"
+               | "bvec4"
+               | "ivec2"
+               | "ivec3"
+               | "ivec4"
+               | "mat2"
+               | "mat3"
+               | "mat4"
+               | "mat2x2"
+               | "mat2x3"
+               | "mat2x4"
+               | "mat3x2"
+               | "mat3x3"
+               | "mat3x4"
+               | "mat4x2"
+               | "mat4x3"
+               | "mat4x4"
+               | "sampler1D"
+               | "sampler2D"
+               | "sampler3D"
+               | "samplerCube"
+               | "sampler1DShadow"
+               | "sampler2DShadow";
+
+type_specifier_or_identifier = type_specifier | <IDENTIFIER>;
+
+type_qualifier = "const";
+
+global_type_qualifier = type_qualifier
+                      | "attribute" # Vertex only.
+                      | "varying"
+                      | ("centroid" "varying")
+                      | ("invariant" ["centroid"] "varying")
+                      | "uniform";
+
+parameter_declaration_qualifier = "in" | "out" | "inout";
+
+boolean_literal = "true" | "false"; # TODO move boolean literal to lexer?
+
+
+assignment_operator = <EQ>
+                    | <MUL_ASSIGN>
+                    | <DIV_ASSIGN>
+                    | <ADD_ASSIGN>
+                    | <SUB_ASSIGN>
+                    | <MOD_ASSIGN>            # reserved
+                    | <LEFT_BITSHIFT_ASSIGN>  # reserved
+                    | <RIGHT_BITSHIFT_ASSIGN> # reserved
+                    | <AND_ASSIGN>            # reserved
+                    | <XOR_ASSIGN>            # reserved
+                    | <OR_ASSIGN>;            # reserved
+
+comperator = <LEFT_ANGLE> | <RIGHT_ANGLE> | <LE> | <GE> | <EQEQ> | <NE>;
+
+operator = <PLUS> 
+         | <MINUS> 
+         | <STAR> 
+         | <SLASH> 
+         | <AMP>
+         | <AMPAMP>
+         | <BAR>            # reserved
+         | <BARBAR>
+         | <CARETCARET>
+         | <CARET>          # reserved
+         | <PERCENT>        # reserved
+         | <RIGHT_BITSHIFT> # reserved
+         | <LEFT_BITSHIFT>; # reserved
+
+unary_operator = <PLUS>
+               | <MINUS> 
+               | <BANG> 
+               | <TILDE>; # reserved
+
+increment_or_decrement_operator = <PLUSPLUS> | <MINUSMINUS>;
+
+reserved = "asm" 
+         | "class"
+         | "union"
+         | "enum"
+         | "typedef"
+         | "template"
+         | "this"
+         | "packed"
+         | "goto"
+         | "switch"
+         | "default"
+         | "inline"
+         | "noinline"
+         | "volatile"
+         | "public"
+         | "static" 
+         | "extern" 
+         | "external" 
+         | "interface"
+         | "long"
+         | "short"
+         | "double"
+         | "half"
+         | "fixed"
+         | "unsigned"
+         | "lowp"
+         | "mediump"
+         | "highp"
+         | "precision"
+         | "input"
+         | "output"
+         | "hvec2"
+         | "hvec3"
+         | "hvec4"
+         | "dvec2"
+         | "dvec3"
+         | "dvec4"
+         | "fvec2"
+         | "fvec3"
+         | "fvec4"
+         | "sampler2DRect"
+         | "sampler3DRect"
+         | "sampler2DRectShadow"
+         | "sizeof"
+         | "cast"
+         | "namespace"
+         | "using";
+
+
+## declarations ################################################################
+declaration = type_specifier_or_identifier [array_index] (function | (global_identifier_list <SEMICOLON>));
+declaration = "void" function;
+declaration = global_type_qualifier struct_declaration <SEMICOLON>;
+declaration = global_type_qualifier global_type_declaration <SEMICOLON>;
+declaration = struct_declaration <SEMICOLON>;
+declaration = global_preprocessor;
+
+global_identifier_list = global_declared_identifier [array_index] (<COMMA> global_declared_identifier [array_index])*;
+global_declared_identifier = <IDENTIFIER>;
+global_preprocessor = <PREPROCESSOR>;
+
+struct_declaration = "struct" <IDENTIFIER> struct_body [global_identifier_list];
+struct_body = "{" (local_type_declaration <SEMICOLON>)+ "}";
+
+global_type_declaration = type_specifier_or_identifier [array_index] global_identifier_list [<EQ> expression];
+type_declaration        = type_specifier_or_identifier [array_index] <IDENTIFIER> [array_index] (<COMMA> <IDENTIFIER> [array_index])*;
+
+local_type_declaration = [type_qualifier] type_declaration;
+
+## function ####################################################################
+function = <FUNCTION> "(" [parameter_declaration_list] ")" (function_body | <SEMICOLON>);
+function_body = code_block;
+
+parameter_declaration = [type_qualifier] [parameter_declaration_qualifier] type_specifier_or_identifier ((array_index <IDENTIFIER>) | (<IDENTIFIER> [array_index]));
+parameter_declaration_list = "void" | (parameter_declaration (<COMMA> parameter_declaration)*);
+
+statement = <PREPROCESSOR>;
+statement = expression_hack <SEMICOLON>;  # statement = local_type_declaration [<EQ> expression] <SEMICOLON>;
+statement = conditional_statement;
+statement = "return" [expression] <SEMICOLON>;
+statement = "break" <SEMICOLON>;   # break just in loops allowed
+statement = "continue" <SEMICOLON>;# continue just in loops allowed
+statement = "discard" <SEMICOLON>; # Fragment shader only.
+
+code_block = "{" statement* "}";
+
+## expresstions and operations #################################################
+# ternary operator
+expression = expression1  ["?" expression1 ":" expression1];
+
+expression1 = [unary_operator] expression2 operation_or_comparison*;
+expression1 = [unary_operator] "(" expression ")" operation_or_comparison*;
+
+expression2 = ( [increment_or_decrement_operator] (<IDENTIFIER> | <BUILD_IN_VAR>) (field_access)* [increment_or_decrement_operator] [assignment])
+            | ((function_call | constructor_call) (field_access)*)
+            | <INTEGER_LITERAL>
+            | <FLOAT_LITERAL>
+            | boolean_literal;
+
+
+
+expression_hack = unary_operator expression1_hack   operation_or_comparison*;
+expression_hack = unary_operator "(" expression ")" operation_or_comparison*;
+expression_hack = expression1_hack   operation_or_comparison*;
+expression_hack = "(" expression ")" operation_or_comparison*;
+
+expression_hack = <IDENTIFIER> (field_access)* [increment_or_decrement_operator] [assignment];
+expression_hack = <IDENTIFIER> (field_access)* <IDENTIFIER> [array_index] (<COMMA> <IDENTIFIER> [array_index])*;
+expression_hack = type_specifier (field_access)* <IDENTIFIER> [array_index] (<COMMA> <IDENTIFIER> [array_index])*;
+
+expression1_hack = (increment_or_decrement_operator (<IDENTIFIER> | <BUILD_IN_VAR>) (field_access)* [increment_or_decrement_operator] [assignment])
+                 | (<BUILD_IN_VAR> (field_access)* [increment_or_decrement_operator] [assignment])
+                 | ((function_call | constructor_call) (field_access)*)
+                 | <INTEGER_LITERAL>
+                 | <FLOAT_LITERAL>
+                 | boolean_literal;
+
+
+
+assignment = assignment_operator expression;
+operation_or_comparison = (comperator | operator) expression;
+
+field_access = array_index;
+field_access = <DOT> <IDENTIFIER>;
+
+array_index = "[" [expression] "]";
+
+function_call = (<FUNCTION> | <BUILD_IN_FUNC>) "(" [expression_list] ")";
+# Note constructor call is something like that: vec2(1.0, 2.0) or float[2] (1.0, 2.0)
+constructor_call = type_specifier [array_index] "(" [expression_list] ")"; #TODO custom structs
+
+expression_list = "void" | (expression (<COMMA> expression)*);
+
+## code flow ###################################################################
+conditional_statement = if_statement 
+                      | for_statement
+                      | while_statement
+                      | do_while_statement;
+
+# TODO if rule not 100% correct, multiple else allowed even before else if
+if_statement = "if" condition statement_or_code_block ("else" ["if" condition] statement_or_code_block)*;
+while_statement = "while" condition statement_or_code_block;
+do_while_statement = "do" statement_or_code_block "while" condition <SEMICOLON>;
+# TODO for rule could be more restrictive
+for_statement = "for" "(" [[type_specifier] <IDENTIFIER> assignment] <SEMICOLON> [expression] <SEMICOLON> [expression] ")" statement_or_code_block;
+
+condition = "(" expression ")";
+statement_or_code_block = (statement | code_block);
+
+

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/glsl/GLSL_130.nbs

@@ -0,0 +1,389 @@
+################################################################################
+# OpenGL Shading Language 1.30 GLF file ########################################
+################################################################################
+# @date 10.09.2007                                                             #
+# @author Michael Bien                                                         #
+# @email mbien@fh-landshut.de                                                  #
+################################################################################
+
+BUNDLE "net.java.nboglpack.glsleditor.glsl.Bundle"
+
+SKIP:WHITESPACE
+SKIP:END_OF_LINE
+SKIP:COMMENT
+SKIP:ML_COMMENT
+
+## error highlighting ##########################################################
+MARK:ERROR: {
+    type:"Error";
+    message:"LBL_SYNTAX_ERROR";
+}
+MARK:error: {
+    type:"Error";
+    message:"LBL_UNEXPECTED_CHARACTER";
+}
+MARK:reserved: {
+    type:"Warning";
+    message:"LBL_RESERVED_KEYWORD";
+}
+
+FOLD:function_body: {
+    fold_display_name:"{...}";
+}
+FOLD:struct_body: {
+    fold_display_name:"{...}";
+}
+FOLD:ML_COMMENT: {
+    fold_display_name:"/*...*/";
+}
+
+BRACE "(:)"
+BRACE "{:}"
+BRACE "[:]"
+
+COMPLETE "(:)"
+COMPLETE "{:}"
+COMPLETE "[:]"
+
+INDENT "(:)"
+INDENT "{:}"
+INDENT "[:]"
+INDENT "\\s*(((if|while)\\s*\\(|else\\s*|else\\s+if\\s*\\(|for\\s*\\(.*\\))[^{;]*)"
+
+SELECTION ( ["a"-"z" "A"-"Z" "0"-"9" "_"] )
+
+AST {
+    process: net.java.nboglpack.glsleditor.glsl.Glsl.process;
+}
+NAVIGATOR:global_preprocessor: {
+    display_name: net.java.nboglpack.glsleditor.glsl.Glsl.createPreprocessorString;
+    icon: "net/java/nboglpack/glsleditor/resources/preprocessor.png";
+    isLeaf: "true";
+}
+NAVIGATOR:global_declared_identifier: {
+    display_name: net.java.nboglpack.glsleditor.glsl.Glsl.createFieldDeclarationString;
+    icon: "net/java/nboglpack/glsleditor/resources/field.gif";
+    isLeaf: "true";
+}
+NAVIGATOR:function: {
+    display_name: net.java.nboglpack.glsleditor.glsl.Glsl.createFunctionDeclarationString;
+    icon: "net/java/nboglpack/glsleditor/resources/function.gif";
+    isLeaf: "true";
+}
+#PROPERTIES {
+#    traceSteps:"true";
+#    printRules:"true";
+#    printFirst:"true";
+#}
+
+##### GLSL 1.3 grammar #########################################################
+
+S = declaration*;
+
+
+## constants ###################################################################
+type_specifier = "float"
+               | "int"
+               | "uint"
+               | "bool"
+               | "vec2"
+               | "vec3"
+               | "vec4"
+               | "bvec2"
+               | "bvec3"
+               | "bvec4"
+               | "ivec2"
+               | "ivec3"
+               | "ivec4"
+               | "uvec2"
+               | "uvec3"
+               | "uvec4"
+               | "mat2"
+               | "mat3"
+               | "mat4"
+               | "mat2x2"
+               | "mat2x3"
+               | "mat2x4"
+               | "mat3x2"
+               | "mat3x3"
+               | "mat3x4"
+               | "mat4x2"
+               | "mat4x3"
+               | "mat4x4"
+               | "sampler1D"
+               | "sampler2D"
+               | "sampler3D"
+               | "samplerCube"
+               | "sampler1DShadow"
+               | "sampler2DShadow"
+               | "sampler1DArray"
+               | "sampler2DArray"
+               | "sampler1DArrayShadow"
+               | "sampler2DArrayShadow"
+               | "isampler1D"
+               | "isampler2D"
+               | "isampler3D"
+               | "isamplerCube"
+               | "isampler1DArray"
+               | "isampler2DArray"
+               | "usampler1D"
+               | "usampler2D"
+               | "usampler3D"
+               | "usamplerCube"
+               | "usampler1DArray"
+               | "usampler2DArray";
+
+type_specifier_or_identifier = type_specifier | <IDENTIFIER>;
+
+type_qualifier = "const";
+
+interpolation_type_qualifier = "smooth"
+                             | "flat"
+                             | "noperspective";
+
+inout_type_qualifier = "in" | "out";
+
+global_type_qualifier = type_qualifier
+                      | (inout_type_qualifier ["invariant"] ["centroid"])
+                      | (interpolation_type_qualifier ["invariant"] ["centroid"] [inout_type_qualifier])
+                      | ("centroid" [interpolation_type_qualifier] [inout_type_qualifier])
+                      | ("invariant" ["centroid"] [inout_type_qualifier])
+                      | "attribute" # Vertex only.
+                      | "varying"
+                      | ("centroid" "varying")
+                      | ("invariant" ["centroid"] "varying")
+                      | "uniform";
+
+parameter_declaration_qualifier = "in" | "out" | "inout";
+
+boolean_literal = "true" | "false"; # TODO move boolean literal to lexer?
+
+precision_qualifier = "highp"
+                    | "mediump"
+                    | "lowp";
+
+assignment_operator = <EQ>
+                    | <MUL_ASSIGN>
+                    | <DIV_ASSIGN>
+                    | <ADD_ASSIGN>
+                    | <SUB_ASSIGN>
+                    | <MOD_ASSIGN>            # reserved
+                    | <LEFT_BITSHIFT_ASSIGN>  # reserved
+                    | <RIGHT_BITSHIFT_ASSIGN> # reserved
+                    | <AND_ASSIGN>            # reserved
+                    | <XOR_ASSIGN>            # reserved
+                    | <OR_ASSIGN>;            # reserved
+
+comperator = <LEFT_ANGLE> | <RIGHT_ANGLE> | <LE> | <GE> | <EQEQ> | <NE>;
+
+operator = <PLUS> 
+         | <MINUS> 
+         | <STAR> 
+         | <SLASH> 
+         | <AMP>
+         | <AMPAMP>
+         | <BAR>            # reserved
+         | <BARBAR>
+         | <CARETCARET>
+         | <CARET>          # reserved
+         | <PERCENT>        # reserved
+         | <RIGHT_BITSHIFT> # reserved
+         | <LEFT_BITSHIFT>; # reserved
+
+unary_operator = <PLUS>
+               | <MINUS> 
+               | <BANG> 
+               | <TILDE>; # reserved
+
+increment_or_decrement_operator = <PLUSPLUS> | <MINUSMINUS>;
+
+reserved = "asm" 
+         | "common"
+         | "partition"
+         | "active"
+         | "class"
+         | "union"
+         | "enum"
+         | "typedef"
+         | "template"
+         | "this"
+         | "packed"
+         | "goto"
+         | "inline"
+         | "noinline"
+         | "volatile"
+         | "public"
+         | "static" 
+         | "extern" 
+         | "external" 
+         | "interface"
+         | "long"
+         | "short"
+         | "double"
+         | "half"
+         | "fixed"
+         | "unsigned"
+         | "superp"
+         | "input"
+         | "output"
+         | "hvec2"
+         | "hvec3"
+         | "hvec4"
+         | "dvec2"
+         | "dvec3"
+         | "dvec4"
+         | "fvec2"
+         | "fvec3"
+         | "fvec4"
+         | "sampler2DRect"
+         | "sampler3DRect"
+         | "sampler2DRectShadow"
+         | "samplerBuffer"
+         | "filter"
+         | "image1D"
+         | "image2D"
+         | "image3D"
+         | "imageCube"
+         | "iimage1D"
+         | "iimage2D"
+         | "iimage3D"
+         | "iimageCube"
+         | "uimage1D"
+         | "uimage2D"
+         | "uimage3D"
+         | "uimageCube"
+         | "image1DArray"
+         | "image2DArray"
+         | "iimage1DArray"
+         | "iimage2DArray"
+         | "uimage1DArray"
+         | "uimage2DArray"
+         | "image1DShadow"
+         | "image2DShadow"
+         | "image1DArrayShadow"
+         | "image2DArrayShadow"
+         | "imageBuffer"
+         | "iimageBuffer"
+         | "uimageBuffer"
+         | "sizeof"
+         | "cast"
+         | "namespace"
+         | "using"
+         | "row_major";
+
+
+## declarations ################################################################
+declaration = [precision_qualifier] type_specifier_or_identifier [array_index] (function | (global_identifier_list [assignment2] <SEMICOLON>));
+declaration = "void" function;
+declaration = field_declaration <SEMICOLON>;
+declaration = struct_declaration <SEMICOLON>;
+declaration = precision_declaration <SEMICOLON>;
+declaration = global_preprocessor;
+
+global_identifier_list = global_declared_identifier [array_index] (<COMMA> global_declared_identifier [array_index])*;
+global_declared_identifier = <IDENTIFIER>;
+global_preprocessor = <PREPROCESSOR>;
+
+field_declaration = global_type_qualifier struct_declaration;
+field_declaration = global_type_qualifier global_type_declaration [assignment2];
+
+struct_declaration = "struct" <IDENTIFIER> struct_body [global_identifier_list];
+struct_body = "{" (local_type_declaration <SEMICOLON>)+ "}";
+
+global_type_declaration = [precision_qualifier] type_specifier_or_identifier [array_index] global_identifier_list [<EQ> expression];
+type_declaration        = [precision_qualifier] type_specifier_or_identifier [array_index] <IDENTIFIER> [array_index] (<COMMA> <IDENTIFIER> [array_index])*;
+
+local_type_declaration = [type_qualifier] type_declaration;
+
+precision_declaration = "precision" precision_qualifier type_specifier;
+
+## function ####################################################################
+function = <FUNCTION> "(" [parameter_declaration_list] ")" (function_body | <SEMICOLON>);
+function_body = code_block;
+
+parameter_declaration = [type_qualifier] [parameter_declaration_qualifier] [precision_qualifier] type_specifier_or_identifier ((array_index <IDENTIFIER>) | (<IDENTIFIER> [array_index]));
+parameter_declaration_list = "void" | (parameter_declaration (<COMMA> parameter_declaration)*);
+
+statement = <PREPROCESSOR>;
+statement = expression_hack <SEMICOLON>;  # statement = local_type_declaration [<EQ> expression] <SEMICOLON>;
+statement = conditional_statement;
+statement = "return" [expression] <SEMICOLON>;
+statement = "break" <SEMICOLON>;   # break just in loops allowed
+statement = "continue" <SEMICOLON>;# continue just in loops allowed
+statement = "discard" <SEMICOLON>; # Fragment shader only.
+
+code_block = "{" code_block* "}";
+code_block = "{" statement* "}";
+
+## expresstions and operations #################################################
+# ternary operator
+expression = expression1  ["?" expression1 ":" expression1];
+
+expression1 = [unary_operator] expression2 operation_or_comparison*;
+expression1 = [unary_operator] "(" expression ")" operation_or_comparison*;
+
+expression2 = ( [increment_or_decrement_operator] (<IDENTIFIER> | <BUILD_IN_VAR>) (field_access)* [increment_or_decrement_operator] [assignment])
+            | ((function_call | constructor_call) (field_access)*)
+            | <INTEGER_LITERAL>
+            | <FLOAT_LITERAL>
+            | boolean_literal;
+
+
+
+expression_hack = unary_operator expression1_hack   operation_or_comparison*;
+expression_hack = unary_operator "(" expression ")" operation_or_comparison*;
+expression_hack = expression1_hack   operation_or_comparison*;
+expression_hack = "(" expression ")" operation_or_comparison*;
+
+expression_hack = <IDENTIFIER> (field_access)* [increment_or_decrement_operator] [assignment];
+expression_hack = <IDENTIFIER> (field_access)* <IDENTIFIER> [array_index] (<COMMA> <IDENTIFIER> [array_index])*;
+expression_hack = type_specifier (field_access)* <IDENTIFIER> [array_index] (<COMMA> <IDENTIFIER> [array_index])*;
+
+expression1_hack = (increment_or_decrement_operator (<IDENTIFIER> | <BUILD_IN_VAR>) (field_access)* [increment_or_decrement_operator] [assignment])
+                 | (<BUILD_IN_VAR> (field_access)* [increment_or_decrement_operator] [assignment])
+                 | ((function_call | constructor_call) (field_access)*)
+                 | <INTEGER_LITERAL>
+                 | <FLOAT_LITERAL>
+                 | boolean_literal;
+
+
+
+assignment = assignment_operator expression;
+assignment2 = <EQ> expression;
+operation_or_comparison = (comperator | operator) expression;
+
+field_access = array_index;
+field_access = <DOT> <IDENTIFIER>;
+
+array_index = "[" [expression] "]";
+
+function_call = (<FUNCTION> | <BUILD_IN_FUNC>) "(" [expression_list] ")";
+# Note constructor call is something like that: vec2(1.0, 2.0) or float[2] (1.0, 2.0)
+constructor_call = type_specifier [array_index] "(" [expression_list] ")"; #TODO custom structs
+
+expression_list = "void" | (expression (<COMMA> expression)*);
+
+## code flow ###################################################################
+conditional_statement = if_statement 
+                      | for_statement
+                      | while_statement
+                      | do_while_statement
+                      | switch_statement;
+
+# TODO if rule not 100% correct, multiple else allowed even before else if
+if_statement = "if" condition statement_or_code_block ("else" ["if" condition] statement_or_code_block)*;
+
+while_statement = "while" condition statement_or_code_block;
+do_while_statement = "do" statement_or_code_block "while" condition <SEMICOLON>;
+
+# TODO for rule could be more restrictive
+for_statement = "for" "(" [[type_specifier] <IDENTIFIER> assignment] <SEMICOLON> [expression] <SEMICOLON> [expression] ")" statement_or_code_block;
+
+switch_statement = "switch" condition "{" case* "}";
+case = ("case" expression ":" statement*)
+     | ("default" ":" statement*);
+
+condition = "(" expression ")";
+statement_or_code_block = (statement | code_block);
+
+

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/glsl/Glsl.java

@@ -0,0 +1,361 @@
+/*
+ * Glsl.java
+ * 
+ * Created on 24.09.2007, 00:46:53
+ * 
+ */
+
+package net.java.nboglpack.glsleditor.glsl;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.swing.text.AbstractDocument;
+import net.java.nboglpack.glsleditor.lexer.GlslTokenId;
+import net.java.nboglpack.glsleditor.vocabulary.GLSLElementDescriptor;
+import org.netbeans.api.languages.ASTItem;
+import org.netbeans.api.languages.ASTNode;
+import org.netbeans.api.languages.ASTToken;
+import org.netbeans.api.languages.SyntaxContext;
+import org.netbeans.api.lexer.Token;
+import org.netbeans.api.lexer.TokenHierarchy;
+import org.netbeans.api.lexer.TokenSequence;
+import org.netbeans.api.lexer.TokenUtilities;
+
+/**
+ * Utility methods called from GLSL.nbs.
+ * @author Michael Bien
+ */
+public final class Glsl {
+    
+ private final static String KEYWORD_FONT_COLOR = "<font color=808080>";
+ 
+ public final static Map<String, GLSLElementDescriptor> declaredFunctions = new HashMap<String, GLSLElementDescriptor>();
+    
+ private Glsl() {}
+    
+     /**
+     * Assembles a human readable String containing the declaraton of a function.
+     * Asumes that the current token of the SyntaxContext represents the function name.
+     */
+    public static final String createFunctionDeclarationString(SyntaxContext context) {
+        
+        AbstractDocument document = (AbstractDocument)context.getDocument();
+        
+        StringBuilder sb = new StringBuilder();
+        
+        try {
+
+            document.readLock();
+            
+            TokenSequence sequence = TokenHierarchy.get(context.getDocument()).tokenSequence();
+            sequence.move(context.getOffset());
+            sequence.moveNext();
+            
+            sb.append("<html>");
+
+            int moved = 0;
+            while(sequence.movePrevious() && isIgnoredToken(sequence.token()))
+                moved++;
+
+            String type = sequence.token().toString();
+            while(moved-- >= 0)
+                sequence.moveNext();
+
+            // append function name
+            sb.append(sequence.token().text());
+
+            while(!TokenUtilities.equals(sequence.token().text(), "("))
+                sequence.moveNext();
+
+            sb.append("(");
+
+            Token token;
+            boolean first = true;
+            while(sequence.moveNext() && !TokenUtilities.equals(sequence.token().text(), ")")) {
+
+                token = sequence.token();
+
+                if(!isIgnoredToken(token)) {
+
+                    if(first) {
+                        sb.append(KEYWORD_FONT_COLOR);
+                    }else if(token.id() != GlslTokenId.COMMA && token.id() != GlslTokenId.BRACKET && token.id() != GlslTokenId.INTEGER_LITERAL) {
+                        sb.append(" ");
+                    }
+
+                    if(!TokenUtilities.equals(token.text(), "void")) {
+
+                        moved = 0;
+                        while(sequence.moveNext() && isIgnoredToken(sequence.token())) 
+                            moved++;
+
+                        if(sequence.token().id() == GlslTokenId.COMMA || TokenUtilities.equals(sequence.token().text(), ")"))
+                            sb.append("</font>");
+
+                        while(moved-- >= 0)
+                            sequence.movePrevious();
+
+                        sb.append(token.text());
+
+                        if(token.id() == GlslTokenId.COMMA) 
+                            sb.append(KEYWORD_FONT_COLOR);
+                    }
+
+                    first = false;
+                }
+
+            }
+
+            sb.append("</font>)");
+
+            if(!"void".equals(type)) {
+                sb.append(" : ");
+                sb.append(KEYWORD_FONT_COLOR);
+                sb.append(type);
+                sb.append("</font>");
+            }
+            sb.append("</html>");
+            
+        } finally {
+          document.readUnlock();
+        }         
+        
+        return sb.toString();
+    }
+    
+    /**
+     * Assambles a human readable String containing the declaraton of a field and the field name itself.
+     * Asumes that the current token of the SyntaxContext represents the field name.
+     */
+    public static final String createFieldDeclarationString(SyntaxContext context) {
+        
+        AbstractDocument document = (AbstractDocument)context.getDocument();
+        
+        StringBuilder sb = new StringBuilder();
+        
+        try {
+
+            document.readLock();
+            
+            TokenSequence sequence = TokenHierarchy.get(context.getDocument()).tokenSequence();
+            sequence.move(context.getOffset());
+            sequence.moveNext();
+            
+            sb.append("<html>");
+            sb.append(sequence.token().text());
+            sb.append(KEYWORD_FONT_COLOR);
+            sb.append(" :");
+
+            int insertIndex = sb.length();
+
+            // read forward
+            int moved = 0;
+            Token token;
+            while(     sequence.moveNext()
+                    && sequence.token().id() != GlslTokenId.SEMICOLON
+                    && sequence.token().id() != GlslTokenId.COMMA
+                    && sequence.token().id() != GlslTokenId.EQ  ) {
+                token = sequence.token();
+                if(!isIgnoredToken(token)) 
+                    sb.append(token);
+                moved++;
+            }
+            while(moved-- >= 0)
+                sequence.movePrevious();
+
+            // read backwards throw the declaration
+            boolean skipToken = false;
+
+            while(     sequence.movePrevious() 
+                    && sequence.token().id() != GlslTokenId.SEMICOLON 
+                    && sequence.token().id() != GlslTokenId.END_OF_LINE ) {
+
+                token = sequence.token();
+
+                if(!isIgnoredToken(token)) {
+
+                    // we have a struct declaration; skip everything between { }
+                    if(token.id() == GlslTokenId.BRACE && TokenUtilities.equals(token.text(), "}")) {
+                        movePreviousUntil(sequence, GlslTokenId.BRACE, "}", "{");
+                        continue;
+                    }                
+
+                    // skip token in case of an comma seperated identifier list
+                    if(skipToken) {
+                        if(     token.id() == GlslTokenId.BRACKET
+                             && TokenUtilities.equals(token.text(), "]")    ) {
+                            movePreviousUntil(sequence, GlslTokenId.BRACKET, "]", "[");
+                            skipToken = false;
+                        }else {
+                            skipToken = false;
+                        }
+                        continue;
+                    }
+
+                    if(token.id() == GlslTokenId.COMMA) {
+                        skipToken = true;
+                        continue;
+                    }
+
+                    if(!TokenUtilities.equals(token.text(), "struct")) {
+                        sb.insert(insertIndex, token.text());
+                        sb.insert(insertIndex, " ");
+                    }
+                }
+
+            }
+
+            sb.append("</font></html>");
+        } finally {
+            document.readUnlock();
+        } 
+        
+        
+        return sb.toString();
+    }
+   
+        
+    public static final String createPreprocessorString(SyntaxContext context) {
+        
+        ASTNode node = (ASTNode)context.getASTPath().getLeaf();
+        List<ASTItem> children = node.getChildren();
+        
+        String str = null;
+        
+        for (ASTItem item : children)
+            if (isTokenType(item, GlslTokenId.PREPROCESSOR.name()))
+                str = ((ASTToken)item).getIdentifier();
+        
+        
+        for(int i = 0; i < str.length(); i++) {
+            
+            char c = str.charAt(i);
+            
+            if(c != '#' && !Character.isWhitespace(c))
+                for(int j = str.length()-1; j > i; j--)
+                    if(!Character.isWhitespace(str.charAt(j)))
+                        return str.substring(i, j+1);
+            
+        }
+        
+        return str;
+    }
+    
+    /**
+     * called from withen GLSL_*.nbs each time the document has been modified.
+     */
+    public static void process(SyntaxContext context) {
+        
+        AbstractDocument document = (AbstractDocument)context.getDocument();
+        try{
+            document.readLock();
+            
+            // remember all declared funktions for auto completion
+            synchronized(declaredFunctions) {
+                declaredFunctions.clear();
+            }
+
+            List<ASTItem> declarations = context.getASTPath().getLeaf().getChildren();
+
+            for (ASTItem declaration : declarations) {
+
+                for (ASTItem declarationItem : declaration.getChildren()) {
+
+                    if(isNode(declarationItem, "function")) {
+                        
+                        
+                        List<ASTItem> functionItems = declarationItem.getChildren();
+                        
+                        if(functionItems.size() < 3)
+                            break;
+                        
+                        ASTItem nameToken = functionItems.get(0);
+
+                        if(isTokenType(nameToken, GlslTokenId.FUNCTION.name())) {
+                            
+                            // determine return type
+                            StringBuilder returnType = new StringBuilder();
+                            for (ASTItem typeItem : declaration.getChildren()) {
+
+                                if(isNode(typeItem, "function"))
+                                    break;
+
+                                if(typeItem instanceof ASTNode) {
+                                    returnType.append(((ASTNode)typeItem).getAsText().trim());
+                                }else if(typeItem instanceof ASTToken) {
+                                    final ASTToken t = (ASTToken) typeItem;
+                                    returnType.append(t.getIdentifier().trim());
+                                }
+
+                            }
+                            
+                            // determine name and parameter list
+                            StringBuilder name = new StringBuilder();
+                            
+                            name.append("(");
+                            ASTItem parameterList = functionItems.get(2);
+                            if(isNode(parameterList, "parameter_declaration_list"))
+                                name.append(((ASTNode)parameterList).getAsText());
+                            name.append(")");
+
+                            GLSLElementDescriptor elementDesc = new GLSLElementDescriptor(
+                                    GLSLElementDescriptor.Category.USER_FUNC,
+                                    "",
+                                    "",
+                                    name.toString(),
+                                    returnType.toString());
+
+                            name.insert(0, ((ASTToken) nameToken).getIdentifier());
+                            
+                            synchronized(declaredFunctions) {
+                                declaredFunctions.put(name.toString(), elementDesc);
+                            }
+                            
+//                            System.out.println("|"+returnType.toString()+"|"+name.toString()+"|");
+                        }
+                        
+                        break;
+                    }
+                }
+            }
+        }finally{
+            document.readUnlock();
+        }
+
+
+    }
+    
+    private static final void movePreviousUntil(TokenSequence sequence, GlslTokenId id, String countToken, String stopToken) {
+        int counter = 1;
+        while(sequence.movePrevious() && counter > 0) {
+            if(sequence.token().id() == id) {
+                if(TokenUtilities.equals(sequence.token().text(), stopToken)) {
+                    counter--;
+                }else if(TokenUtilities.equals(sequence.token().text(), countToken)){
+                    counter++;
+                }
+            }
+        }
+    }
+    
+    private static final boolean isIgnoredToken(Token token) {
+        return     token.id() == GlslTokenId.WHITESPACE
+                || token.id() == GlslTokenId.COMMENT
+                || token.id() == GlslTokenId.PREPROCESSOR;
+    }
+    
+    private static final boolean isNode(ASTItem item, String nodeToken) {
+        return item != null && item instanceof ASTNode && ((ASTNode)item).getNT().equals(nodeToken);
+    }
+
+    private static final boolean isToken(ASTItem item, String id) {
+        return item != null && item instanceof ASTToken && ((ASTToken)item).getIdentifier().equals(id);
+    }
+
+    private static final boolean isTokenType(ASTItem item, String type) {
+        return item != null && item instanceof ASTToken && ((ASTToken) item).getTypeName().equals(type);
+    }
+
+
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/layer.xml

@@ -0,0 +1,289 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE filesystem PUBLIC "-//NetBeans//DTD Filesystem 1.1//EN" "http://www.netbeans.org/dtds/filesystem-1_1.dtd">
+<filesystem>
+    <folder name="Editors">
+        <folder name="text">
+            
+            <folder name="x-glsl-vertex-shader">
+                <attr name="SystemFileSystem.localizingBundle" stringvalue="net.java.nboglpack.glsleditor.Bundle"/>
+                <file name="vocabulary.xml" url="resources/JmeVocabulary.xml"/>
+                <folder name="CompletionProviders">
+                    <file name="GlslCompletionProvider.instance">
+                        <attr name="instanceCreate" methodvalue="net.java.nboglpack.glsleditor.GlslCompletionProvider.createVSCompletionProvider"/>
+                        <attr name="instanceClass" stringvalue="net.java.nboglpack.glsleditor.GlslCompletionProvider"/>
+                    </file>
+                </folder>
+                <folder name="FontsColors">
+                    <folder name="NetBeans">
+                        <folder name="Defaults">
+                            <file name="coloring.xml" url="resources/NetBeans-glsl-fontsColors.xml">
+                                <attr name="SystemFileSystem.localizingBundle" stringvalue="net.java.nboglpack.glsleditor.Bundle"/>
+                            </file>
+                        </folder>
+                    </folder>
+                </folder>
+                <file name="language.instance">
+                    <attr name="instanceCreate" methodvalue="net.java.nboglpack.glsleditor.lexer.Glsl.vertexLanguage"/>
+                    <attr name="instanceOf" stringvalue="org.netbeans.api.lexer.Language"/>
+                </file>
+              <!--  <file name="EditorKit.instance">
+                    <attr name="instanceCreate" methodvalue="org.netbeans.modules.lexer.editorbridge.LexerEditorKit.create"/>
+                    <attr name="instanceClass" stringvalue="org.netbeans.modules.lexer.editorbridge.LexerEditorKit"/>
+                </file>-->
+                <attr name="createDataObject" boolvalue="false"/>
+                <file name="language.nbs" url="glsl/GLSL_130.nbs"/>
+            </folder>
+            
+            <folder name="x-glsl-fragment-shader">
+                <attr name="SystemFileSystem.localizingBundle" stringvalue="net.java.nboglpack.glsleditor.Bundle"/>
+                <file name="vocabulary.xml" url="resources/JmeVocabulary.xml"/>
+                <folder name="CompletionProviders">
+                    <file name="GlslCompletionProvider.instance">
+                        <attr name="instanceCreate" methodvalue="net.java.nboglpack.glsleditor.GlslCompletionProvider.createFSCompletionProvider"/>
+                        <attr name="instanceClass" stringvalue="net.java.nboglpack.glsleditor.GlslCompletionProvider"/>
+                    </file>
+                </folder>
+                <folder name="FontsColors">
+                    <folder name="NetBeans">
+                        <folder name="Defaults">
+                            <file name="coloring.xml" url="resources/NetBeans-glsl-fontsColors.xml">
+                                <attr name="SystemFileSystem.localizingBundle" stringvalue="net.java.nboglpack.glsleditor.Bundle"/>
+                            </file>
+                        </folder>
+                    </folder>
+                </folder>
+                <file name="language.instance">
+                    <attr name="instanceCreate" methodvalue="net.java.nboglpack.glsleditor.lexer.Glsl.fragmentLanguage"/>
+                    <attr name="instanceOf" stringvalue="org.netbeans.api.lexer.Language"/>
+                </file>
+               <!-- <file name="EditorKit.instance">
+                    <attr name="instanceCreate" methodvalue="org.netbeans.modules.lexer.editorbridge.LexerEditorKit.create"/>
+                    <attr name="instanceClass" stringvalue="org.netbeans.modules.lexer.editorbridge.LexerEditorKit"/>
+                </file>-->
+                <attr name="createDataObject" boolvalue="false"/>
+                <file name="language.nbs" url="glsl/GLSL_130.nbs"/>
+            </folder>
+            
+            <folder name="x-glsl-geometry-shader">
+                <attr name="SystemFileSystem.localizingBundle" stringvalue="net.java.nboglpack.glsleditor.Bundle"/>
+                <file name="vocabulary.xml" url="resources/JmeVocabulary.xml"/>
+                <folder name="CompletionProviders">
+                    <file name="GlslCompletionProvider.instance">
+                        <attr name="instanceCreate" methodvalue="net.java.nboglpack.glsleditor.GlslCompletionProvider.createGSCompletionProvider"/>
+                        <attr name="instanceClass" stringvalue="net.java.nboglpack.glsleditor.GlslCompletionProvider"/>
+                    </file>
+                </folder>
+                <folder name="FontsColors">
+                    <folder name="NetBeans">
+                        <folder name="Defaults">
+                            <file name="coloring.xml" url="resources/NetBeans-glsl-fontsColors.xml">
+                                <attr name="SystemFileSystem.localizingBundle" stringvalue="net.java.nboglpack.glsleditor.Bundle"/>
+                            </file>
+                        </folder>
+                    </folder>
+                </folder>
+                <file name="language.instance">
+                    <attr name="instanceCreate" methodvalue="net.java.nboglpack.glsleditor.lexer.Glsl.geometryLanguage"/>
+                    <attr name="instanceOf" stringvalue="org.netbeans.api.lexer.Language"/>
+                </file>
+              <!--  <file name="EditorKit.instance">
+                    <attr name="instanceCreate" methodvalue="org.netbeans.modules.lexer.editorbridge.LexerEditorKit.create"/>
+                    <attr name="instanceClass" stringvalue="org.netbeans.modules.lexer.editorbridge.LexerEditorKit"/>
+                </file>-->
+                <attr name="createDataObject" boolvalue="false"/>
+                <file name="language.nbs" url="glsl/GLSL_130.nbs"/>
+            </folder>
+        </folder>
+    </folder>
+    
+    <folder name="OptionsDialog">
+        <folder name="PreviewExamples">
+            <folder name="text">
+                <file name="x-glsl-vertex-shader" url="resources/GlslVertexShaderExample.vert"/>
+                <file name="x-glsl-fragment-shader" url="resources/GlslFragmentShaderExample.frag"/>
+                <file name="x-glsl-geometry-shader" url="resources/GlslGeometryShaderExample.geom"/>
+            </folder>
+        </folder>
+    </folder> 
+    
+    <folder name="Loaders">
+        <folder name="text">
+            <folder name="x-glsl-geometry-shader">
+                <folder name="Actions">
+                    <file name="org-openide-actions-CopyAction.instance">
+                        <attr name="position" intvalue="500"/>
+                    </file>
+                    <file name="org-openide-actions-CutAction.instance">
+                        <attr name="position" intvalue="400"/>
+                    </file>
+                    <file name="org-openide-actions-DeleteAction.instance">
+                        <attr name="position" intvalue="700"/>
+                    </file>
+                    <file name="org-openide-actions-FileSystemAction.instance">
+                        <attr name="position" intvalue="200"/>
+                    </file>
+                    <file name="org-openide-actions-OpenAction.instance">
+                        <attr name="position" intvalue="100"/>
+                    </file>
+                    <file name="org-openide-actions-PropertiesAction.instance">
+                        <attr name="position" intvalue="1300"/>
+                    </file>
+                    <file name="org-openide-actions-RenameAction.instance">
+                        <attr name="position" intvalue="800"/>
+                    </file>
+                    <file name="org-openide-actions-SaveAsTemplateAction.instance">
+                        <attr name="position" intvalue="1000"/>
+                    </file>
+                    <file name="org-openide-actions-ToolsAction.instance">
+                        <attr name="position" intvalue="1200"/>
+                    </file>
+                    <file name="sep-1.instance">
+                        <attr name="instanceClass" stringvalue="javax.swing.JSeparator"/>
+                        <attr name="position" intvalue="300"/>
+                    </file>
+                    <file name="sep-2.instance">
+                        <attr name="instanceClass" stringvalue="javax.swing.JSeparator"/>
+                        <attr name="position" intvalue="600"/>
+                    </file>
+                    <file name="sep-3.instance">
+                        <attr name="instanceClass" stringvalue="javax.swing.JSeparator"/>
+                        <attr name="position" intvalue="900"/>
+                    </file>
+                    <file name="sep-4.instance">
+                        <attr name="instanceClass" stringvalue="javax.swing.JSeparator"/>
+                        <attr name="position" intvalue="1100"/>
+                    </file>
+                </folder>
+            </folder>
+            <folder name="x-glsl-vertex-shader">
+                <folder name="Actions">
+                    <file name="org-openide-actions-CopyAction.instance">
+                        <attr name="position" intvalue="500"/>
+                    </file>
+                    <file name="org-openide-actions-CutAction.instance">
+                        <attr name="position" intvalue="400"/>
+                    </file>
+                    <file name="org-openide-actions-DeleteAction.instance">
+                        <attr name="position" intvalue="700"/>
+                    </file>
+                    <file name="org-openide-actions-FileSystemAction.instance">
+                        <attr name="position" intvalue="200"/>
+                    </file>
+                    <file name="org-openide-actions-OpenAction.instance">
+                        <attr name="position" intvalue="100"/>
+                    </file>
+                    <file name="org-openide-actions-PropertiesAction.instance">
+                        <attr name="position" intvalue="1300"/>
+                    </file>
+                    <file name="org-openide-actions-RenameAction.instance">
+                        <attr name="position" intvalue="800"/>
+                    </file>
+                    <file name="org-openide-actions-SaveAsTemplateAction.instance">
+                        <attr name="position" intvalue="1000"/>
+                    </file>
+                    <file name="org-openide-actions-ToolsAction.instance">
+                        <attr name="position" intvalue="1200"/>
+                    </file>
+                    <file name="sep-1.instance">
+                        <attr name="instanceClass" stringvalue="javax.swing.JSeparator"/>
+                        <attr name="position" intvalue="300"/>
+                    </file>
+                    <file name="sep-2.instance">
+                        <attr name="instanceClass" stringvalue="javax.swing.JSeparator"/>
+                        <attr name="position" intvalue="600"/>
+                    </file>
+                    <file name="sep-3.instance">
+                        <attr name="instanceClass" stringvalue="javax.swing.JSeparator"/>
+                        <attr name="position" intvalue="900"/>
+                    </file>
+                    <file name="sep-4.instance">
+                        <attr name="instanceClass" stringvalue="javax.swing.JSeparator"/>
+                        <attr name="position" intvalue="1100"/>
+                    </file>
+                </folder>
+            </folder>
+            <folder name="x-glsl-fragment-shader">
+                <folder name="Actions">
+                    <file name="org-openide-actions-CopyAction.instance">
+                        <attr name="position" intvalue="500"/>
+                    </file>
+                    <file name="org-openide-actions-CutAction.instance">
+                        <attr name="position" intvalue="400"/>
+                    </file>
+                    <file name="org-openide-actions-DeleteAction.instance">
+                        <attr name="position" intvalue="700"/>
+                    </file>
+                    <file name="org-openide-actions-FileSystemAction.instance">
+                        <attr name="position" intvalue="200"/>
+                    </file>
+                    <file name="org-openide-actions-OpenAction.instance">
+                        <attr name="position" intvalue="100"/>
+                    </file>
+                    <file name="org-openide-actions-PropertiesAction.instance">
+                        <attr name="position" intvalue="1300"/>
+                    </file>
+                    <file name="org-openide-actions-RenameAction.instance">
+                        <attr name="position" intvalue="800"/>
+                    </file>
+                    <file name="org-openide-actions-SaveAsTemplateAction.instance">
+                        <attr name="position" intvalue="1000"/>
+                    </file>
+                    <file name="org-openide-actions-ToolsAction.instance">
+                        <attr name="position" intvalue="1200"/>
+                    </file>
+                    <file name="sep-1.instance">
+                        <attr name="instanceClass" stringvalue="javax.swing.JSeparator"/>
+                        <attr name="position" intvalue="300"/>
+                    </file>
+                    <file name="sep-2.instance">
+                        <attr name="instanceClass" stringvalue="javax.swing.JSeparator"/>
+                        <attr name="position" intvalue="600"/>
+                    </file>
+                    <file name="sep-3.instance">
+                        <attr name="instanceClass" stringvalue="javax.swing.JSeparator"/>
+                        <attr name="position" intvalue="900"/>
+                    </file>
+                    <file name="sep-4.instance">
+                        <attr name="instanceClass" stringvalue="javax.swing.JSeparator"/>
+                        <attr name="position" intvalue="1100"/>
+                    </file>
+                </folder>
+            </folder>
+        </folder>
+    </folder>
+    
+    <folder name="Services">
+        <folder name="MIMEResolver">
+            <file name="GlslFragmentShaderResolver.xml" url="resources/GlslFragmentShaderResolver.xml">
+                <attr name="SystemFileSystem.icon" urlvalue="nbresloc:/net/java/nboglpack/glsleditor/resources/FragmentShaderIcon.gif"/>
+                <attr name="SystemFileSystem.localizingBundle" stringvalue="net.java.nboglpack.glsleditor.dataobject.Bundle"/>
+            </file>
+            <file name="GlslGeometryShaderResolver.xml" url="resources/GlslGeometryShaderResolver.xml">
+                <attr name="SystemFileSystem.icon" urlvalue="nbresloc:/net/java/nboglpack/glsleditor/resources/GeometryShaderIcon.gif"/>
+                <attr name="SystemFileSystem.localizingBundle" stringvalue="net.java.nboglpack.glsleditor.dataobject.Bundle"/>
+            </file>
+            <file name="GlslVertexShaderResolver.xml" url="resources/GlslVertexShaderResolver.xml">
+                <attr name="SystemFileSystem.icon" urlvalue="nbresloc:/net/java/nboglpack/glsleditor/resources/VertexShaderIcon.gif"/>
+                <attr name="SystemFileSystem.localizingBundle" stringvalue="net.java.nboglpack.glsleditor.dataobject.Bundle"/>
+            </file>
+        </folder>
+    </folder>
+    
+    <folder name="Templates">
+        <folder name="OpenGL">
+            <file name="FragmentShader.frag" url="resources/FragmentShaderTemplate.frag">
+                <attr name="SystemFileSystem.localizingBundle" stringvalue="net.java.nboglpack.glsleditor.dataobject.Bundle"/>
+                <attr name="template" boolvalue="true"/>
+            </file>
+            <file name="GeometryShader.geom" url="resources/GeometryShaderTemplate.geom">
+                <attr name="SystemFileSystem.localizingBundle" stringvalue="net.java.nboglpack.glsleditor.dataobject.Bundle"/>
+                <attr name="template" boolvalue="true"/>
+            </file>
+            <file name="VertexShader.vert" url="resources/VertexShaderTemplate.vert">
+                <attr name="SystemFileSystem.localizingBundle" stringvalue="net.java.nboglpack.glsleditor.dataobject.Bundle"/>
+                <attr name="template" boolvalue="true"/>
+            </file>
+            <attr name="position" intvalue="2000"/>
+        </folder>
+    </folder>
+</filesystem>

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/lexer/Glsl.java

@@ -0,0 +1,61 @@
+/*
+ * VertexLanguage.java
+ * 
+ * Created on 19.08.2007, 18:25:24
+ * 
+ */
+
+package net.java.nboglpack.glsleditor.lexer;
+
+import java.util.Collection;
+import java.util.EnumSet;
+import net.java.nboglpack.glsleditor.GlslVocabularyManager;
+import net.java.nboglpack.glsleditor.dataobject.GlslFragmentShaderDataLoader;
+import net.java.nboglpack.glsleditor.dataobject.GlslGeometryShaderDataLoader;
+import net.java.nboglpack.glsleditor.dataobject.GlslVertexShaderDataLoader;
+import org.netbeans.api.lexer.Language;
+import org.netbeans.spi.lexer.LanguageHierarchy;
+import org.netbeans.spi.lexer.Lexer;
+import org.netbeans.spi.lexer.LexerRestartInfo;
+
+/**
+ * OpenGL Shading Language.
+ * @author Michael Bien
+ */
+public class Glsl extends LanguageHierarchy<GlslTokenId> {
+ 
+ public static final Glsl VERTEX_LANGUAGE = new Glsl(GlslVertexShaderDataLoader.REQUIRED_MIME);
+ public static final Glsl GEOMETRY_LANGUAGE = new Glsl(GlslGeometryShaderDataLoader.REQUIRED_MIME);
+ public static final Glsl FRAGMENT_LANGUAGE = new Glsl(GlslFragmentShaderDataLoader.REQUIRED_MIME);
+ 
+ private final String mimeType;
+ 
+ private Glsl(String mimeType) {
+     this.mimeType = mimeType;
+ }
+ 
+    @Override
+    protected String mimeType() {
+        return mimeType;
+    }
+
+    @Override
+    protected Collection<GlslTokenId> createTokenIds() {
+        return EnumSet.allOf(GlslTokenId.class);
+    }
+    
+    @Override
+    protected Lexer<GlslTokenId> createLexer(LexerRestartInfo<GlslTokenId> info) {
+        return new GlslLexer(info, GlslVocabularyManager.getInstance(mimeType()));
+    }
+    
+    public static Language<GlslTokenId> vertexLanguage(){
+        return VERTEX_LANGUAGE.language();
+    }
+    public static Language<GlslTokenId> fragmentLanguage(){
+        return FRAGMENT_LANGUAGE.language();
+    }
+    public static Language<GlslTokenId> geometryLanguage(){
+        return GEOMETRY_LANGUAGE.language();
+    }
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/lexer/GlslLexer.java

@@ -0,0 +1,343 @@
+/*
+ * GlslLexer.java
+ * 
+ * Created on 19.08.2007, 18:31:16
+ * 
+ */
+
+package net.java.nboglpack.glsleditor.lexer;
+
+import net.java.nboglpack.glsleditor.GlslVocabularyManager;
+import net.java.nboglpack.glsleditor.vocabulary.GLSLElementDescriptor;
+import org.netbeans.api.lexer.Token;
+import org.netbeans.spi.lexer.Lexer;
+import org.netbeans.spi.lexer.LexerInput;
+import org.netbeans.spi.lexer.LexerRestartInfo;
+import org.netbeans.spi.lexer.TokenFactory;
+
+
+/**
+ * Lexer for the OpenGL Shading Language.
+ * @author Michael Bien
+ */
+public class GlslLexer implements Lexer<GlslTokenId> {
+ 
+ private final LexerInput input;
+ private final TokenFactory<GlslTokenId> factory;
+ private final GlslVocabularyManager manager;
+ private final StringBuilder stringBuilder;
+ 
+ 
+ public GlslLexer(LexerRestartInfo<GlslTokenId> info, GlslVocabularyManager manager) {
+     this.input = info.input();
+     this.factory = info.tokenFactory();
+     this.manager = manager;
+     this.stringBuilder = new StringBuilder();
+ }
+
+    @SuppressWarnings("fallthrough")
+    public Token<GlslTokenId> nextToken() {
+        
+        int character = input.read();
+        
+        switch(character) {
+            
+            case '(':
+            case ')':
+                return factory.createToken(GlslTokenId.PAREN);
+            case '{':
+            case '}':
+                return factory.createToken(GlslTokenId.BRACE);
+            case '[':
+            case ']':
+                return factory.createToken(GlslTokenId.BRACKET);
+            case '.':
+                return factory.createToken(GlslTokenId.DOT);
+            case ',':
+                return factory.createToken(GlslTokenId.COMMA);
+            case ':':
+                return factory.createToken(GlslTokenId.COLON);
+            case ';':
+                return factory.createToken(GlslTokenId.SEMICOLON);
+            case '?':
+                return factory.createToken(GlslTokenId.QUESTION);
+            case '~':
+                return factory.createToken(GlslTokenId.TILDE);
+            case '*':
+                if(input.read() == '=') {
+                    return factory.createToken(GlslTokenId.MUL_ASSIGN);
+                }else{
+                    input.backup(1);
+                    return factory.createToken(GlslTokenId.STAR);
+                }
+            case '%':
+                if(input.read() == '=') {
+                    return factory.createToken(GlslTokenId.MOD_ASSIGN);
+                }else{
+                    input.backup(1);
+                    return factory.createToken(GlslTokenId.PERCENT);
+                }
+            case '!':
+                if(input.read() == '=') {
+                    return factory.createToken(GlslTokenId.NE);
+                }else{
+                    input.backup(1);
+                    return factory.createToken(GlslTokenId.BANG);
+                }
+            case '=':
+                if(input.read() == '=') {
+                    return factory.createToken(GlslTokenId.EQEQ);
+                }else{
+                    input.backup(1);
+                    return factory.createToken(GlslTokenId.EQ);
+                }
+            case '^':
+                switch(input.read()) {
+                    case('^'):
+                        return factory.createToken(GlslTokenId.CARETCARET);
+                    case('='):
+                        return factory.createToken(GlslTokenId.XOR_ASSIGN);
+                    default:
+                        input.backup(1);
+                        return factory.createToken(GlslTokenId.CARET);
+                }
+            case '+':
+                switch(input.read()) {
+                    case('+'):
+                        return factory.createToken(GlslTokenId.PLUSPLUS);
+                    case('='):
+                        return factory.createToken(GlslTokenId.ADD_ASSIGN);
+                    default:
+                        input.backup(1);
+                        return factory.createToken(GlslTokenId.PLUS);
+                }
+            case '-':
+                switch(input.read()) {
+                    case('-'):
+                        return factory.createToken(GlslTokenId.MINUSMINUS);
+                    case('='):
+                        return factory.createToken(GlslTokenId.SUB_ASSIGN);
+                    default:
+                        input.backup(1);
+                        return factory.createToken(GlslTokenId.MINUS);
+                }
+            case '&':
+                switch(input.read()) {
+                    case('&'):
+                        return factory.createToken(GlslTokenId.AMPAMP);
+                    case('='):
+                        return factory.createToken(GlslTokenId.AND_ASSIGN);
+                    default:
+                        input.backup(1);
+                        return factory.createToken(GlslTokenId.AMP);
+                }
+            case '|':
+                switch(input.read()) {
+                    case('|'):
+                        return factory.createToken(GlslTokenId.BARBAR);
+                    case ('='):
+                        return factory.createToken(GlslTokenId.OR_ASSIGN);
+                    default:
+                        input.backup(1);
+                        return factory.createToken(GlslTokenId.BAR);
+                }
+            case '<':
+                switch(input.read()) {
+                    case('<'):
+                        if(input.read() == '=') {
+                            return factory.createToken(GlslTokenId.LEFT_BITSHIFT_ASSIGN);
+                        }else{
+                            input.backup(1);
+                            return factory.createToken(GlslTokenId.LEFT_BITSHIFT);
+                        }
+                    case('='):
+                        return factory.createToken(GlslTokenId.LE);
+                    default:
+                        input.backup(1);
+                        return factory.createToken(GlslTokenId.LEFT_ANGLE);
+                }
+            case '>':
+                switch(input.read()) {
+                    case('>'):
+                        if(input.read() == '=') {
+                            return factory.createToken(GlslTokenId.RIGHT_BITSHIFT_ASSIGN);
+                        }else{
+                            input.backup(1);
+                            return factory.createToken(GlslTokenId.RIGHT_BITSHIFT);
+                        }
+                    case('='):
+                        return factory.createToken(GlslTokenId.GE);
+                    default:
+                        input.backup(1);
+                        return factory.createToken(GlslTokenId.RIGHT_ANGLE);
+                }
+            case '/':
+                int c = input.read();
+                if(c == '/') {
+                    readRemainingLine();
+                    return factory.createToken(GlslTokenId.COMMENT);
+                }else if(c == '*') {
+                    return tokenizeMLComment();
+                }else if(c == '=') {
+                    return factory.createToken(GlslTokenId.DIV_ASSIGN);
+                }else{
+                    input.backup(1);
+                    return factory.createToken(GlslTokenId.SLASH);
+                }
+            case '#':
+                readRemainingLine();
+                return factory.createToken(GlslTokenId.PREPROCESSOR);
+            case ' ':
+            case '\t':
+                do{
+                    character = input.read();
+                }while(character == ' ' || character == '\t');
+                input.backup(1);                
+                return factory.createToken(GlslTokenId.WHITESPACE);
+            case '\r':
+                input.consumeNewline();
+            case LexerInput.EOF:
+                if(input.readLength() == 0)
+                    return null;
+            case '\n':
+                return factory.createToken(GlslTokenId.END_OF_LINE);
+            default:
+                if(Character.isDigit(character)) {
+                    return tokenizeNumber();
+                }else if(Character.isUnicodeIdentifierStart(character)) {
+                    return tokenizeName();
+                }else{
+                    return factory.createToken(GlslTokenId.error);
+                }
+        }
+      
+    }
+    
+    @SuppressWarnings("fallthrough")
+    private final void readRemainingLine() {
+        
+        int character = input.read();
+        
+        while(character != LexerInput.EOF) {
+            switch (character) {
+                case '\r':
+                    input.consumeNewline();
+                case '\n':
+                case LexerInput.EOF:
+                    return;
+            }
+            character = input.read();
+        }
+        
+    }
+    
+    private final Token<GlslTokenId> tokenizeMLComment() {
+        
+        int character = input.read();
+        
+        while(character != LexerInput.EOF) {
+            if(character == '*' && input.read() == '/') {
+                return factory.createToken(GlslTokenId.ML_COMMENT);
+            }
+            character = input.read();
+        }
+        return factory.createToken(GlslTokenId.ML_COMMENT);
+        
+    }
+    
+    private final Token<GlslTokenId> tokenizeNumber() {
+        
+        int character;
+        
+        do{
+            character = input.read();
+        }while(Character.isDigit(character));
+        
+        if(character == '.') {
+            
+            do{
+                character = input.read();
+            }while(Character.isDigit(character));
+            
+            if(character != 'f' && character != 'F')
+                input.backup(1);
+            
+            return factory.createToken(GlslTokenId.FLOAT_LITERAL);
+            
+        }else{
+
+            if(character != 'u' && character != 'U')
+                input.backup(1);
+            
+//            input.backup(1);
+            return factory.createToken(GlslTokenId.INTEGER_LITERAL);
+            
+        }
+    }
+    
+    private final Token<GlslTokenId> tokenizeName() {
+        
+        if(stringBuilder.length() > 0)
+            stringBuilder.delete(0, stringBuilder.length());
+        
+        // backup everything read
+        input.backup(input.readLength()); 
+        
+        // assamble token
+        char c;
+        while(Character.isUnicodeIdentifierPart(c = ((char)input.read())))        
+            stringBuilder.append(c);
+        
+        if(stringBuilder.length() > 0)
+            input.backup(1);
+                
+        // categorise token
+        GLSLElementDescriptor[] desc = manager.getDesc(stringBuilder.toString());
+        
+        if(desc != null) {
+            
+            if(desc[0].category != null) {
+                
+                if(desc[0].category == GLSLElementDescriptor.Category.BUILD_IN_FUNC) 
+                    return factory.createToken(GlslTokenId.BUILD_IN_FUNC);
+
+                if(desc[0].category == GLSLElementDescriptor.Category.BUILD_IN_VAR) 
+                    return factory.createToken(GlslTokenId.BUILD_IN_VAR);
+            
+                return factory.createToken(GlslTokenId.KEYWORD);
+                
+            }
+        }
+        
+        // check if token = function name
+        int tokenEnd = input.readLength();
+        int character = input.read();
+        
+        while(true) {
+            switch (character) {
+                case ' ':
+                case '\t':
+                case '\r':
+                case '\n':
+                    character = input.read();
+                    break;
+                case '(':
+                    input.backup(input.readLength()-tokenEnd);
+                    return factory.createToken(GlslTokenId.FUNCTION);
+                default:
+                    input.backup(input.readLength()-tokenEnd);
+                    return factory.createToken(GlslTokenId.IDENTIFIER);
+            }
+        }
+        
+    }
+
+    public Object state() {
+        // we don't need states
+        return null;
+    }
+
+    public void release() {
+    }
+
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/lexer/GlslTokenId.java

@@ -0,0 +1,90 @@
+/*
+ * GlslTokenId.java
+ * 
+ * Created on 19.08.2007, 18:09:00
+ * 
+ */
+
+package net.java.nboglpack.glsleditor.lexer;
+
+import org.netbeans.api.lexer.TokenId;
+
+/**
+ * Enumeration of GLSL token ids.
+ * @author Michael Bien
+ */
+public enum GlslTokenId implements TokenId {
+    
+
+ IDENTIFIER("glsl-name"),
+ INTEGER_LITERAL("glsl-literal"),
+ FLOAT_LITERAL("glsl-literal"),
+ FUNCTION("glsl-function"),
+ KEYWORD("glsl-keyword"),
+ BUILD_IN_FUNC("glsl-build-in-func"),
+ BUILD_IN_VAR("glsl-build-in-var"),
+ COMMENT("glsl-comment"),
+ ML_COMMENT("glsl-comment"),
+ 
+ PAREN("glsl-paren"),
+ BRACE("glsl-brace"),
+ BRACKET("glsl-bracket"),
+ LEFT_ANGLE("glsl-angle"),
+ RIGHT_ANGLE("glsl-angle"),
+ 
+ SEMICOLON("glsl-separator"),
+ COMMA("glsl-separator"),
+ DOT("glsl-separator"),
+ COLON("glsl-separator"),
+ 
+ PERCENT("glsl-operation"),
+ STAR("glsl-operation"),
+ TILDE("glsl-operation"),
+ QUESTION("glsl-operation"),
+ BANG("glsl-operation"),
+ SLASH("glsl-operation"),
+ LEFT_BITSHIFT("glsl-operation"),
+ RIGHT_BITSHIFT("glsl-operation"),
+ PLUS("glsl-operation"),
+ PLUSPLUS("glsl-operation"),
+ MINUS("glsl-operation"),
+ MINUSMINUS("glsl-operation"),
+ AMP("glsl-operation"),
+ AMPAMP("glsl-operation"),
+ EQ("glsl-operation"),
+ EQEQ("glsl-operation"),
+ NE("glsl-operation"),
+ LE("glsl-operation"),
+ GE("glsl-operation"),
+ BAR("glsl-operation"),
+ BARBAR("glsl-operation"),
+ CARET("glsl-operation"),
+ CARETCARET("glsl-operation"),
+ ADD_ASSIGN("glsl-operation"),
+ SUB_ASSIGN("glsl-operation"),
+ MUL_ASSIGN("glsl-operation"),
+ DIV_ASSIGN("glsl-operation"),
+ AND_ASSIGN("glsl-operation"),
+ OR_ASSIGN("glsl-operation"),
+ XOR_ASSIGN("glsl-operation"),
+ MOD_ASSIGN("glsl-operation"),
+ LEFT_BITSHIFT_ASSIGN("glsl-operation"),
+ RIGHT_BITSHIFT_ASSIGN("glsl-operation"),
+ 
+ WHITESPACE("glsl-whitespace"),
+ END_OF_LINE("glsl-end-of-line"),
+ PREPROCESSOR("glsl-preprocessor"),
+
+ error("glsl-error");
+ 
+ private final String primaryCategory;
+   
+ private GlslTokenId(String primaryCategory) {
+    this.primaryCategory = primaryCategory;
+ }
+
+    public String primaryCategory() {
+        return primaryCategory;
+    }
+  
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/resources/FragmentShaderTemplate.frag

@@ -0,0 +1,8 @@
+/*
+* fragment shader template
+*/
+void main() {
+    // Set the fragment color for example to gray, alpha 1.0
+    gl_FragColor = vec4(0.5, 0.5, 0.5, 1.0);  
+}
+

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/resources/GeometryShaderTemplate.geom

@@ -0,0 +1,26 @@
+/*
+* geometry shader template
+*/
+
+#version 120 
+#extension GL_EXT_geometry_shader4 : enable 
+ 
+// a passthrough geometry shader for color and position 
+void main(void) { 
+
+    for(int i = 0; i < gl_VerticesIn; ++i) { 
+
+        // copy color 
+        gl_FrontColor = gl_FrontColorIn[i]; 
+
+        // copy position 
+        gl_Position = gl_PositionIn[i]; 
+
+        // done with the vertex 
+        EmitVertex(); 
+
+    } 
+
+    EndPrimitive();
+
+} 

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/resources/GlslFragmentShaderExample.frag

@@ -0,0 +1,28 @@
+// ------ Fragment shader ------ //
+
+#pragma debug(on)
+
+varying vec3 normal;
+
+/*
+* Toon shader
+*/
+void main() {
+
+    float intensity;
+    vec4 color;
+    vec3 n = normalize(normal);
+
+    intensity = dot(vec3(gl_LightSource[0].position),n);
+
+    if (intensity > 0.95)
+        color = vec4(1.0,0.5,0.5,1.0);
+    else if (intensity > 0.5)
+        color = vec4(0.6,0.3,0.3,1.0);
+    else if (intensity > 0.25)
+        color = vec4(0.4,0.2,0.2,1.0);
+    else
+        color = vec4(0.2,0.1,0.1,1.0);
+
+    gl_FragColor = color;
+} 

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/resources/GlslFragmentShaderResolver.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE MIME-resolver PUBLIC "-//NetBeans//DTD MIME Resolver 1.0//EN" "http://www.netbeans.org/dtds/mime-resolver-1_0.dtd">
+<MIME-resolver>
+    <file>
+        <ext name="frag"/>
+        <ext name="fragment"/>
+        <ext name="glfrag"/>
+        <ext name="glslfrag"/>
+        <ext name="glslfragment"/>
+        <ext name="glfragmentshader"/>
+        <ext name="glslfragmentshader"/>
+        <ext name="glsl-frag"/>
+        <ext name="glsl-fragment"/>
+        <ext name="gl-fragment-shader"/>
+        <ext name="glsl-fragment-shader"/>
+        <resolver mime="text/x-glsl-fragment-shader"/>
+    </file>
+</MIME-resolver>

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/resources/GlslGeometryShaderExample.geom

@@ -0,0 +1,26 @@
+// ------ Geometry shader ------ //
+
+#version 120 
+#extension GL_EXT_geometry_shader4 : enable 
+
+/*
+* a passthrough geometry shader for color and position 
+*/
+void main() { 
+
+  for(int i = 0; i < gl_VerticesIn; ++i) { 
+
+    // copy color 
+    gl_FrontColor = gl_FrontColorIn[i]; 
+ 
+    // copy position 
+    gl_Position = gl_PositionIn[i]; 
+ 
+    // done with the vertex 
+    EmitVertex(); 
+
+  } 
+
+  EndPrimitive();
+
+} 

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/resources/GlslGeometryShaderResolver.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE MIME-resolver PUBLIC "-//NetBeans//DTD MIME Resolver 1.0//EN" "http://www.netbeans.org/dtds/mime-resolver-1_0.dtd">
+<MIME-resolver>
+    <file>
+        <ext name="geom"/>
+        <ext name="geometry"/>
+        <ext name="glgeom"/>
+        <ext name="glslgeom"/>
+        <ext name="glslgeometry"/>
+        <ext name="glgeometryshader"/>
+        <ext name="glslgeometryshader"/>
+        <ext name="glsl-geom"/>
+        <ext name="glsl-geometry"/>
+        <ext name="gl-geometry-shader"/>
+        <ext name="glsl-geometry-shader"/>
+        <resolver mime="text/x-glsl-geometry-shader"/>
+    </file>
+</MIME-resolver>

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/resources/GlslVertexShaderExample.vert

@@ -0,0 +1,29 @@
+// ------ Vertex shader ------ //
+
+#pragma debug(on)
+
+uniform vec3 LightPosition;
+const float SpecularContribution = 0.3;
+varying float LightIntensity;
+
+/*
+* main function
+*/
+void main()  {
+
+    vec3 ecPosition = vec3 (gl_ModelViewMatrix * gl_Vertex);
+    vec3 tnorm      = normalize(gl_NormalMatrix * gl_Normal);
+    vec3 lightVec   = normalize(LightPosition - ecPosition);
+    vec3 reflectVec = reflect(-lightVec, tnorm);
+    vec3 viewVec    = normalize(-ecPosition);
+    float diffuse   = max(dot(lightVec, tnorm), 0.0);
+    float spec      = 0.0;
+
+    if (diffuse > 0.0)    {
+        spec = max(dot(reflectVec, viewVec), 0.0);
+        spec = pow(spec, 16.0);
+    }
+
+    LightIntensity  = 0.7 * diffuse + SpecularContribution * spec;
+    gl_Position     = ftransform();
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/resources/GlslVertexShaderResolver.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE MIME-resolver PUBLIC "-//NetBeans//DTD MIME Resolver 1.0//EN" "http://www.netbeans.org/dtds/mime-resolver-1_0.dtd">
+<MIME-resolver>
+    <file>
+        <ext name="vert"/>
+        <ext name="vertex"/>
+        <ext name="glvert"/>
+        <ext name="glslvert"/>
+        <ext name="glslvertex"/>
+        <ext name="glvertexshader"/>
+        <ext name="glslvertexshader"/>
+        <ext name="glsl-vert"/>
+        <ext name="glsl-vertex"/>
+        <ext name="gl-vertex-shader"/>
+        <ext name="glsl-vertex-shader"/>
+        <resolver mime="text/x-glsl-vertex-shader"/>
+    </file>
+</MIME-resolver>

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/resources/NetBeans-glsl-fontsColors.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE fontscolors PUBLIC "-//NetBeans//DTD Editor Fonts and Colors settings 1.1//EN" "http://www.netbeans.org/dtds/EditorFontsColors-1_1.dtd">
+<fontscolors>
+    <fontcolor name="glsl-keyword" default="keyword"/>
+    <fontcolor name="glsl-name" default="identifier"/>
+    <fontcolor name="glsl-function" default="identifier">
+        <font style="bold"/>
+    </fontcolor>
+    <fontcolor name="glsl-brace" default="operator"/>
+    <fontcolor name="glsl-value" default="number"/>
+    <fontcolor name="glsl-curly-brace" default="operator"/>
+    <fontcolor name="glsl-string-value" default="default"/>
+    <fontcolor name="glsl-comment" default="comment"/>
+    <fontcolor name="glsl-separator" default="operator"/>
+    <fontcolor name="glsl-whitespace" default="whitespace"/>
+    <fontcolor name="glsl-end-of-line" default="whitespace"/>
+    <fontcolor name="glsl-build-in-var" default="string">
+        <font style="bold"/>
+    </fontcolor>
+    <fontcolor name="glsl-build-in-func" default="identifier">
+        <font style="bold,italic"/>
+    </fontcolor>
+    <fontcolor name="glsl-preprocessor" foreColor="ff6060D0">
+        <font style="bold,italic" />
+    </fontcolor>
+</fontscolors>

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/resources/VertexShaderTemplate.vert

@@ -0,0 +1,7 @@
+/*
+* vertex shader template
+*/
+void main() { 
+    // Vertex transformation 
+    gl_Position = ftransform(); 
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/vocabulary/GLSLElementDescriptor.java

@@ -0,0 +1,56 @@
+/*
+ * GLSLElementDescriptor.java
+ * 
+ * Created on 03.06.2007, 23:03:57
+ * 
+ */
+package net.java.nboglpack.glsleditor.vocabulary;
+
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlEnum;
+import javax.xml.bind.annotation.XmlType;
+
+/**
+ *
+ * @author Michael Bien
+ */
+public class GLSLElementDescriptor {
+ 
+ @XmlType
+ @XmlEnum(String.class)
+ public enum Category { BUILD_IN_FUNC, BUILD_IN_VAR, USER_FUNC, JUMP, ITERATION, SELECTION, QUALIFIER, TYPE, KEYWORD  }
+ 
+  @XmlElement
+  public final Category category;
+  
+  @XmlElement(required = true)
+  public final String tooltip;
+  
+  @XmlElement(required = true)
+  public final String doc;
+  
+  @XmlElement(required = true)
+  public final String arguments;
+  
+  @XmlElement(required = true)
+  public final String type;
+
+    /*bean constructor, fields are directly injected*/
+    public GLSLElementDescriptor() {
+        category    = Category.KEYWORD;
+        tooltip     = null;
+        doc         = null;
+        arguments   = null;
+        type        = null;
+    }
+
+    public GLSLElementDescriptor(Category category, String tooltip, String doc, String arguments, String type) {
+        this.category  = category;
+        this.tooltip   = tooltip;
+        this.doc       = doc;
+        this.arguments = arguments;
+        this.type      = type;
+    }
+
+
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/vocabulary/GLSLVocabulary.java

@@ -0,0 +1,33 @@
+/*
+ * GLSLVocabulary.java
+ * 
+ * Created on 03.06.2007, 23:03:57
+ * 
+ */
+package net.java.nboglpack.glsleditor.vocabulary;
+
+import java.util.HashMap;
+import javax.xml.bind.annotation.XmlRootElement;
+
+/**
+ *
+ * @author Michael Bien
+ */
+@XmlRootElement
+public class GLSLVocabulary {
+
+ public final HashMap<String, GLSLElementDescriptor[]> mainVocabulary;
+ public final HashMap<String, GLSLElementDescriptor[]> fragmentShaderVocabulary;
+ public final HashMap<String, GLSLElementDescriptor[]> vertexShaderVocabulary;
+ public final HashMap<String, GLSLElementDescriptor[]> geometryShaderVocabulary;
+ 
+    
+    public GLSLVocabulary() {
+        mainVocabulary           = new HashMap<String, GLSLElementDescriptor[]>();
+        vertexShaderVocabulary   = new HashMap<String, GLSLElementDescriptor[]>();
+        fragmentShaderVocabulary = new HashMap<String, GLSLElementDescriptor[]>();
+        geometryShaderVocabulary = new HashMap<String, GLSLElementDescriptor[]>();
+    }
+ 
+ 
+}

sdk/jme3-glsl-support/src/net/java/nboglpack/glsleditor/vocabulary/jaxb.index

@@ -0,0 +1,2 @@
+GLSLElementDescriptor
+GLSLVocabulary

sdk/jme3-glsl-support/test/unit/src/META-INF/services/org.openide.loaders.DataLoader

@@ -0,0 +1 @@
+net.java.nboglpack.glsleditor.GlslGeometryShaderDataLoader

sdk/nbproject/platform.properties

@@ -51,7 +51,6 @@ disabled.modules=\
     org.netbeans.modules.jellytools.java,\
     org.netbeans.modules.jellytools.platform,\
     org.netbeans.modules.jemmy,\
-    org.netbeans.modules.languages,\
     org.netbeans.modules.maven,\
     org.netbeans.modules.maven.coverage,\
     org.netbeans.modules.maven.embedder,\

sdk/nbproject/project.properties

@@ -44,6 +44,7 @@ modules=\
     ${project.com.jme3.gde.obfuscate}:\
     ${project.com.jme3.gde.blender}:\
     ${project.com.jme3.gde.angelfont}:\
+    ${project.net.java.nboglpack.glsleditor}:\
     ${project.com.jme3.gde.android}
 project.com.jme3.gde.android=jme3-android
 project.com.jme3.gde.angelfont=jme3-angelfont
@@ -51,6 +52,7 @@ project.com.jme3.gde.blender=jme3-blender
 project.com.jme3.gde.codecheck=jme3-code-check
 project.com.jme3.gde.customcontrols=jme3-custom-controls
 project.com.jme3.gde.desktop.executables=jme3-desktop-executables
+project.net.java.nboglpack.glsleditor=jme3-glsl-support
 project.com.jme3.gde.assetpack=jme3-assetpack-support
 project.com.jme3.gde.cinematics=jme3-cinematics
 project.com.jme3.gde.codepalette=jme3-codepalette