twodee

const (
	Step60Hz = time.Duration(16666) * time.Microsecond
	Step30Hz = Step60Hz * 2
	Step20Hz = time.Duration(50000) * time.Microsecond
	Step15Hz = Step30Hz * 2
	Step10Hz = Step20Hz * 2
	Step5Hz  = Step10Hz * 2
)

const (
	KeyUp     = KeyCode(glfw.KeyUp)
	KeyDown   = KeyCode(glfw.KeyDown)
	KeyLeft   = KeyCode(glfw.KeyLeft)
	KeyRight  = KeyCode(glfw.KeyRight)
	KeyEnter  = KeyCode(glfw.KeyEnter)
	KeyEscape = KeyCode(glfw.KeyEscape)
	KeySpace  = KeyCode(glfw.KeySpace)
	KeyA      = KeyCode(glfw.KeyA)
	KeyB      = KeyCode(glfw.KeyB)
	KeyC      = KeyCode(glfw.KeyC)
	KeyD      = KeyCode(glfw.KeyD)
	KeyE      = KeyCode(glfw.KeyE)
	KeyF      = KeyCode(glfw.KeyF)
	KeyG      = KeyCode(glfw.KeyG)
	KeyH      = KeyCode(glfw.KeyH)
	KeyI      = KeyCode(glfw.KeyI)
	KeyJ      = KeyCode(glfw.KeyJ)
	KeyK      = KeyCode(glfw.KeyK)
	KeyL      = KeyCode(glfw.KeyL)
	KeyM      = KeyCode(glfw.KeyM)
	KeyN      = KeyCode(glfw.KeyN)
	KeyO      = KeyCode(glfw.KeyO)
	KeyP      = KeyCode(glfw.KeyP)
	KeyQ      = KeyCode(glfw.KeyQ)
	KeyR      = KeyCode(glfw.KeyR)
	KeyS      = KeyCode(glfw.KeyS)
	KeyT      = KeyCode(glfw.KeyT)
	KeyU      = KeyCode(glfw.KeyU)
	KeyV      = KeyCode(glfw.KeyV)
	KeyW      = KeyCode(glfw.KeyW)
	KeyX      = KeyCode(glfw.KeyX)
	KeyY      = KeyCode(glfw.KeyY)
	KeyZ      = KeyCode(glfw.KeyZ)
	Key1      = KeyCode(glfw.Key1)
	Key2      = KeyCode(glfw.Key2)
	Key3      = KeyCode(glfw.Key3)
	Key4      = KeyCode(glfw.Key4)
	Key5      = KeyCode(glfw.Key5)
	Key6      = KeyCode(glfw.Key6)
	Key7      = KeyCode(glfw.Key7)
	Key8      = KeyCode(glfw.Key8)
	Key9      = KeyCode(glfw.Key9)
	Key0      = KeyCode(glfw.Key0)
)

const (
	Release = Action(glfw.Release)
	Press   = Action(glfw.Press)
	Repeat  = Action(glfw.Repeat)
)

const (
	MouseButton1      = MouseButton(glfw.MouseButton1)
	MouseButton2      = MouseButton(glfw.MouseButton2)
	MouseButton3      = MouseButton(glfw.MouseButton3)
	MouseButton4      = MouseButton(glfw.MouseButton4)
	MouseButton5      = MouseButton(glfw.MouseButton5)
	MouseButton6      = MouseButton(glfw.MouseButton6)
	MouseButton7      = MouseButton(glfw.MouseButton7)
	MouseButton8      = MouseButton(glfw.MouseButton8)
	MouseButtonLast   = MouseButton(glfw.MouseButtonLast)
	MouseButtonLeft   = MouseButton(glfw.MouseButtonLeft)
	MouseButtonRight  = MouseButton(glfw.MouseButtonRight)
	MouseButtonMiddle = MouseButton(glfw.MouseButtonMiddle)
)

const (
	LinearInterpolation  = InterpolationType(gl.LINEAR)
	NearestInterpolation = InterpolationType(gl.NEAREST)
)

const BATCH_FRAGMENT = `#version 150
precision mediump float;

uniform sampler2D u_TextureUnit;
uniform vec2 u_TextureOffset;
in vec2 v_TextureCoordinates;
out vec4 v_FragData;

void main()
{
    vec2 texcoords = v_TextureCoordinates + u_TextureOffset;
    v_FragData = texture(u_TextureUnit, texcoords);
    //v_FragData = vec4(1.0,0.0,0.0,1.0);
}` + "\x00"

const BATCH_VERTEX = `#version 150

in vec4 a_Position;
in vec2 a_TextureCoordinates;

uniform mat4 m_ModelViewMatrix;
uniform mat4 m_ProjectionMatrix;

out vec2 v_TextureCoordinates;

void main()
{
    v_TextureCoordinates = a_TextureCoordinates;
    gl_Position = m_ProjectionMatrix * m_ModelViewMatrix * a_Position;
}` + "\x00"

const GLOW_FRAGMENT = `#version 150
precision mediump float;

uniform sampler2D u_TextureUnit;
in vec2 v_TextureCoordinates;
uniform int Orientation;
uniform int BlurAmount;
uniform float BlurScale;
uniform float BlurStrength;
uniform vec2 BufferDimensions;
out vec4 v_FragData;
vec2 TexelSize = vec2(1.0 / BufferDimensions.x, 1.0 / BufferDimensions.y);

float Gaussian (float x, float deviation) {
  return (1.0 / sqrt(2.0 * 3.141592 * deviation)) * exp(-((x * x) / (2.0 * deviation)));
}


void main() {
  // Locals
  float halfBlur = float(BlurAmount) * 0.5;
  vec4 colour = vec4(0.0);
  vec4 texColour = vec4(0.0);

  // Gaussian deviation
  float deviation = halfBlur * 0.35;
  deviation *= deviation;
  float strength = 1.0 - BlurStrength;

  if ( Orientation == 0 ) {
    // Horizontal blur
    for (int i = 0; i < 10; ++i) {
      if ( i >= BlurAmount ) {
        break;
      }
      float offset = float(i) - halfBlur;
      texColour = texture(
        u_TextureUnit,
        v_TextureCoordinates + vec2(offset * TexelSize.x * BlurScale, 0.0)) * Gaussian(offset * strength, deviation);
      colour += texColour;
    }
  } else {
    // Vertical blur
    for (int i = 0; i < 10; ++i) {
      if ( i >= BlurAmount ) {
        break;
      }
      float offset = float(i) - halfBlur;
      texColour = texture(
        u_TextureUnit,
        v_TextureCoordinates + vec2(0.0, offset * TexelSize.y * BlurScale)) * Gaussian(offset * strength, deviation);
      colour += texColour;
    }
  }
  // Apply colour
  v_FragData = clamp(colour, 0.0, 1.0);
  v_FragData.w = 1.0;
}` + "\x00"

const GLOW_VERTEX = `#version 150

in vec4 a_Position;
in vec2 a_TextureCoordinates;

out vec2 v_TextureCoordinates;

void main() {
    v_TextureCoordinates = a_TextureCoordinates;
    gl_Position = a_Position;
}` + "\x00"

const (
	Joystick1 = Joystick(glfw.Joystick1)
)

const LINES_FRAGMENT = `#version 150
precision mediump float;

in float f_Edge;
uniform float f_Inner;
uniform vec4 v_Color;
out vec4 v_FragData;

void main() {
  float v = 1.0 - abs(f_Edge);
  v = smoothstep(0.65, 0.7, v * f_Inner);
  v_FragData = mix(v_Color, vec4(0.0), v);
}` + "\x00"

const LINES_VERTEX = `#version 150
in vec2 v_Position;
in vec2 v_Normal;
in float f_Miter;
uniform float f_Thickness;
uniform mat4 m_ModelView;
uniform mat4 m_Projection;
out float f_Edge;

void main() {
    f_Edge = sign(f_Miter);

    //push the point along its normal by half thickness
    vec2 position = v_Position.xy + vec2(v_Normal * f_Thickness/2.0 * f_Miter);
    gl_Position = m_Projection * m_ModelView * vec4(position, 0.0, 1.0);
}` + "\x00"

const SPRITE_FRAGMENT = `#version 150
precision mediump float;

uniform sampler2D TextureUnit;
in vec2 v_TextureCoordinates;
in vec4 v_BaseColor;
out vec4 v_FragData;

void main() {
  vec4 color = texture(TextureUnit, v_TextureCoordinates);
  //if (color.a < 0.1) {
  //  discard;
  //}
  // This is really hacky
  if (v_BaseColor.a > 0.1 && color.r == 1.0 && color.g == 100.0/255.0 && color.b == 1.0) {
    v_FragData = v_BaseColor;
  } else {
    v_FragData = color;
  }
}` + "\x00"

const SPRITE_VERTEX = `#version 150

in vec3 v_Translation;
in vec3 v_Rotation;
in vec3 v_Scale;
in vec4 v_Color;

in mat4 m_PointAdjustment;
in mat4 m_TextureAdjustment;

uniform mat4 m_ProjectionMatrix;

out vec4 v_BaseColor;
out vec2 v_TextureCoordinates;

const vec2 Points[] = vec2[6](
  vec2(-0.5, -0.5),
  vec2( 0.5,  0.5),
  vec2(-0.5,  0.5),
  vec2(-0.5, -0.5),
  vec2( 0.5, -0.5),
  vec2( 0.5,  0.5)
);

const vec2 TexturePoints[] = vec2[6](
  vec2(0.0, 0.0),
  vec2(1.0, 1.0),
  vec2(0.0, 1.0),
  vec2(0.0, 0.0),
  vec2(1.0, 0.0),
  vec2(1.0, 1.0)
);

void main() {
  mat4 Translation = mat4(
    vec4(1.0, 0.0, 0.0, v_Translation.x),
    vec4(0.0, 1.0, 0.0, v_Translation.y),
    vec4(0.0, 0.0, 1.0, v_Translation.z),
    vec4(0.0, 0.0, 0.0,             1.0)
  );

  mat4 Scale = mat4(
    vec4(v_Scale.x,       0.0,       0.0, 0.0),
    vec4(      0.0, v_Scale.y,       0.0, 0.0),
    vec4(      0.0,       0.0, v_Scale.z, 0.0),
    vec4(      0.0,       0.0,       0.0, 1.0)
  );

  float rotCos = float(cos(v_Rotation.x));
  float rotSin = float(sin(v_Rotation.x));

  mat4 Rotation = mat4(
    vec4(rotCos, -rotSin, 0.0, 0.0),
    vec4(rotSin,  rotCos, 0.0, 0.0),
    vec4(   0.0,     0.0, 1.0, 0.0),
    vec4(   0.0,     0.0, 0.0, 1.0)
  );

  v_BaseColor = v_Color;
  v_TextureCoordinates = (vec4(TexturePoints[gl_VertexID], 0.0, 1.0) *
     m_TextureAdjustment).xy;

  gl_Position =  m_ProjectionMatrix *
      (vec4(Points[gl_VertexID], 0.0, 1.0) *
      m_PointAdjustment *
      Scale *
      Rotation *
      Translation);
}` + "\x00"

const TEXT_FRAGMENT = `#version 150
precision mediump float;

uniform sampler2D u_TextureUnit;
in vec2 v_TextureCoordinates;
out vec4 v_FragData;

void main()
{
    v_FragData = texture(u_TextureUnit, v_TextureCoordinates);
}` + "\x00"

const TEXT_VERTEX = `#version 150

in vec4 a_Position;
in vec2 a_TextureCoordinates;

uniform mat4 m_ProjectionMatrix;
uniform vec3 v_Trans;
uniform vec3 v_Scale;
out vec2 v_TextureCoordinates;

void main()
{
    mat4 trans;
    trans[0] = vec4(1,0,0,0);
    trans[1] = vec4(0,1,0,0);
    trans[2] = vec4(0,0,1,0);
    trans[3] = vec4(v_Trans.x,v_Trans.y,v_Trans.z,1);

    mat4 scale;
    scale[0] = vec4(v_Scale.x,0,0,0);
    scale[1] = vec4(0,v_Scale.y,0,0);
    scale[2] = vec4(0,0,v_Scale.z,0);
    scale[3] = vec4(0,0,0,1);

    v_TextureCoordinates = a_TextureCoordinates;
    gl_Position = m_ProjectionMatrix * trans * scale * a_Position;
}` + "\x00"