<?xml version="1.0" encoding="UTF-8"?>
<!--
   - Ant build for JOGL.  This build has been tested with ANT 1.7.0.  The
   - optional.jar that contains the optional ANT tasks must be in the ANT
   - classpath (typically the ant/lib directory).
   -
   - A clean download of JOGL is required for this build.
   -
   - This build has no dependence on environment variables; the needed
   - ones (e.g. java.home, ANT_HOME) are all set by the Ant wrapper shell
   - script, by the virtual machine, or elsewhere. However, on all platforms,
   - the C compiler and linker should be in the path. All other paths that
   - need to be set are in host.properties.
   -
   - NOTE:  because the GlueGen config files have their own relative paths
   -        which cannot be overridden by GlueGen, GlueGen MUST be run from
   -        the "make" directory. This also means that this build-jogl.xml MUST
   -        be run from the "make" directory.
   -
   - Public targets:
   -   all: (default; autodetects OS and chooses C compiler from gluegen.properties)
   -   clean:        clean all built
   -   javadoc:      create the standard developer Javadoc (recommended)
   -                 (Note: should build all first - may be dependence in the future)
   -   javadoc.spec:   create the standard developer Javadoc but exclude com.sun.* classes
   -   javadoc.dev.all: create the internal developer Javadoc.  This includes the
   -                       Java and C file generators. Note that it is only supported
   -                       to create the Javadoc for the platform on which you are
   -                       currently running.
   - 
   - Note: on Windows the "win32.c.compiler" property in gluegen.properties
   - is required to select the appropriate C compiler. See the example
   - gluegen.properties in this directory for valid values. On Mac OS X
   - universal binaries may also be built by setting the "macosxfat"
   - property in gluegen.properties; again see the example file in this
   - directory.
   -   
   - Optional properties:
   -   -Djogl.cg=1 when combined with the build or javadoc targets will cause
   -               the experimental binding to NVidia's Cg language to be built.
   -
   - Thanks to Rob Grzywinski and Artur Biesiadowski for the bulk of the
   - ANT build, including the GlueGen and StaticGLInfo tasks, the building of
   - the Java generated sources, the first and second phase Java compiles, and
   - the building of the jar file. Thanks to Alex Radeski for the bulk of the
   - port to the ant-contrib CPPTask framework. Thanks to Athomas Goldberg for
   - the original OS detection code.
   -
   - Some environment defs affecting compilation

   - setup.nodesktop is set iff:
        !isWindows && !isOSX && !isX11

   - Internal settings, may not be necessary to set them manually,
     since all JAR archives are orthogonal.
       setup.noAWT
       setup.noCDC

   - Skip gluegen: java.generate.skip
   -->
<project name="JOGL" basedir="." default="all">

    <import file="build-common.xml"/>

    <!-- ================================================================== -->
    <!-- 
       - Base initialization and detection of operating system.
      -->
    <target name="partitioning.setup" depends="common.init">
        <property name="java.part.core" 
                  value="javax/media/opengl/* javax/media/opengl/fixedfunc/* javax/media/opengl/glu/* javax/media/opengl/glu/gl2es1/* com/jogamp/opengl/impl/* com/jogamp/opengl/impl/glu/* com/jogamp/opengl/impl/glu/error/*"/>
        <property name="java.part.core.exclude" value="javax/media/opengl/Debug* javax/media/opengl/Trace*"/>

        <property name="java.part.nv-cg"
                  value="com/jogamp/opengl/cg com/jogamp/opengl/cg/*"/>

        <property name="java.part.egl"
                  value="com/jogamp/opengl/impl/egl/*"/>

        <property name="java.part.glutess"
                  value="com/jogamp/opengl/impl/glu/tessellator/**"/>

        <property name="java.part.glumipmap"
                  value="com/jogamp/opengl/impl/glu/mipmap/**"/>

        <property name="java.part.glugldesktop"
                  value="com/jogamp/opengl/impl/glu/gl2/** com/jogamp/opengl/impl/glu/nurbs/** com/jogamp/opengl/impl/glu/registry/** javax/media/opengl/glu/gl2/**"/>

        <property name="java.part.openmax"
                  value="com/jogamp/openmax/**"/>

        <property name="java.part.sdk"
                  value="com/jogamp/opengl/util/glsl/sdk/**"/>

        <property name="java.part.glx"
                  value="com/jogamp/opengl/impl/x11/glx/*"/>

        <property name="java.part.wgl"
                  value="com/jogamp/opengl/impl/windows/wgl/*"/>

        <property name="java.part.cgl"
                  value="com/jogamp/opengl/impl/macosx/cgl/*"/>

        <property name="java.part.gl2es12"
                  value="com/jogamp/opengl/impl/gl2es12/**"/>

        <property name="java.part.gldesktop"
                  value="com/jogamp/opengl/impl/**/gl2/** com/jogamp/opengl/impl/**/gl3/** com/jogamp/opengl/impl/**/gl4/**"/>

        <property name="java.part.gldesktop.dbg"
                  value="javax/media/opengl/TraceGL2.* javax/media/opengl/DebugGL2.* javax/media/opengl/TraceGL2GL3.* javax/media/opengl/DebugGL2GL3.* javax/media/opengl/TraceGL3.* javax/media/opengl/DebugGL3.* javax/media/opengl/TraceGL3bc.* javax/media/opengl/DebugGL3bc.* javax/media/opengl/TraceGL4.* javax/media/opengl/DebugGL4.* javax/media/opengl/TraceGL4bc.* javax/media/opengl/DebugGL4bc.*"/>

        <property name="java.part.es1"
                  value="javax/media/opengl/**/es1/** com/jogamp/opengl/**/es1/**"/>

        <property name="java.part.es1.dbg"
                  value="javax/media/opengl/TraceGLES1.* javax/media/opengl/DebugGLES1.* javax/media/opengl/TraceGL2ES1.* javax/media/opengl/DebugGL2ES1.*"/>

        <property name="java.part.es2"
                  value="javax/media/opengl/**/es2/** com/jogamp/opengl/**/es2/**"/>

        <property name="java.part.es2.dbg"
                  value="javax/media/opengl/TraceGLES2.* javax/media/opengl/DebugGLES2.* javax/media/opengl/TraceGL2ES2.* javax/media/opengl/DebugGL2ES2.*"/>

        <property name="java.part.awt"
                  value="javax/media/opengl/awt/** com/jogamp/opengl/impl/**/awt/**"/>

        <property name="java.part.util"
                  value="com/jogamp/opengl/util/* com/jogamp/opengl/util/texture/** com/jogamp/opengl/util/packrect/**"/>

        <property name="java.part.util.awt"
                  value="com/jogamp/opengl/util/**/awt/** com/jogamp/opengl/util/AWTAnimatorImpl*"/>

        <property name="java.part.util.gldesktop"
                  value="com/jogamp/opengl/util/**/gl2/**"/>

        <property name="java.part.util.glsl"
                  value="com/jogamp/opengl/util/glsl/* com/jogamp/opengl/util/glsl/fixedfunc/*"/>

        <property name="java.part.util.fixedfuncemu"
                  value="com/jogamp/opengl/util/glsl/fixedfunc/impl/**"/>

        <property name="java.part.util.fixedfuncemu.shadercode"
                  value="com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/* com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/bin/**"/>

        <!-- condition excludes -->

        <condition property="java.excludes.nv-cg"
                   value="${java.part.nv-cg}">
          <not>
           <isset property="jogl.cg"/> 
          </not>
        </condition>

        <condition property="java.excludes.awt"
                   value="${java.part.awt} ${java.part.util.awt}">
           <isset property="setup.noAWT"/> 
        </condition>

        <property name="java.excludes.javadoc.packagenames"
                  value="com.jogamp.opengl.impl.gl2.fixme.*,com.jogamp.audio.windows.waveout.TestSpatialization"/>

        <property name="java.excludes.fixme" 
                  value="com/jogamp/opengl/impl/gl2/fixme/** com/jogamp/audio/windows/waveout/TestSpatialization.java" />

        <property name="java.excludes.cdcfp"
                  value="${java.excludes.fixme} ${java.part.nv-cg} ${java.part.gldesktop} ${java.part.gldesktop.dbg} ${java.part.awt} ${java.part.glugldesktop} ${java.part.util.awt} ${java.part.util.gldesktop} com/jogamp/opengl/util/TGAWriter.java"/>

        <condition property="java.excludes.desktop"
                   value="${java.part.glx} ${java.excludes.cdcfp}">
           <isset property="setup.nodesktop"/> 
        </condition>

        <property name="java.excludes.all" value="${java.excludes.fixme} ${java.excludes.nv-cg} ${java.excludes.awt} ${java.excludes.desktop}" />
        <echo message="java.excludes.all: ${java.excludes.all}" />
    </target>

    <!-- ================================================================== -->
    <!-- 
       - Declare all paths and user defined variables.
      -->
    <target name="declare.common" description="Declare properties" depends="partitioning.setup">
        <property name="config.jogl"              value="${config}/jogl" />

        <property name="rootrel.src.java"         value="src/jogl/classes" />
        <property name="rootrel.src.c"            value="src/jogl/native" />
        <property name="rootrel.src.c.openmax"    value="src/jogl/native/openmax" />

        <property name="rootrel.src.generated"    value="${rootrel.build}/jogl/gensrc" />
        <property name="rootrel.generated.c.jogl" value="${rootrel.src.generated}/native/jogl" />
        <property name="rootrel.generated.c.cg"   value="${rootrel.src.generated}/native/jogl_cg" />

        <!-- The source directories. -->
        <property name="src.java" value="${project.root}/${rootrel.src.java}" />
        <property name="src.c"    value="${project.root}/${rootrel.src.c}" />
        <property name="tempdir"  value="${project.root}/build-temp" />
        
        <!-- The generated source directories. -->
        <property name="src.generated" value="${build.jogl}/gensrc" />
        <property name="src.generated.java" value="${src.generated}/classes" />
        <property name="src.generated.java-cdc" value="${src.generated}/classes-cdc" />
        <property name="src.generated.java.cg" value="${src.generated.java}/com/jogamp/opengl/cg" />
        <property name="src.generated.c" value="${src.generated}/native/jogl" />
        <property name="src.generated.c.openmax" value="${src.generated}/native/openmax" />
        <property name="src.generated.c.cg" value="${src.generated}/native/jogl_cg" />
        
        <!-- The compiler output directories. -->
        <property name="classes"                    value="${build.jogl}/classes" />
        <property name="classes-cdc"                value="${build.jogl}/classes-cdc" />
        <property name="obj.joglsub"                value="${obj.jogl}/jogl" />
        <property name="obj.cgsub"                  value="${obj.jogl}/cg" />

        <!-- The GL headers from which Java files are generated -->
        <property name="stub.includes.opengl"       value="${stub.includes}/opengl" />

        <dirset id="stub.includes.fileset.all.gldesktop" dir=".">
            <include name="${stub.includes}/opengl/**" />
            <include name="${stub.includes}/macosx/**" />
            <include name="${stub.includes}/win32/**" />
            <include name="${stub.includes}/x11/**" />
            <include name="${stub.includes}/common/**" />
            <include name="${stub.includes}/jni/**" />
        </dirset>
        <fileset id="stub.includes.dependencies.fileset.1" dir="${stub.includes}">
            <include name="opengl/**" />
            <include name="macosx/**" />
            <include name="win32/**" />
            <include name="x11/**" />
            <include name="common/**" />
            <include name="jni/**" />
        </fileset>
        <fileset id="stub.includes.dependencies.fileset.2" file="${gluegen.jar}" />
        <fileset id="stub.includes.dependencies.fileset.3" dir="${config.jogl}">
            <include name="*.cfg" />
            <include name="gl*.java" />
            <include name="*.c" />
            <exclude name="cg-common.cfg" />
        </fileset>
        <dirset id="stub.includes.cg.fileset.all" dir=".">
            <include name="${stub.includes}/opengl/**" />
            <include name="${stub.includes}/cg/**" />
            <include name="${stub.includes}/macosx/**" />
            <include name="${stub.includes}/win32/**" />
            <include name="${stub.includes}/x11/**" />
            <include name="${stub.includes}/common/**" />
        </dirset>
        <fileset id="stub.includes.cg.dependencies.fileset" dir=".">
            <include name="${stub.includes}/cg/**" />
            <include name="${config.jogl}/cg-common.cfg" />
            <include name="${config.jogl}/cg-common-CustomJavaCode.java" />
        </fileset>

        <!-- Create the classpath that includes GlueGen and
           - the current classes for building the composable pipelines.
           -->
        <path id="pipeline.classpath">
          <pathelement location="${gluegen.jar}" />
          <pathelement location="${classes}" />
        </path>

        <!-- The javadoc dirs. -->
        <property name="javadoc" value="${project.root}/javadoc_jogl_public" />
        <property name="javadoc.spec" value="${project.root}/javadoc_jogl_spec" />
        <property name="javadoc.dev" value="${project.root}/javadoc_jogl_dev" />
        <property name="javadoc.link" value="http://java.sun.com/j2se/1.4.2/docs/api/" />
        <property name="javadoc.windowtitle" value="JOGL API -- JSR-231 ${jogl_base_version} Specification" />
        <property name="javadoc.overview" value="doc/jogl/spec-overview.html" />
        <property name="javadoc.spec.packagenames" value="javax.media.opengl.*" />

        <property name="javadoc.packagenames" value="${javadoc.spec.packagenames},com.jogamp.opengl.util.*" />

        <property name="javadoc.dev.packagenames" value="${javadoc.packagenames},com.jogamp.opengl.impl.*,com.sun.gluegen,com.jogamp.gluegen.runtime" />
    <property name="javadoc.bottom" value="Copyright 2005 Sun Microsystems, Inc. All rights reserved. Use is subject to &lt;a href=&quot;http://jcp.org/en/jsr/detail?id=231&quot;&gt;license terms&lt;/a&gt;." />
    </target>
    
    <target name="declare.gl.gles1">
        <property name="gles1.headers" value="${stub.includes}/opengl/GLES/*.h" /> <!-- NOTE:  this MUST be relative for FileSet --> <!-- CHECK:  this may need to be pruned for each platform -->
    </target>

    <target name="declare.gl.gles2">
        <property name="gles2.headers" value="${stub.includes}/opengl/GLES2/*.h" /> <!-- NOTE:  this MUST be relative for FileSet --> <!-- CHECK:  this may need to be pruned for each platform -->
    </target>

    <target name="declare.gl.gles" depends="declare.gl.gles1, declare.gl.gles2">
        <!-- Prepare to build the EGL interface -->
        <property name="window.es.cfg"                             value="${config.jogl}/egl.cfg" />
        <property name="window.es.ext.cfg"                         value="${config.jogl}/eglext.cfg" />
        <property name="window.es.system"                          value="egl"/>
    </target>

    <target name="declare.gl.gl2">
        <property name="gl2.headers" value="${stub.includes}/opengl/GL/*.h" /> <!-- NOTE:  this MUST be relative for FileSet --> <!-- CHECK:  this may need to be pruned for each platform -->
    </target>

    <target name="setup.javacdc">
        <copy file="../src/jogl/classes/com/jogamp/opengl/impl/SystemUtil.java.javame_cdc_fp" tofile="${src.generated.java-cdc}/com/jogamp/opengl/impl/SystemUtil.java" />
        <copy file="../src/jogl/classes/com/jogamp/opengl/util/texture/TextureIO.java.javame_cdc_fp" tofile="${src.generated.java-cdc}/com/jogamp/opengl/util/texture/TextureIO.java" />
        <copy file="../src/jogl/classes/com/jogamp/opengl/util/texture/spi/DDSImage.java.javame_cdc_fp" tofile="${src.generated.java-cdc}/com/jogamp/opengl/util/texture/spi/DDSImage.java" />
        <copy file="../src/jogl/classes/com/jogamp/opengl/util/texture/spi/TGAImage.java.javame_cdc_fp" tofile="${src.generated.java-cdc}/com/jogamp/opengl/util/texture/spi/TGAImage.java" />
    </target>

    <target name="setup.javase">
        <copy file="../src/jogl/classes/com/jogamp/opengl/impl/SystemUtil.java.javase" tofile="${src.generated.java}/com/jogamp/opengl/impl/SystemUtil.java" />
        <copy file="../src/jogl/classes/com/jogamp/opengl/util/texture/TextureIO.java.javase" tofile="${src.generated.java}/com/jogamp/opengl/util/texture/TextureIO.java" />
        <copy file="../src/jogl/classes/com/jogamp/opengl/util/texture/spi/DDSImage.java.javase" tofile="${src.generated.java}/com/jogamp/opengl/util/texture/spi/DDSImage.java" />
        <copy file="../src/jogl/classes/com/jogamp/opengl/util/texture/spi/TGAImage.java.javase" tofile="${src.generated.java}/com/jogamp/opengl/util/texture/spi/TGAImage.java" />
    </target>

    <!-- ================================================================== -->
    <!-- 
       - Initialize all parameters required for the build and create any
       - required directories.
      -->
    <target name="init" depends="declare.common, declare.gl.gles, declare.gl.gl2">
        <!-- Create the required output directories. -->
        <mkdir dir="${src.generated.java}" />
        <mkdir dir="${src.generated.java-cdc}" />
        <mkdir dir="${src.generated.c}" />
        <mkdir dir="${src.generated.c}/MacOSX" />
        <mkdir dir="${src.generated.c}/Windows" />
        <mkdir dir="${src.generated.c}/X11" />
        <mkdir dir="${src.generated.c.openmax}" />
        <mkdir dir="${classes}" />
        <mkdir dir="${classes-cdc}" />
        <mkdir dir="${obj.jogl}" />
        <mkdir dir="${obj.joglsub}" />
        <mkdir dir="${obj.cgsub}" />

        <!-- Set up Java SE and Java CDC files -->
        <antcall target="setup.javase"  inheritRefs="true" />
        <antcall target="setup.javacdc" inheritRefs="true" />
    </target>

    <!--
       - Check to see whether we need to rebuild the generated sources.
      -->
    <target name="java.generate.check">
        <!-- Blow away all target files if any dependencies are violated
             (the uptodate task doesn't allow arbitrary source and target filesets but should) -->
             <!--
        <dependset>
            <srcfileset refid="stub.includes.dependencies.fileset.1" />
            <srcfileset refid="stub.includes.dependencies.fileset.2" />
            <srcfileset refid="stub.includes.dependencies.fileset.3" />
            <targetfileset dir="${src.generated}">
                <include name="**/*.java" />
                <include name="**/*.c" />
            </targetfileset>
        </dependset>
        -->

        <!-- Now check for the presence of one well-known file -->
        <uptodate property="java.generate.skip.es1"
                  targetfile="${src.generated.java}/javax/media/opengl/GLES1.java">
            <srcfiles refid="stub.includes.dependencies.fileset.1" />
            <srcfiles refid="stub.includes.dependencies.fileset.2" />
            <srcfiles refid="stub.includes.dependencies.fileset.3" />
        </uptodate>
        <uptodate property="java.generate.skip.es2"
                  targetfile="${src.generated.java}/javax/media/opengl/GLES2.java">
            <srcfiles refid="stub.includes.dependencies.fileset.1" />
            <srcfiles refid="stub.includes.dependencies.fileset.2" />
            <srcfiles refid="stub.includes.dependencies.fileset.3" />
        </uptodate>
        <uptodate property="java.generate.skip.gl2"
                  targetfile="${src.generated.java}/javax/media/opengl/GL2.java">
            <srcfiles refid="stub.includes.dependencies.fileset.1" />
            <srcfiles refid="stub.includes.dependencies.fileset.2" />
            <srcfiles refid="stub.includes.dependencies.fileset.3" />
        </uptodate>
        <uptodate property="java.generate.skip.glu"
                  targetfile="${src.generated.java}/javax/media/opengl/glu/GLU.java">
            <srcfiles refid="stub.includes.dependencies.fileset.1" />
            <srcfiles refid="stub.includes.dependencies.fileset.2" />
            <srcfiles refid="stub.includes.dependencies.fileset.3" />
        </uptodate>

        <condition property="java.generate.skip">
          <and>
              <isset property="java.generate.skip.es1"/>
              <isset property="java.generate.skip.es2"/>
              <isset property="java.generate.skip.gl2"/>
              <isset property="java.generate.skip.glu"/>
          </and>
        </condition>

        <!--property name="java.generate.skip" value="true"/-->
    </target>

    <target name="java.generate.cleantemp">
        <delete includeEmptyDirs="true" quiet="true">
            <fileset dir="${tempdir}/gensrc" />
        </delete>
    </target>

    <target name="java.generate.copy2temp">
        <copy todir="${tempdir}">
            <fileset dir="${build.jogl}"
                     includes="gensrc/classes/**" />
        </copy>
    </target>

    <target name="java.generate.gl_if">
        <echo message="Generating GL interface" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${stub.includes.opengl}/gles2.c"
                 outputRootDir="${build.jogl}"
                 config="${config.jogl}/gl-if-gl.cfg"
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.gl2_es1_if">
        <echo message="Generating GL2_ES1 interface" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${stub.includes.opengl}/gles1.c"
                 outputRootDir="${build.jogl}"
                 config="${config.jogl}/gl-if-gl2_es1.cfg" 
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.gl2_es2_if">
        <echo message="Generating GL2_ES2 interface" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${stub.includes.opengl}/gles2.c"
                 outputRootDir="${build.jogl}"
                 config="${config.jogl}/gl-if-gl2_es2.cfg" 
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.gl2_gl3_if">
        <echo message="Generating GL2_GL3 interface" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${stub.includes.opengl}/gl3.c" 
                 outputRootDir="${build.jogl}"
                 config="${config.jogl}/gl-if-gl3-subset.cfg"
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
        <gluegen src="${stub.includes.opengl}/gl2.c" 
                 outputRootDir="${build.jogl}"
                 config="${config.jogl}/gl-if-gl2_gl3.cfg"
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.gl2">
        <echo message="Generating GL2 interface and implementation" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${stub.includes.opengl}/gl2.c" 
                 outputRootDir="${build.jogl}"
                 config="${config.jogl}/gl-if-gl2.cfg"
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.gl3">
        <echo message="Generating GL3 interface and implementation" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${stub.includes.opengl}/gl3.c" 
                 outputRootDir="${build.jogl}"
                 config="${config.jogl}/gl-if-gl3.cfg"
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.gl3bc">
        <echo message="Generating GL3bc implementation" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${stub.includes.opengl}/gl3bc.c" 
                 outputRootDir="${build.jogl}"
                 config="${config.jogl}/gl-if-gl3bc.cfg"
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.gl4">
        <echo message="Generating GL4 interface and implementation" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${stub.includes.opengl}/gl4.c" 
                 outputRootDir="${build.jogl}"
                 config="${config.jogl}/gl-if-gl4.cfg"
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.gl4bc">
        <echo message="Generating GL4bc implementation" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${stub.includes.opengl}/gl4bc.c" 
                 outputRootDir="${build.jogl}"
                 config="${config.jogl}/gl-gl4bc.cfg"
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.gl2es12">
        <echo message="Generating GL2ES12 implementation" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${stub.includes.opengl}/gl2es12.c" 
                 outputRootDir="${build.jogl}"
                 config="${config.jogl}/gl-gl2es12.cfg"
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>  

    <target name="java.generate.gles1">
        <echo message="Generating GLES1 interface and implementation" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${stub.includes.opengl}/gles1.c" 
                 outputRootDir="${build.jogl}"
                 config="${config.jogl}/gl-es1.cfg"
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.gles2">
        <echo message="Generating GLES2 interface and implementation" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${stub.includes.opengl}/gles2.c" 
                 outputRootDir="${build.jogl}"
                 config="${config.jogl}/gl-es2.cfg"
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.gl.all" depends="java.generate.gl_if, java.generate.gl2_es1_if, java.generate.gl2_es2_if, java.generate.gl2_gl3_if, java.generate.gl2, java.generate.gl3, java.generate.gl3bc, java.generate.gl4, java.generate.gl4bc, java.generate.gl2es12, java.generate.gles1, java.generate.gles2"/>

    <!-- target name="java.generate.gl.nsig" if="gluegen.nsig">
        <echo message="Generating GL interface and implementation" />
        <gluegen src="${gl.c}" 
                 config="${gl.cfg.nsig}"
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.nativesig.NativeSignatureEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target> -->

    <target name="java.generate.glu.base">
        <echo message="Generating GLU class" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${stub.includes.opengl}/glu.c" 
                 outputRootDir="${build.jogl}"
                 config="${config.jogl}/glu-base.cfg"
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.glu.GL2ES1">
        <echo message="Generating GLU class" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${stub.includes.opengl}/glu.c" 
                 outputRootDir="${build.jogl}"
                 config="${config.jogl}/glu-gl2es1.cfg"
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.glu.GL2">
        <echo message="Generating GLU class" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${stub.includes.opengl}/glu.c" 
                 outputRootDir="${build.jogl}"
                 config="${config.jogl}/glu-gl2.cfg"
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.platform.glext">
        <echo message="Generating platform-specific OpenGL extension class: ${window.os.system}" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${glext.platform.header}" 
                 outputRootDir="${build.jogl}"
                 config="${glext.platform.cfg}"
                 includeRefid="stub.includes.fileset.all.gldesktop"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.window.system.es" if="window.es.cfg">
        <echo message="Generating EGL implementation class" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <dirset id="stub.includes.fileset.platform" dir="." includes="${stub.includes}/${window.es.system}/** ${stub.includes}/common/**" />
        <gluegen src="${stub.includes}/${window.es.system}/window-system1.c"
                 outputRootDir="${build.jogl}"
                 config="${window.es.cfg}"
                 includeRefid="stub.includes.fileset.platform"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.window.system.es.ext" if="window.es.ext.cfg">
        <echo message="Generating EGLExt implementation class" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <dirset id="stub.includes.fileset.platform" dir="." includes="${stub.includes}/${window.es.system}/** ${stub.includes}/common/**" />
        <gluegen src="${stub.includes}/${window.es.system}/window-system-ext.c"
                 outputRootDir="${build.jogl}"
                 config="${window.es.ext.cfg}"
                 includeRefid="stub.includes.fileset.platform"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.window.system.os0" if="window.os0.cfg">
        <echo message="Generating window system glue impl: ${window.os.system}" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${stub.includes}/${window.os.system}/window-system0.c"
                 outputRootDir="${build.jogl}"
                 config="${window.os0.cfg}"
                 includeRefid="stub.includes.fileset.platform"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.window.system.os1" if="window.os1.cfg">
        <echo message="Generating window system glue impl: ${window.os.system}" />
        <antcall target="java.generate.copy2temp" inheritRefs="true" />
        <gluegen src="${stub.includes}/${window.os.system}/window-system1.c"
                 outputRootDir="${build.jogl}"
                 config="${window.os1.cfg}"
                 includeRefid="stub.includes.fileset.platform"
                 emitter="com.sun.gluegen.opengl.GLEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <target name="java.generate.gl.platforms" >
        <dirset id="stub.includes.fileset.platform" dir="." includes="${stub.includes}/${window.os.system}/** ${stub.includes}/${window.es.system}/** ${stub.includes}/common/** ${stub.includes}/opengl/**" />

        <antcall target="java.generate.window.system.os0" inheritRefs="true" />
        <antcall target="java.generate.window.system.os1" inheritRefs="true" />
        <antcall target="java.generate.platform.glext" inheritRefs="true" />
    </target>

    <!--
       - Setup the generating ANT tasks and use it to generate the Java files 
       - from the C GL headers.  This involves setting the taskdef and creating
       - the classpath reference id then running the task on each header.
      -->
    <target name="java.generate" depends="common.gluegen.build, java.generate.check" unless="java.generate.skip">

        <!-- Add the GlueGen and BuildStaticGLInfo tasks to ANT -->
        <taskdef name="gluegen" classname="com.sun.gluegen.ant.GlueGenTask"
                 classpathref="gluegen.classpath" />
        <taskdef name="staticglgen" classname="com.sun.gluegen.ant.StaticGLGenTask"
                 classpathref="gluegen.classpath" />
                 
        <!-- Use the GlueGen and BuildStaticGLInfo tasks to generate the 
           - Java files -->

        <echo message="Generating GL interface and implementation" />
        <antcall target="java.generate.gl.all"      inheritRefs="true" />
        <!--antcall target="java.generate.gl.nsig" inheritRefs="true" /-->

        <antcall target="java.generate.window.system.es"     inheritRefs="true" />
        <antcall target="java.generate.window.system.es.ext" inheritRefs="true" />

        <antcall target="java.generate.gl.platforms" inheritRefs="true">
            <param name="window.os.system"                       value="x11"/>
            <param name="window.os1.cfg"                         value="${config.jogl}/glx-x11.cfg" />
            <param name="glext.platform.cfg"                     value="${config.jogl}/glxext.cfg" />
            <param name="glext.platform.header"                  value="${stub.includes}/x11/glxext.c" />
        </antcall>

        <antcall target="java.generate.gl.platforms" inheritRefs="true">
            <param name="window.os.system"                       value="win32"/>
            <param name="window.os0.cfg"                         value="${config.jogl}/gdi-win32.cfg" />
            <param name="window.os1.cfg"                         value="${config.jogl}/wgl-win32.cfg" />
            <param name="glext.platform.cfg"                     value="${config.jogl}/wglext.cfg" />
            <param name="glext.platform.header"                  value="${stub.includes}/win32/wglext.c" />
        </antcall>          

        <antcall target="java.generate.gl.platforms" inheritRefs="true">
          <param name="window.os.system"                     value="macosx"/>
          <param name="window.os1.cfg"                       value="${config.jogl}/cgl-macosx.cfg" />
          <param name="glext.platform.cfg"                   value="${config.jogl}/cglext.cfg" />
          <param name="glext.platform.header"                value="${stub.includes}/macosx/cglext.c" />
        </antcall>
    
        <!-- Generate GLU class -->
        <antcall target="java.generate.glu.base"   inheritrefs="true" />
        <antcall target="java.generate.glu.GL2ES1" inheritrefs="true" />
        <antcall target="java.generate.glu.GL2"    inheritrefs="true" />

        <!-- Inform the user that the generators have successfully created 
           - the necessary Java files -->
        <echo message="" />
        <echo message="GlueGen and BuildStaticGLInfo have successfully generated files." />
    
    </target>      

    <target name="java.generate.cg.check">
        <!-- Blow away all target files if any dependencies are violated
             (the uptodate task doesn't allow arbitrary source and target filesets but should) -->
        <dependset>
            <srcfileset refid="stub.includes.cg.dependencies.fileset" />
            <targetfileset dir=".">
                <include name="${src.generated.java.cg}/**/*.java" />
                <include name="${src.generated.c.cg}/**/*.c" />
            </targetfileset>
        </dependset>

        <!-- Now check for the presence of one well-known file -->
        <uptodate property="java.generate.cg.skip">
            <srcfiles refid="stub.includes.cg.dependencies.fileset" />
            <mapper type="merge" to="${src.generated.java}/com/jogamp/opengl/cg/CgGL.java" />
        </uptodate>
    </target>

    <!--
       - Setup the generating ANT tasks and use it to generate the Java files 
       - from the C GL headers.  This involves setting the taskdef and creating
       - the classpath reference id then running the task on each header.
      -->
    <target name="java.generate.cg" depends="java.generate.cg.check" if="jogl.cg" unless="java.generate.cg.skip">
        <!-- Add the GlueGen and BuildStaticGLInfo tasks to ANT -->
        <taskdef name="gluegen" classname="com.sun.gluegen.ant.GlueGenTask"
                 classpathref="gluegen.classpath" />
        <taskdef name="staticglgen" classname="com.sun.gluegen.ant.StaticGLGenTask"
                 classpathref="gluegen.classpath" />

        <!-- Generate CgGL interface class -->
        <gluegen src="${stub.includes.opengl}/cg.c" 
                 outputRootDir="${build.jogl}"
                 config="${config.jogl}/cg-common.cfg"
                 includeRefid="stub.includes.cg.fileset.all"
                 emitter="com.sun.gluegen.procaddress.ProcAddressEmitter">
            <classpath refid="gluegen.classpath" />
        </gluegen>
    </target>

    <!-- ================================================================== -->
    <!-- 
       - Build and dependency rules for the composable pipeline
      -->
    <target name="java.generate.composable.pipeline.check.es1">
        <!-- Blow away the DebugGL*.java and TraceGL*.java sources if GL*.class has changed
             (the uptodate element doesn't support arbitrary source and destination files) -->
        <dependset>
            <srcfilelist dir="${classes}/javax/media/opengl" files="GLES1.class" />
            <targetfileset dir="${src.generated.java}/javax/media/opengl"
                           includes="DebugGLES1.java,TraceGLES1.java" />
        </dependset>
                           
        <!-- Now choose one of the two to test to see if we have to regenerate -->
        <uptodate property="java.generate.composable.pipeline.skip.es1"
                  srcfile="${classes}/javax/media/opengl/GLES1.class"
                  targetfile="${src.generated.java}/javax/media/opengl/DebugGLES1.java" />

    </target>        

    <target name="java.generate.composable.pipeline.check.es2">
        <!-- Blow away the DebugGL*.java and TraceGL*.java sources if GL*.class has changed
             (the uptodate element doesn't support arbitrary source and destination files) -->
        <dependset>
            <srcfilelist dir="${classes}/javax/media/opengl" files="GLES2.class" />
            <targetfileset dir="${src.generated.java}/javax/media/opengl"
                           includes="DebugGLES2.java,TraceGLES2.java" />
        </dependset>
                           
        <!-- Now choose one of the two to test to see if we have to regenerate -->
        <uptodate property="java.generate.composable.pipeline.skip.es2"
                  srcfile="${classes}/javax/media/opengl/GLES2.class"
                  targetfile="${src.generated.java}/javax/media/opengl/DebugGLES2.java" />

    </target>        

    <target name="java.generate.composable.pipeline.check.gl2es12">
        <!-- Blow away the DebugGL*.java and TraceGL*.java sources if GL*.class has changed
             (the uptodate element doesn't support arbitrary source and destination files) -->
        <dependset>
            <srcfilelist dir="${classes}/javax/media/opengl" files="GL2ES12.class" />
            <targetfileset dir="${src.generated.java}/javax/media/opengl"
                           includes="DebugGL2ES12.java,TraceGL2ES12.java" />
        </dependset>
                           
        <!-- Now choose one of the two to test to see if we have to regenerate -->
        <uptodate property="java.generate.composable.pipeline.skip.gl2es12"
                  srcfile="${classes}/javax/media/opengl/GL2ES12.class"
                  targetfile="${src.generated.java}/javax/media/opengl/DebugGL2ES12.java" />
    </target>   

    <target name="java.generate.composable.pipeline.check.gl2">
        <!-- Blow away the DebugGL*.java and TraceGL*.java sources if GL*.class has changed
             (the uptodate element doesn't support arbitrary source and destination files) -->
        <dependset>
            <srcfilelist dir="${classes}/javax/media/opengl" files="GL2.class" />
            <targetfileset dir="${src.generated.java}/javax/media/opengl"
                           includes="DebugGL2.java,TraceGL2.java" />
        </dependset>

        <!-- Now choose one of the two to test to see if we have to regenerate -->
        <uptodate property="java.generate.composable.pipeline.skip.gl2"
                  srcfile="${classes}/javax/media/opengl/GL2.class"
                  targetfile="${src.generated.java}/javax/media/opengl/DebugGL2.java" />
    </target>        

    <target name="java.generate.composable.pipeline.check.gl3">
        <!-- Blow away the DebugGL*.java and TraceGL*.java sources if GL*.class has changed
             (the uptodate element doesn't support arbitrary source and destination files) -->
        <dependset>
            <srcfilelist dir="${classes}/javax/media/opengl" files="GL3.class" />
            <targetfileset dir="${src.generated.java}/javax/media/opengl"
                           includes="DebugGL3.java,TraceGL3.java,DebugGL3bc.java,TraceGL3bc.java" />
        </dependset>
                           
        <!-- Now choose one of the two to test to see if we have to regenerate -->
        <uptodate property="java.generate.composable.pipeline.skip.gl3"
                  srcfile="${classes}/javax/media/opengl/GL3.class"
                  targetfile="${src.generated.java}/javax/media/opengl/DebugGL3.java" />
    </target>        

    <target name="java.generate.composable.pipeline.check.gl4">
        <!-- Blow away the DebugGL*.java and TraceGL*.java sources if GL*.class has changed
             (the uptodate element doesn't support arbitrary source and destination files) -->
        <dependset>
            <srcfilelist dir="${classes}/javax/media/opengl" files="GL4.class" />
            <targetfileset dir="${src.generated.java}/javax/media/opengl"
                           includes="DebugGL4.java,TraceGL4.java,DebugGL4bc.java,TraceGL4bc.java" />
        </dependset>
                           
        <!-- Now choose one of the two to test to see if we have to regenerate -->
        <uptodate property="java.generate.composable.pipeline.skip.gl4"
                  srcfile="${classes}/javax/media/opengl/GL4.class"
                  targetfile="${src.generated.java}/javax/media/opengl/DebugGL4.java" />
    </target>        

    <target name="java.generate.composable.pipeline.es1" depends="java.generate.composable.pipeline.check.es1" unless="java.generate.composable.pipeline.skip.es1">
        <java classname="com.sun.gluegen.opengl.BuildComposablePipeline" fork="yes" failonerror="true">
            <arg value="javax.media.opengl.GLES1" />
            <arg value="${src.generated.java}/javax/media/opengl" />
            <classpath refid="pipeline.classpath" />
        </java>
        <java classname="com.sun.gluegen.opengl.BuildComposablePipeline" fork="yes" failonerror="true">
            <arg value="javax.media.opengl.GL2ES1" />
            <arg value="${src.generated.java}/javax/media/opengl" />
            <classpath refid="pipeline.classpath" />
        </java>
        <copy todir="${src.generated.java-cdc}">
            <fileset dir="${src.generated.java}"
                     includes="javax/media/opengl/DebugGLES1.java javax/media/opengl/TraceGLES1.java javax/media/opengl/DebugGL2ES1.java javax/media/opengl/TraceGL2ES1.java" />
        </copy>
    </target>          

    <target name="java.generate.composable.pipeline.es2" depends="java.generate.composable.pipeline.check.es2" unless="java.generate.composable.pipeline.skip.es2">
        <java classname="com.sun.gluegen.opengl.BuildComposablePipeline" fork="yes" failonerror="true">
            <arg value="javax.media.opengl.GLES2" />
            <arg value="${src.generated.java}/javax/media/opengl" />
            <classpath refid="pipeline.classpath" />
        </java>
        <java classname="com.sun.gluegen.opengl.BuildComposablePipeline" fork="yes" failonerror="true">
            <arg value="javax.media.opengl.GL2ES2" />
            <arg value="${src.generated.java}/javax/media/opengl" />
            <classpath refid="pipeline.classpath" />
        </java>
        <copy todir="${src.generated.java-cdc}">
            <fileset dir="${src.generated.java}"
                     includes="javax/media/opengl/DebugGLES2.java javax/media/opengl/TraceGLES2.java javax/media/opengl/DebugGL2ES2.java javax/media/opengl/TraceGL2ES2.java" />
        </copy>
    </target>          

    <target name="java.generate.composable.pipeline.gl2" depends="java.generate.composable.pipeline.check.gl2" unless="java.generate.composable.pipeline.skip.gl2">
        <java classname="com.sun.gluegen.opengl.BuildComposablePipeline" fork="yes" failonerror="true">
            <arg value="javax.media.opengl.GL2" />
            <arg value="${src.generated.java}/javax/media/opengl" />
            <classpath refid="pipeline.classpath" />
        </java>
        <java classname="com.sun.gluegen.opengl.BuildComposablePipeline" fork="yes" failonerror="true">
            <arg value="javax.media.opengl.GL2GL3" />
            <arg value="${src.generated.java}/javax/media/opengl" />
            <classpath refid="pipeline.classpath" />
        </java>
        <copy todir="${src.generated.java-cdc}">
            <fileset dir="${src.generated.java}"
                     includes="javax/media/opengl/DebugGL2.java javax/media/opengl/TraceGL2.java javax/media/opengl/DebugGL2GL3.java javax/media/opengl/TraceGL2GL3.java" />
        </copy>
    </target>          

    <target name="java.generate.composable.pipeline.gl3" depends="java.generate.composable.pipeline.check.gl3" unless="java.generate.composable.pipeline.skip.gl3">
        <java classname="com.sun.gluegen.opengl.BuildComposablePipeline" fork="yes" failonerror="true">
            <arg value="javax.media.opengl.GL3" />
            <arg value="${src.generated.java}/javax/media/opengl" />
            <classpath refid="pipeline.classpath" />
        </java>
        <copy todir="${src.generated.java-cdc}">
            <fileset dir="${src.generated.java}"
                     includes="javax/media/opengl/DebugGL3.java javax/media/opengl/TraceGL3.java" />
        </copy>

        <java classname="com.sun.gluegen.opengl.BuildComposablePipeline" fork="yes" failonerror="true">
            <arg value="javax.media.opengl.GL3bc" />
            <arg value="${src.generated.java}/javax/media/opengl" />
            <classpath refid="pipeline.classpath" />
        </java>
        <copy todir="${src.generated.java-cdc}">
            <fileset dir="${src.generated.java}"
                     includes="javax/media/opengl/DebugGL3bc.java javax/media/opengl/TraceGL3bc.java" />
        </copy>
    </target>          

    <target name="java.generate.composable.pipeline.gl4" depends="java.generate.composable.pipeline.check.gl4" unless="java.generate.composable.pipeline.skip.gl4">
        <java classname="com.sun.gluegen.opengl.BuildComposablePipeline" fork="yes" failonerror="true">
            <arg value="javax.media.opengl.GL4" />
            <arg value="${src.generated.java}/javax/media/opengl" />
            <classpath refid="pipeline.classpath" />
        </java>
        <copy todir="${src.generated.java-cdc}">
            <fileset dir="${src.generated.java}"
                     includes="javax/media/opengl/DebugGL4.java javax/media/opengl/TraceGL4.java" />
        </copy>

        <java classname="com.sun.gluegen.opengl.BuildComposablePipeline" fork="yes" failonerror="true">
            <arg value="javax.media.opengl.GL4bc" />
            <arg value="${src.generated.java}/javax/media/opengl" />
            <classpath refid="pipeline.classpath" />
        </java>
        <copy todir="${src.generated.java-cdc}">
            <fileset dir="${src.generated.java}"
                     includes="javax/media/opengl/DebugGL4bc.java javax/media/opengl/TraceGL4bc.java" />
        </copy>
    </target>          

    <target name="java.generate.composable.pipeline" depends="java.generate.composable.pipeline.es1, java.generate.composable.pipeline.es2, java.generate.composable.pipeline.gl2, java.generate.composable.pipeline.gl3, java.generate.composable.pipeline.gl4">
    </target>

    <target name="java.generate.composable.pipeline.custom.check.glfixfunc">
        <!-- Blow away the DebugGL*.java and TraceGL*.java sources if GL*.class has changed
             (the uptodate element doesn't support arbitrary source and destination files) -->
        <dependset>
            <srcfilelist dir="${classes}/com/jogamp/opengl/util/glsl/fixedfunc" files="FixedFuncHook.class" />
            <srcfilelist dir="${classes}/javax/media/opengl" files="GL2ES1.class" />
            <srcfilelist dir="${classes}/javax/media/opengl" files="GL2ES2.class" />
            <targetfileset dir="${src.generated.java}/com/jogamp/opengl/util/glsl/fixedfunc/impl"
                           includes="FixedFuncImpl.java" />
        </dependset>
                           
        <!-- Now choose one of the two to test to see if we have to regenerate -->
        <uptodate property="java.generate.composable.pipeline.custom.skip.glfixfunc"
                  srcfile="${classes}/javax/media/opengl/GL2ES1.class"
                  targetfile="${src.generated.java}/com/jogamp/opengl/util/glsl/fixedfunc/impl/FixedFuncImpl.java" />
    </target>        
    <target name="java.generate.composable.pipeline.custom.glfixfunc" depends="java.generate.composable.pipeline.custom.check.glfixfunc" unless="java.generate.composable.pipeline.custom.skip.glfixfunc">
        <java classname="com.sun.gluegen.opengl.BuildComposablePipeline" fork="yes" failonerror="true">
            <arg value="javax.media.opengl.GL2ES1" />
            <arg value="${src.generated.java}/com/jogamp/opengl/util/glsl/fixedfunc/impl" />
            <arg value="com.jogamp.opengl.util.glsl.fixedfunc.impl.FixedFuncImpl" />
            <arg value="com.jogamp.opengl.util.glsl.fixedfunc.impl.FixedFuncHook" />
            <arg value="javax.media.opengl.GL2ES2" />
            <arg value="prolog_xor_downstream" />
            <classpath refid="pipeline.classpath" />
        </java>
        <copy todir="${src.generated.java-cdc}">
            <fileset dir="${src.generated.java}"
                     includes="com/jogamp/opengl/util/glsl/fixedfunc/impl/FixedFuncImpl.java" />
        </copy>
    </target>          
    <target name="java.generate.composable.pipeline.custom" depends="init, common.gluegen.build, java.generate.composable.pipeline.custom.glfixfunc">
    </target>

    <!-- ================================================================== -->
    <!-- 
       - Compile the original and generated source.  The composable pipelines
       - will be generated.
      -->
    <target name="java.compile.firstpass" depends="java.generate,java.generate.cg">
        <antcall target="java.generate.cleantemp" inheritRefs="true" />

        <!-- Perform the first pass Java compile. -->
        <javac destdir="${classes}"
               includes="javax/media/opengl/fixedfunc/** javax/media/opengl/GLDrawableFactory.java javax/media/opengl/GLDrawable.java javax/media/opengl/GLContext.java javax/media/opengl/GL.java javax/media/opengl/GL2ES1.java javax/media/opengl/GL2ES2.java javax/media/opengl/GL2GL3.java javax/media/opengl/GL2.java javax/media/opengl/GLES1.java javax/media/opengl/GLES2.java javax/media/opengl/GL3.java javax/media/opengl/GL3bc.java javax/media/opengl/GL4.java javax/media/opengl/GL4bc.java"
               fork="yes"
               memoryMaximumSize="${javac.memorymax}"
               includeAntRuntime="false"
               source="1.4" debug="${javacdebug}" debuglevel="${javacdebuglevel}">
            <classpath refid="nativewindow_gluegen.classpath"/>
            <src path="${src.java}" />
            <src path="${src.generated.java}" />
        </javac>

        <copy todir="${src.generated.java-cdc}">
            <fileset dir="${src.generated.java}"
                     includes="**" 
                     excludes="com/jogamp/opengl/cg/** com/jogamp/opengl/impl/gl2/** com/jogamp/opengl/impl/gl3/** com/jogamp/opengl/impl/gl4/** com/jogamp/opengl/impl/glu/gl2/** javax/media/opengl/glu/gl2/**"/>
        </copy>
        <copy todir="${classes-cdc}">
            <fileset dir="${classes}"
                     includes="**" />
        </copy>
    </target>

    <target name="java.compile.secondpass.javase">
        <!-- Perform the second pass Java compile; everything except portion of fixed function emulation depending on generated code. -->
        <javac destdir="${classes}"
               excludes="com/jogamp/opengl/util/glsl/fixedfunc/FixedFuncUtil.java,${java.excludes.all}"
               source="${target.sourcelevel}"
               fork="yes"
               memoryMaximumSize="${javac.memorymax}"
               includeAntRuntime="false"
               debug="${javacdebug}" debuglevel="${javacdebuglevel}">
            <classpath refid="nativewindow_gluegen.classpath"/>
            <src path="${src.java}" />
            <src path="${src.generated.java}" />
        </javac>
    </target>

           <!--    bootclasspath="${javac.bootclasspath-cdc.jar}" -->
    <target name="java.compile.secondpass.javacdc" unless="setup.noCDC">
        <!-- Perform the second pass Java compile; everything except portion of fixed function emulation depending on generated code. -->
        <javac destdir="${classes-cdc}"
               excludes="com/jogamp/opengl/util/glsl/fixedfunc/FixedFuncUtil.java,${java.excludes.all},${java.excludes.cdcfp}"
               source="${target.sourcelevel}"
               fork="yes"
               memoryMaximumSize="${javac.memorymax}"
               includeAntRuntime="false"
               debug="${javacdebug}" debuglevel="${javacdebuglevel}">
            <classpath refid="nativewindow_gluegen.classpath-cdc"/>
            <src path="${src.java}" />
            <src path="${src.generated.java-cdc}" />
        </javac>
    </target>

    <target name="java.compile.secondpass" depends="java.generate.composable.pipeline, java.compile.secondpass.javase, java.compile.secondpass.javacdc" />

    <target name="java.compile.thirdpass.javase">
        <!-- Perform the third pass Java compile; everything including fixed function emulation. -->
        <javac destdir="${classes}"
               excludes="${java.excludes.all}"
               source="${target.sourcelevel}"
               fork="yes"
               memoryMaximumSize="${javac.memorymax}"
               includeAntRuntime="false"
               debug="${javacdebug}" debuglevel="${javacdebuglevel}">
            <classpath refid="nativewindow_gluegen.classpath"/>
            <src path="${src.java}" />
            <src path="${src.generated.java}" />
        </javac>
    </target>

    <target name="java.compile.thirdpass.javacdc" unless="setup.noCDC">
        <!-- Perform the third pass Java compile; everything including fixed function emulation. -->
        <javac destdir="${classes-cdc}"
               excludes="${java.excludes.all},${java.excludes.cdcfp}"
               source="${target.sourcelevel}"
               bootclasspath="${javac.bootclasspath-cdc.jar}"
               fork="yes"
               memoryMaximumSize="${javac.memorymax}"
               includeAntRuntime="false"
               debug="${javacdebug}" debuglevel="${javacdebuglevel}">
            <classpath refid="nativewindow_gluegen.classpath-cdc"/>
            <src path="${src.java}" />
            <src path="${src.generated.java-cdc}" />
        </javac>
    </target>

    <target name="java.compile.thirdpass" depends="java.generate.composable.pipeline.custom, java.compile.thirdpass.javase, java.compile.thirdpass.javacdc" />

    <target name="java.compile" depends="java.compile.firstpass,java.compile.secondpass,java.compile.thirdpass" />

    <!-- ================================================================== -->
    <!-- 
       - Compile the native C code for JOGL (and optionally the Cg binding).
      -->

    <target name="c.configure.1" depends="gluegen.cpptasks.detect.os,gluegen.cpptasks.setup.compiler">
      <!-- compiler configuration -->
      <!-- Note that we can use the base setups in the gluegen-cpptasks for most of these -->

      <compiler id="compiler.cfg.freebsd.jogl" extends="compiler.cfg.freebsd">
        <!-- Need to force X11R6 headers on to include path after stub_includes -->
        <includepath path="stub_includes/opengl"/>
        <includepath path="/usr/local/include" />
      </compiler>

      <!-- linker configuration -->
 
      <linker id="linker.cfg.freebsd.jogl.x11" extends="linker.cfg.freebsd">
        <syslibset dir="/usr/local/lib" libs="X11"/>
        <syslibset dir="/usr/local/lib" libs="Xxf86vm" />
      </linker>

      <linker id="linker.cfg.freebsd.amd64.jogl.x11" extends="linker.cfg.freebsd.amd64">
        <syslibset dir="/usr/local/lib" libs="X11"/>
        <syslibset dir="/usr/local/lib" libs="Xxf86vm" />
      </linker>

      <linker id="linker.cfg.linux.jogl.x11" extends="linker.cfg.linux">
        <syslibset libs="X11"/>
        <syslibset libs="Xxf86vm" />
      </linker>

      <linker id="linker.cfg.linux.amd64.jogl.x11" extends="linker.cfg.linux.amd64">
        <syslibset libs="X11"/>
        <syslibset libs="Xxf86vm" />
      </linker>

      <linker id="linker.cfg.solaris.jogl.x11" extends="linker.cfg.solaris">
        <syslibset libs="X11"/>
      </linker>

      <linker id="linker.cfg.solaris.sparcv9.jogl.x11" extends="linker.cfg.solaris.sparcv9">
        <linkerarg value="-xarch=v9a" />
        <syslibset dir="/usr/lib/sparcv9" libs="X11"/>
      </linker>

      <linker id="linker.cfg.solaris.amd64.jogl.x11" extends="linker.cfg.solaris.amd64">
        <linkerarg value="-xarch=amd64" />
        <syslibset dir="/usr/lib/amd64" libs="X11"/>
      </linker>

      <linker id="linker.cfg.win32.mingw.jogl" extends="linker.cfg.win32.mingw">
        <linkerarg value="-Wl,--kill-at" />        <!-- remove @ from function names -->
        <syslibset libs="gdi32, kernel32"/>
      </linker>

      <linker id="linker.cfg.win64.mingw.jogl" extends="linker.cfg.win64.mingw">
        <linkerarg value="-Wl,--kill-at" />        <!-- remove @ from function names -->
        <syslibset libs="gdi32, kernel32"/>
      </linker>

      <linker id="linker.cfg.win32.msvc.jogl" extends="linker.cfg.win32.msvc">
        <syslibset libs="user32, kernel32" />
    <!-- This is temporary -->
        <syslibset libs="winmm" />
      </linker>

      <linker id="linker.cfg.macosx.jogl" extends="linker.cfg.macosx">
        <linkerarg value="-framework" />
        <linkerarg value="Cocoa" />
        <linkerarg value="-framework" />
        <linkerarg value="OpenGL" />
      </linker>

      <!--linker id="linker.cfg.macosx.jogl.cg" extends="linker.cfg.macosx.jogl">
        <linkerarg value="-framework"/>
        <linkerarg value="Cg"/>
      </linker-->

      <linker id="linker.cfg.hpux.jogl" extends="linker.cfg.hpux">
        <syslibset dir="/opt/graphics/OpenGL/lib" libs="GL, GLU"/>
        <syslibset dir="/usr/lib" libs="X11"/>
      </linker>
    </target>

    <target name="c.configure.win32.vc" if="isVCFamily">
      <echo message="Win32.VC" />
      <property name="compiler.cfg.id"                     value="compiler.cfg.win32.msvc" />
      <property name="linker.cfg.id.os"                    value="linker.cfg.win32.msvc.jogl" />
    </target>
    
    <target name="c.configure.win32.mingw" if="isMingW32">
      <echo message="Win32.MingW" />
      <property name="compiler.cfg.id"                     value="compiler.cfg.win32.mingw" />
      <property name="linker.cfg.id.os"                    value="linker.cfg.win32.mingw.jogl" />
    </target>

    <target name="c.configure.win64.mingw" if="isMingW64">
      <echo message="Win64.MingW" />
      <property name="compiler.cfg.id"                     value="compiler.cfg.win64.mingw" />
      <property name="linker.cfg.id.os"                    value="linker.cfg.win64.mingw.jogl" />
    </target>

    <target name="c.configure.linux.x86" if="isLinuxX86">
      <echo message="Linux.x86" />
      <property name="compiler.cfg.id"                     value="compiler.cfg.linux" />
      <property name="linker.cfg.id.os"                    value="linker.cfg.linux.jogl.x11" />
    </target>
    
    <target name="c.configure.linux.amd64" if="isLinuxAMD64">
      <echo message="Linux.AMD64" />
      <property name="compiler.cfg.id"                     value="compiler.cfg.linux.amd64" />
      <property name="linker.cfg.id.os"                    value="linker.cfg.linux.amd64.jogl.x11" />
    </target>
    
    <target name="c.configure.linux.ia64" if="isLinuxIA64">
      <echo message="Linux.IA64" />
      <property name="compiler.cfg.id"                     value="compiler.cfg.linux" />
      <property name="linker.cfg.id.os"                    value="linker.cfg.linux.jogl.x11" />
    </target>

    <target name="c.configure.linux" depends="c.configure.linux.x86,c.configure.linux.amd64,c.configure.linux.ia64,c.configure.x11" if="isLinux" />

    <target name="c.configure.solaris32" depends="c.configure.x11" if="isSolaris32Bit">
      <echo message="Solaris" />
      <property name="compiler.cfg.id"                     value="compiler.cfg.solaris" />
      <property name="linker.cfg.id.os"                    value="linker.cfg.solaris.jogl.x11" />
    </target>
  
 
    <target name="c.configure.solaris.sparcv9" depends="c.configure.x11" if="isSolarisSparcv9">
      <echo message="SolarisSparcv9" />
      <property name="compiler.cfg.id"                     value="compiler.cfg.solaris.sparcv9" />
      <property name="linker.cfg.id.os"                    value="linker.cfg.solaris.sparcv9.jogl.x11" />
    </target>
   

    <target name="c.configure.solaris.amd64" depends="c.configure.x11" if="isSolarisAMD64">
      <echo message="SolarisAMD64" />
      <property name="compiler.cfg.id"                     value="compiler.cfg.solaris.amd64" />
      <property name="linker.cfg.id.os"                    value="linker.cfg.solaris.amd64.jogl.x11" />
    </target>
   
    <target name="c.configure.freebsd.x86" depends="c.configure.x11" if="isFreeBSDX86">
      <echo message="FreeBSD" />
      <property name="compiler.cfg.id"                     value="compiler.cfg.freebsd.jogl" />
      <property name="linker.cfg.id.os"                    value="linker.cfg.freebsd.jogl.x11" />
    </target>

    <target name="c.configure.freebsd.amd64" depends="c.configure.x11" if="isFreeBSDAMD64">
      <echo message="FreeBSD" />
      <property name="compiler.cfg.id"                     value="compiler.cfg.freebsd.jogl" />
      <property name="linker.cfg.id.os"                    value="linker.cfg.freebsd.amd64.jogl.x11" />
    </target>

    <target name="c.configure.freebsd" depends="c.configure.freebsd.x86,c.configure.freebsd.amd64,c.configure.x11" if="isFreeBSD" />

    <target name="c.configure.hpux" depends="c.configure.x11" if="isHPUX">
      <echo message="HP-UX" />
      <property name="compiler.cfg.id"                     value="compiler.cfg.hpux" />
      <property name="linker.cfg.id.os"                    value="linker.cfg.hpux.jogl.x11" />
    </target>

    <target name="c.configure.win32" depends="c.configure.win32.vc,c.configure.win32.mingw,c.configure.win64.mingw" if="isWindows" />

    <target name="c.configure.x11" if="isX11" />

    <target name="c.configure.macosx" if="isOSX">
      <property name="compiler.cfg.id"                     value="compiler.cfg.macosx" />
      <property name="linker.cfg.id.os"                    value="linker.cfg.macosx.jogl" />
    </target>
    
    <target name="c.configure.2" depends="c.configure.win32,c.configure.linux,c.configure.solaris32,c.configure.solaris.sparcv9,c.configure.solaris.amd64,c.configure.macosx,c.configure.freebsd,c.configure.hpux" />

    <target name="c.configure" depends="c.configure.1,c.configure.2" />

    <target name="rename.mingw.dll" if="isMingW">
        <move file="${src}" tofile="${dest}" />
    </target>

    <target name="rename.dylib" if="isOSX">
        <move file="${src}" tofile="${dest}" />
        <copy file="${dest}" tofile="${dest-cdc}" />
    </target>

    <macrodef name="c.build">
      <attribute name="c.compiler.src.files" />
      <attribute name="compiler.cfg.id" />
      <attribute name="linker.cfg.id" />
      <attribute name="output.lib.name" />
      <attribute name="c.compiler.use-jawt" default="false"/>
      <sequential>
        <echo message="Output lib name = @{output.lib.name}" />

        <!-- NOTE: the value of the debug and optimise attributes will not be overridden if already set externally -->
        <property name="c.compiler.debug"     value="false" /> 
        <!-- Optimise flags one of { none, size, speed, minimal, full, aggressive, extreme, unsafe } --> 
        <property name="c.compiler.optimise"  value="none" /> 

        <condition property="c.compiler.use-debug"><istrue value="${c.compiler.debug}"/></condition>

        <patternset id="c.src.files.jogl.desktop">
          <include name="${rootrel.src.c}/macosx/MacOSXCustomCGLCode.c" if="isOSX"/>
          <include name="${rootrel.src.c}/macosx/MacOSXWindowSystemInterface.m" if="isOSX"/>
          <include name="${rootrel.src.c}/macosx/ContextUpdater.m" if="isOSX"/>
          <include name="${rootrel.src.c}/GLXGetProcAddressARB.c" if="isX11"/>
          <!-- FIXME: the Mixer should be moved to another library -->
          <!--include name="${rootrel.src.c}/Mixer.cpp" if="isWindows"/-->
          <include name="${rootrel.src.c.openmax}/omx_tool.c"  if="useOpenMAX"/>
          <include name="${rootrel.src.c.openmax}/com_jogamp_openmax_OMXInstance.c"  if="useOpenMAX"/>

          <include name="${rootrel.generated.c.jogl}/gl4/GL4bcImpl_JNI.c"/>
          <!--include name="${rootrel.generated.c.jogl}/GLU_JNI.c"/ EMPTY -->
          <include name="${rootrel.generated.c.jogl}/gl2/GLUgl2_JNI.c"/>
          <include name="${rootrel.generated.c.jogl}/X11/GLX*.c" if="isX11"/>
          <include name="${rootrel.generated.c.jogl}/MacOSX/CGL*.c" if="isOSX"/>
          <include name="${rootrel.generated.c.jogl}/Windows/GDI*.c" if="isWindows"/>
          <include name="${rootrel.generated.c.jogl}/Windows/WGL*.c" if="isWindows"/>
        </patternset>

        <patternset id="c.src.files.jogl.gl2es12">
          <include name="${rootrel.src.c}/macosx/MacOSXCustomCGLCode.c" if="isOSX"/>
          <include name="${rootrel.src.c}/macosx/MacOSXWindowSystemInterface.m" if="isOSX"/>
          <include name="${rootrel.src.c}/macosx/ContextUpdater.m" if="isOSX"/>
          <include name="${rootrel.src.c}/GLXGetProcAddressARB.c" if="isX11"/>
          <include name="${rootrel.src.c.openmax}/omx_tool.c"  if="useOpenMAX"/>
          <include name="${rootrel.src.c.openmax}/com_jogamp_openmax_OMXInstance.c"  if="useOpenMAX"/>

          <include name="${rootrel.generated.c.jogl}/gl2es12/GL2ES12Impl_JNI.c"/>
          <!--include name="${rootrel.generated.c.jogl}/GLU_JNI.c"/ EMPTY -->
          <!--include name="${rootrel.generated.c.jogl}/gl2es12/GLUgl2es12_JNI.c"/ SKIPPED -->
          <include name="${rootrel.generated.c.jogl}/X11/GLX*.c" if="isX11"/>
          <include name="${rootrel.generated.c.jogl}/MacOSX/CGL*.c" if="isOSX"/>
          <include name="${rootrel.generated.c.jogl}/Windows/WGL*.c" if="isWindows"/>
        </patternset>

        <patternset id="c.src.files.jogl.es2">
          <include name="${rootrel.src.c}/GLXGetProcAddressARB.c" if="isX11"/>
          <include name="${rootrel.src.c.openmax}/omx_tool.c"  if="useOpenMAX"/>
          <include name="${rootrel.src.c.openmax}/com_jogamp_openmax_OMXInstance.c"  if="useOpenMAX"/>

          <include name="${rootrel.generated.c.jogl}/egl/EGL_JNI.c"/>
          <include name="${rootrel.generated.c.jogl}/egl/EGLExtImpl_JNI.c"/>
          <include name="${rootrel.generated.c.jogl}/es2/GLES2Impl_JNI.c"/>
        </patternset>

        <patternset id="c.src.files.jogl.es1">
          <include name="${rootrel.src.c}/GLXGetProcAddressARB.c" if="isX11"/>
          <include name="${rootrel.src.c.openmax}/omx_tool.c"  if="useOpenMAX"/>
          <include name="${rootrel.src.c.openmax}/com_jogamp_openmax_OMXInstance.c"  if="useOpenMAX"/>

          <include name="${rootrel.generated.c.jogl}/egl/EGL_JNI.c"/>
          <include name="${rootrel.generated.c.jogl}/egl/EGLExtImpl_JNI.c"/>
          <include name="${rootrel.generated.c.jogl}/es1/GLES1Impl_JNI.c"/>
          <!--include name="${rootrel.generated.c.jogl}/GLU_JNI.c"/ EMPTY -->
          <!--include name="${rootrel.generated.c.jogl}/es1/GLUes1_JNI.c" EMPTY /-->
        </patternset>

        <patternset id="c.src.files.cg">
          <include name="${rootrel.generated.c.cg}/*.c"/>
        </patternset>

        <echo message="Compiling @{output.lib.name}" />

        <cc outtype="shared" 
            objdir="${obj.joglsub}" 
            outfile="${obj.jogl}/@{output.lib.name}"
            optimize="${c.compiler.optimise}" 
            debug="${c.compiler.debug}"
            multithreaded="true" 
            exceptions="false" 
            rtti="false">   
  
          <!-- TODO: versioninfo  companyname="java.net"
                        legalcopyright="Copyright"
                        productname="JOGL" 
                        productversion="x.y.z"
                        description="Description"
                        fileversion="x.y.z" 
                        filecomments="File Comment" /-->      
  
          <fileset dir="${project.root}"><patternset refid="@{c.compiler.src.files}"/></fileset>
  
          <compiler extends="@{compiler.cfg.id}" >
            <sysincludepath path="${java.includes.dir}"/>
            <sysincludepath path="${java.includes.dir.platform}"/>
            <includepath path="stub_includes/opengl"/>
            <includepath path="stub_includes/egl"/>
            <includepath path="stub_includes/openmax" if="useOpenMAX"/>
            <includepath path="stub_includes/cg" if="jogl.cg"/>        
  
            <!-- This is for the generated headers for handwritten C code -->
            <includepath path="${src.generated.c}" />
            <includepath path="${src.generated.c}/X11" if="isX11"/>
            <includepath path="${src.generated.c}/MacOSX" if="isOSX"/>
            <includepath path="${src.generated.c}/Windows" if="isWindows"/>
            <includepath path="${src.generated.c.openmax}" if="useOpenMAX"/>
  
            <!-- This must come last to not override real include paths -->
            <!-- includepath path="stub_includes/macosx" if="isOSX" / -->
          </compiler>

          <linker extends="@{linker.cfg.id}">
            <syslibset dir="${java.lib.platform}" libs="jawt" if="@{output.lib.name}.useLibJAWT"/>
            <syslibset dir="${java.lib.platform}/server" libs="jvm" if="@{output.lib.name}.useLibJVM"/>
          </linker>
        </cc>

        <!-- FIXME: this is a hack; the cpptask should have an option to change the
             suffix or at least understand the override from dylib to jnilib -->
        <antcall target="rename.dylib" inheritRefs="true">
            <param name="src"  value="${build.jogl}/obj/lib@{output.lib.name}.dylib" />
            <param name="dest" value="${build.jogl}/obj/lib@{output.lib.name}.jnilib" />
            <param name="dest-cdc" value="${build.jogl}/obj/lib@{output.lib.name}.so" />
        </antcall>

        <!-- FIXME: this is a hack; the cpptask should have an option to change the
             suffix or at least understand the override from dylib to jnilib -->
        <antcall target="rename.mingw.dll" inheritRefs="true">
            <param name="src"  value="${build.jogl}/obj/lib@{output.lib.name}.so" />
            <param name="dest" value="${build.jogl}/obj/@{output.lib.name}.dll" />
        </antcall>
      </sequential>
    </macrodef>  

    <target name="c.build.jogl.prepare.openMAX" if="useOpenMAX">
      <javah destdir="${src.generated.c.openmax}" classpath="${classes-cdc}" class="com.jogamp.openmax.OMXInstance" />
    </target>

    <target name="c.build.jogl.prepare" depends="c.build.jogl.prepare.openMAX">
      <!-- Generate the waveout Mixer header -->
      <!-- FIXME: this is temporary until we move this to another workspace -->
      <!--javah destdir="${build.jogl}/gensrc/native/jogl" classpath="${classes}" class="com.jogamp.audio.windows.waveout.Mixer" /-->
    </target>

    <target name="c.build.jogl.desktop" unless="setup.nodesktop">
      <c.build c.compiler.src.files="c.src.files.jogl.desktop"
               output.lib.name="jogl_desktop"
               compiler.cfg.id="${compiler.cfg.id}"
               linker.cfg.id="${linker.cfg.id.os}"/>
    </target>

    <target name="c.build.jogl.gl2es12" unless="setup.nodesktop">
      <c.build c.compiler.src.files="c.src.files.jogl.gl2es12"
               output.lib.name="jogl_gl2es12"
               compiler.cfg.id="${compiler.cfg.id}"
               linker.cfg.id="${linker.cfg.id.os}"/>
    </target>

    <target name="c.build.jogl.es2">
      <c.build c.compiler.src.files="c.src.files.jogl.es2"
               output.lib.name="jogl_es2"
               compiler.cfg.id="${compiler.cfg.id}"
               linker.cfg.id="${linker.cfg.id.base}"/>
    </target>

    <target name="c.build.jogl.es1">
      <c.build c.compiler.src.files="c.src.files.jogl.es1"
               output.lib.name="jogl_es1"
               compiler.cfg.id="${compiler.cfg.id}"
               linker.cfg.id="${linker.cfg.id.base}"/>
    </target>

    <target name="c.build.jogl.cg" if="jogl.cg">
      <c.build c.compiler.src.files="c.src.files.cg"
               output.lib.name="jogl_cg"
               compiler.cfg.id="${compiler.cfg.id}"
               linker.cfg.id="${linker.cfg.id.os}"/>
    </target>
    
    <target name="c.manifest.cg" if="jogl.cg">
      <msvc.manifest objdir="${obj.jogl}" dllname="jogl_cg" />
    </target>

    <target name="c.manifest" if="isVC8Family">
      <!-- exec mt, the Microsoft Manifest Tool, to include DLL manifests in order to resolve the location of msvcr80.dll -->
      <msvc.manifest objdir="${obj.jogl}" dllname="jogl_es1" />
      <msvc.manifest objdir="${obj.jogl}" dllname="jogl_es2" />
      <msvc.manifest objdir="${obj.jogl}" dllname="jogl_gl2es12" />
      <msvc.manifest objdir="${obj.jogl}" dllname="jogl_desktop" />
      <antcall target="c.manifest.cg" inheritRefs="true" />
    </target>

    <target name="c.build.jogl" depends="c.configure,c.build.jogl.prepare,c.build.jogl.gl2es12,c.build.jogl.desktop,c.build.jogl.es2,c.build.jogl.es1,c.build.jogl.cg">
      <antcall target="gluegen.cpptasks.striplibs" inheritRefs="true">
          <param name="libdir" value="${obj.jogl}"/>
      </antcall>

      <antcall target="c.manifest" inheritRefs="true" />
    </target>

    <!-- ================================================================== -->
    <!--
       - Build the jogl.jar files.
      -->
    <target name="build-jars" depends="gluegen.cpptasks.detect.os,build-jars-javase,build-jars-cdc" />

    <target name="setup-manifestfile">
        <condition property="manifestfile" value="joglRIversion">
            <isset property="jogl.ri" />
        </condition>
        <condition property="manifestfile" value="joglversion">
            <not>
                <isset property="jogl.ri" />
            </not>
        </condition>
        <tstamp>
             <format property="timestamp" pattern="yyyyMMdd-HH:mm:ss"/>
        </tstamp>
        <copy file="${manifestfile}"
            tofile="${build.jogl}/tempversion"
            overwrite="true">
            <filterset>
                <!-- This token only exists in the non-RI version of the manifest -->
                <filter token="VERSION" value="${jogl_base_version}-pre-${timestamp}"/>
                <!-- This token exists in both the RI and non-RI versions of the manifest -->
                <filter token="BASEVERSION" value="${jogl_base_version}"/>
            </filterset>
        </copy>
    </target>

    <target name="setup-manifestfile-cdc" unless="setup.noCDC">
        <condition property="manifestfile" value="joglRIversion-cdc">
            <isset property="jogl.ri" />
        </condition>
        <condition property="manifestfile" value="joglversion-cdc">
            <not>
                <isset property="jogl.ri" />
            </not>
        </condition>
        <tstamp>
             <format property="timestamp" pattern="yyyyMMdd-HH:mm:ss"/>
        </tstamp>
        <copy file="${manifestfile}"
            tofile="${build.jogl}/tempversion-cdc"
            overwrite="true">
            <filterset>
                <!-- This token only exists in the non-RI version of the manifest -->
                <filter token="VERSION" value="${jogl_base_version}-pre-${timestamp}"/>
                <!-- This token exists in both the RI and non-RI versions of the manifest -->
                <filter token="BASEVERSION" value="${jogl_base_version}"/>
            </filterset>
        </copy>
    </target>

    <target name="build-cg-jar-javase" depends="setup-manifestfile" if="jogl.cg">
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.cg.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.nv-cg}"/>
        </jar>
    </target>

    <target name="build-jars-os-desktop-javase" depends="setup-manifestfile" unless="setup.nodesktop">
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.os.x11.jar}" filesonly="true">
            <fileset dir="${classes}" includes="${java.part.glx}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.os.win.jar}" filesonly="true">
            <fileset dir="${classes}" includes="${java.part.wgl}" />
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.os.osx.jar}" filesonly="true">
            <fileset dir="${classes}" includes="${java.part.cgl}"/>
        </jar>
    </target>

    <target name="build-jars-es-javase" depends="setup-manifestfile">
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.egl.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.egl}"
                     excludes="${java.part.awt}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.gles1.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.es1}"
                     excludes="${java.part.es1.dbg}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.gles1.dbg.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.es1.dbg}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.gles2.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.es2}, ${java.part.openmax}"
                     excludes="${java.part.es2.dbg}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.gles2.dbg.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.es2.dbg}"/>
        </jar>
    </target>

    <target name="build-jars-os-desktop-cdc" depends="setup-manifestfile" unless="setup.nodesktop">
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.os.x11.cdc.jar}" filesonly="true">
            <fileset dir="${classes-cdc}" includes="${java.part.glx}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.os.win.cdc.jar}" filesonly="true">
            <fileset dir="${classes-cdc}" includes="${java.part.wgl}" />
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.os.osx.cdc.jar}" filesonly="true">
            <fileset dir="${classes-cdc}" includes="${java.part.cgl}"/>
        </jar>
    </target>

    <target name="build-jars-es-desktop-cdc" depends="setup-manifestfile-cdc,build-jars-os-desktop-cdc" unless="setup.nodesktop">
        <jar manifest="${build.jogl}/tempversion-cdc" destfile="${jogl.gl2es12.cdc.jar}" filesonly="true">
            <fileset dir="${classes-cdc}"
                     includes="${java.part.gl2es12}, ${java.part.openmax}"
                     excludes="${java.part.glugldesktop}"/>
        </jar>
    </target>

    <target name="build-jars-es-cdc" depends="setup-manifestfile-cdc, build-jars-es-desktop-cdc" unless="setup.noCDC">
        <jar manifest="${build.jogl}/tempversion-cdc" destfile="${jogl.egl.cdc.jar}" filesonly="true">
            <fileset dir="${classes-cdc}"
                     includes="${java.part.egl}"
                     excludes="${java.part.awt}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion-cdc" destfile="${jogl.gles1.cdc.jar}" filesonly="true">
            <fileset dir="${classes-cdc}"
                     includes="${java.part.es1}"
                     excludes="${java.part.es1.dbg}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion-cdc" destfile="${jogl.gles1.dbg.cdc.jar}" filesonly="true">
            <fileset dir="${classes-cdc}"
                     includes="${java.part.es1.dbg}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion-cdc" destfile="${jogl.gles2.cdc.jar}" filesonly="true">
            <fileset dir="${classes-cdc}"
                     includes="${java.part.es2}, ${java.part.openmax}"
                     excludes="${java.part.es2.dbg}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion-cdc" destfile="${jogl.gles2.dbg.cdc.jar}" filesonly="true">
            <fileset dir="${classes-cdc}"
                     includes="${java.part.es2.dbg}"/>
        </jar>
    </target>

    <target name="build-jars-awt-javase" depends="setup-manifestfile" unless="setup.noAWT">
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.awt.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.awt}" />
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.util.awt.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.util.awt}"/>
        </jar>
    </target>

    <target name="build-jars-all-awt-javase" depends="setup-manifestfile" unless="setup.noAWT">
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.all.jar}" filesonly="true">
            <fileset dir="${classes}">
                <include name="javax/media/opengl/**" />
                <include name="com/jogamp/gluegen/runtime/**" />
                <include name="com/jogamp/opengl/**" />
                <include name="${java.part.openmax}" />
                <!-- FIXME: this is temporary until we move these classes to another workspace -->
                <include name="com/jogamp/**" />
                <exclude name="${java.part.gl2es12}"/>
            </fileset>
            <fileset dir="${src.java}"
                     includes="${java.part.util.fixedfuncemu.shadercode}"/>
        </jar>
    </target>
    <target name="build-jars-all-noawt-javase" depends="setup-manifestfile">
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.all-noawt.jar}" filesonly="true">
            <fileset dir="${classes}"
                includes="javax/media/opengl/** com/jogamp/gluegen/runtime/** com/jogamp/opengl/** ${java.part.openmax} com/jogamp/**"
                excludes="${java.part.awt} ${java.part.util.awt} ${java.part.gl2es12}">
            </fileset>
            <fileset dir="${src.java}"
                     includes="${java.part.util.fixedfuncemu.shadercode}"/>
        </jar>
    </target>
    <target name="build-jars-all-cdc" depends="setup-manifestfile">
        <jar manifest="${build.jogl}/tempversion-cdc" destfile="${jogl.all.cdc.jar}" filesonly="true">
            <fileset dir="${classes-cdc}"
                     includes="${java.part.core} ${java.part.egl} ${java.part.glutess} ${java.part.glumipmap} ${java.part.openmax} ${java.part.sdk} ${java.part.glx} ${java.part.cgl} ${java.part.wgl} ${java.part.es1} ${java.part.es1.dbg} ${java.part.es2} ${java.part.es2.dbg} ${java.part.gl2es12} ${java.part.util} ${java.part.util.glsl} ${java.part.util.fixedfuncemu}"
                     excludes="${java.excludes.cdcfp}"/>
            <fileset dir="${src.java}"
                     includes="${java.part.util.fixedfuncemu.shadercode}"/>
        </jar>
    </target>


    <target name="build-jars-cdc" depends="setup-manifestfile-cdc, build-jars-es-cdc, build-jars-all-cdc" unless="setup.noCDC">
        <jar manifest="${build.jogl}/tempversion-cdc" destfile="${jogl.core.cdc.jar}" filesonly="true">
            <fileset dir="${classes-cdc}"
                     includes="${java.part.core}"
                     excludes="${java.part.core.exclude}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion-cdc" destfile="${jogl.glutess.cdc.jar}" filesonly="true">
            <fileset dir="${classes-cdc}"
                     includes="${java.part.glutess}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion-cdc" destfile="${jogl.glumipmap.cdc.jar}" filesonly="true">
            <fileset dir="${classes-cdc}"
                     includes="${java.part.glumipmap}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion-cdc" destfile="${jogl.util.cdc.jar}" filesonly="true">
            <fileset dir="${classes-cdc}"
                     includes="${java.part.util} ${java.part.util.glsl}"
                     excludes="${java.part.util.awt} ${java.part.util.gldesktop} ${java.part.util.fixedfuncemu}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion-cdc" destfile="${jogl.util.fixedfuncemu.cdc.jar}" filesonly="true">
            <fileset dir="${classes-cdc}"
                     includes="${java.part.util.fixedfuncemu}"/>
            <fileset dir="${src.java}"
                     includes="${java.part.util.fixedfuncemu.shadercode}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion-cdc" destfile="${build.jogl}/jogl-natives-${os.and.arch}-cdc.jar" filesonly="true">
            <fileset dir="${obj.jogl}">
              <include name="*_es1.${native.library.suffix-cdc}" />
              <include name="*_es2.${native.library.suffix-cdc}" />
              <include name="*_gl2es12.${native.library.suffix-cdc}" />
            </fileset>
        </jar>
    </target>

    <target name="build-jars-desktop-javase" depends="setup-manifestfile,build-jars-os-desktop-javase" unless="setup.nodesktop">
        <!--os specific gldesktop-->
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.gldesktop.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.gldesktop}, ${java.part.openmax}"
                     excludes="${java.part.gldesktop.dbg}, ${java.part.glugldesktop}, ${java.part.gl2es12}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.gl2es12.jar}" filesonly="true">
            <fileset dir="${classes}" includes="${java.part.gl2es12}, ${java.part.openmax}"
                     excludes="${java.part.glugldesktop}"/>
        </jar>

        <!-- misc -->
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.gldesktop.dbg.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.gldesktop.dbg}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.glugldesktop.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.glugldesktop}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.util.gldesktop.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.util.gldesktop}"
                     excludes="com/jogamp/opengl/**/awt/**"/>
        </jar>
    </target>

    <target name="build-jars-javase" depends="setup-manifestfile, build-jars-es-javase, build-jars-awt-javase, build-cg-jar-javase, build-jars-all-awt-javase, build-jars-all-noawt-javase, build-jars-desktop-javase">
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.core.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.core}"
                     excludes="${java.part.core.exclude}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.sdk.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.sdk}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.glutess.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.glutess}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.glumipmap.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.glumipmap}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.util.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.util} ${java.part.util.glsl}"
                     excludes="${java.part.util.awt} ${java.part.util.gldesktop} ${java.part.util.fixedfuncemu}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${jogl.util.fixedfuncemu.jar}" filesonly="true">
            <fileset dir="${classes}"
                     includes="${java.part.util.fixedfuncemu}"/>
            <fileset dir="${src.java}"
                     includes="${java.part.util.fixedfuncemu.shadercode}"/>
        </jar>
        <jar manifest="${build.jogl}/tempversion" destfile="${build.jogl}/jogl-natives-${os.and.arch}.jar" filesonly="true">
            <fileset dir="${obj.jogl}">
              <include name="*.${native.library.suffix}" />
            </fileset>
        </jar>
    </target>

    <!-- ================================================================== -->
    <!--
       - Build the Javadocs for the sources.
       - NOTE:  these are not entirely correct as the javadocs targets depend 
       -        on the platform specific build targets.  To circumvent any 
       -        errors, ensure that the source is built first.
      -->
    <target name="javadoc.nocg" depends="init" unless="jogl.cg">
        <!-- Build the general public Javadoc -->
        <javadoc packagenames="${javadoc.packagenames}"
                 excludepackagenames="${java.excludes.javadoc.packagenames}"
                 sourcepath="${src.java};${src.generated.java}"        
                 destdir="${javadoc}" windowtitle="${javadoc.windowtitle}"
                 overview="${javadoc.overview}" 
                 source="1.4"
                 maxmemory="512m"
                 linkoffline="${javadoc.link} 142-packages"
         bottom="${javadoc.bottom}" >
          <classpath refid="nativewindow_gluegen.classpath"/>
          <taglet name="net.highteq.nativetaglet.NativeTaglet" path="${gluegen.jar}" />
        </javadoc>
    </target>

    <!-- Same as above but with Cg directories added -->
    <target name="javadoc.cg" depends="init" if="jogl.cg">
        <!-- Build the general public Javadoc with CG -->
        <javadoc packagenames="${javadoc.packagenames},com.jogamp.opengl.cg"
                 excludepackagenames="${java.excludes.javadoc.packagenames}"
                 sourcepath="${src.java};${src.generated.java}"        
                 destdir="${javadoc}" windowtitle="${javadoc.windowtitle}"
                 overview="${javadoc.overview}" 
                 source="1.4"
                 maxmemory="512m"
                 linkoffline="${javadoc.link} 142-packages"
         bottom="${javadoc.bottom}" >
          <classpath refid="nativewindow_gluegen.classpath"/>
          <taglet name="net.highteq.nativetaglet.NativeTaglet" path="${gluegen.jar}" />
        </javadoc>
    </target>

    <target name="javadoc" depends="javadoc.nocg,javadoc.cg" />

    <target name="javadoc.spec.nocg" depends="init" unless="jogl.cg">
        <!-- Build the specification Javadoc -->
        <javadoc packagenames="${javadoc.spec.packagenames}"
                 excludepackagenames="${java.excludes.javadoc.packagenames}"
                 sourcepath="${src.java};${src.generated.java}"
                 destdir="${javadoc.spec}" windowtitle="${javadoc.windowtitle}"
                 overview="${javadoc.overview}"
                 source="1.4"
                 maxmemory="512m"
                 linkoffline="${javadoc.link} 142-packages"
                 bottom="${javadoc.bottom}" >
          <classpath refid="nativewindow_gluegen.classpath"/>
          <taglet name="net.highteq.nativetaglet.NativeTaglet" path="${gluegen.jar}" />
        </javadoc>
    </target>
                                                                                                                                   
    <!-- Same as above since Cg directories are not part of spec -->
    <target name="javadoc.spec.cg" depends="init" if="jogl.cg">
        <!-- Build the specification Javadoc with CG -->
        <javadoc packagenames="${javadoc.spec.packagenames}"
                 excludepackagenames="${java.excludes.javadoc.packagenames}"
                 sourcepath="${src.java};${src.generated.java}"
                 destdir="${javadoc.spec}" windowtitle="${javadoc.windowtitle}"
                 overview="${javadoc.overview}"
                 source="1.4"
                 maxmemory="512m"
                 linkoffline="${javadoc.link} 142-packages"
                 bottom="${javadoc.bottom}" >
          <classpath refid="nativewindow_gluegen.classpath"/>
          <taglet name="net.highteq.nativetaglet.NativeTaglet" path="${gluegen.jar}" />
        </javadoc>
    </target>

    <target name="javadoc.spec" depends="javadoc.spec.nocg,javadoc.spec.cg" />

    <target name="javadoc.dev.nocg" unless="jogl.cg">
        <!-- Build the internal developer Javadoc -->
        <javadoc packagenames="${javadoc.dev.packagenames}"
                 excludepackagenames="${java.excludes.javadoc.packagenames}"
                 sourcepath="${src.java};${src.generated.java}"        
                 destdir="${javadoc.dev}" windowtitle="${javadoc.windowtitle}"
                 overview="${javadoc.overview}" 
                 source="1.4"
                 maxmemory="512m"
                 linkoffline="${javadoc.link} 142-packages"
         bottom="${javadoc.bottom}" >
          <classpath refid="nativewindow_gluegen.classpath"/>
          <taglet name="net.highteq.nativetaglet.NativeTaglet" path="${gluegen.jar}" />
        </javadoc>
    </target>

    <!-- Same as above but with Cg directories added -->
    <target name="javadoc.dev.cg" if="jogl.cg">
        <!-- Build the internal developer Javadoc -->
        <javadoc packagenames="${javadoc.dev.packagenames},com.jogamp.opengl.cg"
                 excludepackagenames="${java.excludes.javadoc.packagenames}"
                 sourcepath="${src.java};${src.generated.java}"        
                 destdir="${javadoc.dev}" windowtitle="${javadoc.windowtitle}"
                 overview="${javadoc.overview}" 
                 source="1.4"
                 maxmemory="512m"
                 linkoffline="${javadoc.link} 142-packages"
         bottom="${javadoc.bottom}" >
          <classpath refid="nativewindow_gluegen.classpath"/>
          <taglet name="net.highteq.nativetaglet.NativeTaglet" path="${gluegen.jar}" />
        </javadoc>
    </target>

    <target name="javadoc.dev.all"  depends="init,javadoc.dev.nocg,javadoc.dev.cg" />

    <target name="all.doc" description="Build JOGL docs" depends="init,javadoc,javadoc.spec,javadoc.dev.all" />

    <!-- ================================================================== -->
    <!--
       - Clean up all that is built.
      -->
    <target name="clean" description="Remove all build products" depends="declare.common">
        <delete includeEmptyDirs="true" quiet="true">
            <fileset dir="${tempdir}" />
            <fileset dir="${build.jogl}" />
            <fileset dir="${javadoc}" />
            <fileset dir="${javadoc.spec}" />
            <fileset dir="${javadoc.dev}" />
        </delete>
    </target>

    <!-- ================================================================== -->
    <!--
       - Build everything.
      -->
    <target name="all" description="Build JOGL JAR file(s) and native libraries." depends="init,java.compile,c.build.jogl,build-jars,generate.version.txt" />

    <target name="generate.version.txt" depends="init">
        <!-- Create a version.txt file indicating which version we just built -->
        <echo message="${jogl.version}" file="${build.jogl}/version.txt" />
    </target>

    <!-- ================================================================== -->
    <!--
       - Build everything and use Sun's Implementation tag in the manifest to
       - indicate this is the Reference Implementation.
      -->
    <target name="RI">
        <!-- Set property for using the RI manifest file so jogl.jar is versioned
           - properly
          -->
          <property name="jogl.ri" value="true" />
          <antcall target="all" inheritRefs="true" />
    </target>
</project>