View difference between Paste ID: LDB9F59r and CYFjr9hT

-------------------------
+package atmos;
-VERTEX PROGRAM:
+
-------------------------
+import java.text.DecimalFormat;
 import java.text.MessageFormat;
-attribute vec4 a_position;
+import java.util.Random;
-attribute vec4 a_color;
+
-attribute vec2 a_texCoord0;
+import com.badlogic.gdx.ApplicationListener;
-uniform mat4 u_proj;
+import com.badlogic.gdx.Gdx;
-uniform mat4 u_trans;
+import com.badlogic.gdx.Input.Keys;
-uniform mat4 u_projTrans;
+import com.badlogic.gdx.InputAdapter;
-varying vec4 v_color;
+import com.badlogic.gdx.backends.lwjgl.LwjglApplication;
-varying vec2 v_texCoords;
+import com.badlogic.gdx.backends.lwjgl.LwjglApplicationConfiguration;
 import com.badlogic.gdx.graphics.Color;
-void main()
+import com.badlogic.gdx.graphics.GL10;
-{
+import com.badlogic.gdx.graphics.OrthographicCamera;
-   v_color = a_color;
+import com.badlogic.gdx.graphics.Pixmap;
-   v_texCoords = a_texCoord0;
+import com.badlogic.gdx.graphics.Pixmap.Format;
-   gl_Position =  u_projTrans * a_position;
+import com.badlogic.gdx.graphics.Texture;
-}
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
 import com.badlogic.gdx.graphics.g2d.SpriteBatch;
 import com.badlogic.gdx.graphics.glutils.ShaderProgram;
 import com.badlogic.gdx.math.Matrix4;
-------------------------
+import com.badlogic.gdx.math.Vector2;
-FRAGMENT PROGRAM:
+import com.badlogic.gdx.math.Vector3;
-------------------------
+
 /**
-#ifdef GL_ES
+ * Simple illumination model with shaders in LibGDX.
-precision mediump float;
+ * @author davedes
-#endif
+ */
 public class Illumination2D implements ApplicationListener {
-varying vec4 v_color;
+
-varying vec2 v_texCoords;
+	Texture texture, texture_n;
-uniform sampler2D u_texture;
+
-uniform sampler2D u_normals;
+	boolean flipY;
-uniform vec3 light;
+	Texture normalBase;
-uniform vec3 ambientColor;
+	OrthographicCamera cam;
-uniform float ambientIntensity;
+	SpriteBatch fxBatch, batch;
-uniform vec2 resolution;
+
-uniform vec3 lightColor;
+	Matrix4 transform = new Matrix4();
-uniform bool useNormals;
+
-uniform bool useShadow;
+	Random rnd = new Random();
-uniform vec3 attenuation;
+
-uniform float strength;
+	// position of our light
-uniform bool yInvert;
+	final Vector3 DEFAULT_LIGHT_POS = new Vector3(0f, 0f, 0.07f);
 	// the color of our light
-void main() {
+	final Vector3 DEFAULT_LIGHT_COLOR = new Vector3(1f, 0.7f, 0.6f);
-	//sample color & normals from our textures
+	// the ambient color (color to use when unlit)
-	vec4 color = texture2D(u_texture, v_texCoords.st);
+	final Vector3 DEFAULT_AMBIENT_COLOR = new Vector3(0.3f, 0.3f, 1f);
-	vec3 nColor = texture2D(u_normals, v_texCoords.st).rgb;
+	// the attenuation factor: x=constant, y=linear, z=quadratic
 	final Vector3 DEFAULT_ATTENUATION = new Vector3(0.4f, 3f, 20f);
-	//some bump map programs will need the Y value flipped..
+	// the ambient intensity (brightness to use when unlit)
-	nColor.g = yInvert ? 1.0 - nColor.g : nColor.g;
+	final float DEFAULT_AMBIENT_INTENSITY = 0.2f;
 	final float DEFAULT_STRENGTH = 1f;
-	//this is for debugging purposes, allowing us to lower the intensity of our bump map
+
-	vec3 nBase = vec3(0.5, 0.5, 1.0);
+	final Color NORMAL_VCOLOR = new Color(1f,1f,1f,DEFAULT_STRENGTH);
-	nColor = mix(nBase, nColor, strength);
+
 	// the position of our light in 3D space
-	//normals need to be converted to [-1.0, 1.0] range and normalized
+	Vector3 lightPos = new Vector3(DEFAULT_LIGHT_POS);
-	vec3 normal = normalize(nColor * 2.0 - 1.0);
+	// the resolution of our game/graphics
 	Vector2 resolution = new Vector2();
-	//here we do a simple distance calculation
+	// the current attenuation
-	vec3 deltaPos = vec3( (light.xy - gl_FragCoord.xy) / resolution.xy, light.z );
+	Vector3 attenuation = new Vector3(DEFAULT_ATTENUATION);
 	// the current ambient intensity
-	vec3 lightDir = normalize(deltaPos);
+	float ambientIntensity = DEFAULT_AMBIENT_INTENSITY;
-	float lambert = useNormals ? clamp(dot(normal, lightDir), 0.0, 1.0) : 1.0;
+	float strength = DEFAULT_STRENGTH;
 
-	//now let's get a nice little falloff
+	// whether to use attenuation/shadows
-	float d = sqrt(dot(deltaPos, deltaPos));
+	boolean useShadow = true;
-	float att = useShadow ? 1.0 / ( attenuation.x + (attenuation.y*d) + (attenuation.z*d*d) ) : 1.0;
+
 	// whether to use lambert shading (with our normal map)
-	vec3 result = (ambientColor * ambientIntensity) + (lightColor.rgb * lambert) * att;
+	boolean useNormals = true;
-	result *= color.rgb;
+
 	DecimalFormat DEC_FMT = new DecimalFormat("0.00000");
-	gl_FragColor = v_color * vec4(result, color.a);
+
 	ShaderProgram program;
 
 	BitmapFont font;
 
 	private int texWidth, texHeight;
 
 	final String TEXT = "Use number keys to adjust parameters:\n" +
 			"1: Randomize Ambient Color\n" +
 			"2: Randomize Ambient Intensity {0}\n" +
 			"3: Randomize Light Color\n" +
 			"4/5: Increase/decrease constant attenuation: {1}\n" +
 			"6/7: Increase/decrease linear attenuation: {2}\n" +
 			"8/9: Increase/decrease quadratic attenuation: {3}\n" +
 			"0: Reset parameters\n" +
 			"RIGHT/LEFT: Increase/decrease normal map intensity: {4}\n" +
 			"UP/DOWN: Increase/decrease lightDir.z: {5}\n\n" +
 			"S toggles attenuation, N toggles normal shading\n" +
 			"T to toggle textures";
 
 	private Texture rock, rock_n, teapot, teapot_n;
 
 	public void create() {
 		// load our textures
 		rock = new Texture(Gdx.files.internal("data/teapot.png"));
 		rock_n = new Texture(Gdx.files.internal("data/teapot_n.png"));
 		teapot = new Texture(Gdx.files.internal("data/rock.png"));
 		teapot_n = new Texture(Gdx.files.internal("data/rock_n.png"));
 
 		texture = teapot;
 		texture_n = teapot_n;
 		flipY = texture==rock;
 
 		//we only use this to show what the strength-adjusted normal map looks like on screen
 		Pixmap pix = new Pixmap(1, 1, Format.RGB565);
 		pix.setColor(0.5f, 0.5f, 1.0f, 1.0f);
 		pix.fill();
 		normalBase = new Texture(pix);
 
 		texWidth = texture.getWidth();
 		texHeight = texture.getHeight();
 
 		// a simple 2D orthographic camera
 		cam = new OrthographicCamera(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
 		cam.setToOrtho(false);
 
 		// create our shader program...
 		program = createShader();
 
 		// now we create our sprite batch for our shader
 		fxBatch = new SpriteBatch(100, program);
 		// setShader is needed; perhaps this is a LibGDX bug?
 		fxBatch.setShader(program);
 		fxBatch.setProjectionMatrix(cam.combined);
 		fxBatch.setTransformMatrix(transform);
 
 		// usually we would just use a single batch for our application,
 		// but for demonstration let's also show the un-affected image
 		batch = new SpriteBatch(100);
 		batch.setProjectionMatrix(cam.combined);
 		batch.setTransformMatrix(transform);
 
 		// quick little input for debugging -- press S to toggle shadows, N to
 		// toggle normals
 		Gdx.input.setInputProcessor(new InputAdapter() {
 			public boolean keyDown(int key) {
 				if (key == Keys.S) {
 					useShadow = !useShadow;
 					return true;
 				} else if (key == Keys.N) {
 					useNormals = !useNormals;
 					return true;
 				} else if (key == Keys.NUM_1) {
 					program.begin();
 					program.setUniformf("ambientColor", rndColor());
 					program.end();
 					return true;
 				} else if (key == Keys.NUM_2) {
 					ambientIntensity = rnd.nextFloat();
 					return true;
 				} else if (key == Keys.NUM_3) {
 					program.begin();
 					program.setUniformf("lightColor", rndColor());
 					program.end();
 					return true;
 				} else if (key == Keys.NUM_0) {
 					attenuation.set(DEFAULT_ATTENUATION);
 					ambientIntensity = DEFAULT_AMBIENT_INTENSITY;
 					lightPos.set(DEFAULT_LIGHT_POS);
 					strength = DEFAULT_STRENGTH;
 					program.begin();
 					program.setUniformf("lightColor", DEFAULT_LIGHT_COLOR);
 					program.setUniformf("ambientColor", DEFAULT_AMBIENT_COLOR);
 					program.setUniformf("ambientIntensity", ambientIntensity);
 					program.setUniformf("attenuation", attenuation);
 					program.setUniformf("lightPos", lightPos);
 					program.setUniformf("strength", strength);
 					program.end();
 				} else if (key == Keys.T) {
 					texture = texture==teapot ? rock : teapot;
 					texture_n = texture_n==teapot_n ? rock_n : teapot_n;
 					flipY = texture==rock;
 					texWidth = texture.getWidth();
 					texHeight = texture.getHeight();
 					program.begin();
 					program.setUniformi("yInvert", flipY ? 1 : 0);
 					program.end();
 				}
 				return false;
 			}
 		});
 
 		font = new BitmapFont();
 	}
 
 	private Vector3 rndColor() {
 		return new Vector3(rnd.nextFloat(), rnd.nextFloat(), rnd.nextFloat());
 	}
 
 	private ShaderProgram createShader() {
 		// see the code here: http://pastebin.com/7fkh1ax8
 		// simple illumination model using ambient, diffuse (lambert) and attenuation
 		// see here: http://nccastaff.bournemouth.ac.uk/jmacey/CGF/slides/IlluminationModels4up.pdf
 		String vert = "attribute vec4 " + ShaderProgram.POSITION_ATTRIBUTE + ";\n" //
 				+ "attribute vec4 " + ShaderProgram.COLOR_ATTRIBUTE + ";\n" //
 				+ "attribute vec2 " + ShaderProgram.TEXCOORD_ATTRIBUTE + "0;\n" //
 				+ "uniform mat4 u_proj;\n" //
 				+ "uniform mat4 u_trans;\n" //
 				+ "uniform mat4 u_projTrans;\n" //
 				+ "varying vec4 v_color;\n" //
 				+ "varying vec2 v_texCoords;\n" //
 				+ "\n" //
 				+ "void main()\n" //
 				+ "{\n" //
 				+ "   v_color = " + ShaderProgram.COLOR_ATTRIBUTE + ";\n" //
 				+ "   v_texCoords = " + ShaderProgram.TEXCOORD_ATTRIBUTE + "0;\n" //
 				+ "   gl_Position =  u_projTrans * " + ShaderProgram.POSITION_ATTRIBUTE + ";\n" //
 				+ "}\n";
 
 		String frag = "#ifdef GL_ES\n" +
 				"precision mediump float;\n" +
 				"#endif\n" +
 				"varying vec4 v_color;\n" +
 				"varying vec2 v_texCoords;\n" +
 
 				"uniform sampler2D u_texture;\n" +
 				"uniform sampler2D u_normals;\n" +
 				"uniform vec3 light;\n" +
 				"uniform vec3 ambientColor;\n" +
 				"uniform float ambientIntensity; \n" +
 				"uniform vec2 resolution;\n" +
 				"uniform vec3 lightColor;\n" +
 				"uniform bool useNormals;\n" +
 				"uniform bool useShadow;\n" +
 				"uniform vec3 attenuation;\n" +
 				"uniform float strength;\n" +
 				"uniform bool yInvert;\n"+
 				"\n" +
 				"void main() {\n" +
 				"	//sample color & normals from our textures\n" +
 				"	vec4 color = texture2D(u_texture, v_texCoords.st);\n" +
 				"	vec3 nColor = texture2D(u_normals, v_texCoords.st).rgb;\n\n" +
 				"	//some bump map programs will need the Y value flipped..\n" +
 				"	nColor.g = yInvert ? 1.0 - nColor.g : nColor.g;\n\n" +
 				"	//this is for debugging purposes, allowing us to lower the intensity of our bump map\n" +
 				"	vec3 nBase = vec3(0.5, 0.5, 1.0);\n" +
 				"	nColor = mix(nBase, nColor, strength);\n\n" +
 				"	//normals need to be converted to [-1.0, 1.0] range and normalized\n" +
 				"	vec3 normal = normalize(nColor * 2.0 - 1.0);\n\n" +
 				"	//here we do a simple distance calculation\n" +
 				"	vec3 deltaPos = vec3( (light.xy - gl_FragCoord.xy) / resolution.xy, light.z );\n\n" +
 				"	vec3 lightDir = normalize(deltaPos);\n" +
 				"	float lambert = useNormals ? clamp(dot(normal, lightDir), 0.0, 1.0) : 1.0;\n" +
 				"	\n" +
 				"	//now let's get a nice little falloff\n" +
 				"	float d = sqrt(dot(deltaPos, deltaPos));"+
 				"	\n" +
 				"	float att = useShadow ? 1.0 / ( attenuation.x + (attenuation.y*d) + (attenuation.z*d*d) ) : 1.0;\n" +
 				"	\n" +
 				"	vec3 result = (ambientColor * ambientIntensity) + (lightColor.rgb * lambert) * att;\n" +
 				"	result *= color.rgb;\n" +
 				"	\n" +
 				"	gl_FragColor = v_color * vec4(result, color.a);\n" +
 				"}";
 		System.out.println("VERTEX PROGRAM:\n------------\n\n"+vert);
 		System.out.println("FRAGMENT PROGRAM:\n------------\n\n"+frag);
 		ShaderProgram program = new ShaderProgram(vert, frag);
 		// u_proj and u_trans will not be active but SpriteBatch will still try to set them...
 		program.pedantic = false;
 		if (program.isCompiled() == false)
 			throw new IllegalArgumentException("couldn't compile shader: "
 					+ program.getLog());
 
 		// set resolution vector
 		resolution.set(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
 
 		// we are only using this many uniforms for testing purposes...!!
 		program.begin();
 		program.setUniformi("u_texture", 0);
 		program.setUniformi("u_normals", 1);
 		program.setUniformf("light", lightPos);
 		program.setUniformf("strength", strength);
 		program.setUniformf("ambientIntensity", ambientIntensity);
 		program.setUniformf("ambientColor", DEFAULT_AMBIENT_COLOR);
 		program.setUniformf("resolution", resolution);
 		program.setUniformf("lightColor", DEFAULT_LIGHT_COLOR);
 		program.setUniformf("attenuation", attenuation);
 		program.setUniformi("useShadow", useShadow ? 1 : 0);
 		program.setUniformi("useNormals", useNormals ? 1 : 0);
 		program.setUniformi("yInvert", flipY ? 1 : 0);
 		program.end();
 
 		return program;
 	}
 
 	public void dispose() {
 		fxBatch.dispose();
 		batch.dispose();
 		texture.dispose();
 		texture_n.dispose();
 	}
 
 	public void render() {
 		Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
 
 		// draw our sprites without any effects
 		batch.begin();
 
 		final int IMG_Y = texHeight/2;
 
 		//let's first simulate our resulting normal map by blending a blue square atop it
 		//we also could have achieved this with glTexEnv in the fixed function pipeline
 		NORMAL_VCOLOR.a = 1.0f - strength;
 		batch.draw(texture_n, texWidth + 10, IMG_Y);
 		batch.setColor(NORMAL_VCOLOR);
 		batch.draw(normalBase, texWidth + 10, IMG_Y, texWidth, texHeight);
 		batch.setColor(Color.WHITE);
 		batch.draw(texture, 0, IMG_Y);
 		//now let's simulate how our normal map will be sampled using strength
 		//we can do this simply by blending a blue fill overtop
 
 		String str = MessageFormat.format(TEXT, ambientIntensity,
 				attenuation.x, attenuation.y, DEC_FMT.format(attenuation.z),
 				strength, lightPos.z);
 		font.drawMultiLine(batch, str, 10, Gdx.graphics.getHeight()-10);
 
 		font.draw(batch, "Diffuse Color", 10, IMG_Y+texHeight + 30);
 		font.draw(batch, "Normal Map", texWidth+20, IMG_Y+texHeight + 30);
 		font.draw(batch, "Final Color", texWidth*2+30, IMG_Y+texHeight + 30);
 		batch.end();
 
 		// start our FX batch, which will bind our shader program
 		fxBatch.begin();
 
 		// get y-down light position based on mouse/touch
 		lightPos.x = Gdx.input.getX();
 		lightPos.y = Gdx.graphics.getHeight() - Gdx.input.getY();
 
 		// handle attenuation input
 		if (Gdx.input.isKeyPressed(Keys.NUM_4)) {
 			attenuation.x += 0.025f;
 		} else if (Gdx.input.isKeyPressed(Keys.NUM_5)) {
 			attenuation.x -= 0.025f;
 			if (attenuation.x < 0)
 				attenuation.x = 0;
 		} else if (Gdx.input.isKeyPressed(Keys.NUM_6)) {
 			attenuation.y += 0.25f;
 		} else if (Gdx.input.isKeyPressed(Keys.NUM_7)) {
 			attenuation.y -= 0.25f;
 			if (attenuation.y < 0)
 				attenuation.y = 0;
 		} else if (Gdx.input.isKeyPressed(Keys.NUM_8)) {
 			attenuation.z += 0.25f;
 		} else if (Gdx.input.isKeyPressed(Keys.NUM_9)) {
 			attenuation.z -= 0.25f;
 			if (attenuation.z < 0)
 				attenuation.z = 0;
 		} else if (Gdx.input.isKeyPressed(Keys.RIGHT)) {
 			strength += 0.025f;
 			if (strength > 1f)
 				strength = 1f;
 		} else if (Gdx.input.isKeyPressed(Keys.LEFT)) {
 			strength -= 0.025f;
 			if (strength < 0)
 				strength = 0;
 		} else if (Gdx.input.isKeyPressed(Keys.UP)) {
 			lightPos.z += 0.0025f;
 		} else if (Gdx.input.isKeyPressed(Keys.DOWN)) {
 			lightPos.z -= 0.0025f;
 		}
 
 		// update our uniforms
 		program.setUniformf("ambientIntensity", ambientIntensity);
 		program.setUniformf("attenuation", attenuation);
 		program.setUniformf("light", lightPos);
 		program.setUniformi("useNormals", useNormals ? 1 : 0);
 		program.setUniformi("useShadow", useShadow ? 1 : 0);
 		program.setUniformf("strength", strength);
 
 		// bind the normal first at texture1
 		texture_n.bind(1);
 
 		// bind the actual texture at texture0
 		texture.bind(0);
 
 		// we bind texture0 second since draw(texture) will end up binding it at
 		// texture0...
 		fxBatch.draw(texture, texWidth*2 + 20, IMG_Y);
 		fxBatch.end();
 	}
 
 	public void resize(int width, int height) {
 		cam.setToOrtho(false, width, height);
 		resolution.set(width, height);
 		program.setUniformf("resolution", resolution);
 	}
 
 	public void pause() {
 	}
 
 	public void resume() {
 	}
 
 	public static void main(String[] args) {
 		LwjglApplicationConfiguration cfg = new LwjglApplicationConfiguration();
 		cfg.title = "Lighting Test";
 		cfg.useGL20 = true;
 		cfg.width = 1024;
 		cfg.height = 768;
 		cfg.resizable = false;
 
 		new LwjglApplication(new Illumination2D(), cfg);
 	}
 }