bool RGBShift::createShader() {
vert = rx_create_shader(GL_VERTEX_SHADER, RGBSHIFT_VS);
frag = rx_create_shader(GL_FRAGMENT_SHADER, RGBSHIFT_FS);
prog = rx_create_program(vert, frag);
glLinkProgram(prog);
return true;
}
bool GPUImage_UYVY422::setupShader(const char* VS, const char* FS) {
prog = rx_create_shader(VS, FS, vert_id, frag_id);
glBindAttribLocation(prog, 0, "a_pos");
glBindAttribLocation(prog, 1, "a_tex");
glLinkProgram(prog);
glUseProgram(prog);
u_tex = glGetUniformLocation(prog, "u_tex");
if(u_tex < 0) {
RX_ERROR("Error while trying to get the u_tex uniform; not used?");
return false;
}
u_pm = glGetUniformLocation(prog, "u_pm");
if(u_pm < 0) {
RX_ERROR("Error while trying to get the u_pm uniform; not used?");
return false;
}
u_mm = glGetUniformLocation(prog, "u_mm");
if(u_mm < 0) {
RX_ERROR("Error while trying to get the u_mm uniform; not used?");
return false;
}
glUniform1i(u_tex, 0);
return true;
}
bool Mist::setup() {
vert = rx_create_shader(GL_VERTEX_SHADER, MIST_VS);
frag = rx_create_shader(GL_FRAGMENT_SHADER, MIST_FS);
prog = rx_create_program(vert, frag);
glBindAttribLocation(prog, 0, "a_pos");
glBindAttribLocation(prog, 1, "a_tex");
glLinkProgram(prog);
rx_print_shader_link_info(prog);
glUseProgram(prog);
glUniform1i(glGetUniformLocation(prog, "u_tex"), 0);
u_time = glGetUniformLocation(prog, "u_time");
u_perc = glGetUniformLocation(prog, "u_perc");
assert(u_time >= 0);
assert(u_perc >= 0);
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(VertexPT3), (GLvoid*)0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(VertexPT3), (GLvoid*)12);
createRing(effects.win_w * 0.5, effects.win_h * 0.5, 20.0f, 450.0);
MistShape shape;
shape.reset();
shape.offset = offsets.back();
shape.count = counts.back();
shape.x = 1024 * 0.5;
shape.y = 768 * 0.5;
shapes.push_back(shape);
mist_tex = rx_create_texture(rx_to_data_path("images/mist.png")); // , GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE);
if(!mist_tex) {
printf("Error: cannot create the mist texture.\n");
return false;
}
printf("mist.mist_tex: %d\n", mist_tex);
return true;
}
bool Blur::setupShader() {
// CREATE SHADER SOURCES
// -----------------------------------------------------------------------
int num_els = num_fetches; /* kernel size */
float* weights = new float[num_els];
float sum = 0.0;
float sigma2 = blur_amount;
weights[0] = gauss(0,sigma2);
sum = weights[0];
for(int i = 1; i < num_els; i++) {
weights[i] = gauss(i, sigma2);
sum += 2 * weights[i];
}
for(int i = 0; i < num_els; ++i) {
weights[i] = weights[i] / sum;
}
float dy = 1.0 / win_h;
float dx = 1.0 / win_w;
std::stringstream xblur;
std::stringstream yblur;
std::stringstream base_frag;
base_frag << "#version 150\n"
<< "uniform sampler2D u_scene_tex;\n"
<< "in vec2 v_tex;\n"
<< "out vec4 fragcolor;\n";
xblur << base_frag.str()
<< "void main() {\n"
<< " fragcolor = texture(u_scene_tex, v_tex) * " << weights[0] << ";\n";
yblur << base_frag.str()
<< "void main() {\n"
<< " fragcolor = texture(u_scene_tex, v_tex) * " << weights[0] << ";\n";
for(int i = 1 ; i <= num_els; ++i) {
yblur << " fragcolor += texture(u_scene_tex, v_tex + vec2(0.0, " << float(i) * dy << ")) * " << weights[i] << ";\n" ;
yblur << " fragcolor += texture(u_scene_tex, v_tex - vec2(0.0, " << float(i) * dy << ")) * " << weights[i] << ";\n" ;
xblur << " fragcolor += texture(u_scene_tex, v_tex + vec2(" << float(i) * dx << ", 0.0)) * " << weights[i] << ";\n" ;
xblur << " fragcolor += texture(u_scene_tex, v_tex - vec2(" << float(i) * dx << ", 0.0)) * " << weights[i] << ";\n" ;
}
yblur << "}";
xblur << "}";
delete weights;
weights = NULL;
// -----------------------------------------------------------------------
std::string yblur_s = yblur.str();
std::string xblur_s = xblur.str();
const char* yblur_vss = yblur_s.c_str();
const char* xblur_vss = xblur_s.c_str();
// y-blur
vert = rx_create_shader(GL_VERTEX_SHADER, B_VS);
frag0 = rx_create_shader(GL_FRAGMENT_SHADER, yblur_vss);
prog0 = rx_create_program(vert, frag0);
glLinkProgram(prog0);
rx_print_shader_link_info(prog0);
// x-blur
frag1 = rx_create_shader(GL_FRAGMENT_SHADER, xblur_vss);
prog1 = rx_create_program(vert, frag1);
glLinkProgram(prog1);
rx_print_shader_link_info(prog1);
GLint u_scene_tex = 0;
// set scene tex unit for 1st pass
glUseProgram(prog0);
u_scene_tex = glGetUniformLocation(prog0, "u_scene_tex");
if(u_scene_tex < 0) {
printf("Cannot find u_scene_tex (1)");
shutdown();
return false;
}
glUniform1i(u_scene_tex, 0);
// set scene tex unit for 2nd pass
glUseProgram(prog1);
u_scene_tex = glGetUniformLocation(prog1, "u_scene_tex");
if(u_scene_tex < 0) {
printf("Cannot find u_scene_tex (2)");
shutdown();
return false;
}
glUniform1i(u_scene_tex, 0);
//printf("%s\n", yblur_s.c_str());
return true;
}
BackgroundBuffer::BackgroundBuffer(int w, int h, int num)
:w(w)
,h(h)
,win_w(0)
,win_h(0)
,num(num)
,index(0)
,vert(0)
,frag(0)
,prog(0)
,vao(0)
,last_index(0)
,out_tex(0)
{
#if 1
GLint vp[4] = { 0 };
glGetIntegerv(GL_VIEWPORT, vp);
win_w = vp[2];
win_h = vp[3];
// Create num fbos;
for(int i = 0; i < num; ++i) {
BackgroundFBO buf = createBuffer();
buffers.push_back(buf);
}
BackgroundFBO bg_fbo = createBuffer();
fbo = bg_fbo.fbo;
out_tex = bg_fbo.tex;
std::stringstream ss;
float div = 1.0 / num;
ss << "#version 330\n";
ss << "in vec2 v_texcoord;\n";
ss << "layout( location = 0 ) out vec4 fragcolor;\n";
ss << "uniform sampler2D u_last_frame;\n";
for(int i = 0; i < num; ++i) {
ss << "uniform sampler2D u_tex" << i << ";\n";
}
ss << "void main() { \n"
<< " fragcolor = vec4(0.0, 0.0, 0.0, 1.0);\n"
<< " vec3 history = vec3(0.0);"
<< " vec3 last_col = texture(u_last_frame, v_texcoord).rgb;\n";
for(int i = 0; i < num; ++i) {
ss << " history += texture(u_tex" << i << ", v_texcoord).rgb * " << div << ";\n";
}
ss << " float dr = last_col.r - history.r; \n"
<< " float dg = last_col.g - history.g; \n"
<< " float db = last_col.b - history.b; \n"
<< " float d = sqrt(dr * dr + dg * dg + db * db); \n"
<< " if(d > 0.1) { \n" // only keep changes which are big enough
<< "fragcolor.rgb = vec3(1.0); \n"
<< " } \n"
<< " } \n"
<< "";
std::string frag_src = ss.str();
const char* frag_src_ptr = frag_src.c_str();
vert = rx_create_shader(GL_VERTEX_SHADER, BG_BUFFER_VS);
frag = rx_create_shader(GL_FRAGMENT_SHADER, frag_src_ptr);
prog = rx_create_program(vert, frag, true);
glUseProgram(prog);
for(int i = 0; i < num; ++i) {
char texname[512] = { 0 } ;
sprintf(texname, "u_tex%d", i);
rx_uniform_1i(prog, texname, i);
}
rx_uniform_1i(prog, "u_last_frame", num);
glGenVertexArrays(1, &vao);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
#endif
}
bool Water::setup(int w, int h) {
assert(w && h);
win_w = w;
win_h = h;
// create shader
vert = rx_create_shader(GL_VERTEX_SHADER, WATER_VS);
frag = rx_create_shader(GL_FRAGMENT_SHADER, WATER_FS);
prog = rx_create_program(vert, frag);
glBindAttribLocation(prog, 0, "a_tex");
glLinkProgram(prog);
rx_print_shader_link_info(prog);
glUseProgram(prog);
glUniform1i(glGetUniformLocation(prog, "u_tex_pos"), 0); // VS
glUniform1i(glGetUniformLocation(prog, "u_tex_norm"), 1); // VS
glUniform1i(glGetUniformLocation(prog, "u_tex_texcoord"), 2); // VS
// glUniform1i(glGetUniformLocation(prog, "u_tex_tang"), 3); // VS
glUniform1i(glGetUniformLocation(prog, "u_tex_gradient"), 3); // VS
glUniform1i(glGetUniformLocation(prog, "u_noise_tex"), 4); // FS
glUniform1i(glGetUniformLocation(prog, "u_norm_tex"), 5); // FS
glUniform1i(glGetUniformLocation(prog, "u_flow_tex"), 6); // FS
glUniform1i(glGetUniformLocation(prog, "u_diffuse_tex"), 7); // FS
glUniform1i(glGetUniformLocation(prog, "u_foam_tex"), 8); // FS
glUniform1i(glGetUniformLocation(prog, "u_color_tex"), 9); // FS
glUniform1i(glGetUniformLocation(prog, "u_extra_flow_tex"), 10); // FS
glUniform1i(glGetUniformLocation(prog, "u_foam_delta_tex"), 11); // FS
glUniform1i(glGetUniformLocation(prog, "u_foam_colors"), 12); // FS
glUniform1i(glGetUniformLocation(prog, "u_foam_ramp"), 13); // FS
glUniform1i(glGetUniformLocation(prog, "u_vortex_tex"), 14); // FS
glUniform1i(glGetUniformLocation(prog, "u_sand_tex"), 15); // FS
glUniform1i(glGetUniformLocation(prog, "u_depth_ramp_tex"), 16); // FS
//GLint texture_units = 0;
//glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &texture_units);
//printf("Max units: %d\n", texture_units);
glUniformMatrix4fv(glGetUniformLocation(prog, "u_pm"), 1, GL_FALSE, height_field.pm.ptr());
glUniformMatrix4fv(glGetUniformLocation(prog, "u_vm"), 1, GL_FALSE, height_field.vm.ptr());
// load textures
normals_tex = createTexture("images/water_normals.png");
flow_tex = createTexture("images/water_flow.png");
noise_tex = createTexture("images/water_noise.png");
diffuse_tex = createTexture("images/water_diffuse.png");
foam_tex = createTexture("images/water_foam.png");
force_tex0 = createTexture("images/force.png");
foam_colors_tex = createTexture("images/foam_densities.png");
foam_ramp_tex = createTexture("images/foam_ramps.png");
vortex_tex = createTexture("images/vortex.png");
sand_tex = createTexture("images/sand.png");
depth_ramp_tex = createTexture("images/depth_ramp.png");
glBindTexture(GL_TEXTURE_2D, foam_colors_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, foam_ramp_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, depth_ramp_tex);
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);
unsigned char* img_pix = NULL;
int img_w, img_h,img_channels = 0;
// load diffuse color ramp
if(!rx_load_png(rx_to_data_path("images/water_color.png"), &img_pix, img_w, img_h, img_channels)) {
printf("Error: cannot load the water_color.png image.\n");
return false;
}
glGenTextures(1, &color_tex);
glBindTexture(GL_TEXTURE_1D, color_tex);
glTexImage1D(GL_TEXTURE_1D, 0, GL_RGB, img_w, 0, GL_RGB, GL_UNSIGNED_BYTE, img_pix);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
delete[] img_pix;
printf("water.color_tex: %d\n", color_tex);
glBindTexture(GL_TEXTURE_2D, flow_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// FBO we used for rendering extra diffuse colors to the water
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glGenTextures(1, &extra_flow_tex);
glBindTexture(GL_TEXTURE_2D, extra_flow_tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, win_w, win_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, extra_flow_tex, 0);
if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
printf("Cannot create the framebuffer for the water diffuse capture.\n");
return false;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
return true;
}
