honey

xdraw.c (5888B)

---

 #include <math.h>
 #include <stdio.h>
 
 #include <sys/ipc.h>
 #include <sys/shm.h>
 
 #include <xcb/xcb.h>
 #include <xcb/shm.h>
 #include <xcb/xcb_image.h>
 
 #include "xdraw.h"
 #include "common.h"
 
 extern uint8_t running;
 
 //window vars
 uint8_t WindowResize = 0;
 uint16_t WWidth = XREZ;
 uint16_t WHeight = YREZ;
 uint16_t RWidth = XREZ;
 uint16_t RHeight = YREZ;
 
 //xcb vars
 xcb_connection_t *c;
 xcb_screen_t *screen;
 xcb_drawable_t win;
 xcb_gcontext_t gc;
 xcb_colormap_t colormap;
 
 //shm vars
 xcb_shm_segment_info_t shinfo;
 uint32_t* bb;
 xcb_pixmap_t bbpix;
 
 
 //the color palette buffer
 xcb_alloc_color_reply_t *colors[256];
 
 //for detecting when the window's closed
 xcb_intern_atom_reply_t *delete_reply;
 
 void InitWindow()
 {
 	if (!XREZ || !YREZ)
 	{
 		running = 0;
 	}
 
 	c = xcb_connect (NULL, NULL);
 	
 	screen = xcb_setup_roots_iterator(xcb_get_setup(c)).data;
 
 	//create window
 	win = xcb_generate_id(c);
 	uint32_t mask = XCB_CW_BACK_PIXEL | 
 			XCB_CW_EVENT_MASK;  
 	uint32_t winvals[2];
 	winvals[0] = 	screen->black_pixel;
 	winvals[1] = 	XCB_EVENT_MASK_EXPOSURE | 
 			XCB_EVENT_MASK_KEY_PRESS |
 			XCB_EVENT_MASK_STRUCTURE_NOTIFY |
 			XCB_EVENT_MASK_POINTER_MOTION |
 			XCB_EVENT_MASK_BUTTON_MOTION |
 			XCB_EVENT_MASK_BUTTON_2_MOTION;
 	xcb_create_window (	c,
 						XCB_COPY_FROM_PARENT,
 						win,
 						screen->root,
 						0, 0,
 						150, 150,
 						10,
 						XCB_WINDOW_CLASS_INPUT_OUTPUT,
 						screen->root_visual,
 						mask, winvals );
 	gc = xcb_generate_id(c);
 
 	//create graphics context
 	mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
 	uint32_t gcvals[2];
 	gcvals[0] =	screen->white_pixel;
 	gcvals[1] =	0;
 	xcb_create_gc (	c,
 					gc,
 					win,
 					mask,
 					gcvals );
 					
 	colormap = screen->default_colormap;
 
 	for (int i = 0; i < 256; i++)
 	{
 		colors[i] = NULL;
 	}
 
 	//set up to detect when the window is closed
 	xcb_intern_atom_cookie_t protocol_cookie = 
 		xcb_intern_atom(c, 1, 12, "WM_PROTOCOLS");
 	xcb_intern_atom_reply_t *protocol_reply =
 		xcb_intern_atom_reply(c, protocol_cookie, 0);
 	xcb_intern_atom_cookie_t delete_cookie =
 		xcb_intern_atom(c, 0, 16, "WM_DELETE_WINDOW");
 	delete_reply = xcb_intern_atom_reply( c, delete_cookie, 0);
 	xcb_change_property (	c,
 							XCB_PROP_MODE_REPLACE,
 							win,
 							(*protocol_reply).atom,
 							4, 32, 1,
 							&(*delete_reply).atom	);
 	free(protocol_reply);
 
 
 	xcb_map_window(c, win);
 
 	//Shm stuff
 	xcb_shm_query_version_reply_t* shreply;
 
 	shreply = xcb_shm_query_version_reply(	c,
 											xcb_shm_query_version(c),
 											NULL	);
 
 	if(!shreply || !shreply->shared_pixmaps)
 	{
 		printf("Shm error\n");
 		running = 0;
 	}
 
 	shinfo.shmid = shmget(	IPC_PRIVATE, 
 							1920*1080*4, //todo: change to screen size
 							IPC_CREAT | 0600	);
 	shinfo.shmaddr = shmat(shinfo.shmid, 0, 0);
 	shinfo.shmseg = xcb_generate_id(c);
 	xcb_shm_attach(c, shinfo.shmseg, shinfo.shmid, 0);
 	shmctl(shinfo.shmid, IPC_RMID, 0);
 	bb = (uint32_t*)shinfo.shmaddr;
 
 
 	bbpix = xcb_generate_id(c);
 	xcb_shm_create_pixmap	(	c, bbpix, win,
 								1920, 1080,
 								screen->root_depth,
 								shinfo.shmseg, 0	);
 	xcb_flush(c);
 }
 
 void LoadPalette(uint32_t *pal)
 {
 	for (int i = 0; i < 256; ++i)
 	{
 		if (colors[i])
 		{
 			free(colors[i]);
 		}
 		uint32_t col = *(pal + i);
 		int blue = (col & 0xff) * 257;
 		int green = ((col >> 8) & 0xff) * 257;
 		int red = ((col >> 16) & 0xff) * 257;
 		xcb_alloc_color_cookie_t coogie = xcb_alloc_color (	c,
 															colormap,
 															red,
 															green,
 															blue	);
 		colors[i] = xcb_alloc_color_reply(c, coogie, NULL);
 	}	
 }
 
 //Update the width and height of the actual drawing area
 void UpdateRScreen()
 {
 	//preserve aspect ratio
 	float ratio;
 
 	ratio = (float)XREZ / (float)YREZ;
 
 	if ((WWidth)  > (WHeight * ratio))
 	{
 		RHeight = WHeight;
 		RWidth = (uint16_t)(RHeight * ratio);
 	}
 	else
 	{
 		RWidth = WWidth;
 		RHeight = (uint16_t)(RWidth / ratio);
 	}
 }
 
 void DrawPixel(uint16_t x, uint16_t y, uint8_t color)
 {
 	if (color)
 	{
 		bb[y * 1920 + x] = colors[color]->pixel;
 	}
 }
 
 //Draw to the screen
 void DrawBuffer(uint8_t* buf)
 {
 	UpdateRScreen();
 
 	double xratio = XREZ / (double)RWidth;
 	double yratio = YREZ / (double)RHeight;
 	double px, py;
 	for (int i = 0; i < RHeight; i++)
 	{
 		for (int j = 0; j < RWidth; j++)
 		{
 			uint8_t color;
 			px = floor(j * xratio);
 			py = floor(i * yratio);
 			color = *(buf + (uint32_t)((py * XREZ) + px));
 			//draw to backbuffer
 			DrawPixel(j, i, color);
 		}
 	}
 	xcb_copy_area	(	c, bbpix, win, gc,
 						0, 0, 0, 0,
 						RWidth, RHeight	);
 	xcb_flush(c);
 }
 
 void HandleEvents()
 {
 	xcb_generic_event_t *e;
 	xcb_configure_notify_event_t *confevent;
 	xcb_motion_notify_event_t *motionevent;
 	WindowResize = 0;
 	e = xcb_poll_for_event(c);
 	if (e)
 	{
 		switch(e->response_type & ~0x80)
 		{
 			//close
 			case XCB_CLIENT_MESSAGE:
 				if ((*(xcb_client_message_event_t*)e).data.data32[0]
 					== (*delete_reply).atom)
 				{
 					running = 0;
 					free(delete_reply);
 				}
 				break;
 			//TODO: Pause rendering while the window is resizing?
 			case XCB_CONFIGURE_NOTIFY:
 				confevent = (xcb_configure_notify_event_t*)e;
 				if ( 	(	(confevent->width > 0) && 
 							(WWidth != confevent->width) ) ||
 						(	(confevent->height > 0) &&
 							(WHeight !=	confevent->height) ) )
 				{
 					WindowResize = 1;
 					WWidth = confevent->width;
 					WHeight = confevent->height;
 				}
 				break;
 			case XCB_MOTION_NOTIFY:
 				motionevent = (xcb_motion_notify_event_t*)e;
 				uint32_t x, y;
 				x = (uint32_t)motionevent->event_x;
 				y = (uint32_t)motionevent->event_y;
 				UpdateCursor(x, y);
 				if ( motionevent->state & XCB_BUTTON_MASK_2 )
 				{
 					Mouse2Pressed();
 				}
 				break;
 		}
 	}
 	free(e);
 
 }
 
 void Cleanup()
 {
 	for (int i = 0; i < 256; ++i)
 	{
 		free(colors[i]);
 	}
 	xcb_shm_detach(c, shinfo.shmseg);
 	shmdt(shinfo.shmaddr);
 	
 	xcb_free_pixmap(c, bbpix);
 
 	xcb_destroy_window(c, win);
 	xcb_disconnect(c);
 }