void piglit_init(int argc, char **argv) { static const char *vs_source = "#version 150\n" "in vec4 piglit_vertex;\n" "void main()\n" "{\n" " gl_Position = piglit_vertex;\n" "}\n"; static const char *fs_source = "#version 150\n" "#extension GL_ARB_gpu_shader5: require\n" "uniform samplerBuffer s[2];\n" "uniform int offset;\n" "uniform int index = 1;\n" "void main()\n" "{\n" " gl_FragColor = texelFetch(s[index], offset);\n" "}\n"; GLuint tex[2], tbo[2]; GLint indices[2] = { 0, 1 }; static const uint8_t datag[4] = {0x00, 0xff, 0x00, 0x00}; static const uint8_t datar[4] = {0xff, 0x00, 0x00, 0x00}; GLuint prog; GLint size = 4; piglit_require_extension("GL_ARB_gpu_shader5"); prog = piglit_build_simple_program(vs_source, fs_source); glUseProgram(prog); glGenBuffers(2, tbo); glGenTextures(2, tex); glBindBuffer(GL_TEXTURE_BUFFER, tbo[0]); glBindTexture(GL_TEXTURE_BUFFER, tex[0]); glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA8, tbo[0]); glBufferData(GL_TEXTURE_BUFFER, size * sizeof(datar), NULL, GL_STATIC_READ); glBufferSubData(GL_TEXTURE_BUFFER, (size - 1) * sizeof(datar), sizeof(datar), datar); glActiveTexture(GL_TEXTURE1); glBindBuffer(GL_TEXTURE_BUFFER, tbo[1]); glBindTexture(GL_TEXTURE_BUFFER, tex[1]); glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA8, tbo[1]); glBufferData(GL_TEXTURE_BUFFER, size * sizeof(datag), NULL, GL_STATIC_READ); glBufferSubData(GL_TEXTURE_BUFFER, (size - 1) * sizeof(datag), sizeof(datag), datag); glUniform1i(glGetUniformLocation(prog, "offset"), size - 1); glUniform1iv(glGetUniformLocation(prog, "s"), 2, indices); }
bool initTexture() { glGenTextures(1, &DisplacementTextureName); glBindTexture(GL_TEXTURE_BUFFER, DisplacementTextureName); glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, BufferName[buffer::DISPLACEMENT]); glBindTexture(GL_TEXTURE_BUFFER, 0); glGenTextures(1, &DiffuseTextureName); glBindTexture(GL_TEXTURE_BUFFER, DiffuseTextureName); glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA8, BufferName[buffer::DIFFUSE]); glBindTexture(GL_TEXTURE_BUFFER, 0); return glf::checkError("initTexture"); }
bool initTexture() { glGenTextures(TEXTURE_MAX, TextureName); glBindTexture(GL_TEXTURE_BUFFER, TextureName[TEXTURE_DISPLACEMENT]); glTexBuffer(GL_TEXTURE_BUFFER, GL_RGB32F, BufferName[BUFFER_DISPLACEMENT]); glBindTexture(GL_TEXTURE_BUFFER, 0); glBindTexture(GL_TEXTURE_BUFFER, TextureName[TEXTURE_DIFFUSE]); glTexBuffer(GL_TEXTURE_BUFFER, GL_RGB32F, BufferName[BUFFER_DIFFUSE]); glBindTexture(GL_TEXTURE_BUFFER, 0); return this->checkError("initTextureBuffer"); }
static inline void _render_world(game *g) { glClear(GL_COLOR_BUFFER_BIT); glUseProgram(g->world_shader); glUniformMatrix4fv(g->d.matrix_id, 1, GL_FALSE, &g->d.mvp[0][0]); glUniform4fv(g->d.colors_id, 5, GET_COL(COLORS_OFFSET)); glUniform1ui(g->d.inv_state_id, !g->w->state); glBindBuffer(GL_ARRAY_BUFFER, g->d.vert_buffer); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0); glBindTexture(GL_TEXTURE_BUFFER, g->d.data_tex); glActiveTexture(GL_TEXTURE0 + g->d.tex_id); glTexBuffer(GL_TEXTURE_BUFFER, GL_R32UI, g->d.data_buffer); glUniform1i(g->d.tex_buff_id, g->d.tex_id); glDrawArrays(GL_TRIANGLES, 0, g->d.vcount / 2); glDisableVertexAttribArray(0); glBindTexture(GL_TEXTURE_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); glUseProgram(0); }
void BufferTexture::setBuffer( const BufferObjRef &buffer, GLenum internalFormat ) { mInternalFormat = internalFormat; mBufferObj = buffer; gl::context()->bindTexture( mTarget, mId ); glTexBuffer( mTarget, mInternalFormat, buffer->getId() ); }
PIGLIT_GL_TEST_CONFIG_END void piglit_init(int argc, char **argv) { bool pass = true; GLuint fbo, buff, tex; glGenFramebuffers(1, &fbo); glBindFramebuffer(GL_FRAMEBUFFER, fbo); glGenBuffers(1, &buff); glBindBuffer(GL_TEXTURE_BUFFER, buff); glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_BUFFER, tex); glTexBuffer(GL_TEXTURE_BUFFER, GL_RG32F, buff); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; /* Try to attach the buffer texture to the framebuffer */ glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex, 0); pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass; piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
static enum piglit_result call_MapBuffer_when_texture_is_referenced(void *data) { static const float red[4] = {1, 0, 0, 0}; GLuint tex, tbo; glGenBuffers(1, &tbo); glBindBuffer(GL_TEXTURE_BUFFER, tbo); glBufferData(GL_TEXTURE_BUFFER, sizeof(red), red, GL_STATIC_DRAW); glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_BUFFER, tex); glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, tbo); glGetTextureHandleARB(tex); if (!piglit_check_gl_error(GL_NO_ERROR)) return PIGLIT_FAIL; /* The ARB_bindless_texture spec says: * * "The contents of the buffer object may still be updated via buffer * update commands such as BufferSubData and MapBuffer*, or via the * texture update commands, even if the buffer is bound to a texture * while that buffer texture object is referenced by one or more * texture handles." */ glMapBuffer(GL_TEXTURE_BUFFER, GL_READ_ONLY); if (!piglit_check_gl_error(GL_NO_ERROR)) return PIGLIT_FAIL; glUnmapBuffer(GL_TEXTURE_BUFFER); return PIGLIT_PASS; }
int opengl_create_texture_buffer_object() { if ( GLSL_version < 130 ) { return -1; } // create the buffer int buffer_object_handle = opengl_create_buffer_object(GL_TEXTURE_BUFFER, GL_DYNAMIC_DRAW); opengl_check_for_errors(); opengl_buffer_object &buffer_obj = GL_buffer_objects[buffer_object_handle]; // create the texture glGenTextures(1, &buffer_obj.texture); glBindTexture(GL_TEXTURE_BUFFER, buffer_obj.texture); gr_opengl_update_buffer_data(buffer_object_handle, 100, NULL); glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, buffer_obj.buffer_id); opengl_check_for_errors(); return buffer_object_handle; }
//-------------------------------------------------------------- void ClusterGrid::createLightIndexTextures() { // Light index TBO. glGenBuffers(1, &this->lightIndexTbo); glBindBuffer(GL_TEXTURE_BUFFER, this->lightIndexTbo); glGenTextures(1, &this->lightIndexTex); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_BUFFER, this->lightIndexTex); glTexBuffer(GL_TEXTURE_BUFFER, GL_R16UI, this->lightIndexTbo); glBindBuffer(GL_TEXTURE_BUFFER, this->lightIndexTbo); glBufferData(GL_TEXTURE_BUFFER, MAX_CLUSTERED_LIGHTS * sizeof(this->lightIndices[0]), NULL, GL_DYNAMIC_DRAW); glBindBuffer(GL_TEXTURE_BUFFER, 0); glBindTexture(GL_TEXTURE_BUFFER, 0); CheckGLError(); // Light pointer 3d texture. // RG32_UI (R = Offset into light index TBO, G = (PointLightCount << 16 | SpotLightCount) glGenTextures(1, &this->lightPointerTableTex3d); glBindTexture(GL_TEXTURE_3D, this->lightPointerTableTex3d); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_REPEAT); CheckGLError(); glTexImage3D(GL_TEXTURE_3D, 0, GL_RG32UI, NUM_CLUSTERS_X, NUM_CLUSTERS_Y, NUM_CLUSTERS_Z, 0, GL_RG_INTEGER, GL_UNSIGNED_INT, nullptr); CheckGLError(); }
void FireParticleSystem::Process(float delta_t) { UpdateParameters(delta_t); glUseProgram(m_animateProgram.program); CHECK_GL_ERRORS; setUniform(m_animateProgram.program, "delta_t", delta_t); setUniform(m_animateProgram.program, "wind", m_wind); //setUniform(m_animateProgram.program, "epicenter", float3(0,1,0)); glBindBuffer(GL_TEXTURE_BUFFER, m_posAndSizeBuffers[1-m_currPinPongId]); CHECK_GL_ERRORS; bindTextureBuffer(m_animateProgram.program, 1, "vertPosBuffer", m_vertexPosTBO); CHECK_GL_ERRORS; glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, m_vertexPosTBO); CHECK_GL_ERRORS; glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_posAndSizeBuffers[m_currPinPongId]); CHECK_GL_ERRORS; glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 1, m_velAndHPBuffers[m_currPinPongId]); CHECK_GL_ERRORS; glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 2, m_randBuffers[m_currPinPongId]); CHECK_GL_ERRORS; glEnable(GL_RASTERIZER_DISCARD); glBeginTransformFeedback(GL_POINTS); CHECK_GL_ERRORS; glBindVertexArray(m_animVAOs[1-m_currPinPongId]); CHECK_GL_ERRORS; glDrawArrays(GL_POINTS, 0, m_particlesNum); CHECK_GL_ERRORS; glBindVertexArray(0); glEndTransformFeedback(); CHECK_GL_ERRORS; glDisable(GL_RASTERIZER_DISCARD); glBindBuffer(GL_TEXTURE_BUFFER, 0); glBindTexture(GL_TEXTURE_BUFFER, 0); m_currPinPongId = 1 - m_currPinPongId; m_lastDeltaTime = delta_t; }
void ParticleSystemProxy::setHeightmap(const std::vector<std::vector<float> > &hm, float f1, float f2, float f3, float f4) { track_x = f1, track_z = f2, track_x_len = f3, track_z_len = f4; printf("track_x is %f, track_x_len is %f, track_z is %f, track_z_len is %f\n", track_x, track_x_len, track_z, track_z_len); unsigned width = hm.size(); unsigned height = hm[0].size(); float *hm_array = new float[width * height]; for (unsigned i = 0; i < width; i++) { for (unsigned j = 0; j < height; j++) { hm_array[i * height + j] = hm[i][j]; } } has_height_map = true; glGenBuffers(1, &heighmapbuffer); glBindBuffer(GL_TEXTURE_BUFFER, heighmapbuffer); glBufferData(GL_TEXTURE_BUFFER, width * height * sizeof(float), hm_array, GL_STATIC_DRAW); glGenTextures(1, &heightmaptexture); glBindTexture(GL_TEXTURE_BUFFER, heightmaptexture); glTexBuffer(GL_TEXTURE_BUFFER, GL_R32F, heighmapbuffer); glBindBuffer(GL_TEXTURE_BUFFER, 0); delete[] hm_array; }
BufferTexture::~BufferTexture() { glBindTexture(GL_TEXTURE_BUFFER, m_textureID); glTexBuffer(GL_TEXTURE_BUFFER, m_buffer->format()->openGLFormat, 0); glBindTexture(GL_TEXTURE_BUFFER, 0); glDeleteTextures(1, &m_textureID); m_textureID = 0; }
bool MarkerSamplingFBO::Init(unsigned int WindowWidth, unsigned int WindowHeight, int agentnum, int markernum, bool debug) { this->m_debug = debug; this->m_markernum = markernum; this->m_agentnum = agentnum; // Create the FBO glGenFramebuffers(1, &m_fbo); // Create the depth buffer glGenTextures(1, &m_markersamplingmap); glBindTexture(GL_TEXTURE_2D, m_markersamplingmap); glGenTextures(1, &m_depthTexture); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, WindowWidth, WindowHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fbo); glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_markersamplingmap, 0); glBindTexture(GL_TEXTURE_2D, m_depthTexture); glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32F, WindowWidth, WindowHeight, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL); glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_depthTexture, 0); GLenum DrawBuffers[] = { GL_COLOR_ATTACHMENT0 }; glDrawBuffers(ARRAY_SIZE_IN_ELEMENTS(DrawBuffers), DrawBuffers); GLenum Status = glCheckFramebufferStatus(GL_FRAMEBUFFER); if (Status != GL_FRAMEBUFFER_COMPLETE) { printf("FB error, status: 0x%x\n", Status); return false; } glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); if(this->m_debug == true) { glGenBuffers(1, &m_writebuffer); glBindBuffer(GL_TEXTURE_BUFFER, m_writebuffer); //glBufferData(GL_TEXTURE_BUFFER, sizeof(float), NULL, GL_DYNAMIC_READ); //glBindBuffer(GL_TEXTURE_BUFFER, 0); glBufferData(GL_TEXTURE_BUFFER, 4 * markernum*sizeof(float), NULL, GL_DYNAMIC_READ); glBindBuffer(GL_TEXTURE_BUFFER, 0); //floating texture glGenTextures(1, &m_writeTex); glBindTexture(GL_TEXTURE_BUFFER, m_writeTex); glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, m_writebuffer); glBindTexture(GL_TEXTURE_BUFFER, 0); } return true; }
PIGLIT_GL_TEST_CONFIG_END enum piglit_result piglit_display(void) { static const char *vs_source = "#version 140\n" "in vec4 piglit_vertex;\n" "void main()\n" "{\n" " gl_Position = piglit_vertex;\n" "}\n"; static const char *fs_source = "#version 140\n" "uniform samplerBuffer s;\n" "void main()\n" "{\n" " gl_FragColor = texelFetch(s, 0);\n" "}\n"; bool pass = true; GLuint tex, bo; GLuint prog; float green[] = {0, 1, 0, 0}; float blue[] = {0, 0, 1, 0}; uint8_t g_rgba8[] = {0x00, 0xff, 0x00, 0x00}; uint8_t b_rgba8[] = {0x00, 0x00, 0xff, 0x00}; prog = piglit_build_simple_program(vs_source, fs_source); glUseProgram(prog); glGenBuffers(1, &bo); glBindBuffer(GL_TEXTURE_BUFFER, bo); /* Make the buffer bigger than the data to trigger the driver * code path we want. */ glBufferData(GL_TEXTURE_BUFFER, 4096, NULL, GL_STREAM_DRAW); glBufferSubData(GL_TEXTURE_BUFFER, 0, sizeof(g_rgba8), g_rgba8); glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_BUFFER, tex); glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA8, bo); piglit_draw_rect(-1, -1, 1, 2); glBufferSubData(GL_TEXTURE_BUFFER, 0, sizeof(b_rgba8), b_rgba8); piglit_draw_rect(0, -1, 1, 2); pass = pass && piglit_probe_rect_rgba(0, 0, piglit_width / 2, piglit_height, green); pass = pass && piglit_probe_rect_rgba(piglit_width / 2, 0, piglit_width / 2, piglit_height, blue); piglit_present_results(); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
int gl_TexBuffer(State& state){ glTexBuffer( (GLenum) state.stack->to<int>(1), (GLenum) state.stack->to<int>(2), (GLuint) state.stack->to<int>(3) ); return 0; }
buffertexture() : texture<GL_TEXTURE_BUFFER>( 0 ) { data( 0, nullptr ); texture::bind(); check_gl_error( glTexBuffer( GL_TEXTURE_BUFFER, InternalFormat, buffer::name() ) ); texture::unbind(); }
void ImageApp::init_buffer() { render_scene_prog = -1; // Create palette texture glGenBuffers(1, &image_palette_buffer); glBindBuffer(GL_TEXTURE_BUFFER, image_palette_buffer); glBufferData(GL_TEXTURE_BUFFER, 256 * 4 * sizeof(float), NULL, GL_STATIC_DRAW); glGenTextures(1, &image_palette_texture); glBindTexture(GL_TEXTURE_BUFFER, image_palette_texture); glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, image_palette_buffer); vmath::vec4 * data = (vmath::vec4 *)glMapBuffer(GL_TEXTURE_BUFFER, GL_WRITE_ONLY); for (int i = 0; i < 256; i++) { data[i] = vmath::vec4((float)i); } glUnmapBuffer(GL_TEXTURE_BUFFER); // Create overdraw counter texture glGenTextures(1, &overdraw_count_buffer); glBindTexture(GL_TEXTURE_2D, overdraw_count_buffer); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_R32UI, MAX_FRAMEBUFFER_WIDTH, MAX_FRAMEBUFFER_HEIGHT, 0, GL_RED_INTEGER, GL_UNSIGNED_INT, NULL); glBindTexture(GL_TEXTURE_2D, 0); // Create buffer for clearing the head pointer texture glGenBuffers(1, &overdraw_count_clear_buffer); glBindBuffer(GL_PIXEL_UNPACK_BUFFER, overdraw_count_clear_buffer); glBufferData(GL_PIXEL_UNPACK_BUFFER, MAX_FRAMEBUFFER_WIDTH * MAX_FRAMEBUFFER_HEIGHT * sizeof(GLuint), NULL, GL_STATIC_DRAW); data = (vmath::vec4 *)glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY); memset(data, 0x00, MAX_FRAMEBUFFER_WIDTH * MAX_FRAMEBUFFER_HEIGHT * sizeof(GLuint)); glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER); // Create VAO containing quad for the final blit glGenVertexArrays(1, &quad_vao); glBindVertexArray(quad_vao); static const GLfloat quad_verts[] = { -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 1.0f, }; glGenBuffers(1, &quad_vbo); glBindBuffer(GL_ARRAY_BUFFER, quad_vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(quad_verts), quad_verts, GL_STATIC_DRAW); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL); glEnableVertexAttribArray(0); glClearDepth(1.0f); object.LoadFromVBM("../../../media/objects/unit_pipe.vbm", 0, 1, 2); }
void Instance::init_buffer() { m_Armadillo.LoadFromVBM("../../../media/objects/armadillo_low.vbm", 0, 1, 2); m_Armadillo.BindVertexArray(); glm::vec4 colors[INSTANCE_COUNT]; for (int n = 0; n < INSTANCE_COUNT; n++) { float a = float(n) / 4.0f; float b = float(n) / 5.0f; float c = float(n) / 6.0f; colors[n][0] = 0.5f * (sinf(a + 1.0f) + 1.0f); colors[n][1] = 0.5f * (sinf(b + 2.0f) + 1.0f); colors[n][2] = 0.5f * (sinf(c + 3.0f) + 1.0f); colors[n][3] = 1.0f; } //Notice the set color_tbo to gl_texture_buffer layer 0, your should use texture to change it glActiveTexture(GL_TEXTURE0); glGenTextures(1, &color_texture); glBindTexture(GL_TEXTURE_BUFFER, color_texture); glGenBuffers(1, &color_tbo); glBindBuffer(GL_TEXTURE_BUFFER, color_tbo); glBufferData(GL_TEXTURE_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW); glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, color_tbo); // Now do the same thing with a TBO for the model matrices. The buffer object // (model_matrix_buffer) has been created and sized to store one mat4 per- // instance. glActiveTexture(GL_TEXTURE1); glGenTextures(1, &model_texture); glBindTexture(GL_TEXTURE_BUFFER, model_texture); glGenBuffers(1, &model_tbo); glBindBuffer(GL_TEXTURE_BUFFER, model_tbo); glBufferData(GL_TEXTURE_BUFFER, INSTANCE_COUNT * sizeof(glm::mat4), NULL, GL_DYNAMIC_DRAW); glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, model_tbo); }
void PathTracingBVH::geometryToTexture(GLuint textureSlot) { BufferObject geometryBuffer(GL_TEXTURE_BUFFER, GL_STATIC_READ); geometryBuffer.data<glm::vec4>(m_geometry->data(), m_geometry->size(), GL_RGBA32F, sizeof(glm::vec4)); glActiveTexture(textureSlot); GLuint textureHandle; glGenTextures(1, &textureHandle); glBindTexture(GL_TEXTURE_BUFFER, textureHandle); glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, geometryBuffer.buffer()); glError(); }
bool initTextureBuffer() { glm::vec4 Position[5] = { glm::vec4( 0.1f, 0.3f,-1.0f, 1.0f), glm::vec4(-0.5f, 0.0f,-0.5f, 1.0f), glm::vec4(-0.2f,-0.2f, 0.0f, 1.0f), glm::vec4( 0.3f, 0.2f, 0.5f, 1.0f), glm::vec4( 0.1f,-0.3f, 1.0f, 1.0f) }; glGenBuffers(1, &DisplacementBufferName); glBindBuffer(GL_TEXTURE_BUFFER, DisplacementBufferName); glBufferData(GL_TEXTURE_BUFFER, sizeof(Position), Position, GL_STATIC_DRAW); glBindBuffer(GL_TEXTURE_BUFFER, 0); glGenTextures(1, &DisplacementTextureName); glBindTexture(GL_TEXTURE_BUFFER, DisplacementTextureName); glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, DisplacementBufferName); glBindTexture(GL_TEXTURE_BUFFER, 0); glm::u8vec4 Diffuse[5] = { glm::u8vec4(255, 0, 0, 255), glm::u8vec4(255, 127, 0, 255), glm::u8vec4(255, 255, 0, 255), glm::u8vec4( 0, 255, 0, 255), glm::u8vec4( 0, 0, 255, 255) }; glGenBuffers(1, &DiffuseBufferName); glBindBuffer(GL_TEXTURE_BUFFER, DiffuseBufferName); glBufferData(GL_TEXTURE_BUFFER, sizeof(Diffuse), Diffuse, GL_STATIC_DRAW); glBindBuffer(GL_TEXTURE_BUFFER, 0); glGenTextures(1, &DiffuseTextureName); glBindTexture(GL_TEXTURE_BUFFER, DiffuseTextureName); glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA8, DiffuseTextureName); glBindTexture(GL_TEXTURE_BUFFER, 0); return glf::checkError("initTextureBuffer"); }
void piglit_init(int argc, char **argv) { static const char *vs_source = "#version 140\n" "in vec4 piglit_vertex;\n" "void main()\n" "{\n" " gl_Position = piglit_vertex;\n" "}\n"; static const char *fs_source = "#version 140\n" "uniform samplerBuffer s;\n" "uniform int offset;\n" "void main()\n" "{\n" " gl_FragColor = texelFetch(s, offset);\n" "}\n"; GLuint tex, tbo; static const uint8_t data[4] = {0x00, 0xff, 0x00, 0x00}; GLuint prog; GLint max; prog = piglit_build_simple_program(vs_source, fs_source); glUseProgram(prog); glGenBuffers(1, &tbo); glBindBuffer(GL_TEXTURE_BUFFER, tbo); glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_BUFFER, tex); glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE, &max); printf("MAX_TEXTURE_BUFFER_SIZE: %d\n", max); if (max >= 512 * 1024 * 1024) { /* Buffer sizes >= 2G are a bit dicey, ideally this * test would try various formats, including GL_R8. */ printf("MAX_TEXTURE_BUFFER_SIZE >= 512M, " "testing with size 512M-1\n"); max = 512 * 1024 * 1024 - 1; } glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA8, tbo); glBufferData(GL_TEXTURE_BUFFER, max * sizeof(data), NULL, GL_STATIC_READ); glBufferSubData(GL_TEXTURE_BUFFER, (max - 1) * sizeof(data), sizeof(data), data); glUniform1i(glGetUniformLocation(prog, "offset"), max - 1); }
void Renderer::uploadTerrainData() { //height map { if (glIsTexture(mTextures.heightMap)) glDeleteTextures(1, &mTextures.heightMap); glGenTextures(1, &mTextures.heightMap); glBindTexture(GL_TEXTURE_2D, mTextures.heightMap); const HeightMap &hm = mTerrainData->heightMap(); glTexStorage2D(GL_TEXTURE_2D, 1, GL_R32F, hm.size(), hm.size()); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, hm.size(), hm.size(), GL_RED, GL_FLOAT, hm.raw()); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); } //light map { if (glIsTexture(mTextures.lightMap)) glDeleteTextures(1, &mTextures.lightMap); glGenTextures(1, &mTextures.lightMap); glBindTexture(GL_TEXTURE_2D, mTextures.lightMap); const LightMap &lm = mTerrainData->lightMap(); glTexStorage2D(GL_TEXTURE_2D, 1, GL_R32F, lm.size(), lm.size()); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, lm.size(), lm.size(), GL_RED, GL_UNSIGNED_SHORT, lm.raw()); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); } //texture indicies { if (glIsTexture(mTextures.indicies)) glDeleteTextures(1, &mTextures.indicies); glGenTextures(1, &mTextures.indicies); glBindTexture(GL_TEXTURE_BUFFER, mTextures.indicies); { GLuint buffer; glGenBuffers(1, &buffer); glBindBuffer(GL_TEXTURE_BUFFER, buffer); { glBufferData(GL_TEXTURE_BUFFER, sizeof(GLubyte)*mTerrainData->textureIndicies().size(), &mTerrainData->textureIndicies()[0], GL_STATIC_DRAW); glTexBuffer(GL_TEXTURE_BUFFER, GL_R8UI, buffer); } } } }
shared_ptr<BufferTexture> BufferTexture::create(const String& name, const shared_ptr<GLPixelTransferBuffer>& buffer) { debugAssertM(GLCaps::maxTextureBufferSize() > 0, "Buffer Textures not supported by your driver."); alwaysAssertM(isValidBufferTextureImageFormat(buffer->format()), G3D::format("Invalidly formatted buffer passed to BufferTexture::create(), format %s is unsupported.", buffer->format()->name().c_str()) ); GLuint textureID = Texture::newGLTextureID(); /** Load the data */ glBindTexture(GL_TEXTURE_BUFFER, textureID); glTexBuffer(GL_TEXTURE_BUFFER, buffer->format()->openGLFormat, buffer->glBufferID()); glBindTexture(GL_TEXTURE_BUFFER, 0); return shared_ptr<BufferTexture>(new BufferTexture(name, buffer, textureID)); }
GL::TextureBuffer::TextureBuffer(GLuint size, GLenum internal_format) : Tex() , _buffer(size) { _target = GL_TEXTURE_BUFFER; bind(); glTexBuffer(GL_TEXTURE_BUFFER, internal_format, _buffer.get_id()); unbind(); }
void scene_buildings::load_tile(glm::ivec2 pos) { BuildingTileDCData building; building._tile_pos = pos; std::string file_name = "bld_tiles/buildingTile"; file_name += '0' + pos.x; file_name += '0' + pos.y; file_name += ".osm.bin"; // load buildings std::ifstream bif(file_name.c_str(),std::ios::binary); if (!bif.is_open()){ _app->shutdown(); return; } std::vector<Building> blds; uint32 blockCount = 0; bif.read((char*)(&blockCount),sizeof(uint32)); base::stats()._ntriangles += uint64(blockCount) * 10; base::stats()._nvertices += uint64(blockCount) * 8; base::stats()._ndrawcalls++; std::vector<glm::ivec4> blocks; blocks.resize(blockCount); bif.read((char*)(blocks.begin()._Ptr), sizeof(glm::ivec4)*blockCount); building._blocks_count = blockCount; building._blocks_vbo = base::create_buffer<glm::int4>(blockCount, 0, blocks.begin()._Ptr); glGenTextures(1, &building._blocks_tb); glBindTexture(GL_TEXTURE_BUFFER, building._blocks_tb); glTexBuffer(GL_TEXTURE_BUFFER, base::get_pfd(base::PF_RGBA32I)->_internal, building._blocks_vbo); glBindTexture(GL_TEXTURE_BUFFER, 0); _tiles.push_back(building); base::cfg().buildings_count += blockCount; }
void GLGpuBufferCore::initialize() { // Create buffer const auto& props = getProperties(); UINT32 size = props.getElementCount() * props.getElementSize(); mBuffer.initialize(GL_TEXTURE_BUFFER, size, props.getUsage()); // Create texture glGenTextures(1, &mTextureID); glBindTexture(GL_TEXTURE_BUFFER, mTextureID); glTexBuffer(GL_TEXTURE_BUFFER, mFormat, mBuffer.getGLBufferId()); BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_GpuBuffer); GpuBufferCore::initialize(); }
void gr_opengl_update_transform_buffer(void* data, size_t size) { if ( Transform_buffer_handle < 0 || size <= 0 ) { return; } gr_opengl_update_buffer_data(Transform_buffer_handle, size, data); opengl_buffer_object &buffer_obj = GL_buffer_objects[Transform_buffer_handle]; // need to rebind the buffer object to the texture buffer after it's been updated. // didn't have to do this on AMD and Nvidia drivers but Intel drivers seem to want it. glBindTexture(GL_TEXTURE_BUFFER, buffer_obj.texture); glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, buffer_obj.buffer_id); }
bool TextureBuffer::init(GLsizeiptr count, GLenum internal_format /*GL_R32F */, GLsizeiptr size, GLenum usage /* GL_STATIC_DRAW ...*/) { SCOPE_profile_cpu_function("TextureBuffer"); AGE_ASSERT(_bufferHandle == -1 && _textureHandle == -1 && _count == 0 && _size == 0 && _buffer == nullptr); _count = count; _size = size; glGenBuffers(1, &_bufferHandle); bindBuffer(); glBufferData(GL_TEXTURE_BUFFER, size * count, nullptr, usage); glGenTextures(1, &_textureHandle); bind(); glTexBuffer(GL_TEXTURE_BUFFER, internal_format, _bufferHandle); _buffer = (char*)AGE_MALLOC(size * count); return true; }
OsdPtexCoordinatesTextureBuffer::OsdPtexCoordinatesTextureBuffer(FarMesh<OsdVertex> *farMesh, int level) { const std::vector<int> &ptexCoordinates = farMesh->GetPtexCoordinates(level); // creates buffer even if the ptexCoordinates is empty. int size = (int)ptexCoordinates.size() * sizeof(GLint); GLuint buffer; glGenBuffers(1, &buffer); glBindBuffer(GL_TEXTURE_BUFFER, buffer); glBufferData(GL_TEXTURE_BUFFER, size, &(ptexCoordinates[0]), GL_STATIC_DRAW); glGenTextures(1, &_texture); glBindTexture(GL_TEXTURE_BUFFER, _texture); glTexBuffer(GL_TEXTURE_BUFFER, GL_RG32I, buffer); glDeleteBuffers(1, &buffer); glBindTexture(GL_TEXTURE_BUFFER, 0); }
static GLuint genTextureBuffer(GLenum format, GLsizeiptr size, GLvoid const * data) { GLuint buffer, result; glGenBuffers(1, &buffer); glBindBuffer(GL_TEXTURE_BUFFER, buffer); glBufferData(GL_TEXTURE_BUFFER, size, data, GL_STATIC_DRAW); glGenTextures(1, & result); glBindTexture(GL_TEXTURE_BUFFER, result); glTexBuffer(GL_TEXTURE_BUFFER, format, buffer); // need to reset texture binding before deleting the source buffer. glBindTexture(GL_TEXTURE_BUFFER, 0); glDeleteBuffers(1, &buffer); return result; }