int wt_init(char *pszWorldFile, int width, int height)
{
FILE *fp;
if ((fp = fopen(pszWorldFile, "r")) == NULL) {
perror(pszWorldFile);
exit(EXIT_FAILURE);
}
w = read_world_file(fp);
fclose(fp);
init_graphics();
init_renderer(width, height);
init_input_devices();
/* setup view */
view = new_view(fixdiv(FIXED_2PI, INT_TO_FIXED(4)));
view->x = FIXED_ZERO;
view->y = FIXED_ZERO;
view->height = FIXED_ONE;
view->angle = FIXED_ZERO;
frames = 0;
return EXIT_SUCCESS;
}
void GameScene::update_camera(float dt)
{
if (dt == 0)
{
return;
}
float panlerpratio = camera_pan_lerp_ratio_ * dt;
float zoomlerpratio = camera_zoom_lerp_ratio_ * dt;
camera_zoom_ = vector_LERP(camera_zoom_, camera_zoom_target_, zoomlerpratio);
const sf::View& dft_view = default_view();
float viewwidth = dft_view.GetRect().GetWidth() / camera_zoom_.x;
float viewheight = dft_view.GetRect().GetHeight() / camera_zoom_.y;
sf::FloatRect target(0,0,
viewwidth, viewheight);
sf::View new_view(target);
sf::Vector2f new_pos = vector_LERP(camera_position_, camera_target_, panlerpratio);
camera_position_ = new_pos;
new_view.SetCenter(new_pos);
set_view(new_view);
}
int main(int argc, char **argv) {
textbuf = new fltk::TextBuffer(0);
textbuf->text("hello \xe4\xb8\xad\xe6\x96\x87\xe6\xb8\xac\xe8\xa9\xa6hello world");
styletable[0].font = fltk::font("Droid Sans", 0);
style_init();
fltk::Window* window = new_view();
fltk::Font **arr;
int i = fltk::list_fonts(arr);
for(int j=0;j<i;j++){
printf("%s\n",arr[j]->name());
}
window->show(1, argv);
if (argc > 1) {
window->label(" "); // Prevent from displaying "Untitled.txt" before its time...
load_file(argv[1], -1);
}
return fltk::run();
}
void BaseMemcachedStore::update_config()
{
MemcachedConfig cfg;
if (_config_reader->read_config(cfg))
{
new_view(cfg);
_tombstone_lifetime = cfg.tombstone_lifetime;
}
else
{
TRC_ERROR("Failed to read config, keeping previous settings");
}
}
static bool handle_view_created(wlc_handle handle) {
swayc_t *focused = get_focused_container(&root_container);
uint32_t type = wlc_view_get_type(handle);
// If override_redirect/unmanaged/popup/modal/splach
if (type) {
sway_log(L_DEBUG,"Unmanaged window of type %x left alone", type);
wlc_view_set_state(handle, WLC_BIT_ACTIVATED, true);
if (type & WLC_BIT_UNMANAGED) {
return true;
}
// For things like Dmenu
if (type & WLC_BIT_OVERRIDE_REDIRECT) {
override_redirect = true;
wlc_view_focus(handle);
}
// Float popups
if (type & WLC_BIT_POPUP) {
swayc_t *view = new_floating_view(handle);
wlc_view_set_state(handle, WLC_BIT_MAXIMIZED, false);
focus_view(view);
arrange_windows(active_workspace, -1, -1);
}
} else {
swayc_t *view = new_view(focused, handle);
//Set maximize flag for windows.
//TODO: floating windows have this unset
wlc_view_set_state(handle, WLC_BIT_MAXIMIZED, true);
unfocus_all(&root_container);
focus_view(view);
arrange_windows(view->parent, -1, -1);
}
if (wlc_view_get_state(focused->handle) & WLC_BIT_FULLSCREEN) {
unfocus_all(&root_container);
focus_view(focused);
arrange_windows(focused, -1, -1);
}
return true;
}
static void
add_holo( /* register a new holodeck section */
HDGRID *hdg,
char *gfn,
char *pfn
)
{
VIEW nv;
double d;
register int hd;
for (hd = 0; hd < HDMAX && hdlist[hd] != NULL; hd++)
;
if (hd >= HDMAX)
error(INTERNAL, "too many holodeck sections in add_holo");
hdlist[hd] = (HOLO *)malloc(sizeof(HOLO));
if (hdlist[hd] == NULL)
error(SYSTEM, "out of memory in add_holo");
memcpy((void *)hdlist[hd], (void *)hdg, sizeof(HDGRID));
hdcompgrid(hdlist[hd]);
hdgfn[hd] = savestr(gfn);
hdpfn[hd] = pfn && *pfn ? savestr(pfn) : (char *)NULL;
if (hd)
return;
/* set initial viewpoint */
nv = odev.v;
VSUM(nv.vp, hdlist[0]->orig, hdlist[0]->xv[0], 0.5);
VSUM(nv.vp, nv.vp, hdlist[0]->xv[1], 0.5);
VSUM(nv.vp, nv.vp, hdlist[0]->xv[2], 0.5);
fcross(nv.vdir, hdlist[0]->xv[1], hdlist[0]->xv[2]);
VCOPY(nv.vup, hdlist[0]->xv[2]);
if (do_outside) {
normalize(nv.vdir);
d = VLEN(hdlist[0]->xv[1]);
d += VLEN(hdlist[0]->xv[2]);
VSUM(nv.vp, nv.vp, nv.vdir, -d);
}
new_view(&nv);
}
static bool handle_view_created(wlc_handle handle) {
swayc_t *focused = get_focused_container(&root_container);
swayc_t *newview = NULL;
switch (wlc_view_get_type(handle)) {
// regular view created regularly
case 0:
newview = new_view(focused, handle);
wlc_view_set_state(handle, WLC_BIT_MAXIMIZED, true);
break;
// takes keyboard focus
case WLC_BIT_OVERRIDE_REDIRECT:
sway_log(L_DEBUG, "view %ld with OVERRIDE_REDIRECT", handle);
locked_view_focus = true;
wlc_view_focus(handle);
wlc_view_set_state(handle, WLC_BIT_ACTIVATED, true);
wlc_view_bring_to_front(handle);
break;
// Takes container focus
case WLC_BIT_OVERRIDE_REDIRECT|WLC_BIT_UNMANAGED:
sway_log(L_DEBUG, "view %ld with OVERRIDE_REDIRECT|WLC_BIT_MANAGED", handle);
wlc_view_bring_to_front(handle);
locked_container_focus = true;
break;
// set modals as floating containers
case WLC_BIT_MODAL:
wlc_view_bring_to_front(handle);
newview = new_floating_view(handle);
case WLC_BIT_POPUP:
break;
}
if (newview) {
set_focused_container(newview);
arrange_windows(newview->parent, -1, -1);
}
return true;
}
int main(int argc, char *argv[])
{
World *w;
FILE *fp;
Boolean quit = False;
Intent *intent;
fixed v = FIXED_ZERO;
double vx = 0.0, vy = 0.0, va = 0.0;
#ifdef MSDOS
long frames;
time_t starttime, endtime;
#endif
if (argc != 2) {
fprintf(stderr, "Usage: wt <world file>\n");
exit(EXIT_FAILURE);
}
if ((fp = fopen(argv[1], "r")) == NULL) {
perror(argv[1]);
exit(EXIT_FAILURE);
}
w = read_world_file(fp);
fclose(fp);
init_graphics();
init_renderer(SCREEN_WIDTH, SCREEN_HEIGHT);
init_input_devices();
/* setup view */
view = new_view(fixdiv(FIXED_2PI, INT_TO_FIXED(4)));
view->x = FIXED_ZERO;
view->y = FIXED_ZERO;
view->height = FIXED_ONE;
view->angle = FIXED_ZERO;
#ifdef MSDOS
starttime = time(NULL);
frames = 0;
#endif
while (!quit) {
double sin_facing, cos_facing;
render(w, view);
#ifdef MSDOS
frames++;
#endif
intent = read_input_devices();
/* This block code is a hack to do acceleration and deceleration. */
if (fabs(vx) > fabs(intent->force_x)) {
if (vx < 0.0)
vx = MIN(vx + 0.1, intent->force_x);
else
vx = MAX(vx - 0.1, intent->force_x);
} else if (fabs(vx) < fabs(intent->force_x)) {
vx += intent->force_x / 5.0;
if (fabs(vx) > fabs(intent->force_x))
vx = intent->force_x;
}
if (fabs(vy) > fabs(intent->force_y)) {
if (vy < 0.0)
vy = MIN(vy + 0.1, intent->force_y);
else
vy = MAX(vy - 0.1, intent->force_y);
} else if (fabs(vy) < fabs(intent->force_y)) {
vy += intent->force_y / 5.0;
if (fabs(vy) > fabs(intent->force_y))
vy = intent->force_y;
}
if (fabs(vy) > fabs(intent->force_y)) {
if (vy < 0.0)
vy = MIN(vy + 0.1, intent->force_y);
else
vy = MAX(vy - 0.1, intent->force_y);
} else if (fabs(vy) < fabs(intent->force_y)) {
vy += intent->force_y / 5.0;
if (fabs(vy) > fabs(intent->force_y))
vy = intent->force_y;
}
/* Angular deceleration here is weird and unrealistic, but it feels
** right to me.
*/
if (fabs(va) > fabs(intent->force_rotate))
va *= 0.6;
else if (fabs(va) < fabs(intent->force_rotate)) {
va += intent->force_rotate / 8.0;
if (fabs(va) > fabs(intent->force_rotate))
va = intent->force_rotate;
}
view->angle += FLOAT_TO_FIXED(0.3 * va);
sin_facing = sin(FIXED_TO_FLOAT(view->angle));
cos_facing = cos(FIXED_TO_FLOAT(view->angle));
view->x += FLOAT_TO_FIXED(0.8 * vx * cos_facing);
view->y += FLOAT_TO_FIXED(0.8 * vx * sin_facing);
view->x += FLOAT_TO_FIXED(0.8 * vy * -sin_facing);
view->y += FLOAT_TO_FIXED(0.8 * vy * cos_facing);
if (view->height > FIXED_ONE)
v -= FIXED_ONE / 16;
view->height += v;
if (view->height < FIXED_ONE) {
v = FIXED_ZERO;
view->height = FIXED_ONE;
}
while (intent->n_special--) {
if (intent->special[intent->n_special] == INTENT_END_GAME)
quit = True;
else
v = FIXED_ONE / 2;
}
}
#ifdef MSDOS
endtime = time(NULL);
#endif
end_input_devices();
end_graphics();
#ifdef MSDOS
printf("%li frames in %lu seconds - %.2f frames per second",
(long) frames, (long) endtime - starttime,
(float) frames / (float) (endtime-starttime));
#endif
return EXIT_SUCCESS;
}
static bool handle_view_created(wlc_handle handle) {
// if view is child of another view, the use that as focused container
wlc_handle parent = wlc_view_get_parent(handle);
swayc_t *focused = NULL;
swayc_t *newview = NULL;
// Get parent container, to add view in
if (parent) {
focused = get_swayc_for_handle(parent, &root_container);
}
if (!focused || focused->type == C_OUTPUT) {
focused = get_focused_container(&root_container);
}
sway_log(L_DEBUG, "handle:%ld type:%x state:%x parent:%ld "
"mask:%d (x:%d y:%d w:%d h:%d) title:%s "
"class:%s appid:%s",
handle, wlc_view_get_type(handle), wlc_view_get_state(handle), parent,
wlc_view_get_mask(handle), wlc_view_get_geometry(handle)->origin.x,
wlc_view_get_geometry(handle)->origin.y,wlc_view_get_geometry(handle)->size.w,
wlc_view_get_geometry(handle)->size.h, wlc_view_get_title(handle),
wlc_view_get_class(handle), wlc_view_get_app_id(handle));
// TODO properly figure out how each window should be handled.
switch (wlc_view_get_type(handle)) {
// regular view created regularly
case 0:
newview = new_view(focused, handle);
wlc_view_set_state(handle, WLC_BIT_MAXIMIZED, true);
break;
// Dmenu keeps viewfocus, but others with this flag dont, for now simulate
// dmenu
case WLC_BIT_OVERRIDE_REDIRECT:
// locked_view_focus = true;
wlc_view_focus(handle);
wlc_view_set_state(handle, WLC_BIT_ACTIVATED, true);
wlc_view_bring_to_front(handle);
break;
// Firefox popups have this flag set.
case WLC_BIT_OVERRIDE_REDIRECT|WLC_BIT_UNMANAGED:
wlc_view_bring_to_front(handle);
locked_container_focus = true;
break;
// Modals, get focus, popups do not
case WLC_BIT_MODAL:
wlc_view_focus(handle);
wlc_view_bring_to_front(handle);
newview = new_floating_view(handle);
case WLC_BIT_POPUP:
wlc_view_bring_to_front(handle);
break;
}
if (newview) {
set_focused_container(newview);
swayc_t *output = swayc_parent_by_type(newview, C_OUTPUT);
arrange_windows(output, -1, -1);
}
return true;
}
int
main(int argc, char **argv) {
GtkWidget *vbox;
int options;
options = get_options(argc, argv);
if(options != 0)
return options;
gtk_init(&argc, &argv);
lightpad = g_slice_new0(Window);
lightpad->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size((GtkWindow*)lightpad->window, 800, 400);
gtk_window_set_title(GTK_WINDOW(lightpad->window), "Lightpad");
gtk_window_set_default_icon_name("accessories-text-editor");
gtk_container_set_border_width(GTK_CONTAINER(lightpad->window), 0);
{
lightpad->popup = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_can_focus(lightpad->popup, TRUE);
gtk_window_set_decorated(GTK_WINDOW(lightpad->popup), FALSE);
gtk_window_set_type_hint(GTK_WINDOW(lightpad->popup), GDK_WINDOW_TYPE_HINT_POPUP_MENU);
gtk_window_set_transient_for(GTK_WINDOW(lightpad->popup), lightpad->window);
GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
lightpad->popupBox = vbox;
gtk_container_add(GTK_CONTAINER(lightpad->popup), vbox);
}
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(lightpad->window), vbox);
lightpad->tabs = gtk_notebook_new();
gtk_notebook_set_scrollable(GTK_NOTEBOOK(lightpad->tabs), TRUE);
gtk_box_pack_start(GTK_BOX(vbox), lightpad->tabs, TRUE, TRUE, 0);
g_signal_connect(lightpad->window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(lightpad->window, "delete-event", G_CALLBACK(on_delete_window), NULL);
g_signal_connect(lightpad->window, "key-press-event", G_CALLBACK(on_keypress_window), NULL);
g_signal_connect(lightpad->tabs, "page-added", G_CALLBACK(on_page_added), NULL);
if(init_config() < 0)
return -1;
if(remaining) {
for (int i = 0; remaining[i]; i++)
new_view(remaining[i]);
g_strfreev(remaining);
} else
new_view(NULL);
gtk_widget_show_all(lightpad->window);
gtk_main();
/* This will destroy all the children, who in turn
* will destroy their own children et cetera.
* Thus, there is no need to explicitly destroy
* all the GtkScrolledWindow objects
*/
gtk_widget_destroy(lightpad->window);
g_slice_free(Window, lightpad);
g_free((gpointer)settings->font);
g_free((gpointer)settings->scheme);
g_slice_free(Settings, settings);
return 0;
}
int
main(
int argc,
char *argv[]
)
{
int rdy, inp, res = 0, pause = 0;
progname = argv[0];
if (argc < 3)
error(USER, "bad command line arguments");
/* open our device */
dev_open(argv[1]);
/* open server process i/o */
sstdout = fdopen(atoi(argv[2]), "w");
if (argc < 4 || (inp = atoi(argv[3])) < 0)
sstdin = NULL;
else
sstdin = fdopen(inp, "r");
/* set command error vector */
erract[COMMAND].pf = eputs;
#ifdef DEBUG
tmodesw = time(NULL);
#endif
/* enter main loop */
do {
rdy = disp_wait();
if (rdy & RDY_SRV) { /* process server result */
res = serv_result();
if (pause && res != DS_SHUTDOWN) {
serv_request(DR_ATTEN, 0, NULL);
while ((res = serv_result()) != DS_ACKNOW &&
res != DS_SHUTDOWN)
;
}
}
if (rdy & RDY_DEV) { /* user input from driver */
inp = dev_input();
if (inp & DFL(DC_SETVIEW))
new_view(&odev.v);
else if (inp & DFL(DC_LASTVIEW))
new_view(NULL);
if (inp & DFL(DC_REDRAW))
imm_mode = beam_sync(1) > 0;
if (inp & DFL(DC_GETVIEW))
printview();
if (inp & DFL(DC_FOCUS))
set_focus(odev_args);
if (inp & DFL(DC_KILL)) {
serv_request(DR_KILL, 0, NULL);
pause = 0;
}
if (inp & DFL(DC_CLOBBER))
serv_request(DR_CLOBBER, 0, NULL);
if (inp & DFL(DC_RESTART)) {
serv_request(DR_RESTART, 0, NULL);
pause = 0;
}
if (inp & DFL(DC_RESUME)) {
serv_request(DR_NOOP, 0, NULL);
pause = 0;
}
if (inp & DFL(DC_PAUSE))
pause = 1;
if (inp & DFL(DC_QUIT))
serv_request(DR_SHUTDOWN, 0, NULL);
}
if (rdy & RDY_SIN && !imm_mode) /* user input from sstdin */
switch (usr_input()) {
case DC_PAUSE:
pause = 1;
break;
case DC_RESUME:
serv_request(DR_NOOP, 0, NULL);
/* fall through */
case DC_KILL:
case DC_RESTART:
pause = 0;
break;
}
} while (res != DS_SHUTDOWN);
#ifdef DEBUG
if (timm && nimmrays)
fprintf(stderr,
"%s: %.1f rays recalled/second (%ld rays total)\n",
progname, (double)nimmrays/timm, nimmrays);
if (tadd && naddrays)
fprintf(stderr,
"%s: %.1f rays calculated/second (%ld rays total)\n",
progname, (double)naddrays/tadd, naddrays);
#endif
/* all done */
quit(0);
return 0; /* pro forma return */
}
static int
usr_input(void) /* get user input and process it */
{
VIEW vparams;
char cmd[256];
register char *args;
register int i;
if (fgets(cmd, sizeof(cmd), sstdin) == NULL) {
fclose(sstdin);
sstdin = NULL;
return(-1);
}
if (*cmd == '\n')
return(DC_RESUME);
for (args = cmd; *args && !isspace(*args); args++)
;
while (isspace(*args))
*args++ = '\0';
if (*args && args[i=strlen(args)-1] == '\n')
args[i] = '\0';
for (i = 0; i < DC_NCMDS; i++)
if (!strcmp(cmd, cmdlist[i]))
break;
if (i >= DC_NCMDS) {
dev_auxcom(cmd, args);
return(-1);
}
switch (i) {
case DC_SETVIEW: /* set the view */
vparams = odev.v;
if (!sscanview(&vparams, args))
error(COMMAND, "missing view options");
else
new_view(&vparams);
break;
case DC_GETVIEW: /* print the current view */
printview();
break;
case DC_LASTVIEW: /* restore previous view */
new_view(NULL);
break;
case DC_FOCUS: /* set focus frame */
set_focus(args);
break;
case DC_PAUSE: /* pause the current calculation */
case DC_RESUME: /* resume the calculation */
/* handled in main() */
break;
case DC_REDRAW: /* redraw from server */
imm_mode = beam_sync(1) > 0;
dev_clear();
break;
case DC_KILL: /* kill rtrace process(es) */
serv_request(DR_KILL, 0, NULL);
break;
case DC_CLOBBER: /* clobber holodeck */
serv_request(DR_CLOBBER, 0, NULL);
break;
case DC_RESTART: /* restart rtrace */
serv_request(DR_RESTART, 0, NULL);
break;
case DC_QUIT: /* quit request */
serv_request(DR_SHUTDOWN, 0, NULL);
break;
default:
error(CONSISTENCY, "bad command id in usr_input");
}
return(i);
}
int main(int argc, char *argv[])
{
World *w;
View *view;
Intent *intent;
Graphics_info *ginfo;
Tcl_Interp *interp;
Object *me;
Boolean quit = False;
#if PROFILE
int fps_count = 0;
double total_time = 0.0;
double start_time;
#endif
interp = Tcl_CreateInterp();
updater = updater_create(interp);
if (argc != 2) {
fprintf(stderr, "Usage: %s <world file>\n", argv[0]);
exit(EXIT_FAILURE);
}
ginfo = init_graphics();
#define TRUECOLOR
#ifdef TRUECOLOR
set_texture_trans(32, ginfo->palette.color_lookup);
#else
set_texture_trans(ginfo->palette.rgb_cube_size,
ginfo->palette.color_lookup);
#endif
init_renderer(ginfo->width, ginfo->height);
init_input_devices();
/* Initialize the view */
view = new_view(FLOAT_TO_FIXED(3.14159265 / 2.0));
w = new_world();
parser_init(interp, w);
if (Tcl_EvalFile(interp, WT_INIT_FILENAME) != TCL_OK) {
fprintf(stderr, "%s\n", Tcl_GetVar(interp, "errorCode", 0));
fprintf(stderr, "%s\n", Tcl_GetVar(interp, "errorInfo", 0));
exit(1);
}
if (Tcl_EvalFile(interp, argv[1]) != TCL_OK) {
fprintf(stderr, "%s\n", Tcl_GetVar(interp, "errorCode", 0));
fprintf(stderr, "%s\n", Tcl_GetVar(interp, "errorInfo", 0));
exit(1);
}
while (!quit) {
double sin_facing, cos_facing;
double fx, fy, fz, torque;
Framebuffer *fb;
int i;
start_time = current_time();
intent = read_input_devices();
me = get_controlled_object();
if (me == NULL)
fatal_error("No controlled object");
for (i = 0; i < intent->n_special; i++) {
switch (intent->special[i]) {
case INTENT_END_GAME:
quit = True;
(void) Tcl_Eval(interp, "action_quit");
break;
case INTENT_JUMP:
(void) Tcl_Eval(interp, "action_jump");
break;
case INTENT_ACTION1:
(void) Tcl_Eval(interp, "action_1");
break;
case INTENT_ACTION2:
(void) Tcl_Eval(interp, "action_2");
break;
case INTENT_ACTION3:
(void) Tcl_Eval(interp, "action_3");
break;
case INTENT_ACTION4:
(void) (Tcl_Eval(interp, "action_4") != TCL_OK);
break;
case INTENT_ACTION5:
(void) Tcl_Eval(interp, "action_5");
break;
default:
break;
}
}
/* Determine forces on viewer. */
sin_facing = sin(me->angle);
cos_facing = cos(me->angle);
fx = cos_facing * intent->force_x - sin_facing * intent->force_y;
fy = sin_facing * intent->force_x + cos_facing * intent->force_y;
fz = -0.05 * me->mass; /* gravity */
torque = intent->force_rotate;
/* Apply the forces. */
object_apply_force(me, fx, fy, fz);
object_apply_torque(me, torque);
object_update(me);
if (me->z <= 0.0 && me->dz <= 0.0) {
me->z = 0.0;
me->dz = 0.0;
}
/* Determine the view. */
me = get_viewpoint_object();
if (me == NULL)
fatal_error("No viewpoint object");
object_view(me, view);
updater_run(updater);
/* Display the world. */
fb = render(w, view);
update_screen(fb);
#if PROFILE
fps_count++;
total_time += current_time() - start_time;
if (fps_count == 100) {
printf("fps = %3.2f\n", (double) fps_count / total_time);
fps_count = 0;
total_time = 0.0;
}
#endif
}
end_input_devices();
end_graphics();
return EXIT_SUCCESS;
}
void view_cb(fltk::Widget*, void*) {
fltk::Window* w = new_view();
w->show();
}
