Golang data.Shader类代码示例

// flatShader is a basic shader used mostly in test programs.
//
// Flat Shading    : The algorithm is used to calculate the colour for the polygon.
//                   The polygon has only one normal and the only part of the above
//                   algorithm used is:
//                            diffuse*(normal . light-direction)
func flatShader(sh *data.Shader) {
	sh.Vsh = []string{
		"#version 150",
		"in      vec4  in_v;",  // vertex coordinates
		"uniform mat4  mvpm;",  // projection * modelView
		"uniform vec3  kd;",    // diffuse colour
		"uniform float alpha;", // transparency
		"out     vec4  v_c;",   // vertex colour
		"void main() {",
		"	gl_Position = mvpm * in_v;",
		"	v_c = vec4(kd, alpha);",
		"}",
	}
	sh.Fsh = []string{
		"#version 150",
		"in  vec4 v_c;", // color from vertex shader
		"out vec4 ffc;", // final fragment colour
		"void main() {",
		"   ffc = v_c;",
		"}",
	}
	sh.Uniforms = map[string]int32{
		"mvpm":  -1,
		"kd":    -1,
		"alpha": -1,
	}
}

// uvShader handles a single texture.
func uvShader(sh *data.Shader) {
	sh.Vsh = []string{
		"#version 150",
		"in      vec4  in_v;", // vertex coordinates
		"in      vec2  in_t;", // texture coordinates
		"uniform mat4  mvpm;", // projection * model_view
		"out     vec2  t_uv;", // pass uv coordinates through
		"void main() {",
		"   gl_Position = mvpm * in_v;",
		"   t_uv = in_t;",
		"}",
	}
	sh.Fsh = []string{
		"#version 150",
		"in      vec2      t_uv;",
		"uniform sampler2D uv;",
		"uniform float     alpha;", // transparency
		"out     vec4      ffc;",   // final fragment colour
		"void main() {",
		"   ffc = texture(uv, t_uv) * vec4(1.0, 1.0, 1.0, alpha);",
		"}",
	}
	sh.Uniforms = map[string]int32{
		"mvpm":  -1,
		"alpha": -1,
		"uv":    -1,
	}
}

// CreateShader creates one of the known shaders. This is expected to be used by
// eng.LoadShader when a shader is not already in the cache. Nil is returned for
// unrecognized shaders. This function contains the list of official shader names.
func CreateShader(shaderName string, sh *data.Shader) {
	sh.Name = shaderName
	switch shaderName {
	case "flat":
		flatShader(sh)
	case "flata":
		flataShader(sh)
	case "gouraud":
		gouraudShader(sh)
	case "phong":
		phongShader(sh)
	case "uv":
		uvShader(sh)
	case "uva":
		uvaShader(sh)
	case "uvra":
		uvraShader(sh)
	case "uvm":
		uvmShader(sh)
	case "wave":
		waveShader(sh)
	case "bb":
		bbShader(sh)
	case "bba":
		bbaShader(sh)
	case "bbra":
		bbraShader(sh)
	default:
		sh.Name = "" // couldn't find the shader.
	}
}

// phongShader is based on
//       http://www.packtpub.com/article/opengl-glsl-4-shaders-basics
//
// Phong Shading   : The full algorithm is calculated at each point.  This is done
//                   by having a normal at each vertex and interpolating the normals
//                   across the polygon.
func phongShader(sh *data.Shader) {
	sh.Vsh = []string{
		"#version 150",
		"in      vec4  in_v;",  // vertex coordinates
		"in      vec3  in_n;",  // vertex normal
		"uniform mat4  mvpm;",  // projection * model_view
		"uniform mat4  mvm;",   // model_view
		"uniform mat3  nm;",    // normal matrix
		"uniform vec4  l;",     // untransformed light position
		"uniform vec3  ld;",    // light source intensity
		"uniform vec3  ka;",    // material ambient value
		"uniform vec3  kd;",    // material diffuse value
		"uniform vec3  ks;",    // material specular value
		"uniform float alpha;", // transparency
		"out     vec4  v_c;",   // vertex colour
		"void main() {",
		"   vec3 norm = normalize( nm * in_n);",
		"   vec4 eyeCoords = mvm * in_v;",
		"   vec3 s = normalize(vec3(l - eyeCoords));",
		"   vec3 v = normalize(-eyeCoords.xyz);",
		"   vec3 r = reflect( -s, norm );",
		"   ",
		"   vec3 la = vec3(1.0);", // FUTURE make la a uniform.
		"   vec3 ambient = la * ka;",
		"   float sDotN = max( dot(s,norm), 0.0 );",
		"   vec3 diffuse = ld * kd * sDotN;",
		"   vec3 spec = vec3(0.0);",
		"   float shininess = 3.0;", // FUTURE make shininess a uniform.",
		"   vec3 ls = vec3(1.0);",   // FUTURE make ls a uniform.",
		"   if( sDotN > 0.0 )",
		"      spec = ls * ks * pow( max( dot(r,v), 0.0 ), shininess );",
		"   ",
		"   vec3 colour = ambient + diffuse + spec;", // combine all the values.
		"   v_c = vec4(colour, alpha);",              // pass on the vertex colour
		"   gl_Position = mvpm * in_v;",              // pass on the transformed vertex position",
		"}",
	}
	sh.Fsh = []string{
		"#version 150",
		"in      vec4      v_c;", // input colour
		"out     vec4      ffc;", // final fragment colour
		"void main() {",
		"   ffc = v_c;",
		"}",
	}
	sh.Uniforms = map[string]int32{
		"mvpm":  -1,
		"mvm":   -1,
		"nm":    -1,
		"l":     -1,
		"ld":    -1,
		"ka":    -1,
		"kd":    -1,
		"ks":    -1,
		"alpha": -1,
	}
}

// bbraShader is a billboard shader that rotates the texture over time. It also
// fades an object out based on distance from the viewer.
func bbraShader(sh *data.Shader) {
	bbShader(sh)
	sh.Fsh = []string{
		"#version 150",
		"in      vec2      t_uv;",  // texture coordinates from vertex shader
		"uniform sampler2D uv;",    // sampler
		"uniform float     fd;",    // fade distance
		"uniform float     time;",  // current time in seconds
		"uniform float     rs;",    // rotation speed 0 -> 1
		"uniform float     alpha;", // transparency
		"out     vec4      ffc;",   // final fragment colour
		"",
		"float fade(float distance) {",
		"   float z = gl_FragCoord.z / gl_FragCoord.w / distance;",
		"   z = clamp(z, 0.0, 1.0);",
		"   return 1.0 - z;",
		"}",
		"void main() {",
		"   float sa = sin(time*rs);",                 // calculate rotation
		"   float ca = cos(time*rs);",                 // ..
		"   mat2 rot = mat2(ca, -sa, sa, ca);",        // ..
		"   ffc = texture(uv, ((t_uv-0.5)*rot)+0.5);", // rotate around its center
		"   ffc.a = ffc.a*fade(fd)*alpha;",
		"}",
	}
	sh.Uniforms["fd"] = -1
	sh.Uniforms["time"] = -1
	sh.Uniforms["rs"] = -1
}

// waveShader is a fragment only effect shader.
// This is a modified version of http://glsl.heroku.com/e#8397.0
func waveShader(sh *data.Shader) {
	sh.Vsh = []string{
		"#version 150",
		"in      vec4  in_v;", // vertex coordinates
		"uniform mat4  mvpm;", // projection * model_view
		"",
		"void main() {",
		"	 gl_Position = mvpm * in_v;",
		"}",
	}
	sh.Fsh = []string{
		"#version 150",
		"uniform float time;",       // current time in seconds
		"uniform vec2  resolution;", // viewport size
		"uniform float alpha;",      // transparency
		"out     vec4  ffc;",        // final fragment colour
		"",
		"const float Pi     = 3.14159;",
		"const float fScale = 4.3;",
		"const float fEps   = 0.5;",
		"",
		"void main()  {",
		"	vec2 p = (2.0*gl_FragCoord.xy-resolution)/max(resolution.x,resolution.y);",
		"	for(int i=1; i<100; i++) {",
		"		vec2 newp =p;",
		"		newp.x += 1.5/float(i)*sin(float(i)*p.y+time/40.0+0.3*float(i))+400./20.0;",
		"		newp.y += 0.05/float(i)*sin(float(i)*p.x+time/1.0+0.3*float(i+10))-400./20.0+15.0;",
		"		p = newp;",
		"	}",
		"	vec3 col = vec3(0.5*sin(3.0*p.x)+0.5,0.5*sin(3.0*p.y)+0.5,sin(p.x+p.y));",
		"	vec3 lum = vec3(0.299,0.587,0.114);",
		"	vec3 c = vec3(dot(col*0.2,lum));",
		"	ffc = vec4(c, 1.0);",
		"	ffc.a = ffc.a*alpha;",
		"}",
	}
	sh.Uniforms = map[string]int32{
		"mvpm":       -1,
		"alpha":      -1,
		"time":       -1,
		"resolution": -1,
	}
}

// bbShader is a billboard shader. Like a uv shader it renders a single texture
// but forces the textured object to always face the camera. See
//     http://www.lighthouse3d.com/opengl/billboarding/billboardingtut.pdf
func bbShader(sh *data.Shader) {
	sh.Vsh = []string{
		"#version 150",
		"in      vec4  in_v;",  // vertex coordinates
		"in      vec2  in_t;",  // texture coordinates
		"uniform mat4  mvpm;",  // projection * model_view
		"uniform vec3  scale;", // scale
		"out     vec2  t_uv;",  // pass uv coordinates through
		"void main() {",
		"   mat4 bb = mvpm;",
		"   bb[0][0] = 1.0;",
		"   bb[1][0] = mvpm[1][0];",
		"   bb[2][0] = 0.0;",
		"   bb[0][1] = 0.0;",
		"   bb[1][1] = 1.0;",
		"   bb[2][1] = 0.0;",
		"   bb[0][2] = 0.0;",
		"   bb[1][2] = mvpm[1][2];",
		"   bb[2][2] = 1.0;",
		"   vec4 vpos = in_v;",
		"   vpos.xyz = vpos.xyz * scale;",
		"   gl_Position = bb * vpos;",
		"   t_uv = in_t;",
		"}",
	}
	sh.Fsh = []string{
		"#version 150",
		"in      vec2      t_uv;",
		"uniform sampler2D uv;",
		"uniform float     alpha;", // transparency
		"out     vec4      ffc;",   // final fragment colour
		"void main() {",
		"   ffc = texture(uv, t_uv) * vec4(1.0, 1.0, 1.0, alpha);",
		"}",
	}
	sh.Uniforms = map[string]int32{
		"mvpm":  -1,
		"alpha": -1,
		"scale": -1,
		"uv":    -1,
	}
}

// uvmShader is a white mask uvshader. This is used to get a white + alpha.
func uvmShader(sh *data.Shader) {
	uvShader(sh)
	sh.Fsh = []string{
		"#version 150",
		"in      vec2      t_uv;",
		"uniform sampler2D uv;",
		"out     vec4      ffc;", // final fragment colour
		"",
		"void main() {",
		"   ffc = texture(uv, t_uv);",
		" 	ffc.r = 1.0;",
		" 	ffc.g = 1.0;",
		" 	ffc.b = 1.0;",
		"}",
	}
	sh.Uniforms = map[string]int32{
		"mvpm": -1,
		"uv":   -1,
	}
}

// gouraudShader is based on
//      http://www.packtpub.com/article/opengl-glsl-4-shaders-basics
//      http://devmaster.net/posts/2974/the-basics-of-3d-lighting
//
// Gouraud Shading : The algorithm is used to calculate a colour at each vertex.
//                   The colours are then interpolated across the polygon.
func gouraudShader(sh *data.Shader) {
	sh.Vsh = []string{
		"#version 150",
		"in      vec4  in_v;",  // vertex coordinates
		"in      vec3  in_n;",  // vertex normal
		"uniform mat4  mvpm;",  // projection * model_view
		"uniform mat4  mvm;",   // model_view
		"uniform mat3  nm;",    // normal matrix
		"uniform vec4  l;",     // untransformed light position
		"uniform vec3  ld;",    // light source intensity
		"uniform vec3  kd;",    // material diffuse value
		"uniform float alpha;", // transparency
		"out     vec4  v_c;",   // vertex colour
		"void main() {",
		"   vec3 norm = normalize( nm * in_n);", // Convert normal and position to eye coords
		"   vec4 eyeCoords = mvm * in_v;",
		"   vec3 lightDirection = normalize(vec3(l - eyeCoords));",
		"   ",
		"   vec3 colour = ld * kd * max( dot( lightDirection, norm ), 0.0 );",
		"   v_c = vec4(colour, alpha);", // pass on the amount of diffuse light.
		"   gl_Position = mvpm * in_v;", // pass on the transformed vertex position
		"}",
	}
	sh.Fsh = []string{
		"#version 150",
		"in  vec4 v_c;", // color from vertex shader
		"out vec4 ffc;", // final fragment colour
		"void main() {",
		"   ffc = v_c;",
		"}",
	}
	sh.Uniforms = map[string]int32{
		"mvpm":  -1,
		"mvm":   -1,
		"nm":    -1,
		"l":     -1,
		"ld":    -1,
		"kd":    -1,
		"alpha": -1,
	}
}

// loadShader imports the named resource and makes it available in the
// resource cache.
func (r *roadie) loadShader(name string, shader *data.Shader) {
	var err error
	if render.CreateShader(name, shader); shader != nil && shader.Name != "" {

		// override the default shader source with anything found on disk.
		ds := &data.Shader{}
		if r.ld.Load(name, &ds); ds != nil {
			if ds.Vsh != nil {
				shader.Vsh = ds.Vsh
			}
			if ds.Fsh != nil {
				shader.Fsh = ds.Fsh
			}
		}
		shader.EnsureNewLines()
		if shader.Program, err = r.gc.BindShader(shader); err != nil {
			log.Printf("roadie.loadShader: could not bind %s\n%s", name, err)
			return
		}
		r.ld.Cache(shader)
	} else {
		log.Printf("roadie.loadShader: unknown shader %s", name)
	}
}

// flataShader is a flat shader that fades an object out based on
// distance from the viewer.
func flataShader(sh *data.Shader) {
	flatShader(sh)
	sh.Fsh = []string{
		"#version 150",
		"in      vec4  v_c;", // color from vertex shader
		"uniform float fd;",  // fade distance
		"out     vec4  ffc;", // final fragment colour
		"",
		"float fade(float distance) {",
		"   float z = gl_FragCoord.z / gl_FragCoord.w / distance;",
		"   z = clamp(z, 0.0, 1.0);",
		"   return 1.0 - z;",
		"}",
		"void main() {",
		"   ffc = v_c;",
		"   ffc.a = ffc.a*fade(fd);",
		"}",
	}
	sh.Uniforms["fd"] = -1
}

// bbaShader is a billboard shader that fades an object out based on distance
// from the viewer.
func bbaShader(sh *data.Shader) {
	bbShader(sh)
	sh.Fsh = []string{
		"#version 150",
		"in      vec2      t_uv;",
		"uniform sampler2D uv;",
		"uniform float     fd;",    // fade distance
		"uniform float     alpha;", // transparency
		"out     vec4      ffc;",   // final fragment colour
		"",
		"float fade(float distance) {",
		"   float z = gl_FragCoord.z / gl_FragCoord.w / distance;",
		"   z = clamp(z, 0.0, 1.0);",
		"   return 1.0 - z;",
		"}",
		"void main() {",
		"   ffc = texture(uv, t_uv);",
		"   ffc.a = ffc.a*fade(fd)*alpha;",
		"}",
	}
	sh.Uniforms["fd"] = -1
}