void compile_shaders() {
static const char *vs =
"#version 330\n"
"layout (location = 0) in vec3 position;\n"
"void main() {\n"
" gl_Position = vec4(0.5 * position.x,\n"
" 0.5 * position.y,\n"
" position.z,\n"
" 1.0);\n"
"}\n";
static const char *fs =
"#version 330\n"
"out vec4 frag;\n"
"uniform vec3 color;\n"
"void main() {\n"
" frag = vec4(color, 1.0);\n"
"}\n";
GLuint program = glCreateProgram();
assert(program);
add_shader(program, vs, GL_VERTEX_SHADER);
add_shader(program, fs, GL_FRAGMENT_SHADER);
glLinkProgram(program);
glValidateProgram(program);
glUseProgram(program);
gColorLocation = glGetUniformLocation(program, "color");
}
GLuint compile_shaders(const char* vert_filename, const char* frag_filename)
{
GLuint shader_program = glCreateProgram();
if (!shader_program)
{
fprintf(stderr, "Error creating shader program\n");
exit(1);
}
else
{
printf("Created shader program %i!\n", shader_program);
}
GLuint vert_shader = glCreateShader(GL_VERTEX_SHADER);
GLuint frag_shader = glCreateShader(GL_FRAGMENT_SHADER);
add_shader(shader_program, file_read(vert_filename), vert_shader);
add_shader(shader_program, file_read(frag_filename), frag_shader);
GLint link_successful = 0;
GLchar ErrorLog[1024] = {0};
glLinkProgram(shader_program);
glGetProgramiv(shader_program, GL_LINK_STATUS, &link_successful);
if (!link_successful)
{
glGetProgramInfoLog(shader_program, sizeof(ErrorLog), NULL, ErrorLog);
fprintf(stderr, "Error linking shader program: '%s'\n", ErrorLog);
exit(1);
}
glValidateProgram(shader_program);
glGetProgramiv(shader_program, GL_VALIDATE_STATUS, &link_successful);
if (!link_successful)
{
glGetProgramInfoLog(shader_program, sizeof(ErrorLog), NULL, ErrorLog);
fprintf(stderr, "Invalid shader program: '%s'\n", ErrorLog);
exit(1);
}
glDeleteShader(vert_shader);
glDeleteShader(frag_shader);
return shader_program;
}
void ShaderManager::online(StringId64 id, ResourceManager& rm)
{
const ShaderResource* shader = (ShaderResource*)rm.get(RESOURCE_TYPE_SHADER, id);
for (u32 i = 0; i < array::size(shader->_data); ++i)
{
const ShaderResource::Data& data = shader->_data[i];
bgfx::ShaderHandle vs = bgfx::createShader(data.vsmem);
CE_ASSERT(bgfx::isValid(vs), "Failed to create vertex shader");
bgfx::ShaderHandle fs = bgfx::createShader(data.fsmem);
CE_ASSERT(bgfx::isValid(fs), "Failed to create fragment shader");
bgfx::ProgramHandle program = bgfx::createProgram(vs, fs, true);
CE_ASSERT(bgfx::isValid(program), "Failed to create GPU program");
add_shader(data.name, data.state, program);
}
}
Scene::Scene(const std::string& filename)
{
add_shader("phong", make_unique<PhongShader>());
add_shader("blinn", make_unique<BlinnShader>());
SceneParser {*this, filename};
}
void ShadowMapTechnique::init(std::string vs, std::string fs) {
add_shader(std::make_shared<Shader>(ShaderType::VERTEX, vs));
add_shader(std::make_shared<Shader>(ShaderType::FRAGMENT, fs));
// update uniform mvp, gSampler
Technique::upload();
}
void Playback3D::overlay_sync(Playback3DCommand *command)
{
#ifdef HAVE_GL
// To do these operations, we need to copy the input buffer to a texture
// and blend 2 textures in a shader
static const char * const overlay_shaders[TRANSFER_TYPES] = {
blend_normal_frag, // TRANSFER_NORMAL
blend_add_frag, // TRANSFER_ADDITION
blend_subtract_frag, // TRANSFER_SUBTRACT
blend_multiply_frag, // TRANSFER_MULTIPLY
blend_divide_frag, // TRANSFER_DIVIDE
blend_replace_frag, // TRANSFER_REPLACE
blend_max_frag, // TRANSFER_MAX
blend_min_frag, // TRANSFER_MIN
blend_average_frag, // TRANSFER_AVERAGE
blend_darken_frag, // TRANSFER_DARKEN
blend_lighten_frag, // TRANSFER_LIGHTEN
blend_dst_frag, // TRANSFER_DST
blend_dst_atop_frag, // TRANSFER_DST_ATOP
blend_dst_in_frag, // TRANSFER_DST_IN
blend_dst_out_frag, // TRANSFER_DST_OUT
blend_dst_over_frag, // TRANSFER_DST_OVER
blend_src_frag, // TRANSFER_SRC
blend_src_atop_frag, // TRANSFER_SRC_ATOP
blend_src_in_frag, // TRANSFER_SRC_IN
blend_src_out_frag, // TRANSFER_SRC_OUT
blend_src_over_frag, // TRANSFER_SRC_OVER
blend_or_frag, // TRANSFER_OR
blend_xor_frag // TRANSFER_XOR
};
command->canvas->lock_canvas("Playback3D::overlay_sync");
if(command->canvas->get_canvas()) {
BC_WindowBase *window = command->canvas->get_canvas();
window->lock_window("Playback3D::overlay_sync");
// Make sure OpenGL is enabled first.
window->enable_opengl();
window->update_video_cursor();
glColor4f(1, 1, 1, 1);
glDisable(GL_BLEND);
if(command->frame) {
// Render to PBuffer
command->frame->enable_opengl();
command->frame->set_opengl_state(VFrame::SCREEN);
canvas_w = command->frame->get_w();
canvas_h = command->frame->get_h();
}
else {
// Render to canvas
canvas_w = window->get_w();
canvas_h = window->get_h();
}
//printf("Playback3D::overlay_sync 1 %d\n", command->input->get_opengl_state());
switch(command->input->get_opengl_state()) {
// Upload texture and composite to screen
case VFrame::RAM:
command->input->to_texture();
break;
// Just composite texture to screen
case VFrame::TEXTURE:
break;
// read from PBuffer to texture, then composite texture to screen
case VFrame::SCREEN:
command->input->enable_opengl();
command->input->screen_to_texture();
if(command->frame)
command->frame->enable_opengl();
else
window->enable_opengl();
break;
default:
printf("Playback3D::overlay_sync unknown state\n");
break;
}
const char *shader_stack[4] = { 0, 0, 0, 0, };
int total_shaders = 0;
VFrame::init_screen(canvas_w, canvas_h);
// Enable texture
command->input->bind_texture(0);
// Convert colormodel to RGB if not nested.
// The color model setting in the output frame is ignored.
if( command->is_nested <= 0 ) { // not nested
switch(command->input->get_color_model()) {
case BC_YUV888:
case BC_YUVA8888:
shader_stack[total_shaders++] = yuv_to_rgb_frag;
break;
}
}
// get the shaders
#define add_shader(s) \
if(!total_shaders) shader_stack[total_shaders++] = read_texture_frag; \
shader_stack[total_shaders++] = s
switch(command->mode) {
case TRANSFER_REPLACE:
// This requires overlaying an alpha multiplied image on a black screen.
if( command->input->get_texture_components() != 4 ) break;
add_shader(overlay_shaders[command->mode]);
break;
default:
enable_overlay_texture(command);
add_shader(overlay_shaders[command->mode]);
break;
}
// if to flatten alpha
if( command->is_nested < 0 ) {
switch(command->input->get_color_model()) {
// yuv has already been converted to rgb
case BC_YUVA8888:
case BC_RGBA_FLOAT:
case BC_RGBA8888:
add_shader(rgba_to_rgb_flatten);
break;
}
}
// run the shaders
unsigned int frag_shader = 0;
if(shader_stack[0]) {
frag_shader = VFrame::make_shader(0,
shader_stack[0], shader_stack[1],
shader_stack[2], shader_stack[3], 0);
glUseProgram(frag_shader);
// Set texture unit of the texture
glUniform1i(glGetUniformLocation(frag_shader, "tex"), 0);
// Set texture unit of the temp texture
glUniform1i(glGetUniformLocation(frag_shader, "tex2"), 1);
// Set alpha
int variable = glGetUniformLocation(frag_shader, "alpha");
glUniform1f(variable, command->alpha);
// Set dimensions of the temp texture
if(temp_texture)
glUniform2f(glGetUniformLocation(frag_shader, "tex2_dimensions"),
(float)temp_texture->get_texture_w(),
(float)temp_texture->get_texture_h());
}
else
glUseProgram(0);
// printf("Playback3D::overlay_sync %f %f %f %f %f %f %f %f\n",
// command->in_x1, command->in_y1, command->in_x2, command->in_y2,
// command->out_x1, command->out_y1, command->out_x2, command->out_y2);
command->input->draw_texture(
command->in_x1, command->in_y1, command->in_x2, command->in_y2,
command->out_x1, command->out_y1, command->out_x2, command->out_y2,
// Don't flip vertical if nested
command->is_nested > 0 ? 0 : 1);
glUseProgram(0);
// Delete temp texture
if(temp_texture) {
delete temp_texture;
temp_texture = 0;
glActiveTexture(GL_TEXTURE1);
glDisable(GL_TEXTURE_2D);
}
glActiveTexture(GL_TEXTURE0);
glDisable(GL_TEXTURE_2D);
window->unlock_window();
}
command->canvas->unlock_canvas();
#endif
}
