void OnBeforeRender()
{
glUseProgram(program_handle);
glUniform1ui(uniform_window_width,(GLuint)Window::width);
glUniform1ui(uniform_window_height,(GLuint)Window::height);
glUseProgram(0);
}
// sets uniforms that are used in both shader_tick and shader_display
void setSharedShaderUniforms(Shader &s) {
glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, connectionMapTexture);
glUniform1i( glGetUniformLocation(s.id(), "connectionMap"), 2);
glUniform1f( glGetUniformLocation(s.id(), "time"), time_sinceInit());
glUniform1i( glGetUniformLocation(s.id(), "lastTick"), 0);
glUniform1ui(glGetUniformLocation(s.id(), "maxVolumes"), maxVolumes);
glUniform1ui(glGetUniformLocation(s.id(), "maxCapacity"), maxCapacity);
}
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);
}
int gl_Uniformui(State& state){
int argc = state.stack->getTop();
switch (argc){
case 5:
glUniform4ui((GLint)state.stack->to<int>(1), (GLuint)state.stack->to<int>(2), (GLuint)state.stack->to<int>(3), (GLuint)state.stack->to<int>(4), (GLuint)state.stack->to<int>(5));
break;
case 4:
glUniform3ui((GLint)state.stack->to<int>(1), (GLuint)state.stack->to<int>(2), (GLuint)state.stack->to<int>(3), (GLuint)state.stack->to<int>(4));
break;
case 3:
glUniform2ui((GLint)state.stack->to<int>(1), (GLuint)state.stack->to<int>(2), (GLuint)state.stack->to<int>(3));
break;
case 2:
if (state.stack->is<LUA_TTABLE>(2)){
size_t size = 0;
GLuint * data;
vector<unsigned int> _data;
size = getArray<unsigned int>(state, 2, _data);
data = _data.data();
glUniform1uiv((GLint)state.stack->to<int>(1), (GLsizei)size, (GLuint *)data);
}
else if (state.stack->is<LUA_TNUMBER>(2)){
glUniform1ui((GLint)state.stack->to<int>(1), (GLuint)state.stack->to<int>(2));
}
break;
default:
break;
}
return 0;
}
void Program::uniform1ui(const char* name, GLuint i)
{
this->bind();
GLint u = this->uniform(name);
glUniform1ui(u, i);
}
void ShaderProgram::setUniform(const GLchar *name, unsigned int x)
{
if (!isInUse())
use();
glUniform1ui(getUniformLocation(name), x);
}
void ObjectRenderer::set_uniform_uint(const char* name, unsigned int value)
{
assert(program.isLinked());
program.bind();
GLuint id = glGetUniformLocation(program.programId(), name);
glUniform1ui(id, value);
program.release();
}
void ShaderProgram::setUniform(const std::string& name, u32 x) const
{
checkInUse();
s32 loc{getUniformLocation(name)};
if (loc == -1)
return;
glUniform1ui(loc, x);
}
void ROC::ShaderUniform::Update()
{
if(!m_updated)
{
switch(m_type)
{
case SUT_Float:
glUniform1f(m_uniform, m_float[0]);
break;
case SUT_Float2:
glUniform2f(m_uniform, m_float[0], m_float[1]);
break;
case SUT_Float3:
glUniform3f(m_uniform, m_float[0], m_float[1], m_float[2]);
break;
case SUT_Float4:
glUniform4f(m_uniform, m_float[0], m_float[1], m_float[2], m_float[3]);
break;
case SUT_Int: case SUT_Sampler: case SUT_ShadowSampler: case SUT_CubeSampler:
glUniform1i(m_uniform, m_int[0]);
break;
case SUT_Int2:
glUniform2i(m_uniform, m_int[0], m_int[1]);
break;
case SUT_Int3:
glUniform3i(m_uniform, m_int[0], m_int[1], m_int[2]);
break;
case SUT_Int4:
glUniform4i(m_uniform, m_int[0], m_int[1], m_int[2], m_int[3]);
break;
case SUT_Bool:
glUniform1ui(m_uniform, m_bool[0]);
break;
case SUT_Bool2:
glUniform2ui(m_uniform, m_bool[0], m_bool[1]);
break;
case SUT_Bool3:
glUniform3ui(m_uniform, m_bool[0], m_bool[1], m_bool[2]);
break;
case SUT_Bool4:
glUniform4ui(m_uniform, m_bool[0], m_bool[1], m_bool[2], m_bool[3]);
break;
case SUT_Mat2:
glUniformMatrix2fv(m_uniform, 1, GL_FALSE, m_float);
break;
case SUT_Mat3:
glUniformMatrix3fv(m_uniform, 1, GL_FALSE, m_float);
break;
case SUT_Mat4:
glUniformMatrix4fv(m_uniform, 1, GL_FALSE, m_float);
break;
}
m_updated = true;
}
}
void GLFuncs::SetUniform(GLuint programId, const string &name, GLuint val) {
if (programId != 0) {
GLint location = getUniformLocation(programId, name);
if (location != -1) {
this->UseProgram(programId);
glUniform1ui(location, val);
}
}
}
void ShaderProgram::SetUniform(const std::string name, const bool b)
{
GLint location = glGetUniformLocation( handle_, name.c_str() );
if(location != -1){
glUniform1ui(location, b);
}else{
DEBUG_MESSAGE("Uniform variable " << name << " not found.");
}
}
// Shader Program //
void ShaderProgram::Uniformui(const char * uniformName, GLuint v0) {
GLint loc = glGetUniformLocation(this->ID, uniformName);
if (loc != -1) {
glUniform1ui(loc, v0);
}
else {
throw Exception(DSGL_UNIFORM_LOCATION_DOESNT_EXISTS, DSGL_MSG_UNIFORM_LOCATION_DOESNT_EXISTS);
}
}
void Program::loadObjectIndex(const unsigned int index)
{
use();
GLint location = glGetUniformLocation(m_Id, m_UNIFORM_NAMES.objectIndex.c_str());
if (location == -1) {
throw std::runtime_error("Error getting uniform location for cameraPosition");
}
glUniform1ui(location, index+1); //saved with 1 added to distinguish no object from object with id 0
}
void ShaderProgram::Set(const char *name, unsigned int value)
{
if (usedProg != 0 && usedProg != prog) {
TODO("Fix bug!");
}
int uniform = getUniformLocation(name);
if (uniform == -1) return;
glUniform1ui(uniform, value);
}
bool Shader::setShaderUniform(const std::string &name, GLuint v0)
{
GLint loc;
if(!this->getUniformLoc(name, loc))
return false;
glUniform1ui(loc, v0);
return true;
}
void GraphicsEngine::LightCullingPass(Engine::World * world)
{
int workGroupsX = (SCREEN_SIZE_X + (SCREEN_SIZE_X % GRID_SIZE)) / GRID_SIZE;
int workGroupsY = (SCREEN_SIZE_Y + (SCREEN_SIZE_Y % GRID_SIZE)) / GRID_SIZE;
GraphicsCore::GPUAPI::UseShader(g_LightCullingProgram);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, g_DepthPrePassFBO.texId);
glm::mat4 projInv = glm::inverse(*(world->GetCamera()->GetPerspectiveMat()));
glUniformMatrix4fv(glGetUniformLocation(g_LightCullingProgram, "inverseProj"), 1, GL_FALSE, glm::value_ptr(projInv));
auto* lights = world->GetLights();
glUniform1ui(glGetUniformLocation(g_LightCullingProgram, "numLights"), static_cast<uint32_t>(lights->size()));
// DEBUGGING STUFF TO REMOVE!!!!
for (int i = 0; i < lights->size(); i++) {
Light& light = (*lights)[i];
float min = 0;
float max = 16;
glm::vec4 pos = light.GetWorldSpacePosition();
//int test = rand() % 3;
light.SetWorldSpacePosition(glm::vec4(fmod((pos.x + (-4.5f * 0.01f) - min + max), max) + min, pos.y, pos.z, 1.0f));
}
// END OF DEBUGGING STUFF!!!
for(uint32_t i = 0; i < world->GetLights()->size(); ++i)
{
(*lights)[i].UpdateViewSpaceCoord(world->GetCamera()->GetViewMatrix());
}
g_LightBufferSSBO.Init(world->GetLights()->size() * sizeof(Renderer::Light), GraphicsCore::BufferUsage::DynamicDraw, static_cast<void*>(world->GetLights()->data()));
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, g_LightBufferSSBO.SSBO);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, g_FrustrumSSBO.SSBO);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, g_OpaqueLightGridSSBO.SSBO);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, g_TransparentLightGridSSBO.SSBO);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, g_OpaqueLightIndexListSSBO.SSBO);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 5, g_TransparentLightIndexListSSBO.SSBO);
uint32_t opaqueLightInitValue = 0;
g_OpaqueLightIndexCounterSSBO.Init(1 * sizeof(uint32_t), GraphicsCore::BufferUsage::DynamicCopy, &opaqueLightInitValue);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 6, g_OpaqueLightIndexCounterSSBO.SSBO);
uint32_t transparentLightInitValue = 0;
g_TransparentLightIndexCounterSSBO.Init(1 * sizeof(uint32_t), GraphicsCore::BufferUsage::DynamicCopy, &opaqueLightInitValue);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 7, g_TransparentLightIndexCounterSSBO.SSBO);
glDispatchCompute(workGroupsX, workGroupsY, 1);
glBindTexture(GL_TEXTURE_2D, 0);
}
void Planet::Draw()
{
int texLoc = glGetUniformLocation(shaderId, "texture");
if (texLoc>-1)
glUniform1ui(texLoc, texId[currTexture]);
glBindTexture(GL_TEXTURE_2D, texId[currTexture]);
glBindVertexArray(vao);
glDrawElements(GL_TRIANGLES, indexesCount, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
}
void Terrain::render(Shader *shader) {
computeModelMatrix();
glUniformMatrix4fv(shader->loc_model_matrix, 1, false, glm::value_ptr(Model));
glUniform1ui(shader->loc_displacement_factor, displacement_factor);
glBindVertexArray(VAO);
glPatchParameteri(GL_PATCH_VERTICES, 3);
glDrawElements(GL_PATCHES, n_indices, GL_UNSIGNED_INT, NULL);
glBindVertexArray(0);
}
void Shader::setUniform<unsigned int>(const std::string& name, const unsigned int& data) {
int prev_bound_program;
glGetIntegerv(GL_CURRENT_PROGRAM, &prev_bound_program);
if(name_to_location.count(name) == 0) {
throw Exceptions::InvalidUniformNameException(name);
}
if(prev_bound_program != program_object)
useProgram();
glUniform1ui(name_to_location[name], data);
if(prev_bound_program != program_object)
glUseProgram(prev_bound_program);
}
void draw(Data*data){
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glUseProgram(data->program);
glUniformMatrix4fv(data->mvpUniform,1,GL_FALSE,glm::value_ptr(data->mvp));
glUniform1ui(data->modeUniform,data->mode);
glBindVertexArray(data->vao);
glDrawArrays(GL_TRIANGLES,0,3);
glBindVertexArray(0);
}
void Terrain::Draw(unsigned int &m_program)
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, this->m_texture);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, this->m_rockD);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, this->m_rockN);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, this->m_snowD);
glActiveTexture(GL_TEXTURE4);
glBindTexture(GL_TEXTURE_2D, this->m_snowN);
unsigned int LightDirUniform = glGetUniformLocation(m_program, "LightDir");
//glUniform3f(LightDirUniform, m_camera->getTransform()[3][0], m_camera->getTransform()[3][1], m_camera->getTransform()[3][2]);
glUniform3f(LightDirUniform, light.x, light.y, light.z);
//glUniform3f(LightDirUniform, 1, 1, 1);
unsigned int LightColourUniform = glGetUniformLocation(m_program, "LightColour");
glUniform3f(LightColourUniform, lightColour.x, lightColour.y, lightColour.z);
unsigned int textureBlendUniform = glGetUniformLocation(m_program, "textureBlend");
glUniform1f(textureBlendUniform, textureBlend);
unsigned int diffuseUniform = glGetUniformLocation(m_program, "diffuse");
glUniform1i(diffuseUniform, 0);
diffuseUniform = glGetUniformLocation(m_program, "ground_textureD");
glUniform1i(diffuseUniform, 1);
unsigned int normalUniform = glGetUniformLocation(m_program, "ground_textureN");
glUniform1i(normalUniform, 2);
diffuseUniform = glGetUniformLocation(m_program, "snow_textureD");
glUniform1i(diffuseUniform, 3);
normalUniform = glGetUniformLocation(m_program, "snow_textureN");
glUniform1i(normalUniform, 4);
unsigned int dimensionUniform = glGetUniformLocation(m_program, "dimension");
glUniform1ui(dimensionUniform, this->dimension);
glBindVertexArray(m_VAO);
unsigned int indexCount = (dimension - 1)*(dimension - 1) * 6;
glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, 0);
}
static void SetUniforms()
{
if (sg_loaded)
{
glUseProgram(sg_shaderID);
glUniformMatrix4fv(sg_projectionViewLocation, 1, false, glm::value_ptr(Engine::GetProjectionViewMatrix()));
glUniform3fv(sg_cameraPositionLocation, 1, &sg_cameraPosition[0]);
glUniform3fv(sg_ambientLightLocation, 1, &sg_lightAmbient[0]);
for (unsigned int i = 0; i < sg_lightCount; ++i)
UpdateLight(i);
glUniform1ui(sg_lightCountLocation, sg_lightCount);
glUniform1i(sg_textureLocation, 0);
}
}
static void Render(const Model& a_model)
{
// Set uniform values
SetUniforms();
glUniformMatrix4fv(sg_modelLocation, 1, false, glm::value_ptr(a_model.modelMatrix));
glUniform4fv(sg_diffuseColorLocation, 1, &(a_model.texture.diffuseColor[0]));
glUniform4fv(sg_specularColorLocation, 1, &(a_model.texture.specularColor[0]));
if (GL_TRUE == glIsTexture(a_model.texture.imageID))
{
glUniform1ui(sg_hasTextureLocation, GL_TRUE);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, a_model.texture.imageID);
}
else
{
glUniform1ui(sg_hasTextureLocation, GL_FALSE);
}
// draw triangles
glBindVertexArray(a_model.mesh.vertexArrayID);
glDrawElements(GL_TRIANGLES, a_model.mesh.indexCount, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
}
void chip8::setupTexture()
{
glGenVertexArrays(1, &VAOHandles[0]);
glBindVertexArray(VAOHandles[0]);
glGenBuffers(1, &VBOHandles[0]);
glBindBuffer(GL_ARRAY_BUFFER, VBOHandles[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertex) + sizeof(texCoordinates), NULL, GL_STATIC_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertex), vertex);
glBufferSubData(GL_ARRAY_BUFFER, sizeof(vertex), sizeof(texCoord), texCoordinates);
glGenBuffers(1, elemIndHandles);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elemIndHandles[0]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(vertexIndex), vertexIndex, GL_STATIC_DRAW);
glGenTextures(1, &texBufferHandles[0]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texBufferHandles[0]);
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, SCREEN_WIDTH, SCREEN_HEIGTH);
glTexSubImage2D(GL_TEXTURE_2D, 0,
0, 0,
SCREEN_WIDTH, SCREEN_HEIGTH,
GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid*)gfx);
loadShaderProgram();
uniformBuffHandles[0] = glGetUniformLocation(pHandle, "tex");
glUniform1ui(uniformBuffHandles[0], 0);
glVertexAttribPointer(vertexPos, 2, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(vertexPos);
glVertexAttribPointer(texCoord, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(vertex));
glEnableVertexAttribArray(texCoord);
glBindBuffer(GL_ARRAY_BUFFER, VBOHandles[0]);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elemIndHandles[0]);
glBindTexture(GL_TEXTURE_2D, texBufferHandles[0]);
glBindVertexArray(0);
glClear(GL_COLOR_BUFFER_BIT);
glActiveTexture(GL_TEXTURE0);
glBindVertexArray(VAOHandles[0]);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
glutSwapBuffers();
}
void ParticleManager::loadUintUniform(GLuint shaderProgramID, std::string name, GLuint value){
glGetError();
int _uniID = glGetUniformLocation(shaderProgramID, name.c_str());
if(glGetError() != GL_NO_ERROR){
throw std::exception(("ERROR: Could not get "+name+"-uniform-location!").c_str());
}
glUniform1ui(_uniID, value);
if(glGetError() != GL_NO_ERROR){
throw std::exception(("ERROR: Could not update "+name+"-uniform-location!").c_str());
}
}
int teatime_run_program(teatime_t *obj, const uint32_t ikey[4], uint32_t rounds)
{
if (obj && obj->program > 0) {
int rc = 0;
do {
glUseProgram(obj->program);
TEATIME_BREAKONERROR(glUseProgram, rc);
glActiveTexture(GL_TEXTURE0);
TEATIME_BREAKONERROR(glActiveTexture, rc);
glBindTexture(GL_TEXTURE_2D, obj->itexid);
TEATIME_BREAKONERROR(glBindTexture, rc);
glUniform1i(obj->locn_input, 0);
TEATIME_BREAKONERROR(glUniform1i, rc);
glActiveTexture(GL_TEXTURE1);
TEATIME_BREAKONERROR(glActiveTexture, rc);
glBindTexture(GL_TEXTURE_2D, obj->otexid);
TEATIME_BREAKONERROR(glBindTexture, rc);
glUniform1i(obj->locn_output, 1);
TEATIME_BREAKONERROR(glUniform1i, rc);
glUniform4uiv(obj->locn_key, 1, ikey);
TEATIME_BREAKONERROR(glUniform1uiv, rc);
glUniform1ui(obj->locn_rounds, rounds);
TEATIME_BREAKONERROR(glUniform1ui, rc);
glFinish();
glPolygonMode(GL_FRONT, GL_FILL);
/* render */
glBegin(GL_QUADS);
glTexCoord2i(0, 0);
glVertex2i(0, 0);
//glTexCoord2i(obj->tex_size, 0);
glTexCoord2i(1, 0);
glVertex2i(obj->tex_size, 0);
//glTexCoord2i(obj->tex_size, obj->tex_size);
glTexCoord2i(1, 1);
glVertex2i(obj->tex_size, obj->tex_size);
glTexCoord2i(0, 1);
//glTexCoord2i(0, obj->tex_size);
glVertex2i(0, obj->tex_size);
glEnd();
glFinish();
TEATIME_BREAKONERROR_FB(Rendering, rc);
TEATIME_BREAKONERROR(Rendering, rc);
rc = 0;
} while (0);
return rc;
}
return -EINVAL;
}
void ScanSystem::combineWithOffsets(GLuint elements, const Buffer& output, const Buffer& offsets )
{
//assert((elements % 4) == 0);
assert(elements * sizeof(GLuint) <= output.size);
glUseProgram(programs.combine);
glUniform1ui(0,elements);
offsets.BindBufferRange(GL_SHADER_STORAGE_BUFFER, 1);
output.BindBufferRange(GL_SHADER_STORAGE_BUFFER, 0);
glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
GLuint groups = snapdiv(elements,GROUPSIZE);
assert(groups < maxGrpsCombine);
glDispatchCompute(groups,1,1);
}
void Shader::setUniform(int location, int type, const GLuint* val) const
{
switch(type)
{
case GL_UNSIGNED_INT:
glUniform1ui(location,val[0]);
break;
case GL_UNSIGNED_INT_VEC2:
glUniform2ui(location,val[0],val[1]);
break;
case GL_UNSIGNED_INT_VEC3:
glUniform3ui(location,val[0],val[1],val[2]);
break;
case GL_UNSIGNED_INT_VEC4:
glUniform4ui(location,val[0],val[1],val[2],val[3]);
break;
}
}
void ShaderProgram::setLocalParamUInt(int i, unsigned int value)
{
if (shaders_supported())
{
const char *loc_strings[] = {"loci0", "loci1", "loci2", "loci3",
"loci4", "loci5", "loci6", "loci7",
"loci8", "loci9", "loci10", "loci11",
"loci12", "loci13", "loci14", "loci15"};
if (loc_ui[i] == -1)
{
loc_ui[i] = glGetUniformLocation(id_, loc_strings[i]);
if (loc_ui[i] == -1)
loc_ui[i]--;
}
if (loc_ui[i] >= 0)
glUniform1ui(loc_ui[i], value);
}
}
void scene_buildings::gpu_draw(base::frame_context * const ctx){
base::hptimer timer;
timer.start();
if (base::cfg().no_cull){
glDisable(GL_CULL_FACE);
}
glUseProgram(_prg);
// this is only needed on AMD cards due to driver bug wich needs
// to have attr0 array anabled
//base::set_attr0_vbo_amd_wa();
glQueryCounter(ctx->_time_queries[0], GL_TIMESTAMP);
glUniformMatrix4fv(_prg_mvp, 1, GL_FALSE, glm::value_ptr(ctx->_mvp));
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indices_vbo);
glUniform1i(_prg_tb_blocks, 0);
glActiveTexture(GL_TEXTURE0);
// bind scene texture buffers
for (uint32 i = 0; i < _tiles.size(); i++){
int x = _tiles[i]._tile_pos.x;
int y = _tiles[i]._tile_pos.y;
glUniform2i(_prg_tile_offset, x,y);
glUniform1ui(_prg_total_count, _tiles[i]._blocks_count);
glBindTexture(GL_TEXTURE_BUFFER, _tiles[i]._blocks_tb);
glDrawElementsInstanced(GL_TRIANGLES,
10 * 3 * base::cfg().blocks_per_idc,
GL_UNSIGNED_INT,
0,
(_tiles[i]._blocks_count + base::cfg().blocks_per_idc - 1) / base::cfg().blocks_per_idc);
}
ctx->_cpu_render_time = timer.elapsed_time();
glQueryCounter(ctx->_time_queries[1], GL_TIMESTAMP);
}
