public static void apply(final JoglRenderer renderer, final GLSLShaderObjectsState state) {
final GL gl = GLU.getCurrentGL();
final RenderContext context = ContextManager.getCurrentContext();
final ContextCapabilities caps = context.getCapabilities();
if (caps.isGLSLSupported()) {
// Ask for the current state record
final ShaderObjectsStateRecord record =
(ShaderObjectsStateRecord) context.getStateRecord(StateType.GLSLShader);
context.setCurrentState(StateType.GLSLShader, state);
if (state.isEnabled()) {
if (state._needSendShader) {
sendToGL(state);
}
if (state._shaderDataLogic != null) {
state._shaderDataLogic.applyData(state, state._mesh, renderer);
}
}
if (!record.isValid() || record.getReference() != state || state.needsRefresh()) {
record.setReference(state);
if (state.isEnabled()) {
if (state._programID != -1) {
gl.glUseProgramObjectARB(state._programID);
final List<ShaderVariable> attribs = state.getShaderAttributes();
for (int i = attribs.size(); --i >= 0; ) {
final ShaderVariable shaderVariable = attribs.get(i);
if (shaderVariable.needsRefresh) {
JoglShaderUtil.updateAttributeLocation(shaderVariable, state._programID);
shaderVariable.needsRefresh = false;
}
JoglShaderUtil.updateShaderAttribute(shaderVariable);
}
final List<ShaderVariable> uniforms = state.getShaderUniforms();
for (int i = uniforms.size(); --i >= 0; ) {
final ShaderVariable shaderVariable = uniforms.get(i);
if (shaderVariable.needsRefresh) {
JoglShaderUtil.updateUniformLocation(shaderVariable, state._programID);
JoglShaderUtil.updateShaderUniform(shaderVariable);
shaderVariable.needsRefresh = false;
}
}
}
} else {
gl.glUseProgramObjectARB(0);
}
}
if (!record.isValid()) {
record.validate();
}
}
}
public ClipStateRecord(final ContextCapabilities caps) {
planeEnabled = new boolean[ClipState.MAX_CLIP_PLANES];
if (caps.areDoubleCoefficientsInClipPlaneEquationSupported()) {
buf = BufferUtils.createDoubleBuffer(4);
} else {
buf = BufferUtils.createFloatBuffer(4);
}
}
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;
}
public static void apply(final JoglRenderer renderer, final VertexProgramState state) {
final GL gl = GLU.getCurrentGL();
final RenderContext context = ContextManager.getCurrentContext();
final ContextCapabilities caps = context.getCapabilities();
if (caps.isVertexProgramSupported()) {
// ask for the current state record
final VertexProgramStateRecord record =
(VertexProgramStateRecord) context.getStateRecord(StateType.VertexProgram);
context.setCurrentState(StateType.VertexProgram, state);
if (!record.isValid() || record.getReference() != state) {
record.setReference(state);
if (state.isEnabled()) {
// Vertex program not yet loaded
if (state._getProgramID() == -1) {
if (state.getProgramAsBuffer() != null) {
final int id = create(state.getProgramAsBuffer());
state._setProgramID(id);
} else {
return;
}
}
gl.glEnable(GL.GL_VERTEX_PROGRAM_ARB);
gl.glBindProgramARB(GL.GL_VERTEX_PROGRAM_ARB, state._getProgramID());
// load environmental parameters...
for (int i = 0; i < VertexProgramState._getEnvParameters().length; i++) {
if (VertexProgramState._getEnvParameters()[i] != null) {
gl.glProgramEnvParameter4fARB(
GL.GL_VERTEX_PROGRAM_ARB,
i,
VertexProgramState._getEnvParameters()[i][0],
VertexProgramState._getEnvParameters()[i][1],
VertexProgramState._getEnvParameters()[i][2],
VertexProgramState._getEnvParameters()[i][3]);
}
}
// load local parameters...
if (state.isUsingParameters()) {
// no parameters are used
for (int i = 0; i < state._getParameters().length; i++) {
if (state._getParameters()[i] != null) {
gl.glProgramLocalParameter4fARB(
GL.GL_VERTEX_PROGRAM_ARB,
i,
state._getParameters()[i][0],
state._getParameters()[i][1],
state._getParameters()[i][2],
state._getParameters()[i][3]);
}
}
}
} else {
gl.glDisable(GL.GL_VERTEX_PROGRAM_ARB);
}
}
if (!record.isValid()) {
record.validate();
}
}
}
/**
* Initialize texture renderers. Load water textures. Create shaders.
*
* @param r
*/
private void initialize(final Renderer r) {
if (cam == null || initialized) {
return;
}
initialized = true;
final ContextCapabilities caps = ContextManager.getCurrentContext().getCapabilities();
if (useRefraction && useProjectedShader && caps.getNumberOfFragmentTextureUnits() < 6
|| useRefraction && caps.getNumberOfFragmentTextureUnits() < 5) {
useRefraction = false;
logger.info("Not enough textureunits, falling back to non refraction water");
}
if (!caps.isGLSLSupported()) {
supported = false;
}
if (!(caps.isPbufferSupported() || caps.isFBOSupported())) {
supported = false;
}
if (isSupported()) {
tRenderer =
TextureRendererFactory.INSTANCE.createTextureRenderer( //
cam.getWidth() / renderScale, // width
cam.getHeight() / renderScale, // height
8, // Depth bits... TODO: Make configurable?
0, // Samples... TODO: Make configurable?
r,
caps);
// blurSampleDistance = 1f / ((float) cam.getHeight() / renderScale);
tRenderer.setMultipleTargets(true);
tRenderer.setBackgroundColor(new ColorRGBA(0.0f, 0.0f, 0.0f, 1.0f));
tRenderer
.getCamera()
.setFrustum(
cam.getFrustumNear(),
cam.getFrustumFar(),
cam.getFrustumLeft(),
cam.getFrustumRight(),
cam.getFrustumTop(),
cam.getFrustumBottom());
textureState = new TextureState();
textureState.setEnabled(true);
setupTextures();
fullScreenQuad = new Quad("FullScreenQuad", cam.getWidth() / 4, cam.getHeight() / 4);
fullScreenQuad.setTranslation(cam.getWidth() / 2, cam.getHeight() / 2, 0);
fullScreenQuad.getSceneHints().setRenderBucketType(RenderBucketType.Ortho);
fullScreenQuad.getSceneHints().setCullHint(CullHint.Never);
fullScreenQuad.getSceneHints().setTextureCombineMode(TextureCombineMode.Replace);
fullScreenQuad.getSceneHints().setLightCombineMode(LightCombineMode.Off);
final TextureState ts = new TextureState();
ts.setTexture(textureReflect);
fullScreenQuad.setRenderState(ts);
fullScreenQuad.setRenderState(blurShaderVertical);
fullScreenQuad.updateWorldRenderStates(false);
}
if (!isSupported()) {
createFallbackData();
} else {
noFog = new FogState();
noFog.setEnabled(false);
}
getSceneHints().setCullHint(CullHint.Never);
setWaterEffectOnSpatial(this);
}