// Ported from GLUT's samples.  Original copyright below applies.

/* Copyright (c) Mark J. Kilgard, 1996. */

/* This program is freely distributable without licensing fees 
   and is provided without guarantee or warrantee expressed or 
   implied. This program is -not- in the public domain. */

/* This program is a response to a question posed by Gil Colgate
   <gcolgate@sirius.com> about how lengthy a program is required using
   OpenGL compared to using  Direct3D immediate mode to "draw a
   triangle at screen coordinates 0,0, to 200,200 to 20,200, and I
   want it to be blue at the top vertex, red at the left vertex, and
   green at the right vertex".  I'm not sure how long the Direct3D
   program is; Gil has used Direct3D and his guess is "about 3000
   lines of code". */

package main

import (
	"gl"
	"glut"
	"exp/draw"
	"image"
	"freetype-go.googlecode.com/hg/freetype/raster"
	"draw2d.googlecode.com/svn/trunk/draw2d/src/pkg/draw2d"
	"postscript-go.googlecode.com/svn/trunk/postscript-go/src/pkg/postscript"
	"fmt"
)

type GLPainter struct {
	// The Porter-Duff composition operator.
	Op draw.Op
	// The 16-bit color to paint the spans.
	cr, cg, cb uint8
	ca         uint32
}

const M16 uint32 = 1<<16 - 1
const M32 uint32 = 1<<32 - 1

// Paint satisfies the Painter interface by painting ss onto an image.RGBA.
func (p *GLPainter) Paint(ss []raster.Span, done bool) {
	gl.Begin(gl.LINES)
	for _, s := range ss {
		ma := s.A >> 16
		a := ma * p.ca / M16
		gl.Color4ub(p.cr, p.cg, p.cb, uint8(a>>8))
		gl.Vertex2i(s.X0, s.Y)
		gl.Vertex2i(s.X1, s.Y)
	}
	gl.End()
}

// SetColor sets the color to paint the spans.
func (p *GLPainter) SetColor(c image.Color) {
	r, g, b, a := c.RGBA()
	if a == 0 {
		p.cr = 0
		p.cg = 0
		p.cb = 0
		p.ca = a
	} else {
		p.cr = uint8((r * M16 / a) >> 8)
		p.cg = uint8((g * M16 / a) >> 8)
		p.cb = uint8((b * M16 / a) >> 8)
		p.ca = a
	}
}

// NewRGBAPainter creates a new RGBAPainter for the given image.
func NewGLPainter() *GLPainter {
	return &GLPainter{}
}


func TestDrawCubicCurve(gc draw2d.GraphicContext) {
	// draw a cubic curve
	x, y := 25.6, 128.0
	x1, y1 := 102.4, 230.4
	x2, y2 := 153.6, 25.6
	x3, y3 := 230.4, 128.0

	gc.SetStrokeColor(image.NRGBAColor{0, 0, 0, 0xff})
	gc.SetLineWidth(10)
	gc.MoveTo(x, y)
	gc.CubicCurveTo(x1, y1, x2, y2, x3, y3)
	gc.Stroke()

	gc.SetStrokeColor(image.NRGBAColor{0xFF, 0x33, 0x33, 0x99})

	gc.SetLineWidth(6)
	// draw segment of curve
	gc.MoveTo(x, y)
	gc.LineTo(x1, y1)
	gc.MoveTo(x2, y2)
	gc.LineTo(x3, y3)
	gc.Stroke()
}

var (
	width, height int
)

func reshape(w, h int) {
	/* Because Gil specified "screen coordinates" (presumably with an
	   upper-left origin), this short bit of code sets up the coordinate
	   system to correspond to actual window coodrinates.  This code
	   wouldn't be required if you chose a (more typical in 3D) abstract
	   coordinate system. */
	gl.ClearColor(1, 1, 1, 1)
	//fmt.Println(gl.GetString(gl.EXTENSIONS))
	gl.Viewport(0, 0, w, h)                       /* Establish viewing area to cover entire window. */
	gl.MatrixMode(gl.PROJECTION)                  /* Start modifying the projection matrix. */
	gl.LoadIdentity()                             /* Reset project matrix. */
	gl.Ortho(0, float64(w), 0, float64(h), -1, 1) /* Map abstract coords directly to window coords. */
	gl.Scalef(1, -1, 1)                           /* Invert Y axis so increasing Y goes down. */
	gl.Translatef(0, float32(-h), 0)              /* Shift origin up to upper-left corner. */
	gl.Enable(gl.BLEND)
	gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)

	width, height = w, h
}

func display() {
	gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
	gl.LineWidth(1)
	p := NewGLPainter()
	fmt.Println("draw")
	gc := draw2d.NewImageGraphicContextFromPainter(p, image.Rect(0, 0, width, height))
	gc.Translate(0, 380)
	gc.Scale(1, -1)
	gc.Translate(0, -380)
	interpreter := postscript.NewInterpreter(gc)
	interpreter.ExecuteFile("../../tiger.ps")
	gl.Flush() /* Single buffered, so needs a flush. */
}

func main() {
	glut.Init()
	glut.InitWindowSize(800, 800)
	glut.CreateWindow("single triangle")

	glut.DisplayFunc(display)
	glut.ReshapeFunc(reshape)
	glut.MainLoop()
}