-#define GL_GLEXT_PROTOTYPES 1
-
#include <epoxy/gl.h>
#include <assert.h>
#include <math.h>
EffectChain::EffectChain(float aspect_nom, float aspect_denom, ResourcePool *resource_pool)
: aspect_nom(aspect_nom),
aspect_denom(aspect_denom),
+ output_color_rgba(false),
+ output_color_ycbcr(false),
dither_effect(NULL),
num_dither_bits(0),
+ output_origin(OUTPUT_ORIGIN_BOTTOM_LEFT),
finalized(false),
resource_pool(resource_pool),
do_phase_timing(false) {
} else {
owns_resource_pool = false;
}
+
+ // Generate a VBO with some data in (shared position and texture coordinate data).
+ float vertices[] = {
+ 0.0f, 2.0f,
+ 0.0f, 0.0f,
+ 2.0f, 0.0f
+ };
+ vbo = generate_vbo(2, GL_FLOAT, sizeof(vertices), vertices);
}
EffectChain::~EffectChain()
if (owns_resource_pool) {
delete resource_pool;
}
+ glDeleteBuffers(1, &vbo);
+ check_error();
}
Input *EffectChain::add_input(Input *input)
void EffectChain::add_output(const ImageFormat &format, OutputAlphaFormat alpha_format)
{
assert(!finalized);
+ assert(!output_color_rgba);
output_format = format;
output_alpha_format = alpha_format;
- output_color_type = OUTPUT_COLOR_RGB;
+ output_color_rgba = true;
}
void EffectChain::add_ycbcr_output(const ImageFormat &format, OutputAlphaFormat alpha_format,
- const YCbCrFormat &ycbcr_format)
+ const YCbCrFormat &ycbcr_format, YCbCrOutputSplitting output_splitting)
{
assert(!finalized);
+ assert(!output_color_ycbcr);
output_format = format;
output_alpha_format = alpha_format;
- output_color_type = OUTPUT_COLOR_YCBCR;
+ output_color_ycbcr = true;
output_ycbcr_format = ycbcr_format;
+ output_ycbcr_splitting = output_splitting;
assert(ycbcr_format.chroma_subsampling_x == 1);
assert(ycbcr_format.chroma_subsampling_y == 1);
return GL_TEXTURE0 + node->incoming_links[input_num]->bound_sampler_num;
}
+GLenum EffectChain::has_input_sampler(Node *node, unsigned input_num) const
+{
+ assert(input_num < node->incoming_links.size());
+ return node->incoming_links[input_num]->bound_sampler_num >= 0 &&
+ node->incoming_links[input_num]->bound_sampler_num < 8;
+}
+
void EffectChain::find_all_nonlinear_inputs(Node *node, vector<Node *> *nonlinear_inputs)
{
if (node->output_gamma_curve == GAMMA_LINEAR &&
return effect;
}
-// GLSL pre-1.30 doesn't support token pasting. Replace PREFIX(x) with <effect_id>_x.
+// ESSL doesn't support token pasting. Replace PREFIX(x) with <effect_id>_x.
string replace_prefix(const string &text, const string &prefix)
{
string output;
return output;
}
+namespace {
+
+template<class T>
+void extract_uniform_declarations(const vector<Uniform<T> > &effect_uniforms,
+ const string &type_specifier,
+ const string &effect_id,
+ vector<Uniform<T> > *phase_uniforms,
+ string *glsl_string)
+{
+ for (unsigned i = 0; i < effect_uniforms.size(); ++i) {
+ phase_uniforms->push_back(effect_uniforms[i]);
+ phase_uniforms->back().prefix = effect_id;
+
+ *glsl_string += string("uniform ") + type_specifier + " " + effect_id
+ + "_" + effect_uniforms[i].name + ";\n";
+ }
+}
+
+template<class T>
+void extract_uniform_array_declarations(const vector<Uniform<T> > &effect_uniforms,
+ const string &type_specifier,
+ const string &effect_id,
+ vector<Uniform<T> > *phase_uniforms,
+ string *glsl_string)
+{
+ for (unsigned i = 0; i < effect_uniforms.size(); ++i) {
+ phase_uniforms->push_back(effect_uniforms[i]);
+ phase_uniforms->back().prefix = effect_id;
+
+ char buf[256];
+ snprintf(buf, sizeof(buf), "uniform %s %s_%s[%d];\n",
+ type_specifier.c_str(), effect_id.c_str(),
+ effect_uniforms[i].name.c_str(),
+ int(effect_uniforms[i].num_values));
+ *glsl_string += buf;
+ }
+}
+
+template<class T>
+void collect_uniform_locations(GLuint glsl_program_num, vector<Uniform<T> > *phase_uniforms)
+{
+ for (unsigned i = 0; i < phase_uniforms->size(); ++i) {
+ Uniform<T> &uniform = (*phase_uniforms)[i];
+ uniform.location = get_uniform_location(glsl_program_num, uniform.prefix, uniform.name);
+ }
+}
+
+} // namespace
+
void EffectChain::compile_glsl_program(Phase *phase)
{
string frag_shader_header = read_version_dependent_file("header", "frag");
string frag_shader = "";
- // Create functions for all the texture inputs that we need.
+ // Create functions and uniforms for all the texture inputs that we need.
for (unsigned i = 0; i < phase->inputs.size(); ++i) {
Node *input = phase->inputs[i]->output_node;
char effect_id[256];
frag_shader += "\treturn tex2D(tex_" + string(effect_id) + ", tc);\n";
frag_shader += "}\n";
frag_shader += "\n";
+
+ Uniform<int> uniform;
+ uniform.name = effect_id;
+ uniform.value = &phase->input_samplers[i];
+ uniform.prefix = "tex";
+ uniform.num_values = 1;
+ uniform.location = -1;
+ phase->uniforms_sampler2d.push_back(uniform);
}
// Give each effect in the phase its own ID.
frag_shader += "\n";
}
frag_shader += string("#define INPUT ") + phase->effect_ids[phase->effects.back()] + "\n";
- frag_shader.append(read_version_dependent_file("footer", "frag"));
+
+ // If we're the last phase, add the right #defines for Y'CbCr multi-output as needed.
+ vector<string> frag_shader_outputs; // In order.
+ if (phase->output_node->outgoing_links.empty() && output_color_ycbcr) {
+ switch (output_ycbcr_splitting) {
+ case YCBCR_OUTPUT_INTERLEAVED:
+ // No #defines set.
+ frag_shader_outputs.push_back("FragColor");
+ break;
+ case YCBCR_OUTPUT_SPLIT_Y_AND_CBCR:
+ frag_shader += "#define YCBCR_OUTPUT_SPLIT_Y_AND_CBCR 1\n";
+ frag_shader_outputs.push_back("Y");
+ frag_shader_outputs.push_back("Chroma");
+ break;
+ case YCBCR_OUTPUT_PLANAR:
+ frag_shader += "#define YCBCR_OUTPUT_PLANAR 1\n";
+ frag_shader_outputs.push_back("Y");
+ frag_shader_outputs.push_back("Cb");
+ frag_shader_outputs.push_back("Cr");
+ break;
+ default:
+ assert(false);
+ }
+
+ if (output_color_rgba) {
+ // Note: Needs to come in the header, because not only the
+ // output needs to see it (YCbCrConversionEffect and DitherEffect
+ // do, too).
+ frag_shader_header += "#define YCBCR_ALSO_OUTPUT_RGBA 1\n";
+ frag_shader_outputs.push_back("RGBA");
+ }
+ }
+ frag_shader.append(read_file("footer.frag"));
// Collect uniforms from all effects and output them. Note that this needs
// to happen after output_fragment_shader(), even though the uniforms come
Node *node = phase->effects[i];
Effect *effect = node->effect;
const string effect_id = phase->effect_ids[node];
- for (unsigned j = 0; j < effect->uniforms_bool.size(); ++j) {
- phase->uniforms_bool.push_back(effect->uniforms_bool[j]);
- phase->uniforms_bool.back().prefix = effect_id;
- frag_shader_uniforms += string("uniform bool ") + effect_id
- + "_" + effect->uniforms_bool[j].name + ";\n";
- }
- for (unsigned j = 0; j < effect->uniforms_int.size(); ++j) {
- phase->uniforms_int.push_back(effect->uniforms_int[j]);
- phase->uniforms_int.back().prefix = effect_id;
- frag_shader_uniforms += string("uniform int ") + effect_id
- + "_" + effect->uniforms_int[j].name + ";\n";
- }
- for (unsigned j = 0; j < effect->uniforms_sampler2d.size(); ++j) {
- phase->uniforms_int.push_back(effect->uniforms_sampler2d[j]);
- phase->uniforms_int.back().prefix = effect_id;
- frag_shader_uniforms += string("uniform sampler2D ") + effect_id
- + "_" + effect->uniforms_sampler2d[j].name + ";\n";
- }
- for (unsigned j = 0; j < effect->uniforms_float.size(); ++j) {
- phase->uniforms_float.push_back(effect->uniforms_float[j]);
- phase->uniforms_float.back().prefix = effect_id;
- frag_shader_uniforms += string("uniform float ") + effect_id
- + "_" + effect->uniforms_float[j].name + ";\n";
- }
- for (unsigned j = 0; j < effect->uniforms_vec2.size(); ++j) {
- phase->uniforms_vec2.push_back(effect->uniforms_vec2[j]);
- phase->uniforms_vec2.back().prefix = effect_id;
- frag_shader_uniforms += string("uniform vec2 ") + effect_id
- + "_" + effect->uniforms_vec2[j].name + ";\n";
- }
- for (unsigned j = 0; j < effect->uniforms_vec3.size(); ++j) {
- phase->uniforms_vec3.push_back(effect->uniforms_vec3[j]);
- phase->uniforms_vec3.back().prefix = effect_id;
- frag_shader_uniforms += string("uniform vec3 ") + effect_id
- + "_" + effect->uniforms_vec3[j].name + ";\n";
- }
- for (unsigned j = 0; j < effect->uniforms_vec4.size(); ++j) {
- phase->uniforms_vec4.push_back(effect->uniforms_vec4[j]);
- phase->uniforms_vec4.back().prefix = effect_id;
- frag_shader_uniforms += string("uniform vec4 ") + effect_id
- + "_" + effect->uniforms_vec4[j].name + ";\n";
- }
- for (unsigned j = 0; j < effect->uniforms_vec2_array.size(); ++j) {
- char buf[256];
- phase->uniforms_vec2.push_back(effect->uniforms_vec2_array[j]);
- phase->uniforms_vec2.back().prefix = effect_id;
- snprintf(buf, sizeof(buf), "uniform vec2 %s_%s[%d];\n",
- effect_id.c_str(), effect->uniforms_vec2_array[j].name.c_str(),
- int(effect->uniforms_vec2_array[j].num_values));
- frag_shader_uniforms += buf;
- }
- for (unsigned j = 0; j < effect->uniforms_vec4_array.size(); ++j) {
- char buf[256];
- phase->uniforms_vec4.push_back(effect->uniforms_vec4_array[j]);
- phase->uniforms_vec4.back().prefix = effect_id;
- snprintf(buf, sizeof(buf), "uniform vec4 %s_%s[%d];\n",
- effect_id.c_str(), effect->uniforms_vec4_array[j].name.c_str(),
- int(effect->uniforms_vec4_array[j].num_values));
- frag_shader_uniforms += buf;
- }
- for (unsigned j = 0; j < effect->uniforms_mat3.size(); ++j) {
- phase->uniforms_mat3.push_back(effect->uniforms_mat3[j]);
- phase->uniforms_mat3.back().prefix = effect_id;
- frag_shader_uniforms += string("uniform mat3 ") + effect_id
- + "_" + effect->uniforms_mat3[j].name + ";\n";
- }
+ extract_uniform_declarations(effect->uniforms_sampler2d, "sampler2D", effect_id, &phase->uniforms_sampler2d, &frag_shader_uniforms);
+ extract_uniform_declarations(effect->uniforms_bool, "bool", effect_id, &phase->uniforms_bool, &frag_shader_uniforms);
+ extract_uniform_declarations(effect->uniforms_int, "int", effect_id, &phase->uniforms_int, &frag_shader_uniforms);
+ extract_uniform_declarations(effect->uniforms_float, "float", effect_id, &phase->uniforms_float, &frag_shader_uniforms);
+ extract_uniform_declarations(effect->uniforms_vec2, "vec2", effect_id, &phase->uniforms_vec2, &frag_shader_uniforms);
+ extract_uniform_declarations(effect->uniforms_vec3, "vec3", effect_id, &phase->uniforms_vec3, &frag_shader_uniforms);
+ extract_uniform_declarations(effect->uniforms_vec4, "vec4", effect_id, &phase->uniforms_vec4, &frag_shader_uniforms);
+ extract_uniform_array_declarations(effect->uniforms_float_array, "float", effect_id, &phase->uniforms_float, &frag_shader_uniforms);
+ extract_uniform_array_declarations(effect->uniforms_vec2_array, "vec2", effect_id, &phase->uniforms_vec2, &frag_shader_uniforms);
+ extract_uniform_array_declarations(effect->uniforms_vec3_array, "vec3", effect_id, &phase->uniforms_vec3, &frag_shader_uniforms);
+ extract_uniform_array_declarations(effect->uniforms_vec4_array, "vec4", effect_id, &phase->uniforms_vec4, &frag_shader_uniforms);
+ extract_uniform_declarations(effect->uniforms_mat3, "mat3", effect_id, &phase->uniforms_mat3, &frag_shader_uniforms);
}
frag_shader = frag_shader_header + frag_shader_uniforms + frag_shader;
string vert_shader = read_version_dependent_file("vs", "vert");
- phase->glsl_program_num = resource_pool->compile_glsl_program(vert_shader, frag_shader);
- // Collect the resulting program numbers for each uniform.
- for (unsigned i = 0; i < phase->uniforms_bool.size(); ++i) {
- Uniform<bool> &uniform = phase->uniforms_bool[i];
- uniform.location = get_uniform_location(phase->glsl_program_num, uniform.prefix, uniform.name);
- }
- for (unsigned i = 0; i < phase->uniforms_int.size(); ++i) {
- Uniform<int> &uniform = phase->uniforms_int[i];
- uniform.location = get_uniform_location(phase->glsl_program_num, uniform.prefix, uniform.name);
- }
- for (unsigned i = 0; i < phase->uniforms_float.size(); ++i) {
- Uniform<float> &uniform = phase->uniforms_float[i];
- uniform.location = get_uniform_location(phase->glsl_program_num, uniform.prefix, uniform.name);
- }
- for (unsigned i = 0; i < phase->uniforms_vec2.size(); ++i) {
- Uniform<float> &uniform = phase->uniforms_vec2[i];
- uniform.location = get_uniform_location(phase->glsl_program_num, uniform.prefix, uniform.name);
- }
- for (unsigned i = 0; i < phase->uniforms_vec3.size(); ++i) {
- Uniform<float> &uniform = phase->uniforms_vec3[i];
- uniform.location = get_uniform_location(phase->glsl_program_num, uniform.prefix, uniform.name);
+ // If we're the last phase and need to flip the picture to compensate for
+ // the origin, tell the vertex shader so.
+ if (phase->output_node->outgoing_links.empty() && output_origin == OUTPUT_ORIGIN_TOP_LEFT) {
+ const string needle = "#define FLIP_ORIGIN 0";
+ size_t pos = vert_shader.find(needle);
+ assert(pos != string::npos);
+
+ vert_shader[pos + needle.size() - 1] = '1';
}
- for (unsigned i = 0; i < phase->uniforms_vec4.size(); ++i) {
- Uniform<float> &uniform = phase->uniforms_vec4[i];
- uniform.location = get_uniform_location(phase->glsl_program_num, uniform.prefix, uniform.name);
+
+ phase->glsl_program_num = resource_pool->compile_glsl_program(vert_shader, frag_shader, frag_shader_outputs);
+ GLint position_attribute_index = glGetAttribLocation(phase->glsl_program_num, "position");
+ GLint texcoord_attribute_index = glGetAttribLocation(phase->glsl_program_num, "texcoord");
+ if (position_attribute_index != -1) {
+ phase->attribute_indexes.insert(position_attribute_index);
}
- for (unsigned i = 0; i < phase->uniforms_mat3.size(); ++i) {
- Uniform<Matrix3d> &uniform = phase->uniforms_mat3[i];
- uniform.location = get_uniform_location(phase->glsl_program_num, uniform.prefix, uniform.name);
+ if (texcoord_attribute_index != -1) {
+ phase->attribute_indexes.insert(texcoord_attribute_index);
}
+
+ // Collect the resulting location numbers for each uniform.
+ collect_uniform_locations(phase->glsl_program_num, &phase->uniforms_sampler2d);
+ collect_uniform_locations(phase->glsl_program_num, &phase->uniforms_bool);
+ collect_uniform_locations(phase->glsl_program_num, &phase->uniforms_int);
+ collect_uniform_locations(phase->glsl_program_num, &phase->uniforms_float);
+ collect_uniform_locations(phase->glsl_program_num, &phase->uniforms_vec2);
+ collect_uniform_locations(phase->glsl_program_num, &phase->uniforms_vec3);
+ collect_uniform_locations(phase->glsl_program_num, &phase->uniforms_vec4);
+ collect_uniform_locations(phase->glsl_program_num, &phase->uniforms_mat3);
}
// Construct GLSL programs, starting at the given effect and following
bool start_new_phase = false;
if (node->effect->needs_texture_bounce() &&
- !deps[i]->effect->is_single_texture()) {
+ !deps[i]->effect->is_single_texture() &&
+ !deps[i]->effect->override_disable_bounce()) {
start_new_phase = true;
}
// and create a GLSL program for it.
assert(!phase->effects.empty());
- // Deduplicate the inputs.
- sort(phase->inputs.begin(), phase->inputs.end());
- phase->inputs.erase(unique(phase->inputs.begin(), phase->inputs.end()), phase->inputs.end());
+ // Deduplicate the inputs, but don't change the ordering e.g. by sorting;
+ // that would be nondeterministic and thus reduce cacheability.
+ // TODO: Make this even more deterministic.
+ vector<Phase *> dedup_inputs;
+ set<Phase *> seen_inputs;
+ for (size_t i = 0; i < phase->inputs.size(); ++i) {
+ if (seen_inputs.insert(phase->inputs[i]).second) {
+ dedup_inputs.push_back(phase->inputs[i]);
+ }
+ }
+ swap(phase->inputs, dedup_inputs);
+
+ // Allocate samplers for each input.
+ phase->input_samplers.resize(phase->inputs.size());
// We added the effects from the output and back, but we need to output
// them in topological sort order in the shader.
// gamma-encoded data.
void EffectChain::add_ycbcr_conversion_if_needed()
{
- assert(output_color_type == OUTPUT_COLOR_RGB || output_color_type == OUTPUT_COLOR_YCBCR);
- if (output_color_type != OUTPUT_COLOR_YCBCR) {
+ assert(output_color_rgba || output_color_ycbcr);
+ if (!output_color_ycbcr) {
return;
}
Node *output = find_output_node();
{
assert(finalized);
+ // This needs to be set anew, in case we are coming from a different context
+ // from when we initialized.
+ check_error();
+ glDisable(GL_DITHER);
+ check_error();
+
// Save original viewport.
GLuint x = 0, y = 0;
}
// Basic state.
+ check_error();
glDisable(GL_BLEND);
check_error();
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
check_error();
+ // Generate a VAO that will be used during the entire execution,
+ // and bind the VBO, since it contains all the data.
+ GLuint vao;
+ glGenVertexArrays(1, &vao);
+ check_error();
+ glBindVertexArray(vao);
+ check_error();
+ glBindBuffer(GL_ARRAY_BUFFER, vbo);
+ check_error();
+ set<GLint> bound_attribute_indices;
+
set<Phase *> generated_mipmaps;
// We choose the simplest option of having one texture per output,
CHECK(dither_effect->set_int("output_height", height));
}
}
- execute_phase(phase, phase_num == phases.size() - 1, &output_textures, &generated_mipmaps);
+ execute_phase(phase, phase_num == phases.size() - 1, &bound_attribute_indices, &output_textures, &generated_mipmaps);
if (do_phase_timing) {
glEndQuery(GL_TIME_ELAPSED);
}
glUseProgram(0);
check_error();
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+ check_error();
+ glBindVertexArray(0);
+ check_error();
+ glDeleteVertexArrays(1, &vao);
+ check_error();
+
if (do_phase_timing) {
// Get back the timer queries.
for (unsigned phase_num = 0; phase_num < phases.size(); ++phase_num) {
printf("Total: %5.1f ms\n", total_time_ms);
}
-void EffectChain::execute_phase(Phase *phase, bool last_phase, map<Phase *, GLuint> *output_textures, set<Phase *> *generated_mipmaps)
+void EffectChain::execute_phase(Phase *phase, bool last_phase,
+ set<GLint> *bound_attribute_indices,
+ map<Phase *, GLuint> *output_textures,
+ set<Phase *> *generated_mipmaps)
{
GLuint fbo = 0;
output_textures->insert(make_pair(phase, tex_num));
}
- const GLuint glsl_program_num = phase->glsl_program_num;
- check_error();
- glUseProgram(glsl_program_num);
+ glUseProgram(phase->glsl_program_num);
check_error();
// Set up RTT inputs for this phase.
check_error();
generated_mipmaps->insert(input);
}
- setup_rtt_sampler(glsl_program_num, sampler, phase->effect_ids[input->output_node], phase->input_needs_mipmaps);
+ setup_rtt_sampler(sampler, phase->input_needs_mipmaps);
+ phase->input_samplers[sampler] = sampler; // Bind the sampler to the right uniform.
}
// And now the output. (Already set up for us if it is the last phase.)
for (unsigned i = 0; i < phase->effects.size(); ++i) {
Node *node = phase->effects[i];
unsigned old_sampler_num = sampler_num;
- node->effect->set_gl_state(glsl_program_num, phase->effect_ids[node], &sampler_num);
+ node->effect->set_gl_state(phase->glsl_program_num, phase->effect_ids[node], &sampler_num);
check_error();
if (node->effect->is_single_texture()) {
// from there.
setup_uniforms(phase);
- // Now draw!
- float vertices[] = {
- 0.0f, 2.0f,
- 0.0f, 0.0f,
- 2.0f, 0.0f
- };
-
- GLuint vao;
- glGenVertexArrays(1, &vao);
- check_error();
- glBindVertexArray(vao);
- check_error();
+ // Clean up old attributes if they are no longer needed.
+ for (set<GLint>::iterator attr_it = bound_attribute_indices->begin();
+ attr_it != bound_attribute_indices->end(); ) {
+ if (phase->attribute_indexes.count(*attr_it) == 0) {
+ glDisableVertexAttribArray(*attr_it);
+ check_error();
+ bound_attribute_indices->erase(attr_it++);
+ } else {
+ ++attr_it;
+ }
+ }
- GLuint position_vbo = fill_vertex_attribute(glsl_program_num, "position", 2, GL_FLOAT, sizeof(vertices), vertices);
- GLuint texcoord_vbo = fill_vertex_attribute(glsl_program_num, "texcoord", 2, GL_FLOAT, sizeof(vertices), vertices); // Same as vertices.
+ // Set up the new attributes, if needed.
+ for (set<GLint>::iterator attr_it = phase->attribute_indexes.begin();
+ attr_it != phase->attribute_indexes.end();
+ ++attr_it) {
+ if (bound_attribute_indices->count(*attr_it) == 0) {
+ glEnableVertexAttribArray(*attr_it);
+ check_error();
+ glVertexAttribPointer(*attr_it, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
+ check_error();
+ bound_attribute_indices->insert(*attr_it);
+ }
+ }
glDrawArrays(GL_TRIANGLES, 0, 3);
check_error();
-
- cleanup_vertex_attribute(glsl_program_num, "position", position_vbo);
- cleanup_vertex_attribute(glsl_program_num, "texcoord", texcoord_vbo);
- glUseProgram(0);
- check_error();
-
for (unsigned i = 0; i < phase->effects.size(); ++i) {
Node *node = phase->effects[i];
node->effect->clear_gl_state();
if (!last_phase) {
resource_pool->release_fbo(fbo);
}
-
- glDeleteVertexArrays(1, &vao);
- check_error();
}
void EffectChain::setup_uniforms(Phase *phase)
{
// TODO: Use UBO blocks.
+ for (size_t i = 0; i < phase->uniforms_sampler2d.size(); ++i) {
+ const Uniform<int> &uniform = phase->uniforms_sampler2d[i];
+ if (uniform.location != -1) {
+ glUniform1iv(uniform.location, uniform.num_values, uniform.value);
+ }
+ }
for (size_t i = 0; i < phase->uniforms_bool.size(); ++i) {
const Uniform<bool> &uniform = phase->uniforms_bool[i];
assert(uniform.num_values == 1);
}
}
-void EffectChain::setup_rtt_sampler(GLuint glsl_program_num, int sampler_num, const string &effect_id, bool use_mipmaps)
+void EffectChain::setup_rtt_sampler(int sampler_num, bool use_mipmaps)
{
glActiveTexture(GL_TEXTURE0 + sampler_num);
check_error();
check_error();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
check_error();
-
- string texture_name = string("tex_") + effect_id;
- glUniform1i(glGetUniformLocation(glsl_program_num, texture_name.c_str()), sampler_num);
- check_error();
}
} // namespace movit
projects / movit / blobdiff