本文整理汇总了Golang中github.com/go-gl/gl/v3/3-core/gl.BindVertexArray函数的典型用法代码示例。如果您正苦于以下问题:Golang BindVertexArray函数的具体用法?Golang BindVertexArray怎么用?Golang BindVertexArray使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了BindVertexArray函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: Draw
func (t *Text) Draw() {
if t.IsDebug {
t.BoundingBox.Draw()
}
gl.UseProgram(t.font.program)
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, t.font.textureID)
// uniforms
gl.Uniform1i(t.font.fragmentTextureUniform, 0)
gl.Uniform4fv(t.font.colorUniform, 1, &t.color[0])
gl.Uniform2fv(t.font.finalPositionUniform, 1, &t.finalPosition[0])
gl.UniformMatrix4fv(t.font.orthographicMatrixUniform, 1, false, &t.font.OrthographicMatrix[0])
gl.UniformMatrix4fv(t.font.scaleMatrixUniform, 1, false, &t.scaleMatrix[0])
// draw
drawCount := int32(t.RuneCount * 6)
if drawCount > int32(t.eboIndexCount) {
drawCount = int32(t.eboIndexCount)
}
if drawCount < 0 {
drawCount = 0
}
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.BindVertexArray(t.vao)
gl.DrawElements(gl.TRIANGLES, drawCount, gl.UNSIGNED_INT, nil)
gl.BindVertexArray(0)
gl.Disable(gl.BLEND)
}
示例2: CreateSprite
func CreateSprite(t Texture) (s Sprite, err error) {
s.texture = t
s.shader, err = CreateShader(vertexShader, fragmentShader)
if err != nil {
return s, err
}
gl.GenBuffers(1, &s.ebo)
gl.GenBuffers(1, &s.vbo)
gl.GenVertexArrays(1, &s.vao)
gl.BindVertexArray(s.vao)
gl.BindBuffer(gl.ARRAY_BUFFER, s.vbo)
gl.BufferData(gl.ARRAY_BUFFER, len(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, s.ebo)
gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(indices)*4, gl.Ptr(indices), gl.STATIC_DRAW)
err = s.shader.SetAttrib("vert", 2, gl.FLOAT, 4*4, 0)
err = s.shader.SetAttrib("vertTexCoord", 2, gl.FLOAT, 4*4, 2*4)
gl.BindVertexArray(0)
return s, err
}
示例3: LoadText
func LoadText(f *Font) (t *Text) {
t = new(Text)
t.font = f
// text hover values
// "resting state" of a text object is the min scale
t.ScaleMin = 1.0
t.ScaleMax = 1.1
t.SetScale(1)
// size of glfloat
glfloat_size := int32(4)
// stride of the buffered data
xy_count := int32(2)
stride := xy_count + int32(2)
gl.GenVertexArrays(1, &t.vao)
gl.GenBuffers(1, &t.vbo)
gl.GenBuffers(1, &t.ebo)
// vao
gl.BindVertexArray(t.vao)
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, t.font.textureID)
// vbo
// specify the buffer for which the VertexAttribPointer calls apply
gl.BindBuffer(gl.ARRAY_BUFFER, t.vbo)
gl.EnableVertexAttribArray(t.font.centeredPosition)
gl.VertexAttribPointer(
t.font.centeredPosition,
2,
gl.FLOAT,
false,
glfloat_size*stride,
gl.PtrOffset(0),
)
gl.EnableVertexAttribArray(t.font.uv)
gl.VertexAttribPointer(
t.font.uv,
2,
gl.FLOAT,
false,
glfloat_size*stride,
gl.PtrOffset(int(glfloat_size*xy_count)),
)
// ebo
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, t.ebo)
// i am guessing that order is important here
gl.BindVertexArray(0)
gl.BindBuffer(gl.ARRAY_BUFFER, 0)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0)
return t
}
示例4: SetString
func (t *Text) SetString(fs string, argv ...interface{}) {
var indices []rune
if len(argv) == 0 {
indices = []rune(fs)
} else {
indices = []rune(fmt.Sprintf(fs, argv...))
}
if len(indices) == 0 {
return
}
if t.MaxRuneCount > 0 && len(indices) > t.MaxRuneCount+1 {
indices = indices[0:t.MaxRuneCount]
}
t.String = string(indices)
// ebo, vbo data
glfloat_size := int32(4)
t.vboIndexCount = len(indices) * 4 * 2 * 2 // 4 indexes per rune (containing 2 position + 2 texture)
t.eboIndexCount = len(indices) * 6 // each rune requires 6 triangle indices for a quad
t.RuneCount = len(indices)
t.vboData = make([]float32, t.vboIndexCount, t.vboIndexCount)
t.eboData = make([]int32, t.eboIndexCount, t.eboIndexCount)
// generate the basic vbo data and bounding box
t.X1 = Point{0, 0}
t.X2 = Point{0, 0}
t.makeBufferData(indices)
// find the centered position of the bounding box
lowerLeft := t.getLowerLeft()
// reposition the vbo data so that it is centered at (0,0)
// according to the orthographic projection being used
t.setDataPosition(lowerLeft)
if t.IsDebug {
fmt.Printf("bounding box %v %v\n", t.X1, t.X2)
fmt.Printf("lower left\n%v\n", lowerLeft)
fmt.Printf("text vbo data\n%v\n", t.vboData)
fmt.Printf("text ebo data\n%v\n", t.eboData)
}
gl.BindVertexArray(t.vao)
gl.BindBuffer(gl.ARRAY_BUFFER, t.vbo)
gl.BufferData(
gl.ARRAY_BUFFER, int(glfloat_size)*t.vboIndexCount, gl.Ptr(t.vboData), gl.DYNAMIC_DRAW)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, t.ebo)
gl.BufferData(
gl.ELEMENT_ARRAY_BUFFER, int(glfloat_size)*t.eboIndexCount, gl.Ptr(t.eboData), gl.DYNAMIC_DRAW)
gl.BindVertexArray(0)
// not necesssary, but i just want to better understand using vertex arrays
gl.BindBuffer(gl.ARRAY_BUFFER, 0)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0)
// SetString can be called at anytime. we want to make sure that if the user is updating the text,
// the previous position will be maintained
t.SetPosition(t.SetPositionX, t.SetPositionY)
}
示例5: Draw
func (b *BoundingBox) Draw() {
gl.UseProgram(b.program)
// uniforms
gl.Uniform2fv(b.finalPositionUniform, 1, &b.finalPosition[0])
gl.UniformMatrix4fv(b.orthographicMatrixUniform, 1, false, &b.font.OrthographicMatrix[0])
// draw
gl.BindVertexArray(b.vao)
gl.DrawElements(gl.TRIANGLES, int32(b.eboIndexCount), gl.UNSIGNED_INT, nil)
gl.BindVertexArray(0)
}
示例6: Draw
func (s *Sprite) Draw() {
s.shader.Use()
s.texture.Bind()
gl.BindVertexArray(s.vao)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, s.ebo)
gl.BindBuffer(gl.ARRAY_BUFFER, s.vbo)
//gl.DrawArrays(gl.TRIANGLES, 0, 3)
gl.DrawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, gl.PtrOffset(0))
gl.BindVertexArray(0)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0)
}
示例7: UpdatePoints
// Updating the list of Points that this LineRender should be rendering.
func (lr *LineRender) UpdatePoints(points []Point) {
// Determining the buffer mode.
var mode uint32
if lr.static {
mode = gl.STATIC_DRAW
} else {
mode = gl.DYNAMIC_DRAW
}
// Setting the number of points.
lr.points = int32(len(points))
// Generating the buffer data.
vboData := generateVBOData(points)
eboData := generateEBOData(len(points))
// Filling the buffer data.
gl.BindVertexArray(lr.vao)
gl.BindBuffer(gl.ARRAY_BUFFER, lr.vbo)
gl.BufferData(gl.ARRAY_BUFFER, len(vboData)*4, gl.Ptr(vboData), mode)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, lr.ebo)
gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(eboData)*4, gl.Ptr(eboData), mode)
}
示例8: Render
// Rendering this LineRender.
func (lr *LineRender) Render() {
// Binding the appropriate information.
gl.BindVertexArray(lr.vao)
gl.BindBuffer(gl.ARRAY_BUFFER, lr.vbo)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, lr.ebo)
gl.UseProgram(lr.shaderProgram)
// Loading up vertex attributes.
vertAttrib := uint32(gl.GetAttribLocation(lr.shaderProgram, gl.Str("vert\x00")))
gl.EnableVertexAttribArray(vertAttrib)
gl.VertexAttribPointer(vertAttrib, 2, gl.FLOAT, false, 2*4, gl.PtrOffset(0))
// Line thickness information.
gl.Uniform1f(
gl.GetUniformLocation(lr.shaderProgram, gl.Str("in_thickness\x00")),
lr.weight)
// Fragment shader color information.
gl.Uniform4f(
gl.GetUniformLocation(lr.shaderProgram, gl.Str("in_color\x00")),
lr.color.Red,
lr.color.Green,
lr.color.Blue,
lr.color.Alpha)
gl.BindFragDataLocation(lr.shaderProgram, 0, gl.Str("out_color\x00"))
// Performing the render.
gl.DrawElements(gl.LINE_STRIP, lr.points, gl.UNSIGNED_INT, nil)
}
示例9: CreateRenderObject
// Creating a RenderObject with a given shaderProgram, texture, and set of
// vertices.
func CreateRenderObject(shaderProgram ShaderProgram, texture Texture, vertices []float32) *RenderObject {
renderObject := new(RenderObject)
// Creating the basic information.
renderObject.shaderProgram = uint32(shaderProgram)
renderObject.texture = uint32(texture)
gl.GenVertexArrays(1, &renderObject.vao)
gl.GenBuffers(1, &renderObject.vbo)
gl.GenBuffers(1, &renderObject.ebo)
// Filling the RenderObject with information.
gl.BindVertexArray(renderObject.vao)
gl.BindBuffer(gl.ARRAY_BUFFER, renderObject.vbo)
gl.BufferData(gl.ARRAY_BUFFER, len(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, renderObject.ebo)
vertOrder := []uint32{
0, 1, 2,
2, 3, 0,
}
gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(vertOrder)*4, gl.Ptr(vertOrder), gl.STATIC_DRAW)
// Loading up vertex attributes.
vertAttrib := uint32(gl.GetAttribLocation(renderObject.shaderProgram, gl.Str("vert\x00")))
gl.EnableVertexAttribArray(vertAttrib)
gl.VertexAttribPointer(vertAttrib, 2, gl.FLOAT, false, 4*4, gl.PtrOffset(0))
// Loading up texture attributes.
texAttrib := uint32(gl.GetAttribLocation(renderObject.shaderProgram, gl.Str("vertTexCoord\x00")))
gl.EnableVertexAttribArray(texAttrib)
gl.VertexAttribPointer(texAttrib, 2, gl.FLOAT, false, 4*4, gl.PtrOffset(2*4))
return renderObject
}
示例10: Delete
func (c *Context) Delete() {
cleanupSound()
gl.BindVertexArray(0)
gl.DeleteVertexArrays(1, &c.VAO)
if c.window != nil {
c.window.Destroy()
}
glfw.Terminate()
}
示例11: createVAO
func (p *Program) createVAO() error {
gl.GenVertexArrays(1, &p.vao)
if e := gl.GetError(); e != 0 {
return fmt.Errorf("ERROR gl.GenVertexArray %X", e)
}
gl.BindVertexArray(p.vao)
if e := gl.GetError(); e != 0 {
return fmt.Errorf("ERROR array.Bind %X", e)
}
return nil
}
示例12: CreateVertexArray
//CreateVertexArray is a "constructor" of vertex array, hence returns a opengl
//mesh, specifically a cube for testing
func CreateVertexArray() VertexArray {
var vertexArray VertexArray
cubeVertices := vertexArray.PosData()
gl.GenVertexArrays(1, &vertexArray.handleVAO)
gl.BindVertexArray(vertexArray.handleVAO)
gl.GenBuffers(1, &vertexArray.handleVBO)
gl.BindBuffer(gl.ARRAY_BUFFER, vertexArray.handleVBO)
gl.BufferData(gl.ARRAY_BUFFER, len(cubeVertices)*4, gl.Ptr(cubeVertices), gl.STATIC_DRAW)
return vertexArray
}
示例13: CreateVAO
func CreateVAO() (array uint32, err error) {
gl.GenVertexArrays(1, &array)
if e := gl.GetError(); e != 0 {
err = fmt.Errorf("ERROR gl.GenVertexArray %X", e)
return
}
gl.BindVertexArray(array)
if e := gl.GetError(); e != 0 {
err = fmt.Errorf("ERROR array.Bind %X", e)
return
}
return
}
示例14: Render
func (renderObject *RenderObject) Render() {
gl.BindVertexArray(renderObject.vao)
gl.BindBuffer(gl.ARRAY_BUFFER, renderObject.vbo)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, renderObject.ebo)
gl.UseProgram(renderObject.shaderProgram)
// Binding the texture.
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, renderObject.texture)
gl.BindFragDataLocation(renderObject.shaderProgram, 0, gl.Str("outputColor\x00"))
// Drawing the object.
gl.DrawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, nil)
}
示例15: CreateBuffers
func CreateBuffers() {
var err error
program, err = MakeProgram(VertexShader(), FragmentShader())
// defer program.Delete()
if err != nil {
fmt.Println("Error loading shaders: " + err.Error())
panic("error loading shaders")
}
gl.BindFragDataLocation(program, 0, gl.Str("color\x00"))
MVPid = gl.GetUniformLocation(program, gl.Str("MVP\x00"))
lightpositionID = gl.GetUniformLocation(program, gl.Str("light.position\x00"))
lightintensitiesID = gl.GetUniformLocation(program, gl.Str("light.intensities\x00"))
lightattenuationID = gl.GetUniformLocation(program, gl.Str("light.attenuation\x00"))
lightambientCoeficientID = gl.GetUniformLocation(program, gl.Str("light.ambientCoeficient\x00"))
cameraPositionID = gl.GetUniformLocation(program, gl.Str("cameraPosition\x00"))
// View := mathgl.LookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
// viewM = View
gl.DepthFunc(gl.LEQUAL)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
// var vao uint32
gl.GenVertexArrays(1, &vao)
gl.BindVertexArray(vao)
// var vbo uint32
gl.GenBuffers(1, &vbo)
// gl.GenBuffers(1, &elementvbo)
// fmt.Println(program)
gl.UseProgram(program)
for idx, img := range aggregateImages {
bindAggregateImage(img, idx)
}
}