+
+#if defined(TARGET_X11)
+
/* 2000-08-10T18:03:54Z
*
* open X11 display and sound
*/
+#if 1
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <X11/Xos.h>
+#include <X11/Intrinsic.h>
+#include <X11/keysymdef.h>
+#endif
+
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#include <errno.h>
#include "../libgame/platform.h"
+#include "../libgame/libgame.h"
#include "global.h"
#include "display.h"
#include "sample.h"
+#if 0
Display *display;
Window xwindow;
+#endif
+
+#if 1
+Bitmap *objBitmap;
+Bitmap *botBitmap;
+Bitmap *sprBitmap;
+Bitmap *ttlBitmap;
+#endif
+
+#if 1
+Bitmap *screenBitmap;
+Bitmap *scoreBitmap;
+#endif
Pixmap screenPixmap;
Pixmap scorePixmap;
static unsigned long screenBlackPixel;
static unsigned long screenWhitePixel;
+#if 0
static XSizeHints sizeHints;
static XSetWindowAttributes setWindowAttributes;
static XWMHints wmHints;
static XVisualInfo visualInfo;
+#endif
static XGCValues gcValues;
static Colormap privateColourmap;
static int gotRed;
static int gotWhite;
+#if 1
+static Bitmap *pcxBitmaps[4];
+static Bitmap *pcxBitmapsX2[4];
+#endif
+
+#if 0
static Pixmap xpmPixmaps[4];
static Pixmap xpmBitmaps[4];
static XpmAttributes xpmAttributes[4];
static int xpmGot[4];
+#endif
static int xpmAllocColourFunc(Display *, Colormap, char *, XColor *, void *);
static int xpmFreeColoursFunc(Display *, Colormap, unsigned long *, int, void *);
static KeyCode keycodes[16];
+#if 0
static const char *xpmNames[4] = { "object.xpm", "score.xpm", "sprite.xpm", "title.xpm" };
+#endif
+
+#if 1
+static const char *pcxNames[4] = { "object.pcx", "score.pcx", "sprite.pcx", "title.pcx" };
+#endif
+
static const int xpmCloseness[4] = { 10000, 10000, 40000, 50000 };
static const KeySym keysyms[16] = {
XK_Up, XK_KP_Up, XK_r, /* north */
100
};
+static void xdebug(char *msg)
+{
+#if 1
+ XSync(display, False);
+ printf("EM DEBUG: %s\n", msg);
+#endif
+}
+
int open_all(void)
{
char name[MAXNAME+2];
+#if 0
void *dummyptr;
int dummyint;
+#endif
int i;
+#if 0
display = XOpenDisplay(arg_display);
if(display == 0) {
fprintf(stderr, "%s: \"%s\": %s: %s\n", progname, XDisplayName(arg_display), "failed to open display", strerror(errno));
return(1);
}
+#endif
defaultScreen = DefaultScreenOfDisplay(display);
defaultVisual = DefaultVisualOfScreen(defaultScreen);
screenBlackPixel = BlackPixelOfScreen(defaultScreen);
screenWhitePixel = WhitePixelOfScreen(defaultScreen);
+#if 0
if(arg_install) {
visualInfo.visualid = XVisualIDFromVisual(defaultVisual);
dummyptr = XGetVisualInfo(display, VisualIDMask, &visualInfo, &dummyint);
if(cursor) XDefineCursor(display, xwindow, cursor);
XMapWindow(display, xwindow);
+#endif
+#if 0
for(i = 0; i < 4; i++) {
name[MAXNAME] = 0;
if(arg_basedir) {
}
xpmGot[i] = 1;
}
+#endif
+ for(i = 0; i < 4; i++)
+ {
+ name[MAXNAME] = 0;
+ snprintf(name, MAXNAME+2, "%s/%s", EM_GFX_DIR, pcxNames[i]);
+
+ if (name[MAXNAME])
+ snprintf_overflow("read graphics/ files");
+
+ if ((pcxBitmaps[i] = LoadImage(name)) == NULL)
+ {
+ printf("::: LoadImage() failed for file '%s'\n", name);
+ return 1;
+ }
+ }
+
+ objBitmap = pcxBitmaps[0];
+ botBitmap = pcxBitmaps[1];
+ sprBitmap = pcxBitmaps[2];
+ ttlBitmap = pcxBitmaps[3];
+
+#if 0
objPixmap = xpmPixmaps[0];
botPixmap = xpmPixmaps[1];
sprPixmap = xpmPixmaps[2];
botmaskBitmap = xpmBitmaps[1];
sprmaskBitmap = xpmBitmaps[2];
ttlmaskBitmap = xpmBitmaps[3];
+#else
+ objPixmap = pcxBitmaps[0]->drawable;
+ botPixmap = pcxBitmaps[1]->drawable;
+ sprPixmap = pcxBitmaps[2]->drawable;
+ ttlPixmap = pcxBitmaps[3]->drawable;
+ objmaskBitmap = pcxBitmaps[0]->clip_mask;
+ botmaskBitmap = pcxBitmaps[1]->clip_mask;
+ sprmaskBitmap = pcxBitmaps[2]->clip_mask;
+ ttlmaskBitmap = pcxBitmaps[3]->clip_mask;
+#endif
+
+#if 1
+ for (i = 0; i < 4; i++)
+ {
+ Pixmap clip_mask;
+
+ if ((clip_mask = XCreatePixmap(display, window->drawable,
+ pcxBitmaps[i]->width * 2,
+ pcxBitmaps[i]->height * 2, 1))
+ == None)
+ {
+ printf("::: cannot create clip mask");
+ return 1;
+ }
+
+#if 0
+ {
+ XGCValues clip_gc_values;
+ unsigned long clip_gc_valuemask;
+ GC gc;
+
+ clip_gc_values.graphics_exposures = False;
+ clip_gc_valuemask = GCGraphicsExposures;
+ if ((gc = XCreateGC(display, clip_mask,
+ clip_gc_valuemask, &clip_gc_values)) == None)
+ {
+ printf("X CreateGC failed\n");
+ exit(1);
+ }
+
+ XFillRectangle(display, clip_mask, gc, 0, 0,
+ pcxBitmaps[i]->width * 2,
+ pcxBitmaps[i]->height * 2);
+ }
+#endif
+
+#if 0
+ {
+ byte * src_ptr;
+ int src_width = pcxBitmaps[i]->width;
+ int src_height = pcxBitmaps[i]->height;
+
+#if 0
+ printf("::: %d, %d [%ld -> %ld (%ld)]\n",
+ src_width, src_height,
+ src_ptr,
+ src_ptr + src_width * src_height * 1,
+ src_width * src_height * 1);
+#endif
+
+#if 0
+ for (i = src_ptr; i < src_ptr + src_width * src_height * 1; i++)
+ {
+ byte x = *(byte *)i;
+
+ x = x * 1;
+ }
+#endif
+ }
+#endif
+
+ pcxBitmapsX2[i] = ZoomBitmap(pcxBitmaps[i],
+ pcxBitmaps[i]->width * 2,
+ pcxBitmaps[i]->height * 2);
+
+#if 1
+
+#if 0
+ printf("::: CREATING NEW CLIPMASKS ...\n");
+#endif
+#if 1
+ clip_mask = Pixmap_to_Mask(pcxBitmapsX2[i]->drawable,
+ pcxBitmapsX2[i]->width,
+ pcxBitmapsX2[i]->height);
+#endif
+#if 0
+ printf("::: CREATING NEW CLIPMASKS DONE\n");
+#endif
+
+ pcxBitmapsX2[i]->clip_mask = clip_mask;
+
+#if 0
+ printf("::: %ld, %ld, %ld, %ld, %ld, %ld, %ld\n",
+ pcxBitmaps[i]->gc,
+ pcxBitmaps[i]->clip_mask, pcxBitmapsX2[i]->clip_mask,
+ pcxBitmaps[i]->width, pcxBitmaps[i]->height,
+ pcxBitmapsX2[i]->width, pcxBitmapsX2[i]->height);
+#endif
+
+#if 0
+ ZoomPixmap(display, pcxBitmaps[i]->gc,
+ pcxBitmaps[i]->clip_mask, pcxBitmapsX2[i]->clip_mask,
+ pcxBitmaps[i]->width, pcxBitmaps[i]->height,
+ pcxBitmapsX2[i]->width, pcxBitmapsX2[i]->height);
+#endif
+
+#endif
+ }
+
+ objBitmap = pcxBitmapsX2[0];
+ botBitmap = pcxBitmapsX2[1];
+ sprBitmap = pcxBitmapsX2[2];
+ ttlBitmap = pcxBitmapsX2[3];
+
+ objPixmap = pcxBitmapsX2[0]->drawable;
+ botPixmap = pcxBitmapsX2[1]->drawable;
+ sprPixmap = pcxBitmapsX2[2]->drawable;
+ ttlPixmap = pcxBitmapsX2[3]->drawable;
+#if 1
+ objmaskBitmap = pcxBitmapsX2[0]->clip_mask;
+ botmaskBitmap = pcxBitmapsX2[1]->clip_mask;
+ sprmaskBitmap = pcxBitmapsX2[2]->clip_mask;
+ ttlmaskBitmap = pcxBitmapsX2[3]->clip_mask;
+#endif
+#endif
+
+#if 1
+ screenBitmap = CreateBitmap(22 * TILEX, 14 * TILEY, DEFAULT_DEPTH);
+ scoreBitmap = CreateBitmap(20 * TILEX, SCOREY, DEFAULT_DEPTH);
+#endif
screenPixmap = XCreatePixmap(display, xwindow, 22 * TILEX, 14 * TILEY, screenDepth);
if(screenPixmap == 0) {
for(i = 0; i < 3; i++) fireKeyCode[i] = keycodes[i + 12];
for(i = 0; i < 1; i++) escKeyCode[i] = keycodes[i + 15];
+ /* ----------------------------------------------------------------- */
+
+#if 0
+ {
+ Bitmap *bm = pcxBitmaps[2];
+ Pixmap clip_mask = bm->clip_mask;
+
+ if (clip_mask)
+ {
+#if 1
+ int width = bm->width;
+ int height = bm->height;
+#else
+ int width = 16 * 4;
+ int height = 16 * 4;
+#endif
+ XImage *src_ximage = XGetImage(display, clip_mask, 0, 0,
+ width, height, AllPlanes, ZPixmap);
+ XImage *dst_ximage = XGetImage(display, xwindow, 0, 0,
+ width, height, AllPlanes, ZPixmap);
+ int x, y;
+
+ if (src_ximage == NULL)
+ {
+ printf("src_ximage failed\n");
+ exit(1);
+ }
+
+ if (dst_ximage == NULL)
+ {
+ printf("dst_ximage failed\n");
+ exit(1);
+ }
+
+ printf("::: DISPLAY CLIP MASK ...\n");
+
+ for (x=0; x<width; x++)
+ {
+ for (y=0; y<height; y++)
+ {
+ unsigned long pixel = XGetPixel(src_ximage, x, y);
+
+ if (pixel != BlackPixel(display, screen))
+ pixel = WhitePixel(display, screen);
+
+ XPutPixel(dst_ximage, x, y, pixel);
+ }
+ }
+
+ printf("::: DISPLAY CLIP MASK NOW\n");
+
+ XPutImage(display, xwindow, screenGC, dst_ximage, 0, 0,
+ 0, 13 * TILEY, width, height);
+
+ printf("::: DISPLAY CLIP MASK DONE\n");
+ }
+ }
+#endif
+
+ /* ----------------------------------------------------------------- */
+
+#if 0
+ {
+ int ii = 2;
+
+ XGCValues clip_gc_values;
+ unsigned long clip_gc_valuemask;
+
+#if 1
+ GC gc = screenGC;
+#else
+#if 1
+ GC gc = pcxBitmaps[ii]->stored_clip_gc;
+#else
+ GC gc = pcxBitmaps[ii]->gc;
+#endif
+#endif
+ Pixmap src_pixmap = pcxBitmaps[ii]->clip_mask;
+ Pixmap dst_pixmap = pcxBitmapsX2[ii]->clip_mask;
+ int src_width = pcxBitmaps[ii]->width;
+ int src_height = pcxBitmaps[ii]->height;
+ int dst_width = pcxBitmapsX2[ii]->width;
+ int dst_height = pcxBitmapsX2[ii]->height;
+
+ XImage *src_ximage, *dst_ximage;
+ byte *src_ptr, *dst_ptr;
+ int bits_per_pixel;
+ int bytes_per_pixel;
+ int x, y, xx, yy, i;
+#if 1
+ boolean scale_down = (src_width > dst_width);
+ int zoom_factor;
+#else
+ int zoom_factor = src_width / dst_width; /* currently very limited! */
+#endif
+ int row_skip, col_skip;
+
+ printf("::: %d\n", scale_down);
+
+ xdebug("::: ZOOM STEP 1");
+
+ clip_gc_values.graphics_exposures = False;
+ clip_gc_valuemask = GCGraphicsExposures;
+ if ((gc = XCreateGC(display, pcxBitmaps[ii]->clip_mask,
+ clip_gc_valuemask, &clip_gc_values)) == None)
+ {
+ printf("XCreateGC failed\n");
+ exit(1);
+ }
+
+ xdebug("::: ZOOM STEP 2");
+
+ if (scale_down)
+ {
+ zoom_factor = src_width / dst_width;
+
+ /* adjust source image size to integer multiple of destination size */
+ src_width = dst_width * zoom_factor;
+ src_height = dst_height * zoom_factor;
+ }
+ else
+ {
+ zoom_factor = dst_width / src_width;
+
+ /* no adjustment needed when scaling up (some pixels may be left blank) */
+ }
+
+ /* copy source pixmap to temporary image */
+ if ((src_ximage = XGetImage(display, src_pixmap, 0, 0, src_width, src_height,
+ AllPlanes, ZPixmap)) == NULL)
+ Error(ERR_EXIT, "ZoomPixmap(): XGetImage() failed");
+
+ bits_per_pixel = src_ximage->bits_per_pixel;
+ bytes_per_pixel = (bits_per_pixel + 7) / 8;
+
+ printf("::: bits_per_pixel == %d\n", bits_per_pixel);
+
+ if ((dst_ximage = XCreateImage(display, visual, src_ximage->depth, ZPixmap,
+ 0, NULL, dst_width, dst_height,
+ 8, dst_width * bytes_per_pixel)) == NULL)
+ Error(ERR_EXIT, "ZoomPixmap(): XCreateImage() failed");
+
+ dst_ximage->data =
+ checked_malloc(dst_width * dst_height * bytes_per_pixel);
+ dst_ximage->byte_order = src_ximage->byte_order;
+
+ src_ptr = (byte *)src_ximage->data;
+ dst_ptr = (byte *)dst_ximage->data;
+
+ if (scale_down)
+ {
+ col_skip = (zoom_factor - 1) * bytes_per_pixel;
+ row_skip = col_skip * src_width;
+
+ /* scale image down by scaling factor 'zoom_factor' */
+ for (y = 0; y < src_height; y += zoom_factor, src_ptr += row_skip)
+ for (x = 0; x < src_width; x += zoom_factor, src_ptr += col_skip)
+ for (i = 0; i < bytes_per_pixel; i++)
+ *dst_ptr++ = *src_ptr++;
+ }
+ else
+ {
+ row_skip = src_width * bytes_per_pixel;
+
+#if 1
+ printf("::: %d, %d -> %d, %d [%d / %d]\n[%ld -> %ld (%ld)] [%ld -> %ld (%ld)]\n",
+ src_width, src_height,
+ dst_width, dst_height,
+ zoom_factor, bytes_per_pixel,
+ src_ptr,
+ src_ptr + src_width * src_height * bytes_per_pixel,
+ src_width * src_height * bytes_per_pixel,
+ dst_ptr,
+ dst_ptr + dst_width * dst_height * bytes_per_pixel,
+ dst_width * dst_height * bytes_per_pixel);
+#endif
+
+#if 0
+ printf("A\n");
+
+ for (i = 0; i < src_width * src_height * bytes_per_pixel;
+ i++)
+ {
+ byte x = *(byte *)(src_ptr + i);
+
+ printf("::: %d ...\n", i);
+
+ x = x * 1;
+ }
+
+ printf("B\n");
+#endif
+
+ /* scale image up by scaling factor 'zoom_factor' */
+ for (y = 0; y < src_height; y++)
+ {
+ for (yy = 0; yy < zoom_factor; yy++)
+ {
+ if (yy > 0)
+ src_ptr -= row_skip;
+
+#if 0
+ printf("::: [%d -> %ld / %ld]\n", y, src_ptr, dst_ptr);
+#endif
+
+ for (x = 0; x < src_width; x++)
+ {
+ for (xx = 0; xx < zoom_factor; xx++)
+ for (i = 0; i < bytes_per_pixel; i++)
+#if 1
+ {
+#if 0
+ printf("::: %d\n", *(src_ptr + i));
+#endif
+
+ *dst_ptr++ = *(src_ptr + i);
+ }
+#else
+ *dst_ptr++ = 0;
+#endif
+
+ src_ptr += i;
+ }
+ }
+ }
+ }
+
+ xdebug("::: ZOOM STEP 9");
+
+ /* copy scaled image to destination pixmap */
+ XPutImage(display, dst_pixmap, gc, dst_ximage, 0, 0, 0, 0,
+ dst_width, dst_height);
+
+ /* free temporary images */
+ X11DestroyImage(src_ximage);
+ X11DestroyImage(dst_ximage);
+
+
+ xdebug("::: ZOOM DONE");
+
+ }
+#endif
+
+ /* ----------------------------------------------------------------- */
+
+#if 0
+ {
+ Bitmap *bm = pcxBitmapsX2[2];
+ Pixmap clip_mask = bm->clip_mask;
+
+ if (clip_mask)
+ {
+#if 0
+ int width = bm->width;
+ int height = bm->height;
+#else
+ int width = 16 * 4;
+ int height = 16 * 4;
+#endif
+ XImage *src_ximage = XGetImage(display, clip_mask, 0, 0,
+ width, height, AllPlanes, ZPixmap);
+ XImage *dst_ximage = XGetImage(display, xwindow, 0, 0,
+ width, height, AllPlanes, ZPixmap);
+ int x, y;
+
+ if (src_ximage == NULL)
+ {
+ printf("src_ximage failed\n");
+ exit(1);
+ }
+
+ if (dst_ximage == NULL)
+ {
+ printf("dst_ximage failed\n");
+ exit(1);
+ }
+
+ printf("::: DISPLAY CLIP MASK ...\n");
+
+ for (x=0; x<width; x++)
+ {
+ for (y=0; y<height; y++)
+ {
+ unsigned long pixel = XGetPixel(src_ximage, x, y);
+
+ if (pixel != BlackPixel(display, screen))
+ pixel = WhitePixel(display, screen);
+
+ XPutPixel(dst_ximage, x, y, pixel);
+ }
+ }
+
+ printf("::: DISPLAY CLIP MASK NOW\n");
+
+ XPutImage(display, xwindow, screenGC, dst_ximage, 0, 0,
+ 0, 13 * TILEY + height, width, height);
+
+ printf("::: DISPLAY CLIP MASK DONE\n");
+ }
+ }
+#endif
+
+ /* ----------------------------------------------------------------- */
+
+#if 0
+ {
+ XImage *dst_ximage;
+
+ printf("::: GET IMAGE ...\n");
+
+ dst_ximage = XGetImage(display, xwindow, 0, 0,
+ 16, 16, AllPlanes, ZPixmap);
+ if (dst_ximage == NULL)
+ {
+ printf("dst_ximage failed\n");
+ exit(1);
+ }
+
+ printf("::: PUT IMAGE ...\n");
+
+ XPutImage(display, xwindow, screenGC, dst_ximage, 0, 0,
+ 0, 13 * TILEY, 10, 10);
+
+ printf("::: PUT IMAGE DONE\n");
+ }
+#endif
+
+ /* ----------------------------------------------------------------- */
+
#if defined(PLATFORM_LINUX) || defined(PLATFORM_BSD)
if(arg_silence == 0) {
for(i = 0; i < SAMPLE_MAX; i++) {
if(sound_pipe[1] != -1) close(sound_pipe[1]);
for(i = 0; i < SAMPLE_MAX; i++) if(sound_data[i]) free(sound_data[i]);
+#if 0
for(i = 0; i < 4; i++) if(xpmPixmaps[i]) XFreePixmap(display, xpmPixmaps[i]);
for(i = 0; i < 4; i++) if(xpmBitmaps[i]) XFreePixmap(display, xpmBitmaps[i]);
for(i = 0; i < 4; i++) if(xpmGot[i]) {
xpmFreeColoursFunc(display, xpmAttributes[i].colormap, xpmAttributes[i].alloc_pixels, xpmAttributes[i].nalloc_pixels, 0);
XpmFreeAttributes(&xpmAttributes[i]);
}
+#endif
+
if(gotRed) xpmFreeColoursFunc(display, privateColourmap ? privateColourmap : defaultColourmap, &redColour.pixel, 1, 0);
if(gotWhite) xpmFreeColoursFunc(display, privateColourmap ? privateColourmap : defaultColourmap, &whiteColour.pixel, 1, 0);
+
if(screenGC) XFreeGC(display, screenGC);
if(scoreGC) XFreeGC(display, scoreGC);
if(spriteGC) XFreeGC(display, spriteGC);
if(colourmap != privateColourmap) XFreeColors(display, colourmap, pixels, npixels, 0);
return(1); /* non-zero for success */
}
+
+#endif
projects / rocksndiamonds.git / blobdiff