anchor.diff:                    (let ((foreign-name (or name (string-downcase
                                                   (bodge-util:translate-name-to-foreign symbol-name)))))
                       (make-shader-struct-field :name symbol-name
  -                                              :type (type->glsl type)
  +                                              :type (make-instance (type->glsl type))
                                                 :count count
                                                 :foreign-name foreign-name)))))
   
  
positive.code: (defun find-shader-struct-descriptor (class)
    (gethash class *struct-descriptor-registry*))
  
  
  (defstruct shader-struct-field
    (name nil :type symbol :read-only t)
    (type "float" :type string :read-only t)
    (count 1 :type fixnum :read-only t)
    (foreign-name "" :type string :read-only t))
  
  
  (defun type->glsl (type)
    (eswitch (type :test #'equal)
      (:float "float")
      (:int "int")
      (:uint "uint")
      (:bool "bool")
  
      (:bool2 "bvec2")
      (:bool3 "bvec3")
      (:bool4 "bvec4")
      (:float2 "vec2")
      (:float3 "vec3")
      (:float4 "vec4")
      (:int2 "ivec2")
      (:int3 "ivec3")
      (:int4 "ivec4")
      (:uint2 "uvec2")
      (:uint3 "uvec3")
      (:uint4 "uvec4")
      (:float3x3 "mat3")
      (:float4x4 "mat4")
  
      (:bvec2 "bvec2")
      (:bvec3 "bvec3")
      (:bvec4 "bvec4")
      (:vec2 "vec2")
      (:vec3 "vec3")
      (:vec4 "vec4")
      (:ivec2 "ivec2")
      (:ivec3 "ivec3")
      (:ivec4 "ivec4")
      (:uvec2 "uvec2")
      (:uvec3 "uvec3")
      (:uvec4 "uvec4")
      (:mat3 "mat3")
      (:mat4 "mat4")
  
      (:sampler-2d "sampler2D")
      ('(:sampler-2d :shadow) "sampler2DShadow")
      ('(:sampler-2d :float) "sampler2D")
      ('(:sampler-2d :uint) "usampler2D")
      ('(:sampler-2d :int) "isampler2D")
      (:sampler-cube "samplerCube")))
  
  
  (defun make-shader-struct-descriptor (fields)
  
negative.code:                               ((> field-count 1)
                                 (format nil "~A[~A]" foreign-name field-count))
                                (t foreign-name))))
      (format nil "~A ~A;" (%glsl-name-of field-type) full-foreign-name)))
  
  
  (defun serialize-struct-as-interface (struct-type interface-type &optional block-name (output t))
    (let ((descriptor (find-shader-struct-descriptor struct-type)))
      (format output "~&layout(std140) ~A ~A_i {
  ~{~&  ~A~}
  