anchor.diff:  									     0.0   0.0
   									     1.0   0.0
   									     1.0   1.0)))))
  -		       :uniforms `(("M" . :model)
  -				   ("P" . :projection)
  -				   ("ambientTexture" . :place-holder)
  -				   ("ambientLight" . (.2 .2 .2))
  -				   ("lightIntensity" . (.8 .8 .8))
  -				   ("lightDirection" . (0.5772705 0.5772705 0.5772705)))))
  +		       :uniforms `(("M" . :model)                     ;; :model is a special value which inserts the current model matrix.
  +				   ("P" . :projection)                ;; :projection is a special value which inserts the current projection matrix.
  +				   ("ambientTexture" . :place-holder)))) ;; Texture value, a place holder for now.
   
  -  (make-simple-texture-shader)
  +  ;; Creates the texture to use.
     (setf *texture*
   	(clinch::create-texture-from-file 
   	 (concatenate 'string 
   		      (directory-namestring
   		       (asdf:system-relative-pathname :clinch "clinch.asd"))
   		      "examples/Tutorial05/lambda.png")))
  -		       
     
  -  (setf (clinch:shader-program *quad-mesh*) *simple-texture-shader*)
  +  ;; I could have put this inside the quad's attributes, but I wanted to 
  +  ;; demonstrate setting a uniform. Attributes work the same way. 
     (setf (clinch:uniform *quad-mesh* "ambientTexture") (lambda () *texture*))
  +
  +  ;; Create a node so I can move the quad around.
  +  ;; :Children takes a list.
     (setf *node* (make-instance 'clinch:node :children (list *quad-mesh*)))
  +
  +  ;; Move the node so it's in front of the camera.
     (clinch:translate *node* (clinch:v! 0 0 -2)))
   
   
  
positive.code: in vec3 v;
  in vec2 tc1;
  out vec2 v_tc1;
          void main() {
              gl_Position = P * M * vec4(v, 1);
              v_tc1 = vec2(tc1.x, -tc1.y);
          }")
  	      
  	      ;; String for the Fragment Shader
  	      ;;   t1    is the texture sampler
  
negative.code: uniform sampler2D ambientTexture;
  in vec2 v_tc1;
  out vec4 fragColor;
  
  void main() {
       fragColor = texture2D(ambientTexture, v_tc1);
   }"))
  	      ;; create and compile the shader. 
  	      (make-instance 'clinch:shader-program
  			     :name "Shader01"
  			     :vertex-shader vert-source
  			     :fragment-shader frag-source
  			     
  			     ;; Sets the uniforms and their types.
  			     ;; Eventually, I would like to query 
  			     ;; the shader for these, until then
  			     ;; it's a manual step.
  			     :uniforms '(("P" :matrix)
  					 ("M" :matrix)
  					 ("ambientTexture" :int)) ;; Textures or samplers are integer values.
  			     :attributes '(("tc1" :float)
  					   ("v" :float)))))))
  
  ;; Initialize the test. 
  (defun init-test ()
    
    ;; Create the entity (mesh)
    (setf *quad-mesh*
  	(make-instance 'clinch:entity
  
  		       ;; shader-program to use
  		       :shader-program  (make-simple-texture-shader)
  
  		       ;; Index values. 
  		       :indexes (make-instance 'clinch:index-buffer :data '(0 1 2 0 2 3))
  
  		       ;; List of attributes.
  		       ;; "v" is a buffer which holds the vertices.
  		       ;; "tc1" is a buffers which holds the texture coordinates.
  		       :attributes   `(("v" . ,(make-instance 'clinch:buffer 
  							      :Stride 3
  							      :data (map 'list (lambda (x)
  