void wxGL_PMFCanvas::Reinit(bool should_reset_view)
{
previus_focus = NULL;
if (FreezeRender)// don't do this if we're already froze
return;
FreezeRender = true;
while (IsRendering);
int itemp;
wxConfigBase *pConfig = wxConfigBase::Get();
pConfig->SetPath(_T("/gr_options/"));
pConfig->Read(_("use_vertex_buffer_objects"), &itemp, 0); // default to off
UseVBOs = (itemp == 1);
model.init_vertex_buffers(itemp == 1);
if (model.GetSOBJCount())
{
if (should_reset_view) {
reset_view();
}
reload_textures();
}
static geo_sphere sphere(3);
if (GLEE_ARB_vertex_buffer_object)
omni_point_buffer = sphere.make_vertex_buffer(3);
FreezeRender = false;
}
void OrderView::on_key_down(unsigned char key, int x, int y)
{
switch (key)
{
case 'c':
reset_view(true);
refresh();
break;
case 'm':
b_orders = !b_orders;
refresh();
break;
case 'p':
{
switch (pal_type)
{
case H2DV_PT_HUESCALE: pal_type = H2DV_PT_GRAYSCALE; break;
case H2DV_PT_GRAYSCALE: pal_type = H2DV_PT_INVGRAYSCALE; break;
case H2DV_PT_INVGRAYSCALE: pal_type = H2DV_PT_HUESCALE; break;
default: throw Hermes::Exceptions::Exception("Invalid palette type");
}
ord.lock_data();
init_order_palette(ord.get_vertices());
ord.unlock_data();
refresh();
break;
}
default:
View::on_key_down(key, x, y);
break;
}
}
void MeshView::on_key_down(unsigned char key, int x, int y)
{
switch (key)
{
case 'c':
reset_view(true);
refresh();
break;
case 'b':
b_markers = !b_markers;
refresh();
break;
case 'i':
if(b_elem_mrk) b_elem_mrk = false;
b_ids = !b_ids;
refresh();
break;
case 'm':
if(b_ids) b_ids = false;
b_elem_mrk = !b_elem_mrk;
refresh();
break;
default:
View::on_key_down(key, x, y);
break;
}
}
obj::camera::camera(float init_angle) {
i = new float[3];
i[0] = 0;
i[1] = 0;
i[2] = 0;
d = new float[3];
d[1] = 0;
angle = init_angle;
refresh_direction();
reset_view(800, 600);
}
vktraceviewer::~vktraceviewer()
{
close_trace_file();
if (m_pTimeline != NULL)
{
delete m_pTimeline;
m_pTimeline = NULL;
}
reset_view();
delete ui;
vktraceviewer_output_deinit();
}
t_3dview *init_view(matrix box)
{
t_3dview *view;
int i,j;
snew(view,1);
/* Copy parameters into variables */
for(i=0; (i<DIM); i++)
for(j=0; (j<DIM); j++)
view->box[i][j]=box[i][j];
reset_view(view);
return view;
}
void OrderView::show(SpaceSharedPtr<Scalar> space, bool show_edge_orders)
{
if (!space->is_up_to_date())
throw Hermes::Exceptions::Exception("The space is not up to date.");
ord.lock_data();
ord.process_space(space, show_edge_orders);
ord.calc_vertices_aabb(&vertices_min_x, &vertices_max_x, &vertices_min_y, &vertices_max_y);
init_order_palette(ord.get_vertices());
ord.unlock_data();
create();
update_layout();
reset_view(false);
refresh();
wait_for_draw();
}
void VectorView::show(MeshFunction* xsln, MeshFunction* ysln, double eps, int xitem, int yitem)
{
vec.lock_data();
vec.process_solution(xsln, xitem, ysln, yitem, eps);
if (range_auto) { range_min = vec.get_min_value();
range_max = vec.get_max_value(); }
vec.calc_vertices_aabb(&vertices_min_x, &vertices_max_x, &vertices_min_y, &vertices_max_y);
vec.unlock_data();
create();
update_layout();
reset_view(false);
refresh();
wait_for_draw();
}
void VectorView::on_key_down(unsigned char key, int x, int y)
{
switch (key)
{
case 'm':
lines = !lines;
refresh();
break;
case 'l':
pmode = !pmode;
refresh();
break;
case 'c':
reset_view(true);
refresh();
break;
case 'f':
set_palette_filter(pal_filter != GL_LINEAR);
break;
case 'x':
set_grid_type(!hexa);
break;
case 'b':
mode++;
if (mode > 2) mode = 0;
refresh();
break;
case '*':
case '/':
if (key == '*') length_coef *= 1.1;
else length_coef /= 1.1;
refresh();
break;
default:
View::on_key_down(key, x, y);
break;
}
}
static bool
help_open(struct view *view, enum open_flags flags)
{
struct keymap *keymap;
reset_view(view);
add_line_text(view, "Quick reference for tig keybindings:", LINE_DEFAULT);
add_line_text(view, "", LINE_DEFAULT);
for (keymap = get_keymaps(); keymap; keymap = keymap->next) {
struct help_request_iterator iterator = { view, keymap, TRUE };
if (foreach_request(help_open_keymap, &iterator))
help_open_keymap_run_requests(&iterator);
}
return TRUE;
}
void Window::connect_signaux_scene()
{
//Si la zone d'affichage existe
if (area_view)
{
//modification de r
QObject::connect(sld_r, SIGNAL(valueChanged(int)), area_view->get_scene(), SLOT(signal_set_pov_r(int)));
QObject::connect(sld_r, SIGNAL(valueChanged(int)),this, SLOT(update()));
//modification de theta
QObject::connect(sld_theta, SIGNAL(valueChanged(int)), area_view->get_scene(), SLOT(signal_set_pov_theta(int)));
QObject::connect(sld_theta, SIGNAL(valueChanged(int)),this, SLOT(update()));
//modification de phi
QObject::connect(sld_phi, SIGNAL(valueChanged(int)), area_view->get_scene(), SLOT(signal_set_pov_phi(int)));
QObject::connect(sld_phi, SIGNAL(valueChanged(int)),this, SLOT(update()));
//modification de r
QObject::connect(sld_r_lum, SIGNAL(valueChanged(int)), area_view->get_scene(), SLOT(signal_set_pol_r(int)));
QObject::connect(sld_r_lum, SIGNAL(valueChanged(int)),this, SLOT(update()));
//modification de theta
QObject::connect(sld_theta_lum, SIGNAL(valueChanged(int)), area_view->get_scene(), SLOT(signal_set_pol_theta(int)));
QObject::connect(sld_theta_lum, SIGNAL(valueChanged(int)),this, SLOT(update()));
//modification de phi
QObject::connect(sld_phi_lum, SIGNAL(valueChanged(int)), area_view->get_scene(), SLOT(signal_set_pol_phi(int)));
QObject::connect(sld_phi_lum, SIGNAL(valueChanged(int)),this, SLOT(update()));
QObject::connect(cbb_vitesse_deplacement, SIGNAL(highlighted(int)),area_view->get_scene(), SLOT(set_drag_speed(int)));
QObject::connect(cbb_vitesse_zoom, SIGNAL(highlighted(int)),area_view->get_scene(), SLOT(set_zoom_speed(int)));
}
//Lorsqu'on click sur "Reset de l'objet"
QObject::connect(bt_raz, SIGNAL(clicked()), this, SLOT(reset_view()));
//Lorsqu'on click sur "Reset de la lumière"
QObject::connect(bt_raz_lum, SIGNAL(clicked()), this, SLOT(reset_lum()));
//lorsqu'on change de mode de visualisation
QObject::connect(cbb_line, SIGNAL(highlighted(int)), this , SLOT(signal_set_mode_line(int)));
QObject::connect(cbb_texture, SIGNAL(highlighted(int)), this, SLOT(signal_set_mode_surface(int)));
}
bool Viewer::on_configure_event(GdkEventConfigure* event) {
Glib::RefPtr<Gdk::GL::Drawable> gldrawable = get_gl_drawable();
if (!gldrawable) return false;
if (!gldrawable->gl_begin(get_gl_context()))
return false;
gldrawable->gl_end();
if (firstConfig) {
firstConfig = false;
reset_view();
} else {
reset_perspective_screen();
}
return true;
}
void Viewer::on_realize() {
// Do some OpenGL setup.
// First, let the base class do whatever it needs to
Gtk::GL::DrawingArea::on_realize();
Glib::RefPtr<Gdk::GL::Drawable> gldrawable = get_gl_drawable();
if (!gldrawable)
return;
if (!gldrawable->gl_begin(get_gl_context()))
return;
gldrawable->gl_end();
reset_view();
// Redraw label first time.
reset_window_label();
}
void VectorView::load_data(const char* filename)
{
//get data
vec.load_data(filename);
vec.lock_data();
vec.calc_vertices_aabb(&vertices_min_x, &vertices_max_x, &vertices_min_y, &vertices_max_y);
vec.unlock_data();
if (range_auto) {
range_min = vec.get_min_value();
range_max = vec.get_max_value();
}
create();
update_layout();
reset_view(false);
refresh();
wait_for_draw();
}
void init(SDL_Renderer* renderer)
{
input_show_debug_rect = false;
worldMap.Load("test.map");
//worldMap.NewMap(32, 32);
reset_view();
tileset = IMG_LoadTexture(renderer, "tileset.png");
SDL_QueryTexture(tileset, NULL, NULL, &tilesetRect.get()->w, &tilesetRect.get()->h);
TILESET_WIDTH = tilesetRect.get()->w / tileSizeX;
TILESET_HEIGHT = tilesetRect.get()->h / tileSizeY;
TILES_EDITOR[0] = getTileIndex(0, 0, TILESET_WIDTH);
TILES_EDITOR[1] = getTileIndex(0, 6, TILESET_WIDTH);
TILES_EDITOR[2] = getTileIndex(4, 11, TILESET_WIDTH);
TILES_EDITOR[3] = getTileIndex(4, 8, TILESET_WIDTH);
TILES_EDITOR[4] = getTileIndex(8, 12, TILESET_WIDTH);
for (int i = 0; i < NB_TILES_EDITOR; i++) {
std::cout << "editor[" << i << "]= " << TILES_EDITOR[i] << "\n";
}
}
static int main_game_loop(struct env *board,
struct creature *pac,
struct creature *ghost,
int cnt)
{
unsigned long time_to_sleep;
enum dir_t direction;
int i, won = 0;
draw_board(board);
box_print(0, 0, "Welcome. Hit any key to start :)");
update_view();
blocking_input();
do {
/* set up and place the players (ghosts etc) */
if (!init_players(board, pac, ghost, cnt))
return 0;
/* blank out screen, ready for action */
reset_view();
draw_board(board);
time_to_sleep = INITIAL_DELAY;
for (;;) {
/* check for user input */
direction = get_user_input();
if (direction == QUIT) break;
move_pac(board, pac, direction);
draw_creature(board, pac);
erase_tail(board, pac);
/* Move and draw N ghosts. */
for (i=0; i<cnt; i++) {
ghost_move(board, &(ghost[i]), i);
draw_creature(board, &(ghost[i]));
erase_tail(board, &(ghost[i]));
}
/* Up the score if we got any cherries,
* then print the new (or old) score. */
pick_up_cherries(board, pac);
print_stat(board);
/* update the whole screen */
update_view();
/* Check if there's any more cherries to
* pick, otherwise the game is won. */
won = game_won(board);
if (won) break;
if (pac_caught(pac, ghost, cnt)) {
down_lives(board);
break;
}
/*
* Sleep for a short while. This function is not
* ANSI/ISO-C.
*/
usleep(time_to_sleep);
if (time_to_sleep > MIN_DELAY)
time_to_sleep -= DEC_DELAY;
}
} while (direction != QUIT && !won && lives_left(board) > 0 && play_again());
finish(won, lives_left(board));
return 1;
}
static void resize(int w, int h)
{
reset_view(w,h);
}
int main(int argc, char** argv)
{
char c;
unsigned width_override = 0;
unsigned height_override = 0;
unsigned window_width = 512;
unsigned window_height = 512;
unsigned long time_generations = 0;
view.fullscreen = true;
DEBUG("Initializing GLUT\n");
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_RGBA);
while ((c = getopt_long(argc, argv, "w:s:hft:", longopts, NULL)) != -1) {
switch (c) {
case 's':
sscanf(optarg, "%ux%u\n", &width_override, &height_override);
break;
case 'w':
sscanf(optarg, "%ux%u\n", &window_width, &window_height);
break;
case 'f':
view.fullscreen = true;
break;
case 't':
time_generations = strtoul(optarg, NULL, 10);
break;
case 'h':
default:
usage(argv[0]);
}
}
argc -= optind;
argv += optind;
atexit(cleanup);
init_parallel_component();
compute_params.generations_per_redraw = 0.05;
create_window(window_width, window_height);
uint8_t* data = NULL;
unsigned width = width_override ? width_override : 128;
unsigned height = height_override ? height_override : 128;
if (argc >= 1) {
const char* filename = argv[0];
DEBUG("Filename argument \"%s\" given\n", filename);
unsigned __width, __height;
data = read_file(filename, &__width, &__height, width_override, height_override);
if (data != NULL) {
width = __width;
height = __height;
}
}
create_grid(width, height, data);
if (time_generations) {
struct timeval t1, t2;
gettimeofday(&t1, NULL);
DEBUG("Timing how long it takes to advance %lu generations\n", time_generations);
advance_generations(time_generations);
gettimeofday(&t2, NULL);
unsigned long us_elapsed = (t2.tv_sec * 1000000 + t2.tv_usec) -
(t1.tv_sec * 1000000 + t1.tv_usec);
printf("%lu milliseconds elapsed\n", us_elapsed / 1000);
} else {
reset_view();
glutMainLoop();
}
return 0;
}
static bool HandleClient(t_x11 *x11, int ID, t_gmx *gmx)
{
t_pulldown *pd;
pd = gmx->pd;
switch (ID)
{
/* File Menu */
case IDDUMPWIN:
write_gmx(x11, gmx, IDDODUMP);
break;
case IDDODUMP:
if (gmx->man->bAnimate)
{
hide_but(x11, gmx->man->vbox);
}
dump_it(gmx->man);
if (gmx->man->bAnimate)
{
show_but(x11, gmx->man->vbox);
}
break;
case IDCLOSE:
case IDIMPORT:
case IDEXPORT:
ShowDlg(gmx->dlgs[edExport]);
break;
case IDDOEXPORT:
write_sto_conf(gmx->confout, *gmx->man->top.name,
&(gmx->man->top.atoms),
gmx->man->x, NULL, gmx->man->molw->ePBC, gmx->man->box);
break;
case IDQUIT:
show_mb(gmx, emQuit);
break;
case IDTERM:
done_gmx(x11, gmx);
return true;
/* Edit Menu */
case IDEDITTOP:
edit_file("topol.gmx");
break;
case IDEDITCOORDS:
edit_file("confin.gmx");
break;
case IDEDITPARAMS:
edit_file("mdparin.gmx");
break;
/* Display Menu */
case IDFILTER:
if (gmx->filter)
{
ShowDlg(gmx->dlgs[edFilter]);
}
break;
case IDDOFILTER:
do_filter(x11, gmx->man, gmx->filter);
break;
case IDANIMATE:
check_pd_item(pd, IDANIMATE, toggle_animate(x11, gmx->man));
break;
case IDLABELSOFF:
no_labels(x11, gmx->man);
break;
case IDRESETVIEW:
reset_view(gmx->man->view);
ExposeWin(x11->disp, gmx->man->molw->wd.self);
break;
case IDPHOTO:
show_mb(gmx, emNotImplemented);
break;
case IDBONDOPTS:
ShowDlg(gmx->dlgs[edBonds]);
break;
case IDTHIN:
set_bond_type(x11, gmx->man->molw, eBThin);
break;
case IDFAT:
set_bond_type(x11, gmx->man->molw, eBFat);
break;
case IDVERYFAT:
set_bond_type(x11, gmx->man->molw, eBVeryFat);
break;
case IDBALLS:
set_bond_type(x11, gmx->man->molw, eBSpheres);
break;
case IDNOBOX:
set_box_type(x11, gmx->man->molw, esbNone);
break;
case IDRECTBOX:
set_box_type(x11, gmx->man->molw, esbRect);
break;
case IDTRIBOX:
set_box_type(x11, gmx->man->molw, esbTri);
break;
case IDTOBOX:
set_box_type(x11, gmx->man->molw, esbTrunc);
break;
/* Analysis Menu */
case IDBOND:
case IDANGLE:
case IDDIH:
case IDRMS:
case IDRDF:
case IDENERGIES:
case IDCORR:
show_mb(gmx, emNotImplemented);
break;
/* Help Menu */
case IDHELP:
show_mb(gmx, emHelp);
break;
case IDABOUT:
show_logo(x11, gmx->logo);
break;
default:
break;
}
return false;
}
void update(SDL_Event& event)
{
const Uint8* state = SDL_GetKeyboardState(NULL);
if (state[SDL_SCANCODE_LEFT]) {
camX -= CAM_INC;
}
else if (state[SDL_SCANCODE_RIGHT]) {
camX += CAM_INC;
}
if (state[SDL_SCANCODE_UP]) {
camY -= CAM_INC;
}
else if (state[SDL_SCANCODE_DOWN]) {
camY += CAM_INC;
}
if (state[SDL_SCANCODE_P]) {
input_offset++;
}
else if(state[SDL_SCANCODE_O]) {
input_offset--;
}
if (state[SDL_SCANCODE_L]) {
input_scale += 0.2;
}
else if (state[SDL_SCANCODE_K]) {
input_scale -= 0.2;
}
if (state[SDL_SCANCODE_M]) {
reset_view();
}
if (state[SDL_SCANCODE_F]) {
input_draw_space = !input_draw_space;
}
SDL_GetMouseState(&mouse_x, &mouse_y);
if (event.type == SDL_MOUSEBUTTONDOWN) {
if (event.button.button == SDL_BUTTON_LEFT) {
if(!mouseLeftPressed) {
mouseLeftPressed = true;
mouseLeft = false;
}
}
else if (event.button.button == SDL_BUTTON_RIGHT) {
if (!mouseRightPressed) {
mouseRightPressed = true;
mouseRight = false;
}
}
}
else if (event.type == SDL_MOUSEBUTTONUP) {
if (event.button.button == SDL_BUTTON_LEFT) {
if (mouseLeftPressed) {
mouseLeftPressed = false;
mouseLeft = true;
}
}
else if (event.button.button == SDL_BUTTON_RIGHT) {
if (mouseRightPressed) {
mouseRightPressed = false;
mouseRight = true;
}
}
}
else if (event.type == SDL_KEYDOWN) {
if (event.key.keysym.sym == SDLK_s) {
if (!key1Pressed) {
key1Pressed = true;
key1 = false;
}
}
else if (event.key.keysym.sym == SDLK_d) {
if (!key2Pressed) {
key2Pressed = true;
key2 = false;
}
}
else if (event.key.keysym.sym == SDLK_f) {
if (!keyDebugPressed) {
keyDebugPressed = true;
keyDebug = false;
}
}
}
else if (event.type == SDL_KEYUP) {
if (event.key.keysym.sym == SDLK_s) {
if (key1Pressed) {
key1Pressed = false;
key1 = true;
}
}
else if (event.key.keysym.sym == SDLK_d) {
if (key2Pressed) {
key2Pressed = false;
key2 = true;
}
}
else if (event.key.keysym.sym == SDLK_f) {
if (keyDebugPressed) {
keyDebugPressed = false;
keyDebug = true;
}
}
}
if (mouseLeft) {
mouseLeft = false;
std::cout << "mouse click left\n";
mouseClick(MOUSE_LEFT);
}
if (mouseRight) {
mouseRight = false;
std::cout << "mouse click right\n";
mouseClick(MOUSE_RIGHT);
}
if (key1) {
key1 = false;
std::cout << "key1\n";
keyClick(1);
}
else if (key2) {
key2 = false;
std::cout << "key2\n";
keyClick(2);
}
if (keyDebug) {
keyDebug = false;
input_show_debug_rect = !input_show_debug_rect;
}
/*rect.x = i * tileSizeX;
rect.y = WIN_HEIGHT - tileSizeY;*/
}
