8:30 – 11:00, 12:30 – 3:00 VISIBILITY

• Worked on getting Data Visualization working
• ISR/PMO meeting from 1:00 – 3:00

11:00 – 12:30, 3:00 – 5:00 FP

• Working on multiple rendering surfaces. For the trivial case, I’m going to try to take the blurred image and invert the colors.
• Added definition of the vertex and fragment shaders in the ScreenRepaint class, since it’s pretty generic.
• Took screen rendering out of the Gl_ShaderWindow base class and added two instances to the GeoTestShaderWindow. Everything works just as it should.
• Meeting at UMBC on surface displays, journals and other things. Looks like I’m on a team to build a “Surface-style” interface for the visually impaired. Meetings are every Wednesday at 4:30

10:00 – 4:30 FP

• The surgeon has declared me healed, and bid me to go forth and play hard.
• And now that I’ve gotten the screen aligned rendering working, I can get back to the book.
• Working on adding multiple, sequential rendering surfaces.

8:30 – FP

• I think I found GLSL documentation! http://www.opengl.org/sdk/docs/manglsl/
• A working convolution filter that blurs anything above a certain luminance:

• #version 150
  // glow.fs
  // outputs the color negative of a texture
  //
  
  in vec2 vTexCoord;
  
  uniform int screenWidth;
  uniform int screenHeight;
  
  uniform sampler2D textureUnit0;
  
  vec4 getTexOffset(const sampler2D texUnit, const vec2 texCoord, const float dx, const float dy){
  	vec2 offset = texCoord + vec2(dx, dy);
  	return texture(textureUnit0, offset);
  }
  
  void main(void)
  {
  	float dx = 1.0 / float(screenWidth);
  	float dy = 1.0 / float (screenHeight);
  
  	float x;
  	float y;
  	vec4 blurSum = vec4(0, 0, 0, 0);
  	float patchSize = 4.0;
  	float xmin = -patchSize*dx;
  	float xmax = patchSize*dx+dx*0.5;
  	float ymin = -patchSize*dy;
  	float ymax = patchSize*dy+dx*0.5;
  	float count = 0;
  
  	for(x = xmin; x < xmax; x += dx){
  		for(y = ymin; y < ymax; y += dy){
   			blurSum += getTexOffset(textureUnit1, vTexCoord, x, y);
   			if(count > 1000){
  				discard;
  			}
  			count += 1.0;
  		}
  	}
  	float weight = 1.0/count;
  	vec4 blured = vec4(blurSum.r*weight, blurSum.g*weight, blurSum.b*weight, 1.0);
  	vec4 sharp = texture(textureUnit0, vTexCoord);
  
  	float luminance = blured.r + blured.g + blured.b;
  	if(luminance > 1.0){
  		gl_FragColor = blured;
  	}else{
  		gl_FragColor = sharp;
  	}
  }

• And here’s the picture it produces. Note the sharp moon and gridlines with the blurry sun 🙂
• 
• Next on the hit parade, add a test to see if the corners of the convolution filter touch anything above the luminance threshold and discard if it doesn’t. My guess is that should speed up things a lot. Done. Discovered that there are some odd problems that crop up as the screen gets made quite large. This could have something to do with the fact that I’m not checking to see that the convolution patch’s coordinates can run off the texture (i.e not clamped between 0.0 and 1.0)?
• Migrate the screen drawing to a DrawableObject class. I’m pretty sure it should work there, as long as it’s called after postDraw3D(). In fact, it should be possible to have multiple screen drawing classes, though I’m not sure why.
• Add shader directory to svn repo – done
• And it appears that after a while, something is clogging the graphics pipeline, because the drawing slows way done. This does look like it’s due to the shader, as the neg.fs doesn’t seem to be slowing things down. Yep,  adding clamping to the glow.fs shader fixed that problem. Still have the problem where the screen texture gets messed up if the window gets too big…
• So here’s the better version of the fragment shader

• #version 150
  // glow.fs
  // outputs the color negative of a texture
  //
  
  in vec2 vTexCoord;
  
  uniform int screenWidth;
  uniform int screenHeight;
  
  uniform sampler2D textureUnit0;
  
  void luminanceTest(const sampler2D texUnit, const vec2 texCoord, const float xmin, const float xmax, const float ymin, const float ymax, const float luminance){
  	vec2 ll = clamp(texCoord + vec2(xmin, ymin), 0.0, 1.0);
  	vec2 lr = clamp(texCoord + vec2(xmax, ymin), 0.0, 1.0);
  	vec2 ur = clamp(texCoord + vec2(xmax, ymax), 0.0, 1.0);
  	vec2 ul = clamp(texCoord + vec2(xmin, ymax), 0.0, 1.0);
  
  	vec4 total = texture(texUnit, ll);
  	total += texture(texUnit, lr);
  	total += texture(texUnit, ur);
  	total += texture(texUnit, ul);
  
  	float weight = 1.0/4.0;
  	float val = (total.r + total.g + total.b)*weight;
  	if(val < luminance){
  		discard;
  	}
  }
  
  vec4 getTexOffset(const sampler2D texUnit, const vec2 texCoord, const float dx, const float dy){
  	vec2 offset = texCoord + vec2(dx, dy);
  	clamp(offset, 0.0, 1.0);
  	return texture(texUnit, offset);
  }
  
  void main(void)
  {
  	float dx = 1.0 / float(screenWidth);
  	float dy = 1.0 / float (screenHeight);
  
  	float x;
  	float y;
  	vec4 blurSum = vec4(0, 0, 0, 0);
  	float patchSize = 4.0;
  	float xmin = -patchSize*dx;
  	float xmax = patchSize*dx+dx*0.5;
  	float ymin = -patchSize*dy;
  	float ymax = patchSize*dy+dx*0.5;
  	float count = 0;
  
  	luminanceTest(textureUnit0, vTexCoord, xmin, xmax, ymin, ymax, 1.0);
  
  	for(x = xmin; x < xmax; x += dx){
  		for(y = ymin; y < ymax; y += dy){
   			blurSum += getTexOffset(textureUnit0, vTexCoord, x, y);
   			if(count > 1000){
  				discard;
  			}
  			count += 1.0;
  		}
  	}
  	vec4 sharp = texture(textureUnit0, vTexCoord);
  	float weight = 1.0/count;
  	vec4 blured = vec4(blurSum.r*weight, blurSum.g*weight, blurSum.b*weight, sharp.a);
  
  	float luminance = blured.r + blured.g + blured.b;
  	if(luminance > 1.0){
  		gl_FragColor = blured;
  	}else{
  		gl_FragColor = sharp;
  	}
  }

8:00 – 1:00 FP

• More rendering to a texture
• Yay! Progress!
• 
• Yeah, I know it doesn’t look like much, but it means I’m that much less confused…
• Deleting unneeded code for multiple buffers, malloc, etc.
• Refresh rate drops on screen resize. Why?

1:00 – 4:30 VISIBILITY

• VisTool Review

8:30 – 4:30 FP

• Reflection cube maps today
• And they are working! The trick to handling rotating reflections is the following (note that the camera matrix is determined before the model roation, and the surface normal is calculated after the rotation.):

	M3DMatrix44f mCameraRotOnly;
	M3DMatrix44f mInverseCamera;
	M3DMatrix33f mNormalMat;

	const M3DMatrix44f &mCamera = modelViewStack.GetMatrix();

	modelViewStack.PushMatrix();
		modelViewStack.Rotate(angle, 0.0f, 1.0f, 0.0f);

		orient44fromMat44(mCameraRotOnly, mCamera);
		orient33fromMat44(mNormalMat, modelViewStack.GetMatrix());
		m3dInvertMatrix44(mInverseCamera, mCameraRotOnly);

		projectionStack.PushMatrix();
			projectionStack.MultMatrix(modelViewStack.GetMatrix());
			glUseProgram(reflectionShader);
			glUniformMatrix4fv(locMVPReflect, 1, GL_FALSE, projectionStack.GetMatrix());
			glUniformMatrix4fv(locMVReflect, 1, GL_FALSE, modelViewStack.GetMatrix());
			glUniformMatrix3fv(locNormalReflect, 1, GL_FALSE, mNormalMat);
			glUniformMatrix4fv(locInvertedCamera, 1, GL_FALSE, mInverseCamera);
			triangleBatch.Draw();
			glUseProgram(NULL);
		projectionStack.PopMatrix();
	modelViewStack.PopMatrix();

• 
• It seems to be a nice day for pretty pictures. Here’s an example of multitexturing:
• 
• And now that our connection is better, maybe I’ll install R on fgmdev

8:30 – 4:30 FP

• Making good, albiet slow progress on shaders. It’s kind of like programming in pre IDE-days; edit in vim then submit to the GPU compiler for a cryptic message. On the list of things to do is a framework that allows for the more sophisticated editing of shaders in the context of a running program. Will probably do this is Java for eclipse. Looks like there’s a starting point here: http://glshaders.sourceforge.net/
• Nice progress so far. Let’s see if this video uploads…
• solarSystem
• Useful post on how to make a skybox with photoshop: http://www.interlopers.net/forum/viewtopic.php?f=44&t=31549
• Going to set up a new project – ShaderLearning2
• Use frame this time in Gl_ShaderWindow. Nope, I need Euler Angles for this.
• Need to install R on the new server.