protected static void sendToGL(final GLSLShaderObjectsState state) {
    final GL gl = GLU.getCurrentGL();

    if (state.getVertexShader() == null && state.getFragmentShader() == null) {
      logger.warning("Could not find shader resources!" + "(both inputbuffers are null)");
      state._needSendShader = false;
      return;
    }

    if (state._programID == -1) {
      state._programID = gl.glCreateProgramObjectARB();
    }

    if (state.getVertexShader() != null) {
      if (state._vertexShaderID != -1) {
        removeVertShader(state);
      }

      state._vertexShaderID = gl.glCreateShaderObjectARB(GL.GL_VERTEX_SHADER_ARB);

      // Create the sources
      final byte array[] = new byte[state.getVertexShader().limit()];
      state.getVertexShader().rewind();
      state.getVertexShader().get(array);
      gl.glShaderSourceARB(
          state._vertexShaderID, 1, new String[] {new String(array)}, new int[] {array.length}, 0);

      // Compile the vertex shader
      final IntBuffer compiled = BufferUtils.createIntBuffer(1);
      gl.glCompileShaderARB(state._vertexShaderID);
      gl.glGetObjectParameterivARB(
          state._vertexShaderID, GL.GL_OBJECT_COMPILE_STATUS_ARB, compiled);
      checkProgramError(compiled, state._vertexShaderID);

      // Attach the program
      gl.glAttachObjectARB(state._programID, state._vertexShaderID);
    } else if (state._vertexShaderID != -1) {
      removeVertShader(state);
      state._vertexShaderID = -1;
    }

    if (state.getFragmentShader() != null) {
      if (state._fragmentShaderID != -1) {
        removeFragShader(state);
      }

      state._fragmentShaderID = gl.glCreateShaderObjectARB(GL.GL_FRAGMENT_SHADER_ARB);

      // Create the sources
      final byte array[] = new byte[state.getFragmentShader().limit()];
      state.getFragmentShader().rewind();
      state.getFragmentShader().get(array);
      gl.glShaderSourceARB(
          state._fragmentShaderID,
          1,
          new String[] {new String(array)},
          new int[] {array.length},
          0);

      // Compile the fragment shader
      final IntBuffer compiled = BufferUtils.createIntBuffer(1);
      gl.glCompileShaderARB(state._fragmentShaderID);
      gl.glGetObjectParameterivARB(
          state._fragmentShaderID, GL.GL_OBJECT_COMPILE_STATUS_ARB, compiled);
      checkProgramError(compiled, state._fragmentShaderID);

      // Attach the program
      gl.glAttachObjectARB(state._programID, state._fragmentShaderID);
    } else if (state._fragmentShaderID != -1) {
      removeFragShader(state);
      state._fragmentShaderID = -1;
    }

    gl.glLinkProgramARB(state._programID);
    checkLinkError(state._programID);
    state.setNeedsRefresh(true);
    state._needSendShader = false;
  }
  protected static void sendToGL(
      final GLSLShaderObjectsState state, final ContextCapabilities caps) {
    final GL gl = GLContext.getCurrentGL();

    if (state.getVertexShader() == null && state.getFragmentShader() == null) {
      logger.warning("Could not find shader resources!" + "(both inputbuffers are null)");
      state._needSendShader = false;
      return;
    }

    if (state._programID == -1) {
      if (gl.isGL2()) {
        state._programID = gl.getGL2().glCreateProgramObjectARB();
      } else {
        if (gl.isGL2ES2()) {
          state._programID = gl.getGL2ES2().glCreateProgram();
        }
      }
    }

    if (state.getVertexShader() != null) {
      if (state._vertexShaderID != -1) {
        removeVertShader(state);
      }
      if (gl.isGL2()) {
        state._vertexShaderID = gl.getGL2().glCreateShaderObjectARB(GL2ES2.GL_VERTEX_SHADER);
      } else {
        if (gl.isGL2ES2()) {
          state._vertexShaderID = gl.getGL2ES2().glCreateShader(GL2ES2.GL_VERTEX_SHADER);
        }
      }

      // Create the sources
      final byte array[] = new byte[state.getVertexShader().limit()];
      state.getVertexShader().rewind();
      state.getVertexShader().get(array);
      if (gl.isGL2()) {
        gl.getGL2()
            .glShaderSourceARB(
                state._vertexShaderID,
                1,
                new String[] {new String(array)},
                new int[] {array.length},
                0);
      } else {
        if (gl.isGL2ES2()) {
          gl.getGL2ES2()
              .glShaderSource(
                  state._vertexShaderID,
                  1,
                  new String[] {new String(array)},
                  new int[] {array.length},
                  0);
        }
      }

      // Compile the vertex shader
      final JoglRenderContext context = (JoglRenderContext) ContextManager.getCurrentContext();
      final IntBuffer compiled = context.getDirectNioBuffersSet().getSingleIntBuffer();
      compiled.clear();
      if (gl.isGL2()) {
        gl.getGL2().glCompileShaderARB(state._vertexShaderID);
        gl.getGL2()
            .glGetObjectParameterivARB(
                state._vertexShaderID, GL2.GL_OBJECT_COMPILE_STATUS_ARB, compiled);
      } else {
        if (gl.isGL2ES2()) {
          gl.getGL2ES2().glCompileShader(state._vertexShaderID);
          gl.getGL2ES2().glGetShaderiv(state._vertexShaderID, GL2ES2.GL_COMPILE_STATUS, compiled);
        }
      }
      checkProgramError(compiled.get(0), state._vertexShaderID, state._vertexShaderName);

      // Attach the program
      if (gl.isGL2()) {
        gl.getGL2().glAttachObjectARB(state._programID, state._vertexShaderID);
      } else {
        if (gl.isGL2ES2()) {
          gl.getGL2ES2().glAttachShader(state._programID, state._vertexShaderID);
        }
      }
    } else if (state._vertexShaderID != -1) {
      removeVertShader(state);
      state._vertexShaderID = -1;
    }

    if (state.getFragmentShader() != null) {
      if (state._fragmentShaderID != -1) {
        removeFragShader(state);
      }

      if (gl.isGL2()) {
        state._fragmentShaderID = gl.getGL2().glCreateShaderObjectARB(GL2ES2.GL_FRAGMENT_SHADER);
      } else {
        if (gl.isGL2ES2()) {
          state._fragmentShaderID = gl.getGL2ES2().glCreateShader(GL2ES2.GL_FRAGMENT_SHADER);
        }
      }

      // Create the sources
      final byte array[] = new byte[state.getFragmentShader().limit()];
      state.getFragmentShader().rewind();
      state.getFragmentShader().get(array);
      if (gl.isGL2()) {
        gl.getGL2()
            .glShaderSourceARB(
                state._fragmentShaderID,
                1,
                new String[] {new String(array)},
                new int[] {array.length},
                0);
      } else {
        if (gl.isGL2ES2()) {
          gl.getGL2ES2()
              .glShaderSource(
                  state._fragmentShaderID,
                  1,
                  new String[] {new String(array)},
                  new int[] {array.length},
                  0);
        }
      }

      // Compile the fragment shader
      final JoglRenderContext context = (JoglRenderContext) ContextManager.getCurrentContext();
      final IntBuffer compiled = context.getDirectNioBuffersSet().getSingleIntBuffer();
      compiled.clear();
      if (gl.isGL2()) {
        gl.getGL2().glCompileShaderARB(state._fragmentShaderID);
        gl.getGL2()
            .glGetObjectParameterivARB(
                state._fragmentShaderID, GL2.GL_OBJECT_COMPILE_STATUS_ARB, compiled);
      } else {
        if (gl.isGL2ES2()) {
          gl.getGL2ES2().glCompileShader(state._fragmentShaderID);
          gl.getGL2ES2().glGetShaderiv(state._fragmentShaderID, GL2ES2.GL_COMPILE_STATUS, compiled);
        }
      }
      checkProgramError(compiled.get(0), state._fragmentShaderID, state._vertexShaderName);

      // Attach the program
      if (gl.isGL2()) {
        gl.getGL2().glAttachObjectARB(state._programID, state._fragmentShaderID);
      } else {
        if (gl.isGL2ES2()) {
          gl.getGL2ES2().glAttachShader(state._programID, state._fragmentShaderID);
        }
      }
    } else if (state._fragmentShaderID != -1) {
      removeFragShader(state);
      state._fragmentShaderID = -1;
    }

    if (caps.isGeometryShader4Supported()) {
      if (state.getGeometryShader() != null) {
        if (state._geometryShaderID != -1) {
          removeGeomShader(state);
        }

        if (gl.isGL2()) {
          state._geometryShaderID = gl.getGL2().glCreateShaderObjectARB(GL3.GL_GEOMETRY_SHADER);
        } else {
          if (gl.isGL2ES2()) {
            state._geometryShaderID = gl.getGL2ES2().glCreateShader(GL3.GL_GEOMETRY_SHADER);
          }
        }

        // Create the sources
        final byte array[] = new byte[state.getGeometryShader().limit()];
        state.getGeometryShader().rewind();
        state.getGeometryShader().get(array);
        if (gl.isGL2()) {
          gl.getGL2()
              .glShaderSourceARB(
                  state._geometryShaderID,
                  1,
                  new String[] {new String(array)},
                  new int[] {array.length},
                  0);
        } else {
          if (gl.isGL2ES2()) {
            gl.getGL2ES2()
                .glShaderSource(
                    state._geometryShaderID,
                    1,
                    new String[] {new String(array)},
                    new int[] {array.length},
                    0);
          }
        }

        // Compile the geometry shader
        final JoglRenderContext context = (JoglRenderContext) ContextManager.getCurrentContext();
        final IntBuffer compiled = context.getDirectNioBuffersSet().getSingleIntBuffer();
        compiled.clear();
        if (gl.isGL2()) {
          gl.getGL2().glCompileShaderARB(state._geometryShaderID);
          gl.getGL2()
              .glGetObjectParameterivARB(
                  state._geometryShaderID, GL2.GL_OBJECT_COMPILE_STATUS_ARB, compiled);
        } else {
          if (gl.isGL2ES2()) {
            gl.getGL2ES2().glCompileShader(state._geometryShaderID);
            gl.getGL2ES2()
                .glGetShaderiv(state._geometryShaderID, GL2ES2.GL_COMPILE_STATUS, compiled);
          }
        }
        checkProgramError(compiled.get(0), state._geometryShaderID, state._geometryShaderName);

        // Attach the program
        if (gl.isGL2()) {
          gl.getGL2().glAttachObjectARB(state._programID, state._geometryShaderID);
        } else {
          if (gl.isGL2ES2()) {
            gl.getGL2ES2().glAttachShader(state._programID, state._geometryShaderID);
          }
        }
      } else if (state._geometryShaderID != -1) {
        removeGeomShader(state);
        state._geometryShaderID = -1;
      }
    }

    if (caps.isTessellationShadersSupported()) {
      if (state.getTessellationControlShader() != null) {
        if (state._tessellationControlShaderID != -1) {
          removeTessControlShader(state);
        }

        if (gl.isGL2()) {
          state._tessellationControlShaderID =
              gl.getGL2().glCreateShaderObjectARB(GL4.GL_TESS_CONTROL_SHADER);
        } else {
          if (gl.isGL2ES2()) {
            state._tessellationControlShaderID =
                gl.getGL2ES2().glCreateShader(GL4.GL_TESS_CONTROL_SHADER);
          }
        }

        // Create the sources
        final byte array[] = new byte[state.getTessellationControlShader().limit()];
        state.getTessellationControlShader().rewind();
        state.getTessellationControlShader().get(array);
        if (gl.isGL2()) {
          gl.getGL2()
              .glShaderSourceARB(
                  state._tessellationControlShaderID,
                  1,
                  new String[] {new String(array)},
                  new int[] {array.length},
                  0);
        } else {
          if (gl.isGL2ES2()) {
            gl.getGL2ES2()
                .glShaderSource(
                    state._tessellationControlShaderID,
                    1,
                    new String[] {new String(array)},
                    new int[] {array.length},
                    0);
          }
        }

        // Compile the tessellation control shader
        final JoglRenderContext context = (JoglRenderContext) ContextManager.getCurrentContext();
        final IntBuffer compiled = context.getDirectNioBuffersSet().getSingleIntBuffer();
        compiled.clear();
        if (gl.isGL2()) {
          gl.getGL2().glCompileShaderARB(state._tessellationControlShaderID);
          gl.getGL2()
              .glGetObjectParameterivARB(
                  state._tessellationControlShaderID, GL2.GL_OBJECT_COMPILE_STATUS_ARB, compiled);
        } else {
          if (gl.isGL2ES2()) {
            gl.getGL2ES2().glCompileShader(state._tessellationControlShaderID);
            gl.getGL2ES2()
                .glGetShaderiv(
                    state._tessellationControlShaderID, GL2ES2.GL_COMPILE_STATUS, compiled);
          }
        }
        checkProgramError(
            compiled.get(0),
            state._tessellationControlShaderID,
            state._tessellationControlShaderName);

        // Attach the program
        if (gl.isGL2()) {
          gl.getGL2().glAttachObjectARB(state._programID, state._tessellationControlShaderID);
        } else {
          if (gl.isGL2ES2()) {
            gl.getGL2ES2().glAttachShader(state._programID, state._tessellationControlShaderID);
          }
        }
      } else if (state._tessellationControlShaderID != -1) {
        removeTessControlShader(state);
        state._tessellationControlShaderID = -1;
      }
      if (state.getTessellationEvaluationShader() != null) {
        if (state._tessellationEvaluationShaderID != -1) {
          removeTessEvalShader(state);
        }

        if (gl.isGL2()) {
          state._tessellationEvaluationShaderID =
              gl.getGL2().glCreateShaderObjectARB(GL4.GL_TESS_CONTROL_SHADER);
        } else {
          if (gl.isGL2ES2()) {
            state._tessellationEvaluationShaderID =
                gl.getGL2ES2().glCreateShader(GL4.GL_TESS_CONTROL_SHADER);
          }
        }

        // Create the sources
        final byte array[] = new byte[state.getTessellationEvaluationShader().limit()];
        state.getTessellationEvaluationShader().rewind();
        state.getTessellationEvaluationShader().get(array);
        if (gl.isGL2()) {
          gl.getGL2()
              .glShaderSourceARB(
                  state._tessellationEvaluationShaderID,
                  1,
                  new String[] {new String(array)},
                  new int[] {array.length},
                  0);
        } else {
          if (gl.isGL2ES2()) {
            gl.getGL2ES2()
                .glShaderSource(
                    state._tessellationEvaluationShaderID,
                    1,
                    new String[] {new String(array)},
                    new int[] {array.length},
                    0);
          }
        }

        // Compile the tessellation control shader
        final JoglRenderContext context = (JoglRenderContext) ContextManager.getCurrentContext();
        final IntBuffer compiled = context.getDirectNioBuffersSet().getSingleIntBuffer();
        compiled.clear();
        if (gl.isGL2()) {
          gl.getGL2().glCompileShaderARB(state._tessellationEvaluationShaderID);
          gl.getGL2()
              .glGetObjectParameterivARB(
                  state._tessellationEvaluationShaderID,
                  GL2.GL_OBJECT_COMPILE_STATUS_ARB,
                  compiled);
        } else {
          if (gl.isGL2ES2()) {
            gl.getGL2ES2().glCompileShader(state._tessellationEvaluationShaderID);
            gl.getGL2ES2()
                .glGetShaderiv(
                    state._tessellationEvaluationShaderID, GL2ES2.GL_COMPILE_STATUS, compiled);
          }
        }
        checkProgramError(
            compiled.get(0),
            state._tessellationEvaluationShaderID,
            state._tessellationEvaluationShaderName);

        // Attach the program
        if (gl.isGL2()) {
          gl.getGL2().glAttachObjectARB(state._programID, state._tessellationEvaluationShaderID);
        } else {
          if (gl.isGL2ES2()) {
            gl.getGL2ES2().glAttachShader(state._programID, state._tessellationEvaluationShaderID);
          }
        }
      } else if (state._tessellationEvaluationShaderID != -1) {
        removeTessEvalShader(state);
        state._tessellationEvaluationShaderID = -1;
      }
    }

    if (gl.isGL2()) {
      gl.getGL2().glLinkProgramARB(state._programID);
    } else {
      if (gl.isGL2ES2()) {
        gl.getGL2ES2().glLinkProgram(state._programID);
      }
    }
    checkLinkError(state._programID);
    state.setNeedsRefresh(true);
    state._needSendShader = false;
  }
예제 #3
0
  public void reloadShader() {
    if (useProjectedShader) {
      if (useRefraction) {
        currentShaderStr = projectedShaderRefractionStr;
      } else {
        currentShaderStr = projectedShaderStr;
      }
    } else {
      if (useRefraction) {
        currentShaderStr = simpleShaderRefractionStr;
      } else {
        currentShaderStr = simpleShaderStr;
      }
    }

    try {
      logger.info("loading " + currentShaderStr);
      waterShader.setVertexShader(
          ResourceLocatorTool.getClassPathResourceAsStream(
              WaterNode.class, currentShaderStr + ".vert"));
      waterShader.setFragmentShader(
          ResourceLocatorTool.getClassPathResourceAsStream(
              WaterNode.class, currentShaderStr + ".frag"));
    } catch (final IOException e) {
      logger.log(Level.WARNING, "Error loading shader", e);
      return;
    }

    waterShader.setUniform("normalMap", 0);
    waterShader.setUniform("reflection", 1);
    waterShader.setUniform("dudvMap", 2);
    if (useRefraction) {
      waterShader.setUniform("refraction", 3);
      waterShader.setUniform("depthMap", 4);
    }
    if (useProjectedShader) {
      if (useRefraction) {
        waterShader.setUniform("foamMap", 5);
      } else {
        waterShader.setUniform("foamMap", 3);
      }
    }

    waterShader._needSendShader = true;

    try {
      blurShaderVertical.setVertexShader(
          ResourceLocatorTool.getClassPathResourceAsStream(
              WaterNode.class, "com/ardor3d/extension/effect/bloom/bloom_blur.vert"));
      blurShaderVertical.setFragmentShader(
          ResourceLocatorTool.getClassPathResourceAsStream(
              WaterNode.class,
              "com/ardor3d/extension/effect/bloom/bloom_blur_vertical5_down.frag"));
    } catch (final IOException ex) {
      logger.logp(
          Level.SEVERE, getClass().getName(), "init(Renderer)", "Could not load shaders.", ex);
    }
    blurShaderVertical.setUniform("RT", 0);
    blurShaderVertical.setUniform("sampleDist", blurSampleDistance);
    blurShaderVertical._needSendShader = true;

    logger.info("Shader reloaded...");
  }