Java WebGLShader类代码示例

import com.googlecode.gwtgl.binding.WebGLShader; //导入依赖的package包/类
private WebGLShader loadShader(int shaderType, String shaderSource) {
  // Create the shader object
  WebGLShader shader = gl.createShader(shaderType);
  if (shader == null) {
    throw new RuntimeException();
  }
  // Load the shader source
  gl.shaderSource(shader, shaderSource);

  // Compile the shader
  gl.compileShader(shader);

  // Check the compile status
  boolean compiled = gl.getShaderParameterb(shader, COMPILE_STATUS);
  if (!compiled) {
    // Something went wrong during compilation; get the error
    throw new RuntimeException("Shader compile error: "
        + gl.getShaderInfoLog(shader));
  }
  return shader;
}
 

import com.googlecode.gwtgl.binding.WebGLShader; //导入依赖的package包/类
public void onModuleLoad() {
	
	Canvas canvas = Canvas.createIfSupported();
	canvas.setStyleName("MyCanvas");
	canvas.setCoordinateSpaceWidth(400);
	canvas.setCoordinateSpaceHeight(400);
	RootLayoutPanel.get().add(canvas);
	
	gl = (WebGLRenderingContext)canvas.getContext("experimental-webgl");
	gl.viewport(0, 0, 400, 400);
	
	WebGLBuffer vertexBuffer = gl.createBuffer();
	gl.bindBuffer(ARRAY_BUFFER, vertexBuffer);
	gl.bufferData(ARRAY_BUFFER, Float32Array.create(VERTICES), STATIC_DRAW);

	WebGLShader vertexShader = gl.createShader(VERTEX_SHADER);
	gl.shaderSource(vertexShader, VERTEX_SHADER_SOURCE);
	gl.compileShader(vertexShader);
	
	WebGLShader fragmentShader = gl.createShader(FRAGMENT_SHADER);
	gl.shaderSource(fragmentShader, FRAGMENT_SHADER_SOURCE);
	gl.compileShader(fragmentShader);
	
	program = gl.createProgram();
	gl.attachShader(program, vertexShader);
	gl.attachShader(program, fragmentShader);
	gl.linkProgram(program);
	
	gl.useProgram(program);
	gl.bindBuffer(ARRAY_BUFFER, vertexBuffer);
	
	WebGLUniformLocation texture = gl.getUniformLocation(program, "texture");
	gl.uniform1i(texture, 0);
	
	int posAttr = gl.getAttribLocation(program, "position");
	gl.vertexAttribPointer(posAttr, 3, FLOAT, false, 5*4, 0);
	gl.enableVertexAttribArray(posAttr);
	
	int texAttr = gl.getAttribLocation(program, "texcoord");
	gl.vertexAttribPointer(texAttr, 2, FLOAT, false, 5*4, 3*4);
	gl.enableVertexAttribArray(texAttr);
	
	for(int i=0; i<TEXTURE_URLS.length; i++) {
		loadTexture(TEXTURE_URLS[i], i);
	}
	
}
 

import com.googlecode.gwtgl.binding.WebGLShader; //导入依赖的package包/类
private WebGLShader getShader(int type, String source) {
	WebGLShader shader = GLES20.createShader(type);

	GLES20.shaderSource(shader, source);
	GLES20.compileShader(shader);

	if (!GLES20.getShaderParameterb(shader, WebGLRenderingContext.COMPILE_STATUS)) {
		throw new RuntimeException(GLES20.getShaderInfoLog(shader));
	}
	return shader;
}
 

import com.googlecode.gwtgl.binding.WebGLShader; //导入依赖的package包/类
public final native void attachShader(WebGLProgram program, WebGLShader shader) /*-{
  this.attachShader(program, shader);
}-*/;
 

import com.googlecode.gwtgl.binding.WebGLShader; //导入依赖的package包/类
public final native void compileShader(WebGLShader shader) /*-{
  this.compileShader(shader);
}-*/;
 

import com.googlecode.gwtgl.binding.WebGLShader; //导入依赖的package包/类
public final native WebGLShader createShader(int type) /*-{
  return this.createShader(type);
}-*/;
 

import com.googlecode.gwtgl.binding.WebGLShader; //导入依赖的package包/类
public final native void deleteShader(WebGLShader shader) /*-{
  this.deleteShader(shader);
}-*/;
 

import com.googlecode.gwtgl.binding.WebGLShader; //导入依赖的package包/类
public final native void detachShader(WebGLProgram program, WebGLShader shader) /*-{
  this.detachShader(program, shader);
}-*/;
 

import com.googlecode.gwtgl.binding.WebGLShader; //导入依赖的package包/类
public final native JsArray<WebGLShader> getAttachedShaders(WebGLProgram program) /*-{
  return this.getAttachedShaders(program);
}-*/;
 

import com.googlecode.gwtgl.binding.WebGLShader; //导入依赖的package包/类
public final native String getShaderInfoLog(WebGLShader shader) /*-{
  return this.getShaderInfoLog(shader);
}-*/;
 

import com.googlecode.gwtgl.binding.WebGLShader; //导入依赖的package包/类
public final native String getShaderSource(WebGLShader shader) /*-{
  return this.getShaderSource(shader);
}-*/;
 

import com.googlecode.gwtgl.binding.WebGLShader; //导入依赖的package包/类
public final native boolean isShader(WebGLShader shader) /*-{
  return this.isShader(shader);
}-*/;
 

import com.googlecode.gwtgl.binding.WebGLShader; //导入依赖的package包/类
public final native void shaderSource(WebGLShader shader, String source) /*-{
  this.shaderSource(shader, source);
}-*/;
 

import com.googlecode.gwtgl.binding.WebGLShader; //导入依赖的package包/类
public void finishShaderLoad(Scene scene, Material material) {
	StringBuffer vertexShaderStringBuffer = new StringBuffer();
	StringBuffer fragmentShaderStringBuffer = new StringBuffer();

	// TODO precision
	for (String k : shaderDefines.keySet()) {
		if (shaderDefines.get(k) == null) {
			vertexShaderStringBuffer.append("#define " + k + "\n");
			fragmentShaderStringBuffer.append("#define " + k + "\n");
		} else {
			vertexShaderStringBuffer.append("#define " + k + " " + shaderDefines.get(k) + "\n");
			fragmentShaderStringBuffer.append("#define " + k + " " + shaderDefines.get(k) + "\n");
		}
	}

	vertexShaderStringBuffer.append(vertexShaderLoaded);
	fragmentShaderStringBuffer.append(fragmentShaderLoaded);

	String vertexShaderString = vertexShaderStringBuffer.toString();
	String fragmentShaderString = fragmentShaderStringBuffer.toString();

	WebGLShader vertexShader = getShader(WebGLRenderingContext.VERTEX_SHADER, vertexShaderString);
	WebGLShader fragmentShader = getShader(WebGLRenderingContext.FRAGMENT_SHADER, fragmentShaderString);

	webGLProgram = GLES20.createProgram();
	GLES20.attachShader(webGLProgram, vertexShader);
	GLES20.attachShader(webGLProgram, fragmentShader);
	GLES20.linkProgram(webGLProgram);

	if (!GLES20.getProgramParameterb(webGLProgram, WebGLRenderingContext.LINK_STATUS)) {
		throw new RuntimeException("Could not initialize shaders");
	}
	GLES20.useProgram(webGLProgram);

	onShaderLoaded();

	GLES20.deleteShader(vertexShader);
	GLES20.deleteShader(fragmentShader);

	vertexShaderLoaded = null;
	fragmentShaderLoaded = null;
	shaderLoaded = true;
}
 

import com.googlecode.gwtgl.binding.WebGLShader; //导入依赖的package包/类
/**
 * Return the value for the passed pname given the passed shader.
 * 
 * @param pname one of DELETE_STATUS, COMPILE_STATUS
 */
public final native boolean getShaderParameterb(WebGLShader shader, int pname) /*-{
  return this.getShaderParameter(shader, pname);
}-*/;