void moth_gui::goto_page(unsigned int number)
{
if (page_is_moving())
return;
if (number < 1 || number > book->get_pages()) {
moth_dialog dialog;
std::string info("\"Bad page number\"");
dialog.info(info);
return;
}
if (book->get_page() == (number & (int)(~0x1)))
return;
number = (number & ~(0x1));
dir = (book->get_page() > (number)) ? move_left : move_right;
int page_before = book->get_page();
book->set_page(number);
if (check_textures())
load_textures();
book->set_page(page_before);
move_by_pages = abs(number - page_before);
moving_page = 1;
moving_page_ctr = moving_ctr;
sleep_time = moving_sleep_time;
}
int main(int argc ,char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
screen_width = glutGet(GLUT_SCREEN_WIDTH);
screen_height = glutGet(GLUT_SCREEN_HEIGHT);
glutInitWindowPosition(0,0);
glutInitWindowSize(screen_width,screen_height);
glutCreateWindow("Graphics.... :)");
initRendering();
world.gen_missing();
world.gen_moving();
world.gen_coins();
load_textures();
glutDisplayFunc(draw_scene);
glutReshapeFunc(reshape_window);
glutKeyboardFunc(handle_keyboard_keys);
glutSpecialFunc(handle_special_keyboard_keys);
glutSpecialUpFunc(release_keyboard_keys);
glutMouseFunc(click_action);
glutMotionFunc(click_hold_action);
//glutPassiveMotionFunc(mouse_action);
glutTimerFunc(60,update_world,0);
glutTimerFunc(10,robot_move_forward,0);
glutMainLoop();
return 0;
}
static bool load_preset(const char *path)
{
unsigned i;
if (!load_stock())
return false;
RARCH_LOG("Loading Cg meta-shader: %s\n", path);
config_file_t *conf = config_file_new(path);
if (!conf)
{
RARCH_ERR("Failed to load preset.\n");
return false;
}
if (!cg_shader)
cg_shader = (struct gfx_shader*)calloc(1, sizeof(*cg_shader));
if (!cg_shader)
return false;
if (!gfx_shader_read_conf_cgp(conf, cg_shader))
{
RARCH_ERR("Failed to parse CGP file.\n");
config_file_free(conf);
return false;
}
config_file_free(conf);
gfx_shader_resolve_relative(cg_shader, path);
if (cg_shader->passes > GFX_MAX_SHADERS - 3)
{
RARCH_WARN("Too many shaders ... Capping shader amount to %d.\n", GFX_MAX_SHADERS - 3);
cg_shader->passes = GFX_MAX_SHADERS - 3;
}
for (i = 0; i < cg_shader->passes; i++)
{
if (!load_shader(i))
{
RARCH_ERR("Failed to load shaders ...\n");
return false;
}
}
if (!load_textures())
{
RARCH_ERR("Failed to load lookup textures ...\n");
return false;
}
if (!load_imports())
{
RARCH_ERR("Failed to load imports ...\n");
return false;
}
return true;
}
void initTeapotTexture(char *fileName)
{
teapotTex = (textureUnit*)calloc(sizeof(textureUnit), 1);
teapotTex->name = fileName;
glGenTextures(1, &teapotTex->texID);
teapotTex->format = GL_RGB;
teapotTex->alpha = NULL_A;
teapotTex->texunit = GL_TEXTURE1;
teapotTex->combine = GL_MODULATE;
load_textures(teapotTex);
}
void init(void)
{
glClearColor(0.3, 0.3, 0.3, 1);
glGenVertexArrays(1, &vao_quad);
glBindVertexArray(vao_quad);
#define N 30
GLfloat vertices[4][4] = {
{ -0.90, -0.90, 0, N },
{ 0.90, -0.90, N, N },
{ -0.90, 0.90, 0, 0 },
{ 0.90, 0.90, N, 0 },
};
glGenBuffers(1, &buf_quad);
glBindBuffer(GL_ARRAY_BUFFER, buf_quad);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
GLuint h_prog = build_program_from_files("quad_tex_mipmap.vert", "quad_tex_mipmap.frag");
glUseProgram(h_prog);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*4, BUFFER_OFFSET(0));
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*4, BUFFER_OFFSET(sizeof(GLfloat)*2));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glm::mat4 M = glm::rotate(glm::mat4(1.0f), -85.0f, glm::vec3(1.0f, 0.0f, 0.0f));
glm::mat4 V = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -1.0f));
glm::mat4 P = glm::perspective(45.0f, 1.0f, 0.1f, 5.0f);
glUniformMatrix4fv(glGetUniformLocation(h_prog, "MVP"), 1, GL_FALSE, glm::value_ptr(P*V*M));
glUniform4f(glGetUniformLocation(h_prog, "color"), 1, 1, .5, .5);
glUniform1i(glGetUniformLocation(h_prog, "tex"), 4);
glEnable(GL_CULL_FACE);
load_textures();
glGenSamplers(1, &sampler);
glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_REPEAT);
glSamplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_REPEAT);
// glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
// glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
// glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
// glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glBindSampler(3, sampler);
glBindSampler(4, sampler);
}
void moth_gui::move_page_right()
{
stop_show_search_res();
if (page_is_moving() || book->page_last())
return;
dir = move_right;
if (check_textures())
load_textures();
moving_page = 1;
moving_page_ctr = moving_ctr;
sleep_time = moving_sleep_time;
}
int main(int argc, char *argv[])
{
signal(SIGINT, finish);
initscr();
keypad(stdscr, TRUE);
nonl();
cbreak();
noecho();
nodelay(stdscr, 1);
server = NULL;
console = new Console(COLS, LINES);
load_textures(1);
my_ship = NULL;
std::list<Sector *> sectors;
server = new NetServer(DEFAULT_PORT, "initialD");
nickname = "SERVER";
servername = "localhost";
std::string input("");
std::list<Sector *>::iterator i;
server->setup_master();
sectors.push_front(server);
while(1){
// Select loop here
wait_next_frame();
int key = getch();
if(key != ERR){
if(key == 13){
std::string line;
line = "> " + input;
console->log(line);
input = "";
}else {
input += (char)key;
}
}
server->do_frame();
for(i = sectors.begin() ; i != sectors.end(); ++i){
(*i)->frameupdate_with_collisions();
}
console->render();
mvaddstr(LINES-1, 0, input.c_str());
refresh();
}
finish(0);
}
void launch(int fd)
{
t_env e;
e.mlx = mlx_init();
e.win = mlx_new_window(e.mlx, WIN_X, WIN_Y, "insert a funny title here");
load_textures(e.mlx);
e.draw_img = new_img(e.mlx, WIN_X, WIN_Y);
if (!(e.map = new_map_with_fd(fd)))
return (ft_putstr("Map error\n"));
init_kernel(&e);
draw_env(&e);
mlx_loop(e.mlx);
}
int main(int argc, char** argv){
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH);
glutInitWindowSize(640,640);
glutInitWindowPosition(100,50);
glutCreateWindow("multi-textured cube");
glEnable(GL_DEPTH_TEST);
load_textures();
setup_the_viewlolume();
do_lights();
do_material();
glutDisplayFunc(draw_stuff);
glutMainLoop();
return 0;
}
void moth_gui::create_textures()
{
GError *err = NULL;
GdkPixbuf *img = gdk_pixbuf_new_from_inline(420 * 300 * 4 + 1,
(guint8*)last_page_img,
FALSE, &err);
if (!img) {
std::cerr << "Could not create texture, err " << err->code << std::endl;
std::cerr << "Err msg " << err->message << std::endl;
throw moth_bad_gui();
}
num_pages = book->get_pages();
book->get_page_size(0, &page_width, &page_height);
textures = new GLuint[num_pages];
textures_state = new uint8_t[num_pages];
memset(textures_state, '\0', num_pages);
memset(textures, '\0', num_pages * sizeof(GLuint));
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGenTextures(1, &moth_texture);
glGenTextures(1, &last_page_texture);
glGenTextures(num_pages, textures);
glBindTexture(GL_TEXTURE_2D, last_page_texture);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
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_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 300, 420, 0, GL_RGBA,
GL_UNSIGNED_BYTE, gdk_pixbuf_get_pixels(img));
g_object_unref(img);
dir = move_right;
if (page_height >= page_width) {
best_zoom = (height / page_height) * 0.8;
}
else {
best_zoom = (width / (page_width * 2)) * 0.8;
}
zoom = best_zoom;
pages_to_load = load_pages_at_start;
load_textures();
return;
}
static int init(void)
{
srandom(time(NULL));
if (!glfwInit()) {
perror("Can't init glfw\n");
goto err_glfw;
}
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
window = glfwCreateWindow(config.screen_width, config.screen_height, "Anko", NULL, NULL);
if (!window) {
glfwTerminate();
goto err_window;
}
glfwMakeContextCurrent(window);
printf("OpenGL Version : %s\n\n", glGetString(GL_VERSION));
if (!init_context())
goto err_context;
if (!load_textures())
goto err_texture;
init_events(window);
if(!load_font())
goto err_font;
return 1;
err_font:
unload_textures();
err_texture:
close_context();
err_context:
glfwDestroyWindow(window);
err_window:
glfwTerminate();
err_glfw:
return 0;
}
int
main(int argc, char **argv)
{
int i;
glutInit(&argc, argv);
for (i=1; i<argc; i++) {
if (!strcmp(argv[i], "-mipmap"))
useMipmaps = 1;
else if (!strcmp(argv[i], "-v"))
verbose = 1;
}
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutCreateWindow("glflare");
glutDisplayFunc(display);
glutVisibilityFunc(visible);
init_flares();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(
60.0, /* field of view in degree */
1.0, /* aspect ratio */
0.5, 30.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(
from[0], from[1], from[2],
at[0], at[1], at[2],
0.0, 1.0, 0.); /* up is in positive Y direction */
load_textures();
glEnable(GL_TEXTURE_2D);
glutMainLoop();
return 0; /* ANSI C requires main to return int. */
}
Game::Game() {
glClearColor(1, 1, 1, 1);
//load textures
load_textures();
//create water
water.init(((SCREEN_WIDTH - WATER_WIDTH) / 2), 0);
//spawn character
user.place(300, &event, textures, &water, &bullets);
//misc
bullets = NULL;
enemies = NULL;
pups = NULL;
srand(time(NULL));
//start the main cycle
printf("starting...\n");
start();
}
void onInit()
{
sys::info << "app::COGLDev02App::onInit()" << sys::endl;
pCamera = new app::CCamera(50.0f, mConfig.mRatio, 0.1f, 100.0f);
pCamera->setPosition(math::vec3(0.0f, -1.0f, 0.0f));
load_programs();
load_textures();
load_objects();
oDirectionalLight.vColor = math::vec3(1.0f, 1.0f, 1.0f);
oDirectionalLight.vDirection = math::vec3(1.0f, 0.0f, 0.0f);
oDirectionalLight.fAmbientIntensity = 0.20f;
oDirectionalLight.fDiffuseIntensity = 0.60;
glFrontFace(GL_CCW);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
}
void createCity(char *chemin)
{
int texId[14]; //A créer en même temps que toutes les variables. La taille depend du nombre de textures
int i;
GLUquadricObj* qobj;
//GLUquadricObj* GLAPIENTRY qobj;
// allocation d´une description de quadrique
qobj = gluNewQuadric();
// la quadrique est pleine
gluQuadricDrawStyle(qobj, GLU_FILL);
// les ombrages, s´il y en a, sont doux
gluQuadricNormals(qobj, GLU_SMOOTH);
load_textures(chemin, texId); // loading textures
makeSky(texId[13]); // creating skybox
glNewList(BORD, GL_COMPILE);
glBegin(GL_POLYGON);
glTexCoord2i(1,1); glVertex3f(-150,-150,0);
glTexCoord2i(1,0); glVertex3f(-150,-150,5);
glTexCoord2i(0,0); glVertex3f(150,-150,5);
glTexCoord2i(0,1); glVertex3f(150,-150,0);
glEnd();
glEndList();
//sol
glNewList(FLOOR, GL_COMPILE);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,texId[0]);
glColor3f (1,1,1);
glPushMatrix();
glBegin(GL_POLYGON);
glTexCoord2i(1,1); glVertex3f(150,150,0);
glTexCoord2i(1,0); glVertex3f(150,-150,0);
glTexCoord2i(0,0); glVertex3f(-150,-150,0);
glTexCoord2i(0,1); glVertex3f(-150,150,0);
glEnd();
for(i=0;i<4;i++)
{
glRotatef(90, 0, 0, 1);
glCallList(BORD);
}
glDisable(GL_TEXTURE_2D);
glPopMatrix();
glEndList();
//batiment 1
glNewList(BAT1, GL_COMPILE);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,texId[1]);
glPushMatrix();
glTranslatef(20,20,0);
glBegin(GL_QUADS);
//4 faces latrales
glTexCoord2i(0,0); glVertex3d(10,10,60);
glTexCoord2i(0,4); glVertex3d(10,10,0);
glTexCoord2i(4,4); glVertex3d(0,10,0);
glTexCoord2i(4,0); glVertex3d(0,10,60);
glTexCoord2i(0,0); glVertex3d(10,0,60);
glTexCoord2i(0,4); glVertex3d(10,0,0);
glTexCoord2i(4,4); glVertex3d(10,10,0);
glTexCoord2i(4,0); glVertex3d(10,10,60);
glTexCoord2i(0,0); glVertex3d(0,0,60);
glTexCoord2i(0,4); glVertex3d(0,0,0);
glTexCoord2i(4,4); glVertex3d(10,0,0);
glTexCoord2i(4,0); glVertex3d(10,0,60);
glTexCoord2i(0,0); glVertex3d(0,10,60);
glTexCoord2i(0,4); glVertex3d(0,10,0);
glTexCoord2i(4,4); glVertex3d(0,0,0);
glTexCoord2i(4,0); glVertex3d(0,0,60);
//sol
glTexCoord2i(0,0); glVertex3d(10,10,0);
glTexCoord2i(0,4); glVertex3d(10,0,0);
glTexCoord2i(4,4); glVertex3d(0,0,0);
glTexCoord2i(4,0); glVertex3d(0,10,0);
//toit
glTexCoord2i(0,0); glVertex3d(10,0,60);
glTexCoord2i(0,4); glVertex3d(10,10,60);
glTexCoord2i(4,4); glVertex3d(0,10,60);
glTexCoord2i(4,0); glVertex3d(0,0,60);
glEnd();
glPopMatrix();
glDisable(GL_TEXTURE_2D);
glEndList();
//batiment 2
glNewList(BAT2, GL_COMPILE);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,texId[2]);
glPushMatrix();
glTranslatef(30,-90,0);
glBegin(GL_QUADS);
//4 faces latrales
glTexCoord2i(0,0); glVertex3d(15,15,90);
glTexCoord2i(0,1); glVertex3d(15,15,0);
glTexCoord2i(1,1); glVertex3d(0,15,0);
glTexCoord2i(1,0); glVertex3d(0,15,90);
glTexCoord2i(0,0); glVertex3d(15,0,90);
glTexCoord2i(0,1); glVertex3d(15,0,0);
glTexCoord2i(1,1); glVertex3d(15,15,0);
glTexCoord2i(1,0); glVertex3d(15,15,90);
glTexCoord2i(0,0); glVertex3d(0,0,90);
glTexCoord2i(0,1); glVertex3d(0,0,0);
glTexCoord2i(1,1); glVertex3d(15,0,0);
glTexCoord2i(1,0); glVertex3d(15,0,90);
glTexCoord2i(0,0); glVertex3d(0,15,90);
glTexCoord2i(0,1); glVertex3d(0,15,0);
glTexCoord2i(1,1); glVertex3d(0,0,0);
glTexCoord2i(1,0); glVertex3d(0,0,90);
//sol
glTexCoord2i(0,0); glVertex3d(15,15,0);
glTexCoord2i(0,1); glVertex3d(15,0,0);
glTexCoord2i(1,1); glVertex3d(0,0,0);
glTexCoord2i(1,0); glVertex3d(0,15,0);
//toit
glTexCoord2i(0,0); glVertex3d(15,0,90);
glTexCoord2i(0,1); glVertex3d(15,15,90);
glTexCoord2i(1,1); glVertex3d(0,15,90);
glTexCoord2i(1,0); glVertex3d(0,0,90);
glEnd();
glPopMatrix();
glDisable(GL_TEXTURE_2D);
glEndList();
//batiment3
glNewList(BAT3,GL_COMPILE);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,texId[3]);
glPushMatrix();
glTranslatef(60,80,0);
glBegin(GL_QUADS);
//4 faces latrales
glTexCoord2i(0,0); glVertex3d(30,30,10);
glTexCoord2i(0,1); glVertex3d(30,30,0);
glTexCoord2i(1,1); glVertex3d(0,30,0);
glTexCoord2i(1,0); glVertex3d(0,30,10);
glTexCoord2i(0,0); glVertex3d(30,0,10);
glTexCoord2i(0,1); glVertex3d(30,0,0);
glTexCoord2i(1,1); glVertex3d(30,30,0);
glTexCoord2i(1,0); glVertex3d(30,30,10);
glTexCoord2i(0,0); glVertex3d(0,0,10);
glTexCoord2i(0,1); glVertex3d(0,0,0);
glTexCoord2i(1,1); glVertex3d(30,0,0);
glTexCoord2i(1,0); glVertex3d(30,0,10);
glTexCoord2i(0,0); glVertex3d(0,30,10);
glTexCoord2i(0,1); glVertex3d(0,30,0);
glTexCoord2i(1,1); glVertex3d(0,0,0);
glTexCoord2i(1,0); glVertex3d(0,0,10);
//sol
glTexCoord2i(0,0); glVertex3d(30,30,0);
glTexCoord2i(0,1); glVertex3d(30,0,0);
glTexCoord2i(1,1); glVertex3d(0,0,0);
glTexCoord2i(1,0); glVertex3d(0,30,0);
//toit
glTexCoord2i(0,0); glVertex3d(30,0,10);
glTexCoord2i(0,1); glVertex3d(30,30,10);
glTexCoord2i(1,1); glVertex3d(0,30,10);
glTexCoord2i(1,0); glVertex3d(0,0,10);
glEnd();
glPopMatrix();
glDisable(GL_TEXTURE_2D);
glEndList();
//batiment 4 conique
glNewList(BAT4, GL_COMPILE);
GLUquadricObj* quadric = gluNewQuadric();
gluQuadricTexture(quadric, GLU_TRUE);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,texId[10]);
glPushMatrix();
glTranslatef(0,-60,0);
//glColor3f(0.5, 0.35, 0.05);
gluCylinder(quadric, 5, 5, 40, 100, 100);
glTranslatef(0,0,30);
//glColor3f(0.5, 0.35, 0.05);
gluCylinder(quadric, 5, 10, 30, 100, 100);
glTranslatef(0, 0, 30);
gluDisk(quadric,0,10,100,100);
glPopMatrix();
glDisable(GL_TEXTURE_2D);
gluQuadricTexture(quadric, GLU_FALSE);
glEndList();
//batiment 5 avec sphere
glNewList(BAT5, GL_COMPILE);
GLUquadricObj* quadric2 = gluNewQuadric();
gluQuadricTexture(quadric2, GLU_TRUE);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,texId[11]);
glPushMatrix();
glTranslatef(-15,-15,0);
glColor3f(0.01, 0.56, 0.61);
gluCylinder(quadric2, 5, 5, 20, 100, 100);
glTranslatef(0,0,20);
glColor3f(0.01, 0.56, 0.61);
gluSphere(quadric2, 10, 100, 100);
glPopMatrix();
glDisable(GL_TEXTURE_2D);
gluQuadricTexture(quadric2, GLU_FALSE);
glEndList();
//batiment 6
glNewList(BAT6, GL_COMPILE);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,texId[4]);
glPushMatrix();
glTranslatef(-30,20,0);
glBegin(GL_QUADS);
//4 faces latrales
glTexCoord2i(0,0); glVertex3d(20,20,70);
glTexCoord2i(0,2); glVertex3d(20,20,0);
glTexCoord2i(2,2); glVertex3d(0,20,0);
glTexCoord2i(2,0); glVertex3d(0,20,70);
glTexCoord2i(0,0); glVertex3d(20,0,70);
glTexCoord2i(0,2); glVertex3d(20,0,0);
glTexCoord2i(2,2); glVertex3d(20,20,0);
glTexCoord2i(2,0); glVertex3d(20,20,70);
glTexCoord2i(0,0); glVertex3d(0,0,70);
glTexCoord2i(0,2); glVertex3d(0,0,0);
glTexCoord2i(2,2); glVertex3d(20,0,0);
glTexCoord2i(2,0); glVertex3d(20,0,70);
glTexCoord2i(0,0); glVertex3d(0,20,70);
glTexCoord2i(0,2); glVertex3d(0,20,0);
glTexCoord2i(2,2); glVertex3d(0,0,0);
glTexCoord2i(2,0); glVertex3d(0,0,70);
//sol
glTexCoord2i(0,0); glVertex3d(20,20,0);
glTexCoord2i(0,2); glVertex3d(20,0,0);
glTexCoord2i(2,2); glVertex3d(0,0,0);
glTexCoord2i(2,0); glVertex3d(0,20,0);
//toit
glTexCoord2i(0,0); glVertex3d(20,0,70);
glTexCoord2i(0,2); glVertex3d(20,20,70);
glTexCoord2i(2,2); glVertex3d(0,20,70);
glTexCoord2i(2,0); glVertex3d(0,0,70);
glEnd();
glPopMatrix();
glDisable(GL_TEXTURE_2D);
glEndList();
//batiment 7
glNewList(BAT7, GL_COMPILE);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,texId[5]);
glPushMatrix();
glTranslatef(-70,-60,0);
glBegin(GL_QUADS);
//4 faces latrales
glTexCoord2i(0,0); glVertex3d(25,25,5);
glTexCoord2i(0,1); glVertex3d(25,25,0);
glTexCoord2i(1,1); glVertex3d(0,25,0);
glTexCoord2i(1,0); glVertex3d(0,25,5);
glTexCoord2i(0,0); glVertex3d(25,0,5);
glTexCoord2i(0,1); glVertex3d(25,0,0);
glTexCoord2i(1,1); glVertex3d(25,25,0);
glTexCoord2i(1,0); glVertex3d(25,25,5);
glTexCoord2i(0,0); glVertex3d(0,0,5);
glTexCoord2i(0,1); glVertex3d(0,0,0);
glTexCoord2i(1,1); glVertex3d(25,0,0);
glTexCoord2i(1,0); glVertex3d(25,0,5);
glTexCoord2i(0,0); glVertex3d(0,25,5);
glTexCoord2i(0,1); glVertex3d(0,25,0);
glTexCoord2i(1,1); glVertex3d(0,0,0);
glTexCoord2i(1,0); glVertex3d(0,0,5);
//sol
glTexCoord2i(0,0); glVertex3d(25,25,0);
glTexCoord2i(0,1); glVertex3d(25,0,0);
glTexCoord2i(1,1); glVertex3d(0,0,0);
glTexCoord2i(1,0); glVertex3d(0,25,0);
//toit
glTexCoord2i(0,0); glVertex3d(25,0,5);
glTexCoord2i(0,1); glVertex3d(25,25,5);
glTexCoord2i(1,1); glVertex3d(0,25,5);
glTexCoord2i(1,0); glVertex3d(0,0,5);
glEnd();
glPopMatrix();
glDisable(GL_TEXTURE_2D);
glEndList();
//batiment 8
glNewList(BAT8, GL_COMPILE);
GLUquadricObj* quadric3 = gluNewQuadric();
gluQuadricTexture(quadric3, GLU_TRUE);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,texId[9]);
glPushMatrix();
glTranslatef(100, 50, 0);
glColor3f(0.5, 0.37, 0.05);
gluCylinder(quadric3, 10, 10, 90, 100, 100);
glTranslatef(0, 0, 90);
gluDisk(quadric3,0,10,100,100);
glPopMatrix();
glDisable(GL_TEXTURE_2D);
gluQuadricTexture(quadric3, GLU_FALSE);
glEndList();
//batiment 9
glNewList(BAT9, GL_COMPILE);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,texId[6]);
glPushMatrix();
glTranslatef(-100,-120,0);
glBegin(GL_QUADS);
//4 faces latrales
glTexCoord2i(0,0); glVertex3d(18,18,120);
glTexCoord2i(0,1); glVertex3d(18,18,0);
glTexCoord2i(1,1); glVertex3d(0,18,0);
glTexCoord2i(1,0); glVertex3d(0,18,120);
glTexCoord2i(0,0); glVertex3d(18,0,120);
glTexCoord2i(0,1); glVertex3d(18,0,0);
glTexCoord2i(1,1); glVertex3d(18,18,0);
glTexCoord2i(1,0); glVertex3d(18,18,120);
glTexCoord2i(0,0); glVertex3d(0,0,120);
glTexCoord2i(0,1); glVertex3d(0,0,0);
glTexCoord2i(1,1); glVertex3d(18,0,0);
glTexCoord2i(1,0); glVertex3d(18,0,120);
glTexCoord2i(0,0); glVertex3d(0,18,120);
glTexCoord2i(0,1); glVertex3d(0,18,0);
glTexCoord2i(1,1); glVertex3d(0,0,0);
glTexCoord2i(1,0); glVertex3d(0,0,120);
//sol
glTexCoord2i(0,0); glVertex3d(18,18,0);
glTexCoord2i(0,1); glVertex3d(18,0,0);
glTexCoord2i(1,1); glVertex3d(0,0,0);
glTexCoord2i(1,0); glVertex3d(0,18,0);
//toit
glTexCoord2i(0,0); glVertex3d(18,0,120);
glTexCoord2i(0,1); glVertex3d(18,18,120);
glTexCoord2i(1,1); glVertex3d(0,18,120);
glTexCoord2i(1,0); glVertex3d(0,0,120);
glEnd();
glPopMatrix();
glDisable(GL_TEXTURE_2D);
glEndList();
//batiment 10
glNewList(BAT10, GL_COMPILE);
GLUquadricObj* quadric4 = gluNewQuadric();
gluQuadricTexture(quadric4, GLU_TRUE);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,texId[7]);
glPushMatrix();
glTranslatef(100,-60,0);
gluCylinder(quadric4, 30, 30, 10, 100, 100);
glTranslatef(0,0,10);
gluDisk(quadric4,0,30,100,100);
gluSphere(quadric4, 10, 100, 100);
glPopMatrix();
glDisable(GL_TEXTURE_2D);
gluQuadricTexture(quadric4, GLU_FALSE);
glEndList();
//batiment 11
glNewList(BAT11, GL_COMPILE);
GLUquadricObj* quadric5 = gluNewQuadric();
gluQuadricTexture(quadric5, GLU_TRUE);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,texId[8]);
glPushMatrix();
glTranslatef(-110,80,0);
gluCylinder(quadric5, 10, 0, 95, 100, 100);
glPopMatrix();
glDisable(GL_TEXTURE_2D);
gluQuadricTexture(quadric5, GLU_FALSE);
glEndList();
//batiment 12 sphere
glNewList(BAT12, GL_COMPILE);
GLUquadricObj* quadric6 = gluNewQuadric();
gluQuadricDrawStyle(quadric6, GLU_FILL);
gluQuadricNormals(quadric6, GLU_SMOOTH);
gluQuadricTexture(quadric6, GLU_TRUE);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,texId[12]);
glColor3f(1, 1, 1);
glPushMatrix();
glTranslatef(-90,-60,0);
glTranslatef(0,0,5);
gluSphere(quadric6, 20, 100, 100);
glPopMatrix();
glDisable(GL_TEXTURE_2D);
gluQuadricTexture(quadric6, GLU_FALSE);
glEndList();
//city
glNewList(CITY, GL_COMPILE); // declaration de la liste City
glCallList(SKY);
glCallList(FLOOR);
glCallList(BAT1);
glCallList(BAT2);
glCallList(BAT3);
glCallList(BAT4);
glCallList(BAT5);
glCallList(BAT6);
glCallList(BAT7);
glCallList(BAT8);
glCallList(BAT9);
glCallList(BAT10);
glCallList(BAT11);
glCallList(BAT12);
glEndList();
}
ENTRYPOINT void
init_toasters (ModeInfo *mi)
{
toaster_configuration *bp;
int wire = MI_IS_WIREFRAME(mi);
int i;
if (!bps) {
bps = (toaster_configuration *)
calloc (MI_NUM_SCREENS(mi), sizeof (toaster_configuration));
if (!bps) {
fprintf(stderr, "%s: out of memory\n", progname);
exit(1);
}
}
bp = &bps[MI_SCREEN(mi)];
bp->glx_context = init_GL(mi);
reshape_toasters (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glEnable(GL_CULL_FACE);
if (!wire)
{
GLfloat pos[4] = {0.4, 0.2, 0.4, 0.0};
/* GLfloat amb[4] = {0.0, 0.0, 0.0, 1.0};*/
GLfloat amb[4] = {0.2, 0.2, 0.2, 1.0};
GLfloat dif[4] = {1.0, 1.0, 1.0, 1.0};
GLfloat spc[4] = {1.0, 1.0, 1.0, 1.0};
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glLightfv(GL_LIGHT0, GL_POSITION, pos);
glLightfv(GL_LIGHT0, GL_AMBIENT, amb);
glLightfv(GL_LIGHT0, GL_DIFFUSE, dif);
glLightfv(GL_LIGHT0, GL_SPECULAR, spc);
}
if (!wire && do_texture)
load_textures (mi);
bp->user_trackball = gltrackball_init ();
auto_track_init (mi);
bp->dlists = (GLuint *) calloc (countof(all_objs)+1, sizeof(GLuint));
for (i = 0; i < countof(all_objs); i++)
bp->dlists[i] = glGenLists (1);
for (i = 0; i < countof(all_objs); i++)
{
const struct gllist *gll = *all_objs[i];
glNewList (bp->dlists[i], GL_COMPILE);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glMatrixMode(GL_MODELVIEW);
glRotatef (-90, 1, 0, 0);
glRotatef (180, 0, 0, 1);
glScalef (6, 6, 6);
glBindTexture (GL_TEXTURE_2D, 0);
if (i == BASE_TOASTER)
{
GLfloat color[4] = {1.00, 1.00, 1.00, 1.00};
GLfloat spec[4] = {1.00, 1.00, 1.00, 1.0};
GLfloat shiny = 20.0;
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, spec);
glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, shiny);
if (do_texture)
glBindTexture (GL_TEXTURE_2D, bp->chrome_texture);
# ifndef HAVE_JWZGLES
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
# endif
}
else if (i == TOAST || i == TOAST_BITTEN)
{
GLfloat color[4] = {0.80, 0.80, 0.00, 1.0};
GLfloat spec[4] = {0.00, 0.00, 0.00, 1.0};
GLfloat shiny = 0.0;
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, spec);
glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, shiny);
if (do_texture)
glBindTexture (GL_TEXTURE_2D, bp->toast_texture);
# ifndef HAVE_JWZGLES
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
# endif
glMatrixMode(GL_TEXTURE);
glTranslatef(0.5, 0.5, 0);
glMatrixMode(GL_MODELVIEW);
}
else if (i == SLOTS || i == HANDLE_SLOT)
{
GLfloat color[4] = {0.30, 0.30, 0.40, 1.0};
GLfloat spec[4] = {0.40, 0.40, 0.70, 1.0};
GLfloat shiny = 128.0;
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, spec);
glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, shiny);
}
else if (i == HANDLE)
{
GLfloat color[4] = {0.80, 0.10, 0.10, 1.0};
GLfloat spec[4] = {1.00, 1.00, 1.00, 1.0};
GLfloat shiny = 20.0;
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, spec);
glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, shiny);
}
else if (i == KNOB)
{
GLfloat color[4] = {0.80, 0.10, 0.10, 1.0};
GLfloat spec[4] = {0.00, 0.00, 0.00, 1.0};
GLfloat shiny = 0.0;
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, spec);
glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, shiny);
}
else if (i == JET || i == JET_WING)
{
GLfloat color[4] = {0.70, 0.70, 0.70, 1.0};
GLfloat spec[4] = {1.00, 1.00, 1.00, 1.0};
GLfloat shiny = 20.0;
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, spec);
glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, shiny);
}
else if (i == BASE)
{
GLfloat color[4] = {0.50, 0.50, 0.50, 1.0};
GLfloat spec[4] = {1.00, 1.00, 1.00, 1.0};
GLfloat shiny = 20.0;
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, spec);
glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, shiny);
}
else
{
GLfloat color[4] = {1.00, 1.00, 1.00, 1.00};
GLfloat spec[4] = {1.00, 1.00, 1.00, 1.0};
GLfloat shiny = 128.0;
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, spec);
glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, shiny);
}
renderList (gll, wire);
glMatrixMode(GL_TEXTURE);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glEndList ();
}
bp->nfloaters = ntoasters + nslices;
bp->floaters = (floater *) calloc (bp->nfloaters, sizeof (floater));
for (i = 0; i < bp->nfloaters; i++)
{
floater *f = &bp->floaters[i];
/* arrange the list so that half the toasters are in front of bread,
and half are behind. */
f->toaster_p = ((i < ntoasters / 2) ||
(i >= (nslices + (ntoasters / 2))));
reset_floater (mi, f);
/* Position the first generation randomly, but make sure they aren't
on screen yet (until we rotate the view into position.)
*/
{
GLfloat min = -GRID_DEPTH/2;
GLfloat max = GRID_DEPTH/3.5;
f->z = frand (max - min) + min;
}
}
}
int mainloop(void*)
{
int drawchange = 0; int refreshdelay[2] = {33, 33}; int rdelay = 33;
Uint32 time1 = SDL_GetTicks(), time2 = SDL_GetTicks();
float ts; int u; int i;
if(!init_SDL(surface))
{ fprintf(stderr, "SDL_OPENGL failed\n"); exit(1);}
if(!initGL(w_width, w_height))
{ fprintf(stderr, "OpenGL failed\n"); exit(1);}
SDL_WM_SetCaption( "Tesseract", NULL );
glPointSize(8.0f);
resizewindow(1280, 1024);
load_textures();
lbounds[0] = 10;
ts = lbounds[0];
q = (Quaternion*)(malloc(9999999*sizeof(Quaternion)));
qbuffer = (Quaternion*)(malloc(9999*sizeof(Quaternion)));
quatnum = 0;
// quatnum += construct_tesseract(1,1,1,1, 0, 0, 0, 1,quatnum, 0.5);
playerpost.set(0,0,0,0);
float acc = fack;
float spp[18] = {
0,
0,
(GLfloat)iterations, // 255 iterations
0.35f,
0,
F_QUATMANDEL,
-acc+playerpost.a,
acc+playerpost.a,
-acc+playerpost.b,
acc+playerpost.b,
-acc+playerpost.c,
acc+playerpost.c,
-acc+playerpost.d,
acc+playerpost.d,
acc,
zoom2,
tesseract,
simplex
};
if(points)
{
quatnum = calc_fractal(spp, q);
}
else
quatnum += construct_tesseract(1,1,1,1, 0, 0, 0, 0,quatnum, 0.5);
bquat = quatnum;
t_size = quatnum;
/*
quatnum += construct_tesseract(1,1,1,1, -ts, ts, ts, ts,quatnum, 0.5);
quatnum += construct_tesseract(1,1,1,1, ts, -ts, ts, ts,quatnum, 0.5);
quatnum += construct_tesseract(1,1,1,1, ts, ts, -ts, ts,quatnum, 0.5);
quatnum += construct_tesseract(1,1,1,1, ts, ts, ts, ts,quatnum, 0.5);
quatnum += construct_tesseract(1,1,1,1, ts, -ts, -ts, ts,quatnum, 0.5);
quatnum += construct_tesseract(1,1,1,1, -ts, -ts, ts, ts,quatnum, 0.5);
quatnum += construct_tesseract(1,1,1,1, -ts, ts, -ts, ts,quatnum, 0.5);
quatnum += construct_tesseract(1,1,1,1, -ts, -ts, -ts, ts,quatnum, 0.5);
quatnum += construct_tesseract(1,1,1,1, -ts, ts, ts, -ts,quatnum, 0.5);
quatnum += construct_tesseract(1,1,1,1, ts, -ts, ts, -ts,quatnum, 0.5);
quatnum += construct_tesseract(1,1,1,1, ts, ts, -ts, -ts,quatnum, 0.5);
quatnum += construct_tesseract(1,1,1,1, ts, ts, ts, -ts,quatnum, 0.5);
quatnum += construct_tesseract(1,1,1,1, ts, -ts, -ts, -ts,quatnum, 0.5);
quatnum += construct_tesseract(1,1,1,1, -ts, -ts, ts, -ts,quatnum, 0.5);
quatnum += construct_tesseract(1,1,1,1, -ts, ts, -ts, -ts,quatnum, 0.5);
quatnum += construct_tesseract(1,1,1,1, -ts, -ts, -ts, -ts,quatnum, 0.5);
*/
freequat = quatnum;
// quatnum += construct_tesseract(1,1,1,1, 0, 0, 0, 0,quatnum, 0.5);
/*
for(u = 4; u <= 8; u+=2)
quatnum += construct_tesseract(1,1,1,1, 0, 0, 0, -(5-u*4),quatnum, 1.75);
for(u = 4; u <= 8; u+=2)
quatnum += construct_tesseract(1,1,1,1, 0, 0, -(5-u*4), 0,quatnum, 1.75);
for(u = 4; u <= 8; u+=2)
quatnum += construct_tesseract(1,1,1,1, 0, -(5-u*4), 0, 0,quatnum, 1.75);
for(u = 4; u <= 8; u+=2)
quatnum += construct_tesseract(1,1,1,1, -(5-u*4), 0, 0, 0,quatnum, 1.75);
*/
movquat = quatnum;
/*
quatnum += construct_tesseract(1,1,1,1, 0, 0, 0, 0,quatnum, 0.8);
quatnum += construct_tesseract(1,1,1,1, 0, 0, 0, 0,quatnum, 1.1);
quatnum += construct_tesseract(1,1,1,1, 0, 0, 0, 0,quatnum, 0.1);
quatnum += construct_tesseract(1,1,1,1, 0, 0, 0, 0,quatnum, 0.1);
quatnum += construct_tesseract(1,1,1,1, 0, 0, 0, 0,quatnum, 0.1);
quatnum += construct_tesseract(1,1,1,1, 0, 0, 0, 0,quatnum, 0.1);
quatnum += construct_tesseract(1,1,1,1, 0, 0, 0, 0,quatnum, 0.1);
quatnum += construct_tesseract(1,1,1,1, 0, 0, 0, 0,quatnum, 0.1);
quatnum += construct_tesseract(1,1,1,1, 0, 0, 0, 0,quatnum, 0.1);
quatnum += construct_tesseract(1,1,1,1, 0, 0, 0, 0,quatnum, 0.1);
quatnum += construct_tesseract(1,1,1,1, 0, 0, 0, 0,quatnum, 0.1);
quatnum += construct_tesseract(1,1,1,1, 0, 0, 0, 0,quatnum, 0.1);
*/
maxquat = quatnum;
int yy;
printf("quatnum: %d\n", quatnum);
// for(u = 0; u < quatnum; u++)
// qo[u] = q[u];
playerpos.set(0,0,0,0);
playerpost.set(0,0,0,0);
padd.set(0,0,0,0);
ptemp.set(0,0,0,0);
ptemp2.set(0,0,0,0);
randreinit();
init_fbo(0);
init_fbo(1);
init_fbo(2);
init_fbo(3);
for(i = 0; i < quatnum/4; i++)
{
zposbuf[i] = get_zposbuf(i);
zposbufi[i] = i;
}
while(!done)
{
framecounter++;
if(framecounter > 4294967000UL) framecounter = 0;
drawchange = keylistener();
SDL_Delay(rdelay*0.5);
if(!(framecounter%5))
{
// printf("Delay: %d\n", rdelay);
time1 = SDL_GetTicks();
refreshdelay[framecounter%2] =
1000/((((int)(time1-time2)) > 0)
? (int)(time1-time2) : 1000 );
time2 = time1;
if(abs(refreshdelay[framecounter%2]
- refreshdelay[(framecounter-1)%2])
>= 2)
{
rdelay = (refreshdelay[framecounter%2]
+ refreshdelay[(framecounter-1)%2])/2;
rdelay -= 16;
if(rdelay <= 0) rdelay = 0;
rdelay = 33;
}
}
if(!(framecounter%((int)(33*20))))
randreinit();
drawGLscene();
}
printf("Quit called, cleaning up\n");
SDL_Quit();
return(0);
}
void MapObject::set_tile(std::string _tile) {
tile = _tile;
load_textures();
generate_tex_data();
generate_vertex_data();
}
int main(int argc, char *argv[]) {
CmdLine cmd;
std::string sSfM_Dir;
cmd.add( make_option('i', sSfM_Dir, "sfmdir") );
try {
if (argc == 1) throw std::string("Invalid command line parameter.");
cmd.process(argc, argv);
} catch(const std::string& s) {
std::cerr << "Usage: " << argv[0] << '\n'
<< "[-i|--sfmdir SfM_Output path]\n"
<< std::endl;
std::cerr << s << std::endl;
return EXIT_FAILURE;
}
if (m_doc.load(sSfM_Dir))
{
current_cam = 0;
std::cout << "Press left or right key to navigate between cameras ;-)" << std::endl
<< "Move viewpoint with Q,W,E,A,S,D" << std::endl
<< "Change Normalized focal with Z and X" << std::endl
<< "Reset viewpoint position with R" << std::endl
<< "Esc to quit" << std::endl;
}
else {
exit( EXIT_FAILURE);
}
//-- Create the GL window context
GLFWwindow* window;
int width, height;
if( !glfwInit() )
{
fprintf( stderr, "Failed to initialize GLFW\n" );
exit( EXIT_FAILURE );
}
glfwWindowHint(GLFW_DEPTH_BITS, 16);
window = glfwCreateWindow( 1000, 600, "SfmViewer", NULL, NULL );
if (!window)
{
fprintf( stderr, "Failed to open GLFW window\n" );
glfwTerminate();
exit( EXIT_FAILURE );
}
// Set callback functions
glfwSetWindowCloseCallback(window, window_close_callback);
glfwSetWindowSizeCallback(window, reshape);
glfwSetKeyCallback(window, key);
glfwMakeContextCurrent(window);
glfwSwapInterval( 1 );
glfwGetWindowSize(window, &width, &height);
reshape(window, width, height);
load_textures();
// Main loop
while( running )
{
// Draw SfM Scene
draw();
// Swap buffers
glfwSwapBuffers(window);
glfwPollEvents();
}
// Terminate GLFW
glfwTerminate();
// Exit program
exit( EXIT_SUCCESS );
}
int main(int argc, char *argv[])
{
if (argc > 1){
if (strcmp(argv[1], "-debug") == 0 )
mode = MODE_DEBUG;
else if ( strcmp(argv[1], "-oculus") == 0 )
mode = MODE_OCULUS;
else if ( strcmp(argv[1], "-oculus-debug") == 0 )
mode = MODE_OCULUS_DEBUG;
else return 100;
}else
mode = MODE_DEBUG;
int err;
// Init OVR library, hardware and sensors.
err = init_ovr();
if ( err != 0 )
exit( 10 + err );
//Init windows and OpenGL context
err = init_SDL_GL();
if ( err != 0 )
exit( 0 + err );
// Load and Init shader and shaders Program
err = load_init_shaders();
if ( err != 0 )
exit( 20 + err );
// Load the Vertices, vertex arrays, etc... And bind them, along with the shaders.
err = load_vertex();
if ( err != 0 )
exit( 30 + err );
// Loads the texture from files and bien them as uniform in the frag shader
err = load_textures();
if ( err != 0 )
exit( 40 + err );
if (mode != MODE_DEBUG){
// Inits the frame buffer, usefull for rendering the scene in a texture to send it to Oculus
err = init_framebuffers();
if ( err != 0 )
exit( 50 + err );
err = init_render_ovr();
if ( err != 0 )
exit( 60 + err );
}
std::cout << "Recommended w " << recommendedTex0Size.w << std::endl << "Recommended h " << recommendedTex0Size.h << std::endl;
// Tansformations
//---------------------------------------------
// ---- Transfo
glm::mat4 trans;
GLuint uniTrans = glGetUniformLocation(shaderProgram, "trans");
// ---- View
glm::mat4 view;
// ---- Projection
glm::mat4 proj;
// Render in Texture, and display
//-------------------------------------------------
if (mode == MODE_OCULUS_DEBUG ){
load_init_passthrough_shaders();
GLuint passthroughOB;
glGenBuffers(1, &passthroughOB);
glBindBuffer(GL_ARRAY_BUFFER, passthroughOB);
glBufferData(GL_ARRAY_BUFFER, sizeof(passthroughScreen), passthroughScreen, GL_STATIC_DRAW);
// Binding the fragment Shader output to the current buffer
glBindFragDataLocation(passthroughShadersProgram, 0, "passthroughColor");
errorCode = glGetError();
// Link and Use Program
glLinkProgram(passthroughShadersProgram);
glUseProgram(passthroughShadersProgram);
// Store the attributes for the shaders
glGenVertexArrays(1, &passthroughVAO);
glBindVertexArray(passthroughVAO);
// Attributes Locations for Shaders and Enable
GLint posAttrib = glGetAttribLocation(passthroughShadersProgram, "position");
glVertexAttribPointer(posAttrib, 0, GL_FLOAT, GL_FALSE, sizeof(float) * 4, (void*) 2 );
glEnableVertexAttribArray(posAttrib);
GLint colorAttrib = glGetAttribLocation(passthroughShadersProgram, "texCoords");
glVertexAttribPointer(colorAttrib, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, (void*)(sizeof(float) * 2) );
glEnableVertexAttribArray(colorAttrib);
glUseProgram(passthroughShadersProgram);
glUniform1i(glGetUniformLocation(passthroughShadersProgram, "renderedTex"), 0);
}
// Event Loop
//--------------------------------------------------
SDL_Event windowEvent;
while (true)
{
if (SDL_PollEvent(&windowEvent))
{
// Quit events
if (windowEvent.type == SDL_QUIT) break;
else if (windowEvent.type == SDL_KEYUP && windowEvent.key.keysym.sym == SDLK_ESCAPE) break;
}
// Enabling ressources to draw the cube
// Before entering the rendering loop
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textures[0]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textures[1]);
// ---- View
view = glm::lookAt(
glm::vec3(5.0f, 5.0f, 5.0f),
glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3(0.0f, 0.0f, 1.0f)
);
GLint uniView = glGetUniformLocation(shaderProgram, "view");
glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(view));
// ---- Projection
if ( mode == MODE_DEBUG ){
proj = glm::perspective(45.0f, 1280.0f / 720.0f, 1.0f, 10.0f);
}else{
proj = glm::perspective(45.0f, 640.0f / 720.0f, 1.0f, 10.0f);
}
GLint uniProj = glGetUniformLocation(shaderProgram, "proj");
glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj));
//Turn around Z
trans = glm::rotate(
trans,
0.7f,
glm::vec3(0.0f, 0.0f, 1.0f)
);
glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(trans));
if ( mode == MODE_OCULUS || mode == MODE_OCULUS_DEBUG ){
hdmFrameTiming = ovrHmd_BeginFrame(hmd, 0);
glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
for (int eyeIndex = 0; eyeIndex < ovrEye_Count; eyeIndex++){
ovrEyeType eye = hmd->EyeRenderOrder[eyeIndex];
headPose[eye] = ovrHmd_GetEyePose(hmd, eye);
if (eye == ovrEye_Right){
glScissor(renderTargetSize.w / 2, 0, renderTargetSize.w / 2, renderTargetSize.h);
glViewport(renderTargetSize.w / 2, 0, renderTargetSize.w / 2, renderTargetSize.h);
}else{
glScissor(0, 0, renderTargetSize.w / 2, renderTargetSize.h);
glViewport(0, 0, renderTargetSize.w / 2, renderTargetSize.h);
}
if (eye == ovrEye_Right)
glClearColor(0.0f, 0.3f, 0.0f, 1.0f);
else
glClearColor(0.3f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
// Drawing
glDrawArrays(GL_TRIANGLES, 0, 36);
}
if (mode == MODE_OCULUS ){
glScissor(0, 0, renderTargetSize.w, renderTargetSize.h);
glViewport(0, 0, renderTargetSize.w, renderTargetSize.h);
ovrHmd_EndFrame(hmd, headPose, eyeTex);
Sleep(1);
}else if ( mode == MODE_OCULUS_DEBUG ){
glBindBuffer(GL_FRAMEBUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glUseProgram(0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindVertexArray(passthroughVAO);
glDisable(GL_DEPTH_TEST);
glUseProgram(passthroughShadersProgram);
glActiveTexture(GL_TEXTURE0);
glDrawArrays(GL_TRIANGLES, 0, 6);
}
}else if (mode == MODE_DEBUG){
// Clear the screen and the depth buffer (as it is filled with 0 initially,
// nothing will be draw (0 = on top);
glClearColor(0.0f, 0.3f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Drawing
glDrawArrays(GL_TRIANGLES, 0, 36);
}
if ( mode != MODE_OCULUS )
SDL_GL_SwapWindow(window);
}
// Destoy the HMD and shutdown the library
ovrHmd_Destroy(hmd);
ovr_Shutdown();
// Quite SDL and OpenGL
glDeleteFramebuffers(1, &frameBuffer);
SDL_GL_DeleteContext(context);
SDL_Quit();
return 0;
}
ENTRYPOINT void
init_matrix (ModeInfo *mi)
{
matrix_configuration *mp;
int wire = MI_IS_WIREFRAME(mi);
Bool flip_p = 0;
int i;
if (wire)
do_texture = False;
if (!mps) {
mps = (matrix_configuration *)
calloc (MI_NUM_SCREENS(mi), sizeof (matrix_configuration));
if (!mps) {
fprintf(stderr, "%s: out of memory\n", progname);
exit(1);
}
}
mp = &mps[MI_SCREEN(mi)];
mp->glx_context = init_GL(mi);
if (!mode_str || !*mode_str || !strcasecmp(mode_str, "matrix"))
{
flip_p = 1;
mp->glyph_map = matrix_encoding;
mp->nglyphs = countof(matrix_encoding);
}
else if (!strcasecmp (mode_str, "dna"))
{
flip_p = 0;
mp->glyph_map = dna_encoding;
mp->nglyphs = countof(dna_encoding);
}
else if (!strcasecmp (mode_str, "bin") ||
!strcasecmp (mode_str, "binary"))
{
flip_p = 0;
mp->glyph_map = binary_encoding;
mp->nglyphs = countof(binary_encoding);
}
else if (!strcasecmp (mode_str, "hex") ||
!strcasecmp (mode_str, "hexadecimal"))
{
flip_p = 0;
mp->glyph_map = hex_encoding;
mp->nglyphs = countof(hex_encoding);
}
else if (!strcasecmp (mode_str, "dec") ||
!strcasecmp (mode_str, "decimal"))
{
flip_p = 0;
mp->glyph_map = decimal_encoding;
mp->nglyphs = countof(decimal_encoding);
}
else
{
fprintf (stderr,
"%s: `mode' must be matrix, dna, binary, or hex: not `%s'\n",
progname, mode_str);
exit (1);
}
reshape_matrix (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
glShadeModel(GL_SMOOTH);
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glEnable(GL_NORMALIZE);
if (do_texture)
{
load_textures (mi, flip_p);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
/* Jeff Epler points out:
By using GL_ONE instead of GL_SRC_ONE_MINUS_ALPHA, glyphs are
added to each other, so that a bright glyph with a darker one
in front is a little brighter than the bright glyph alone.
*/
glBlendFunc (GL_SRC_ALPHA, GL_ONE);
}
/* to scale coverage-percent to strips, this number looks about right... */
mp->nstrips = (int) (density * 2.2);
if (mp->nstrips < 1) mp->nstrips = 1;
else if (mp->nstrips > 2000) mp->nstrips = 2000;
mp->strips = calloc (mp->nstrips, sizeof(strip));
for (i = 0; i < mp->nstrips; i++)
{
strip *s = &mp->strips[i];
reset_strip (mi, s);
/* If we start all strips from zero at once, then the first few seconds
of the animation are much denser than normal. So instead, set all
the initial strips to erase-mode with random starting positions.
As these die off at random speeds and are re-created, we'll get a
more consistent density. */
s->erasing_p = True;
s->spinner_y = frand(GRID_SIZE);
memset (s->glyphs, 0, sizeof(s->glyphs)); /* no visible glyphs */
}
/* Compute the brightness ramp.
*/
for (i = 0; i < WAVE_SIZE; i++)
{
GLfloat j = ((WAVE_SIZE - i) / (GLfloat) (WAVE_SIZE - 1));
j *= (M_PI / 2); /* j ranges from 0.0 - PI/2 */
j = sin (j); /* j ranges from 0.0 - 1.0 */
j = 0.2 + (j * 0.8); /* j ranges from 0.2 - 1.0 */
mp->brightness_ramp[i] = j;
/* printf("%2d %8.2f\n", i, j); */
}
auto_track_init (mi);
}
void Renderizer::load_files()
{
load_textures();
load_sprites();
}
