void RenderChain::render_pass(Pass &pass, unsigned pass_index)
{
set_shaders(pass.fPrg, pass.vPrg);
dev->SetTexture(0, pass.tex);
dev->SetSamplerState(0, D3DSAMP_MINFILTER,
translate_filter(pass.info.pass->filter));
dev->SetSamplerState(0, D3DSAMP_MAGFILTER,
translate_filter(pass.info.pass->filter));
dev->SetVertexDeclaration(pass.vertex_decl);
for (unsigned i = 0; i < 4; i++)
dev->SetStreamSource(i, pass.vertex_buf, 0, sizeof(Vertex));
bind_orig(pass);
bind_prev(pass);
bind_pass(pass, pass_index);
bind_luts(pass);
bind_tracker(pass, pass_index);
if (SUCCEEDED(dev->BeginScene()))
{
dev->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
dev->EndScene();
}
// So we don't render with linear filter into render targets,
// which apparently looked odd (too blurry).
dev->SetSamplerState(0, D3DSAMP_MINFILTER,
D3DTEXF_POINT);
dev->SetSamplerState(0, D3DSAMP_MAGFILTER,
D3DTEXF_POINT);
unbind_all();
}
int main(int argc, char **argv) {
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_DOUBLE|GLUT_ACCUM);
glutInitWindowSize(XRES,YRES);
glutInitWindowPosition(300,50);
glutCreateWindow("Beautiful Teapot");
sprogram=set_shaders();
load_obj(sprogram, "teapot.605.obj");
load_texture( "glaz.ppm", TEXTURE1, sprogram);
load_texture( "snow.ppm", TEXTURE2, sprogram);
load_texture( "sky.ppm", TEXTURE3, sprogram);
load_texture( "teabump.ppm", NORMAL1, sprogram);
glActiveTexture(GL_TEXTURE0);
build_shadowmap();
glBindBuffer(GL_ARRAY_BUFFER, mybuf);
glBufferData(GL_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
glVertexPointer(3, GL_FLOAT, 3*sizeof(GLfloat), NULL+0);
glTexCoordPointer(2, GL_FLOAT, 2*sizeof(GLfloat), NULL+numFaces*3*4*sizeof(GLfloat));
glNormalPointer(GL_FLOAT, 3*sizeof(GLfloat), NULL+numFaces*(3*4+2*4)*sizeof(GLfloat));
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glutDisplayFunc(do_stuff);
glutMainLoop();
return 0;
}
void PLodSubRenderer::_initialize_material_dependent_shader_programs(MaterialShader* material) {
auto program = std::make_shared<ShaderProgram>();
auto smap = global_substitution_map_;
for (const auto& i : material->generate_substitution_map()) {
smap[i.first] = i.second;
}
program->set_shaders(shader_stages_, std::list<std::string>(), false, smap);
material_dependent_shader_programs_[material] = program;
}
int main(int argc, char **argv)
{
std::string fileName(argv[1]);
primaryOBJ = new model(fileName, verticesPerFace);
//setup glut window
setupGlut(argc, argv);
//setup the projection and view matrices
initViewport();
//initialize the cube map textures that will form our skybox
initCubeMap();
// initialize the fbo for dynamic cubemapping
//initDynamicCubeMap();
// standard light initialization. Relatively unchanged from the Bunny project
create_lights();
//standard material initialization. Relatively unchanged from the Bunny project
create_material();
teapotShader = set_shaders((char *)"phongEC");
planeShader = set_shaders((char *)"plane");
// This will read in the texture that will be applied to the teapot, if a texture is applied to the teapot at all
// initTeapotTexture((char*)"textures/bubble_color.ppm");
initCircleTexture((char*)"textures/circle.tga");
// setting up the main shader for the teapot
defaultShader = set_shaders((char*)"phongEC");
// setting up the shader for the skybox / cube map
skyboxShader = set_shaders((char*)"skybox");
// set up the skybox geometry cube
initSkyboxGeometry();
// Main loop functions
glutDisplayFunc(draw_AA);
glutKeyboardFunc(keyBindings);
glutSpecialFunc(translateCam);
glutMainLoop();
return 0;
}
int main (int argc, char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH);
glutInitWindowSize(XRES,YRES);
glutInitWindowPosition(100,100);
glutCreateWindow("shadowmap");
lights();
//~ build_shadowmap();
sprogram = set_shaders();
glutDisplayFunc(do_stuff);
glutMainLoop();
return 0;
}
void Video3DUberShader::create(std::set<std::string> const& material_names)
{
UberShader::create(material_names);
// create depth shader
std::vector<ShaderProgramStage> warp_pass_stages;
warp_pass_stages.push_back( ShaderProgramStage( scm::gl::STAGE_VERTEX_SHADER, _warp_pass_vertex_shader()));
warp_pass_stages.push_back( ShaderProgramStage( scm::gl::STAGE_GEOMETRY_SHADER, _warp_pass_geometry_shader()));
warp_pass_stages.push_back( ShaderProgramStage( scm::gl::STAGE_FRAGMENT_SHADER, _warp_pass_fragment_shader()));
auto warp_pass_program = std::make_shared<ShaderProgram>();
warp_pass_program->set_shaders(warp_pass_stages);
add_program(warp_pass_program);
// create final shader
std::vector<ShaderProgramStage> blend_pass_stages;
blend_pass_stages.push_back(ShaderProgramStage(scm::gl::STAGE_VERTEX_SHADER, _blend_pass_vertex_shader()));
blend_pass_stages.push_back(ShaderProgramStage(scm::gl::STAGE_FRAGMENT_SHADER, _blend_pass_fragment_shader()));
auto blend_pass_program = std::make_shared<ShaderProgram>();
blend_pass_program->set_shaders(blend_pass_stages);
add_program(blend_pass_program);
}
int main(int argc,char** argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE);
glutInitWindowSize(500,500);
glutInitWindowPosition(100,100);
glutCreateWindow("basic GLSL demo");
p=set_shaders();
graphics_init();
glutDisplayFunc(do_stuff);
glutIdleFunc(do_stuff);
glutMainLoop();
return 0;
}
int main(int argc,char** argv)
{
int p;
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH);
glutInitWindowSize(500,500);
glutInitWindowPosition(100,100);
glutCreateWindow("phong shaded teapot");
glActiveTexture(GL_TEXTURE0);
load_texture(argv[1],1);
glActiveTexture(GL_TEXTURE1);
load_texture(argv[2],2);
glEnable(GL_DEPTH_TEST);
view_volume();
set_light();
set_material();
p = set_shaders();
set_uniform(p);
glutDisplayFunc(renderScene);
//glutIdleFunc(renderScene);
glutMainLoop();
return 0;
}
void PLodSubRenderer::_initialize_shader_program() {
auto new_program = std::make_shared<ShaderProgram>();
new_program->set_shaders(shader_stages_);
shader_program_ = new_program;
}
bool RenderChain::render(const void *data,
unsigned width, unsigned height, unsigned pitch, unsigned rotation)
{
start_render();
unsigned current_width = width, current_height = height;
unsigned out_width = 0, out_height = 0;
convert_geometry(passes[0].info, out_width, out_height,
current_width, current_height, final_viewport);
blit_to_texture(data, width, height, pitch);
// Grab back buffer.
LPDIRECT3DSURFACE back_buffer;
dev->GetRenderTarget(0, &back_buffer);
// In-between render target passes.
for (unsigned i = 0; i < passes.size() - 1; i++)
{
Pass &from_pass = passes[i];
Pass &to_pass = passes[i + 1];
LPDIRECT3DSURFACE target;
to_pass.tex->GetSurfaceLevel(0, &target);
dev->SetRenderTarget(0, target);
convert_geometry(from_pass.info,
out_width, out_height,
current_width, current_height, final_viewport);
// Clear out whole FBO.
D3DVIEWPORT viewport = {0};
viewport.Width = to_pass.info.tex_w;
viewport.Height = to_pass.info.tex_h;
viewport.MinZ = 0.0f;
viewport.MaxZ = 1.0f;
dev->SetViewport(&viewport);
dev->Clear(0, 0, D3DCLEAR_TARGET, 0, 1, 0);
viewport.Width = out_width;
viewport.Height = out_height;
set_viewport(viewport);
set_vertices(from_pass,
current_width, current_height,
out_width, out_height,
out_width, out_height, 0);
render_pass(from_pass, i + 1);
current_width = out_width;
current_height = out_height;
target->Release();
}
// Final pass
dev->SetRenderTarget(0, back_buffer);
Pass &last_pass = passes.back();
convert_geometry(last_pass.info,
out_width, out_height,
current_width, current_height, final_viewport);
set_viewport(final_viewport);
set_vertices(last_pass,
current_width, current_height,
out_width, out_height,
final_viewport.Width, final_viewport.Height,
rotation);
render_pass(last_pass, passes.size());
frame_count++;
back_buffer->Release();
end_render();
set_shaders(fStock, vStock);
set_cg_mvp(vStock, final_viewport.Width, final_viewport.Height, 0);
return true;
}
