function widget:GetInfo()
  return {
    name      = "!GL test",
    desc      = "Shaded spinning cube",
    author    = "q",
    date      = "Jan 8, 2007",
    license   = "GNU GPL, v2 or later",
    layer     = -3,
    enabled   = false  --  loaded by default?
  }
end

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------

local m = 0

local A = { -1,  1,  1}
local B = {  1,  1,  1}
local C = {  1, -1,  1}
local D = { -1, -1,  1}
local E = { -1,  1, -1}
local F = {  1,  1, -1}
local G = {  1, -1, -1}
local H = { -1, -1, -1}

local startTime = Spring.GetTimer()

local vsx, vsy = 0, 0

local screenTexture = 0
function widget:ViewResize(viewSizeX, viewSizeY)
  vsx = viewSizeX
  vsy = viewSizeY

  if (screenTexture) then
    gl.DeleteTexture(screenTexture)
  end
  screenTexture = gl.CreateTexture(vsx, vsy, {
    min_filter = GL.NEAREST,
    mag_filter = GL.NEAREST,
  })
  if (screenTexture == nil) then
    Spring.Echo("Removing grey widget, bad screen texture")
    widgetHandler:RemoveWidget()
    return
  end
end

function widget:Initialize()
  if (gl.CreateShader == nil) then
    Spring.Echo("Removing grey widget, no shaders")
    widgetHandler:RemoveWidget()
    return
  end
  cubeListNumber = gl.CreateList(function()
      gl.BeginEnd(GL.QUADS, function() 
          Cube(A, B, C, D, E, F, G, H)
        end
      )
    end
  )
  greyShader = gl.CreateShader({
    fragment = [[
      uniform sampler2D tex0;
      uniform float time;

      void main(void)
      {
        const vec2 txcd = vec2(gl_TexCoord[0]);
        const vec3 color = vec3(texture2D(tex0, txcd));
        const float illum = dot(color, vec3(0.299, 0.587, 0.114));
        gl_FragColor = vec4(vec3(illum), 1.0) * vec4(1, 0.8, 0.6, 1);
        gl_FragColor = gl_FragColor + noise4(gl_TexCoord[0]);

        float noise = fract(time) * 1.25 * (txcd.x + txcd.y + txcd.x * txcd.y);
        noise = fract(1234567.89 * noise);
        noise = fract(345 * noise);
        gl_FragColor += 0.5 * vec4(noise);
      }
    ]],
    uniform = {
      time = 1,
    },
    uniformInt = {
      tex0 = 0,
    }
  })
  timeLoc = gl.GetUniformLocation(greyShader, 'time')
end


function widget:Shutdown()
  gl.DeleteList(cubeListNumber)
  gl.DeleteTexture(screenTexture)
  if (gl.DeleteShader) then
    gl.DeleteShader(greyShader)
  end
end


function widget:DrawScreen()
  m = m + 1
  local n = math.sin(m/100)
  local diffTime = Spring.DiffTimers(Spring.GetTimer(), startTime)
  gl.MatrixMode(GL.MODELVIEW) 
  gl.PushMatrix()
  gl.Scale(44, 44, 44)
  gl.Translate( 9+n,  8+n, 20+2*n)
  gl.Rotate(m, 0, 1, 0)
  gl.Rotate(m, 0, 0, 1)
  gl.Culling( false )
  gl.DepthTest( true )
  gl.DepthMask( true )
  gl.MatrixMode(GL.TEXTURE)
  gl.PushMatrix()
  --gl.Rotate(-45, 0, 0, 1)
  gl.CopyToTexture(screenTexture, 0, 0, 0, 0, vsx, vsy)
  gl.Blending(false)
  gl.UseShader(greyShader)
  gl.Texture(screenTexture)
  gl.Uniform(timeLoc, diffTime)
  gl.CallList(cubeListNumber)
  gl.PopMatrix()
  gl.PopMatrix()
  gl.ResetMatrices()
  gl.UseShader(0)
  gl.Texture(false)
  gl.Blending(true)
end


function Cube(A, B, C, D, E, F, G, H)
  Face(A, B, C, D)
  Face(E, F, G, H)
  Face(B, F, G, C)
  Face(A, E, H, D)
  Face(A, B, F, E)
  Face(D, C, G, H)
end


function Face(A, B, C, D)
  gl.TexCoord(0, 1)
  gl.Vertex(A[1], A[2], A[3])
  gl.TexCoord(1, 1)
  gl.Vertex(B[1], B[2], B[3])
  gl.TexCoord(1, 0)
  gl.Vertex(C[1], C[2], C[3])
  gl.TexCoord(0, 0)
  gl.Vertex(D[1], D[2], D[3])
end