eukara/ngunix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
ngunix/video/vid_gdk.c

1455 lines
39 KiB
C
Raw Blame History

/*
Copyright (C) 2015 Marco "eukara" Hladik
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
// vid_gdk.c -- general gdk video driver
#include <ctype.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <gdk/gdkx.h>
#include <gdk/gdkkeysyms.h>
#include "globaldef.h"
#include "d_local.h"
#include "../splash.xpm"
#include "../icon.xpm"
viddef_t vid;
unsigned short d_8to16table[256];
static int gdk_initialized = 0;
static int vid_frame[4];
static float mouse_x, mouse_y;
static float old_mouse_x, old_mouse_y;
static qboolean mouse_enabled;
cvar_t *m_filter;
extern int deathcam_yesiamdead;
extern vec3_t deathcam_angles;
static GtkWidget *x_win;
static GdkGC *x_gc;
static GdkRgbCmap *x_cmap = NULL;
static GdkDisplay *display = NULL;
static GdkScreen *screen = NULL;
static unsigned char *x_framebuffer = NULL;
static int verbose = 0;
static long X11_highhunkmark;
static long X11_buffersize;
static int vid_surfcachesize;
void *vid_surfcache;
static int vid_center_x, vid_center_y;
static int vid_mouseposx, vid_mouseposy;
void (*vid_menudrawfn) (void);
void (*vid_menukeyfn) (int key);
void VID_MenuKey(int key);
int config_notify=0;
int config_notify_width;
int config_notify_height;
qboolean vid_ineditor = false;
void VID_HandleDeath(int signal_num)
{
Sys_Error("[VIDEO] This death brought to you by the number %d\n", signal_num);
}
void VID_ResetFrameBuffer(void)
{
if (d_pzbuffer)
{
D_FlushCaches();
Hunk_FreeToHighMark(X11_highhunkmark);
d_pzbuffer = NULL;
}
X11_highhunkmark = Hunk_HighMark();
/* alloc an extra line in case we want to wrap, and allocate the z-buffer */
X11_buffersize = vid.width * vid.height * sizeof(*d_pzbuffer);
vid_surfcachesize = D_SurfaceCacheForRes(vid.width, vid.height);
X11_buffersize += vid_surfcachesize;
d_pzbuffer = Hunk_HighAllocName(X11_buffersize, "video");
if (d_pzbuffer == NULL)
Sys_Error ("[VIDEO] Not enough memory for video mode\n");
vid_surfcache = (byte *) d_pzbuffer + vid.width * vid.height * sizeof(*d_pzbuffer);
D_InitCaches(vid_surfcache, vid_surfcachesize);
if (x_framebuffer)
free(x_framebuffer);
x_framebuffer = malloc(vid.width * vid.height * 3);
if (!x_framebuffer)
Sys_Error("[VIDE] Failed to reset framebuffer!\n");
vid.buffer = (byte *) (x_framebuffer);
vid.conbuffer = vid.buffer;
}
void VID_Init(unsigned char *palette)
{
int pnum;
struct sigaction sa;
vid.width = 640;
vid.height = 480;
if ((pnum=COM_CheckParm("-winsize")))
{
if (pnum >= com_argc-2)
Sys_Error("[VIDEO] -winsize <width> <height>\n");
vid.width = Q_atoi(com_argv[pnum+1]);
vid.height = Q_atoi(com_argv[pnum+2]);
if (!vid.width || !vid.height)
Sys_Error("[VIDEO] Bad window width/height\n");
}
if ((pnum=COM_CheckParm("-width"))) {
if (pnum >= com_argc-1)
Sys_Error("[VIDEO] -width <width>\n");
vid.width = Q_atoi(com_argv[pnum+1]);
if (!vid.width)
Sys_Error("[VIDEO] Bad window width\n");
}
if ((pnum=COM_CheckParm("-height"))) {
if (pnum >= com_argc-1)
Sys_Error("[VIDEO] -height <height>\n");
vid.height = Q_atoi(com_argv[pnum+1]);
if (!vid.height)
Sys_Error("[VIDEO] Bad window height\n");
}
vid.maxwarpwidth = WARP_WIDTH;
vid.maxwarpheight = WARP_HEIGHT;
vid.maxlowwidth = LOW_WIDTH;
vid.maxlowheight = LOW_HEIGHT;
vid.numpages = 2;
vid.colormap = host_colormap;
vid.fullbright = 256 - LittleLong(*((int *) vid.colormap + 2048));
srandom(getpid());
verbose = COM_CheckParm("-verbose");
/* initialize GDK */
gtk_init(NULL, NULL);
gdk_rgb_init();
sigaction(SIGINT, 0, &sa);
sa.sa_handler = VID_HandleDeath;
sigaction(SIGINT, &sa, 0);
sigaction(SIGTERM, &sa, 0);
display = gdk_display_get_default ();
screen = gdk_display_get_default_screen (display);
/* create the main window */
x_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(x_win, "NGUNIX");
gtk_widget_set_size_request(x_win, vid.width, vid.height);
gtk_window_set_default_size(x_win, vid.width, vid.height);
gtk_window_set_position(x_win,GTK_WIN_POS_CENTER_ALWAYS);
g_signal_connect (x_win, "destroy", G_CALLBACK (exit), NULL);
gtk_widget_set_events(x_win, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
if ((pnum=COM_CheckParm("-noborder")))
gtk_window_set_decorated(x_win, FALSE);
gtk_widget_realize(x_win);
/* create the GC */
x_gc = gdk_gc_new(gtk_widget_get_window(x_win));
if (!x_gc)
Sys_Error("VID: Cannot make GC\n");
/* map the window */
gtk_widget_show_all(x_win);
VID_ResetFrameBuffer();
vid.rowbytes = vid.width;
vid.buffer = x_framebuffer;
vid.direct = 0;
vid.conbuffer = x_framebuffer;
vid.conrowbytes = vid.rowbytes;
vid.conwidth = vid.width;
vid.conheight = vid.height;
vid.aspect =
((float) vid.height / (float) vid.width) * (320.0 / 240.0);
mouse_enabled = false;
gdk_window_get_geometry (gtk_widget_get_window(x_win), &vid_frame[0], &vid_frame[1], &vid_frame[2], &vid_frame[3], NULL);
gdk_window_get_position(gtk_widget_get_window(x_win), &vid_frame[0], &vid_frame[1]);
vid_center_x = (int)(((float)vid_frame[2] / 2) + vid_frame[0]);
vid_center_y = (int)(((float)vid_frame[2] / 2) + vid_frame[1]);
vid_frame[2] += vid_frame[0];
vid_frame[3] += vid_frame[1];
gdk_initialized = 1;
}
void VID_ShiftPalette(unsigned char *p)
{
VID_SetPalette(p);
}
void VID_SetPalette(unsigned char *palette)
{
int i = 768;
unsigned char *ptr;
unsigned int colors[256];
if (x_cmap)
gdk_rgb_cmap_free(x_cmap);
ptr = palette;
for (i = 0; i < 256; i++) {
unsigned char r, g, b;
r = *ptr++;
g = *ptr++;
b = *ptr++;
colors[i] = r << 16 | g << 8 | b;
}
x_cmap = gdk_rgb_cmap_new(colors, 256);
}
void VID_Shutdown(void)
{
Con_Printf("[VIDEO] Shutting down...\n");
}
int IN_LateKey(int keysym)
{
int key = 0;
switch (keysym) {
case GDK_Page_Up:
key = K_PGUP;
break;
case GDK_Page_Down:
key = K_PGDN;
break;
case GDK_Home:
key = K_HOME;
break;
case GDK_End:
key = K_END;
break;
case GDK_Left:
key = K_LEFTARROW;
break;
case GDK_Right:
key = K_RIGHTARROW;
break;
case GDK_Down:
key = K_DOWNARROW;
break;
case GDK_Up:
key = K_UPARROW;
break;
case GDK_Escape:
key = K_ESCAPE;
break;
case GDK_Return:
case GDK_KEY_KP_Enter:
key = K_ENTER;
break;
case GDK_Tab:
key = K_TAB;
break;
case GDK_space:
key = K_SPACE;
break;
case GDK_F1:
key = K_F1;
break;
case GDK_F2:
key = K_F2;
break;
case GDK_F3:
key = K_F3;
break;
case GDK_F4:
key = K_F4;
break;
case GDK_F5:
key = K_F5;
break;
case GDK_F6:
key = K_F6;
break;
case GDK_F7:
key = K_F7;
break;
case GDK_F8:
key = K_F8;
break;
case GDK_F9:
key = K_F9;
break;
case GDK_F10:
key = K_F10;
break;
case GDK_F11:
key = K_F11;
break;
case GDK_F12:
key = K_F12;
break;
case GDK_BackSpace:
case GDK_Delete:
key = K_BACKSPACE;
break;
case GDK_Pause:
key = K_PAUSE;
break;
case GDK_Shift_L:
case GDK_Shift_R:
key = K_SHIFT;
break;
case GDK_Execute:
case GDK_Control_L:
case GDK_Control_R:
key = K_CTRL;
break;
case GDK_Alt_L:
case GDK_Meta_L:
case GDK_Alt_R:
case GDK_Meta_R:
key = K_ALT;
break;
case GDK_grave:
key = '`';
break;
case GDK_KEY_underscore:
key = '_';
break;
case GDK_KEY_KP_Multiply:
key = '*';
break;
case GDK_KEY_KP_Add:
key = '+';
break;
case GDK_KEY_KP_Subtract:
key = '-';
break;
case GDK_KEY_KP_Divide:
key = '/';
break;
case GDK_KEY_KP_Delete:
key = ',';
break;
case GDK_KEY_KP_0 :
key = '0';
break;
case GDK_KEY_KP_1 :
key = '1';
break;
case GDK_KEY_KP_2 :
key = '2';
break;
case GDK_KEY_KP_3 :
key = '3';
break;
case GDK_KEY_KP_4:
key = '4';
break;
case GDK_KEY_KP_5 :
key = '5';
break;
case GDK_KEY_KP_6 :
key = '6';
break;
case GDK_KEY_KP_7 :
key = '7';
break;
case GDK_KEY_KP_8 :
key = '8';
break;
case GDK_KEY_KP_9 :
key = '9';
break;
default:
if (keysym > GDK_space && keysym <= GDK_9)
key = keysym;
if (keysym >= GDK_A && keysym <= GDK_Z)
key = keysym - GDK_A + 'a';
if (keysym >= GDK_a && keysym <= GDK_z)
key = keysym - GDK_a + 'a';
break;
}
//printf("keysym: %x, key: %x\n", keysym, key);
return key;
}
struct {
int key;
int down;
} keyq[64];
int keyq_head = 0;
int keyq_tail = 0;
void VID_GetEvent(void)
{
int w, h;
GdkEvent *event;
event = gdk_event_get();
if (event)
switch (event->type) {
case GDK_KEY_PRESS:
keyq[keyq_head].key = IN_LateKey(event->key.keyval);
keyq[keyq_head].down = true;
keyq_head = (keyq_head + 1) & 63;
break;
case GDK_KEY_RELEASE:
keyq[keyq_head].key = IN_LateKey(event->key.keyval);
keyq[keyq_head].down = false;
keyq_head = (keyq_head + 1) & 63;
break;
case GDK_ENTER_NOTIFY:
break;
case GDK_LEAVE_NOTIFY:
if(mouse_enabled)
gdk_display_warp_pointer (display, screen, vid_center_x, vid_center_y);
else
IN_DeactivateMouse();
break;
case GDK_CONFIGURE:
gtk_window_get_size(GTK_WINDOW(x_win), &w, &h);
gdk_window_get_geometry (gtk_widget_get_window(x_win), &vid_frame[0], &vid_frame[1], &vid_frame[2], &vid_frame[3], NULL);
gdk_window_get_position(gtk_widget_get_window(x_win), &vid_frame[0], &vid_frame[1]);
vid_center_x = (int)(((float)vid_frame[2] / 2) + vid_frame[0]);
vid_center_y = (int)(((float)vid_frame[2] / 2) + vid_frame[1]);
vid_frame[2] += vid_frame[0];
vid_frame[3] += vid_frame[1];
config_notify_width = w;
config_notify_height = h;
config_notify = 1;
break;
case GDK_BUTTON_PRESS:
if(event->button.button == 1)
Key_Event (K_MOUSE1, true);
if(event->button.button == 3)
Key_Event (K_MOUSE2, true);
if(event->button.button == 2)
Key_Event (K_MOUSE3, true);
break;
case GDK_BUTTON_RELEASE:
if(event->button.button == 1)
Key_Event (K_MOUSE1, false);
if(event->button.button == 3)
Key_Event (K_MOUSE2, false);
if(event->button.button == 2)
Key_Event (K_MOUSE3, false);
break;
case GDK_SCROLL:
if(event->scroll.direction == GDK_SCROLL_UP)
{
Key_Event (K_MWHEELUP, true);
Key_Event (K_MWHEELUP, false);
}
if(event->scroll.direction == GDK_SCROLL_DOWN){
Key_Event (K_MWHEELDOWN, true);
Key_Event (K_MWHEELDOWN, false);
}
break;
break;
}
}
// flushes the given rectangles from the view buffer to the screen
void VID_Update(vrect_t * rects)
{
if (config_notify)
{
config_notify = 0;
vid.width = config_notify_width & ~7;
vid.height = config_notify_height;
VID_ResetFrameBuffer();
vid.rowbytes = vid.width;
vid.buffer = x_framebuffer;
vid.conbuffer = x_framebuffer;
vid.conrowbytes = vid.rowbytes;
vid.conwidth = vid.width;
vid.conheight = vid.height;
vid.recalc_refdef = 1;
Con_CheckResize();
return;
}
scr_fullupdate = 0;
while (rects) {
gdk_draw_indexed_image(gtk_widget_get_window(x_win),
x_gc, rects->x, rects->y, rects->width, rects->height, GDK_RGB_DITHER_NONE, x_framebuffer, vid.width, x_cmap);
rects = rects->pnext;
}
}
int Sys_OpenWindow(void)
{
return 0;
}
void Sys_EraseWindow(int window)
{
}
void Sys_DrawCircle(int window, int x, int y, int r)
{
}
void Sys_DisplayWindow(int window)
{
}
void Sys_SendKeyEvents(void)
{
if (!gdk_initialized)
return;
while (gdk_events_pending())
{
VID_GetEvent();
while (keyq_head != keyq_tail)
{
Key_Event(keyq[keyq_tail].key, keyq[keyq_tail].down);
keyq_tail = (keyq_tail + 1) & 63;
}
}
}
void D_BeginDirectRect(int x, int y, byte * pbitmap, int width, int height)
{
// direct drawing of the "accessing disk" icon isn't supported under Linux
}
void D_EndDirectRect(int x, int y, int width, int height)
{
// direct drawing of the "accessing disk" icon isn't supported under Linux
}
void VID_HandlePause (qboolean pause)
{
if (pause)
{
IN_DeactivateMouse ();
IN_ShowMouse ();
}
else
{
IN_ActivateMouse ();
IN_HideMouse ();
}
}
void IN_Move (usercmd_t *cmd)
{
vec3_t tangles; // eukara - deathcam
if (m_filter->value) {
mouse_x = (mouse_x + old_mouse_x) * 0.5;
mouse_y = (mouse_y + old_mouse_y) * 0.5;
}
if (mouse_enabled == true)
{
gdk_display_get_pointer (display, NULL, &vid_mouseposx, &vid_mouseposy, NULL);
mouse_x = (float)vid_mouseposx - vid_center_x;
mouse_y = (float)vid_mouseposy - vid_center_y;
old_mouse_x = mouse_x;
old_mouse_y = mouse_y;
mouse_x *= sensitivity->value;
mouse_y *= sensitivity->value;
}
if (deathcam_yesiamdead)
{
tangles[0] = deathcam_angles[0];
tangles[1] = deathcam_angles[1];
tangles[2] = deathcam_angles[2];
}
else
{
tangles[0] = cl.viewangles[0];
tangles[1] = cl.viewangles[1];
tangles[2] = cl.viewangles[2];
}
if ( (in_strafe.state & 1) || (lookstrafe->value && ((in_mlook.state & 1) ^ ((int)m_look->value & 1)) ))
cmd->sidemove += m_side->value * mouse_x;
else
tangles[YAW] -= m_yaw->value * mouse_x;
if ((in_mlook.state & 1) ^ ((int)m_look->value & 1))
V_StopPitchDrift ();
if ( ((in_mlook.state & 1) ^ ((int)m_look->value & 1)) && !(in_strafe.state & 1))
{
tangles[PITCH] += m_pitch->value * mouse_y;
if (!deathcam_yesiamdead)
{
if (tangles[PITCH] > m_lockdown->value)
tangles[PITCH] = m_lockdown->value;
if (tangles[PITCH] < m_lockup->value)
tangles[PITCH] = m_lockup->value;
}
}
else
{
if ((in_strafe.state & 1) && noclip_anglehack)
cmd->upmove -= m_forward->value * mouse_y;
else
cmd->forwardmove -= m_forward->value * mouse_y;
}
if (deathcam_yesiamdead)
{
deathcam_angles[0] = tangles[0];
deathcam_angles[1] = tangles[1];
deathcam_angles[2] = tangles[2];
}
else
{
cl.viewangles[0] = tangles[0];
cl.viewangles[1] = tangles[1];
cl.viewangles[2] = tangles[2];
}
if((mouse_x || mouse_y) && mouse_enabled)
gdk_display_warp_pointer (display, screen, vid_center_x, vid_center_y);
mouse_x = mouse_y = 0;
}
gboolean VID_KillSplash(gpointer data){
gtk_widget_destroy((GtkWidget*)data);
gtk_main_quit ();
return(FALSE);
}
void VID_CreateSplash()
{
GdkBitmap *splash_mask;
GdkPixmap *splash_image;
GtkWidget *x_splash, *x_splash_image;
GdkPixbuf *icon_image;
gtk_init(NULL, NULL);
icon_image = gdk_pixbuf_new_from_xpm_data(icon_xpm);
gtk_window_set_default_icon (icon_image);
x_splash = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (x_splash, 440, 116);
gtk_window_set_decorated(x_splash, FALSE);
gtk_window_set_position(x_splash,GTK_WIN_POS_CENTER_ALWAYS);
gtk_window_set_resizable(x_splash, FALSE);
gtk_widget_realize(x_splash);
splash_image = gdk_pixmap_create_from_xpm_d(x_splash->window, &splash_mask, NULL, (gchar **)splash_xpm );
x_splash_image = gtk_image_new_from_pixmap(splash_image, splash_mask);
gtk_container_add(GTK_CONTAINER(x_splash), x_splash_image);
gtk_widget_show_all (x_splash);
g_timeout_add (1000, VID_KillSplash, x_splash);
gtk_main ();
}
void IN_Init_Cvars()
{
m_filter = Cvar_Get ("m_filter", "0", CVAR_ARCHIVE|CVAR_ORIGINAL);
}
/*
* Mouse related functions
* that have nothing todo with aiming or pushing buttons
*/
void IN_DeactivateMouse (void)
{
mouse_enabled = false;
gdk_pointer_ungrab (GDK_CURRENT_TIME);
}
void IN_ActivateMouse (void)
{
mouse_enabled = true;
gdk_pointer_grab(gtk_widget_get_window(x_win), TRUE, (GdkEventMask)(GDK_BUTTON_PRESS_MASK ), (GdkWindow *)NULL, NULL, GDK_CURRENT_TIME);
}
void IN_HideMouse (void)
{
GdkCursor* cursor_blank = gdk_cursor_new(GDK_BLANK_CURSOR);
gdk_window_set_cursor(gtk_widget_get_window(x_win), cursor_blank);
}
void IN_ShowMouse (void)
{
GdkCursor* cursor_arrow = gdk_cursor_new(GDK_ARROW);
gdk_window_set_cursor(gtk_widget_get_window(x_win), cursor_arrow);
}
/*
* NGUNIX EDITOR GUFF
* ==================
* Most engines don't come with an integrated toolset.
* We are not one of those guys.
*/
GtkWidget *ed_window;
GdkGC *ed_pic;
GdkGC *ed_palpic;
qpic_t *ed_file;
qpic_t *ed_palfile;
GtkWidget *ed_menubar;
GdkRgbCmap *ed_cmap = NULL;
unsigned char *ed_palette;
/* EDITOR: PALETTE SWITCHER
* ========================
* TODO: This somehow affects the main engine despite us using our own GdkColmap...
*/
gint VID_EditorLoadPalette(gpointer data)
{
int i;
GtkWidget *dialog;
GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
gint res;
loadedfile_t *palfile;
unsigned int colors[256];
dialog = gtk_file_chooser_dialog_new ("NGUNIXEd - Open Palette (.lmp) File",
NULL,
action,
("_Cancel"),
GTK_RESPONSE_CANCEL,
("_Open"),
GTK_RESPONSE_ACCEPT,
NULL);
// Set the dialog and the default path (current directory)
GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
char path[MAX_OSPATH];
sprintf(path, "file://%s", get_current_dir_name());
gtk_file_chooser_set_current_folder_uri(chooser, path);
// Add the filter for .lmp files
GtkFileFilter *filter = gtk_file_filter_new ();
gtk_file_filter_add_pattern (filter, "*.lmp");
gtk_file_chooser_set_filter (chooser, filter);
res = gtk_dialog_run (GTK_DIALOG (dialog));
if (res == GTK_RESPONSE_ACCEPT)
{
char *filename;
filename = gtk_file_chooser_get_filename (chooser);
palfile = COM_LoadFile (filename, 2);
if(palfile)
{
Con_Printf("[EDITOR] Switching palette to %s\n", filename);
for(i=0; i < 16*16*3; i++)
ed_palette[i] = palfile->data[i];
if (ed_cmap)
gdk_rgb_cmap_free(ed_cmap);
for (i = 0; i < 256; i++)
{
unsigned char r, g, b;
r = *ed_palette++;
g = *ed_palette++;
b = *ed_palette++;
colors[i] = r << 16 | g << 8 | b;
}
ed_cmap = gdk_rgb_cmap_new(colors, 256);
}
g_free (filename);
}
gtk_widget_destroy (dialog);
return 0;
}
/* EDITOR: COLORMAP VIEWER
* =======================
* Colormaps differ from lump files in the way that they don't start with a width | height header
* Otherwise they are identical in how they refer to palette indexes for their color
*/
gint VID_EditorViewColormap(gpointer data)
{
int i;
GtkWidget *dialog;
GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
gint res;
loadedfile_t *pic;
dialog = gtk_file_chooser_dialog_new ("NGUNIXEd - Open Colormap (.lmp) File",
NULL,
action,
("_Cancel"),
GTK_RESPONSE_CANCEL,
("_Open"),
GTK_RESPONSE_ACCEPT,
NULL);
// Set the dialog and the default path (current directory)
GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
char path[MAX_OSPATH];
sprintf(path, "file://%s", get_current_dir_name());
gtk_file_chooser_set_current_folder_uri(chooser, path);
// Add the filter for .lmp files
GtkFileFilter *filter = gtk_file_filter_new ();
gtk_file_filter_add_pattern (filter, "*.lmp");
gtk_file_chooser_set_filter (chooser, filter);
res = gtk_dialog_run (GTK_DIALOG (dialog));
if (res == GTK_RESPONSE_ACCEPT)
{
char *filename;
filename = gtk_file_chooser_get_filename (chooser);
pic = COM_LoadFile (filename, 2);
if(pic)
{
Con_Printf("[EDITOR] Previewing Colormap %s\n", filename);
ed_file = malloc(16385 + (sizeof(int) * 2));
ed_file->width = 256;
ed_file->height = 64;
for(i = 0; i < 256 * 64; i++)
ed_file->data[i] = pic->data[i];
gtk_window_resize(ed_window, ed_file->width + ed_palfile->width, ed_file->height + ed_menubar->allocation.height);
}
g_free (filename);
}
gtk_widget_destroy (dialog);
return 0;
}
/* EDITOR: GENERATE COLORMAP
* ===============
* Generate a colormap for the current palette...
* makes use of our builtin function for generating them
*/
gint VID_EditorGenerateColormap(gpointer data)
{
GtkWidget *dialog;
GtkFileChooser *chooser;
GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
gint res;
byte *pic;
dialog = gtk_file_chooser_dialog_new ("NGUNIXEd - Save Generated Colormap (.lmp) File",
NULL,
action,
("_Cancel"),
GTK_RESPONSE_CANCEL,
("_Save"),
GTK_RESPONSE_ACCEPT,
NULL);
chooser = GTK_FILE_CHOOSER (dialog);
gtk_file_chooser_set_do_overwrite_confirmation (chooser, TRUE);
// Set the default path (current directory)
char path[MAX_OSPATH];
sprintf(path, "file://%s", get_current_dir_name());
gtk_file_chooser_set_current_folder_uri(chooser, path);
// Add the filter for .lmp files
GtkFileFilter *filter = gtk_file_filter_new ();
gtk_file_filter_add_pattern (filter, "*.lmp");
gtk_file_chooser_set_filter (chooser, filter);
res = gtk_dialog_run (GTK_DIALOG (dialog));
if (res == GTK_RESPONSE_ACCEPT)
{
char *filename;
filename = gtk_file_chooser_get_filename (chooser);
unsigned char out_colormap[16384];
Con_Printf("[EDITOR] Generating colormap based on current palette...\n");
Colormap_Generate(ed_palette, out_colormap);
COM_WriteFile (filename, out_colormap, 16384);
g_free (filename);
}
gtk_widget_destroy (dialog);
return 0;
}
/* EDITOR: SAVE LUMP
* =================
* Saves the pic currently displayed as a lump...
* This means that you can save special files, such as colormaps as regular piclumps, too!
*/
gint VID_EditorSaveFile(gpointer data)
{
GtkWidget *dialog;
GtkFileChooser *chooser;
GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
gint res;
if(!ed_file)
return;
dialog = gtk_file_chooser_dialog_new ("NGUNIXEd - Save LUMP (.lmp) File",
NULL,
action,
("_Cancel"),
GTK_RESPONSE_CANCEL,
("_Save"),
GTK_RESPONSE_ACCEPT,
NULL);
chooser = GTK_FILE_CHOOSER (dialog);
gtk_file_chooser_set_do_overwrite_confirmation (chooser, TRUE);
// Set the default path (current directory)
char path[MAX_OSPATH];
sprintf(path, "file://%s", get_current_dir_name());
gtk_file_chooser_set_current_folder_uri(chooser, path);
// Add the filter for .lmp files
GtkFileFilter *filter = gtk_file_filter_new ();
gtk_file_filter_add_pattern (filter, "*.lmp");
gtk_file_chooser_set_filter (chooser, filter);
//if (user_edited_a_new_document)
gtk_file_chooser_set_current_name (chooser,
("untitled.lmp"));
//else
// gtk_file_chooser_set_filename (chooser,
// existing_filename);
res = gtk_dialog_run (GTK_DIALOG (dialog));
if (res == GTK_RESPONSE_ACCEPT)
{
char *filename;
filename = gtk_file_chooser_get_filename (chooser);
Con_Printf("[EDITOR] Saving LUMP as %s...\n", filename);
#if 0
printf("Saving IMAGE: %i, %i\n", pic[0], pic[1]);
for(i = 2; i < pic[0] * pic[1]+2; i++)
printf("%i,", pic[i]);
printf("\n...DONE\n");
#endif
COM_WriteFile (filename, ed_file, ed_file->width * ed_file->height + 2);
g_free (filename);
// free(pic);
}
gtk_widget_destroy (dialog);
return 0;
}
/* EDITOR: LOAD LUMP
* =================
* Loads a lump into the editor as a pic...
* There is nothing more to it, really
*/
gint VID_EditorLoadFile(gpointer data)
{
GtkWidget *dialog;
GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
gint res;
loadedfile_t *pic;
dialog = gtk_file_chooser_dialog_new ("NGUNIXEd - Open LUMP (.lmp) File",
NULL,
action,
("_Cancel"),
GTK_RESPONSE_CANCEL,
("_Open"),
GTK_RESPONSE_ACCEPT,
NULL);
// Set the dialog and the default path (current directory)
GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
char path[MAX_OSPATH];
sprintf(path, "file://%s", get_current_dir_name());
gtk_file_chooser_set_current_folder_uri(chooser, path);
// Add the filter for .lmp files
GtkFileFilter *filter = gtk_file_filter_new ();
gtk_file_filter_add_pattern (filter, "*.lmp");
gtk_file_chooser_set_filter (chooser, filter);
res = gtk_dialog_run (GTK_DIALOG (dialog));
if (res == GTK_RESPONSE_ACCEPT)
{
char *filename;
filename = gtk_file_chooser_get_filename (chooser);
pic = COM_LoadFile (filename, 2);
if(pic)
{
Con_Printf("[EDITOR] Loading LUMP at %s...\n", filename);
ed_file = (qpic_t *)pic->data;
gtk_window_resize(ed_window, ed_file->width + ed_palfile->width, ed_file->height + ed_menubar->allocation.height);
}
#if 0
int i;
printf("Loading IMAGE: %i, %i\n", ed_file->width, ed_file->height);
for(i = 0; i < ed_file->width * ed_file->height; i++)
printf("%i,", ed_file->data[i]);
printf("\n...DONE\n");
#endif
g_free (filename);
}
gtk_widget_destroy (dialog);
return 0;
}
/* EDITOR: CREATE LUMP
* ===================
* Creates a lump based on width*height chosen by the user
* The default pixel color is 255 - which is transparent in-engine
*/
GtkWidget *ed_newwindow;
GtkWidget *ed_widthbox;
GtkWidget *ed_heightbox;
gint VID_EditorCreatePic(gpointer data)
{
int i;
int mem;
mem = (size_t)((sizeof(int) * 2) + (gtk_spin_button_get_value_as_int (ed_widthbox) * gtk_spin_button_get_value_as_int (ed_heightbox)));
//mem = 262152;
Con_Printf("[EDITOR] Creating new %ix%i LUMP\n", gtk_spin_button_get_value_as_int (ed_widthbox), gtk_spin_button_get_value_as_int (ed_heightbox));
ed_file = Hunk_Alloc((size_t)mem);
ed_file->width = gtk_spin_button_get_value_as_int (ed_widthbox);
ed_file->height = gtk_spin_button_get_value_as_int (ed_heightbox);
for(i=0; i < (ed_file->width * ed_file->height); i++)
ed_file->data[i] = 255;
gtk_window_resize(ed_window, ed_file->width + ed_palfile->width, ed_file->height + ed_menubar->allocation.height);
gtk_widget_destroy(ed_newwindow);
}
gint VID_EditorNewFile(gpointer data)
{
GtkWidget *table;
GtkWidget *label1;
GtkWidget *label2;
ed_newwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(ed_newwindow), GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(ed_newwindow), "New LMP");
gtk_container_set_border_width(GTK_CONTAINER(ed_newwindow), 10);
table = gtk_table_new(3, 2, FALSE);
gtk_container_add(GTK_CONTAINER(ed_newwindow), table);
label1 = gtk_label_new("Width");
label2 = gtk_label_new("Height");
gtk_table_attach(GTK_TABLE(table), label1, 0, 1, 0, 1, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
gtk_table_attach(GTK_TABLE(table), label2, 0, 1, 1, 2, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
ed_widthbox = gtk_spin_button_new_with_range (1, 512, 1);
ed_heightbox = gtk_spin_button_new_with_range (1, 512, 1);
gtk_table_attach(GTK_TABLE(table), ed_widthbox, 1, 2, 0, 1, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
gtk_table_attach(GTK_TABLE(table), ed_heightbox, 1, 2, 1, 2, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
GtkWidget *btnok = gtk_button_new_with_label("Create");
gtk_table_attach(GTK_TABLE(table), btnok, 1, 2, 2, 3, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
gtk_widget_show_all(ed_newwindow);
g_signal_connect(ed_newwindow, "destroy", G_CALLBACK(gtk_widget_destroy), NULL);
g_signal_connect(btnok, "clicked", G_CALLBACK(VID_EditorCreatePic), G_OBJECT(ed_newwindow));
}
/* EDITOR: LOAD PCX
* ================
* Loads a PCX into the editor as a pic...
*/
gint VID_EditorImportFile(gpointer data)
{
GtkWidget *dialog;
GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
gint res;
loadedfile_t *pic;
dialog = gtk_file_chooser_dialog_new ("NGUNIXEd - Picture Exchange (.pcx) File",
NULL,
action,
("_Cancel"),
GTK_RESPONSE_CANCEL,
("_Open"),
GTK_RESPONSE_ACCEPT,
NULL);
// Set the dialog and the default path (current directory)
GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
char path[MAX_OSPATH];
sprintf(path, "file://%s", get_current_dir_name());
gtk_file_chooser_set_current_folder_uri(chooser, path);
// Add the filter for .lmp files
GtkFileFilter *filter = gtk_file_filter_new ();
gtk_file_filter_add_pattern (filter, "*.pcx");
gtk_file_chooser_set_filter (chooser, filter);
res = gtk_dialog_run (GTK_DIALOG (dialog));
if (res == GTK_RESPONSE_ACCEPT)
{
char *filename;
byte *temp;
filename = gtk_file_chooser_get_filename (chooser);
pic = COM_LoadFile (filename, 2);
if (pic)
{
int pic_width, pic_height;
Con_Printf("[EDITOR] Importing PCX at %s...\n", filename);
byte *pic_data = Hunk_Alloc(pic->filelen);
pic_data = Image_ReadPCXFile(pic->data, pic->filelen, &pic_width, &pic_height, ed_palette);
if(pic_data == NULL)
{
g_free(filename);
gtk_widget_destroy (dialog);
return 0;
}
ed_file = Hunk_Alloc((sizeof(int) * 2) + (pic_width * pic_height));
ed_file->width = pic_width;
ed_file->height = pic_height;
int i;
for(i = 0; i < pic_width * pic_height; i++)
ed_file->data[i] = pic_data[i];
gtk_window_resize(ed_window, ed_file->width + ed_palfile->width, ed_file->height + ed_menubar->allocation.height);
}
g_free (filename);
}
gtk_widget_destroy (dialog);
return 0;
}
/* EDITOR: EXPORT LUMP
* ===================
* Saves the pic currently displayed as a PCX file...
*/
gint VID_EditorExportFile(gpointer data)
{
GtkWidget *dialog;
GtkFileChooser *chooser;
GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
gint res;
byte *pic;
if(!ed_file)
return;
dialog = gtk_file_chooser_dialog_new ("NGUNIXEd - Save Picture Exchange (.pcx) File",
NULL,
action,
("_Cancel"),
GTK_RESPONSE_CANCEL,
("_Save"),
GTK_RESPONSE_ACCEPT,
NULL);
chooser = GTK_FILE_CHOOSER (dialog);
gtk_file_chooser_set_do_overwrite_confirmation (chooser, TRUE);
// Set the default path (current directory)
char path[MAX_OSPATH];
sprintf(path, "file://%s", get_current_dir_name());
gtk_file_chooser_set_current_folder_uri(chooser, path);
// Add the filter for .lmp files
GtkFileFilter *filter = gtk_file_filter_new ();
gtk_file_filter_add_pattern (filter, "*.pcx");
gtk_file_chooser_set_filter (chooser, filter);
//if (user_edited_a_new_document)
gtk_file_chooser_set_current_name (chooser,
("untitled.pcx"));
//else
// gtk_file_chooser_set_filename (chooser,
// existing_filename);
res = gtk_dialog_run (GTK_DIALOG (dialog));
if (res == GTK_RESPONSE_ACCEPT)
{
char *filename;
filename = gtk_file_chooser_get_filename (chooser);
Con_Printf("[EDITOR] Exporting PCX to %s...\n", filename);
int w, h;
w = ed_file->width;
h = ed_file->height;
pic = Hunk_Alloc(ed_file->width * ed_file->height);
memcpy(pic, &ed_file->data, (ed_file->width * ed_file->height));
#if 0
int i;
printf("Exporting IMAGE: %i, %i\n", ed_file->width, ed_file->height);
for(i = 0; i < ed_file->width * ed_file->height; i++)
printf("%i,", ed_file->data[i]);
printf("\n...DONE\n");
#endif
Image_WritePCXfile (filename, pic, w, h, ed_file->width, host_basepal);
g_free (filename);
}
gtk_widget_destroy (dialog);
return 0;
}
/* EDITOR: DRAWTILE
* ============
* Draw a tiling backg into the engine window
*/
qpic_t *ed_backtile;
void VID_EditorDrawTile(void)
{
ed_backtile = malloc(vid.width * vid.height + (2 * sizeof(int)));
ed_backtile->width = vid.width;
ed_backtile->height = vid.height;
int rgb[3];
rgb[0] = 107;
rgb[1] = 107;
rgb[2] = 151;
int color = Convert_24_to_8(host_basepal, rgb);
int i, j;
for(i = 0; i < vid.width * vid.height; i++)
ed_backtile->data[i] = 0;
for(i = 0; i < vid.height; i++)
{
for(j = 0; j < vid.width; j++)
ed_backtile->data[i*vid.width + j] = color;
i += 16;
}
for(i = 0; i < vid.width; i++)
{
for(j = 0; j < vid.height; j++)
ed_backtile->data[j * vid.width + i] = color;
i += 16;
}
}
/* EDITOR: QUIT
* ============
* Kills the editor, unloads any pics, etc.
*/
gint VID_EditorQuit(gpointer data)
{
if(vid_ineditor == true)
{
Con_Printf("[EDITOR] Shutting down\n");
gtk_widget_destroy(ed_window);
vid_ineditor = false;
gtk_main_quit();
}
}
/* EDITOR: UPDATE
* ==============
* Called every once in a while to update the picture inside the window...
*/
int ed_tilecol = 0;
gint VID_EditorUpdate(gpointer data)
{
/*if(ed_tilecol >= 255-16)
ed_tilecol = 0;
int i, j;
for(i = 0; i < vid.height; i++)
{
for(j = 0; j < vid.width; j++)
ed_backtile->data[i * vid.width + j] = ed_tilecol;
i += 16;
}
for(i = 0; i < vid.width; i++)
{
for(j = 0; j < vid.height; j++)
ed_backtile->data[j * vid.width + i] = ed_tilecol;
i += 16;
}
ed_tilecol++;
*/
gdk_draw_indexed_image(gtk_widget_get_window(x_win), x_gc, 0, 0, ed_backtile->width, ed_backtile->height, GDK_RGB_DITHER_NONE, ed_backtile->data, ed_backtile->width, x_cmap);
if(ed_file)
{
gdk_draw_indexed_image(gtk_widget_get_window(ed_window), ed_pic, 0, ed_menubar->allocation.height, ed_file->width, ed_file->height, GDK_RGB_DITHER_NONE, ed_file->data, ed_file->width, ed_cmap);
gdk_draw_indexed_image(gtk_widget_get_window(ed_window), ed_pic, ed_file->width, ed_menubar->allocation.height, ed_palfile->width, ed_palfile->height, GDK_RGB_DITHER_NONE, ed_palfile->data, ed_palfile->width, ed_cmap);
return 1;
}
gdk_draw_indexed_image(gtk_widget_get_window(ed_window), ed_pic, 0, ed_menubar->allocation.height, ed_palfile->width, ed_palfile->height, GDK_RGB_DITHER_NONE, ed_palfile->data, ed_palfile->width, ed_cmap);
return 1;
}
/* EDITOR: MAIN FUNCTION
* =====================
* This is the first function called when calling the editor.
* Here we get functions to Create, Load and Save LUMPS, as well as
* play with palettes and generate colormaps.
*
* TODO: Import/Export of PCX files
*/
void VID_LaunchEditor(void)
{
GtkWidget *vbox;
GtkWidget *fileMenu;
GtkWidget *extraMenu;
unsigned int ed_colors[256];
ed_palfile = malloc(256+8);
ed_palette = malloc(16*16*3);
memcpy(&ed_palette, &host_basepal, sizeof(16*16*3));
int i;
for (i = 0; i < 256; i++)
{
unsigned char r, g, b;
r = *ed_palette++;
g = *ed_palette++;
b = *ed_palette++;
ed_colors[i] = r << 16 | g << 8 | b;
ed_palfile->data[i] = i;
}
ed_cmap = gdk_rgb_cmap_new(ed_colors, 256);
ed_palfile = Image_Resize(ed_palfile->data, 16, 16, 64, 64);
VID_EditorDrawTile();
ed_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(ed_window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(ed_window), 300, 200);
gtk_window_set_title(GTK_WINDOW(ed_window), "NGUNIXEd - 2D Lump Editor");
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(ed_window), vbox);
ed_menubar = gtk_menu_bar_new();
fileMenu = gtk_menu_new();
extraMenu = gtk_menu_new();
GtkWidget *fileMi = gtk_menu_item_new_with_label("File");
GtkWidget *newMi = gtk_menu_item_new_with_label("New");
GtkWidget *loadMi = gtk_menu_item_new_with_label("Load...");
GtkWidget *saveMi = gtk_menu_item_new_with_label("Save...");
GtkWidget *importMi = gtk_menu_item_new_with_label("Import...");
GtkWidget *exportMi = gtk_menu_item_new_with_label("Export...");
//GtkWidget *quitMi = gtk_menu_item_new_with_label("Quit");
GtkWidget *extrMi = gtk_menu_item_new_with_label("Extra");
GtkWidget *swipalMi = gtk_menu_item_new_with_label("Switch Palette...");
GtkWidget *viewcolmapMi = gtk_menu_item_new_with_label("View Colormap...");
GtkWidget *gencolmapMi = gtk_menu_item_new_with_label("Generate Colormap...");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(fileMi), fileMenu);
gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), newMi);
gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), loadMi);
gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), saveMi);
gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), importMi);
gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), exportMi);
//gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), quitMi);
gtk_menu_shell_append(GTK_MENU_SHELL(ed_menubar), fileMi);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(extrMi), extraMenu);
gtk_menu_shell_append(GTK_MENU_SHELL(extraMenu), swipalMi);
gtk_menu_shell_append(GTK_MENU_SHELL(extraMenu), viewcolmapMi);
gtk_menu_shell_append(GTK_MENU_SHELL(extraMenu), gencolmapMi);
gtk_menu_shell_append(GTK_MENU_SHELL(ed_menubar), extrMi);
gtk_box_pack_start(GTK_BOX(vbox), ed_menubar, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(ed_window), "destroy", G_CALLBACK(VID_EditorQuit), NULL);
g_signal_connect(G_OBJECT(newMi), "activate", G_CALLBACK(VID_EditorNewFile), NULL);
g_signal_connect(G_OBJECT(loadMi), "activate", G_CALLBACK(VID_EditorLoadFile), NULL);
g_signal_connect(G_OBJECT(saveMi), "activate", G_CALLBACK(VID_EditorSaveFile), NULL);
g_signal_connect(G_OBJECT(importMi), "activate", G_CALLBACK(VID_EditorImportFile), NULL);
g_signal_connect(G_OBJECT(exportMi), "activate", G_CALLBACK(VID_EditorExportFile), NULL);
//g_signal_connect(G_OBJECT(quitMi), "activate", G_CALLBACK(VID_EditorQuit), NULL);
g_signal_connect(G_OBJECT(swipalMi), "activate", G_CALLBACK(VID_EditorLoadPalette), NULL);
g_signal_connect(G_OBJECT(viewcolmapMi), "activate", G_CALLBACK(VID_EditorViewColormap), NULL);
g_signal_connect(G_OBJECT(gencolmapMi), "activate", G_CALLBACK(VID_EditorGenerateColormap), NULL);
gtk_timeout_add(100, VID_EditorUpdate, NULL);
gtk_widget_realize(ed_window);
gtk_widget_realize(ed_menubar);
ed_pic = gdk_gc_new(gtk_widget_get_window(ed_window));
gtk_widget_show_all(ed_window);
Con_Printf("[EDITOR] Initialized\n");
vid_ineditor = true;
gtk_main();
};
void VID_Init_Cmds(void)
{
Cmd_AddCommand ("editor", VID_LaunchEditor);
}
// Commdand graveyard TODO: Get rid of this
void IN_Init(void){}
void IN_Shutdown(void){}
void IN_Commands(void){}
Reference in a new issue View git blame Copy permalink