summaryrefslogtreecommitdiffstats
path: root/src/demos/proceduralTexturePhysics
diff options
context:
space:
mode:
authorKenneth Russel <[email protected]>2009-06-15 23:05:16 +0000
committerKenneth Russel <[email protected]>2009-06-15 23:05:16 +0000
commit935d2596c13371bb745d921dbcb9f05b0c11a010 (patch)
tree7fcc310618ae5a90edc734dc821e75afc0f080aa /src/demos/proceduralTexturePhysics
parente2332d2f2908e68f1e77454c73f329f8ff2b400d (diff)
Deleted obsolete source code in preparation for copying JOGL_2_SANDBOX
on to trunk git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/../svn-server-sync/jogl-demos/trunk@351 3298f667-5e0e-4b4a-8ed4-a3559d26a5f4
Diffstat (limited to 'src/demos/proceduralTexturePhysics')
-rw-r--r--src/demos/proceduralTexturePhysics/ProceduralTexturePhysics.java381
-rw-r--r--src/demos/proceduralTexturePhysics/Water.java1844
2 files changed, 0 insertions, 2225 deletions
diff --git a/src/demos/proceduralTexturePhysics/ProceduralTexturePhysics.java b/src/demos/proceduralTexturePhysics/ProceduralTexturePhysics.java
deleted file mode 100644
index e20d811..0000000
--- a/src/demos/proceduralTexturePhysics/ProceduralTexturePhysics.java
+++ /dev/null
@@ -1,381 +0,0 @@
-/*
- * Portions Copyright (C) 2003 Sun Microsystems, Inc.
- * All rights reserved.
- */
-
-/*
- *
- * COPYRIGHT NVIDIA CORPORATION 2003. ALL RIGHTS RESERVED.
- * BY ACCESSING OR USING THIS SOFTWARE, YOU AGREE TO:
- *
- * 1) ACKNOWLEDGE NVIDIA'S EXCLUSIVE OWNERSHIP OF ALL RIGHTS
- * IN AND TO THE SOFTWARE;
- *
- * 2) NOT MAKE OR DISTRIBUTE COPIES OF THE SOFTWARE WITHOUT
- * INCLUDING THIS NOTICE AND AGREEMENT;
- *
- * 3) ACKNOWLEDGE THAT TO THE MAXIMUM EXTENT PERMITTED BY
- * APPLICABLE LAW, THIS SOFTWARE IS PROVIDED *AS IS* AND
- * THAT NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES,
- * EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED
- * TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE.
- *
- * IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS BE LIABLE FOR ANY
- * SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
- * WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS
- * OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
- * INFORMATION, OR ANY OTHER PECUNIARY LOSS), INCLUDING ATTORNEYS'
- * FEES, RELATING TO THE USE OF OR INABILITY TO USE THIS SOFTWARE,
- * EVEN IF NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- *
- */
-
-package demos.proceduralTexturePhysics;
-
-import java.awt.*;
-import java.awt.event.*;
-import javax.swing.*;
-
-import javax.media.opengl.*;
-import com.sun.opengl.util.*;
-import demos.common.*;
-import demos.util.*;
-import gleem.*;
-import gleem.linalg.*;
-
-/**
- * Water demonstration by NVidia Corporation - <a href =
- * "http://developer.nvidia.com/view.asp?IO=ogl_dynamic_bumpreflection">http://developer.nvidia.com/view.asp?IO=ogl_dynamic_bumpreflection</a>
- *
- * <P>
- *
- * Demonstrates pbuffers, vertex programs, fragment programs
- *
- * <P>
- *
- * Ported to Java and ARB_fragment_program by Kenneth Russell
- *
- */
-
-public class ProceduralTexturePhysics extends Demo {
- public static void main(String[] args) {
- GLCanvas canvas = new GLCanvas();
- ProceduralTexturePhysics demo = new ProceduralTexturePhysics();
- canvas.addGLEventListener(demo);
-
- final Animator animator = new Animator(canvas);
- demo.setDemoListener(new DemoListener() {
- public void shutdownDemo() {
- runExit(animator);
- }
- public void repaint() {}
- });
-
- Frame frame = new Frame("Procedural Texture Waves");
- frame.setLayout(new BorderLayout());
- canvas.setSize(512, 512);
- frame.add(canvas, BorderLayout.CENTER);
- frame.pack();
- frame.show();
- canvas.requestFocus();
-
- frame.addWindowListener(new WindowAdapter() {
- public void windowClosing(WindowEvent e) {
- runExit(animator);
- }
- });
-
- animator.start();
- }
-
- //----------------------------------------------------------------------
- // Internals only below this point
- //
-
- public void shutdownDemo() {
- viewer.detach();
- ManipManager.getManipManager().unregisterWindow(drawable);
- drawable.removeGLEventListener(this);
- super.shutdownDemo();
- }
-
- private volatile boolean drawing;
- private volatile int mousePosX;
- private volatile int mousePosY;
-
- private GLAutoDrawable drawable;
- private Water water = new Water();
- private volatile ExaminerViewer viewer;
- private boolean[] b = new boolean[256];
- private boolean doViewAll = true;
- private float zNear = 0.1f;
- private float zFar = 10.0f;
-
- private DurationTimer timer = new DurationTimer();
- private boolean firstRender = true;
- private int frameCount;
-
- private float blurIncrement = 0.01f;
- private float bumpIncrement = 0.01f;
- private float frequencyIncrement = 0.1f;
-
- public void init(GLAutoDrawable drawable) {
- water.destroy();
- water.initialize("demos/data/images/nvfixed.tga",
- "demos/data/images/nvspin.tga",
- "demos/data/images/droplet.tga",
- "demos/data/cubemaps/CloudyHills_",
- "tga",
- drawable);
-
- GL gl = drawable.getGL();
- gl.setSwapInterval(1);
-
- try {
- checkExtension(gl, "GL_VERSION_1_3"); // For multitexture
- checkExtension(gl, "GL_ARB_vertex_program");
- checkExtension(gl, "GL_ARB_fragment_program");
- checkExtension(gl, "GL_ARB_pbuffer");
- checkExtension(gl, "GL_ARB_pixel_format");
- } catch (GLException e) {
- e.printStackTrace();
- throw(e);
- }
-
- gl.glClearColor(0, 0.2f, 0.5f, 0);
- gl.glDisable(GL.GL_LIGHTING);
- gl.glDisable(GL.GL_DEPTH_TEST);
- gl.glDisable(GL.GL_CULL_FACE);
-
- doViewAll = true;
-
- if (firstRender) {
- firstRender = false;
-
- // Register the window with the ManipManager
- ManipManager manager = ManipManager.getManipManager();
- manager.registerWindow(drawable);
- this.drawable = drawable;
-
- viewer = new ExaminerViewer(MouseButtonHelper.numMouseButtons());
- viewer.setAutoRedrawMode(false);
- viewer.attach(drawable, new BSphereProvider() {
- public BSphere getBoundingSphere() {
- return new BSphere(new Vec3f(0, 0, 0), 1.2f);
- }
- });
- viewer.setVertFOV((float) (15.0f * Math.PI / 32.0f));
- viewer.setZNear(zNear);
- viewer.setZFar(zFar);
-
- drawable.addKeyListener(new KeyAdapter() {
- public void keyPressed(KeyEvent e) {
- dispatchKey(e.getKeyChar());
- }
- });
-
- drawable.addMouseListener(new MouseAdapter() {
- public void mousePressed(MouseEvent e) {
- if (e.getButton() == MouseEvent.BUTTON1 &&
- !e.isAltDown() && !e.isMetaDown()) {
- drawing = true;
- }
- }
-
- public void mouseReleased(MouseEvent e) {
- if (e.getButton() == MouseEvent.BUTTON1) {
- drawing = false;
- }
- }
- });
-
- drawable.addMouseMotionListener(new MouseMotionAdapter() {
- public void mouseDragged(MouseEvent e) {
- mousePosX = e.getX();
- mousePosY = e.getY();
- }
- });
-
- timer.start();
- }
- }
-
- public void display(GLAutoDrawable drawable) {
- if (++frameCount == 30) {
- timer.stop();
- System.err.println("Frames per second: " + (30.0f / timer.getDurationAsSeconds()));
- timer.reset();
- timer.start();
- frameCount = 0;
- }
-
- GL gl = drawable.getGL();
-
- gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
-
- if (doViewAll) {
- viewer.viewAll(gl);
- doViewAll = false;
- }
-
- viewer.update(gl);
- ManipManager.getManipManager().updateCameraParameters(drawable, viewer.getCameraParameters());
- ManipManager.getManipManager().render(drawable, gl);
-
- if (drawing) {
- int w = drawable.getWidth();
- int h = drawable.getHeight();
- water.addDroplet(new Water.Droplet( 2 * (mousePosX / (float) w - 0.5f),
- -2 * (mousePosY / (float) h - 0.5f),
- 0.08f));
- }
- water.tick();
-
- CameraParameters params = viewer.getCameraParameters();
- water.draw(gl, params.getOrientation().inverse());
- }
-
- public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {}
-
- // Unused routines
- public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged) {}
-
- private void setFlag(char key, boolean val) {
- b[((int) key) & 0xFF] = val;
- }
-
- private boolean getFlag(char key) {
- return b[((int) key) & 0xFF];
- }
-
- private void checkExtension(GL gl, String extensionName) {
- if (!gl.isExtensionAvailable(extensionName)) {
- String message = "Unable to initialize " + extensionName + " OpenGL extension";
- JOptionPane.showMessageDialog(null, message, "Unavailable extension", JOptionPane.ERROR_MESSAGE);
- shutdownDemo();
- }
- }
-
- private void dispatchKey(char k) {
- setFlag(k, !getFlag(k));
-
- switch (k) {
- case 27:
- case 'q':
- shutdownDemo();
- break;
- case 'w':
- water.enableWireframe(getFlag('w'));
- break;
- case 'd':
- // FIXME
- /*
-
- if (getKey('d')) {
- glutMouseFunc(glh::glut_mouse_function);
- glutMotionFunc(glh::glut_motion_function);
- }
- else
- {
- glutMouseFunc(Mouse);
- glutMotionFunc(Motion);
- }
- */
- break;
- case ' ':
- water.enableAnimation(getFlag(' '));
- break;
- case 'b':
- water.enableBorderWrapping(getFlag('b'));
- break;
- case 'n':
- water.singleStep();
- break;
- case 's':
- water.enableSlowAnimation(getFlag('s'));
- break;
- case '1':
- water.setRenderMode(Water.CA_FULLSCREEN_REFLECT);
- break;
- case '2':
- water.setRenderMode(Water.CA_FULLSCREEN_HEIGHT);
- break;
- case '3':
- water.setRenderMode(Water.CA_FULLSCREEN_FORCE);
- break;
- case '4':
- water.setRenderMode(Water.CA_FULLSCREEN_NORMALMAP);
- break;
- case '5':
- water.setRenderMode(Water.CA_TILED_THREE_WINDOWS);
- break;
- case 'r':
- water.reset();
- break;
- case 'i':
- // FIXME: make sure this is what this does
- doViewAll = true;
- // gluPerspective(90, 1, .01, 10);
- break;
- case 'c': {
- float dist = water.getBlurDistance();
- if (dist > blurIncrement)
- water.setBlurDistance(dist - blurIncrement);
- break;
- }
- case 'v': {
- float dist = water.getBlurDistance();
- if (dist < 1)
- water.setBlurDistance(dist + blurIncrement);
- break;
- }
- case '-': {
- float scale = water.getBumpScale();
- if (scale > -1)
- water.setBumpScale(scale - bumpIncrement);
- break;
- }
- case '=': {
- float scale = water.getBumpScale();
- if (scale < 1)
- water.setBumpScale(scale + bumpIncrement);
- break;
- }
- case 'l':
- water.enableBoundaryApplication(getFlag('l'));
- break;
- case 'o':
- water.enableSpinningLogo(getFlag('o'));
- break;
- case '.': {
- float frequency = water.getBumpScale();
- if (frequency < 1)
- water.setDropFrequency(frequency + frequencyIncrement);
- break;
- }
- case ',': {
- float frequency = water.getBumpScale();
- if (frequency > 0)
- water.setDropFrequency(frequency - frequencyIncrement);
- break;
- }
- default:
- break;
- }
- }
-
- private static void runExit(final Animator animator) {
- // Note: calling System.exit() synchronously inside the draw,
- // reshape or init callbacks can lead to deadlocks on certain
- // platforms (in particular, X11) because the JAWT's locking
- // routines cause a global AWT lock to be grabbed. Run the
- // exit routine in another thread.
- new Thread(new Runnable() {
- public void run() {
- animator.stop();
- System.exit(0);
- }
- }).start();
- }
-}
diff --git a/src/demos/proceduralTexturePhysics/Water.java b/src/demos/proceduralTexturePhysics/Water.java
deleted file mode 100644
index 50be158..0000000
--- a/src/demos/proceduralTexturePhysics/Water.java
+++ /dev/null
@@ -1,1844 +0,0 @@
-/*
- * Portions Copyright (C) 2003 Sun Microsystems, Inc.
- * All rights reserved.
- */
-
-/*
- *
- * COPYRIGHT NVIDIA CORPORATION 2003. ALL RIGHTS RESERVED.
- * BY ACCESSING OR USING THIS SOFTWARE, YOU AGREE TO:
- *
- * 1) ACKNOWLEDGE NVIDIA'S EXCLUSIVE OWNERSHIP OF ALL RIGHTS
- * IN AND TO THE SOFTWARE;
- *
- * 2) NOT MAKE OR DISTRIBUTE COPIES OF THE SOFTWARE WITHOUT
- * INCLUDING THIS NOTICE AND AGREEMENT;
- *
- * 3) ACKNOWLEDGE THAT TO THE MAXIMUM EXTENT PERMITTED BY
- * APPLICABLE LAW, THIS SOFTWARE IS PROVIDED *AS IS* AND
- * THAT NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES,
- * EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED
- * TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE.
- *
- * IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS BE LIABLE FOR ANY
- * SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
- * WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS
- * OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
- * INFORMATION, OR ANY OTHER PECUNIARY LOSS), INCLUDING ATTORNEYS'
- * FEES, RELATING TO THE USE OF OR INABILITY TO USE THIS SOFTWARE,
- * EVEN IF NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- *
- */
-
-package demos.proceduralTexturePhysics;
-
-import java.awt.Image;
-import java.awt.image.*;
-import java.io.*;
-import java.nio.*;
-import java.text.*;
-import java.util.*;
-
-import gleem.linalg.*;
-import javax.media.opengl.*;
-import javax.media.opengl.glu.*;
-import com.sun.opengl.util.*;
-import com.sun.opengl.util.texture.*;
-import demos.util.*;
-
-/**
- * Auxiliary Water simulation class used by ProceduralTexturePhysics
- * main loop. Demonstration by NVidia Corporation.
- *
- * <P>
- *
- * Ported to Java and ARB_fragment_program by Kenneth Russell
- */
-
-public class Water {
- // Note: this class is organized differently than most of the demos
- // due to the fact that it is used for two purposes: when the
- // pbuffer's context is current it is used to update the cellular
- // automata, and when the parent drawable's context is current it is
- // used to render the water geometry (with the parent drawable's GL
- // object).
-
- private GLU glu = new GLU();
-
- // Rendering modes
- public static final int CA_FULLSCREEN_REFLECT = 0;
- public static final int CA_FULLSCREEN_FORCE = 1;
- public static final int CA_FULLSCREEN_HEIGHT = 2;
- public static final int CA_FULLSCREEN_NORMALMAP = 3;
- public static final int CA_TILED_THREE_WINDOWS = 4;
- public static final int CA_DO_NOT_RENDER = 5;
-
- private int[] initialMapDimensions = new int[2];
- private TextureData initialMapData;
-
- private String tmpSpinFilename;
- private String tmpDropletFilename;
- private String tmpCubeMapFilenamePrefix;
- private String tmpCubeMapFilenameSuffix;
-
- private GLPbuffer pbuffer;
- private Rotf cameraOrientation = new Rotf();
-
- // Dynamic texture names
- private static final int CA_TEXTURE_FORCE_INTERMEDIATE = 0;
- private static final int CA_TEXTURE_FORCE_TARGET = 1;
- private static final int CA_TEXTURE_VELOCITY_SOURCE = 2;
- private static final int CA_TEXTURE_VELOCITY_TARGET = 3;
- private static final int CA_TEXTURE_HEIGHT_SOURCE = 4;
- private static final int CA_TEXTURE_HEIGHT_TARGET = 5;
- private static final int CA_TEXTURE_NORMAL_MAP = 6;
- private static final int CA_NUM_DYNAMIC_TEXTURES = 7;
-
- // List names
- private static final int CA_FRAGMENT_PROGRAM_EQ_WEIGHT_COMBINE = 0;
- private static final int CA_FRAGMENT_PROGRAM_NEIGHBOR_FORCE_CALC_1 = 1;
- private static final int CA_FRAGMENT_PROGRAM_NEIGHBOR_FORCE_CALC_2 = 2;
- private static final int CA_FRAGMENT_PROGRAM_APPLY_FORCE = 3;
- private static final int CA_FRAGMENT_PROGRAM_APPLY_VELOCITY = 4;
- private static final int CA_FRAGMENT_PROGRAM_CREATE_NORMAL_MAP = 5;
- private static final int CA_FRAGMENT_PROGRAM_REFLECT = 6;
- private static final int CA_DRAW_SCREEN_QUAD = 7;
- private static final int CA_NUM_LISTS = 8;
-
- // Static textures
- private Texture initialMapTex;
- private Texture spinTex;
- private Texture dropletTex;
- private Texture cubemap;
-
- private Texture[] dynamicTextures = new Texture[CA_NUM_DYNAMIC_TEXTURES];
-
- private int texHeightInput; // current input height texture ID.
- private int texHeightOutput; // current output height texture ID.
- private int texVelocityInput; // current input velocity texture ID.
- private int texVelocityOutput; // current output velocity texture ID.
- private int texForceStepOne; // intermediate force computation result texture ID.
- private int texForceOutput; // current output force texture ID.
-
- private int[] displayListIDs = new int[CA_NUM_LISTS];
-
- private int vertexProgramID; // one vertex program is used to choose the texcoord offset
-
- private int flipState; // used to flip target texture configurations.
-
- private boolean wrap; // CA can either wrap its borders, or clamp (clamp by default)
- private boolean reset = true; // are we resetting this frame? (user hit reset).
- private boolean singleStep; // animation step on keypress.
- private boolean animate = true; // continuous animation.
- private boolean slow = true; // run slow.
- private boolean wireframe; // render in wireframe mode
- private boolean applyInteriorBoundaries = true; // enable / disable "boundary" image drawing.
- private boolean spinLogo = true; // draw spinning logo.
- private boolean createNormalMap = true; // enable / disable normal map creation.
-
- private float perTexelWidth; // width of a texel (percentage of texture)
- private float perTexelHeight; // height of a texel
-
- private float blurDist = 0.5f; // distance over which to blur.
- private boolean mustUpdateBlurOffsets; // flag indicating blurDist was set last tick
-
- private float normalSTScale = 0.8f; // scale of normals in normal map.
- private float bumpScale = 0.25f; // scale of bumps in water.
-
- private float dropletFrequency = 0.175f; // frequency at which droplets are drawn in water...
-
- private int slowDelay = 1; // amount (milliseconds) to delay when running slow.
- private int skipInterval; // frames to skip simulation.
- private int skipCount; // frame count for skipping rendering
-
- private int angle; // angle in degrees for spinning logo
-
- private List/*<Droplet>*/ droplets = new ArrayList/*<Droplet>*/(); // array of droplets
-
- private int renderMode;
-
- // Constant memory locations
- private static final int CV_UV_OFFSET_TO_USE = 0;
-
- private static final int CV_UV_T0_NO_OFFSET = 1;
- private static final int CV_UV_T0_TYPE1 = 2;
- private static final int CV_UV_T0_TYPE2 = 3;
- private static final int CV_UV_T0_TYPE3 = 4;
- private static final int CV_UV_T0_TYPE4 = 5;
-
- private static final int CV_UV_T1_NO_OFFSET = 6;
- private static final int CV_UV_T1_TYPE1 = 7;
- private static final int CV_UV_T1_TYPE2 = 8;
- private static final int CV_UV_T1_TYPE3 = 9;
- private static final int CV_UV_T1_TYPE4 = 10;
-
- private static final int CV_UV_T2_NO_OFFSET = 11;
- private static final int CV_UV_T2_TYPE1 = 12;
- private static final int CV_UV_T2_TYPE2 = 13;
- private static final int CV_UV_T2_TYPE3 = 14;
- private static final int CV_UV_T2_TYPE4 = 15;
-
- private static final int CV_UV_T3_NO_OFFSET = 16;
- private static final int CV_UV_T3_TYPE1 = 17;
- private static final int CV_UV_T3_TYPE2 = 18;
- private static final int CV_UV_T3_TYPE3 = 19;
- private static final int CV_UV_T3_TYPE4 = 20;
-
- private static final int CV_CONSTS_1 = 21;
-
- public void initialize(String initialMapFilename,
- String spinFilename,
- String dropletFilename,
- String cubeMapFilenamePrefix,
- String cubeMapFilenameSuffix,
- GLAutoDrawable parentWindow) {
- loadInitialTexture(initialMapFilename);
- tmpSpinFilename = spinFilename;
- tmpDropletFilename = dropletFilename;
- tmpCubeMapFilenamePrefix = cubeMapFilenamePrefix;
- tmpCubeMapFilenameSuffix = cubeMapFilenameSuffix;
-
- // create the pbuffer. Will use this as an offscreen rendering buffer.
- // it allows rendering a texture larger than our window.
- GLCapabilities caps = new GLCapabilities();
- caps.setDoubleBuffered(false);
- if (!GLDrawableFactory.getFactory().canCreateGLPbuffer()) {
- throw new GLException("Pbuffers not supported with this graphics card");
- }
- pbuffer = GLDrawableFactory.getFactory().createGLPbuffer(caps,
- null,
- initialMapDimensions[0],
- initialMapDimensions[1],
- parentWindow.getContext());
- pbuffer.addGLEventListener(new Listener());
- }
-
- public void destroy() {
- if (pbuffer != null) {
- pbuffer.destroy();
- pbuffer = null;
- }
- reset = true;
- }
-
- public void tick() {
- pbuffer.display();
- }
-
- public void draw(GL gl, Rotf cameraOrientation) {
- this.cameraOrientation.set(cameraOrientation);
-
- if (skipCount >= skipInterval && renderMode != CA_DO_NOT_RENDER) {
- skipCount = 0;
- // Display the results of the rendering to texture
- if (wireframe) {
- gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_LINE);
-
- // chances are the texture will be all dark, so lets not use a texture
- gl.glDisable(GL.GL_TEXTURE_2D);
- } else {
- gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_FILL);
-
- gl.glActiveTexture(GL.GL_TEXTURE0);
- gl.glEnable(GL.GL_TEXTURE_2D);
- }
-
- switch (renderMode) {
- case CA_FULLSCREEN_REFLECT: {
- // include bump scale...
- Mat4f bscale = new Mat4f();
- bscale.makeIdent();
- bscale.set(0, 0, bumpScale);
- bscale.set(1, 1, bumpScale);
- Mat4f rot = new Mat4f();
- rot.makeIdent();
- rot.setRotation(cameraOrientation);
- Mat4f matRot = rot.mul(bscale);
-
- gl.glCallList(displayListIDs[CA_FRAGMENT_PROGRAM_REFLECT]);
-
- // Draw quad over full display
- gl.glActiveTexture(GL.GL_TEXTURE0);
- dynamicTextures[CA_TEXTURE_NORMAL_MAP].bind();
- dynamicTextures[CA_TEXTURE_NORMAL_MAP].disable();
- gl.glActiveTexture(GL.GL_TEXTURE3);
- cubemap.bind();
- cubemap.enable();
-
- gl.glColor4f(1, 1, 1, 1);
- gl.glBegin(GL.GL_QUADS);
-
- gl.glMultiTexCoord2f(GL.GL_TEXTURE0, 0,0);
- gl.glMultiTexCoord4f(GL.GL_TEXTURE1, matRot.get(0,0), matRot.get(0,1), matRot.get(0,2), 1);
- gl.glMultiTexCoord4f(GL.GL_TEXTURE2, matRot.get(1,0), matRot.get(1,1), matRot.get(1,2), 1);
- gl.glMultiTexCoord4f(GL.GL_TEXTURE3, matRot.get(2,0), matRot.get(2,1), matRot.get(2,2), 1);
- gl.glVertex2f(-1,-1);
-
- gl.glMultiTexCoord2f(GL.GL_TEXTURE0, 1,0);
- gl.glMultiTexCoord4f(GL.GL_TEXTURE1, matRot.get(0,0), matRot.get(0,1), matRot.get(0,2), -1);
- gl.glMultiTexCoord4f(GL.GL_TEXTURE2, matRot.get(1,0), matRot.get(1,1), matRot.get(1,2), 1);
- gl.glMultiTexCoord4f(GL.GL_TEXTURE3, matRot.get(2,0), matRot.get(2,1), matRot.get(2,2), 1);
- gl.glVertex2f( 1,-1);
-
- gl.glMultiTexCoord2f(GL.GL_TEXTURE0, 1,1);
- gl.glMultiTexCoord4f(GL.GL_TEXTURE1, matRot.get(0,0), matRot.get(0,1), matRot.get(0,2), -1);
- gl.glMultiTexCoord4f(GL.GL_TEXTURE2, matRot.get(1,0), matRot.get(1,1), matRot.get(1,2), -1);
- gl.glMultiTexCoord4f(GL.GL_TEXTURE3, matRot.get(2,0), matRot.get(2,1), matRot.get(2,2), 1);
- gl.glVertex2f( 1, 1);
-
- gl.glMultiTexCoord2f(GL.GL_TEXTURE0, 0,1);
- gl.glMultiTexCoord4f(GL.GL_TEXTURE1, matRot.get(0,0), matRot.get(0,1), matRot.get(0,2), 1);
- gl.glMultiTexCoord4f(GL.GL_TEXTURE2, matRot.get(1,0), matRot.get(1,1), matRot.get(1,2), -1);
- gl.glMultiTexCoord4f(GL.GL_TEXTURE3, matRot.get(2,0), matRot.get(2,1), matRot.get(2,2), 1);
- gl.glVertex2f(-1, 1);
-
- gl.glEnd();
-
- cubemap.disable();
- gl.glDisable(GL.GL_FRAGMENT_PROGRAM_ARB);
-
- break;
- }
-
- case CA_FULLSCREEN_NORMALMAP: {
- // Draw quad over full display
- gl.glActiveTexture(GL.GL_TEXTURE0);
- dynamicTextures[CA_TEXTURE_NORMAL_MAP].bind();
-
- gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
- break;
- }
-
- case CA_FULLSCREEN_HEIGHT: {
- // Draw quad over full display
- gl.glActiveTexture(GL.GL_TEXTURE0);
- gl.glBindTexture(GL.GL_TEXTURE_2D, texHeightOutput);
-
- gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
- break;
- }
-
- case CA_FULLSCREEN_FORCE: {
- // Draw quad over full display
- gl.glActiveTexture(GL.GL_TEXTURE0);
- dynamicTextures[CA_TEXTURE_FORCE_TARGET].bind();
-
- gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
- break;
- }
-
- case CA_TILED_THREE_WINDOWS: {
- // Draw quad over full display
- // lower left
- gl.glActiveTexture(GL.GL_TEXTURE0);
- dynamicTextures[CA_TEXTURE_FORCE_TARGET].bind();
- gl.glMatrixMode(GL.GL_MODELVIEW);
- gl.glPushMatrix();
-
- gl.glTranslatef(-0.5f, -0.5f, 0);
- gl.glScalef(0.5f, 0.5f, 1);
- gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
- gl.glPopMatrix();
-
- // lower right
- gl.glBindTexture(GL.GL_TEXTURE_2D, texVelocityOutput);
- gl.glPushMatrix();
-
- gl.glTranslatef(0.5f, -0.5f, 0);
- gl.glScalef(0.5f, 0.5f, 1);
- gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
- gl.glPopMatrix();
-
- // upper left
- dynamicTextures[CA_TEXTURE_NORMAL_MAP].bind();
- gl.glMatrixMode(GL.GL_MODELVIEW);
- gl.glPushMatrix();
-
- gl.glTranslatef(-0.5f, 0.5f, 0);
- gl.glScalef(0.5f, 0.5f, 1);
- gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
- gl.glPopMatrix();
-
- // upper right
- gl.glBindTexture(GL.GL_TEXTURE_2D, texHeightOutput);
- gl.glMatrixMode(GL.GL_MODELVIEW);
- gl.glPushMatrix();
-
- gl.glTranslatef(0.5f, 0.5f, 0);
- gl.glScalef(0.5f, 0.5f, 1);
- gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
- gl.glPopMatrix();
-
- break;
- }
- }
- } else {
- // skip rendering this frame
- skipCount++;
- }
- }
-
- public void singleStep() { singleStep = true; }
- public void enableAnimation(boolean enable) { animate = enable; }
- public void enableSlowAnimation(boolean enable) { slow = enable; }
- public void reset() { reset = true; }
- public void setRenderMode(int mode) { renderMode = mode; }
-
- public void enableWireframe(boolean enable) { wireframe = enable; }
- public void enableBorderWrapping(boolean enable) { wrap = enable; }
-
- public void enableBoundaryApplication(boolean enable) { applyInteriorBoundaries = enable; }
- public void enableSpinningLogo(boolean enable) { spinLogo = enable; }
-
- public void setBlurDistance(float distance) { blurDist = distance;
- mustUpdateBlurOffsets = true; }
- public float getBlurDistance() { return blurDist; }
-
- public void setBumpScale(float scale) { bumpScale = scale; }
- public float getBumpScale() { return bumpScale; }
-
- public void setDropFrequency(float frequency) { dropletFrequency = frequency; }
- public float getDropFrequency() { return dropletFrequency; }
-
- public static class Droplet {
- private float rX;
- private float rY;
- private float rScale;
-
- Droplet(float rX, float rY, float rScale) {
- this.rX = rX;
- this.rY = rY;
- this.rScale = rScale;
- }
-
- float rX() { return rX; }
- float rY() { return rY; }
- float rScale() { return rScale; }
- }
-
- public synchronized void addDroplet(Droplet drop) {
- droplets.add(drop);
- }
-
- //----------------------------------------------------------------------
- // Internals only below this point
- //
-
- class Listener implements GLEventListener {
- public void init(GLAutoDrawable drawable) {
- GL gl = drawable.getGL();
-
- initOpenGL(gl);
- }
-
- public void display(GLAutoDrawable drawable) {
- GL gl = drawable.getGL();
- if (mustUpdateBlurOffsets) {
- updateBlurVertOffset(gl);
- mustUpdateBlurOffsets = false;
- }
-
- // Take a single step in the cellular automaton
-
- // Disable culling
- gl.glDisable(GL.GL_CULL_FACE);
-
- if (reset) {
- reset = false;
- flipState = 0;
- }
-
- if (animate) {
- // Update the textures for one step of the simulation
- doSingleTimeStep(gl);
- } else if (singleStep) {
- doSingleTimeStep(gl);
- singleStep = false;
- }
-
- // Force rendering to pbuffer to complete
- gl.glFlush();
-
- if (slow && (slowDelay > 0) ) {
- try {
- Thread.sleep(slowDelay);
- } catch (InterruptedException e) {
- }
- }
- }
-
- public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {}
-
- // Unused routines
- public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged) {}
- }
-
- // We need to load the initial texture file early to get the width
- // and height for the pbuffer
- private void loadInitialTexture(String initialMapFilename) {
- try {
- initialMapData = TextureIO.newTextureData(getClass().getClassLoader().getResourceAsStream(initialMapFilename),
- false,
- FileUtil.getFileSuffix(initialMapFilename));
- } catch (IOException e) {
- throw new GLException(e);
- }
- initialMapDimensions[0] = initialMapData.getWidth();
- initialMapDimensions[1] = initialMapData.getHeight();
- }
-
- private void initOpenGL(GL gl) {
- try {
- loadTextures(gl, tmpSpinFilename, tmpDropletFilename, tmpCubeMapFilenamePrefix, tmpCubeMapFilenameSuffix);
- } catch (IOException e) {
- throw new GLException(e);
- }
- tmpSpinFilename = null;
- tmpDropletFilename = null;
- tmpCubeMapFilenamePrefix = null;
- tmpCubeMapFilenameSuffix = null;
-
- gl.glMatrixMode(GL.GL_MODELVIEW);
- gl.glLoadIdentity();
- gl.glMatrixMode(GL.GL_PROJECTION);
- gl.glLoadIdentity();
- glu.gluOrtho2D(-1, 1, -1, 1);
-
- gl.glClearColor(0, 0, 0, 0);
- gl.glDisable(GL.GL_LIGHTING);
- gl.glDisable(GL.GL_DEPTH_TEST);
-
- createAndWriteUVOffsets(gl, initialMapDimensions[0], initialMapDimensions[1]);
-
- checkExtension(gl, "GL_ARB_vertex_program");
- checkExtension(gl, "GL_ARB_fragment_program");
- checkExtension(gl, "GL_ARB_multitexture");
-
- ///////////////////////////////////////////////////////////////////////////
- // UV Offset Vertex Program
- ///////////////////////////////////////////////////////////////////////////
-
- int[] tmpInt = new int[1];
- gl.glGenProgramsARB(1, tmpInt, 0);
- vertexProgramID = tmpInt[0];
- gl.glBindProgramARB(GL.GL_VERTEX_PROGRAM_ARB, vertexProgramID);
-
- String programBuffer =
-"!!ARBvp1.0\n" +
-"# Constant memory location declarations (must match those in Java sources)\n" +
-"# CV_UV_OFFSET_TO_USE = 0\n" +
-"\n" +
-"# CV_UV_T0_NO_OFFSET = 1\n" +
-"# CV_UV_T0_TYPE1 = 2\n" +
-"# CV_UV_T0_TYPE2 = 3\n" +
-"# CV_UV_T0_TYPE3 = 4\n" +
-"# CV_UV_T0_TYPE4 = 5\n" +
-"\n" +
-"# CV_UV_T1_NO_OFFSET = 6\n" +
-"# CV_UV_T1_TYPE1 = 7\n" +
-"# CV_UV_T1_TYPE2 = 8\n" +
-"# CV_UV_T1_TYPE3 = 9\n" +
-"# CV_UV_T1_TYPE4 = 10\n" +
-"\n" +
-"# CV_UV_T2_NO_OFFSET = 11\n" +
-"# CV_UV_T2_TYPE1 = 12\n" +
-"# CV_UV_T2_TYPE2 = 13\n" +
-"# CV_UV_T2_TYPE3 = 14\n" +
-"# CV_UV_T2_TYPE4 = 15\n" +
-"\n" +
-"# CV_UV_T3_NO_OFFSET = 16\n" +
-"# CV_UV_T3_TYPE1 = 17\n" +
-"# CV_UV_T3_TYPE2 = 18\n" +
-"# CV_UV_T3_TYPE3 = 19\n" +
-"# CV_UV_T3_TYPE4 = 20\n" +
-"\n" +
-"# CV_CONSTS_1 = 21\n" +
-"\n" +
-"# Parameters\n" +
-"PARAM mvp [4] = { state.matrix.mvp }; # modelview projection matrix\n" +
-"PARAM uvOffsetToUse = program.env[0];\n" +
-"PARAM uvOffsets[20] = { program.env[1..20] };\n" +
-"\n" +
-"# Addresses\n" +
-"ADDRESS addr;\n" +
-"\n" +
-"# Per vertex inputs\n" +
-"ATTRIB iPos = vertex.position; #position\n" +
-"\n" +
-"# Outputs\n" +
-"OUTPUT oPos = result.position; #position\n" +
-"\n" +
-"# Transform vertex-position to clip-space\n" +
-"DP4 oPos.x, iPos, mvp[0];\n" +
-"DP4 oPos.y, iPos, mvp[1];\n" +
-"DP4 oPos.z, iPos, mvp[2];\n" +
-"DP4 oPos.w, iPos, mvp[3];\n" +
-"\n" +
-"# Read which set of offsets to use\n" +
-"ARL addr.x, uvOffsetToUse.x;\n" +
-"\n" +
-"# c[CV_CONSTS_1] = c[28]\n" +
-"# x = 0\n" +
-"# y = 0.5\n" +
-"# z = 1\n" +
-"# w = 2.0f\n" +
-"\n" +
-"# Put a scale factor into r0 so the sample points\n" +
-"# can be moved farther from the texel being written\n" +
-"# MOV R0, c[28].z;\n" +
-"\n" +
-"# Add the offsets to the input texture\n" +
-"# coordinate, creating 4 sets of independent\n" +
-"# texture coordinates.\n" +
-"ADD result.texcoord[0], uvOffsets[addr.x ], vertex.texcoord[0];\n" +
-"ADD result.texcoord[1], uvOffsets[addr.x + 5 ], vertex.texcoord[0];\n" +
-"ADD result.texcoord[2], uvOffsets[addr.x + 10], vertex.texcoord[0];\n" +
-"ADD result.texcoord[3], uvOffsets[addr.x + 15], vertex.texcoord[0];\n" +
-"\n" +
-"END\n";
-
- // set up constants (not currently used in the vertex program, though)
- float[] rCVConsts = new float[] { 0, 0.5f, 1.0f, 2.0f };
- gl.glProgramEnvParameter4fvARB(GL.GL_VERTEX_PROGRAM_ARB, CV_CONSTS_1, rCVConsts, 0);
-
- loadProgram(gl, GL.GL_VERTEX_PROGRAM_ARB, programBuffer);
-
- ///////////////////////////////////////////////////////////////////////////
- // fragment program setup for equal weight combination of texels
- ///////////////////////////////////////////////////////////////////////////
- displayListIDs[CA_FRAGMENT_PROGRAM_EQ_WEIGHT_COMBINE] = gl.glGenLists(1);
- initEqWeightCombine_PostMult(gl, displayListIDs[CA_FRAGMENT_PROGRAM_EQ_WEIGHT_COMBINE]);
-
- ///////////////////////////////////////////////////////////////////////////
- // fragment program setup for computing force from neighbors (step 1)
- ///////////////////////////////////////////////////////////////////////////
- displayListIDs[CA_FRAGMENT_PROGRAM_NEIGHBOR_FORCE_CALC_1] = gl.glGenLists(1);
- initNeighborForceCalcStep1(gl, displayListIDs[CA_FRAGMENT_PROGRAM_NEIGHBOR_FORCE_CALC_1]);
-
- ///////////////////////////////////////////////////////////////////////////
- // fragment program setup for computing force from neighbors (step 2)
- ///////////////////////////////////////////////////////////////////////////
- displayListIDs[CA_FRAGMENT_PROGRAM_NEIGHBOR_FORCE_CALC_2] = gl.glGenLists(1);
- initNeighborForceCalcStep2(gl, displayListIDs[CA_FRAGMENT_PROGRAM_NEIGHBOR_FORCE_CALC_2]);
-
- ///////////////////////////////////////////////////////////////////////////
- // fragment program setup to apply force
- ///////////////////////////////////////////////////////////////////////////
- displayListIDs[CA_FRAGMENT_PROGRAM_APPLY_FORCE] = gl.glGenLists(1);
- initApplyForce(gl, displayListIDs[CA_FRAGMENT_PROGRAM_APPLY_FORCE]);
-
- ///////////////////////////////////////////////////////////////////////////
- // fragment program setup to apply velocity
- ///////////////////////////////////////////////////////////////////////////
- displayListIDs[CA_FRAGMENT_PROGRAM_APPLY_VELOCITY] = gl.glGenLists(1);
- initApplyVelocity(gl, displayListIDs[CA_FRAGMENT_PROGRAM_APPLY_VELOCITY]);
-
- ///////////////////////////////////////////////////////////////////////////
- // fragment program setup to create a normal map
- ///////////////////////////////////////////////////////////////////////////
- displayListIDs[CA_FRAGMENT_PROGRAM_CREATE_NORMAL_MAP] = gl.glGenLists(1);
- initCreateNormalMap(gl, displayListIDs[CA_FRAGMENT_PROGRAM_CREATE_NORMAL_MAP]);
-
- ///////////////////////////////////////////////////////////////////////////
- // fragment program setup for dot product reflection
- ///////////////////////////////////////////////////////////////////////////
- displayListIDs[CA_FRAGMENT_PROGRAM_REFLECT] = gl.glGenLists(1);
- initDotProductReflect(gl, displayListIDs[CA_FRAGMENT_PROGRAM_REFLECT]);
-
- ///////////////////////////////////////////////////////////////////////////
- // display list to render a single screen space quad.
- ///////////////////////////////////////////////////////////////////////////
- displayListIDs[CA_DRAW_SCREEN_QUAD] = gl.glGenLists(1);
- gl.glNewList(displayListIDs[CA_DRAW_SCREEN_QUAD], GL.GL_COMPILE);
- gl.glColor4f(1, 1, 1, 1);
- gl.glBegin(GL.GL_TRIANGLE_STRIP);
- gl.glTexCoord2f(0, 1); gl.glVertex2f(-1, 1);
- gl.glTexCoord2f(0, 0); gl.glVertex2f(-1, -1);
- gl.glTexCoord2f(1, 1); gl.glVertex2f( 1, 1);
- gl.glTexCoord2f(1, 0); gl.glVertex2f( 1, -1);
- gl.glEnd();
- gl.glEndList();
- }
-
- private void checkExtension(GL gl, String extensionName) {
- if (!gl.isExtensionAvailable(extensionName)) {
- throw new GLException("Unable to initialize " + extensionName + " OpenGL extension");
- }
- }
-
- private void doSingleTimeStep(GL gl) {
- int temp;
-
- // Swap texture source & target indices & pointers
- // 0 = start from initial loaded texture
- // 1/2 = flip flop back and forth between targets & sources
-
- switch (flipState) {
- case 0:
- texHeightInput = dynamicTextures[CA_TEXTURE_HEIGHT_SOURCE].getTextureObject(); // initial height map.
- texHeightOutput = dynamicTextures[CA_TEXTURE_HEIGHT_TARGET].getTextureObject(); // next height map.
-
- texVelocityInput = dynamicTextures[CA_TEXTURE_VELOCITY_SOURCE].getTextureObject(); // initial velocity.
- texVelocityOutput = dynamicTextures[CA_TEXTURE_VELOCITY_TARGET].getTextureObject(); // next velocity.
-
- // Clear initial velocity texture to 0x80 == gray
- gl.glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
- gl.glClear(GL.GL_COLOR_BUFFER_BIT);
-
- // Now we need to copy the resulting pixels into the intermediate force field texture
- gl.glActiveTexture(GL.GL_TEXTURE0);
- gl.glBindTexture(GL.GL_TEXTURE_2D, texVelocityInput);
-
- // use CopyTexSubImage for speed (even though we copy all of it) since we pre-allocated the texture
- gl.glCopyTexSubImage2D(GL.GL_TEXTURE_2D, 0, 0, 0, 0, 0, initialMapDimensions[0], initialMapDimensions[1]);
-
- break;
-
- case 1:
- temp = texHeightInput;
- texHeightInput = texHeightOutput;
- texHeightOutput = temp;
-
- temp = texVelocityInput;
- texVelocityInput = texVelocityOutput;
- texVelocityOutput = temp;
-
- break;
-
- case 2:
- temp = texHeightInput;
- texHeightInput = texHeightOutput;
- texHeightOutput = temp;
-
- temp = texVelocityInput;
- texVelocityInput = texVelocityOutput;
- texVelocityOutput = temp;
- break;
- }
-
- // even if wireframe mode, render to texture as solid
- gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_FILL);
-
- /////////////////////////////////////////////////////////////
- // Render first 3 components of force from three neighbors
- // Offsets selected are 1 center texel for center height
- // and 3 of the 4 nearest neighbors. Texture selected
- // is same for all stages as we're turning height difference
- // of nearest neightbor texels into a force value.
-
- gl.glCallList(displayListIDs[CA_FRAGMENT_PROGRAM_NEIGHBOR_FORCE_CALC_1]);
-
- // set current source texture for stage 0 texture
- for (int i = 0; i < 4; i++)
- {
- gl.glActiveTexture(GL.GL_TEXTURE0 + i);
- gl.glBindTexture(GL.GL_TEXTURE_2D, texHeightInput);
- gl.glEnable(GL.GL_TEXTURE_2D);
- }
-
- int wrapMode = wrap ? GL.GL_REPEAT : GL.GL_CLAMP_TO_EDGE;
- gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, wrapMode);
- gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, wrapMode);
-
- // disable blending
- gl.glDisable(GL.GL_BLEND);
-
- // render using offset 1 (type 1 -- center + 3 of 4 nearest neighbors).
- gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, CV_UV_OFFSET_TO_USE, 1, 0, 0, 0);
-
- // bind the vertex program to be used for this step and the next one.
- gl.glBindProgramARB(GL.GL_VERTEX_PROGRAM_ARB, vertexProgramID);
- gl.glEnable(GL.GL_VERTEX_PROGRAM_ARB);
-
- // render a screen quad. with texture coords doing difference of nearby texels for force calc.
- gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
-
- gl.glDisable(GL.GL_FRAGMENT_PROGRAM_ARB);
-
- // Now we need to copy the resulting pixels into the intermediate force field texture
- gl.glActiveTexture(GL.GL_TEXTURE2);
- dynamicTextures[CA_TEXTURE_FORCE_INTERMEDIATE].bind();
-
- // use CopyTexSubImage for speed (even though we copy all of it) since we pre-allocated the texture
- gl.glCopyTexSubImage2D(GL.GL_TEXTURE_2D, 0, 0, 0, 0, 0, initialMapDimensions[0], initialMapDimensions[1]);
-
- ////////////////////////////////////////////////////////////////
- // Now add in last component of force for the 4th neighbor
- // that we didn't have enough texture lookups to do in the
- // first pass
-
- gl.glCallList(displayListIDs[CA_FRAGMENT_PROGRAM_NEIGHBOR_FORCE_CALC_2]);
-
- // Cannot use additive blending as the force contribution might
- // be negative and would have to subtract from the dest.
- // We must instead use an additional texture as target and read
- // the previous partial 3-neighbor result into the pixel shader
- // for possible subtraction
-
- // Alphablend must be false
-
- //; t0 = center (same as last phase)
- //; t1 = 2nd axis final point (same as last phase)
- //; t2 = previous partial result texture sampled at center (result of last phase copied to texture)
- //; t3 = not used (disable now)
-
- gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, wrapMode);
- gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, wrapMode);
-
- gl.glActiveTexture(GL.GL_TEXTURE3);
- gl.glDisable(GL.GL_TEXTURE_2D);
-
- // vertex program already bound.
- // render using offset 2 (type 2 -- final nearest neighbor plus center of previous result).
- gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, CV_UV_OFFSET_TO_USE, 2, 0, 0, 0);
-
- // render a screen quad
- gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
-
- gl.glDisable(GL.GL_FRAGMENT_PROGRAM_ARB);
-
- // Now we need to copy the resulting pixels into the intermediate force field texture
- gl.glActiveTexture(GL.GL_TEXTURE1);
- dynamicTextures[CA_TEXTURE_FORCE_TARGET].bind();
-
- // use CopyTexSubImage for speed (even though we copy all of it) since we pre-allocated the texture
- gl.glCopyTexSubImage2D(GL.GL_TEXTURE_2D, 0, 0, 0, 0, 0, initialMapDimensions[0], initialMapDimensions[1]);
-
- /////////////////////////////////////////////////////////////////
- // Apply the force with a scale factor to reduce it's magnitude.
- // Add this to the current texture representing the water height.
-
- gl.glCallList(displayListIDs[CA_FRAGMENT_PROGRAM_APPLY_FORCE]);
-
- // use offsets of zero
- gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, CV_UV_OFFSET_TO_USE, 0, 0, 0, 0);
-
- // bind the vertex program to be used for this step and the next one.
-
- gl.glActiveTexture(GL.GL_TEXTURE0);
- gl.glBindTexture(GL.GL_TEXTURE_2D, texVelocityInput);
- gl.glActiveTexture(GL.GL_TEXTURE1);
- dynamicTextures[CA_TEXTURE_FORCE_TARGET].bind();
- gl.glActiveTexture(GL.GL_TEXTURE2);
- gl.glDisable(GL.GL_TEXTURE_2D);
- gl.glActiveTexture(GL.GL_TEXTURE3);
- gl.glDisable(GL.GL_TEXTURE_2D);
-
- // Draw the quad to add in force.
- gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
-
- gl.glDisable(GL.GL_FRAGMENT_PROGRAM_ARB);
-
- ///////////////////////////////////////////////////////////////////
- // With velocity texture selected, render new excitation droplets
- // at random freq.
-
- float randomFrequency = (float) Math.random();
-
- if (dropletFrequency > randomFrequency) {
- // a drop falls - decide where
- Droplet drop = new Droplet(2 * ((float)Math.random() - 0.5f),
- 2 * ((float)Math.random() - 0.5f),
- 0.02f + 0.1f * ((float)Math.random()));
- addDroplet(drop);
- }
-
- // Now draw the droplets:
- if (!droplets.isEmpty()) {
- drawDroplets(gl);
- droplets.clear();
- }
-
- // Now we need to copy the resulting pixels into the velocity texture
- gl.glActiveTexture(GL.GL_TEXTURE1);
- gl.glBindTexture(GL.GL_TEXTURE_2D, texVelocityOutput);
-
- // use CopyTexSubImage for speed (even though we copy all of it) since we pre-allocated the texture
- gl.glCopyTexSubImage2D(GL.GL_TEXTURE_2D, 0, 0, 0, 0, 0, initialMapDimensions[0], initialMapDimensions[1]);
-
- //////////////////////////////////////////////////////////////////////
- // Apply velocity to position
- gl.glCallList(displayListIDs[CA_FRAGMENT_PROGRAM_APPLY_VELOCITY]);
- gl.glEnable(GL.GL_VERTEX_PROGRAM_ARB);
-
- gl.glActiveTexture(GL.GL_TEXTURE0);
- gl.glBindTexture(GL.GL_TEXTURE_2D, texHeightInput);
- gl.glActiveTexture(GL.GL_TEXTURE1); // velocity output already bound
- gl.glEnable(GL.GL_TEXTURE_2D);
-
- // use offsets of zero
- gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, CV_UV_OFFSET_TO_USE, 0, 0, 0, 0);
-
- // Draw the quad to add in force.
- gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
-
- gl.glDisable(GL.GL_FRAGMENT_PROGRAM_ARB);
-
- // Now we need to copy the resulting pixels into the input height texture
- gl.glActiveTexture(GL.GL_TEXTURE0);
- gl.glBindTexture(GL.GL_TEXTURE_2D, texHeightInput);
-
- // use CopyTexSubImage for speed (even though we copy all of it) since we pre-allocated the texture
- gl.glCopyTexSubImage2D(GL.GL_TEXTURE_2D, 0, 0, 0, 0, 0, initialMapDimensions[0], initialMapDimensions[1]);
-
- ///////////////////////////////////////////////////////////////////
- // blur positions to smooth noise & generaly dampen things
- // degree of blur is controlled by magnitude of 4 neighbor texel
- // offsets with bilinear on
-
- for (int i = 1; i < 4; i++) {
- gl.glActiveTexture(GL.GL_TEXTURE0 + i);
- gl.glBindTexture(GL.GL_TEXTURE_2D, texHeightInput);
- gl.glEnable(GL.GL_TEXTURE_2D);
- }
-
- // use offsets of 3
- gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, CV_UV_OFFSET_TO_USE, 3, 0, 0, 0);
-
- gl.glCallList(displayListIDs[CA_FRAGMENT_PROGRAM_EQ_WEIGHT_COMBINE]);
-
- gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
- gl.glDisable(GL.GL_FRAGMENT_PROGRAM_ARB);
-
- // Draw the logo in the water.
- if (applyInteriorBoundaries) {
- gl.glDisable(GL.GL_VERTEX_PROGRAM_ARB);
- drawInteriorBoundaryObjects(gl);
- }
-
- // Now we need to copy the resulting pixels into the velocity texture
- gl.glActiveTexture(GL.GL_TEXTURE0);
- gl.glBindTexture(GL.GL_TEXTURE_2D, texHeightOutput);
-
- // use CopyTexSubImage for speed (even though we copy all of it) since we pre-allocated the texture
- gl.glCopyTexSubImage2D(GL.GL_TEXTURE_2D, 0, 0, 0, 0, 0, initialMapDimensions[0], initialMapDimensions[1]);
-
- ///////////////////////////////////////////////////////////////////
- // If selected, create a normal map from the height
-
- if (createNormalMap) {
- createNormalMap(gl);
- }
-
- ///////////////////////////////////////////////////////////
- // Flip the state variable for the next round of rendering
- switch (flipState) {
- case 0:
- flipState = 1;
- break;
- case 1:
- flipState = 2;
- break;
- case 2:
- flipState = 1;
- break;
- }
- }
-
- private void createNormalMap(GL gl) {
- // use the height output on all four texture stages
- for (int i = 0; i < 4; i++) {
- gl.glActiveTexture(GL.GL_TEXTURE0 + i);
- gl.glBindTexture(GL.GL_TEXTURE_2D, texHeightOutput);
- gl.glEnable(GL.GL_TEXTURE_2D);
- }
-
- // Set constants for red & green scale factors (also essential color masks)
- // Red mask first
- float[] pixMasks = new float[] { normalSTScale, 0.0f, 0.0f, 0.0f };
-
- gl.glProgramEnvParameter4fvARB(GL.GL_FRAGMENT_PROGRAM_ARB, 0, pixMasks, 0);
-
- // Now green mask & scale:
- pixMasks[0] = 0.0f;
- pixMasks[1] = normalSTScale;
- gl.glProgramEnvParameter4fvARB(GL.GL_FRAGMENT_PROGRAM_ARB, 1, pixMasks, 0);
-
- gl.glCallList(displayListIDs[CA_FRAGMENT_PROGRAM_CREATE_NORMAL_MAP]);
-
- // set vp offsets to nearest neighbors
- gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, CV_UV_OFFSET_TO_USE, 4, 0, 0, 0);
- gl.glEnable(GL.GL_VERTEX_PROGRAM_ARB);
-
- gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
-
- gl.glDisable(GL.GL_FRAGMENT_PROGRAM_ARB);
-
- // Now we need to copy the resulting pixels into the normal map
- gl.glActiveTexture(GL.GL_TEXTURE0);
- dynamicTextures[CA_TEXTURE_NORMAL_MAP].bind();
-
- // use CopyTexSubImage for speed (even though we copy all of it) since we pre-allocated the texture
- gl.glCopyTexSubImage2D(GL.GL_TEXTURE_2D, 0, 0, 0, 0, 0, initialMapDimensions[0], initialMapDimensions[1]);
- }
-
- private void drawInteriorBoundaryObjects(GL gl) {
- gl.glDisable(GL.GL_REGISTER_COMBINERS_NV);
-
- gl.glActiveTexture(GL.GL_TEXTURE0);
- initialMapTex.bind();
- initialMapTex.enable();
-
- gl.glEnable(GL.GL_ALPHA_TEST);
-
- // disable other texture units.
- for (int i = 1; i < 4; i++) {
- gl.glActiveTexture(GL.GL_TEXTURE0 + i);
- gl.glDisable(GL.GL_TEXTURE_2D);
- }
-
- gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
- gl.glEnable(GL.GL_BLEND);
-
- gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
-
- if (spinLogo) {
- gl.glActiveTexture(GL.GL_TEXTURE0);
- spinTex.bind();
- gl.glMatrixMode(GL.GL_MODELVIEW);
- gl.glPushMatrix();
- gl.glRotatef(angle, 0, 0, 1);
- angle += 1;
-
- gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
-
- gl.glPopMatrix();
- }
-
- gl.glDisable(GL.GL_ALPHA_TEST);
- gl.glDisable(GL.GL_BLEND);
- }
-
- private void loadTextures(GL gl,
- String spinFilename,
- String dropletFilename,
- String cubeMapFilenamePrefix,
- String cubeMapFilenameSuffix) throws IOException {
- if (initialMapData == null) {
- throw new GLException("Must call loadInitialTexture ahead of time");
- }
-
- initialMapTex = TextureIO.newTexture(initialMapData);
- spinTex = TextureIO.newTexture(getClass().getClassLoader().getResourceAsStream(spinFilename), false,
- FileUtil.getFileSuffix(spinFilename));
- dropletTex = TextureIO.newTexture(getClass().getClassLoader().getResourceAsStream(dropletFilename), false,
- FileUtil.getFileSuffix(dropletFilename));
-
- // load the cubemap texture
- cubemap = Cubemap.loadFromStreams(getClass().getClassLoader(),
- cubeMapFilenamePrefix,
- cubeMapFilenameSuffix,
- true);
-
- // now create dummy intermediate textures from the initial map texture
- for (int i = 0; i < CA_NUM_DYNAMIC_TEXTURES; i++) {
- dynamicTextures[i] = TextureIO.newTexture(initialMapData);
- }
-
- initialMapData = null;
-
- texHeightInput = initialMapTex.getTextureObject(); // initial height map.
- texHeightOutput = dynamicTextures[CA_TEXTURE_HEIGHT_TARGET].getTextureObject(); // next height map.
-
- texVelocityInput = dynamicTextures[CA_TEXTURE_VELOCITY_SOURCE].getTextureObject(); // initial velocity.
- texVelocityOutput = dynamicTextures[CA_TEXTURE_VELOCITY_TARGET].getTextureObject(); // next velocity.
- }
-
- private void createAndWriteUVOffsets(GL gl, int width, int height) {
- // This sets vertex shader constants used to displace the
- // source texture over several additive samples. This is
- // used to accumulate neighboring texel information that we
- // need to run the game - the 8 surrounding texels, and the
- // single source texel which will either spawn or die in the
- // next generation.
- // Label the texels as follows, for a source texel "e" that
- // we want to compute for the next generation:
- //
- // abc
- // def
- // ghi:
-
- // first the easy one: no offsets for sampling center
- // occupied or unoccupied
- // Use index offset value 0.0 to access these in the
- // vertex shader.
-
- perTexelWidth = 1.0f / width;
- perTexelHeight = 1.0f / height;
-
- // Offset set 0 : center texel sampling
- float[] noOffsetX = new float[] { 0, 0, 0, 0 };
- float[] noOffsetY = new float[] { 0, 0, 0, 0 };
-
- // Offset set 1: For use with neighbor force pixel shader 1
- // samples center with 0, +u, -u, and +v,
- // ie the 'e','d', 'f', and 'h' texels
- float dist = 1.5f;
- float[] type1OffsetX = new float[] { 0.0f, -dist * perTexelWidth, dist * perTexelWidth, dist * perTexelWidth };
- float[] type1OffsetY = new float[] { 0.0f, dist * perTexelHeight, dist * perTexelHeight, -dist * perTexelHeight };
-
- // Offset set 2: for use with neighbor force pixel shader 2
- // samples center with 0, and -v texels
- // ie the 'e' and 'b' texels
- // This completes a pattern of sampling center texel and it's
- // 4 nearest neighbors to run the height-based water simulation
- // 3rd must be 0 0 to sample texel center from partial result
- // texture.
-
- float[] type2OffsetX = new float[] { 0.0f, -dist * perTexelWidth, 0.0f, 0.0f };
- float[] type2OffsetY = new float[] { 0.0f, -dist * perTexelHeight, 0.0f, 0.0f };
-
- // type 3 offsets
- updateBlurVertOffset(gl);
-
- /////////////////////////////////////////////////////////////
- // Nearest neighbor offsets:
-
- float[] type4OffsetX = new float[] { -perTexelWidth, perTexelWidth, 0.0f, 0.0f };
- float[] type4OffsetY = new float[] { 0.0f, 0.0f, -perTexelHeight, perTexelHeight };
-
- // write all these offsets to constant memory
- for (int i = 0; i < 4; ++i) {
- float noOffset[] = { noOffsetX[i], noOffsetY[i], 0.0f, 0.0f };
- float type1Offset[] = { type1OffsetX[i], type1OffsetY[i], 0.0f, 0.0f };
- float type2Offset[] = { type2OffsetX[i], type2OffsetY[i], 0.0f, 0.0f };
- float type4Offset[] = { type4OffsetX[i], type4OffsetY[i], 0.0f, 0.0f };
-
- gl.glProgramEnvParameter4fvARB(GL.GL_VERTEX_PROGRAM_ARB, CV_UV_T0_NO_OFFSET + 5 * i, noOffset, 0);
- gl.glProgramEnvParameter4fvARB(GL.GL_VERTEX_PROGRAM_ARB, CV_UV_T0_TYPE1 + 5 * i, type1Offset, 0);
- gl.glProgramEnvParameter4fvARB(GL.GL_VERTEX_PROGRAM_ARB, CV_UV_T0_TYPE2 + 5 * i, type2Offset, 0);
- gl.glProgramEnvParameter4fvARB(GL.GL_VERTEX_PROGRAM_ARB, CV_UV_T0_TYPE4 + 5 * i, type4Offset, 0);
- }
- }
-
- private void updateBlurVertOffset(GL gl) {
- float[] type3OffsetX = new float[] { -perTexelWidth * 0.5f,
- perTexelWidth,
- perTexelWidth * 0.5f,
- -perTexelWidth
- };
- float[] type3OffsetY = new float[] { perTexelHeight,
- perTexelHeight * 0.5f,
- -perTexelHeight,
- -perTexelHeight * 0.5f
- };
- float[] offsets = new float[] { 0, 0, 0, 0 };
-
- for (int i = 0; i < 4; ++i) {
- offsets[0] = blurDist * ( type3OffsetX[i]);
- offsets[1] = blurDist * ( type3OffsetY[i]);
- gl.glProgramEnvParameter4fvARB(GL.GL_VERTEX_PROGRAM_ARB, CV_UV_T0_TYPE3 + 5 * i, offsets, 0);
- }
- }
-
- private synchronized void drawDroplets(GL gl) {
- gl.glDisable(GL.GL_FRAGMENT_PROGRAM_ARB);
- gl.glDisable(GL.GL_VERTEX_PROGRAM_ARB);
-
- gl.glActiveTexture(GL.GL_TEXTURE0);
- dropletTex.bind();
- dropletTex.enable();
-
- gl.glActiveTexture(GL.GL_TEXTURE1);
- gl.glDisable(GL.GL_TEXTURE_2D);
-
- gl.glBlendFunc(GL.GL_ONE, GL.GL_ONE);
- gl.glEnable(GL.GL_BLEND);
-
- gl.glBegin(GL.GL_QUADS);
- gl.glColor4f(1, 1, 1, 1);
- for (Iterator iter = droplets.iterator(); iter.hasNext(); ) {
- Droplet droplet = (Droplet) iter.next();
- // coords in [-1,1] range
-
- // Draw a single quad to the texture render target
- // The quad is textured with the initial droplet texture, and
- // covers some small portion of the render target
- // Draw the droplet
-
- gl.glTexCoord2f(0, 0); gl.glVertex2f(droplet.rX() - droplet.rScale(), droplet.rY() - droplet.rScale());
- gl.glTexCoord2f(1, 0); gl.glVertex2f(droplet.rX() + droplet.rScale(), droplet.rY() - droplet.rScale());
- gl.glTexCoord2f(1, 1); gl.glVertex2f(droplet.rX() + droplet.rScale(), droplet.rY() + droplet.rScale());
- gl.glTexCoord2f(0, 1); gl.glVertex2f(droplet.rX() - droplet.rScale(), droplet.rY() + droplet.rScale());
- }
- gl.glEnd();
-
- gl.glDisable(GL.GL_BLEND);
- }
-
- //----------------------------------------------------------------------
- // Inlined register combiner and texture shader programs
- // (don't want to port nvparse as it's a dead-end; we'll focus on Cg instead)
-
- private void initEqWeightCombine_PostMult(GL gl, int displayListID) {
- // Take samples of all four texture inputs and average them,
- // adding on a bias
- //
- // Original register combiner program:
- //
- // Stage 0
- // rgb
- // {
- // discard = half_bias(tex0);
- // discard = half_bias(tex1);
- // spare0 = sum();
- // scale_by_one_half();
- // }
- // Stage 1
- // rgb
- // {
- // discard = half_bias(tex2);
- // discard = half_bias(tex3);
- // spare1 = sum();
- // scale_by_one_half();
- // }
- // Stage 2
- // rgb
- // {
- // discard = spare0;
- // discard = spare1;
- // spare0 = sum();
- // scale_by_one_half();
- // }
- // Stage 3
- // rgb
- // {
- // discard = const0;
- // discard = spare0;
- // spare0 = sum();
- // }
-
- float[] const0 = new float[] { 0.5f, 0.5f, 0.5f, 1.0f };
-
- int[] tmpInt = new int[1];
- gl.glGenProgramsARB(1, tmpInt, 0);
- int fragProg = tmpInt[0];
- gl.glBindProgramARB(GL.GL_FRAGMENT_PROGRAM_ARB, fragProg);
-
- String program =
-"!!ARBfp1.0\n" +
-"PARAM const0 = program.env[0];\n" +
-"PARAM oneQtr = { 0.25, 0.25, 0.25, 0.25 };\n" +
-"PARAM two = { 2.0, 2.0, 2.0, 2.0 };\n" +
-"TEMP texSamp0, texSamp1, texSamp2, texSamp3;\n" +
-"TEMP spare0, spare1;\n" +
-"\n" +
-"TEX texSamp0, fragment.texcoord[0], texture[0], 2D;\n" +
-"TEX texSamp1, fragment.texcoord[1], texture[1], 2D;\n" +
-"TEX texSamp2, fragment.texcoord[2], texture[2], 2D;\n" +
-"TEX texSamp3, fragment.texcoord[3], texture[3], 2D;\n" +
-"ADD spare0, texSamp0, texSamp1;\n" +
-"ADD spare1, texSamp2, texSamp3;\n" +
-"ADD spare0, spare0, spare1;\n" +
-"SUB spare0, spare0, two;\n" +
-"MAD result.color, oneQtr, spare0, const0;\n" +
-"\n" +
-"END\n";
-
- loadProgram(gl, GL.GL_FRAGMENT_PROGRAM_ARB, program);
-
- gl.glNewList(displayListID, GL.GL_COMPILE);
- gl.glProgramEnvParameter4fvARB(GL.GL_FRAGMENT_PROGRAM_ARB, 0, const0, 0);
- gl.glBindProgramARB(GL.GL_FRAGMENT_PROGRAM_ARB, fragProg);
- gl.glEnable(GL.GL_FRAGMENT_PROGRAM_ARB);
- gl.glEndList();
- }
-
- private void initNeighborForceCalcStep1(GL gl, int displayListID) {
- // Step one in the nearest-neighbor force calculation for height-based water
- // simulation. NeighborForceCalc2 is the second step.
- //
- // This step takes the center point and three neighboring points, and computes
- // the texel difference as the "force" acting to pull the center texel.
- //
- // The amount to which the computed force is applied to the texel is controlled
- // in a separate shader.
-
- // get colors from all 4 texture stages
- // tex0 = center texel
- // tex1 = 1st neighbor
- // tex2 = 2nd neighbor - same axis as 1st neighbor point
- // so force for that axis == t1 - t0 + t2 - t0
- // tex3 = 3rd neighbor on other axis
-
- // Original register combiner program:
- //
- // Stage 0
- // rgb
- // {
- // //s0 = t1 - t0;
- // discard = -tex0;
- // discard = tex1;
- // spare0 = sum();
- // }
- // Stage 1
- // rgb
- // {
- // //s1 = t2 - t0;
- // discard = -tex0;
- // discard = tex2;
- // spare1 = sum();
- // }
- // Stage 2
- // // 'force' for 1st axis
- // rgb
- // {
- // //s0 = s0 + s1 = t1 - t0 + t2 - t0;
- // discard = spare0;
- // discard = spare1;
- // spare0 = sum();
- // }
- // Stage 3
- // // one more point for 2nd axis
- // rgb
- // {
- // //s1 = t3 - t0;
- // discard = -tex0;
- // discard = tex3;
- // spare1 = sum();
- // }
- // Stage 4
- // rgb
- // {
- // //s0 = s0 + s1 = t3 - t0 + t2 - t0 + t1 - t0;
- // discard = spare0;
- // discard = spare1;
- // spare0 = sum();
- // }
- // Stage 5
- // // Now add in a force to gently pull the center texel's
- // // value to 0.5. The strength of this is controlled by
- // // the PCN_EQ_REST_FAC - restoration factor
- // // Without this, the simulation will fade to zero or fly
- // // away to saturate at 1.0
- // rgb
- // {
- // //s1 = 0.5 - t0;
- // discard = -tex0;
- // discard = const0;
- // spare1 = sum();
- // }
- // Stage 6
- // {
- // rgb
- // {
- // discard = spare1 * const0;
- // discard = spare0;
- // spare0 = sum();
- // }
- // }
- // Stage 7
- // rgb
- // {
- // discard = spare0;
- // discard = const0;
- // spare0 = sum();
- // }
-
- float[] const0 = new float[] { 0.5f, 0.5f, 0.5f, 1.0f };
-
- int[] tmpInt = new int[1];
- gl.glGenProgramsARB(1, tmpInt, 0);
- int fragProg = tmpInt[0];
- gl.glBindProgramARB(GL.GL_FRAGMENT_PROGRAM_ARB, fragProg);
-
- String program =
-"!!ARBfp1.0\n" +
-"PARAM const0 = program.env[0];\n" +
-"PARAM three = { 3, 3, 3, 1.0 };\n" +
-"TEMP texSamp0, texSamp1, texSamp2, texSamp3;\n" +
-"TEMP spare0, spare1;\n" +
-"\n" +
-"TEX texSamp0, fragment.texcoord[0], texture[0], 2D;\n" +
-"TEX texSamp1, fragment.texcoord[1], texture[1], 2D;\n" +
-"TEX texSamp2, fragment.texcoord[2], texture[2], 2D;\n" +
-"TEX texSamp3, fragment.texcoord[3], texture[3], 2D;\n" +
-"ADD spare0, texSamp1, texSamp2;\n" +
-"MAD spare1, const0, const0, const0;\n" +
-"ADD spare0, texSamp3, spare0;\n" +
-"ADD spare0, spare1, spare0;\n" +
-"ADD spare1, three, const0;\n" +
-"MAD result.color, -spare1, texSamp0, spare0;\n" +
-
-// Faster version which hardcodes in value of const0:
-//"ADD spare0, texSamp1, texSamp2;\n" +
-//"ADD spare1, texSamp3, pointSevenFive;\n" +
-//"ADD spare0, spare0, spare1;\n" +
-//"MAD result.color, minusThreePointFive, texSamp0, spare0;\n" +
-
-// Straightforward port:
-//"SUB spare0, texSamp1, texSamp0;\n" +
-//"SUB spare1, texSamp2, texSamp0;\n" +
-//"ADD spare0, spare0, spare1;\n" +
-//"SUB spare1, texSamp3, texSamp0;\n" +
-//"ADD spare0, spare0, spare1;\n" +
-//"SUB spare1, const0, texSamp0;\n" +
-//"MAD spare0, const0, spare1, spare0;\n" +
-//"ADD result.color, spare0, const0;\n" +
-
-"\n" +
-"END\n";
-
- loadProgram(gl, GL.GL_FRAGMENT_PROGRAM_ARB, program);
-
- gl.glNewList(displayListID, GL.GL_COMPILE);
- gl.glProgramEnvParameter4fvARB(GL.GL_FRAGMENT_PROGRAM_ARB, 0, const0, 0);
- gl.glBindProgramARB(GL.GL_FRAGMENT_PROGRAM_ARB, fragProg);
- gl.glEnable(GL.GL_FRAGMENT_PROGRAM_ARB);
- gl.glEndList();
- }
-
- private void initNeighborForceCalcStep2(GL gl, int displayListID) {
- // 2nd step of force calc for render-to-texture
- // water simulation.
- //
- // Adds the 4th & final neighbor point to the
- // force calc..
- //
- // Bias and scale the values so 0 force is 0.5,
- // full negative force is 0.0, and full pos is
- // 1.0
- //
- // tex0 Center texel
- // tex1 2nd axis neighbor point
- // tex2 previous partial force amount
- // Result from t1 - t0 is added to this t2
- // partial result & output
-
- // Original register combiner program:
- //
- // Stage 0
- // last element of neighbor force
- // rgb
- // {
- // discard = -tex0;
- // discard = tex1;
- // spare0 = sum();
- // }
- // Stage 1
- // add with previous partial force amount
- // rgb
- // {
- // discard = spare0;
- // discard = tex2;
- // spare0 = sum();
- // }
-
- int[] tmpInt = new int[1];
- gl.glGenProgramsARB(1, tmpInt, 0);
- int fragProg = tmpInt[0];
- gl.glBindProgramARB(GL.GL_FRAGMENT_PROGRAM_ARB, fragProg);
-
- String program =
-"!!ARBfp1.0\n" +
-"PARAM const0 = program.env[0];\n" +
-"TEMP texSamp0, texSamp1, texSamp2;\n" +
-"TEMP spare0;\n" +
-"\n" +
-"TEX texSamp0, fragment.texcoord[0], texture[0], 2D;\n" +
-"TEX texSamp1, fragment.texcoord[1], texture[1], 2D;\n" +
-"TEX texSamp2, fragment.texcoord[2], texture[2], 2D;\n" +
-"SUB spare0, texSamp1, texSamp0;\n" +
-"ADD result.color, spare0, texSamp2;\n" +
-"\n" +
-"END\n";
-
- loadProgram(gl, GL.GL_FRAGMENT_PROGRAM_ARB, program);
-
- gl.glNewList(displayListID, GL.GL_COMPILE);
- gl.glBindProgramARB(GL.GL_FRAGMENT_PROGRAM_ARB, fragProg);
- gl.glEnable(GL.GL_FRAGMENT_PROGRAM_ARB);
- gl.glEndList();
- }
-
- private void initApplyForce(GL gl, int displayListID) {
- // This shader samples t1, biases its value to a signed number, and applies this
- // value multiplied by a scale factor to the t0 sample.
- //
- // This is used to apply a "force" texture value to a "velocity" state texture
- // for nearest-neighbor height-based water simulations. The output pixel is
- // the new "velocity" value to replace the t0 sample in rendering to a new
- // texture which will replace the texture selected into t0.
- //
- // A nearly identical shader using a different scaling constant is used to
- // apply the "velocity" value to a "height" texture at each texel.
- //
- // t1 comes in the range [0,1] but needs to hold signed values, so a value of
- // 0.5 in t1 represents zero force. This is biased to a signed value in
- // computing the new velocity.
- //
- // tex0 = previous velocity
- // tex1 = force
- //
- // Bias the force so that 0.5 input = no change in t0 value
- // and 0.0 input means -0.5 * scale change in t0 value
- //
- // New velocity = force * scale + previous velocity
-
- // Original register combiner program:
- //
- // Stage 0
- // rgb
- // {
- // discard = expand(tex1) * const0;
- // discard = expand(tex0);
- // spare0 = sum();
- // scale_by_one_half();
- // }
- // Stage 1
- // rgb
- // {
- // discard = spare0;
- // discard = const1;
- // spare0 = sum();
- // }
-
- float[] const0 = new float[] { 0.25f, 0.25f, 0.25f, 1.0f };
- float[] const1 = new float[] { 0.5f, 0.5f, 0.5f, 1.0f };
-
- int[] tmpInt = new int[1];
- gl.glGenProgramsARB(1, tmpInt, 0);
- int fragProg = tmpInt[0];
- gl.glBindProgramARB(GL.GL_FRAGMENT_PROGRAM_ARB, fragProg);
-
- String program =
-"!!ARBfp1.0\n" +
-"PARAM const0 = program.env[0];\n" +
-"PARAM const1 = program.env[1];\n" +
-"PARAM one = { 1.0, 1.0, 1.0, 0.0 };\n" +
-"PARAM oneHalf = { 0.5, 0.5, 0.5, 1.0 };\n" +
-"PARAM two = { 2.0, 2.0, 2.0, 1.0 };\n" +
-"TEMP texSamp0, texSamp1;\n" +
-"TEMP spare0, spare1;\n" +
-"\n" +
-"TEX texSamp0, fragment.texcoord[0], texture[0], 2D;\n" +
-"TEX texSamp1, fragment.texcoord[1], texture[1], 2D;\n" +
-"MAD spare0, two, texSamp1, -one;\n" +
-"MAD spare1, two, texSamp0, -one;\n" +
-"MAD spare0, spare0, const0, spare1;\n" +
-"MAD result.color, oneHalf, spare0, const1;\n" +
-"\n" +
-"END\n";
-
- loadProgram(gl, GL.GL_FRAGMENT_PROGRAM_ARB, program);
-
- gl.glNewList(displayListID, GL.GL_COMPILE);
- gl.glProgramEnvParameter4fvARB(GL.GL_FRAGMENT_PROGRAM_ARB, 0, const0, 0);
- gl.glProgramEnvParameter4fvARB(GL.GL_FRAGMENT_PROGRAM_ARB, 1, const1, 0);
- gl.glBindProgramARB(GL.GL_FRAGMENT_PROGRAM_ARB, fragProg);
- gl.glEnable(GL.GL_FRAGMENT_PROGRAM_ARB);
- gl.glEndList();
- }
-
- private void initApplyVelocity(GL gl, int displayListID) {
- // This shader samples t1, biases its value to a signed number, and applies this
- // value multiplied by a scale factor to the t0 sample.
- //
- // This is used to apply a "velocity" texture value to a "height" state texture
- // for nearest-neighbor height-based water simulations. The output pixel is
- // the new "height" value to replace the t0 sample in rendering to a new
- // texture which will replace the texture selected into t0.
- //
- // A nearly identical shader using a different scaling constant is used to
- // apply the "force" value to the "velocity" texture at each texel.
- //
- // t1 comes in the range [0,1] but needs to hold signed values, so a value of
- // 0.5 in t1 represents zero velocity. This is biased to a signed value in
- // computing the new position.
- //
- // tex0 = height field
- // tex1 = velocity
- //
- // Bias the force/velocity to a signed value so we can subtract from
- // the t0 position sample.
- //
- // New height = velocity * scale factor + old height
-
- // Original register combiner program:
- //
- // Stage 0
- // rgb
- // {
- // discard = expand(tex1) * const0;
- // discard = expand(tex0);
- // spare0 = sum();
- // scale_by_one_half();
- // }
- // Stage 1
- // rgb
- // {
- // discard = spare0;
- // discard = const0;
- // spare0 = sum();
- // }
- // }
-
- float[] const0 = new float[] { 0.5f, 0.5f, 0.5f, 1.0f };
-
- int[] tmpInt = new int[1];
- gl.glGenProgramsARB(1, tmpInt, 0);
- int fragProg = tmpInt[0];
- gl.glBindProgramARB(GL.GL_FRAGMENT_PROGRAM_ARB, fragProg);
-
- String program =
-"!!ARBfp1.0\n" +
-"PARAM const0 = program.env[0];\n" +
-"PARAM one = { 1.0, 1.0, 1.0, 0.0 };\n" +
-"PARAM oneHalf = { 0.5, 0.5, 0.5, 1.0 };\n" +
-"PARAM two = { 2.0, 2.0, 2.0, 1.0 };\n" +
-"TEMP texSamp0, texSamp1;\n" +
-"TEMP spare0, spare1;\n" +
-"\n" +
-"TEX texSamp0, fragment.texcoord[0], texture[0], 2D;\n" +
-"TEX texSamp1, fragment.texcoord[1], texture[1], 2D;\n" +
-"MAD spare0, two, texSamp1, -one;\n" +
-"MAD spare1, two, texSamp0, -one;\n" +
-"MAD spare0, spare0, const0, spare1;\n" +
-"MAD result.color, oneHalf, spare0, const0;\n" +
-"\n" +
-"END\n";
-
- loadProgram(gl, GL.GL_FRAGMENT_PROGRAM_ARB, program);
-
- gl.glNewList(displayListID, GL.GL_COMPILE);
- gl.glProgramEnvParameter4fvARB(GL.GL_FRAGMENT_PROGRAM_ARB, 0, const0, 0);
- gl.glBindProgramARB(GL.GL_FRAGMENT_PROGRAM_ARB, fragProg);
- gl.glEnable(GL.GL_FRAGMENT_PROGRAM_ARB);
- gl.glEndList();
- }
-
- private void initCreateNormalMap(GL gl, int displayListID) {
- // Neighbor-differencing for RGB normal map creation. Scale factors for s and t
- // axis components are set in program code.
- // This does a crude 1-s^2-t^2 calculation for the blue component in order to
- // approximately normalize the RGB normal map vector. For s^2+t^2 close to 1.0,
- // this is a close approximation to blue = sqrt(1 - s^2 - t^2) which would give a
- // normalized vector.
- // An additional pass with a dependent texture lookup (alpha-red or green-blue)
- // could be used to produce an exactly normalized normal.
-
- // colors from all 4 texture stages
- // tex0 = -s, 0
- // tex1 = +s, 0
- // tex2 = 0, +t
- // tex3 = 0, -t
-
- // Original register combiner program:
- //
- // Stage 0
- // rgb
- // {
- // // (t0 - t1)*4 : 4 for higher scale
- // discard = -tex1;
- // discard = tex0;
- // spare0 = sum();
- // scale_by_four();
- // }
- // Stage 1
- // rgb
- // {
- // // (t3 - t2)*4 : 4 for higher scale
- // discard = -tex2;
- // discard = tex3;
- // spare1 = sum();
- // scale_by_four();
- // }
- // Stage 2
- // Define const0 in the third general combiner as RGBA = (scale, 0, 0, 0)
- // Where scale [0,1] is applied to reduce the magnitude
- // of the s axis component of the normal.
- // Define const1 in the third combiner similarly to affect the t axis component
- // define these by "ramboing" them in the C++ code that uses this combiner script.
- // Note: these variables have been renamed to "redMask" and "greenMask" in
- // the fragment program below.
- // rgb
- // {
- // // see comment about consts above!
- // // t0 = s result in red only
- // discard = spare0 * const0;
- // discard = spare1 * const1;
- // spare0 = sum();
- // }
- // Stage 3
- // rgb
- // {
- // tex1 = spare0 * spare0;
- // scale_by_two();
- // }
- // Stage 4
- // const0 = (1, 1, 0, 0);
- // rgb
- // {
- // spare1 = unsigned_invert(tex1) . const0;
- // scale_by_one_half();
- // }
- // Stage 5
- // const0 = (0.5, 0.5, 0, 0);
- // rgb
- // {
- // discard = spare0;
- // discard = const0;
- // spare0 = sum();
- // }
- // Stage 6
- // const0 = (0, 0, 1, 1);
- // rgb
- // {
- // discard = spare1 * const0;
- // discard = spare0;
- // spare0 = sum();
- // }
-
-
- float[] const0 = new float[] { 0.5f, 0.5f, 0.5f, 1.0f };
-
- int[] tmpInt = new int[1];
- gl.glGenProgramsARB(1, tmpInt, 0);
- int fragProg = tmpInt[0];
- gl.glBindProgramARB(GL.GL_FRAGMENT_PROGRAM_ARB, fragProg);
-
- String program =
-"!!ARBfp1.0\n" +
-"PARAM redMask = program.env[0];\n" +
-"PARAM greenMask = program.env[1];\n" +
-"PARAM const0 = { 1.0, 1.0, 0.0, 0.0 };\n" +
-"PARAM const1 = { 0.5, 0.5, 0.0, 0.0 };\n" +
-"PARAM const2 = { 0.0, 0.0, 1.0, 1.0 };\n" +
-"PARAM one = { 1.0, 1.0, 1.0, 0.0 };\n" +
-"PARAM oneHalf = { 0.5, 0.5, 0.5, 1.0 };\n" +
-"PARAM two = { 2.0, 2.0, 2.0, 1.0 };\n" +
-"PARAM four = { 4.0, 4.0, 4.0, 1.0 };\n" +
-"TEMP texSamp0, texSamp1, texSamp2, texSamp3;\n" +
-"TEMP spare0, spare1, spare2;\n" +
-"\n" +
-"TEX texSamp0, fragment.texcoord[0], texture[0], 2D;\n" +
-"TEX texSamp1, fragment.texcoord[1], texture[1], 2D;\n" +
-"TEX texSamp2, fragment.texcoord[2], texture[2], 2D;\n" +
-"TEX texSamp3, fragment.texcoord[3], texture[3], 2D;\n" +
-"SUB spare0, texSamp0, texSamp1;\n" +
-"MUL spare0, spare0, four;\n" +
-"SUB spare1, texSamp3, texSamp2;\n" +
-"MUL spare1, spare1, four;\n" +
-"MUL spare0, spare0, redMask;\n" +
-"MAD spare0, greenMask, spare1, spare0;\n" +
-"MUL_SAT spare2, spare0, spare0;\n" +
-"SUB spare2, one, spare2;\n" +
-"DP3 spare1, spare2, const0;\n" +
-"ADD spare0, spare0, const1;\n" +
-"MAD result.color, const2, spare1, spare0;\n" +
-"\n" +
-"END\n";
-
- loadProgram(gl, GL.GL_FRAGMENT_PROGRAM_ARB, program);
-
- gl.glNewList(displayListID, GL.GL_COMPILE);
- gl.glBindProgramARB(GL.GL_FRAGMENT_PROGRAM_ARB, fragProg);
- gl.glEnable(GL.GL_FRAGMENT_PROGRAM_ARB);
- gl.glEndList();
- }
-
- private void initDotProductReflect(GL gl, int displayListID) {
- // Pseudocode for this operation, derived from the NVidia
- // texture_shader.txt documentation at
- // http://oss.sgi.com/projects/ogl-sample/registry/NV/texture_shader.txt
-
- // TEX texSamp0, fragment.texcoord[0], texture[0], 2D;
- // MAD texSamp0, two, texSamp0, minusOne;
- // TEMP dotPP = texSamp0 . texcoord[1];
- // TEMP dotP = texSamp0 . texcoord[2];
- // TEMP dotC = texSamp0 . texcoord[3];
- // TEMP R, N, E;
- // N = [dotPP, dotP, dotC];
- // ooNLength = N dot N;
- // RCP ooNLength, ooNLength;
- // E = [texcoord[1].w, texcoord[2].w, texcoord[3].w];
- // nDotE = N dot E;
- // MUL R, nDotE, N;
- // MUL R, R, two;
- // MUL R, R, ooNLength;
- // SUB R, R, E;
- // TEX result.color, R, texture[3], CUBE;
-
- // This fragment program is pretty length-sensitive; making it too
- // big causes the frame rate to be cut in half on my machine
- // (Quadro FX Go700) due to sync-to-vertical-refresh. The program
- // below is more optimized in its use of temporaries. Some of the
- // scaling operations on the first component of the normal vector
- // (before subtracting off the E vector) don't appear to make much
- // of a visual difference so they are skipped as well.
-
- int[] tmpInt = new int[1];
- gl.glGenProgramsARB(1, tmpInt, 0);
- int fragProg = tmpInt[0];
- gl.glBindProgramARB(GL.GL_FRAGMENT_PROGRAM_ARB, fragProg);
-
- String program =
-"!!ARBfp1.0\n" +
-"PARAM minusOne = { -1.0, -1.0, -1.0, 0.0 };\n" +
-"PARAM two = { 2.0, 2.0, 2.0, 0.0 };\n" +
-"TEMP texSamp0, R, N, E;\n" +
-"\n" +
-"TEX texSamp0, fragment.texcoord[0], texture[0], 2D;\n" +
-"MAD texSamp0, two, texSamp0, minusOne;\n" +
-"DP3 N.x, texSamp0, fragment.texcoord[1];\n" +
-"DP3 N.y, texSamp0, fragment.texcoord[2];\n" +
-"DP3 N.z, texSamp0, fragment.texcoord[3];\n" +
-"MOV E.x, fragment.texcoord[1].w;\n" +
-"MOV E.y, fragment.texcoord[2].w;\n" +
-"MOV E.z, fragment.texcoord[3].w;\n" +
-"MUL N, N, two;\n" +
-"SUB R, N, E;\n" +
-"TEX result.color, R, texture[3], CUBE;\n" +
-"\n" +
-"END";
-
- loadProgram(gl, GL.GL_FRAGMENT_PROGRAM_ARB, program);
-
- gl.glNewList(displayListID, GL.GL_COMPILE);
- gl.glBindProgramARB(GL.GL_FRAGMENT_PROGRAM_ARB, fragProg);
- gl.glEnable(GL.GL_FRAGMENT_PROGRAM_ARB);
- gl.glEndList();
- }
-
- private void loadProgram(GL gl,
- int target,
- String programBuffer) {
- gl.glProgramStringARB(target, GL.GL_PROGRAM_FORMAT_ASCII_ARB, programBuffer.length(), programBuffer);
- int[] errPos = new int[1];
- gl.glGetIntegerv(GL.GL_PROGRAM_ERROR_POSITION_ARB, errPos, 0);
- if (errPos[0] >= 0) {
- String kind = "Program";
- if (target == GL.GL_VERTEX_PROGRAM_ARB) {
- kind = "Vertex program";
- } else if (target == GL.GL_FRAGMENT_PROGRAM_ARB) {
- kind = "Fragment program";
- }
- System.out.println(kind + " failed to load:");
- String errMsg = gl.glGetString(GL.GL_PROGRAM_ERROR_STRING_ARB);
- if (errMsg == null) {
- System.out.println("[No error message available]");
- } else {
- System.out.println("Error message: \"" + errMsg + "\"");
- }
- System.out.println("Error occurred at position " + errPos[0] + " in program:");
- int endPos = errPos[0];
- while (endPos < programBuffer.length() && programBuffer.charAt(endPos) != '\n') {
- ++endPos;
- }
- System.out.println(programBuffer.substring(errPos[0], endPos));
- throw new GLException("Error loading " + kind);
- } else {
- if (target == GL.GL_FRAGMENT_PROGRAM_ARB) {
- int[] isNative = new int[1];
- gl.glGetProgramivARB(GL.GL_FRAGMENT_PROGRAM_ARB,
- GL.GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB,
- isNative, 0);
- if (isNative[0] != 1) {
- System.out.println("WARNING: fragment program is over native resource limits");
- Thread.dumpStack();
- }
- }
- }
- }
-}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-30 05:33:20 +0000