Example #1
0
func (me *Mesh) GpuUpload() (err error) {
	sizeVerts, sizeIndices := gl.Sizeiptr(4*len(me.raw.verts)), gl.Sizeiptr(4*len(me.raw.indices))
	me.GpuDelete()
	if sizeVerts > gl.Sizeiptr(me.meshBuffer.memSizeVertices) {
		err = errf("Cannot upload mesh '%v': vertex size (%vB) exceeds mesh buffer's available vertex memory (%vB)", me.Name, sizeVerts, me.meshBuffer.memSizeVertices)
	} else if sizeIndices > gl.Sizeiptr(me.meshBuffer.memSizeIndices) {
		err = errf("Cannot upload mesh '%v': index size (%vB) exceeds mesh buffer's available index memory (%vB)", me.Name, sizeIndices, me.meshBuffer.memSizeIndices)
	} else {
		me.meshBufOffsetBaseIndex, me.meshBufOffsetIndices, me.meshBufOffsetVerts = me.meshBuffer.offsetBaseIndex, me.meshBuffer.offsetIndices, me.meshBuffer.offsetVerts
		Diag.LogMeshes("Upload %v at voff=%v ioff=%v boff=%v", me.Name, me.meshBufOffsetVerts, me.meshBufOffsetIndices, me.meshBufOffsetBaseIndex)
		me.meshBuffer.glIbo.Bind()
		defer me.meshBuffer.glIbo.Unbind()
		me.meshBuffer.glVbo.Bind()
		defer me.meshBuffer.glVbo.Unbind()
		if err = me.meshBuffer.glVbo.SubData(gl.Intptr(me.meshBufOffsetVerts), sizeVerts, gl.Ptr(&me.raw.verts[0])); err == nil {
			me.meshBuffer.offsetVerts += int32(sizeVerts)
			if err = me.meshBuffer.glIbo.SubData(gl.Intptr(me.meshBufOffsetIndices), sizeIndices, gl.Ptr(&me.raw.indices[0])); err == nil {
				me.meshBuffer.offsetIndices += int32(sizeIndices)
				me.meshBuffer.offsetBaseIndex += int32(len(me.raw.indices))
				if err == nil {
					me.gpuSynced = true
				}
			}
		}
	}
	return
}
Example #2
0
func newMeshBuffer(name string, capacity int32) (me *MeshBuffer, err error) {
	me = &MeshBuffer{}
	me.Name = name
	me.meshIDs = make([]int, 0, 256)
	me.glVaos = make([]ugl.VertexArray, 16)
	numVerts, numIndices := capacity, capacity
	me.memSizeIndices = Core.Mesh.Buffers.MemSizePerIndex() * numIndices
	me.memSizeVertices = Core.Mesh.Buffers.MemSizePerVertex() * numVerts
	if err = me.glVbo.Recreate(gl.ARRAY_BUFFER, gl.Sizeiptr(me.memSizeVertices), ugl.PtrNil, gl.STATIC_DRAW); err == nil {
		err = me.glIbo.Recreate(gl.ELEMENT_ARRAY_BUFFER, gl.Sizeiptr(me.memSizeIndices), ugl.PtrNil, gl.STATIC_DRAW)
	}
	// if err == nil {
	// 	var ok bool
	// 	for i := 0; i < len(ogl.progs.All); i++ {
	// 		if err = me.setupVao(i); err != nil {
	// 			break
	// 		}
	// 	}
	// }
	if err != nil {
		me.dispose()
		me = nil
	}
	return
}
Example #3
0
func uploadGeometry(mesh *geometry) {
	gl.GenVertexArrays(1, &mesh.glVao)
	gl.BindVertexArray(mesh.glVao)
	gl.GenBuffers(1, &mesh.glVertBuf)
	gl.BindBuffer(gl.ARRAY_BUFFER, mesh.glVertBuf)
	gl.EnableVertexAttribArray(progPosAttrLoc)
	gl.VertexAttribPointer(progPosAttrLoc, 3, gl.FLOAT, gl.FALSE, 0, gl.Ptr(nil))
	gl.BufferData(gl.ARRAY_BUFFER, gl.Sizeiptr(4*len(mesh.glVerts)), gl.Ptr(&mesh.glVerts[0]), gl.STATIC_DRAW)
	gl.BindBuffer(gl.ARRAY_BUFFER, 0)
	gl.BindVertexArray(0)
}
Example #4
0
func (me *TextureBase) subImage(glTarget gl.Enum, x, y gl.Int, width, height gl.Sizei, ptr gl.Ptr) (err error) {
	if ptr != PtrNil {
		if Support.Textures.StreamUpdatesViaPixelBuffer {
			buf := NewPixelUnpackBuffer()
			defer buf.Dispose()
			buf.Recreate(0, gl.Sizeiptr(width*height*4), PtrNil, gl.STREAM_DRAW)
			buf.Bind()
			defer buf.Unbind()
			pbo := buf.Map(true, true)
			*pbo = gl.Ptr(ptr)
			buf.Unmap()
			err = Try.TexSubImage2D(glTarget, 0, x, y, width, height, me.PixelData.Format, me.PixelData.Type, PtrNil)
		} else {
			err = Try.TexSubImage2D(glTarget, 0, x, y, width, height, me.PixelData.Format, me.PixelData.Type, ptr)
		}
	}
	return
}