本文整理汇总了Python中OpenGL.arrays.vbo.VBO类的典型用法代码示例。如果您正苦于以下问题:Python VBO类的具体用法?Python VBO怎么用?Python VBO使用的例子?那么, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了VBO类的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: loadsquirrel
def loadsquirrel(self):
# When loading the data, pad the normals to 4 floats (16bytes) since GPUs hate unaligned memory.
obj = wf.ObjFileParser("squirrel.obj", padnormals = 4)
self.objscale = 1 / np.max(obj.scale / 2)
self.objcenter = obj.minpos + (obj.scale / 2)
self.obj_mat = hm.scale(hm.identity(),
[self.objscale * 0.2] * 3)
self.obj_mat = hm.translation(self.obj_mat,
-self.objcenter)
# Generate a GL compatible indexed vertex buffer for the object
self.vbdata, ibdata = obj.generateIndexedBuffer([0,1], np.uint16)
vbdata = self.vbdata
self.elementnum = np.shape(ibdata)[0]
# VAO
self.vertobj = glGenVertexArrays(1)
glBindVertexArray(self.vertobj)
# Setup the VBO for the vertex data.
self.vertbuf = VBO(vbdata, GL_STATIC_DRAW, GL_ARRAY_BUFFER)
self.vertbuf.bind()
glVertexAttribPointer(self.positionloc, 4, GL_FLOAT, GL_TRUE, 8 * 4, ctypes.c_void_p(0))
glVertexAttribPointer(self.normalloc, 4, GL_FLOAT, GL_TRUE, 8 * 4, ctypes.c_void_p(16))
glEnableVertexAttribArray(self.positionloc)
glEnableVertexAttribArray(self.normalloc)
# Indexbuffer
self.indexbuf = VBO(ibdata, GL_STATIC_DRAW, GL_ELEMENT_ARRAY_BUFFER)
self.indexbuf.bind()
glBindVertexArray(0)
self.vertbuf.unbind()
self.indexbuf.unbind()
#Animation init...
self.rotation = 0
示例2: VolumeObject
class VolumeObject(object):
def __init__(self, stack, spacing):
self.active = True
self.stack_object = StackObject(stack, spacing)
shape = self.stack_object.shape
self.vao = glGenVertexArrays(1)
glBindVertexArray(self.vao)
tl = np.array((shape[2]*spacing[0], # x
shape[1]*spacing[1], # y
shape[0]*spacing[2])) # z
# Vertex buffer: corners of cube.
# x, y, z, texture_x, texture_y, texture_z
vb = [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], # Corner 0.
[tl[0], 0.0, 0.0, 1.0, 0.0, 0.0],
[0.0, tl[1], 0.0, 0.0, 1.0, 0.0],
[tl[0], tl[1], 0.0, 1.0, 1.0, 0.0],
[0.0, 0.0, tl[2], 0.0, 0.0, 1.0],
[tl[0], 0.0, tl[2], 1.0, 0.0, 1.0],
[0.0, tl[1], tl[2], 0.0, 1.0, 1.0],
[tl[0], tl[1], tl[2], 1.0, 1.0, 1.0]] # Corner 7.
vb = np.array(vb, dtype=np.float32)
vb = vb.flatten()
# Triangles of cube.
idx_out = np.array([[0, 2, 1], [2, 3, 1], # Triangle 0, triangle 1.
[1, 4, 0], [1, 5, 4],
[3, 5, 1], [3, 7, 5],
[2, 7, 3], [2, 6, 7],
[0, 6, 2], [0, 4, 6],
[5, 6, 4], [5, 7, 6]], # Triangle 10, triangle 11.
dtype=np.uint32)
self.vtVBO = VBO(vb)
self.vtVBO.bind()
sc = 1.0/la.norm(tl)
c = 0.5*tl
self.transform = np.array(((sc, 0.0, 0.0, -sc*c[0]),
(0.0, sc, 0.0, -sc*c[1]),
(0.0, 0.0, sc, -sc*c[2]),
(0.0, 0.0, 0.0, 1.0)))
self.tex_transform = np.array(((1.0/tl[0], 0.0, 0.0, 0.0),
(0.0, 1.0/tl[1], 0.0, 0.0),
(0.0, 0.0, 1.0/tl[2], 0.0),
(0.0, 0.0, 0.0, 1.0)))
glBindVertexArray(0)
self.elVBO = VBO(idx_out, target=GL_ELEMENT_ARRAY_BUFFER)
self.elCount = len(idx_out.flatten())
def update_stack(self, stack):
self.stack_object.update_stack(stack)
示例3: _initializeGL
def _initializeGL(self):
self.initialized = True
self.__filled_vao = VAO()
self.__outline_vao = VAO()
with self.__filled_vao, self.parent._sq_vbo:
vbobind(self.parent._filled_shader, self.parent._sq_vbo.data.dtype, "vertex").assign()
# Use a fake array to get a zero-length VBO for initial binding
filled_instance_array = numpy.ndarray(0, dtype=self.parent._filled_instance_dtype)
self.filled_instance_vbo = VBO(filled_instance_array)
with self.__filled_vao, self.filled_instance_vbo:
vbobind(self.parent._filled_shader, self.parent._filled_instance_dtype, "pos", div=1).assign()
vbobind(self.parent._filled_shader, self.parent._filled_instance_dtype, "r", div=1).assign()
vbobind(self.parent._filled_shader, self.parent._filled_instance_dtype, "r_inside_frac_sq", div=1).assign()
vbobind(self.parent._filled_shader, self.parent._filled_instance_dtype, "color", div=1).assign()
with self.__outline_vao, self.parent._outline_vbo:
vbobind(self.parent._outline_shader, self.parent._outline_vbo.data.dtype, "vertex").assign()
# Build instance for outline rendering
# We don't have an inner 'r' for this because we just do two instances per vertex
# Use a fake array to get a zero-length VBO for initial binding
outline_instance_array = numpy.ndarray(0, dtype=self.parent._outline_instance_dtype)
self.outline_instance_vbo = VBO(outline_instance_array)
with self.__outline_vao, self.outline_instance_vbo:
vbobind(self.parent._outline_shader, self.parent._outline_instance_dtype, "pos", div=1).assign()
vbobind(self.parent._outline_shader, self.parent._outline_instance_dtype, "r", div=1).assign()
vbobind(self.parent._outline_shader, self.parent._outline_instance_dtype, "color", div=1).assign()
示例4: __init__
def __init__(self, draw_type=GL_QUADS):
self.count = 0
self.color_data = []
self.position_data = []
self.color_buffer = VBO(np.array([]))
self.position_buffer = VBO(np.array([]))
self.draw_type = draw_type
示例5: bind
def bind(self):
"""
bind the vbo to the gl context.
needs to be done before accessing the vbo.
"""
GLVBO.bind(self)
for att in self.attributes:
gl.glEnableVertexAttribArray( att.location )
示例6: init
def init(self):
self.vertex_buffer = VBO(self.vertices, 'GL_STATIC_DRAW')
self.vertex_color_buffer = VBO(self.colors.repeat(2, 0), 'GL_STATIC_DRAW') # each pair of vertices shares the color
if self.arrows_enabled:
self.arrow_buffer = VBO(self.arrows, 'GL_STATIC_DRAW')
self.arrow_color_buffer = VBO(self.colors.repeat(3, 0), 'GL_STATIC_DRAW') # each triplet of vertices shares the color
self.initialized = True
示例7: initializeGL
def initializeGL(self, gls):
self.gls = gls
# Basic solid-color program
self.prog = self.gls.shader_cache.get("vert2", "frag1")
self.mat_loc = GL.glGetUniformLocation(self.prog, "mat")
self.col_loc = GL.glGetUniformLocation(self.prog, "color")
# Build a VBO for rendering square "drag-handles"
self.vbo_handles_ar = numpy.ndarray(4, dtype=[("vertex", numpy.float32, 2)])
self.vbo_handles_ar["vertex"] = numpy.array(corners) * HANDLE_HALF_SIZE
self.vbo_handles = VBO(self.vbo_handles_ar, GL.GL_STATIC_DRAW, GL.GL_ARRAY_BUFFER)
self.vao_handles = VAO()
with self.vbo_handles, self.vao_handles:
vbobind(self.prog, self.vbo_handles_ar.dtype, "vertex").assign()
# Build a VBO/VAO for the perimeter
# We don't initialize it here because it is updated every render
# 4 verticies for outside perimeter
# 6 verticies for each dim
self.vbo_per_dim_ar = numpy.zeros(16, dtype=[("vertex", numpy.float32, 2)])
self.vbo_per_dim = VBO(self.vbo_per_dim_ar, GL.GL_DYNAMIC_DRAW, GL.GL_ARRAY_BUFFER)
self.vao_per_dim = VAO()
with self.vao_per_dim, self.vbo_per_dim:
vbobind(self.prog, self.vbo_per_dim_ar.dtype, "vertex").assign()
示例8: __init__
def __init__(self, src, actor=None):
Component.__init__(self, actor)
# TODO Include a mesh name (e.g. 'Dragon') as ID as well as src (e.g. '../res/models/Dragon.obj')
self.src = src
self.filepath = Context.getInstance().getResourcePath('models', src)
# OpenGL version-dependent code (NOTE assumes major version = 3)
self.vao = None
if Context.getInstance().GL_version_minor > 0: # 3.1 (or greater?)
self.vao = glGenVertexArrays(1)
else: # 3.0 (or less?)
self.vao = GLuint(0)
glGenVertexArrays(1, self.vao)
glBindVertexArray(self.vao)
self.loadModel(self.filepath)
self.vbo = VBO(self.meshData, GL_STATIC_DRAW)
self.vbo.bind()
glEnableVertexAttribArray(0)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6*4, self.vbo+0)
glEnableVertexAttribArray(1)
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6*4, self.vbo+12)
self.ebo = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.ebo)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, len(self.elements)*4, self.elements, GL_STATIC_DRAW)
示例9: initializeGL
def initializeGL(self):
# Working VBO that will contain glyph data
self.vbo = VBO(numpy.ndarray(0, dtype=self.text_render.buffer_dtype), GL.GL_DYNAMIC_DRAW, GL.GL_ARRAY_BUFFER)
self.vao = VAO()
with self.vao, self.vbo:
self.text_render.b1.assign()
self.text_render.b2.assign()
self.__vbo_needs_update = True
示例10: initializeGL
def initializeGL(self):
self.__vao = VAO()
# Lookup for vertex positions
self.__vert_vbo_dtype = numpy.dtype([("vertex", numpy.float32, 2)])
self.__vert_vbo = VBO(numpy.ndarray(0, dtype=self.__vert_vbo_dtype),
GL.GL_DYNAMIC_DRAW)
self.__vert_vbo_current = False
self.__index_vbo_dtype = numpy.uint32
self.__index_vbo = VBO(numpy.ndarray(0, dtype=self.__index_vbo_dtype), GL.GL_DYNAMIC_DRAW, GL.GL_ELEMENT_ARRAY_BUFFER)
self.__index_vbo_current = False
self.__shader = self.__gls.shader_cache.get("vert2", "frag1")
with self.__vao, self.__vert_vbo:
vbobind(self.__shader, self.__vert_vbo_dtype, "vertex").assign()
self.__index_vbo.bind()
示例11: __init__
def __init__(self, stl_data, batchh=None):
''' initialise model data'''
vert, norm = stl_data
self.vertices = numpy.array(vert, dtype=GLfloat)
self.normals = numpy.array(norm, dtype=GLfloat)
self.vertex_buffer = VBO(self.vertices, 'GL_STATIC_DRAW')
self.normal_buffer = VBO(self.normals, 'GL_STATIC_DRAW')
# calculate model scale
self.corner = self.vertices.transpose().min(1)
self.corner2 = self.vertices.transpose().max(1)
self.scale = abs(self.corner) + abs(self.corner2)
self.scale = max(self.scale[0], self.scale[1], self.scale[2])
print 'STL File loaded in: ', loadtime
print 'Object information'
print 'corner 1: ', self.corner
print 'corner 2: ', self.corner2
print 'object scale: ', self.scale
示例12: __init__
def __init__(self, data, parent=None, **kw):
"""
Constructor, initialization
"""
QGLWidget.__init__(self, parent)
self.setFormat(QGLFormat(QGL.SampleBuffers))
self.setMinimumSize(500,300)#300
self.setMouseTracking(True)
self.setFocusPolicy(Qt.StrongFocus)
self.data=data
vertexes=[]
colors=[]
from utils.misc import IceAndFire
maxY=max(map(max, [log10(el.y_data) for el in data]))
maxX=max(map(max, [el.x_data for el in data]))
rtmax=max([z.rtmin for z in data])
for el in data:
for i, x in enumerate(el.x_data):
c=IceAndFire.getQColor(log10(el.y_data[i])/maxY)
colors.append(c)
vertexes.append([(x*2*self.corner_)/maxX, (el.rt*2*self.corner_)/rtmax])
from OpenGL.arrays.vbo import VBO
self.vertexes= VBO(array(vertexes,'f'))
self.colors=VBO(array(colors,'f'))
self.mode = "None" # "ZOOMING", "PANNING", "NONE"
self.lastpos = QPoint()
self.counter_trans_x = 0
self.counter_trans_y = 0
self.defaultColors = {'ticks':(0.,0.,0.,0.),
'axes':(0.,0.,0.,0.),
'curves':(0.,0.,1.,0.),
'backgroundColor':(1.,1.,1.,1.)
}
#self.axes=self.drawAxes()
self.transformationMatrix = self.setupTransformationMatrix(self.width(),
self.height())
示例13: __init__
def __init__(self, dtype, shader, glhint):
self.__dtype = dtype
self.vao = VAO()
self.batch_vbo = VBO(numpy.array([], dtype=dtype), glhint)
with self.vao, self.batch_vbo:
vbobind(shader, dtype, "vertex").assign()
self.clear()
示例14: __init__
def __init__(self,
data,
attributes,
segment,
bufferSize,
target=gl.GL_ARRAY_BUFFER,
usage=gl.GL_STATIC_DRAW):
self.target = target
self.usage = usage
if data==None or data.size==0:
self.bind = doNothing
self.bindAttributes = doNothing
self.unbind = doNothing
return
GLVBO.__init__(self,
data=data,
usage=usage,
target=target,
size=bufferSize)
self.segment = segment
# GLVertexAttribute instances
self.attributes = []
# queued slices
self.slices = []
self.DUMMY = False
# remember attribute locations in the shader
for att in attributes:
att.location = gl.glGetAttribLocation(segment.shaderProgram, att.name)
if att.location!=-1:
self.attributes.append(att)
else:
print "WARNING: cannot find attribute %s in shader" % att.name
示例15: RenderBatch
class RenderBatch(object):
def __init__(self, draw_type=GL_QUADS):
self.count = 0
self.color_data = []
self.position_data = []
self.color_buffer = VBO(np.array([]))
self.position_buffer = VBO(np.array([]))
self.draw_type = draw_type
def draw2d(self, points, color=(0, 0, 0, 1), rotation=0, center=(0, 0)):
n = len(points)
self.count += n
if not isinstance(color[0], (tuple, list)):
color = [color]*n
if rotation:
transform = psi.calc.rotation_matrix(rotation)
temp = np.array(points) - center
temp = transform.dot(temp.T).T + center
points = temp.tolist()
self.color_data.extend(color)
self.position_data.extend(points)
def clear(self):
self.position_data = []
self.color_data = []
self.count = 0
def render(self):
self.color_buffer.set_array(np.array(self.color_data, dtype='float32'))
self.position_buffer.set_array(np.array(self.position_data, dtype='float32'))
self.color_buffer.bind()
glColorPointer(4, GL_FLOAT, 0, self.color_buffer)
self.position_buffer.bind()
glVertexPointer(2, GL_FLOAT, 0, self.position_buffer)
glEnableClientState(GL_VERTEX_ARRAY)
glEnableClientState(GL_COLOR_ARRAY)
glDrawArrays(self.draw_type, 0, self.count)
glDisableClientState(GL_COLOR_ARRAY)
glDisableClientState(GL_VERTEX_ARRAY)