anchor.diff:  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);
  -        }")
  +
  +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
  
positive.code: 
    ;; Enable a few opengl features. 
    (gl:enable :blend :depth-test :line-smooth :point-smooth :texture-2d :cull-face)
  
    ;; Set the blending mode. 
    (%gl:blend-func :src-alpha :one-minus-src-alpha)
    (gl:polygon-mode :front-and-back :fill)
  
    (gl:clear-color 0 0 1 0)
  
    (init-test))
  
  
  (clinch:defevent clinch:*on-idle* ()
  
    (gl:clear :color-buffer-bit :depth-buffer-bit)
    (clinch:render *node* :projection *projection*))
  
  (clinch:defevent clinch:*on-mouse-move* (win mouse state x y xrel yrel ts)
    ;;(format t "x:~A y:~A mouse:~A state:~A~%" x y mouse state)
    (case state
      (1 (clinch:rotate *node*
  		      (q:from-fixed-angles (clinch:degrees->radians yrel) (clinch:degrees->radians xrel) 0)))
      
      (2 (clinch:translate *node* (clinch:v! (/ xrel 2) (/ yrel -2) 0)))))
  
  
      
  (clinch:defevent clinch:*on-window-resized* (win width height ts)
    (format t "Resized: ~A ~A~%" width height)
    
    (setf *projection* (clinch::make-perspective-transform (clinch:degrees->radians 45)
  							 (/ width height) .1 1000)))
  
  (clinch:defevent clinch:*on-mouse-wheel-move* (win mouse x y ts)
    ;;(format t "win=~A mouse=~A x=~A y=~A ts=~A~%" win mouse x y ts)
    (clinch:translate *node* (clinch:v! 0 0 (/ y 1))))
  
  (clinch:init :init-controllers nil)
  
  
  
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)
  