static gint display_main (char** args, int args_length1) {
gint result;
Display* dialog;
gtk_init (&args_length1, &args);
dialog = g_object_ref_sink (display_new ());
gtk_widget_show_all ((GtkWidget*) dialog);
gtk_main ();
result = 0;
_g_object_unref0 (dialog);
return result;
}
static int
x_vdisplay_on_append(x_object *so, x_object *parent)
{
virtual_display_t *thiz = (virtual_display_t *) so;
ENTER;
thiz->yuv[0].data = NULL;
display_new(so, &thiz->yuv, &thiz->UI_ctx);
EXIT;
return 0;
}
static void
time_bar_init (TimeBar* self)
{
GtkWidget* button;
PRIV(self) = G_TYPE_INSTANCE_GET_PRIVATE (self,
TYPE_TIME_BAR,
TimeBarPrivate);
PRIV(self)->display = display_new ();
gtk_widget_show (PRIV(self)->display);
button = add_arrow_button (GTK_BOX (self),
GTK_ARROW_LEFT,
PRIV(self)->display);
gtk_box_pack_start_defaults (GTK_BOX (self),
PRIV(self)->display);
button = add_arrow_button (GTK_BOX (self),
GTK_ARROW_RIGHT,
PRIV(self)->display);
PRIV(self)->vbox = gtk_vbox_new (TRUE, 0);
gtk_widget_show (PRIV (self)->vbox);
gtk_box_pack_start (GTK_BOX (self),
PRIV(self)->vbox,
FALSE,
FALSE,
0);
button = add_icon_button (GTK_BOX (PRIV(self)->vbox),
GTK_STOCK_ZOOM_IN,
PRIV(self)->display);
bind_sensitive (button, "clicked", G_CALLBACK (display_zoom_in),
PRIV(self)->display, "can-zoom-in");
button = add_icon_button (GTK_BOX (PRIV(self)->vbox),
GTK_STOCK_ZOOM_OUT,
PRIV(self)->display);
bind_sensitive (button, "clicked", G_CALLBACK (display_zoom_out),
PRIV(self)->display, "can-zoom-out");
}
static void bind_display(struct uterm_video *video, drmModeRes *res,
drmModeConnector *conn)
{
struct uterm_display *disp;
struct uterm_mode *mode;
int ret, i;
ret = display_new(&disp, &dumb_display_ops);
if (ret)
return;
for (i = 0; i < conn->count_modes; ++i) {
ret = mode_new(&mode, &dumb_mode_ops);
if (ret)
continue;
mode->dumb.info = conn->modes[i];
mode->next = disp->modes;
disp->modes = mode;
/* TODO: more sophisticated default-mode selection */
if (!disp->default_mode)
disp->default_mode = mode;
}
if (!disp->modes) {
log_warn("no valid mode for display found");
uterm_display_unref(disp);
return;
}
disp->video = video;
disp->dumb.conn_id = conn->connector_id;
disp->flags |= DISPLAY_AVAILABLE;
disp->next = video->displays;
video->displays = disp;
disp->dpms = get_dpms(disp, conn);
log_info("display %p DPMS is %s", disp,
uterm_dpms_to_name(disp->dpms));
VIDEO_CB(video, disp, UTERM_NEW);
}
static int video_init(struct uterm_video *video, const char *node)
{
int ret;
struct uterm_display *disp;
ret = display_new(&disp, &fbdev_display_ops);
if (ret)
return ret;
disp->fbdev.node = strdup(node);
if (!disp->fbdev.node) {
log_err("cannot dup node name");
ret = -ENOMEM;
goto err_free;
}
disp->fbdev.fd = open(node, O_RDWR | O_CLOEXEC);
if (disp->fbdev.fd < 0) {
log_err("cannot open %s (%d): %m", node, errno);
ret = -EFAULT;
goto err_node;
}
disp->video = video;
disp->dpms = UTERM_DPMS_UNKNOWN;
video->displays = disp;
log_info("new device on %s", disp->fbdev.node);
return 0;
err_node:
free(disp->fbdev.node);
err_free:
uterm_display_unref(disp);
return ret;
}
Display* init_display()
{
Display *pDisplay = display_new();
display_init( pDisplay );
return pDisplay;
}
void renderer_cool::draw(int vertex_count)
{
static bool initial_resize = false;
if (!initial_resize)
{
if (enabler->fullscreen)
resize(size_x, size_y);
else
resize((size_x/init->font.small_font_dispx)*init->font.small_font_dispx, (size_y/init->font.small_font_dispy)*init->font.small_font_dispy);
//resize(gps->dimx*init->font.small_font_dispx, gps->dimy*init->font.small_font_dispy);
reshape_gl();
initial_resize = true;
}
static df::viewscreen *prevws = NULL;
df::viewscreen *ws = Gui::getCurViewscreen();
is_main_scr = df::viewscreen_dwarfmodest::_identity.is_direct_instance(ws) || df::viewscreen_dungeonmodest::_identity.is_direct_instance(ws);
if (ws != prevws)
{
gps->force_full_display_count = 1;
prevws = ws;
/*if (is_main_scr)
{
for (int x = 1; x < gps->dimx-gmenu_w-1; x++)
{
for (int y = 1; y < gps->dimy-1; y++)
{
const int tile1 = x * gps->dimy + y;
for (int i = 0; i < 6; i++)
*(fg + tile * 4 * i + 3) = 0;
}
}
}*/
}
display_new(is_main_scr);
#ifdef WIN32
// We can't do this in plugin_init() because OpenGL context isn't initialized by that time
static bool glew_init = false;
if (!glew_init)
{
GLenum err = glewInit();
if (err != GLEW_OK)
*out2 << glewGetErrorString(err);
glew_init = true;
}
#endif
static int old_dimx, old_dimy, old_winx, old_winy;
if (domapshot)
{
if (domapshot == 10)
{
old_dimx = gps->dimx;
old_dimy = gps->dimy;
old_winx = *df::global::window_x;
old_winy = *df::global::window_y;
grid_resize(world->map.x_count + 36, world->map.y_count + 2);
*df::global::window_x = 0;
*df::global::window_y = 0;
gps->force_full_display_count = 1;
}
domapshot--;
}
GLuint framebuffer, renderbuffer;
GLenum status;
if (domapshot == 5)
{
// Set the width and height appropriately for your image
GLuint imageWidth = gps->dimx * dispx,
imageHeight = gps->dimy * dispy;
//Set up a FBO with one renderbuffer attachment
glGenFramebuffers(1, &framebuffer);
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
glGenRenderbuffers(1, &renderbuffer);
glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, imageWidth, imageHeight);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER, renderbuffer);
glViewport(0, 0, gps->dimx * dispx, gps->dimy * dispy);
/*glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0,gps->dimx,gps->dimy,0,-1,1);*/
}
if (is_main_scr)
{
bool skip = false;
if (df::viewscreen_dungeonmodest::_identity.is_direct_instance(ws))
{
int m = df::global::ui_advmode->menu;
bool tmode = advmode_needs_map(m);
skip = !tmode;
}
if (!skip)
{
/////
glViewport(goff_x, goff_y_gl, gdimx * gdispx, gdimy * gdispy);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, gdimx, gdimy, 0, -1, 1);
//glTranslatef(1,-1,0);
//glScissor(off_x+(float)size_x/gps->dimx, off_y+(float)size_y/gps->dimy, gsize_x, gsize_y);
//glEnable(GL_SCISSOR_TEST);
//glClearColor(1,0,0,1);
//glClear(GL_COLOR_BUFFER_BIT);
if (multi_rendered && fogdensity > 0)
{
glEnable(GL_FOG);
glFogfv(GL_FOG_COLOR, fogcolor);
glFogf(GL_FOG_DENSITY, fogdensity);
glFogi(GL_FOG_COORD_SRC, GL_FOG_COORD);
glEnableClientState(GL_FOG_COORD_ARRAY);
glFogCoordPointer(GL_FLOAT, 0, fogcoord);
}
glVertexPointer(2, GL_FLOAT, 0, gvertexes);
// Render background colors
glDisable(GL_TEXTURE_2D);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_BLEND);
glColorPointer(4, GL_FLOAT, 0, gbg);
glDrawArrays(GL_TRIANGLES, 0, gdimx * gdimy * 6);
// Render foreground
glEnable(GL_TEXTURE_2D);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glTexCoordPointer(2, GL_FLOAT, 0, gtex);
glColorPointer(4, GL_FLOAT, 0, gfg);
glDrawArrays(GL_TRIANGLES, 0, gdimx * gdimy * 6);
if (multi_rendered)
{
glDisableClientState(GL_FOG_COORD_ARRAY);
glDisable(GL_FOG);
}
// Prepare and render shadows
if (multi_rendered)
{
int elemcnt = 0;
//TODO: don't do this if view not moved and tiles with shadows not changed
{
gl_texpos *txt = (gl_texpos *) enabler->textures.gl_texpos;
int x1 = std::min(gdimx, world->map.x_count-gwindow_x);
int y1 = std::min(gdimy, world->map.y_count-gwindow_y);
for (int tile = 0; tile < gdimx * gdimy; tile++)
{
int xx = tile / gdimy;
int yy = tile % gdimy;
int d = depth[tile];
if (d && d != 0x7f) //TODO: no need for the second check in fort mode
{
GLfloat *tex = shadowtex + elemcnt * 2;
bool top = false, left = false, btm = false, right = false;
if (xx > 0 && (depth[((xx - 1)*gdimy + yy)]) < d)
{
memcpy(shadowvert + elemcnt * 2, gvertexes + tile * 6 * 2, 6 * 2 * sizeof(float));
SETTEX(shadow_texpos[0]);
elemcnt += 6;
left = true;
}
if (yy < y1 - 1 && (depth[((xx)*gdimy + yy + 1)]) < d)
{
memcpy(shadowvert + elemcnt * 2, gvertexes + tile * 6 * 2, 6 * 2 * sizeof(float));
SETTEX(shadow_texpos[1]);
elemcnt += 6;
btm = true;
}
if (yy > 0 && (depth[((xx)*gdimy + yy - 1)]) < d)
{
memcpy(shadowvert + elemcnt * 2, gvertexes + tile * 6 * 2, 6 * 2 * sizeof(float));
SETTEX(shadow_texpos[2]);
elemcnt += 6;
top = true;
}
if (xx < x1-1 && (depth[((xx + 1)*gdimy + yy)]) < d)
{
memcpy(shadowvert + elemcnt * 2, gvertexes + tile * 6 * 2, 6 * 2 * sizeof(float));
SETTEX(shadow_texpos[3]);
elemcnt += 6;
right = true;
}
if (!right && !btm && xx < x1 - 1 && yy < y1 - 1 && (depth[((xx + 1)*gdimy + yy + 1)]) < d)
{
memcpy(shadowvert + elemcnt * 2, gvertexes + tile * 6 * 2, 6 * 2 * sizeof(float));
SETTEX(shadow_texpos[4]);
elemcnt += 6;
}
if (!left && !btm && xx > 0 && yy < y1 - 1 && (depth[((xx - 1)*gdimy + yy + 1)]) < d)
{
memcpy(shadowvert + elemcnt * 2, gvertexes + tile * 6 * 2, 6 * 2 * sizeof(float));
SETTEX(shadow_texpos[5]);
elemcnt += 6;
}
if (!left && !top && xx > 0 && yy > 0 && (depth[((xx - 1)*gdimy + yy - 1)]) < d)
{
memcpy(shadowvert + elemcnt * 2, gvertexes + tile * 6 * 2, 6 * 2 * sizeof(float));
SETTEX(shadow_texpos[6]);
elemcnt += 6;
}
if (!top && !right && xx < x1 - 1 && yy > 0 && (depth[((xx + 1)*gdimy + yy - 1)]) < d)
{
memcpy(shadowvert + elemcnt * 2, gvertexes + tile * 6 * 2, 6 * 2 * sizeof(float));
SETTEX(shadow_texpos[7]);
elemcnt += 6;
}
}
}
}
if (elemcnt)
{
glDisableClientState(GL_COLOR_ARRAY);
glColor4fv(shadowcolor);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//glBlendFunc(GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA);
glTexCoordPointer(2, GL_FLOAT, 0, shadowtex);
glVertexPointer(2, GL_FLOAT, 0, shadowvert);
glDrawArrays(GL_TRIANGLES, 0, elemcnt);
glEnableClientState(GL_COLOR_ARRAY);
}
}
glDisable(GL_SCISSOR_TEST);
glViewport(off_x, off_y, size_x, size_y);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, tdimx, tdimy, 0, -1, 1);
}
}
{
glVertexPointer(2, GL_FLOAT, 0, vertexes);
// Render background colors
glDisable(GL_TEXTURE_2D);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glEnable(GL_BLEND);
glColorPointer(4, GL_FLOAT, 0, bg);
glDrawArrays(GL_TRIANGLES, 0, tdimx*tdimy*6);
// Render foreground
glEnable(GL_TEXTURE_2D);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glTexCoordPointer(2, GL_FLOAT, 0, tex);
glColorPointer(4, GL_FLOAT, 0, fg);
glDrawArrays(GL_TRIANGLES, 0, tdimx*tdimy*6);
}
if (domapshot == 1)
{
int w = world->map.x_count * dispx;
int h = world->map.y_count * dispy;
unsigned char *data = (unsigned char *) malloc(w * h * 3);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
glReadPixels(dispx, dispy, w, h, GL_BGR, GL_UNSIGNED_BYTE, data);
#pragma pack(push,1)
typedef struct _TgaHeader
{
unsigned char IDLength; /* 00h Size of Image ID field */
unsigned char ColorMapType; /* 01h Color map type */
unsigned char ImageType; /* 02h Image type code */
unsigned short CMapStart; /* 03h Color map origin */
unsigned short CMapLength; /* 05h Color map length */
unsigned char CMapDepth; /* 07h Depth of color map entries */
unsigned short XOffset; /* 08h X origin of image */
unsigned short YOffset; /* 0Ah Y origin of image */
unsigned short Width; /* 0Ch Width of image */
unsigned short Height; /* 0Eh Height of image */
unsigned char PixelDepth; /* 10h Image pixel size */
unsigned char ImageDescriptor; /* 11h Image descriptor byte */
} TGAHEAD;
#pragma pop
TGAHEAD hdr;
memset(&hdr, 0, sizeof(hdr));
hdr.ImageType = 2;
hdr.Width = w;
hdr.Height = h;
hdr.PixelDepth = 24;
*out2 << w << " " << h << std::endl;
std::ofstream img("mapshot.tga", std::ofstream::binary);
img.write((const char *)&hdr, sizeof(hdr));
/* for (int j = 0; j<w*h*3; j++)
{
unsigned char c = data[j+0];
data[0] = data[j+2];
data[j+2] = c;
}*/
img.write((const char *)data, w * h * 3);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Delete the renderbuffer attachment
glDeleteRenderbuffers(1, &renderbuffer);
grid_resize(old_dimx, old_dimy);
*df::global::window_x = old_winx;
*df::global::window_y = old_winy;
gps->force_full_display_count = 1;
domapshot = 0;
}
}
int main (int argc, char **argv)
{
SADisplay *display;
VisVideo *video;
VisInput *input;
VisActor *actor;
VisEventQueue *localqueue;
VisVideoAttributeOptions *vidoptions;
int running = TRUE;
int fullscreen = FALSE;
int visible = TRUE;
int depth;
//visual_mem_alloc_install_vtable (visual_mem_alloc_vtable_profile ());
visual_init (&argc, &argv);
display = display_new (sdl_driver_new ());
/* Libvisual stuff */
if (argc > 1)
actor = visual_actor_new (argv[1]);
else
actor = visual_actor_new ("projectM");
if (argc > 3) {
depth = visual_video_depth_enum_from_value (atoi (argv[3]));
} else
depth = visual_video_depth_get_highest (visual_actor_get_supported_depth (actor));
vidoptions = visual_actor_get_video_attribute_options (actor);
display_create (display, depth, vidoptions, 480, 360, TRUE);
visual_actor_realize (actor);
video = display_get_video (display);
visual_actor_set_video (actor, video);
visual_actor_video_negotiate (actor, 0, FALSE, FALSE);
if (argc > 2)
input = visual_input_new (argv[2]);
else
input = visual_input_new ("alsa");
visual_input_realize (input);
localqueue = visual_event_queue_new ();
while (running) {
VisEventQueue *pluginqueue;
VisEvent *ev;
/* Handle all events */
display_drain_events (display, localqueue);
pluginqueue = visual_plugin_get_eventqueue (visual_actor_get_plugin (actor));
while (visual_event_queue_poll_by_reference (localqueue, &ev)) {
if (ev->type != VISUAL_EVENT_RESIZE)
visual_event_queue_add (pluginqueue, ev);
switch (ev->type) {
case VISUAL_EVENT_RESIZE:
video = display_get_video (display);
visual_actor_set_video (actor, video);
visual_actor_video_negotiate (actor, depth, FALSE, FALSE);
break;
case VISUAL_EVENT_MOUSEMOTION:
break;
case VISUAL_EVENT_MOUSEBUTTONDOWN:
break;
case VISUAL_EVENT_MOUSEBUTTONUP:
break;
case VISUAL_EVENT_KEYDOWN:
switch (ev->event.keyboard.keysym.sym) {
case VKEY_ESCAPE:
running = FALSE;
break;
case VKEY_TAB:
fullscreen = !fullscreen;
display_set_fullscreen (display, fullscreen, TRUE);
/* Resync video */
video = display_get_video (display);
visual_actor_set_video (actor, video);
visual_actor_video_negotiate (actor, depth, FALSE, FALSE);
break;
default:
printf ("key: %c\n", ev->event.keyboard.keysym.sym);
break;
}
break;
case VISUAL_EVENT_KEYUP:
break;
case VISUAL_EVENT_QUIT:
running = FALSE;
break;
case VISUAL_EVENT_VISIBILITY:
visible = ev->event.visibility.is_visible;
break;
default:
break;
}
}
if (visible == FALSE) {
visual_input_run (input);
visual_time_usleep (10000);
continue;
}
/* Do a run cycle */
visual_input_run (input);
display_lock (display);
visual_actor_run (actor, input->audio);
display_unlock (display);
display_update_all (display);
display_fps_limit (display, 30);
}
/* Termination procedure */
display_set_fullscreen (display, FALSE, TRUE);
display_close (display);
visual_quit ();
//visual_mem_alloc_profile ();
printf ("Total frames: %d, average fps: %f\n", display_fps_total (display), display_fps_average (display));
return 0;
}
ui_t *
ui_new(char *filename, jack_client_t *client)
{
int i;
ui_t *ui;
ui = (ui_t *)malloc(sizeof(ui_t));
if (!ui) {
return NULL;
}
ui->read = NULL;
ui->write = NULL;
ui->read_pos = NULL;
ui->display = display_new();
if (!ui->display) {
free(ui);
return NULL;
}
ui->pattern = 0;
ui->client = client;
ui->filename = NULL;
if (filename) {
ui->filename = strdup(filename);
}
for (i = 0; i < 8; i++) {
ui->patterns[i] = NULL;
}
ui->pseq.pos = 0;
ui->pseq.max_len = MAX_PSEQ;
ui->pseq.len = 1;
ui->yank.key = ui->display->y;
ui->yank.step = ui->display->x;
ui->yank.pattern = ui->pattern;
for (i = 0; i < MAX_PSEQ; i++) {
ui->pseq.patterns[i] = 0;
}
ui->bpm = BPM;
ui->len = LEN;
ui->swing = 0;
ui->quant = QUANT;
ui->steps = LEN * QUANT;
ui->oct = 4;
ui->ts = JackTransportStopped;
initscr();
noecho();
cbreak();
timeout(1000 / 25);
toggle_terminal(true);
keypad(stdscr, 1);
/* change delay time after ESC */
if (!getenv("ESCDELAY")) {
ESCDELAY = 25;
}
ui->commands = commands;
ui->history = NULL;
clear();
refresh();
return ui;
}
