Golang C.GLdouble函数代码示例

//void glMap1d (GLenum target, float64 u1, float64 u2, int stride, int order, const float64 *points)
func Map1d(target GLenum, u1 float64, u2 float64, stride int, order int, points []float64) {
	if len(points) == 0 {
		panic("Invalid points size")
	}
	C.glMap1d(C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2),
		C.GLint(stride), C.GLint(order), (*C.GLdouble)(&points[0]))
}

func Perspective(fovy, aspect, zNear, zFar float64) {
	C.gluPerspective(
		C.GLdouble(fovy),
		C.GLdouble(aspect),
		C.GLdouble(zNear),
		C.GLdouble(zFar),
	)
}

// Project object coordinates to screen coordinates.
func Project(objx, objy, objz float64, model, proj []float64, view []int32) (x, y, z float64) {
	var wx, wy, wz C.GLdouble
	C.gluProject(
		C.GLdouble(objx), C.GLdouble(objy), C.GLdouble(objz), (*C.GLdouble)(&model[0]),
		(*C.GLdouble)(&proj[0]), (*C.GLint)(&view[0]), &wx, &wy, &wz,
	)
	return float64(wx), float64(wy), float64(wz)
}

// Project screen coordinates to object coordinates.
func Unproject(wx, wy, wz float64, model, proj []float64, view []int32) (objx, objy, objz float64) {
	var ox, oy, oz C.GLdouble
	C.gluUnProject(
		C.GLdouble(wx), C.GLdouble(wy), C.GLdouble(wz), (*C.GLdouble)(&model[0]),
		(*C.GLdouble)(&proj[0]), (*C.GLint)(&view[0]), &ox, &oy, &oz,
	)
	return float64(ox), float64(oy), float64(oz)
}

//void glMap2d (GLenum target, float64 u1, float64 u2, int ustride, int uorder, float64 v1, float64 v2, int vstride, int vorder, const float64 *points)
func Map2d(target GLenum, u1 float64, u2 float64, ustride int, uorder int, v1 float64, v2 float64, vstride int, vorder int, points []float64) {
	if len(points) == 0 {
		panic("Invalid points size")
	}
	C.glMap2d(C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(ustride),
		C.GLint(uorder), C.GLdouble(v1), C.GLdouble(v2), C.GLint(vstride),
		C.GLint(vorder), (*C.GLdouble)(&points[0]))
}

func LookAt(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ float64) {
	C.gluLookAt(
		C.GLdouble(eyeX),
		C.GLdouble(eyeY),
		C.GLdouble(eyeZ),
		C.GLdouble(centerX),
		C.GLdouble(centerY),
		C.GLdouble(centerZ),
		C.GLdouble(upX),
		C.GLdouble(upY),
		C.GLdouble(upZ),
	)
}

func init() {
	//
	right[0], front[1], top[2] = 1.0, 1.0, 1.0
	matrix[3][3] = 1.
	for l := 0; l < MaxL; l++ {
		lightSource[l] = vect.New()
	}
	w := 2.0 * math.Pi / float64(nLamp)
	sin[0], cos[0] = C.GLdouble(0.0), C.GLdouble(1.0)
	sin[nLamp], cos[nLamp] = sin[0], cos[0]
	for g := 1; g < nLamp; g++ {
		sin[g] = C.GLdouble(math.Sin(float64(g) * w))
		cos[g] = C.GLdouble(math.Cos(float64(g) * w))
	}
	sin[nLamp+1], sin[1] = cos[nLamp+1], cos[1]
	//  C.glDepthFunc (C.GL_LESS) // default
	C.glEnable(C.GL_DEPTH_TEST)
	C.glShadeModel(C.GL_SMOOTH)
	for i := 0; i < 3; i++ {
		lmAmb[i] = C.GLfloat(0.2)
	} // default: 0.2
	lmAmb[3] = C.GLfloat(1.0) // default: 1.0
	C.glLightModelfv(C.GL_LIGHT_MODEL_AMBIENT, &lmAmb[0])
	for i := 0; i < 3; i++ {
		mAmbi[i] = C.GLfloat(0.2)
	} // default: 0.2
	mAmbi[3] = C.GLfloat(1.0) // default: 1.0
	//  C.glLightModelfv (C.GL_LIGHT_MODEL_TWO_SIDE, 1)
	C.glMaterialfv(C.GL_FRONT_AND_BACK, C.GL_AMBIENT_AND_DIFFUSE, &mAmbi[0])
	for i := 0; i < 3; i++ {
		mDiff[i] = C.GLfloat(0.8)
	} // default: 0.8
	mDiff[3] = C.GLfloat(1.0) // default: 1.0
	w = 1.
	C.glClearDepth(C.GLclampd(w))
	//  C.glMaterialfv (C.GL_FRONT_AND_BACK, C.GL_DIFFUSE, mDiff)
	//  C.glColorMaterial (C.GL_FRONT_AND_BACK, C.GL_DIFFUSE)
	//  C.glColorMaterial (C.GL_FRONT, C.GL_AMBIENT)
	C.glColorMaterial(C.GL_FRONT_AND_BACK, C.GL_AMBIENT_AND_DIFFUSE)
	C.glEnable(C.GL_COLOR_MATERIAL)
	C.glEnable(C.GL_LIGHTING)
	initialize()
}

func lamp(n uint) {
	//
	if !lightInitialized[n] {
		return
	}
	xx, yy, zz := lightSource[n].Coord3()
	x, y, z := C.GLdouble(xx), C.GLdouble(yy), C.GLdouble(zz)
	r := C.GLdouble(0.1)
	C.glBegin(TRIANGLE_FAN)
	C.glColor3ub(C.GLubyte(lightColour[n].R), C.GLubyte(lightColour[n].G), C.GLubyte(lightColour[n].B))
	C.glNormal3d(C.GLdouble(0.0), C.GLdouble(0.0), C.GLdouble(-1.0))
	C.glVertex3d(C.GLdouble(x), C.GLdouble(y), C.GLdouble(z+r))
	r0 := r * sin[1]
	z0 := z + r*cos[1]
	for l := 0; l <= nLamp; l++ {
		C.glNormal3d(-sin[1]*cos[l], -sin[1]*sin[l], -cos[1])
		C.glVertex3d(x+r0*cos[l], y+r0*sin[l], z0)
	}
	C.glEnd()
	C.glBegin(QUAD_STRIP)
	var r1, z1 C.GLdouble
	for b := 1; b <= nLamp/2-2; b++ {
		r0, z0 = r*sin[b], z+r*cos[b]
		r1, z1 = r*sin[b+1], z+r*cos[b+1]
		for l := 0; l <= nLamp; l++ {
			C.glNormal3d(-sin[b+1]*cos[l], -sin[b+1]*sin[l], -cos[b+1])
			C.glVertex3d(x+r1*cos[l], y+r1*sin[l], z1)
			C.glNormal3d(-sin[b]*cos[l], -sin[b]*sin[l], -cos[b])
			C.glVertex3d(x+r0*cos[l], y+r0*sin[l], z0)
		}
	}
	C.glEnd()
	C.glBegin(TRIANGLE_FAN)
	C.glNormal3d(0., 0., 1.)
	C.glVertex3d(x, y, z-r)
	r0, z0 = r*sin[1], z-r*cos[1]
	b := nLamp/2 - 1
	for l := 0; l <= nLamp; l++ {
		C.glNormal3d(-sin[b]*cos[l], -sin[b]*sin[l], -cos[b])
		C.glVertex3d(x+r0*cos[l], y+r0*sin[l], z0)
	}
	C.glEnd()
}

func UnProject(winX, winY, winZ float64, model, proj *[16]float64, view *[4]int32) (float64, float64, float64) {
	var ox, oy, oz C.GLdouble

	m := (*C.GLdouble)(unsafe.Pointer(model))
	p := (*C.GLdouble)(unsafe.Pointer(proj))
	v := (*C.GLint)(unsafe.Pointer(view))

	C.gluUnProject(
		C.GLdouble(winX),
		C.GLdouble(winY),
		C.GLdouble(winZ),
		m,
		p,
		v,
		&ox,
		&oy,
		&oz,
	)

	return float64(ox), float64(oy), float64(oz)
}

func Init(fern float64) { // called by points.Start ()
	//
	const (
		D   = 2.0 // -fache Bildschirmbreite
		nah = C.GLdouble(0.2)
	)
	if !initialized {
		initialize()
	}
	C.glMatrixMode(C.GL_PROJECTION)
	C.glLoadIdentity()
	deg := D * math.Atan((0.5/D)/scr.Proportion())
	deg /= 0.9 // experimentelle Weitwinkelkorrektur
	var m [4][4]C.GLdouble
	m[1][1] = 1.0 / C.GLdouble(math.Tan(deg)) // Cot
	m[0][0] = m[1][1] / C.GLdouble(scr.Proportion())
	//  delta:= C.GLdouble(fern) - nah
	//  m[2][2] = - (C.GLdouble(fern) + nah) / delta
	//  m[2][3] = GLdouble(-1.0)
	//  m[3][2] = -2. * nah * C.GLdouble(fern) / delta
	m[2][2] = C.GLdouble(-1.0)
	m[2][3] = C.GLdouble(-1.0)
	m[3][2] = C.GLdouble(-1.0) * nah
	C.glMultMatrixd(&m[0][0])
	//  q:= C.GLdouble(0.75)
	//  GLFrustum (-1.0 * nah, 1.0 * nah, -q * nah, q * nah, 1.0 * nah, C.GLdouble(fern))
	C.glMatrixMode(C.GL_MODELVIEW)
}

func Write0() {
	//
	if !initialized {
		initialize()
	}
	if !scr.UnderX() {
		ker.Stop(pack, 1)
	}
	C.glMatrixMode(C.GL_MODELVIEW)
	C.glLoadIdentity()
	for i := 0; i < 3; i++ {
		matrix[i][0] = C.GLdouble(right[i])
		matrix[i][1] = C.GLdouble(top[i])
		matrix[i][2] = C.GLdouble(-front[i])
	}
	C.glMultMatrixd(&matrix[0][0])
	C.glTranslated(C.GLdouble(-eye[0]), C.GLdouble(-eye[1]), C.GLdouble(-eye[2]))
	C.glClear(C.GL_COLOR_BUFFER_BIT + C.GL_DEPTH_BUFFER_BIT)
	for n := uint(0); n < MaxL; n++ {
		if lightInitialized[n] {
			ActualizeLight(n)
		}
	}
	C.glBegin(POINTS)
	nn = 0
}

// Project screen coordinates to object coordinates.
func Unproject4(wx, wy, wz, clipw float64, model, proj []float64, view []int32, near, far float64) (objx, objy, objz, objw float64) {
	var ox, oy, oz, ow C.GLdouble
	C.gluUnProject4(
		C.GLdouble(wx), C.GLdouble(wy), C.GLdouble(wz), C.GLdouble(clipw),
		(*C.GLdouble)(&model[0]), (*C.GLdouble)(&proj[0]), (*C.GLint)(&view[0]),
		C.GLdouble(near), C.GLdouble(far), &ox, &oy, &oz, &ow,
	)
	return float64(ox), float64(oy), float64(oz), float64(ow)
}

//void glTexGend (GLenum coord, GLenum pname, float64 param)
func TexGend(coord GLenum, pname GLenum, param float64) {
	C.glTexGend(C.GLenum(coord), C.GLenum(pname), C.GLdouble(param))
}

func Ortho2D(left, right, bottom, top float64) {
	C.gluOrtho2D(C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top))
}

func PickMatrix(x, y, delx, dely float64, viewport []int32) {
	C.gluPickMatrix(C.GLdouble(x), C.GLdouble(y), C.GLdouble(delx),
		C.GLdouble(dely), (*C.GLint)(&viewport[0]))
}