/** Called from test harness/main */
void
PerfInit(void)
{
const GLenum filter = GL_LINEAR;
GLenum stat;
int i;
if (!PerfExtensionSupported("GL_EXT_framebuffer_object")) {
perf_printf("fboswitch: GL_EXT_framebuffer_object not supported\n");
exit(0);
}
/* setup VBO */
glGenBuffersARB(1, &VBO);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, VBO);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(vertices),
vertices, GL_STATIC_DRAW_ARB);
glVertexPointer(2, GL_FLOAT, sizeof(struct vertex), VOFFSET(x));
glTexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), VOFFSET(s));
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glGenFramebuffersEXT(2, FBO);
glGenTextures(2, Tex);
for (i = 0; i < 2; i++) {
/* setup texture */
glBindTexture(GL_TEXTURE_2D, Tex[i]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
TexSize, TexSize, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
/* setup fbo */
glBindFramebufferEXT(GL_FRAMEBUFFER, FBO[i]);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D, Tex[i], 0/*level*/);
stat = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (stat != GL_FRAMEBUFFER_COMPLETE_EXT) {
perf_printf("fboswitch: Error: incomplete FBO!\n");
exit(1);
}
/* clear the FBO */
glClear(GL_COLOR_BUFFER_BIT);
}
glEnable(GL_TEXTURE_2D);
}
void View::initScenePbo()
{
// Iterate through all of the objects
for( vector<SceneObject *>::iterator it = m_objects.begin(); it != m_objects.end(); it++ )
{
int bufferSize = (*it)->m_bumpResolution * (*it)->m_bumpResolution * sizeof(BGRA);
GLuint* ids = (*it)->m_pbo;
//generate two buffers to alternate between during updating for performance (halting)
glGenBuffersARB(2, ids);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, ids[m_pboIndexA]);
glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, bufferSize, 0, GL_STREAM_DRAW_ARB);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, ids[m_pboIndexB]);
glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, bufferSize, 0, GL_STREAM_DRAW_ARB);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
// Tell the scene object its pbo buffer
(*it)->setPboBuffers(ids);
}
}
static GLuint init_ibo(int n, const GLushort *data)
{
GLuint ibo;
GLsizei N = n * (n + 1) * 2 * sizeof (GLushort);
glGenBuffersARB(1, &ibo);
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, ibo);
glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, N, data, GL_STATIC_DRAW_ARB);
opengl_check("init_ibo");
return ibo;
}
static GLuint init_vbo(int n, const struct vertex *data)
{
GLuint vbo;
GLsizei N = (n + 1) * (n + 1) * sizeof (struct vertex);
glGenBuffersARB(1, &vbo);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, N, data, GL_STATIC_DRAW_ARB);
opengl_check("init_vbo");
return vbo;
}
void
piglit_init(int argc, char **argv)
{
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
piglit_require_extension("GL_ARB_vertex_buffer_object");
glGenBuffersARB(1, &vbo);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, 12 * sizeof(GLfloat),
NULL, GL_DYNAMIC_DRAW);
}
void meshVBO::load( vboType t, unsigned int sz, void* data )
{
type = vboEnumToType( t );
size = sz;
glGenBuffersARB( 1, &vboID );
glBindBufferARB( type, vboID );
glBufferDataARB( type, sz, data, GL_STATIC_DRAW );
glBindBufferARB( type, 0 );
assert( glGetError() == GL_NO_ERROR );
}
void DiGLIndexBuffer::WriteData(uint32 offset, uint32 length, const void* pSource, bool discardWholeBuffer /*= false*/)
{
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, mBufferId);
if (offset == 0 && length == mBufferSize)
{
glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, mBufferSize, pSource,
DiGLTypeMappings::GetGLUsage(mResUsage));
}
else
{
if (discardWholeBuffer)
{
glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, mBufferSize, NULL,
DiGLTypeMappings::GetGLUsage(mResUsage));
}
// Now update the real buffer
glBufferSubDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, offset, length, pSource);
}
}
void Flush(uint& buffer, int& vtxs) {
//上次才知道原来Flush还有冲厕所的意思QAQ
//OpenGL有个函数glFlush()，翻译过来就是GL冲厕所() ←_←
vtxs = Vertexes;
if (EnableShaders) {
for (int i = 0; i != shadercount; i++) {
glUseProgramObjectARB(shaderPrograms[i]);
}
}
if (Vertexes > 0) {
glBindBufferARB(GL_ARRAY_BUFFER_ARB, buffer);
if (Textured) {
if (Colored)
glBufferDataARB(GL_ARRAY_BUFFER_ARB, Vertexes * 8 * sizeof(float), VertexArray.data(), GL_STATIC_DRAW);
else
glBufferDataARB(GL_ARRAY_BUFFER_ARB, Vertexes * 5 * sizeof(float), VertexArray.data(), GL_STATIC_DRAW);
}
else {
if (Colored)
glBufferDataARB(GL_ARRAY_BUFFER_ARB, Vertexes * 6 * sizeof(float), VertexArray.data(), GL_STATIC_DRAW);
else
glBufferDataARB(GL_ARRAY_BUFFER_ARB, Vertexes * 3 * sizeof(float), VertexArray.data(), GL_STATIC_DRAW);
}
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
//重置
Init();
}
if (EnableShaders) glUseProgramObjectARB(0);
}
/* Create a vertex buffer object (VBO) to store data in video memory. */
uint ModelGL::createVBO (const void* data, int dataSize, uint target, uint usage) {
uint id = 0;
glGenBuffersARB (1, &id); // Create a vertex buffer object.
if (id == 0) { // Check for success.
printf ("[ERROR] VBO could not be created!\n");
return 0;
}
// Select new VBO, update data to video card and return ID.
glBindBufferARB (target, id);
glBufferDataARB (target, dataSize, data, usage);
return id;
}
void
CheckRender::allocateMemory( unsigned int width, unsigned int height, unsigned int bpp, bool bUsePBO)
{
// Create the PBO for readbacks
if (bUsePBO) {
glGenBuffersARB(1, &m_pboReadback);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, m_pboReadback);
glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, width*height*bpp, NULL, GL_STREAM_READ);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
}
m_pImageData = (unsigned char *)malloc(width*height*bpp); // This is the image data stored in system memory
}
void Patch::VBOUploadVertices()
{
if (renderMode == VBO) {
// Upload vertexBuffer
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertexBuffer);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, vertices.size() * sizeof(float), &vertices[0], GL_STATIC_DRAW_ARB);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
vboVerticesUploaded = true;
} else {
vboVerticesUploaded = false;
}
}
void VertexBuffer::writeData(uint offset,uint length,const void* pSource,bool discardWholeBuffer)
{
glBindBufferARB(GL_ARRAY_BUFFER,m_ui32BufferID);
if(discardWholeBuffer)
{
glBufferDataARB(GL_ARRAY_BUFFER,m_ui32VertexSize * m_ui32NumVertices,0,BufferManager::getGLUsage(m_Usage));
}
// Now update the real buffer
glBufferSubDataARB(GL_ARRAY_BUFFER,offset,length,pSource);
glBindBufferARB(GL_ARRAY_BUFFER,0);
}
void upload_image_data_to_opengl(unsigned char* raw_image_data,
CameraPixelCoding coding,
int device_number) {
unsigned char * gl_image_data;
static unsigned char* show_pixels=NULL;
GLuint textureId;
GLubyte* ptr;
textureId = textureId_all[device_number];
if (use_pbo) {
#ifdef USE_GLEW
glBindTexture(GL_TEXTURE_2D, textureId);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, tex_width, tex_height, gl_data_format, GL_UNSIGNED_BYTE, 0);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, PBO_stride*tex_height, 0, GL_STREAM_DRAW_ARB);
ptr = (GLubyte*)glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_WRITE_ONLY_ARB);
if(ptr) {
convert_pixels(raw_image_data, coding, PBO_stride, ptr, 1);
glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB); // release pointer to mapping buffer
}
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
#endif /* ifdef USE_GLEW */
} else {
if (show_pixels==NULL) {
/* allocate memory */
show_pixels = (unsigned char *)malloc( PBO_stride*height );
if (show_pixels==NULL) {
fprintf(stderr,"couldn't allocate memory in %s, line %d\n",__FILE__,__LINE__);
exit(1);
}
}
gl_image_data = convert_pixels(raw_image_data, coding, PBO_stride, show_pixels, 0);
glBindTexture(GL_TEXTURE_2D, textureId);
glTexSubImage2D(GL_TEXTURE_2D, /* target */
0, /* mipmap level */
0, /* x offset */
0, /* y offset */
width,
height,
gl_data_format, /* data format */
GL_UNSIGNED_BYTE, /* data type */
gl_image_data);
}
}
void* OpenGLTexture::lock(TextureUsage _access)
{
MYGUI_PLATFORM_ASSERT(mTextureID, "Texture is not created");
if (_access == TextureUsage::Read)
{
glBindTexture(GL_TEXTURE_2D, mTextureID);
mBuffer = new unsigned char[mDataSize];
glGetTexImage(GL_TEXTURE_2D, 0, mPixelFormat, GL_UNSIGNED_BYTE, mBuffer);
mLock = false;
return mBuffer;
}
// bind the texture
glBindTexture(GL_TEXTURE_2D, mTextureID);
if (!OpenGLRenderManager::getInstance().isPixelBufferObjectSupported())
{
//Fallback if PBO's are not supported
mBuffer = new unsigned char[mDataSize];
}
else
{
// bind the PBO
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, mPboID);
// Note that glMapBufferARB() causes sync issue.
// If GPU is working with this buffer, glMapBufferARB() will wait(stall)
// until GPU to finish its job. To avoid waiting (idle), you can call
// first glBufferDataARB() with NULL pointer before glMapBufferARB().
// If you do that, the previous data in PBO will be discarded and
// glMapBufferARB() returns a new allocated pointer immediately
// even if GPU is still working with the previous data.
glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, mDataSize, 0, mUsage);
// map the buffer object into client's memory
mBuffer = (GLubyte*)glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, mAccess);
if (!mBuffer)
{
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
glBindTexture(GL_TEXTURE_2D, 0);
MYGUI_PLATFORM_EXCEPT("Error texture lock");
}
}
mLock = true;
return mBuffer;
}
void
glmMakeVBOs(GLMmodel *model)
{
uint bytes, vertexFloats, i;
float *buffer;
vertexFloats = 3;
model->posOffset = 0;
if (model->numnormals > 0) {
assert(model->numnormals == model->numvertices);
model->normOffset = vertexFloats * sizeof(GLfloat);
vertexFloats += 3;
}
if (model->numtexcoords > 0) {
assert(model->numtexcoords == model->numvertices);
model->texOffset = vertexFloats * sizeof(GLfloat);
vertexFloats += 2;
}
model->vertexSize = vertexFloats;
bytes = (model->numvertices + 1) * vertexFloats * sizeof(float);
buffer = (float *) malloc(bytes);
for (i = 0; i < model->numvertices; i++) {
/* copy vertex pos */
uint j = 0;
buffer[i * vertexFloats + j++] = model->vertices[i * 3 + 0];
buffer[i * vertexFloats + j++] = model->vertices[i * 3 + 1];
buffer[i * vertexFloats + j++] = model->vertices[i * 3 + 2];
if (model->numnormals > 0) {
buffer[i * vertexFloats + j++] = model->normals[i * 3 + 0];
buffer[i * vertexFloats + j++] = model->normals[i * 3 + 1];
buffer[i * vertexFloats + j++] = model->normals[i * 3 + 2];
}
if (model->numtexcoords > 0) {
buffer[i * vertexFloats + j++] = model->texcoords[i * 2 + 0];
buffer[i * vertexFloats + j++] = model->texcoords[i * 2 + 1];
}
}
glGenBuffersARB(1, &model->vbo);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, model->vbo);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, bytes, buffer, GL_STATIC_DRAW_ARB);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
free(buffer);
}
void cVertexBufferVBO::UpdateData(tVertexFlag aTypes, bool abIndices)
{
GLenum usageType = GL_STATIC_DRAW_ARB;
if(mUsageType== eVertexBufferUsageType_Dynamic) usageType = GL_DYNAMIC_DRAW_ARB;
else if(mUsageType== eVertexBufferUsageType_Stream) usageType = GL_STREAM_DRAW_ARB;
//Create the VBO vertex arrays
for(int i=0;i< klNumOfVertexFlags; i++)
{
if((mVertexFlags & kvVertexFlags[i]) && (aTypes & kvVertexFlags[i]))
{
glBindBufferARB(GL_ARRAY_BUFFER_ARB, mvArrayHandle[i]);
//This was apparently VERY slow.
glBufferDataARB(GL_ARRAY_BUFFER_ARB, mvVertexArray[i].size()*sizeof(float),
NULL, usageType);//Clear memory
glBufferDataARB(GL_ARRAY_BUFFER_ARB, mvVertexArray[i].size()*sizeof(float),
&(mvVertexArray[i][0]), usageType);
}
}
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
//Create the VBO index array
if(abIndices)
{
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,mlElementHandle);
//glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB,GetIndexNum()*sizeof(unsigned int),
// NULL, usageType);
glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, GetIndexNum()*sizeof(unsigned int),
&mvIndexArray[0], usageType);
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,0);
}
}
// Initialize GL
//*****************************************************************************
void initPixelBuffer()
{
ciErrNum = CL_SUCCESS;
if (pbo) {
// delete old buffer
clReleaseMemObject(pbo_cl);
glDeleteBuffersARB(1, &pbo);
}
// create pixel buffer object for display
glGenBuffersARB(1, &pbo);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, width * height * sizeof(GLubyte) * 4, 0, GL_STREAM_DRAW_ARB);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
if( g_glInterop )
{
// create OpenCL buffer from GL PBO
pbo_cl = clCreateFromGLBuffer(cxGPUContext,CL_MEM_WRITE_ONLY, pbo, &ciErrNum);
//oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
printf("Create from GL buffer error %i\n",ciErrNum);
}
else
{
pbo_cl = clCreateBuffer(cxGPUContext, CL_MEM_WRITE_ONLY, width * height * sizeof(GLubyte) * 4, NULL, &ciErrNum);
}
// calculate new grid size
//gridSize[0] = floor(width/LOCAL_SIZE_X);
//gridSize[1] = floor(height/LOCAL_SIZE_Y);
gridSize[0] = width;
gridSize[1] = height;
int xBlocks = (size_t)ceil((float)width / (float)LOCAL_SIZE_X);
int yBlocks = (size_t)ceil((float)height / (float)LOCAL_SIZE_Y);
// Calculate total number of threads (this is done to guarantee that total number of threads is multiple of local work size, required by OpenCL)
gridSize[0] = xBlocks * LOCAL_SIZE_X;
gridSize[1] = yBlocks * LOCAL_SIZE_Y;
ciErrNum |= clSetKernelArg(ckKernel, 0, sizeof(cl_mem), (void *) &pbo_cl);
ciErrNum |= clSetKernelArg(ckKernel, 1, sizeof(unsigned int), &width);
ciErrNum |= clSetKernelArg(ckKernel, 2, sizeof(unsigned int), &height);
printf("Error first kernel args is %i\n",ciErrNum);
//oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
}
void initGLBuffers()
{
if (pbo)
{
// delete old buffer
checkCudaErrors(cudaGraphicsUnregisterResource(cuda_pbo_resource));
glDeleteBuffersARB(1, &pbo);
}
// create pixel buffer object for display
glGenBuffersARB(1, &pbo);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, width*height*sizeof(uchar4), 0, GL_STREAM_DRAW_ARB);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
checkCudaErrors(cudaGraphicsGLRegisterBuffer(&cuda_pbo_resource, pbo,
cudaGraphicsMapFlagsWriteDiscard));
#if USE_BUFFER_TEX
// create buffer texture, attach to pbo
if (bufferTex)
{
glDeleteTextures(1, &bufferTex);
}
glGenTextures(1, &bufferTex);
glBindTexture(GL_TEXTURE_BUFFER_EXT, bufferTex);
glTexBufferEXT(GL_TEXTURE_BUFFER_EXT, GL_RGBA8, pbo);
glBindTexture(GL_TEXTURE_BUFFER_EXT, 0);
#else
// create texture for display
if (displayTex)
{
glDeleteTextures(1, &displayTex);
}
glGenTextures(1, &displayTex);
glBindTexture(GL_TEXTURE_TYPE, displayTex);
glTexImage2D(GL_TEXTURE_TYPE, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_TYPE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_TYPE, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_TYPE, 0);
#endif
// calculate new grid size
gridSize = dim3(iDivUp(width, blockSize.x), iDivUp(height, blockSize.y));
}
/* Context activation is done by the caller. */
static void wined3d_volume_prepare_pbo(struct wined3d_volume *volume, struct wined3d_context *context)
{
const struct wined3d_gl_info *gl_info = context->gl_info;
if (volume->pbo)
return;
GL_EXTCALL(glGenBuffersARB(1, &volume->pbo));
GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, volume->pbo));
GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, volume->resource.size, NULL, GL_STREAM_DRAW_ARB));
GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
checkGLcall("Create PBO");
TRACE("Created PBO %u for volume %p.\n", volume->pbo, volume);
}
//--------------------------------------------------------------
void ofVbo::setTexCoordData(const ofVec2f * texCoords, int total, int usage) {
if(texCoords == NULL) {
ofLog(OF_LOG_WARNING,"ofVbo: bad texCoord data!\n");
return;
}
texUsage = usage;
if(!bUsingTexCoords) {
bUsingTexCoords = true;
glGenBuffers(1, &texCoordId);
}
glBindBufferARB(GL_ARRAY_BUFFER_ARB, texCoordId);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, total * sizeof(ofVec2f), &texCoords[0].x, usage);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
}
void CMesh::Setup(unsigned int vbovertices)
{
m_nVBOVertices = vbovertices;
_ASSERT_EXPR_A(!(error = glGetError()), (const char*)gluErrorString(error));
glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_nVBOVertices);
_ASSERT_EXPR_A(!(error = glGetError()), (const char*)gluErrorString(error));
std::vector<XMFLOAT3> data(polygons.size() * VERTICESPERPOLY);
for (size_t i = 0, dst = 0; i < polygons.size(); ++i) {
data[dst++] = vertices[polygons[i].v[0]];
data[dst++] = vertices[polygons[i].v[1]];
data[dst++] = vertices[polygons[i].v[2]];
}
glBufferDataARB(GL_ARRAY_BUFFER_ARB, data.size() * sizeof(XMFLOAT3), &data.front(), GL_STATIC_DRAW_ARB);
_ASSERT_EXPR_A(!(error = glGetError()), (const char*)gluErrorString(error));
// Normals...
glGenBuffersARB(1, &m_nVBONormals);
_ASSERT_EXPR_A(!(error = glGetError()), (const char*)gluErrorString(error));
std::vector<XMFLOAT3> normals(polygons.size() * VERTICESPERPOLY);
for (size_t i = 0, dst = 0; i < polygons.size(); ++i) {
// TODO:: ccw hack
XMFLOAT3 n;
XMStoreFloat3(&n, XMVectorScale(XMLoadFloat3(&normalsV[i].n[0]), -1.f));
normals[dst++] = n;
XMStoreFloat3(&n, XMVectorScale(XMLoadFloat3(&normalsV[i].n[1]), -1.f));
normals[dst++] = n;
XMStoreFloat3(&n, XMVectorScale(XMLoadFloat3(&normalsV[i].n[2]), -1.f));
normals[dst++] = n;
}
glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_nVBONormals);
_ASSERT_EXPR_A(!(error = glGetError()), (const char*)gluErrorString(error));
glBufferDataARB(GL_ARRAY_BUFFER_ARB, normals.size() * sizeof(XMFLOAT3), &normals.front(), GL_STATIC_DRAW_ARB);
_ASSERT_EXPR_A(!(error = glGetError()), (const char*)gluErrorString(error));
}
//--------------------------------------------------------------
void ofVbo::setColorData(const ofColor * colors, int total, int usage) {
if(colors == NULL) {
ofLog(OF_LOG_WARNING,"ofVbo: bad color data!\n");
return;
}
colorUsage = usage;
if(!bUsingColors) {
bUsingColors = true;
glGenBuffers(1, &colorId);
}
glBindBufferARB(GL_ARRAY_BUFFER_ARB, colorId);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, total * sizeof(ofColor), &colors[0].r, usage);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
}
void OpenNI2ViewNode::customDraw() {
update();
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo[0]);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, nPoints * 3 * sizeof(float), Wxyz.getPixels(), GL_STATIC_DRAW_ARB);
glVertexPointer(3, GL_FLOAT, 0, 0);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo[1]);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, nPoints * 3 * sizeof(unsigned char), kinect.getRGBPixels().getPixels(), GL_STATIC_DRAW_ARB);
glColorPointer(3, GL_UNSIGNED_BYTE, 0, 0);
glPointSize(2.0f);
glDrawArrays(GL_POINTS, 0, nPoints);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
}
//--------------------------------------------------------------
void ofVbo::setNormalData(const ofVec3f * normals, int total, int usage) {
if(normals == NULL) {
ofLog(OF_LOG_WARNING,"ofVbo: bad normal data!\n");
return;
}
normUsage = usage;
if(!bUsingNormals) {
bUsingNormals = true;
glGenBuffers(1, &normalId);
}
glBindBufferARB(GL_ARRAY_BUFFER_ARB, normalId);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, total * sizeof(ofVec3f), &normals[0].x, usage);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
}
enum piglit_result
piglit_display(void)
{
GLuint vbo;
GLboolean pass;
glGenBuffersARB(1, &vbo);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, 100*100, NULL, GL_STATIC_DRAW_ARB);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
pass = test_Purgeable(vbo, GL_BUFFER_OBJECT_APPLE);
glDeleteBuffersARB(1, &vbo);
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
//--------------------------------------------------------------
void ofVbo::setIndexData(const GLuint * indices, int total, int usage) {
if(indices == NULL) {
ofLog(OF_LOG_WARNING,"ofVbo: bad index data!\n");
return;
}
if(!bUsingIndices) {
bUsingIndices = true;
glGenBuffers(1, &indexId);
}
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, indexId);
indexData = (GLuint*)indices;
glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, sizeof(GLuint) * total, indexData, usage);
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
}
TGen::VertexData * TGen::OpenGL::Renderer::createVertexData(const TGen::VertexStructure & vertstruct, uint size, ushort usage) {
GLuint newVBO = 0;
glGenBuffersARB(1, &newVBO);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, newVBO);
DEBUG_PRINT("[opengl]: created new vbo for vertex data: " << newVBO);
GLenum fixedUsage = 0;
if (usage & TGen::UsageStream) {
if (usage & TGen::UsageDraw)
fixedUsage = GL_STREAM_DRAW_ARB;
else if (usage & TGen::UsageCopy)
fixedUsage = GL_STREAM_COPY_ARB;
else if (usage & TGen::UsageRead)
fixedUsage = GL_STREAM_READ_ARB;
else
fixedUsage = GL_STREAM_DRAW_ARB;
}
else if (usage & TGen::UsageDynamic) {
if (usage & TGen::UsageDraw)
fixedUsage = GL_DYNAMIC_DRAW_ARB;
else if (usage & TGen::UsageCopy)
fixedUsage = GL_DYNAMIC_COPY_ARB;
else if (usage & TGen::UsageRead)
fixedUsage = GL_DYNAMIC_READ_ARB;
else
fixedUsage = GL_DYNAMIC_DRAW_ARB;
}
else if (usage & TGen::UsageStatic) {
if (usage & TGen::UsageDraw)
fixedUsage = GL_STATIC_DRAW_ARB;
else if (usage & TGen::UsageCopy)
fixedUsage = GL_STATIC_COPY_ARB;
else if (usage & TGen::UsageRead)
fixedUsage = GL_STATIC_READ_ARB;
else
fixedUsage = GL_STATIC_DRAW_ARB;
}
glBufferDataARB(GL_ARRAY_BUFFER_ARB, size, NULL, fixedUsage);
// TODO: in i ~ också...
PSTAT_ADD_VAL(TGen::StatBufferAlloc, size);
return new TGen::OpenGL::VertexData(*this, stats, vertstruct, size, fixedUsage, newVBO);
}
void* mapWrite()
{
if( !_testInitialized( ))
return 0;
if( _type != GL_WRITE_ONLY_ARB )
{
_setError( ERROR_PBO_READ_ONLY );
return 0;
}
bind();
// cancel all draw operations on this buffer to prevent stalling
EQ_GL_CALL( glBufferDataARB( GL_PIXEL_UNPACK_BUFFER_ARB, size, 0,
GL_STREAM_DRAW_ARB ));
return glMapBufferARB( GL_PIXEL_UNPACK_BUFFER_ARB, _type );
}
void PointCloudViewer::drawPointCloud()
{
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glBindBufferARB(GL_ARRAY_BUFFER, buffers[0]);
glBufferDataARB(GL_ARRAY_BUFFER, sizeof(float)*pointCloud->cols*pointCloud->rows*3, pointCloud->ptr(), GL_DYNAMIC_DRAW);
glVertexPointer(3 , GL_FLOAT , 0 , 0);
glBindBufferARB(GL_ARRAY_BUFFER, buffers[1]);
glTexCoordPointer(2, GL_FLOAT, 0, 0);
glEnable(GL_TEXTURE_2D);
glDrawArrays(GL_POINTS, 0, pointCloud->cols * pointCloud->rows);
glDisable(GL_TEXTURE_2D);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
//--------------------------------------------------------------
void ofVbo::setVertexData(const ofVec3f * verts, int total, int usage) {
if(verts == NULL) {
ofLog(OF_LOG_WARNING,"ofVbo: bad vertex data!\n");
return;
}
vertUsage = usage;
if(!bUsingVerts) {
bAllocated = true;
bUsingVerts = true;
glGenBuffers(1, &vertId);
}
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertId);
vertData = (float*)&verts[0].x;
glBufferDataARB(GL_ARRAY_BUFFER_ARB, total * sizeof(ofVec3f), vertData, usage);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
}