本文整理汇总了Golang中github.com/go-gl/gl.BufferData函数的典型用法代码示例。如果您正苦于以下问题:Golang BufferData函数的具体用法?Golang BufferData怎么用?Golang BufferData使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了BufferData函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: ReadTextureFromGPU
func (t *Texture) ReadTextureFromGPU() []byte {
t.Bind()
b := gl.GenBuffer()
b.Bind(gl.PIXEL_UNPACK_BUFFER)
gl.BufferData(gl.PIXEL_UNPACK_BUFFER, t.Width()*t.Height()*t.PixelSize(), 0, gl.STREAM_DRAW)
//gl.GetTexImage(t.target, 0, t.format, buffer)
b.Bind(gl.PIXEL_UNPACK_BUFFER)
gl.TexSubImage2D(t.target, 0, 0, 0, t.Width(), t.Height(), t.format, t.typ, unsafe.Pointer(uintptr(0)))
b.Bind(gl.PIXEL_UNPACK_BUFFER)
l := t.Width() * t.Height() * t.PixelSize()
gl.BufferData(gl.PIXEL_UNPACK_BUFFER, t.Width()*t.Height()*t.PixelSize(), 0, gl.STREAM_DRAW)
ptr := gl.MapBuffer(gl.PIXEL_UNPACK_BUFFER, gl.WRITE_ONLY)
var x []byte
s := (*reflect.SliceHeader)(unsafe.Pointer(&x))
s.Data = uintptr(ptr)
s.Len = l
s.Cap = l
gl.UnmapBuffer(gl.PIXEL_UNPACK_BUFFER)
return x
}
示例2: fill
func fill(canv *Canvas, alphaTex *glh.Texture, paint *Paint) {
gGl.GlColorConfig.SetColor(paint.fillColor)
defer gGl.GlColorConfig.Reset()
gGl.Activate(gGl.FillDrawer)
gl.ColorMask(true, true, true, true)
gl.StencilMask(0x3)
gl.StencilFunc(gl.LESS, 0, 0xff)
w, h := canv.W, canv.H
p := canv.toGLPoints([]Point{
iPt(0, 0),
iPt(w, 0),
iPt(w, h),
iPt(0, h),
})
vertices := []float32{
p[0].X, p[0].Y, 0, 1,
p[1].X, p[1].Y, 1, 1,
p[2].X, p[2].Y, 1, 0,
p[3].X, p[3].Y, 0, 0,
}
gl.BufferData(gl.ARRAY_BUFFER, len(vertices)*4, vertices, gl.STATIC_DRAW)
elements := []uint32{
0, 1, 2,
2, 3, 0,
}
gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(elements)*4, elements, gl.STATIC_DRAW)
glh.With(alphaTex, func() {
gl.DrawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, nil)
})
}
示例3: NewModel
// Create a new model from the given data slice.
func NewModel(vertices []Vertex, indices []uint32) (*Model, error) {
// TODO add error detection
m := new(Model)
m.vertices, m.indices = vertices, indices
m.program = &DefaultShaderProgram
m.vao = gl.GenVertexArray()
m.vao.Bind()
m.vbo = gl.GenBuffer()
m.vbo.Bind(gl.ARRAY_BUFFER)
m.ibo = gl.GenBuffer()
m.ibo.Bind(gl.ELEMENT_ARRAY_BUFFER)
vSize := int(unsafe.Sizeof(m.vertices[0]))
uSize := int(unsafe.Sizeof(uint32(0)))
gl.BufferData(gl.ARRAY_BUFFER, len(m.vertices)*vSize, &m.vertices[0],
gl.STATIC_DRAW)
gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(m.indices)*uSize, &m.indices[0],
gl.STATIC_DRAW)
posLoc.EnableArray()
colorLoc.EnableArray()
posLoc.AttribPointer(3, gl.FLOAT, false, vSize, uintptr(0))
colorLoc.AttribPointer(4, gl.FLOAT, false, vSize,
uintptr(int(unsafe.Sizeof(float32(0))*3)))
colorLoc.DisableArray()
posLoc.DisableArray()
m.vbo.Unbind(gl.ARRAY_BUFFER)
m.ibo.Unbind(gl.ELEMENT_ARRAY_BUFFER)
return m, nil
}
示例4: LoadMesh
func (self *OpenGLRenderer) LoadMesh(mesh *render.Mesh) {
if len(mesh.VertexList) == 0 {
log.Println("WARNING Stopping load of mesh [", mesh.Name, "] with no verticies")
return
}
vertexArrayObj := gl.GenVertexArray()
vertexArrayObj.Bind()
vertexBuffer := gl.GenBuffer()
vertexBuffer.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(mesh.VertexList)*4, mesh.VertexList, gl.STATIC_DRAW)
attribLoc := gl.AttribLocation(0)
attribLoc.EnableArray()
attribLoc.AttribPointer(3, gl.FLOAT, false, 0, nil)
if len(mesh.UVList) > 0 {
uvBuffer := gl.GenBuffer()
uvBuffer.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(mesh.UVList)*4, mesh.UVList, gl.STATIC_DRAW)
attribLoc := gl.AttribLocation(1)
attribLoc.EnableArray()
attribLoc.AttribPointer(2, gl.FLOAT, false, 0, nil)
mesh.UVBuffer = uvBuffer
} else if len(mesh.ColorList) > 0 {
colorBuffer := gl.GenBuffer()
colorBuffer.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(mesh.ColorList)*4, mesh.ColorList, gl.STATIC_DRAW)
attribLoc := gl.AttribLocation(1)
attribLoc.EnableArray()
attribLoc.AttribPointer(3, gl.FLOAT, false, 0, nil)
mesh.ColorBuffer = colorBuffer
}
if len(mesh.IndexList) > 0 {
indexBuffer := gl.GenBuffer()
indexBuffer.Bind(gl.ELEMENT_ARRAY_BUFFER)
gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(mesh.IndexList)*4, mesh.IndexList, gl.STATIC_DRAW)
mesh.IndexBuffer = indexBuffer
}
mesh.VertexArrayObj = vertexArrayObj
mesh.VertexBuffer = vertexBuffer
}
示例5: SetVertices
func (b *VertexBuffer) SetVertices(src []byte, usage Usage) error {
gl.VertexArray(0).Bind()
b.bind()
// set size of buffer and invalidate it
gl.BufferData(gl.ARRAY_BUFFER, len(src), nil, usage.gl())
if len(src) > 0 {
// if unmap returns false, the buffer we wrote to is no longer valid and we
// need to try again. though, this is apparently uncommon in modern
// drivers. this means it is not feasible to compute/copy vertices directly
// into the mapped buffer. however, it would be nice to provide a
// failure-capable API to do this.
const maxretries = 5
retries := 0
for ; retries < maxretries; retries++ {
ptr := gl.MapBuffer(gl.ARRAY_BUFFER, gl.WRITE_ONLY)
slicehdr := reflect.SliceHeader{
Data: uintptr(ptr),
Len: len(src),
Cap: len(src),
}
dest := *(*[]byte)(unsafe.Pointer(&slicehdr))
copy(dest, src)
if gl.UnmapBuffer(gl.ARRAY_BUFFER) {
break
}
}
if retries == maxretries {
return errMapBufferFailed
}
}
b.count = len(src) / b.format.Stride()
return nil
}
示例6: MakeBuffer
func MakeBuffer(target gl.GLenum, size int, data interface{}) gl.Buffer {
buffer := gl.GenBuffer()
buffer.Bind(target)
gl.BufferData(target, size, data, gl.STATIC_DRAW)
gl.BufferUnbind(target)
return buffer
}
示例7: newVertexBuffer
func newVertexBuffer(geometry Shape) gl.Buffer {
result := []float32{}
faces := geometry.Faces()
vertices := geometry.Vertices()
if len(faces) > 0 {
// Handle faces
for _, face := range faces {
for i := 0; i < 3; i++ {
vertex := vertices[face.At(i)]
result = append(result, vertex.X(), vertex.Y(), vertex.Z())
}
}
} else {
// Handle plain vertices
for _, vertex := range geometry.Vertices() {
result = append(result, vertex.X(), vertex.Y(), vertex.Z())
}
}
glBuffer := gl.GenBuffer()
glBuffer.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(result)*3*4, result, gl.STATIC_DRAW)
return glBuffer
}
示例8: NewIndex
// NewIndex creates a new element index
func NewIndex(data []uint16) *Index {
glBuffer := gl.GenBuffer()
glBuffer.Bind(gl.ELEMENT_ARRAY_BUFFER)
gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(data)*int(glh.Sizeof(gl.UNSIGNED_SHORT)), data, gl.STATIC_DRAW)
return &Index{glBuffer: glBuffer, count: len(data)}
}
示例9: main
func main() {
if err := glfw.Init(); err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
return
}
defer glfw.Terminate()
glfw.OpenWindowHint(glfw.FsaaSamples, 4)
glfw.OpenWindowHint(glfw.OpenGLVersionMajor, 3)
glfw.OpenWindowHint(glfw.OpenGLVersionMinor, 3)
glfw.OpenWindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
if err := glfw.OpenWindow(1024, 768, 0, 0, 0, 0, 32, 0, glfw.Windowed); err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
return
}
gl.Init() // Can't find gl.GLEW_OK or any variation, not sure how to check if this worked
gl.GetError() // Ignore error
glfw.SetWindowTitle("Tutorial 02")
glfw.Enable(glfw.StickyKeys)
gl.ClearColor(0., 0., 0.4, 0.)
prog := helper.MakeProgram("SimpleVertexShader.vertexshader", "SimpleFragmentShader.fragmentshader")
vBufferData := [...]float32{
-1., -1., 0.,
1., -1., 0.,
0., 1., 0.}
vertexArray := gl.GenVertexArray()
vertexArray.Bind()
buffer := gl.GenBuffer()
buffer.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(vBufferData)*4, &vBufferData, gl.STATIC_DRAW)
// Equivalent to a do... while
for ok := true; ok; ok = (glfw.Key(glfw.KeyEsc) != glfw.KeyPress && glfw.WindowParam(glfw.Opened) == gl.TRUE) {
gl.Clear(gl.COLOR_BUFFER_BIT)
prog.Use()
attribLoc := gl.AttribLocation(0)
attribLoc.EnableArray()
buffer.Bind(gl.ARRAY_BUFFER)
attribLoc.AttribPointer(3, gl.FLOAT, false, 0, nil)
gl.DrawArrays(gl.TRIANGLES, 0, 3)
attribLoc.DisableArray()
glfw.SwapBuffers()
}
}
示例10: Initialize
func (r *Renderer) Initialize() {
r.vertices = []mapVertex{
{200, 200, 0, 1, 1, 1, 1, 0, 0},
{218, 200, 0, 1, 0, 0, 1, 0, 0},
}
vs, err := LoadShader(vertexShader, gl.VERTEX_SHADER)
if err != nil {
panic(err)
}
gs, err := LoadShader(geometryShader, gl.GEOMETRY_SHADER)
if err != nil {
panic(err)
}
fs, err := LoadShader(fragmentShader, gl.FRAGMENT_SHADER)
if err != nil {
panic(err)
}
gl.ClearColor(0, 1, 0, 0)
// Create the VAO
// GL 3+ allows us to store the vertex layout in a vertex array object (VAO).
r.vao = gl.GenVertexArray()
r.vao.Bind()
// Create VBO
r.vbo = gl.GenBuffer()
r.vbo.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(r.vertices)*4*9, r.vertices, gl.DYNAMIC_DRAW)
prog, err := LoadProgram(vs, gs, fs)
if err != nil {
panic(err)
}
prog.Use()
r.prog = prog
r.mvmLocation = r.prog.GetUniformLocation("modelview_matrix")
pos := r.prog.GetAttribLocation("in_position")
color := r.prog.GetAttribLocation("in_color")
texcoord := r.prog.GetAttribLocation("in_texcoord")
// FIXME: size math
pos.AttribPointer(3, gl.FLOAT, false, 9*4, nil)
color.AttribPointer(4, gl.FLOAT, false, 9*4, uintptr(3*4))
texcoord.AttribPointer(2, gl.FLOAT, false, 9*4, uintptr(7*4))
pos.EnableArray()
color.EnableArray()
texcoord.EnableArray()
}
示例11: draw
func (c *QuadraticCurve) draw(canv *Canvas) {
p := canv.toGLPoints(c.Points())
vertices := []float32{
p[0].X, p[0].Y, 0.0, 0.0,
p[1].X, p[1].Y, 0.5, 0.0,
p[2].X, p[2].Y, 1.0, 1.0,
}
gl.BufferData(gl.ARRAY_BUFFER, len(vertices)*4, vertices, gl.STATIC_DRAW)
gl.DrawArrays(gl.TRIANGLES, 0, 3)
}
示例12: render
func (d *DrawImage) render() error {
fn := func(idx int) (err error) {
defer func() {
//err = recover()
}()
vbuf := gl.GenBuffer()
vbuf.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(d.vertex[idx])*4, d.vertex[idx], gl.STATIC_DRAW)
panicGlError()
defer vbuf.Delete()
uvbuf := gl.GenBuffer()
uvbuf.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(d.uv[idx])*4, d.uv[idx], gl.STATIC_DRAW)
panicGlError()
defer uvbuf.Delete()
vloc := gl.AttribLocation(0)
vloc.EnableArray()
vbuf.Bind(gl.ARRAY_BUFFER)
vloc.AttribPointer(3, gl.FLOAT, false, 0, nil)
panicGlError()
defer vloc.DisableArray()
uvloc := gl.AttribLocation(1)
uvloc.EnableArray()
uvbuf.Bind(gl.ARRAY_BUFFER)
uvloc.AttribPointer(2, gl.FLOAT, false, 0, nil)
panicGlError()
defer uvloc.DisableArray()
gl.DrawArrays(gl.TRIANGLES, 0, 3)
return checkGlError()
}
if err := fn(0); err != nil {
return err
}
return fn(1)
}
示例13: update
// updateBuffer fills the OpenGL buffer IF NEEDED.
// It updates the buffer if the bufferdataClean flag is false.
// It is safe to call this method every frame via the concrete classes method
// UpdateBuffer: most of the time it will just return immediately.
func (buffer *baseBuffer) update(vertexdata interface{}) {
if buffer.bufferdataClean {
return
}
if buffer.name == 0 {
panic("tried to update buffer 0")
}
// Convert the Go-friendly data into OpenGL-friendly data.
oldSize := len(buffer.bufferdata)
bufferdata := new(bytes.Buffer)
err := binary.Write(bufferdata, endianness, vertexdata)
if err != nil {
panic(err)
}
buffer.bufferdata = bufferdata.Bytes()
buffer.bufferdataClean = true
newSize := len(buffer.bufferdata)
// Should we make the buffer bigger?
needBigger := newSize > oldSize
buffer.bind()
if needBigger {
// (Re)allocate a buffer.
gl.BufferData(
buffer.target,
len(buffer.bufferdata),
buffer.bufferdata,
buffer.usage,
)
if err := CheckGlError(); err != nil {
err.Description = "gl.BufferData"
panic(err)
}
} else {
// Re-use existing buffer.
gl.BufferSubData(
buffer.target,
0,
len(buffer.bufferdata),
buffer.bufferdata,
)
if err := CheckGlError(); err != nil {
err.Description = "gl.BufferSubData"
panic(err)
}
}
buffer.unbind()
}
示例14: initGL
func (video *SDLVideo) initGL() {
if gl.Init() != 0 {
panic(sdl.GetError())
}
gl.ClearColor(0.0, 0.0, 0.0, 1.0)
gl.Enable(gl.CULL_FACE)
gl.Enable(gl.DEPTH_TEST)
video.prog = createProgram(vertShaderSrcDef, fragShaderSrcDef)
posAttrib := video.prog.GetAttribLocation("vPosition")
texCoordAttr := video.prog.GetAttribLocation("vTexCoord")
video.textureUni = video.prog.GetAttribLocation("texture")
video.texture = gl.GenTexture()
gl.ActiveTexture(gl.TEXTURE0)
video.texture.Bind(gl.TEXTURE_2D)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
video.prog.Use()
posAttrib.EnableArray()
texCoordAttr.EnableArray()
vertVBO := gl.GenBuffer()
vertVBO.Bind(gl.ARRAY_BUFFER)
verts := []float32{-1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, 1.0, -1.0, 1.0}
gl.BufferData(gl.ARRAY_BUFFER, len(verts)*int(unsafe.Sizeof(verts[0])), &verts[0], gl.STATIC_DRAW)
textCoorBuf := gl.GenBuffer()
textCoorBuf.Bind(gl.ARRAY_BUFFER)
texVerts := []float32{0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0}
gl.BufferData(gl.ARRAY_BUFFER, len(texVerts)*int(unsafe.Sizeof(texVerts[0])), &texVerts[0], gl.STATIC_DRAW)
posAttrib.AttribPointer(2, gl.FLOAT, false, 0, uintptr(0))
texCoordAttr.AttribPointer(2, gl.FLOAT, false, 0, uintptr(0))
}
示例15: newTextVertexBuffer
func newTextVertexBuffer(geometry *TextGeometry) gl.Buffer {
result := []float32{}
vertices := geometry.Vertices
for _, vertex := range vertices {
result = append(result, vertex.X(), vertex.Y())
}
glBuffer := gl.GenBuffer()
glBuffer.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(result)*2*4, result, gl.STATIC_DRAW)
return glBuffer
}