func drawSegment(s SegmentShape) {
verts := []float32{
float32(s.A().X), float32(s.A().Y),
float32(s.B().X), float32(s.B().Y),
}
gl.VertexPointer(2, 0, verts)
gl.DrawArrays(gl.LINES, 0, 2)
}
func drawCircle(s CircleShape) {
center := s.Center()
radius := s.Radius()
angle := s.Body().Angle()
gl.VertexPointer(2, 0, circleVerts)
gl.PushMatrix()
gl.Translated(center.X, center.Y, 0.0)
gl.Rotated(angle*180.0/math.Pi, 0.0, 0.0, 1.0)
gl.Scaled(radius, radius, 1.0)
gl.DrawArrays(gl.LINE_STRIP, 0, len(circleVerts)/2)
gl.PopMatrix()
}
func initGl() {
h := float64(height) / float64(width)
gl.Viewport(0, 0, width, height)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Frustum(-1.0, 1.0, -h, h, 5.0, 60.0)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.Translatef(0.0, 0.0, -6.0)
gl.EnableClientState(gl.VERTEX_ARRAY)
gl.EnableClientState(gl.TEXTURE_COORD_ARRAY)
gl.VertexPointer(3, 0, &vertices[0][0])
gl.TexCoordPointer(2, 0, &texCoords[0][0])
}
func drawPoly(s PolyShape) {
verts := s.VertsWorldFloat64()
gl.VertexPointer(2, 0, verts)
gl.DrawArrays(gl.LINE_LOOP, 0, len(verts)/2)
}
func testPlot(dimension, order int) {
var (
iterations float64 = 0
start_t = time.Now()
split time.Time = start_t
total time.Duration
fps float64 = 1.0
new_attractor, redraw bool = true, true
npoints int = 1e5
coeffs []float64
//offsets, offset_coeffs []float64
start Matrix = MakeMatrix(1, int(math.Max(3, float64(dimension))))
points, points2/*, points3*/ Matrix
//attractor = gl.GenLists(1);
)
//offsets = make([]float64, ncoeffs(order))
//offset_coeffs = make([]float64, ncoeffs(order))
//coeffs = make([]float64, dimension + nCoeffs(order, dimension) * dimension)
//for i := range offsets { offsets[i] += rand.Float64() }
for handleEvents(&new_attractor, &redraw, &npoints) {
xoff += xvel / fps
yoff += yvel / fps
zoff += zvel / fps
xrot += xrotvel / fps
yrot += yrotvel / fps
zrot += zrotvel / fps
scale += svel / fps
if new_attractor {
coeffs, start = find_map_with_L(dimension, order, 0.1, 0.4)
redraw = true
new_attractor = false
}
if redraw {
points = MakePointMatrix(makeMapFn(dimension, order, coeffs), start, 500, npoints)
points2 = MakeMatrix(npoints, points.Height())
//points3 = MakeMatrix(npoints, points.Height())
redraw = false
fmt.Println("Redraw", npoints, "points")
}
//points2 = points
//RotationXW(xwrot).Apply(points, points2)
//RotationYW(xwrot + 0.25).Apply(points2, points3)
//RotationZW(xwrot + 0.50).Apply(points3, points2)
if dimension == 4 {
RotationZW(xwrot).Apply(points, points2)
xwrot += 0.05
ApplyW(points2, points2)
} else {
points2 = points
}
gl.Enable(gl.BLEND)
gl.Enable(gl.POINT_SMOOTH)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.PointSize(1.0)
gl.LoadIdentity()
gl.Rotated(xrot, 1, 0, 0)
gl.Rotated(yrot, 0, 1, 0)
gl.Rotated(zrot, 0, 0, 1)
gl.Scaled(scale, scale, scale)
gl.Translated(xoff, yoff, zoff)
gl.Color4d(1, 1, 1, 0.25)
gl.EnableClientState(gl.VERTEX_ARRAY)
if dimension > 3 {
gl.VertexPointer(3, (dimension-3)*32, points2.FlatCols())
} else {
gl.VertexPointer(3, 0, points2.FlatCols())
}
gl.DrawArrays(gl.POINTS, 0, points2.Width())
gl.DisableClientState(gl.VERTEX_ARRAY)
sdl.GL_SwapBuffers()
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
iterations++
if time.Since(split).Seconds() > 1.0 {
total = time.Since(start_t)
fps = iterations / total.Seconds()
fmt.Println(iterations, "iterations in", total.Seconds(), "gives",
fps, "fps")
split = time.Now()
}
}
}
