Пример #1
1
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);
}
Пример #2
0
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");
	}
Пример #4
0
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);
}
Пример #5
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);
}
Пример #7
0
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;
}
Пример #8
0
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;
}
Пример #9
0
        //--------------------------------------------------------------
        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();
        }
Пример #10
0
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;
}
Пример #11
0
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;
}
Пример #12
0
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;
}
Пример #14
0
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;
}
Пример #15
0
Файл: t.cpp Проект: soulik/luagl
	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;
	}
Пример #16
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);
}
Пример #18
0
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);

}
Пример #19
0
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();
}
Пример #20
0
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");
}
Пример #21
0
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);
}
Пример #22
0
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);
            }
        }
    }
}
Пример #23
0
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));
}
Пример #24
0
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();

}
Пример #25
0
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;
}
Пример #26
0
	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();
	}
Пример #27
0
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);
}
Пример #28
0
	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);
}
Пример #30
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;
}