diff options
Diffstat (limited to 'src/demos')
| -rwxr-xr-x | src/demos/jrefract/JRefract.java | 781 |
1 files changed, 781 insertions, 0 deletions
diff --git a/src/demos/jrefract/JRefract.java b/src/demos/jrefract/JRefract.java new file mode 100755 index 0000000..a2feafe --- /dev/null +++ b/src/demos/jrefract/JRefract.java @@ -0,0 +1,781 @@ +/* + * Portions Copyright (C) 2005 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.jrefract; + +import java.awt.*; +import java.awt.event.*; +import java.awt.image.*; +import java.io.*; +import java.nio.*; +import java.util.*; +import javax.imageio.*; +import javax.imageio.stream.*; +import javax.swing.*; + +import net.java.games.jogl.*; +import net.java.games.jogl.util.*; +import demos.util.*; +import gleem.*; +import gleem.linalg.*; + +/** + Wavelength-dependent refraction demo<br> + It's a chromatic aberration!<br> + [email protected] 4/2001<br><p> + + Currently 3 passes - could do it in 1 with 4 texture units<p> + + Cubemap courtesy of Paul Debevec<p> + + Ported to Java, Swing and ARB_fragment_program by Kenneth Russell +*/ + +public class JRefract { + private boolean useRegisterCombiners; + private GLJPanel canvas; + private Animator animator; + private volatile boolean quit; + + public static void main(String[] args) { + new JRefract().run(args); + } + + public void run(String[] args) { + + JFrame frame = new JFrame("JOGL and Swing Interoperability"); + JDesktopPane desktop = new JDesktopPane(); + desktop.setSize(1024, 768); + JInternalFrame inner = new JInternalFrame("Refraction Using Vertex Programs"); + inner.setResizable(true); + + canvas = GLDrawableFactory.getFactory().createGLJPanel(new GLCapabilities()); + canvas.addGLEventListener(new Listener()); + canvas.setSize(512, 512); + canvas.addMouseListener(new MouseAdapter() { + public void mouseClicked(MouseEvent e) { + canvas.requestFocus(); + } + }); + + inner.getContentPane().setLayout(new BorderLayout()); + inner.getContentPane().add(canvas, BorderLayout.CENTER); + inner.getContentPane().add(new JButton("West"), BorderLayout.WEST); + inner.getContentPane().add(new JButton("East"), BorderLayout.EAST); + inner.getContentPane().add(new JButton("North"), BorderLayout.NORTH); + inner.getContentPane().add(new JButton("South"), BorderLayout.SOUTH); + inner.setSize(canvas.getSize()); + frame.getContentPane().setLayout(new BorderLayout()); + frame.getContentPane().add(desktop, BorderLayout.CENTER); + desktop.add(inner); + inner.setVisible(true); + + JInternalFrame inner2 = new JInternalFrame("Hello, World"); + JLabel label = new JLabel("Hello, World!"); + label.setFont(new Font("SansSerif", Font.PLAIN, 128)); + inner2.getContentPane().add(label); + inner2.pack(); + inner2.setResizable(true); + desktop.add(inner2); + inner2.setVisible(true); + + animator = new Animator(canvas); + frame.addWindowListener(new WindowAdapter() { + public void windowClosing(WindowEvent e) { + runExit(); + } + }); + frame.setSize(desktop.getSize()); + frame.setVisible(true); + animator.start(); + } + + class Listener implements GLEventListener { + private boolean firstRender = true; + private int vtxProg; + private int fragProg; + private int cubemap; + private int bunnydl; + private int obj; + + private GLUT glut = new GLUT(); + + private ExaminerViewer viewer; + private boolean doViewAll = true; + + private Time time = new SystemTime(); + private float animRate = (float) Math.toRadians(-6.0f); // Radians / sec + + private float refract = 1.1f; // ratio of indicies of refraction + private float wavelengthDelta = 0.05f; // difference in refraction for each "wavelength" (R,G,B) + private float fresnel = 2.0f; // Fresnel multiplier + + private boolean wire = false; + private boolean toggleWire = false; + + private static final String transformRefract = +"!!ARBvp1.0\n" + +"# Refraction\n" + +"\n" + +"# Parameters\n" + +"PARAM mvp [4] = { state.matrix.mvp }; # modelview projection matrix\n" + +"PARAM mvit[4] = { state.matrix.modelview.invtrans }; # modelview matrix inverse transpose\n" + +"PARAM mv [4] = { state.matrix.modelview }; # modelview matrix\n" + +"PARAM tex [4] = { state.matrix.texture }; # texture matrix\n" + +"PARAM eyePosition = program.env[0]; # eye position\n" + +"PARAM fresnel = program.env[1]; # fresnel multiplier\n" + +"PARAM texScale = program.env[2]; # texture scale\n" + +"PARAM misc = program.env[3]; # misc. constants\n" + +"PARAM refraction = program.env[4]; # refractive index\n" + +"\n" + +"# Per vertex inputs\n" + +"ATTRIB iPos = vertex.position; #position\n" + +"ATTRIB iCol0 = vertex.color; #color\n" + +"ATTRIB iNorm = vertex.normal; #normal\n" + +"\n" + +"# Temporaries\n" + +"TEMP r0;\n" + +"TEMP r1;\n" + +"TEMP r2;\n" + +"TEMP r3;\n" + +"TEMP r8;\n" + +"TEMP r9;\n" + +"TEMP r11;\n" + +"\n" + +"# Outputs\n" + +"OUTPUT oPos = result.position; #position\n" + +"OUTPUT oCol0 = result.color; #primary color\n" + +"OUTPUT oTex0 = result.texcoord[0]; #texture coordinate set 0\n" + +"OUTPUT oTex1 = result.texcoord[1]; #texture coordinate set 1\n" + +"\n" + +"\n" + +"# transform vertex position to eye space\n" + +"DP4 r9.x, mv[0], iPos ;\n" + +"DP4 r9.y, mv[1], iPos ;\n" + +"DP4 r9.z, mv[2], iPos ;\n" + +"DP4 r9.w, mv[3], iPos ;\n" + +"\n" + +"# transform normal to eye space\n" + +"DP3 r11.x, mvit[0], iNorm ;\n" + +"DP3 r11.y, mvit[1], iNorm ;\n" + +"DP3 r11.z, mvit[2], iNorm ;\n" + +"\n" + +"# vertex->eye vector\n" + +"ADD r0, -r9, eyePosition;\n" + +"\n" + +"# normalize\n" + +"DP3 r8.w, r0, r0;\n" + +"RSQ r8.w, r8.w;\n" + +"MUL r8, r0, r8.w; # r8 = eye/incident vector\n" + +"\n" + +"# refraction, Renderman style\n" + +"\n" + +"# float IdotN = I.N;\n" + +"# float k = 1 - eta*eta*(1 - IdotN*IdotN);\n" + +"# return k < 0 ? (0,0,0) : eta*I - (eta*IdotN + sqrt(k))*N;\n" + +"\n" + +"DP3 r0.x, r11, -r8; # r0 = N.I\n" + +"\n" + +"MAD r1.x, -r0.x, r0.x, misc.y; # r1 = -IdotN*IdotN + 1\n" + +"MUL r1.x, r1.x, refraction.y; # r1 = -(r1*eta*eta)+1\n" + +"ADD r1.x, misc.y, -r1.x;\n" + +"\n" + +"RSQ r2.x, r1.x;\n" + +"RCP r2.x, r2.x;\n" + +"MAD r2.x, refraction.x, r0.x, r2.x;\n" + +"MUL r2, r11, r2.x;\n" + +"MAD r2, refraction.x, -r8, r2;\n" + +"\n" + +"# transform refracted ray by cubemap transform\n" + +"DP3 oTex0.x, tex[0], r2;\n" + +"DP3 oTex0.y, tex[1], r2;\n" + +"DP3 oTex0.z, tex[2], r2;\n" + +"\n" + +"# calculate reflection\n" + +"MUL r0, r11, misc.z;\n" + +"DP3 r3.w, r11, r8;\n" + +"MAD r3, r3.w, r0, -r8;\n" + +"\n" + +"# transform reflected ray by cubemap transform\n" + +"DP3 oTex1.x, tex[0], r3;\n" + +"DP3 oTex1.y, tex[1], r3;\n" + +"DP3 oTex1.z, tex[2], r3;\n" + +"\n" + +"# cheesy Fresnel approximation = (1-(I.N))^p\n" + +"DP3 r0.x, r8, r11;\n" + +"ADD r0.x, misc.y, -r0.x;\n" + +"MUL r0.x, r0.x, r0.x;\n" + +"MUL oCol0, r0.x, fresnel;\n" + +"\n" + +"# transform vertex to clip space\n" + +"DP4 oPos.x, mvp[0], iPos ;\n" + +"DP4 oPos.y, mvp[1], iPos ;\n" + +"DP4 oPos.z, mvp[2], iPos ;\n" + +"DP4 oPos.w, mvp[3], iPos ;\n" + +"\n" + +"END\n"; + + public void init(GLDrawable drawable) { + GL gl = drawable.getGL(); + GLU glu = drawable.getGLU(); + float cc = 1.0f; + gl.glClearColor(cc, cc, cc, 1); + gl.glColor3f(1,1,1); + gl.glEnable(GL.GL_DEPTH_TEST); + + try { + initExtension(gl, "GL_ARB_vertex_program"); + initExtension(gl, "GL_ARB_multitexture"); + if (!gl.isExtensionAvailable("GL_ARB_fragment_program")) { + if (gl.isExtensionAvailable("GL_NV_register_combiners")) { + useRegisterCombiners = true; + } else { + final String message = "This demo requires either the GL_ARB_fragment_program\n" + + "or GL_NV_register_combiners extension"; + new Thread(new Runnable() { + public void run() { + JOptionPane.showMessageDialog(null, message, "Unavailable extension", JOptionPane.ERROR_MESSAGE); + runExit(); + } + }).start(); + throw new RuntimeException(message); + } + } + } catch (RuntimeException e) { + quit = true; + throw(e); + } + + b[' '] = true; // animate by default + + int[] vtxProgTmp = new int[1]; + gl.glGenProgramsARB(1, vtxProgTmp); + vtxProg = vtxProgTmp[0]; + gl.glBindProgramARB (GL.GL_VERTEX_PROGRAM_ARB, vtxProg); + gl.glProgramStringARB(GL.GL_VERTEX_PROGRAM_ARB, GL.GL_PROGRAM_FORMAT_ASCII_ARB, transformRefract.length(), transformRefract); + + gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, 0, 0.0f, 0.0f, 0.0f, 1.0f); // eye position + + gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, 1, fresnel, fresnel, fresnel, 1.0f); // fresnel multiplier + + gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, 2, 1.0f, -1.0f, 1.0f, 0.0f); // texture scale + gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, 3, 0.0f, 1.0f, 2.0f, 3.0f); // misc constants + + int[] cubemapTmp = new int[1]; + gl.glGenTextures(1, cubemapTmp); + cubemap = cubemapTmp[0]; + gl.glBindTexture(GL.GL_TEXTURE_CUBE_MAP_ARB, cubemap); + + gl.glTexParameteri(GL.GL_TEXTURE_CUBE_MAP_ARB, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); + gl.glTexParameteri(GL.GL_TEXTURE_CUBE_MAP_ARB, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR_MIPMAP_LINEAR); + + try { + loadPNGCubemap(gl, glu, "demos/data/cubemaps/uffizi", true); + } catch (IOException e) { + runExit(); + throw new RuntimeException(e); + } + + gl.glTexEnvi(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_REPLACE); + + gl.glDisable(GL.GL_CULL_FACE); + + if (useRegisterCombiners) { + initCombiners(gl); + } else { + initFragmentProgram(gl); + } + + try { + bunnydl = Bunny.gen3DObjectList(gl); + } catch (IOException e) { + throw new RuntimeException(e); + } + + drawable.addKeyListener(new KeyAdapter() { + public void keyTyped(KeyEvent e) { + dispatchKey(e.getKeyChar()); + } + }); + + doViewAll = true; + + // Do this only once per drawable, not once each time the OpenGL + // context is created + if (firstRender) { + firstRender = false; + + drawable.addKeyListener(new KeyAdapter() { + public void keyTyped(KeyEvent e) { + dispatchKey(e.getKeyChar()); + } + }); + + // Register the window with the ManipManager + ManipManager manager = ManipManager.getManipManager(); + manager.registerWindow(drawable); + + viewer = new ExaminerViewer(MouseButtonHelper.numMouseButtons()); + viewer.setNoAltKeyMode(true); + viewer.attach(drawable, new BSphereProvider() { + public BSphere getBoundingSphere() { + return new BSphere(new Vec3f(0, 0, 0), 1.0f); + } + }); + viewer.setVertFOV((float) (15.0f * Math.PI / 32.0f)); + viewer.setZNear(0.1f); + viewer.setZFar(10.0f); + } + } + + public void display(GLDrawable drawable) { + if (quit) { + return; + } + + time.update(); + + GL gl = drawable.getGL(); + GLU glu = drawable.getGLU(); + gl.glClear(GL.GL_COLOR_BUFFER_BIT|GL.GL_DEPTH_BUFFER_BIT); + + if (doViewAll) { + System.err.println("viewer.viewAll()"); + viewer.viewAll(gl); + doViewAll = false; + } + + if (getFlag(' ')) { + viewer.rotateAboutFocalPoint(new Rotf(Vec3f.Y_AXIS, (float) (time.deltaT() * animRate))); + } + + if (toggleWire) { + toggleWire = false; + wire = !wire; + if (wire) { + gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_LINE); + } else { + gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_FILL); + } + } + + // draw background + gl.glDisable(GL.GL_DEPTH_TEST); + drawSkyBox(gl, glu); + gl.glEnable(GL.GL_DEPTH_TEST); + + gl.glPushMatrix(); + + viewer.update(gl); + ManipManager.getManipManager().updateCameraParameters(drawable, viewer.getCameraParameters()); + ManipManager.getManipManager().render(drawable, gl); + + gl.glBindProgramARB(GL.GL_VERTEX_PROGRAM_ARB, vtxProg); + + gl.glEnable(GL.GL_VERTEX_PROGRAM_ARB); + gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, 62, fresnel, fresnel, fresnel, 1.0f); + + // set texture transforms + gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB); + gl.glBindTexture(GL.GL_TEXTURE_CUBE_MAP_ARB, cubemap); + gl.glEnable(GL.GL_TEXTURE_CUBE_MAP_ARB); + gl.glMatrixMode(GL.GL_TEXTURE); + gl.glLoadIdentity(); + gl.glScalef(1.0f, -1.0f, 1.0f); + viewer.updateInverseRotation(gl); + + gl.glActiveTextureARB(GL.GL_TEXTURE1_ARB); + gl.glBindTexture(GL.GL_TEXTURE_CUBE_MAP_ARB, cubemap); + gl.glEnable(GL.GL_TEXTURE_CUBE_MAP_ARB); + gl.glMatrixMode(GL.GL_TEXTURE); + gl.glLoadIdentity(); + gl.glScalef(1.0f, -1.0f, 1.0f); + viewer.updateInverseRotation(gl); + + if (useRegisterCombiners) { + gl.glEnable(GL.GL_REGISTER_COMBINERS_NV); + } else { + gl.glBindProgramARB(GL.GL_FRAGMENT_PROGRAM_ARB, fragProg); + gl.glEnable(GL.GL_FRAGMENT_PROGRAM_ARB); + } + + gl.glColor3f(1.0f, 1.0f, 1.0f); + + if (getFlag('s')) { + // single pass + setRefraction(gl, refract); + drawObj(gl, glu, obj); + + } else { + // red pass + gl.glColorMask(true, false, false, false); + setRefraction(gl, refract); + drawObj(gl, glu, obj); + + gl.glDepthMask(false); + gl.glDepthFunc(GL.GL_EQUAL); + + // green pass + gl.glColorMask(false, true, false, false); + setRefraction(gl, refract + wavelengthDelta); + drawObj(gl, glu, obj); + + // blue pass + gl.glColorMask(false, false, true, false); + setRefraction(gl, refract + (wavelengthDelta * 2)); + drawObj(gl, glu, obj); + + gl.glDepthMask(true); + gl.glDepthFunc(GL.GL_LESS); + gl.glColorMask(true, true, true, false); + } + + if (useRegisterCombiners) { + gl.glDisable(GL.GL_REGISTER_COMBINERS_NV); + } else { + gl.glDisable(GL.GL_FRAGMENT_PROGRAM_ARB); + } + gl.glDisable(GL.GL_VERTEX_PROGRAM_ARB); + + gl.glMatrixMode(GL.GL_MODELVIEW); + gl.glPopMatrix(); + } + + // Unused routines + public void reshape(GLDrawable drawable, int x, int y, int width, int height) {} + public void displayChanged(GLDrawable drawable, boolean modeChanged, boolean deviceChanged) {} + + //---------------------------------------------------------------------- + // Internals only below this point + // + private boolean[] b = new boolean[256]; + private void dispatchKey(char k) { + setFlag(k, !getFlag(k)); + // Quit on escape or 'q' + if ((k == (char) 27) || (k == 'q')) { + runExit(); + return; + } + + switch (k) { + case '1': + obj = 0; + break; + + case '2': + obj = 1; + break; + + case '3': + obj = 2; + break; + + case '4': + obj = 3; + break; + + case 'v': + doViewAll = true; + break; + + case 'w': + toggleWire = true; + break; + + default: + break; + } + } + + private void setFlag(char key, boolean val) { + b[((int) key) & 0xFF] = val; + } + + private boolean getFlag(char key) { + return b[((int) key) & 0xFF]; + } + + // FIXME: note we found that we had to swap the negy and posy portions of the cubemap. + // Not sure why this is the case. Vertical flip in the image read? Possible, but doesn't + // appear to be the case (have tried this and produced wrong results at the time). + String[] suffixes = { "posx", "negx", "negy", "posy", "posz", "negz" }; + int[] targets = { GL.GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, + GL.GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, + GL.GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, + GL.GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, + GL.GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, + GL.GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB }; + private void loadPNGCubemap(GL gl, GLU glu, String baseName, boolean mipmapped) throws IOException { + for (int i = 0; i < suffixes.length; i++) { + String resourceName = baseName + "_" + suffixes[i] + ".png"; + // Note: use of BufferedInputStream works around 4764639/4892246 + BufferedImage img = ImageIO.read(new BufferedInputStream(getClass().getClassLoader().getResourceAsStream(resourceName))); + if (img == null) { + throw new RuntimeException("Error reading PNG image " + resourceName); + } + makeRGBTexture(gl, glu, img, targets[i], mipmapped); + } + } + + private void makeRGBTexture(GL gl, GLU glu, BufferedImage img, int target, boolean mipmapped) { + ByteBuffer dest = null; + switch (img.getType()) { + case BufferedImage.TYPE_3BYTE_BGR: + case BufferedImage.TYPE_CUSTOM: { + byte[] data = ((DataBufferByte) img.getRaster().getDataBuffer()).getData(); + dest = ByteBuffer.allocateDirect(data.length); + dest.order(ByteOrder.nativeOrder()); + dest.put(data, 0, data.length); + break; + } + + case BufferedImage.TYPE_INT_RGB: { + int[] data = ((DataBufferInt) img.getRaster().getDataBuffer()).getData(); + dest = ByteBuffer.allocateDirect(data.length * BufferUtils.SIZEOF_INT); + dest.order(ByteOrder.nativeOrder()); + dest.asIntBuffer().put(data, 0, data.length); + break; + } + + default: + throw new RuntimeException("Unsupported image type " + img.getType()); + } + + if (mipmapped) { + glu.gluBuild2DMipmaps(target, GL.GL_RGB8, img.getWidth(), img.getHeight(), GL.GL_RGB, + GL.GL_UNSIGNED_BYTE, dest); + } else { + gl.glTexImage2D(target, 0, GL.GL_RGB, img.getWidth(), img.getHeight(), 0, + GL.GL_RGB, GL.GL_UNSIGNED_BYTE, dest); + } + } + + private void initExtension(GL gl, String glExtensionName) { + if (!gl.isExtensionAvailable(glExtensionName)) { + final String message = "OpenGL extension \"" + glExtensionName + "\" not available"; + new Thread(new Runnable() { + public void run() { + JOptionPane.showMessageDialog(null, message, "Unavailable extension", JOptionPane.ERROR_MESSAGE); + runExit(); + } + }).start(); + throw new RuntimeException(message); + } + } + + // initalize texture combiners to compute: + // refraction*(1-fresnel) + reflection*fresnel + private void initCombiners(GL gl) { + gl.glCombinerParameteriNV(GL.GL_NUM_GENERAL_COMBINERS_NV, 1); + + // combiner 0 + // a*b+c*d + gl.glCombinerInputNV(GL.GL_COMBINER0_NV, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_TEXTURE0_ARB, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB); + gl.glCombinerInputNV(GL.GL_COMBINER0_NV, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_PRIMARY_COLOR_NV, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB); + gl.glCombinerInputNV(GL.GL_COMBINER0_NV, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_TEXTURE1_ARB, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB); + gl.glCombinerInputNV(GL.GL_COMBINER0_NV, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_PRIMARY_COLOR_NV, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB); + + // output: + // (stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum) + gl.glCombinerOutputNV(GL.GL_COMBINER0_NV, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_NONE, GL.GL_NONE, false, false, false); + + // final combiner + // output: Frgb = A*B + (1-A)*C + D + // (variable, input, mapping, componentUsage); + gl.glFinalCombinerInputNV(GL.GL_VARIABLE_A_NV, GL.GL_SPARE0_NV, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB); + gl.glFinalCombinerInputNV(GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB); + gl.glFinalCombinerInputNV(GL.GL_VARIABLE_C_NV, GL.GL_ZERO, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB); + gl.glFinalCombinerInputNV(GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB); + } + + private void initFragmentProgram(GL gl) { + int[] fragProgTmp = new int[1]; + gl.glGenProgramsARB(1, fragProgTmp); + fragProg = fragProgTmp[0]; + String combineFragProg = +"!!ARBfp1.0\n" + +"# compute refraction*(1-fresnel) + reflection*fresnel\n" + +"TEMP texSamp0, texSamp1;\n" + +"TEMP invFresnel;\n" + +"PARAM one = { 1.0, 1.0, 1.0, 1.0 };\n" + +"TEX texSamp0, fragment.texcoord[0], texture[0], CUBE;\n" + +"TEX texSamp1, fragment.texcoord[1], texture[1], CUBE;\n" + +"SUB invFresnel, one, fragment.color;\n" + +"MUL texSamp0, texSamp0, invFresnel;\n" + +"MUL texSamp1, texSamp1, fragment.color;\n" + +"ADD texSamp0, texSamp0, texSamp1;\n" + +"MOV result.color, texSamp0;\n" + +"END"; + + gl.glBindProgramARB (GL.GL_FRAGMENT_PROGRAM_ARB, fragProg); + gl.glProgramStringARB(GL.GL_FRAGMENT_PROGRAM_ARB, GL.GL_PROGRAM_FORMAT_ASCII_ARB, + combineFragProg.length(), combineFragProg); + int[] errPos = new int[1]; + gl.glGetIntegerv(GL.GL_PROGRAM_ERROR_POSITION_ARB, errPos); + if (errPos[0] >= 0) { + System.out.println("Fragment program 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 < combineFragProg.length() && combineFragProg.charAt(endPos) != '\n') { + ++endPos; + } + System.out.println(combineFragProg.substring(errPos[0], endPos)); + } + } + + private void drawSkyBox(GL gl, GLU glu) { + // Compensates for ExaminerViewer's modification of modelview matrix + gl.glMatrixMode(GL.GL_MODELVIEW); + gl.glLoadIdentity(); + + gl.glActiveTextureARB(GL.GL_TEXTURE1_ARB); + gl.glDisable(GL.GL_TEXTURE_CUBE_MAP_ARB); + + gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB); + gl.glBindTexture(GL.GL_TEXTURE_CUBE_MAP_ARB, cubemap); + gl.glEnable(GL.GL_TEXTURE_CUBE_MAP_ARB); + + // This is a workaround for a driver bug on Mac OS X where the + // normals are not being sent down to the hardware in + // GL_NORMAL_MAP_EXT texgen mode. Temporarily enabling lighting + // causes the normals to be sent down. Thanks to Ken Dyke. + gl.glEnable(GL.GL_LIGHTING); + + gl.glTexGeni(GL.GL_S, GL.GL_TEXTURE_GEN_MODE, GL.GL_NORMAL_MAP_EXT); + gl.glTexGeni(GL.GL_T, GL.GL_TEXTURE_GEN_MODE, GL.GL_NORMAL_MAP_EXT); + gl.glTexGeni(GL.GL_R, GL.GL_TEXTURE_GEN_MODE, GL.GL_NORMAL_MAP_EXT); + + gl.glEnable(GL.GL_TEXTURE_GEN_S); + gl.glEnable(GL.GL_TEXTURE_GEN_T); + gl.glEnable(GL.GL_TEXTURE_GEN_R); + + gl.glTexEnvi(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_REPLACE); + + gl.glMatrixMode(GL.GL_TEXTURE); + gl.glPushMatrix(); + gl.glLoadIdentity(); + gl.glScalef(1.0f, -1.0f, 1.0f); + viewer.updateInverseRotation(gl); + + glut.glutSolidSphere(glu, 5.0, 40, 20); + + gl.glDisable(GL.GL_LIGHTING); + + gl.glPopMatrix(); + gl.glMatrixMode(GL.GL_MODELVIEW); + + gl.glDisable(GL.GL_TEXTURE_GEN_S); + gl.glDisable(GL.GL_TEXTURE_GEN_T); + gl.glDisable(GL.GL_TEXTURE_GEN_R); + } + + private void drawObj(GL gl, GLU glu, int obj) { + switch(obj) { + case 0: + gl.glCallList(bunnydl); + break; + + case 1: + glut.glutSolidSphere(glu, 0.5, 64, 64); + break; + + case 2: + glut.glutSolidTorus(gl, 0.25, 0.5, 64, 64); + break; + + case 3: + drawPlane(gl, 1.0f, 1.0f, 50, 50); + break; + } + } + + private void setRefraction(GL gl, float index) { + gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, 4, index, index*index, 0.0f, 0.0f); + } + + // draw square subdivided into quad strips + private void drawPlane(GL gl, float w, float h, int rows, int cols) { + int x, y; + float vx, vy, s, t; + float ts, tt, tw, th; + + ts = 1.0f / cols; + tt = 1.0f / rows; + + tw = w / cols; + th = h / rows; + + gl.glNormal3f(0.0f, 0.0f, 1.0f); + + for(y=0; y<rows; y++) { + gl.glBegin(GL.GL_QUAD_STRIP); + for(x=0; x<=cols; x++) { + vx = tw * x -(w/2.0f); + vy = th * y -(h/2.0f); + s = ts * x; + t = tt * y; + + gl.glTexCoord2f(s, t); + gl.glColor3f(s, t, 0.0f); + gl.glVertex3f(vx, vy, 0.0f); + + gl.glColor3f(s, t + tt, 0.0f); + gl.glTexCoord2f(s, t + tt); + gl.glVertex3f(vx, vy + th, 0.0f); + } + gl.glEnd(); + } + } + } + + private void runExit() { + quit = true; + // 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. Instead run + // the exit routine in another thread. + new Thread(new Runnable() { + public void run() { + animator.stop(); + System.exit(0); + } + }).start(); + } +} |