     let characterFullPixelSize = characterFullPointSize.map({Int(ceil(Float($0) * scale))})
     
     let textureSize = _required_texture_size(atlasText.characters.count, size: characterFullPixelSize)
-    
-//    // Work out how many characters we can fit in wide and high
-//    let characterCount = (x: Int(floor(textureSize.width/CGFloat(characterFullPixelSize.w))),
-//                          y: Int(floor(textureSize.height/CGFloat(characterFullPixelSize.h))))
 
     // Calculate the exact UV size to use
     let uvSize = Size2D(w: GLfloat(characterPixelSize.w)/GLfloat(textureSize.width),

  /// The font name being used by this texture renderer
  var fontName : String { get }
  
  func draw(text: String, size : GLfloat, position : Point2D, align : NSTextAlignment,
  rotation: GLfloat, transform : GLKMatrix4)
}

extension TextRenderer {

    rotation: GLfloat = 0, transform : GLKMatrix4 = GLKMatrix4Identity) {
      return self.draw(text, size: size, position: position, align: align, rotation: rotation, transform: transform)
  }
}



/// Work out the size of texture we require for a particular count of characters
private func _required_texture_size(count: Int, size : Size2D<Int>) -> CGSize {
  // Work out the power of two length required for the maximum dimension
  let pwrMaxRequired = Int(ceil(log2(Float(max(size))*sqrt(Float(count)))))
  // Check the power below this, as it MIGHT work with uneven character aspect
  let charCount2 = (x: Int(floor(pow(2, Float(pwrMaxRequired-1))/Float(size.w))),
    y: Int(floor(pow(2, Float(pwrMaxRequired-1))/Float(size.h))))
  let txSize : Int
  if charCount2.x*charCount2.y > count {
    txSize = Int(pow(2, Float(pwrMaxRequired-1)))
  } else {
    txSize = Int(pow(2, Float(pwrMaxRequired)))
  }
  return CGSize(width: txSize, height: txSize)
}

class AtlasTextRenderer : TextRenderer {
