sergiotarxz/nuttx-apps
sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Run some .c files throut nuttx/tools/indents.sh

Browse Source
This commit is contained in:
Gregory Nutt 2016-11-10 12:21:47 -06:00
parent 85ba39f596
commit 8db489ed8c
42 changed files with 968 additions and 862 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
graphics/traveler/tools/libwld/wld_addplane.c
View File

@ -52,32 +52,32 @@
* This function adds a plane to a world plane list * This function adds a plane to a world plane list
************************************************************************/ ************************************************************************/
void wld_add_plane(rect_list_t *newRect, rect_head_t *list) void wld_add_plane(rect_list_t * newRect, rect_head_t * list)
{ {
rect_list_t *nextRect, *prevRect; rect_list_t *nextRect, *prevRect;
/* Search the list to find the location to insert the new rectangle. /* Search the list to find the location to insert the new rectangle. Each
* Each is list is maintained in ascending plane order. * list is maintained in ascending plane order.
*/ */
for (nextRect = list->head; for (nextRect = list->head;
((nextRect) && (nextRect->d.plane < newRect->d.plane)); ((nextRect) && (nextRect->d.plane < newRect->d.plane));
nextRect = nextRect->flink); nextRect = nextRect->flink);
/* Add the newRect to the spot found in the list. Check if the newRect /* Add the newRect to the spot found in the list. Check if the newRect goes
* goes at the end of the list. * at the end of the list.
*/ */
if (!nextRect) if (!nextRect)
{ {
/* No rectangle with plane larger than the one to be added was /* No rectangle with plane larger than the one to be added was found in
* found in the list. The newRect goes at the end of the list. * the list. The newRect goes at the end of the list.
*/ */
prevRect = list->tail; prevRect = list->tail;
if (!prevRect) if (!prevRect)
{ {
/* Special case: The list is empty */ /* Special case: The list is empty */
newRect->flink = NULL; newRect->flink = NULL;
newRect->blink = NULL; newRect->blink = NULL;
@ -99,7 +99,7 @@ void wld_add_plane(rect_list_t *newRect, rect_head_t *list)
prevRect = nextRect->blink; prevRect = nextRect->blink;
if (!prevRect) if (!prevRect)
{ {
/* Special case: Insert at the head of the list */ /* Special case: Insert at the head of the list */
newRect->flink = nextRect; newRect->flink = nextRect;
newRect->blink = NULL; newRect->blink = NULL;

6
graphics/traveler/tools/libwld/wld_bitmaps.c
View File

@ -50,9 +50,9 @@
* bitmaps * bitmaps
*/ */
wld_bitmap_t *evenBitmaps[MAX_BITMAPS]; wld_bitmap_t *g_even_bitmaps[MAX_BITMAPS];
#ifndef WEDIT #ifndef WEDIT
wld_bitmap_t *oddBitmaps[MAX_BITMAPS]; wld_bitmap_t *g_odd_bitmaps[MAX_BITMAPS];
#endif #endif
/* This is the palette to use for the selected world */ /* This is the palette to use for the selected world */
@ -63,7 +63,7 @@ RGBColor worldPalette[256];
/* This is the maximum value + 1 of a texture code. */ /* This is the maximum value + 1 of a texture code. */
uint16_t numBitmaps; uint16_t g_nbitmaps;
/* These are the colors from the worldPalette which should used to rend /* These are the colors from the worldPalette which should used to rend
* the sky and ground * the sky and ground

6
graphics/traveler/tools/libwld/wld_bitmaps.h
View File

@ -101,9 +101,9 @@ typedef struct
* bitmaps * bitmaps
*/ */
extern wld_bitmap_t *evenBitmaps[MAX_BITMAPS]; extern wld_bitmap_t *g_even_bitmaps[MAX_BITMAPS];
#ifndef WEDIT #ifndef WEDIT
extern wld_bitmap_t *oddBitmaps[MAX_BITMAPS]; extern wld_bitmap_t *g_odd_bitmaps[MAX_BITMAPS];
#endif #endif
/* This is the palette to use for the selected world */ /* This is the palette to use for the selected world */
@ -114,7 +114,7 @@ extern RGBColor worldPalette[256];
/* This is the maximum value + 1 of a texture code */ /* This is the maximum value + 1 of a texture code */
extern uint16_t numBitmaps; extern uint16_t g_nbitmaps;
/* These are the colors from the worldPalette which should used to rend /* These are the colors from the worldPalette which should used to rend
* the sky and ground * the sky and ground

96
graphics/traveler/tools/libwld/wld_createworld.c
View File

@ -126,43 +126,50 @@ static uint8_t wld_manage_worldfile(INIHANDLE handle)
/* Read the initial camera/player position */ /* Read the initial camera/player position */
result = wld_read_shortint(handle, &g_initial_camera.x, result = wld_read_shortint(handle, &g_initial_camera.x,
g_camera_section_name, g_camera_section_name, g_camera_initialx_name);
g_camera_initialx_name);
if (result != 0) if (result != 0)
return result; {
return result;
}
result = wld_read_shortint(handle, &g_initial_camera.y, result = wld_read_shortint(handle, &g_initial_camera.y,
g_camera_section_name, g_camera_section_name, g_camera_initialy_name);
g_camera_initialy_name);
if (result != 0) if (result != 0)
return result; {
return result;
}
result = wld_read_shortint(handle, &g_initial_camera.z, result = wld_read_shortint(handle, &g_initial_camera.z,
g_camera_section_name, g_camera_section_name, g_camera_initialz_name);
g_camera_initialz_name);
if (result != 0) if (result != 0)
return result; {
return result;
}
/* Get the player's yaw/pitch orientation */ /* Get the player's yaw/pitch orientation */
result = wld_read_shortint(handle, &g_initial_camera.yaw, result = wld_read_shortint(handle, &g_initial_camera.yaw,
g_camera_section_name, g_camera_section_name, g_camera_initialyaw_name);
g_camera_initialyaw_name);
if (result != 0) if (result != 0)
return result; {
return result;
}
result = wld_read_shortint(handle, &g_initial_camera.pitch, result = wld_read_shortint(handle, &g_initial_camera.pitch,
g_camera_section_name, g_camera_initialpitch_name); g_camera_section_name, g_camera_initialpitch_name);
if (result != 0) if (result != 0)
return result; {
return result;
}
/* Get the height of the player */ /* Get the height of the player */
result = wld_read_shortint(handle, &playerHeight, result = wld_read_shortint(handle, &playerHeight,
g_player_section_name, g_player_section_name, g_player_height_name);
g_player_height_name);
if (result != 0) if (result != 0)
return result; {
return result;
}
/* Read the player's capability to step on top of things in the world. */ /* Read the player's capability to step on top of things in the world. */
@ -170,33 +177,45 @@ static uint8_t wld_manage_worldfile(INIHANDLE handle)
g_player_section_name, g_player_section_name,
g_player_walk_stepheight_name); g_player_walk_stepheight_name);
if (result != 0) if (result != 0)
return result; {
return result;
}
result = wld_read_shortint(handle, &runStepHeight, result = wld_read_shortint(handle, &runStepHeight,
g_player_section_name, g_player_section_name,
g_player_run_stepheight_name); g_player_run_stepheight_name);
if (result != 0) if (result != 0)
return result; {
return result;
}
/* Get the name of the file containing the world map */ /* Get the name of the file containing the world map */
result = wld_read_filename(handle, &filename, result = wld_read_filename(handle, &filename,
g_world_section_name, g_world_section_name, g_wold_map_name);
g_wold_map_name);
if (result != 0) if (result != 0)
return result; {
return result;
}
if (filename == NULL) if (filename == NULL)
return WORLD_PLANE_FILE_NAME_ERROR; {
return WORLD_PLANE_FILE_NAME_ERROR;
}
/* Allocate and load the world */ /* Allocate and load the world */
result = wld_initialize_planes(); result = wld_initialize_planes();
if (result != 0) if (result != 0)
return result; {
return result;
}
result = wld_load_planefile(filename); result = wld_load_planefile(filename);
if (result != 0) if (result != 0)
return result; {
return result;
}
inifile_free_string(filename); inifile_free_string(filename);
@ -206,15 +225,22 @@ static uint8_t wld_manage_worldfile(INIHANDLE handle)
result = wld_read_filename(handle, &filename, g_world_section_name, result = wld_read_filename(handle, &filename, g_world_section_name,
g_world_palette_name); g_world_palette_name);
if (result != 0) if (result != 0)
return result; {
return result;
}
if (filename == NULL) if (filename == NULL)
return WORLD_PALR_FILE_NAME_ERROR; {
return WORLD_PALR_FILE_NAME_ERROR;
}
/* Then load it into g_pal_table. */ /* Then load it into g_pal_table. */
result = wld_load_paltable(filename); result = wld_load_paltable(filename);
if (result != 0) if (result != 0)
return result; {
return result;
}
inifile_free_string(filename); inifile_free_string(filename);
@ -223,9 +249,14 @@ static uint8_t wld_manage_worldfile(INIHANDLE handle)
result = wld_read_filename(handle, &filename, g_world_section_name, result = wld_read_filename(handle, &filename, g_world_section_name,
g_world_images_name); g_world_images_name);
if (result != 0) if (result != 0)
return result; {
return result;
}
if (filename == NULL) if (filename == NULL)
return WORLD_BITMAP_FILE_NAME_ERROR; {
return WORLD_BITMAP_FILE_NAME_ERROR;
}
/* Create the RGB lookup table */ /* Create the RGB lookup table */
@ -235,7 +266,9 @@ static uint8_t wld_manage_worldfile(INIHANDLE handle)
result = wld_initialize_bitmaps(); result = wld_initialize_bitmaps();
if (result != 0) if (result != 0)
return result; {
return result;
}
result = wld_load_bitmapfile(filename); result = wld_load_bitmapfile(filename);
inifile_free_string(filename); inifile_free_string(filename);
@ -329,8 +362,7 @@ static uint8_t wld_read_filename(INIHANDLE handle,
{ {
/* Read the string from the ini file. We supply the default value of NULL. /* Read the string from the ini file. We supply the default value of NULL.
* If this value is returned, we assume that that is evidence that the * If this value is returned, we assume that that is evidence that the
* requested value was not supplied in the ini file. * requested value was not supplied in the ini file. */
*/
char *value = inifile_read_string(handle, section_name, variable_name, char *value = inifile_read_string(handle, section_name, variable_name,
NULL); NULL);

16
graphics/traveler/tools/libwld/wld_discardbitmaps.c
View File

@ -45,7 +45,7 @@
#include "wld_world.h" #include "wld_world.h"
#include "wld_bitmaps.h" #include "wld_bitmaps.h"
#if (MSWINDOWS) #if (MSWINDOWS)
#include "wld_pcx.h" # include "wld_pcx.h"
#endif #endif
/************************************************************************* /*************************************************************************
@ -63,20 +63,20 @@ void wld_discard_bitmaps(void)
int i; int i;
for (i = 0; i < MAX_BITMAPS; i++) for (i = 0; i < MAX_BITMAPS; i++)
{ {
if (evenBitmaps[i]) if (g_even_bitmaps[i])
{ {
wld_free_texture((void*)evenBitmaps[i]); wld_free_texture((void *)g_even_bitmaps[i]);
evenBitmaps[i] = NULL; g_even_bitmaps[i] = NULL;
} }
#ifndef WEDIT #ifndef WEDIT
if (oddBitmaps[i]) if (g_odd_bitmaps[i])
{ {
wld_free_texture((void*)oddBitmaps[i]); wld_free_texture((void *)g_odd_bitmaps[i]);
oddBitmaps[i] = NULL; g_odd_bitmaps[i] = NULL;
} }
#endif #endif
} }
numBitmaps = 0; g_nbitmaps = 0;
} }

1
graphics/traveler/tools/libwld/wld_discardpaltable.c
View File

@ -54,6 +54,7 @@
void wld_discard_paltable(void) void wld_discard_paltable(void)
{ {
int i; int i;
for (i = 0; i < NUM_ZONES; i++) for (i = 0; i < NUM_ZONES; i++)
{ {
if (g_pal_table[i]) if (g_pal_table[i])

17
graphics/traveler/tools/libwld/wld_discardplanes.c
View File

@ -53,14 +53,14 @@
* This function deallocates one plane of the world * This function deallocates one plane of the world
************************************************************************/ ************************************************************************/
static void wld_DiscardWorldPlane(rect_list_t *rect) static void wld_DiscardWorldPlane(rect_list_t * rect)
{ {
rect_list_t *next; rect_list_t *next;
while (rect) while (rect)
{ {
next = rect->flink; next = rect->flink;
wld_free((void *) rect); wld_free((void *)rect);
rect = next; rect = next;
} }
} }
@ -77,13 +77,12 @@ static void wld_DiscardWorldPlane(rect_list_t *rect)
void wld_discard_planes(void) void wld_discard_planes(void)
{ {
wld_DiscardWorldPlane(xPlane.head); wld_DiscardWorldPlane(g_xplane_list.head);
xPlane.head = xPlane.tail = NULL; g_xplane_list.head = g_xplane_list.tail = NULL;
wld_DiscardWorldPlane(yPlane.head); wld_DiscardWorldPlane(g_yplane_list.head);
yPlane.head = yPlane.tail = NULL; g_yplane_list.head = g_yplane_list.tail = NULL;
wld_DiscardWorldPlane(zPlane.head); wld_DiscardWorldPlane(g_zplane_list.head);
zPlane.head = zPlane.tail = NULL; g_zplane_list.head = g_zplane_list.tail = NULL;
wld_DiscardWorldPlane(freeList); wld_DiscardWorldPlane(freeList);
freeList = NULL; freeList = NULL;
} }

12
graphics/traveler/tools/libwld/wld_fatalerror.c
View File

@ -59,12 +59,12 @@
void wld_fatal_error(char *message, ...) void wld_fatal_error(char *message, ...)
{ {
va_list args; va_list args;
va_start(args, message); va_start(args, message);
vfprintf(stderr, message, args); vfprintf(stderr, message, args);
putc('\n', stderr); putc('\n', stderr);
va_end(args); va_end(args);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }

25
graphics/traveler/tools/libwld/wld_findplane.c
View File

@ -55,36 +55,31 @@
************************************************************************/ ************************************************************************/
rect_list_t *wld_find_plane(wld_coord_t h, wld_coord_t v, wld_coord_t plane, rect_list_t *wld_find_plane(wld_coord_t h, wld_coord_t v, wld_coord_t plane,
rect_head_t *list) rect_head_t * list)
{ {
rect_list_t *rect; rect_list_t *rect;
/* Search until we find the first occurrence of a rectangle in the /* Search until we find the first occurrence of a rectangle in the specified
* specified plane * plane.
*/ */
for (rect = list->head; for (rect = list->head;
((rect) && (rect->d.plane < plane)); ((rect) && (rect->d.plane < plane)); rect = rect->flink);
rect = rect->flink);
/* Then look at every occurrence of rectangles at this plane or /* Then look at every occurrence of rectangles at this plane or until a
* until a rectangle containing the specified point is found * rectangle containing the specified point is found.
*/ */
for (; for (; ((rect) && (rect->d.plane == plane)); rect = rect->flink)
((rect) && (rect->d.plane == plane));
rect = rect->flink)
{ {
/* There is another rectangle in this plane. Check if the /* There is another rectangle in this plane. Check if the point lies
* point lies within the rectangle. * within the rectangle.
*/ */
if ((h >= rect->d.hStart) && (h <= rect->d.hEnd) if ((h >= rect->d.hStart) && (h <= rect->d.hEnd)
&& (v >= rect->d.vStart) && (v <= rect->d.vEnd)) && (v >= rect->d.vStart) && (v <= rect->d.vEnd))
return rect; return rect;
} }
return NULL; return NULL;
} }

2
graphics/traveler/tools/libwld/wld_freegraphicfile.c
View File

@ -51,7 +51,7 @@
* Description: * Description:
************************************************************************/ ************************************************************************/
void wld_free_graphicfile(graphic_file_t *gfile) void wld_free_graphicfile(graphic_file_t * gfile)
{ {
if (gfile != NULL) if (gfile != NULL)
{ {

8
graphics/traveler/tools/libwld/wld_freetexture.c
View File

@ -52,8 +52,12 @@
* Description: * Description:
************************************************************************/ ************************************************************************/
void wld_free_texture(wld_bitmap_t *t) void wld_free_texture(wld_bitmap_t * t)
{ {
if (t->bm) wld_free(t->bm); if (t->bm)
{
wld_free(t->bm);
}
wld_free(t); wld_free(t);
} }

1
graphics/traveler/tools/libwld/wld_graphicfilepixel.c
View File

@ -71,4 +71,3 @@ RGBColor wld_graphicfile_pixel(graphic_file_t *gfile, int x, int y)
return rgb; return rgb;
} }
} }

8
graphics/traveler/tools/libwld/wld_initializebitmaps.c
View File

@ -45,7 +45,7 @@
#include "wld_world.h" #include "wld_world.h"
#include "wld_bitmaps.h" #include "wld_bitmaps.h"
#if (MSWINDOWS) #if (MSWINDOWS)
#include "wld_pcx.h" # include "wld_pcx.h"
#endif #endif
/************************************************************************* /*************************************************************************
@ -62,12 +62,12 @@ uint8_t wld_initialize_bitmaps(void)
int i; int i;
for (i = 0; i < MAX_BITMAPS; i++) for (i = 0; i < MAX_BITMAPS; i++)
{ {
evenBitmaps[i] = NULL; g_even_bitmaps[i] = NULL;
#ifndef WEDIT #ifndef WEDIT
oddBitmaps[i] = NULL; g_odd_bitmaps[i] = NULL;
#endif #endif
} }
numBitmaps = 0; g_nbitmaps = 0;
return BMAP_SUCCESS; return BMAP_SUCCESS;
} }

7
graphics/traveler/tools/libwld/wld_initializeplanes.c
View File

@ -1,3 +1,4 @@
/**************************************************************************** /****************************************************************************
* apps/graphics/traveler/tools/libwld/wld_initializeplanes.c * apps/graphics/traveler/tools/libwld/wld_initializeplanes.c
* This file contains the logic initialize world plane data structures * This file contains the logic initialize world plane data structures
@ -54,9 +55,9 @@
uint8_t wld_initialize_planes(void) uint8_t wld_initialize_planes(void)
{ {
xPlane.head = xPlane.tail = NULL; g_xplane_list.head = g_xplane_list.tail = NULL;
yPlane.head = yPlane.tail = NULL; g_yplane_list.head = g_yplane_list.tail = NULL;
zPlane.head = zPlane.tail = NULL; g_zplane_list.head = g_zplane_list.tail = NULL;
freeList = NULL; freeList = NULL;
return PLANE_SUCCESS; return PLANE_SUCCESS;

124
graphics/traveler/tools/libwld/wld_loadbitmapfile.c
View File

@ -46,7 +46,7 @@
#include "wld_world.h" #include "wld_world.h"
#include "wld_bitmaps.h" #include "wld_bitmaps.h"
#if (MSWINDOWS) #if (MSWINDOWS)
#include "wld_pcx.h" # include "wld_pcx.h"
#endif #endif
#include "wld_utils.h" #include "wld_utils.h"
@ -60,9 +60,9 @@
* Read a file name from the input stream * Read a file name from the input stream
************************************************************************/ ************************************************************************/
static bool wld_read_filename(FILE *fp, char *fileName) static bool wld_read_filename(FILE * fp, char *fileName)
{ {
int16_t nbytes; int16_t nbytes;
int ch; int ch;
/* Skip over any leading spaces, new lines, or carriage returns (for /* Skip over any leading spaces, new lines, or carriage returns (for
@ -72,7 +72,8 @@ static bool wld_read_filename(FILE *fp, char *fileName)
do do
{ {
ch = getc(fp); ch = getc(fp);
if (ch == EOF) return false; if (ch == EOF)
return false;
} }
while ((ch == ' ') || (ch == '\n') || (ch == '\r')); while ((ch == ' ') || (ch == '\n') || (ch == '\r'));
@ -87,7 +88,10 @@ static bool wld_read_filename(FILE *fp, char *fileName)
{ {
/* Make sure that the file name is not too large */ /* Make sure that the file name is not too large */
if (nbytes >= FILE_NAME_SIZE) return false; if (nbytes >= FILE_NAME_SIZE)
{
return false;
}
/* Add the new character to the file name */ /* Add the new character to the file name */
@ -102,10 +106,9 @@ static bool wld_read_filename(FILE *fp, char *fileName)
break; break;
} }
/* Get the character for the next time through the loop. Every file /* Get the character for the next time through the loop. Every file name
* name should be terminated with a space or a new line. EOF is * should be terminated with a space or a new line. EOF is unexpected in
* unexpected in this context. * this context. */
*/
ch = getc(fp); ch = getc(fp);
if (ch == EOF) if (ch == EOF)
@ -123,15 +126,15 @@ static bool wld_read_filename(FILE *fp, char *fileName)
* This function loads the world data from the input file * This function loads the world data from the input file
************************************************************************/ ************************************************************************/
static uint8_t wld_load_bitmaps(FILE *fp) static uint8_t wld_load_bitmaps(FILE * fp)
{ {
#if MSWINDOWS #if MSWINDOWS
volatile pcxPicture workPCX; volatile pcxPicture workPCX;
RGBColor *palette; RGBColor *palette;
#endif #endif
uint16_t bMapIndex; uint16_t bMapIndex;
uint8_t result = BMAP_SUCCESS; uint8_t result = BMAP_SUCCESS;
uint8_t graphicsFileName[FILE_NAME_SIZE]; uint8_t graphicsFileName[FILE_NAME_SIZE];
/* Discard any bitmaps that we may currently have buffered */ /* Discard any bitmaps that we may currently have buffered */
@ -139,19 +142,18 @@ static uint8_t wld_load_bitmaps(FILE *fp)
/* Get the number of bitmaps in the bitmap file */ /* Get the number of bitmaps in the bitmap file */
numBitmaps = wld_read_decimal(fp); g_nbitmaps = wld_read_decimal(fp);
if (numBitmaps >= MAX_BITMAPS) if (g_nbitmaps >= MAX_BITMAPS)
return BMAP_TOO_MANY; return BMAP_TOO_MANY;
/* Read the colors used to rend the sky and ground */ /* Read the colors used to rend the sky and ground */
skyColor = wld_read_decimal(fp); skyColor = wld_read_decimal(fp);
groundColor = wld_read_decimal(fp); groundColor = wld_read_decimal(fp);
#if MSWINDOWS #if MSWINDOWS
/* Load the textures -- Note that the first texture will be used /* Load the textures -- Note that the first texture will be used to define
* to define the worldPalette * the worldPalette */
*/
palette = worldPalette; palette = worldPalette;
#endif #endif
@ -159,74 +161,92 @@ static uint8_t wld_load_bitmaps(FILE *fp)
/* Load each bitmap file */ /* Load each bitmap file */
for (bMapIndex = 0; for (bMapIndex = 0;
((bMapIndex < numBitmaps) && (result == BMAP_SUCCESS)); ((bMapIndex < g_nbitmaps) && (result == BMAP_SUCCESS)); bMapIndex++)
bMapIndex++)
{ {
/* Load the even bitmap */ /* Load the even bitmap */
/* Get the name of the file which contains the even bitmap */ /* Get the name of the file which contains the even bitmap */
if (!wld_read_filename(fp, graphicsFileName)) if (!wld_read_filename(fp, graphicsFileName))
return BMAP_BML_READ_ERROR; {
return BMAP_BML_READ_ERROR;
}
#if MSWINDOWS #if MSWINDOWS
/* Setup to load the PCX bitmap from the file for the event bitmap */ /* Setup to load the PCX bitmap from the file for the event bitmap */
result = wld_pcx_init(&workPCX, BITMAP_HEIGHT, BITMAP_WIDTH, result = wld_pcx_init(&workPCX, BITMAP_HEIGHT, BITMAP_WIDTH,
palette, NULL); palette, NULL);
if (result) return result; if (result)
{
return result;
}
/* Put the bitmap buffer into the evenBitmap list */ /* Put the bitmap buffer into the evenBitmap list */
evenBitmaps[bMapIndex].w = BITMAP_WIDTH; g_even_bitmaps[bMapIndex].w = BITMAP_WIDTH;
evenBitmaps[bMapIndex].h = BITMAP_HEIGHT; g_even_bitmaps[bMapIndex].h = BITMAP_HEIGHT;
evenBitmaps[bMapIndex].log2h = BITMAP_LOG2H; g_even_bitmaps[bMapIndex].log2h = BITMAP_LOG2H;
evenBitmaps[bMapIndex].bm = workPCX.buffer; g_even_bitmaps[bMapIndex].bm = workPCX.buffer;
/* Load the PCX bitmap from the file for the event bitmap */ /* Load the PCX bitmap from the file for the event bitmap */
result = wld_loadpcx(graphicsFileName, &workPCX); result = wld_loadpcx(graphicsFileName, &workPCX);
if (result) return result; if (result)
{
return result;
}
/* Don't bother to load the palette on the rest of the textures -- /* Don't bother to load the palette on the rest of the textures -- we
* we will assume the same palette for all textures. * will assume the same palette for all textures. */
*/
palette = NULL; palette = NULL;
#else #else
evenBitmaps[bMapIndex] = wld_read_texturefile(graphicsFileName); g_even_bitmaps[bMapIndex] = wld_read_texturefile(graphicsFileName);
if (!evenBitmaps[bMapIndex]) return BMAP_BML_READ_ERROR; if (!g_even_bitmaps[bMapIndex])
{
return BMAP_BML_READ_ERROR;
}
#endif #endif
/* Load the odd bitmap */ /* Load the odd bitmap */
/* Get the name of the file which contains the odd bitmap */ /* Get the name of the file which contains the odd bitmap */
if (!wld_read_filename(fp, graphicsFileName)) if (!wld_read_filename(fp, graphicsFileName))
return BMAP_BML_READ_ERROR; {
return BMAP_BML_READ_ERROR;
}
#ifndef WEDIT #ifndef WEDIT
#if MSWINDOWS # if MSWINDOWS
/* Setup to load the PCX bitmap from the file for the odd bitmap */ /* Setup to load the PCX bitmap from the file for the odd bitmap */
result = wld_pcx_init(&workPCX, BITMAP_HEIGHT, BITMAP_WIDTH, result = wld_pcx_init(&workPCX, BITMAP_HEIGHT, BITMAP_WIDTH,
palette, NULL); palette, NULL);
if (result) return result; if (result)
{
return result;
}
/* Put the bitmap buffer into the oddBitmap list */ /* Put the bitmap buffer into the oddBitmap list */
oddBitmaps[bMapIndex].w = BITMAP_WIDTH; g_odd_bitmaps[bMapIndex].w = BITMAP_WIDTH;
oddBitmaps[bMapIndex].h = BITMAP_HEIGHT; g_odd_bitmaps[bMapIndex].h = BITMAP_HEIGHT;
oddBitmaps[bMapIndex].log2h = BITMAP_LOG2H; g_odd_bitmaps[bMapIndex].log2h = BITMAP_LOG2H;
oddBitmaps[bMapIndex].bm = workPCX.buffer; g_odd_bitmaps[bMapIndex].bm = workPCX.buffer;
/* Load the PCX bitmap from the file for the odd bitmap */ /* Load the PCX bitmap from the file for the odd bitmap */
result = wld_loadpcx(graphicsFileName, &workPCX); result = wld_loadpcx(graphicsFileName, &workPCX);
#else # else
oddBitmaps[bMapIndex] = wld_read_texturefile(graphicsFileName); g_odd_bitmaps[bMapIndex] = wld_read_texturefile(graphicsFileName);
if (!oddBitmaps[bMapIndex]) return BMAP_BML_READ_ERROR; if (!g_odd_bitmaps[bMapIndex])
#endif {
return BMAP_BML_READ_ERROR;
}
# endif
#endif #endif
} }
return result; return result;
} }
@ -242,18 +262,20 @@ static uint8_t wld_load_bitmaps(FILE *fp)
uint8_t wld_load_bitmapfile(char *bmlFile) uint8_t wld_load_bitmapfile(char *bmlFile)
{ {
FILE *fp; FILE *fp;
uint8_t result; uint8_t result;
/* Open the file which contains the names of all of the bitmap files */ /* Open the file which contains the names of all of the bitmap files */
fp = fopen(bmlFile, "r"); fp = fopen(bmlFile, "r");
if (!fp) return BMAP_BML_OPEN_ERROR; if (!fp)
return BMAP_BML_OPEN_ERROR;
/* Load all of the bitmaps */ /* Load all of the bitmaps */
result = wld_load_bitmaps(fp); result = wld_load_bitmaps(fp);
if (result) wld_discard_bitmaps(); if (result)
wld_discard_bitmaps();
/* We are all done with the file, so close it */ /* We are all done with the file, so close it */

252
graphics/traveler/tools/libwld/wld_loadgif.c
View File

@ -66,35 +66,35 @@
* Private Data * Private Data
*************************************************************************/ *************************************************************************/
int BitOffset = 0, /* Bit Offset of next code */ int BitOffset = 0, /* Bit Offset of next code */
XC = 0, YC = 0, /* Output X and Y coords of current pixel */ XC = 0, YC = 0, /* Output X and Y coords of current pixel */
Pass = 0, /* Used by output routine if interlaced pic */ Pass = 0, /* Used by output routine if interlaced pic */
OutCount = 0, /* Decompressor output 'stack count' */ OutCount = 0, /* Decompressor output 'stack count' */
RWidth, RHeight, /* screen dimensions */ RWidth, RHeight, /* screen dimensions */
Width, Height, /* image dimensions */ Width, Height, /* image dimensions */
LeftOfs, TopOfs, /* image offset */ LeftOfs, TopOfs, /* image offset */
BitsPerPixel, /* Bits per pixel, read from GIF header */ BitsPerPixel, /* Bits per pixel, read from GIF header */
BytesPerScanline, /* bytes per scanline in output rwld_er */ BytesPerScanline, /* bytes per scanline in output rwld_er */
ColorMapSize, /* number of colors */ ColorMapSize, /* number of colors */
Background, /* background color */ Background, /* background color */
CodeSize, /* Code size, read from GIF header */ CodeSize, /* Code size, read from GIF header */
InitCodeSize, /* Starting code size, used during Clear */ InitCodeSize, /* Starting code size, used during Clear */
Code, /* Value returned by ReadCode */ Code, /* Value returned by ReadCode */
MaxCode, /* limiting value for current code size */ MaxCode, /* limiting value for current code size */
ClearCode, /* GIF clear code */ ClearCode, /* GIF clear code */
EOFCode, /* GIF end-of-information code */ EOFCode, /* GIF end-of-information code */
CurCode, OldCode, InCode, /* Decompressor variables */ CurCode, OldCode, InCode, /* Decompressor variables */
FirstFree, /* First free code, generated per GIF spec */ FirstFree, /* First free code, generated per GIF spec */
FreeCode, /* Decompressor, next free slot in hash table*/ FreeCode, /* Decompressor, next free slot in hash table */
FinChar, /* Decompressor variable */ FinChar, /* Decompressor variable */
BitMask, /* AND mask for data size */ BitMask, /* AND mask for data size */
ReadMask; /* Code AND mask for current code size */ ReadMask; /* Code AND mask for current code size */
bool Interlace, HasColormap; bool Interlace, HasColormap;
bool Verbose = true; bool Verbose = true;
uint8_t *Image; /* The result array */ uint8_t *Image; /* The result array */
uint8_t *RawGIF; /* The heap array to hold it, raw */ uint8_t *RawGIF; /* The heap array to hold it, raw */
uint8_t *Rwld_er; /* The rwld_er data stream, unblocked */ uint8_t *Rwld_er; /* The rwld_er data stream, unblocked */
/* The hash table used by the decompressor */ /* The hash table used by the decompressor */
@ -109,7 +109,7 @@ int OutCode[1025];
/* The color map, read from the GIF header */ /* The color map, read from the GIF header */
uint8_t Red[256], Green[256], Blue[256], used[256]; uint8_t Red[256], Green[256], Blue[256], used[256];
int numused; int numused;
char *id87 = "GIF87a"; char *id87 = "GIF87a";
char *id89 = "GIF89a"; char *id89 = "GIF89a";
@ -134,25 +134,25 @@ static int ReadCode(void)
int RawCode, ByteOffset; int RawCode, ByteOffset;
ByteOffset = BitOffset / 8; ByteOffset = BitOffset / 8;
RawCode = Rwld_er[ByteOffset] + (0x100 * Rwld_er[ByteOffset + 1]); RawCode = Rwld_er[ByteOffset] + (0x100 * Rwld_er[ByteOffset + 1]);
if (CodeSize >= 8) if (CodeSize >= 8)
RawCode += (0x10000 * Rwld_er[ByteOffset + 2]); RawCode += (0x10000 * Rwld_er[ByteOffset + 2]);
RawCode >>= (BitOffset % 8); RawCode >>= (BitOffset % 8);
BitOffset += CodeSize; BitOffset += CodeSize;
return(RawCode & ReadMask); return (RawCode & ReadMask);
} }
static void AddToPixel(uint8_t Index) static void AddToPixel(uint8_t Index)
{ {
if (YC<Height) if (YC < Height)
*(Image + YC * BytesPerScanline + XC) = Index; *(Image + YC * BytesPerScanline + XC) = Index;
if (!used[Index]) if (!used[Index])
{ {
used[Index]=1; used[Index] = 1;
numused++; numused++;
} }
@ -164,11 +164,13 @@ static void AddToPixel(uint8_t Index)
/* If a non-interlaced picture, just increment YC to the next scan line. /* If a non-interlaced picture, just increment YC to the next scan line.
* If it's interlaced, deal with the interlace as described in the GIF * If it's interlaced, deal with the interlace as described in the GIF
* spec. Put the decoded scan line out to the screen if we haven't gone * spec. Put the decoded scan line out to the screen if we haven't gone
* pwld_ the bottom of it * pwld_ the bottom of it */
*/
XC = 0; XC = 0;
if (!Interlace) YC++; if (!Interlace)
{
YC++;
}
else else
{ {
switch (Pass) switch (Pass)
@ -212,11 +214,11 @@ static void AddToPixel(uint8_t Index)
************************************************************************/ ************************************************************************/
/************************************************************************* /*************************************************************************
* Name: * Name: wld_LoadGIF
* Description: * Description:
************************************************************************/ ************************************************************************/
graphic_file_t *wld_LoadGIF(FILE *fp, char *fname) graphic_file_t *wld_LoadGIF(FILE * fp, char *fname)
{ {
graphic_file_t *gfile; graphic_file_t *gfile;
int filesize; int filesize;
@ -239,7 +241,9 @@ graphic_file_t *wld_LoadGIF(FILE *fp, char *fname)
fseek(fp, 0L, 0); fseek(fp, 0L, 0);
if (!(ptr = RawGIF = (uint8_t *) malloc(filesize))) if (!(ptr = RawGIF = (uint8_t *) malloc(filesize)))
wld_fatal_error("not enough memory to read gif file"); {
wld_fatal_error("not enough memory to read gif file");
}
if (!(Rwld_er = (uint8_t *) malloc(filesize))) if (!(Rwld_er = (uint8_t *) malloc(filesize)))
{ {
@ -251,47 +255,57 @@ graphic_file_t *wld_LoadGIF(FILE *fp, char *fname)
wld_fatal_error("GIF data read failed"); wld_fatal_error("GIF data read failed");
if (strncmp(ptr, id87, 6)) if (strncmp(ptr, id87, 6))
if (strncmp(ptr, id89, 6)) {
wld_fatal_error("not a GIF file"); if (strncmp(ptr, id89, 6))
{
wld_fatal_error("not a GIF file");
}
}
ptr += 6; ptr += 6;
/* Get variables from the GIF screen descriptor */ /* Get variables from the GIF screen descriptor */
ch = NEXTBYTE; ch = NEXTBYTE;
RWidth = ch + 0x100 * NEXTBYTE; /* screen dimensions... not used. */ RWidth = ch + 0x100 * NEXTBYTE; /* screen dimensions... not used. */
ch = NEXTBYTE; ch = NEXTBYTE;
RHeight = ch + 0x100 * NEXTBYTE; RHeight = ch + 0x100 * NEXTBYTE;
if (Verbose) if (Verbose)
fprintf(stderr, "screen dims: %dx%d.\n", RWidth, RHeight); {
fprintf(stderr, "screen dims: %dx%d.\n", RWidth, RHeight);
}
ch = NEXTBYTE; ch = NEXTBYTE;
HasColormap = ((ch & COLORMAPMASK) ? true : false); HasColormap = ((ch & COLORMAPMASK) ? true : false);
BitsPerPixel = (ch & 7) + 1; BitsPerPixel = (ch & 7) + 1;
ColorMapSize = 1 << BitsPerPixel; ColorMapSize = 1 << BitsPerPixel;
BitMask = ColorMapSize - 1; BitMask = ColorMapSize - 1;
Background = NEXTBYTE; /* background color... not used. */ Background = NEXTBYTE; /* background color... not used. */
if (NEXTBYTE) /* supposed to be NULL */ if (NEXTBYTE) /* supposed to be NULL */
wld_fatal_error("corrupt GIF file (bad screen descriptor)"); {
wld_fatal_error("corrupt GIF file (bad screen descriptor)");
}
/* Read in global colormap. */ /* Read in global colormap. */
if (HasColormap) if (HasColormap)
{ {
if (Verbose) if (Verbose)
fprintf(stderr, "%s is %dx%d, %d bits per pixel, (%d colors).\n", {
fname, RWidth,RHeight,BitsPerPixel, ColorMapSize); fprintf(stderr, "%s is %dx%d, %d bits per pixel, (%d colors).\n",
fname, RWidth, RHeight, BitsPerPixel, ColorMapSize);
}
for (i = 0; i < ColorMapSize; i++) for (i = 0; i < ColorMapSize; i++)
{ {
Red[i] = NEXTBYTE; Red[i] = NEXTBYTE;
Green[i] = NEXTBYTE; Green[i] = NEXTBYTE;
Blue[i] = NEXTBYTE; Blue[i] = NEXTBYTE;
used[i] = 0; used[i] = 0;
} }
numused = 0; numused = 0;
@ -299,7 +313,7 @@ graphic_file_t *wld_LoadGIF(FILE *fp, char *fname)
/* look for image separator */ /* look for image separator */
for (ch = NEXTBYTE ; ch != IMAGESEP ; ch = NEXTBYTE) for (ch = NEXTBYTE; ch != IMAGESEP; ch = NEXTBYTE)
{ {
i = ch; i = ch;
fprintf(stderr, "EXTENSION CHARACTER: %x\n", i); fprintf(stderr, "EXTENSION CHARACTER: %x\n", i);
@ -314,9 +328,10 @@ graphic_file_t *wld_LoadGIF(FILE *fp, char *fname)
ch = NEXTBYTE; ch = NEXTBYTE;
if (ptr[0] & 0x1) if (ptr[0] & 0x1)
{ {
transparency = ptr[3]; /* transparent color index */ transparency = ptr[3]; /* transparent color index */
fprintf(stderr, "transparency index: %i\n", transparency); fprintf(stderr, "transparency index: %i\n", transparency);
} }
ptr += ch; ptr += ch;
break; break;
case PLAINTEXT_EXT: case PLAINTEXT_EXT:
@ -330,19 +345,21 @@ graphic_file_t *wld_LoadGIF(FILE *fp, char *fname)
} }
while ((ch = NEXTBYTE)) while ((ch = NEXTBYTE))
ptr += ch; {
ptr += ch;
}
} }
/* Now read in values from the image descriptor */ /* Now read in values from the image descriptor */
ch = NEXTBYTE; ch = NEXTBYTE;
LeftOfs = ch + 0x100 * NEXTBYTE; LeftOfs = ch + 0x100 * NEXTBYTE;
ch = NEXTBYTE; ch = NEXTBYTE;
TopOfs = ch + 0x100 * NEXTBYTE; TopOfs = ch + 0x100 * NEXTBYTE;
ch = NEXTBYTE; ch = NEXTBYTE;
Width = ch + 0x100 * NEXTBYTE; Width = ch + 0x100 * NEXTBYTE;
ch = NEXTBYTE; ch = NEXTBYTE;
Height = ch + 0x100 * NEXTBYTE; Height = ch + 0x100 * NEXTBYTE;
Interlace = ((NEXTBYTE & INTERLACEMASK) ? true : false); Interlace = ((NEXTBYTE & INTERLACEMASK) ? true : false);
if (Verbose) if (Verbose)
@ -350,61 +367,62 @@ graphic_file_t *wld_LoadGIF(FILE *fp, char *fname)
Width, Height, (Interlace) ? "" : "non-"); Width, Height, (Interlace) ? "" : "non-");
gfile = wld_new_graphicfile(); gfile = wld_new_graphicfile();
gfile->palette = (RGBColor*)wld_malloc(sizeof(RGBColor) * ColorMapSize); gfile->palette = (RGBColor *) wld_malloc(sizeof(RGBColor) * ColorMapSize);
for (i = 0; i < ColorMapSize; i++) for (i = 0; i < ColorMapSize; i++)
{ {
gfile->palette[i].red = Red[i]; gfile->palette[i].red = Red[i];
gfile->palette[i].green = Green[i]; gfile->palette[i].green = Green[i];
gfile->palette[i].blue = Blue[i]; gfile->palette[i].blue = Blue[i];
} }
gfile->bitmap = (uint8_t*)wld_malloc(Width * Height);
gfile->bitmap = (uint8_t *) wld_malloc(Width * Height);
gfile->type = gfPaletted; gfile->type = gfPaletted;
gfile->width = Width; gfile->width = Width;
gfile->height = Height; gfile->height = Height;
gfile->transparent_entry = transparency; gfile->transparent_entry = transparency;
/* Note that I ignore the possible existence of a local color map. /* Note that I ignore the possible existence of a local color map. I'm told
* I'm told there aren't many files around that use them, and the spec * there aren't many files around that use them, and the spec says it's
* says it's defined for future use. This could lead to an error * defined for future use. This could lead to an error reading some files.
* reading some files.
*/ */
/* Start reading the rwld_er data. First we get the intial code size /* Start reading the rwld_er data. First we get the intial code size and
* and compute decompressor constant values, based on this code size. * compute decompressor constant values, based on this code size.
*/ */
CodeSize = NEXTBYTE; CodeSize = NEXTBYTE;
ClearCode = (1 << CodeSize); ClearCode = (1 << CodeSize);
EOFCode = ClearCode + 1; EOFCode = ClearCode + 1;
FreeCode = FirstFree = ClearCode + 2; FreeCode = FirstFree = ClearCode + 2;
/* The GIF spec has it that the code size is the code size used to /* The GIF spec has it that the code size is the code size used to compute
* compute the above values is the code size given in the file, but the * the above values is the code size given in the file, but the code size
* code size used in compression/decompression is the code size given in * used in compression/decompression is the code size given in the file plus
* the file plus one. (thus the ++). * one. (thus the ++).
*/ */
CodeSize++; CodeSize++;
InitCodeSize = CodeSize; InitCodeSize = CodeSize;
MaxCode = (1 << CodeSize); MaxCode = (1 << CodeSize);
ReadMask = MaxCode - 1; ReadMask = MaxCode - 1;
/* Read the rwld_er data. Here we just transpose it from the GIF array /* Read the rwld_er data. Here we just transpose it from the GIF array to
* to the Rwld_er array, turning it from a series of blocks into one long * the Rwld_er array, turning it from a series of blocks into one long data
* data stream, which makes life much easier for ReadCode(). * stream, which makes life much easier for ReadCode().
*/ */
ptr1 = Rwld_er; ptr1 = Rwld_er;
do do
{ {
ch = ch1 = NEXTBYTE; ch = ch1 = NEXTBYTE;
while (ch--) *ptr1++ = NEXTBYTE; while (ch--)
*ptr1++ = NEXTBYTE;
if ((ptr1 - Rwld_er) > filesize) if ((ptr1 - Rwld_er) > filesize)
wld_fatal_error("corrupt GIF file (unblock)"); wld_fatal_error("corrupt GIF file (unblock)");
} }
while(ch1); while (ch1);
free(RawGIF); /* We're done with the raw data now... */ free(RawGIF); /* We're done with the raw data now... */
if (Verbose) if (Verbose)
{ {
@ -412,12 +430,11 @@ graphic_file_t *wld_LoadGIF(FILE *fp, char *fname)
fprintf(stderr, "Decompressing..."); fprintf(stderr, "Decompressing...");
} }
Image = gfile->bitmap; Image = gfile->bitmap;
BytesPerScanline = Width; BytesPerScanline = Width;
/* Decompress the file, continuing until you see the GIF EOF code. One
/* Decompress the file, continuing until you see the GIF EOF code. * obvious enhancement is to add checking for corrupt files here.
* One obvious enhancement is to add checking for corrupt files here.
*/ */
Code = ReadCode(); Code = ReadCode();
@ -431,24 +448,23 @@ graphic_file_t *wld_LoadGIF(FILE *fp, char *fname)
if (Code == ClearCode) if (Code == ClearCode)
{ {
CodeSize = InitCodeSize; CodeSize = InitCodeSize;
MaxCode = (1 << CodeSize); MaxCode = (1 << CodeSize);
ReadMask = MaxCode - 1; ReadMask = MaxCode - 1;
FreeCode = FirstFree; FreeCode = FirstFree;
CurCode = OldCode = Code = ReadCode(); CurCode = OldCode = Code = ReadCode();
FinChar = CurCode & BitMask; FinChar = CurCode & BitMask;
AddToPixel(FinChar); AddToPixel(FinChar);
} }
else else
{ {
/* If not a clear code, then must be data: save same as CurCode and
/* If not a clear code, then must be data: save same as CurCode * InCode
* and InCode
*/ */
CurCode = InCode = Code; CurCode = InCode = Code;
/* If greater or equal to FreeCode, not in the hash table yet; /* If greater or equal to FreeCode, not in the hash table yet; repeat
* repeat the lwld_ character decoded * the lwld_ character decoded
*/ */
if (CurCode >= FreeCode) if (CurCode >= FreeCode)
@ -457,17 +473,16 @@ graphic_file_t *wld_LoadGIF(FILE *fp, char *fname)
OutCode[OutCount++] = FinChar; OutCode[OutCount++] = FinChar;
} }
/* Unless this code is raw data, pursue the chain pointed to /* Unless this code is raw data, pursue the chain pointed to by
* by CurCode through the hash table to its end; each code * CurCode through the hash table to its end; each code in the chain
* in the chain puts its associated output code on the output * puts its associated output code on the output queue.
* queue.
*/ */
while (CurCode > BitMask) while (CurCode > BitMask)
{ {
if (OutCount > 1024) if (OutCount > 1024)
{ {
fprintf(stderr,"\nCorrupt GIF file (OutCount)!\n"); fprintf(stderr, "\nCorrupt GIF file (OutCount)!\n");
exit(-1); exit(-1);
} }
OutCode[OutCount++] = Suffix[CurCode]; OutCode[OutCount++] = Suffix[CurCode];
@ -476,11 +491,11 @@ graphic_file_t *wld_LoadGIF(FILE *fp, char *fname)
/* The lwld_ code in the chain is treated as raw data. */ /* The lwld_ code in the chain is treated as raw data. */
FinChar = CurCode & BitMask; FinChar = CurCode & BitMask;
OutCode[OutCount++] = FinChar; OutCode[OutCount++] = FinChar;
/* Now we put the data out to the Output routine. /* Now we put the data out to the Output routine. It's been stacked
* It's been stacked LIFO, so deal with it that way... * LIFO, so deal with it that way...
*/ */
for (i = OutCount - 1; i >= 0; i--) for (i = OutCount - 1; i >= 0; i--)
@ -491,12 +506,11 @@ graphic_file_t *wld_LoadGIF(FILE *fp, char *fname)
Prefix[FreeCode] = OldCode; Prefix[FreeCode] = OldCode;
Suffix[FreeCode] = FinChar; Suffix[FreeCode] = FinChar;
OldCode = InCode; OldCode = InCode;
/* Point to the next slot in the table. If we exceed the current /* Point to the next slot in the table. If we exceed the current
* MaxCode value, increment the code size unless it's already 12. * MaxCode value, increment the code size unless it's already 12. If
* If it is, do nothing: the next code decompressed better be * it is, do nothing: the next code decompressed better be CLEAR
* CLEAR
*/ */
FreeCode++; FreeCode++;
@ -510,16 +524,20 @@ graphic_file_t *wld_LoadGIF(FILE *fp, char *fname)
} }
} }
} }
Code = ReadCode(); Code = ReadCode();
} }
free(Rwld_er); free(Rwld_er);
if (Verbose) if (Verbose)
fprintf(stderr, "done.\n"); {
fprintf(stderr, "done.\n");
}
else else
fprintf(stderr,"(of which %d are used)\n",numused); {
fprintf(stderr, "(of which %d are used)\n", numused);
}
return gfile; return gfile;
} }

75
graphics/traveler/tools/libwld/wld_loadpaltable.c
View File

@ -50,8 +50,8 @@
#include "wld_world.h" #include "wld_world.h"
#include "wld_paltable.h" #include "wld_paltable.h"
#if (!MSWINDOWS) #if (!MSWINDOWS)
#include "wld_bitmaps.h" # include "wld_bitmaps.h"
#include "wld_color.h" # include "wld_color.h"
#endif #endif
#include "wld_mem.h" #include "wld_mem.h"
#include "wld_utils.h" #include "wld_utils.h"
@ -65,7 +65,7 @@
*/ */
#if USE_PAL_RANGES #if USE_PAL_RANGES
# define MAX_PAL_RANGES 64 # define MAX_PAL_RANGES 64
#endif #endif
/************************************************************************* /*************************************************************************
@ -74,11 +74,11 @@
#if USE_PAL_RANGES #if USE_PAL_RANGES
typedef struct typedef struct
{ {
uint8_t firstColor; uint8_t firstColor;
int8_t colorRange; int8_t colorRange;
uint8_t clipColor; uint8_t clipColor;
} pal_range_t; } pal_range_t;
#endif #endif
/************************************************************************* /*************************************************************************
@ -106,7 +106,8 @@ static void wld_allocate_paltable(uint32_t palTabEntrySize)
for (i = 0; i < NUM_ZONES; i++) for (i = 0; i < NUM_ZONES; i++)
{ {
g_pal_table[i] = (trv_pixel_t*)wld_malloc(palTabEntrySize*sizeof(trv_pixel_t)); g_pal_table[i] =
(trv_pixel_t *) wld_malloc(palTabEntrySize * sizeof(trv_pixel_t));
} }
} }
@ -125,13 +126,13 @@ uint8_t wld_load_paltable(char *file)
#if (!MSWINDOWS) #if (!MSWINDOWS)
trv_pixel_t *palptr; trv_pixel_t *palptr;
color_lum_t lum; color_lum_t lum;
int16_t zone; int16_t zone;
float scale; float scale;
int pixel; int pixel;
/* Allocate memory to hold the palette range mapping data */ /* Allocate memory to hold the palette range mapping data */
wld_allocate_paltable(TRV_PIXEL_MAX+1); wld_allocate_paltable(TRV_PIXEL_MAX + 1);
/* The first zone is just the identity transformation */ /* The first zone is just the identity transformation */
@ -165,9 +166,8 @@ uint8_t wld_load_paltable(char *file)
lum.luminance *= scale; lum.luminance *= scale;
/* Then save the pixel associated with this scaled value in /* Then save the pixel associated with this scaled value in the range
* the range palette table * palette table */
*/
*palptr++ = wld_lum2pixel(&lum); *palptr++ = wld_lum2pixel(&lum);
} }
@ -176,12 +176,12 @@ uint8_t wld_load_paltable(char *file)
return WORLD_SUCCESS; return WORLD_SUCCESS;
#else #else
#if USE_PAL_RANGES # if USE_PAL_RANGES
FILE *fp, *fopen(); FILE *fp, *fopen();
int16_t i; int16_t i;
int16_t nranges; int16_t nranges;
int16_t zone; int16_t zone;
int16_t palndx; int16_t palndx;
trv_pixel_t plotcolor; trv_pixel_t plotcolor;
trv_pixel_t *palptr; trv_pixel_t *palptr;
pal_range_t ranges[MAX_PAL_RANGES]; pal_range_t ranges[MAX_PAL_RANGES];
@ -189,7 +189,10 @@ uint8_t wld_load_paltable(char *file)
/* Open the file which contains the palette table */ /* Open the file which contains the palette table */
fp = fopen(file, "r"); fp = fopen(file, "r");
if (!fp) return PALR_FILE_OPEN_ERROR; if (!fp)
{
return PALR_FILE_OPEN_ERROR;
}
/* Read the number of ranges from the file */ /* Read the number of ranges from the file */
@ -206,7 +209,7 @@ uint8_t wld_load_paltable(char *file)
{ {
ranges[i].firstColor = wld_read_decimal(fp); ranges[i].firstColor = wld_read_decimal(fp);
ranges[i].colorRange = wld_read_decimal(fp); ranges[i].colorRange = wld_read_decimal(fp);
ranges[i].clipColor = wld_read_decimal(fp); ranges[i].clipColor = wld_read_decimal(fp);
} }
/* We are now done with the input file */ /* We are now done with the input file */
@ -229,9 +232,8 @@ uint8_t wld_load_paltable(char *file)
for (palndx = 0; palndx < PALETTE_SIZE; palndx++) for (palndx = 0; palndx < PALETTE_SIZE; palndx++)
{ {
/* Assume that the range will not be found. In this case, we /* Assume that the range will not be found. In this case, we will
* will perform the 1-to-1 mapping * perform the 1-to-1 mapping */
*/
plotcolor = palndx; plotcolor = palndx;
@ -255,12 +257,11 @@ uint8_t wld_load_paltable(char *file)
plotcolor -= zone; plotcolor -= zone;
/* Check if we have exceeded the range of this /* Check if we have exceeded the range of this color.
* color. If so, then set the color to the * If so, then set the color to the clipColor */
* clipColor
*/
if (plotcolor <= ranges[i].firstColor + ranges[i].colorRange) if (plotcolor <=
ranges[i].firstColor + ranges[i].colorRange)
{ {
plotcolor = ranges[i].clipColor; plotcolor = ranges[i].clipColor;
} }
@ -286,8 +287,7 @@ uint8_t wld_load_paltable(char *file)
plotcolor += zone; plotcolor += zone;
/* Check if we have exceeded the range of this color. If so, /* Check if we have exceeded the range of this color. If so,
* then set the color to black * then set the color to black */
*/
if (plotcolor >= ranges[i].firstColor + ranges[i].colorRange) if (plotcolor >= ranges[i].firstColor + ranges[i].colorRange)
{ {
@ -308,7 +308,7 @@ uint8_t wld_load_paltable(char *file)
} }
return WORLD_SUCCESS; return WORLD_SUCCESS;
#else # else
FILE *fp; FILE *fp;
int16_t zone; int16_t zone;
int16_t palndx; int16_t palndx;
@ -322,7 +322,10 @@ uint8_t wld_load_paltable(char *file)
/* Open the file which contains the palette table */ /* Open the file which contains the palette table */
fp = fopen(file, "r"); fp = fopen(file, "r");
if (!fp) return PALR_FILE_OPEN_ERROR; if (!fp)
{
return PALR_FILE_OPEN_ERROR;
}
/* Process each distance zone */ /* Process each distance zone */
@ -344,6 +347,6 @@ uint8_t wld_load_paltable(char *file)
fclose(fp); fclose(fp);
return WORLD_SUCESS; return WORLD_SUCESS;
#endif /* USE_PAL_RANGES */ # endif /* USE_PAL_RANGES */
#endif /* !MSWINDOWS */ #endif /* !MSWINDOWS */
} }

55
graphics/traveler/tools/libwld/wld_loadpcx.c
View File

@ -51,8 +51,8 @@
#include "trv_types.h" #include "trv_types.h"
#include "wld_mem.h" #include "wld_mem.h"
#if (!MSWINDOWS) #if (!MSWINDOWS)
#include "wld_bitmaps.h" # include "wld_bitmaps.h"
#include "wld_graphicfile.h" # include "wld_graphicfile.h"
#endif #endif
#include "wld_pcx.h" #include "wld_pcx.h"
@ -68,9 +68,9 @@
* Private Function Prototypes * Private Function Prototypes
*************************************************************************/ *************************************************************************/
static void wld_loadpcxHeader(FILE *fp, pcxHeader *header); static void wld_loadpcxHeader(FILE * fp, pcxHeader * header);
static void wld_loadpcxData(FILE *fp, int32_t imagSize, uint8_t *imageBuffer); static void wld_loadpcxData(FILE * fp, int32_t imagSize, uint8_t * imageBuffer);
static void wld_loadpcxPalette(FILE *fp, RGBColor *palette); static void wld_loadpcxPalette(FILE * fp, RGBColor * palette);
/************************************************************************* /*************************************************************************
* Global Variables * Global Variables
@ -93,13 +93,16 @@ static void wld_loadpcxPalette(FILE *fp, RGBColor *palette);
uint8_t wld_loadpcx(char *filename, pcxPicturePtr image) uint8_t wld_loadpcx(char *filename, pcxPicturePtr image)
{ {
FILE *fp, *fopen(); FILE *fp, *fopen();
uint16_t imageWidth, imageHeight; uint16_t imageWidth, imageHeight;
uint32_t imageSize; uint32_t imageSize;
/* Open the file */ /* Open the file */
fp = fopen(filename,"rb"); fp = fopen(filename, "rb");
if (!fp) return PCX_OPEN_ERROR; if (!fp)
{
return PCX_OPEN_ERROR;
}
/* Load the PCX Header */ /* Load the PCX Header */
@ -126,13 +129,13 @@ uint8_t wld_loadpcx(char *filename, pcxPicturePtr image)
return PCX_SUCCESS; return PCX_SUCCESS;
} }
#else #else
graphic_file_t *wld_loadpcx(FILE *fp, char *filename) graphic_file_t *wld_loadpcx(FILE * fp, char *filename)
{ {
pcxHeader header; pcxHeader header;
trv_pixel_t *buffer; trv_pixel_t *buffer;
graphic_file_t *gFile; graphic_file_t *gFile;
RGBColor *palette; RGBColor *palette;
uint16_t imageWidth, imageHeight; uint16_t imageWidth, imageHeight;
uint32_t imageSize; uint32_t imageSize;
/* Load the PCX Header */ /* Load the PCX Header */
@ -144,15 +147,15 @@ graphic_file_t *wld_loadpcx(FILE *fp, char *filename)
imageWidth = header.width - header.x + 1; imageWidth = header.width - header.x + 1;
imageHeight = header.height - header.y + 1; imageHeight = header.height - header.y + 1;
imageSize = imageHeight * imageWidth * sizeof(trv_pixel_t); imageSize = imageHeight * imageWidth * sizeof(trv_pixel_t);
buffer = (trv_pixel_t*)wld_malloc(imageSize + 1); buffer = (trv_pixel_t *) wld_malloc(imageSize + 1);
/* Load the PCX data into the buffer */ /* Load the PCX data into the buffer */
wld_loadpcxData(fp, imageSize, (uint8_t*)buffer); wld_loadpcxData(fp, imageSize, (uint8_t *) buffer);
/* Allocate space to hold the PCX palette */ /* Allocate space to hold the PCX palette */
palette = (RGBColor*)wld_malloc(sizeof(RGBColor) * 256); palette = (RGBColor *) wld_malloc(sizeof(RGBColor) * 256);
/* Load the PCX palette */ /* Load the PCX palette */
@ -176,14 +179,14 @@ graphic_file_t *wld_loadpcx(FILE *fp, char *filename)
* Description: * Description:
************************************************************************/ ************************************************************************/
static void wld_loadpcxHeader(FILE *fp, pcxHeader *header) static void wld_loadpcxHeader(FILE * fp, pcxHeader * header)
{ {
uint8_t *tempBuffer; uint8_t *tempBuffer;
int i; int i;
/* Load the header */ /* Load the header */
tempBuffer = (uint8_t*)header; tempBuffer = (uint8_t *) header;
for (i = 0; i < SIZEOF_PCX_HEADER; i++) for (i = 0; i < SIZEOF_PCX_HEADER; i++)
{ {
@ -196,14 +199,14 @@ static void wld_loadpcxHeader(FILE *fp, pcxHeader *header)
* Description: * Description:
************************************************************************/ ************************************************************************/
static void wld_loadpcxData(FILE *fp, int32_t imageSize, uint8_t *imageBuffer) static void wld_loadpcxData(FILE * fp, int32_t imageSize, uint8_t * imageBuffer)
{ {
uint32_t count; uint32_t count;
int16_t numBytes; int16_t numBytes;
uint8_t data; uint8_t data;
count = 0; count = 0;
while(count <= imageSize) while (count <= imageSize)
{ {
/* Get the first piece of data */ /* Get the first piece of data */
@ -211,7 +214,7 @@ static void wld_loadpcxData(FILE *fp, int32_t imageSize, uint8_t *imageBuffer)
/* Is this a run length encoding? */ /* Is this a run length encoding? */
if ((data >= 192) /* && (data <= 255) */) if ((data >= 192) /* && (data <= 255) */ )
{ {
/* How many bytes in run? */ /* How many bytes in run? */
@ -219,11 +222,11 @@ static void wld_loadpcxData(FILE *fp, int32_t imageSize, uint8_t *imageBuffer)
/* Get the actual data for the run */ /* Get the actual data for the run */
data = getc(fp); data = getc(fp);
/* Replicate data in buffer numBytes times */ /* Replicate data in buffer numBytes times */
while(numBytes-- > 0) while (numBytes-- > 0)
{ {
imageBuffer[count++] = data; imageBuffer[count++] = data;
} }
@ -242,7 +245,7 @@ static void wld_loadpcxData(FILE *fp, int32_t imageSize, uint8_t *imageBuffer)
* Description: * Description:
************************************************************************/ ************************************************************************/
static void wld_loadpcxPalette(FILE *fp, RGBColor *palette) static void wld_loadpcxPalette(FILE * fp, RGBColor * palette)
{ {
int i; int i;
@ -257,13 +260,13 @@ static void wld_loadpcxPalette(FILE *fp, RGBColor *palette)
/* Get the RGB components */ /* Get the RGB components */
#if MSWINDOWS #if MSWINDOWS
palette[i].red = (getc(fp) >> 2); palette[i].red = (getc(fp) >> 2);
palette[i].green = (getc(fp) >> 2); palette[i].green = (getc(fp) >> 2);
palette[i].blue = (getc(fp) >> 2); palette[i].blue = (getc(fp) >> 2);
#else #else
palette[i].red = getc(fp); palette[i].red = getc(fp);
palette[i].green = getc(fp); palette[i].green = getc(fp);
palette[i].blue = getc(fp); palette[i].blue = getc(fp);
#endif #endif
} }
} }

2
graphics/traveler/tools/libwld/wld_loadplanefile.c
View File

@ -57,7 +57,7 @@
uint8_t wld_load_planefile(const char *wldFile) uint8_t wld_load_planefile(const char *wldFile)
{ {
FILE *fp; FILE *fp;
uint8_t result; uint8_t result;
/* Open the map file which contains the description of the world */ /* Open the map file which contains the description of the world */

26
graphics/traveler/tools/libwld/wld_loadplanes.c
View File

@ -46,14 +46,14 @@
* Private Functions * Private Functions
*************************************************************************/ *************************************************************************/
/************************************************************************* /*************************************************************************
* Name: wld_LoadWorldPlane * Name: wld_load_worldplane
* Description: * Description:
* This function loads the world data for one plane * This function loads the world data for one plane
************************************************************************/ ************************************************************************/
static uint8_t wld_LoadWorldPlane(FILE *fp, rect_head_t *list, uint8_t numRects) static uint8_t wld_load_worldplane(FILE * fp, rect_head_t * list,
uint8_t numRects)
{ {
rect_list_t *rect; rect_list_t *rect;
int i; int i;
@ -63,16 +63,18 @@ static uint8_t wld_LoadWorldPlane(FILE *fp, rect_head_t *list, uint8_t numRects)
/* Allocate space for the next rectangle */ /* Allocate space for the next rectangle */
rect = wld_new_plane(); rect = wld_new_plane();
if (!rect) return PLANE_ALLOCATION_FAILURE; if (!rect)
{
return PLANE_ALLOCATION_FAILURE;
}
/* Read the next rectangle from the input file */ /* Read the next rectangle from the input file */
if (fread((char*)&rect->d, SIZEOF_RECTDATATYPE, 1, fp) != 1) if (fread((char *)&rect->d, SIZEOF_RECTDATATYPE, 1, fp) != 1)
{ {
fprintf(stderr, "Error: read of rectangle %d (of %d) failed! ", fprintf(stderr, "Error: read of rectangle %d (of %d) failed! ",
i, numRects); i, numRects);
fprintf(stderr, "feof=%d ferror=%d\n", fprintf(stderr, "feof=%d ferror=%d\n", feof(fp), ferror(fp));
feof(fp), ferror(fp));
return PLANE_DATA_READ_ERROR; return PLANE_DATA_READ_ERROR;
} }
@ -94,23 +96,23 @@ static uint8_t wld_LoadWorldPlane(FILE *fp, rect_head_t *list, uint8_t numRects)
* This function loads the world data from the opened file * This function loads the world data from the opened file
************************************************************************/ ************************************************************************/
uint8_t wld_load_planes(FILE *fp) uint8_t wld_load_planes(FILE * fp)
{ {
plane_file_header_t fileHeader; plane_file_header_t fileHeader;
uint8_t result; uint8_t result;
/* Read the plane file header */ /* Read the plane file header */
if (fread((char*)&fileHeader, SIZEOF_PLANEFILEHEADERTYPE, 1, fp) != 1) if (fread((char *)&fileHeader, SIZEOF_PLANEFILEHEADERTYPE, 1, fp) != 1)
return PLANE_HEADER_READ_ERROR; return PLANE_HEADER_READ_ERROR;
/* Then load each grid, performing run length (rle) decoding */ /* Then load each grid, performing run length (rle) decoding */
result = wld_LoadWorldPlane(fp, &xPlane, fileHeader.numXRects); result = wld_load_worldplane(fp, &g_xplane_list, fileHeader.numXRects);
if (!result) if (!result)
result = wld_LoadWorldPlane(fp, &yPlane, fileHeader.numYRects); result = wld_load_worldplane(fp, &g_yplane_list, fileHeader.numYRects);
if (!result) if (!result)
result = wld_LoadWorldPlane(fp, &zPlane, fileHeader.numZRects); result = wld_load_worldplane(fp, &g_zplane_list, fileHeader.numZRects);
return result; return result;
} }

7
graphics/traveler/tools/libwld/wld_loadppm.c
View File

@ -47,7 +47,6 @@
#include "wld_graphicfile.h" #include "wld_graphicfile.h"
#include "wld_utils.h" #include "wld_utils.h"
/************************************************************************* /*************************************************************************
* Private Functions * Private Functions
*************************************************************************/ *************************************************************************/
@ -58,7 +57,7 @@
* Skip white space and comments. * Skip white space and comments.
************************************************************************/ ************************************************************************/
static void skip_cruft(FILE *fp) static void skip_cruft(FILE * fp)
{ {
int c; int c;
@ -97,7 +96,7 @@ static void skip_cruft(FILE *fp)
* Description: * Description:
************************************************************************/ ************************************************************************/
graphic_file_t *wld_LoadPPM(FILE *fp, char *filename) graphic_file_t *wld_LoadPPM(FILE * fp, char *filename)
{ {
int width, height; int width, height;
int unknown; int unknown;
@ -132,7 +131,7 @@ graphic_file_t *wld_LoadPPM(FILE *fp, char *filename)
gfile->palette = NULL; gfile->palette = NULL;
gfile->width = width; gfile->width = width;
gfile->height = height; gfile->height = height;
gfile->bitmap = (uint8_t*)wld_malloc(height * width * 3); gfile->bitmap = (uint8_t *) wld_malloc(height * width * 3);
if (fread(gfile->bitmap, height * width * 3, 1, fp) != 1) if (fread(gfile->bitmap, height * width * 3, 1, fp) != 1)
{ {

262
graphics/traveler/tools/libwld/wld_lum2pixel.c
View File

@ -53,42 +53,42 @@
****************************************************************************/ ****************************************************************************/
#if RGB_CUBE_SIZE < MIN_LUM_LEVELS #if RGB_CUBE_SIZE < MIN_LUM_LEVELS
static uint8_t wld_lum2formtype(color_form_t *lum) static uint8_t wld_lum2formtype(color_form_t * lum)
{ {
float factor1; float factor1;
float factor2; float factor2;
float factor3; float factor3;
float error; float error;
float lse; float lse;
uint8_t formno; uint8_t formno;
int i; int i;
/* Initialize for the search */ /* Initialize for the search */
factor1 = g_wld_colorform[0].max - lum->max; factor1 = g_wld_colorform[0].max - lum->max;
factor2 = g_wld_colorform[0].mid - lum->mid; factor2 = g_wld_colorform[0].mid - lum->mid;
factor3 = g_wld_colorform[0].min - lum->min; factor3 = g_wld_colorform[0].min - lum->min;
lse = factor1*factor1 + factor2*factor2 + factor3*factor3; lse = factor1 * factor1 + factor2 * factor2 + factor3 * factor3;
formno = 0; formno = 0;
/* Now, search the rest of the table, keeping the form with least /* Now, search the rest of the table, keeping the form with least squared
* squared error value * error value
*/ */
for (i = 1; i < NCOLOR_FORMS; i++) for (i = 1; i < NCOLOR_FORMS; i++)
{ {
factor1 = g_wld_colorform[i].max - lum->max; factor1 = g_wld_colorform[i].max - lum->max;
factor2 = g_wld_colorform[i].mid - lum->mid; factor2 = g_wld_colorform[i].mid - lum->mid;
factor3 = g_wld_colorform[i].min - lum->min; factor3 = g_wld_colorform[i].min - lum->min;
error = factor1*factor1 + factor2*factor2 + factor3*factor3; error = factor1 * factor1 + factor2 * factor2 + factor3 * factor3;
if (error < lse) if (error < lse)
{ {
lse = error; lse = error;
formno = i; formno = i;
} }
} }
return formno; return formno;
} }
#endif #endif
@ -102,87 +102,87 @@ static uint8_t wld_lum2formtype(color_form_t *lum)
****************************************************************************/ ****************************************************************************/
#if RGB_CUBE_SIZE < MIN_LUM_LEVELS #if RGB_CUBE_SIZE < MIN_LUM_LEVELS
static enum unit_vector_index_e wld_lum2colorform(color_lum_t *lum) static enum unit_vector_index_e wld_lum2colorform(color_lum_t * lum)
{ {
color_form_t orderedLum; color_form_t orderedLum;
enum unit_vector_index_e uvndx; enum unit_vector_index_e uvndx;
/* Get an ordered representation of the luminance value */ /* Get an ordered representation of the luminance value */
if (lum->red >= lum->green) if (lum->red >= lum->green)
{ {
if (lum->red >= lum->blue) if (lum->red >= lum->blue)
{ {
/* RED >= GREEN && RED >= BLUE */ /* RED >= GREEN && RED >= BLUE */
if (lum->green >= lum->blue) if (lum->green >= lum->blue)
{ {
/* RED >= GREEN >= BLUE */ /* RED >= GREEN >= BLUE */
orderedLum.max = lum->red; orderedLum.max = lum->red;
orderedLum.mid = lum->green; orderedLum.mid = lum->green;
orderedLum.min = lum->blue; orderedLum.min = lum->blue;
uvndx = g_wld_rgbform_map[wld_lum2formtype(&orderedLum)]; uvndx = g_wld_rgbform_map[wld_lum2formtype(&orderedLum)];
} }
else else
{ {
/* RED >= BLUE > GREEN */ /* RED >= BLUE > GREEN */
orderedLum.max = lum->red; orderedLum.max = lum->red;
orderedLum.mid = lum->blue; orderedLum.mid = lum->blue;
orderedLum.min = lum->green; orderedLum.min = lum->green;
uvndx = g_wld_rbgform_map[wld_lum2formtype(&orderedLum)]; uvndx = g_wld_rbgform_map[wld_lum2formtype(&orderedLum)];
} }
} }
else else
{ {
/* BLUE > RED >= GREEN */ /* BLUE > RED >= GREEN */
orderedLum.max = lum->blue; orderedLum.max = lum->blue;
orderedLum.mid = lum->red; orderedLum.mid = lum->red;
orderedLum.min = lum->green; orderedLum.min = lum->green;
uvndx = g_wld_brgform_map[wld_lum2formtype(&orderedLum)]; uvndx = g_wld_brgform_map[wld_lum2formtype(&orderedLum)];
} }
} }
else else
{ {
/* lum->red < lum->green) */ /* lum->red < lum->green) */
if (lum->green >= lum->blue) if (lum->green >= lum->blue)
{ {
/* GREEN > RED && GREEN >= BLUE */ /* GREEN > RED && GREEN >= BLUE */
if (lum->red >= lum->blue) if (lum->red >= lum->blue)
{ {
/* GREEN > RED >= BLUE */ /* GREEN > RED >= BLUE */
orderedLum.max = lum->green; orderedLum.max = lum->green;
orderedLum.mid = lum->red; orderedLum.mid = lum->red;
orderedLum.min = lum->blue; orderedLum.min = lum->blue;
uvndx = g_wld_grbform_map[wld_lum2formtype(&orderedLum)]; uvndx = g_wld_grbform_map[wld_lum2formtype(&orderedLum)];
} }
else else
{ {
/* GREEN >= BLUE > RED*/ /* GREEN >= BLUE > RED */
orderedLum.max = lum->green; orderedLum.max = lum->green;
orderedLum.mid = lum->blue; orderedLum.mid = lum->blue;
orderedLum.min = lum->red; orderedLum.min = lum->red;
uvndx = g_wld_gbrform_map[wld_lum2formtype(&orderedLum)]; uvndx = g_wld_gbrform_map[wld_lum2formtype(&orderedLum)];
} }
} }
else else
{ {
/* BLUE > GREEN > RED */ /* BLUE > GREEN > RED */
orderedLum.max = lum->blue; orderedLum.max = lum->blue;
orderedLum.mid = lum->green; orderedLum.mid = lum->green;
orderedLum.min = lum->red; orderedLum.min = lum->red;
uvndx = g_wld_bgrform_map[wld_lum2formtype(&orderedLum)]; uvndx = g_wld_bgrform_map[wld_lum2formtype(&orderedLum)];
} }
} }
return uvndx; return uvndx;
} }
#endif #endif
@ -191,51 +191,51 @@ static enum unit_vector_index_e wld_lum2colorform(color_lum_t *lum)
* Description: Convert an RGB-Luminance value into a pixel * Description: Convert an RGB-Luminance value into a pixel
****************************************************************************/ ****************************************************************************/
wld_pixel_t wld_color_lum2pixel(color_lum_t *lum) wld_pixel_t wld_color_lum2pixel(color_lum_t * lum)
{ {
#if RGB_CUBE_SIZE < MIN_LUM_LEVELS #if RGB_CUBE_SIZE < MIN_LUM_LEVELS
enum unit_vector_index_e uvndx; enum unit_vector_index_e uvndx;
uint8_t lumndx; uint8_t lumndx;
/* Get the g_unit_vector array index associated with this lum */ /* Get the g_unit_vector array index associated with this lum */
uvndx = wld_lum2colorform(lum); uvndx = wld_lum2colorform(lum);
/* Get the luminance number associated with this lum at this index /* Get the luminance number associated with this lum at this index Make sure
* Make sure that the requested luminance does not exceed the maximum * that the requested luminance does not exceed the maximum allowed for this
* allowed for this unit vector. * unit vector.
*/ */
if (lum->luminance >= g_unit_vector[uvndx].luminance) if (lum->luminance >= g_unit_vector[uvndx].luminance)
{ {
lumndx = (NLUMINANCES-1); lumndx = (NLUMINANCES - 1);
} }
else else
{ {
lumndx = (uint8_t)((float)NLUMINANCES lumndx = (uint8_t) ((float)NLUMINANCES
* lum->luminance / g_unit_vector[uvndx].luminance); * lum->luminance / g_unit_vector[uvndx].luminance);
if (lumndx > 0) if (lumndx > 0)
{ {
lumndx--; lumndx--;
} }
} }
/* Now get the pixel value from the unit vector index and the luminance /* Now get the pixel value from the unit vector index and the luminance
* number. We will probably have to expand this later from the 8-bit * number. We will probably have to expand this later from the 8-bit index
* index to a wider representation. * to a wider representation.
*/ */
return TRV_UVLUM2NDX(uvndx, lumndx); return TRV_UVLUM2NDX(uvndx, lumndx);
#else #else
color_rgb_t rgb; color_rgb_t rgb;
/* Convert the luminance value to its RGB components */ /* Convert the luminance value to its RGB components */
rgb.red = lum->red * lum->luminance; rgb.red = lum->red * lum->luminance;
rgb.green = lum->green * lum->luminance; rgb.green = lum->green * lum->luminance;
rgb.blue = lum->blue * lum->luminance; rgb.blue = lum->blue * lum->luminance;
return wld_rgb2pixel(&rgb); return wld_rgb2pixel(&rgb);
#endif #endif
} }

1
graphics/traveler/tools/libwld/wld_malloc.c
View File

@ -61,5 +61,6 @@ void *wld_malloc(size_t size)
{ {
wld_fatal_error("out of memory (wld_malloc %x bytes)", size); wld_fatal_error("out of memory (wld_malloc %x bytes)", size);
} }
return new; return new;
} }

21
graphics/traveler/tools/libwld/wld_mergeplanelists.c
View File

@ -52,7 +52,7 @@
* This function concatenates two world plane lists * This function concatenates two world plane lists
************************************************************************/ ************************************************************************/
void wld_merge_planelists(rect_head_t *outList, rect_head_t *inList) void wld_merge_planelists(rect_head_t * outList, rect_head_t * inList)
{ {
rect_list_t *inRect, *nextInRect; rect_list_t *inRect, *nextInRect;
rect_list_t *outRect, *prevRect; rect_list_t *outRect, *prevRect;
@ -67,30 +67,27 @@ void wld_merge_planelists(rect_head_t *outList, rect_head_t *inList)
{ {
nextInRect = inRect->flink; nextInRect = inRect->flink;
/* Search the output plane list to find the location to insert the /* Search the output plane list to find the location to insert the input
* input rectangle. Each is list is maintained in ascending plane * rectangle. Each is list is maintained in ascending plane order.
* order.
*/ */
for (; for (;
((outRect) && (outRect->d.plane < inRect->d.plane)); ((outRect) && (outRect->d.plane < inRect->d.plane));
outRect = outRect->flink); outRect = outRect->flink);
/* Add the inRect to the spot found in the list. Check if the /* Add the inRect to the spot found in the list. Check if the inRect
* inRect goes at the one of the ends of the list. * goes at the one of the ends of the list. */
*/
if (!outRect) if (!outRect)
{ {
/* No rectangle with plane larger than the one to be added /* No rectangle with plane larger than the one to be added was found
* was found in the list. The inRect goes at the end of * in the list. The inRect goes at the end of the list.
* the list.
*/ */
prevRect = outList->tail; prevRect = outList->tail;
if (!prevRect) if (!prevRect)
{ {
/* Special case: The list is empty */ /* Special case: The list is empty */
inRect->flink = NULL; inRect->flink = NULL;
inRect->blink = NULL; inRect->blink = NULL;
@ -112,7 +109,7 @@ void wld_merge_planelists(rect_head_t *outList, rect_head_t *inList)
prevRect = outRect->blink; prevRect = outRect->blink;
if (!prevRect) if (!prevRect)
{ {
/* Special case: Insert at the head of the list */ /* Special case: Insert at the head of the list */
inRect->flink = outRect; inRect->flink = outRect;
inRect->blink = NULL; inRect->blink = NULL;

20
graphics/traveler/tools/libwld/wld_moveplane.c
View File

@ -54,22 +54,30 @@
* then adds it to the world plane destList * then adds it to the world plane destList
************************************************************************/ ************************************************************************/
void wld_move_plane(rect_list_t *rect, rect_head_t *destList, void wld_move_plane(rect_list_t * rect, rect_head_t * destList,
rect_head_t *srcList) rect_head_t * srcList)
{ {
/* Un-hook the backward link to the rect */ /* Un-hook the backward link to the rect */
if (rect->flink) if (rect->flink)
rect->flink->blink = rect->blink; {
rect->flink->blink = rect->blink;
}
else else
srcList->tail = rect->blink; {
srcList->tail = rect->blink;
}
/* Un-hook the forward link to the rect */ /* Un-hook the forward link to the rect */
if (rect->blink) if (rect->blink)
rect->blink->flink = rect->flink; {
rect->blink->flink = rect->flink;
}
else else
srcList->head = rect->flink; {
srcList->head = rect->flink;
}
/* Then add the rect to the specified list */ /* Then add the rect to the specified list */

6
graphics/traveler/tools/libwld/wld_newgraphicfile.c
View File

@ -47,13 +47,13 @@
*************************************************************************/ *************************************************************************/
/************************************************************************* /*************************************************************************
* Name: * Name: wld_new_graphicfile
* Description: * Description:
************************************************************************/ ************************************************************************/
graphic_file_t *wld_new_graphicfile( void ) graphic_file_t *wld_new_graphicfile(void)
{ {
graphic_file_t *gf = (graphic_file_t*)wld_malloc(sizeof(graphic_file_t)); graphic_file_t *gf = (graphic_file_t *) wld_malloc(sizeof(graphic_file_t));
gf->transparent_entry = -1; gf->transparent_entry = -1;

2
graphics/traveler/tools/libwld/wld_newplane.c
View File

@ -70,7 +70,7 @@ rect_list_t *wld_new_plane(void)
{ {
/* Nothing on the free list. Allocate a new one */ /* Nothing on the free list. Allocate a new one */
rect = (rect_list_t*)wld_malloc(sizeof(rect_list_t)); rect = (rect_list_t *) wld_malloc(sizeof(rect_list_t));
} }
return rect; return rect;

24
graphics/traveler/tools/libwld/wld_pcxinit.c
View File

@ -40,11 +40,11 @@
* Included files * Included files
*************************************************************************/ *************************************************************************/
#include <stdio.h> # include <stdio.h>
#include <malloc.h> # include <malloc.h>
#include "trv_types.h" # include "trv_types.h"
#include "wld_mem.h" # include "wld_mem.h"
#include "wld_pcx.h" # include "wld_pcx.h"
/************************************************************************* /*************************************************************************
* Public Functions * Public Functions
@ -56,28 +56,28 @@
* This function allocates the buffer region needed to load a pcx file * This function allocates the buffer region needed to load a pcx file
************************************************************************/ ************************************************************************/
uint8_t wld_pcx_init(pcxPicturePtr image, uint16_t height, uint16_t width, uint8_t wld_pcx_init(pcxPicturePtr image, uint16_t height, uint16_t width,
RGBColor *palette, uint8_t *buffer) RGBColor * palette, uint8_t * buffer)
{ {
image->palette = palette; image->palette = palette;
if (buffer) if (buffer)
{ {
image->buffer = buffer; image->buffer = buffer;
} }
else else
{ {
image->buffer = (uint8_t*)wld_malloc(height * width + 1); image->buffer = (uint8_t *) wld_malloc(height * width + 1);
} }
if (!image->buffer) if (!image->buffer)
{ {
return PCX_ALLOCATION_FAILURE; return PCX_ALLOCATION_FAILURE;
} }
else else
{ {
return PCX_SUCCESS; return PCX_SUCCESS;
} }
} }
#endif /* MSWINDOWS */ #endif /* MSWINDOWS */

23
graphics/traveler/tools/libwld/wld_pixel2lum.c
View File

@ -49,14 +49,14 @@
* Private Data * Private Data
*************************************************************************/ *************************************************************************/
static float g_cube2pixel = (float)TRV_PIXEL_MAX / (float)(RGB_CUBE_SIZE-1); static float g_cube2pixel = (float)TRV_PIXEL_MAX / (float)(RGB_CUBE_SIZE - 1);
/************************************************************************* /*************************************************************************
* Function: wld_pixel2lum * Function: wld_pixel2lum
* Description: Convert a pixel value into RGB-Luminance value. * Description: Convert a pixel value into RGB-Luminance value.
************************************************************************/ ************************************************************************/
void wld_pixel2lum(trv_pixel_t pixel_value, color_lum_t *lum) void wld_pixel2lum(trv_pixel_t pixel_value, color_lum_t * lum)
{ {
dev_pixel_t devpixel = g_devpixel_lut[pixel_value]; dev_pixel_t devpixel = g_devpixel_lut[pixel_value];
@ -68,16 +68,15 @@ void wld_pixel2lum(trv_pixel_t pixel_value, color_lum_t *lum)
/* Get the luminance associated with the RGB value */ /* Get the luminance associated with the RGB value */
lum->luminance = sqrt(lum->red * lum->red + lum->luminance = sqrt(lum->red * lum->red +
lum->green * lum->green + lum->green * lum->green + lum->blue * lum->blue);
lum->blue * lum->blue);
/* Convert the RGB Component into unit vector + luminance */ /* Convert the RGB Component into unit vector + luminance */
if (lum->luminance > 0.0) if (lum->luminance > 0.0)
{ {
lum->red /= lum->luminance; lum->red /= lum->luminance;
lum->blue /= lum->luminance; lum->blue /= lum->luminance;
lum->green /= lum->luminance; lum->green /= lum->luminance;
} }
} }

7
graphics/traveler/tools/libwld/wld_plane.c
View File

@ -51,12 +51,11 @@
* for each of the X, Y, and Z planes. * for each of the X, Y, and Z planes.
*/ */
rect_head_t xPlane; /* list of X=plane rectangles */ rect_head_t g_xplane_list; /* list of X=plane rectangles */
rect_head_t yPlane; /* list of Y=plane rectangles */ rect_head_t g_yplane_list; /* list of Y=plane rectangles */
rect_head_t zPlane; /* list of Z=plane rectangles */ rect_head_t g_zplane_list; /* list of Z=plane rectangles */
rect_list_t *freeList; rect_list_t *freeList;
/************************************************************************* /*************************************************************************
* Private Variables * Private Variables
*************************************************************************/ *************************************************************************/

6
graphics/traveler/tools/libwld/wld_plane.h
View File

@ -150,9 +150,9 @@ typedef struct
* for each of the X, Y, and Z planes. * for each of the X, Y, and Z planes.
*/ */
extern rect_head_t xPlane; /* list of X=plane rectangles */ extern rect_head_t g_xplane_list; /* list of X=plane rectangles */
extern rect_head_t yPlane; /* list of Y=plane rectangles */ extern rect_head_t g_yplane_list; /* list of Y=plane rectangles */
extern rect_head_t zPlane; /* list of Z=plane rectangles */ extern rect_head_t g_zplane_list; /* list of Z=plane rectangles */
/* This is the maximum value of a texture code */ /* This is the maximum value of a texture code */

20
graphics/traveler/tools/libwld/wld_readdecimal.c
View File

@ -53,17 +53,20 @@
* Read a decimal number from the steam fp * Read a decimal number from the steam fp
************************************************************************/ ************************************************************************/
int16_t wld_read_decimal(FILE *fp) int16_t wld_read_decimal(FILE * fp)
{ {
int16_t value = 0; int16_t value = 0;
bool negative = false; bool negative = false;
int ch; int ch;
/* Skip over any leading spaces, new lines, or carriage returns (for /* Skip over any leading spaces, new lines, or carriage returns (for MSDOS
* MSDOS compatibility) * compatibility)
*/ */
do ch = getc(fp); do
{
ch = getc(fp);
}
while ((ch == ' ') || (ch == '\n') || (ch == '\r')); while ((ch == ' ') || (ch == '\n') || (ch == '\r'));
/* if the first character is '-', then its a negative number */ /* if the first character is '-', then its a negative number */
@ -78,13 +81,16 @@ int16_t wld_read_decimal(FILE *fp)
while ((ch >= '0') && (ch <= '9')) while ((ch >= '0') && (ch <= '9'))
{ {
value = 10*value + (ch - (int)'0'); value = 10 * value + (ch - (int)'0');
ch = getc(fp); ch = getc(fp);
} }
/* Apply the negation, if appropriate */ /* Apply the negation, if appropriate */
if (negative) value = -value; if (negative)
{
value = -value;
}
return value; return value;
} }

19
graphics/traveler/tools/libwld/wld_readgraphicfile.c
View File

@ -47,8 +47,8 @@
#include "wld_pcx.h" #include "wld_pcx.h"
#include "wld_utils.h" #include "wld_utils.h"
graphic_file_t *wld_LoadPPM(FILE *fp, char *filename); graphic_file_t *wld_LoadPPM(FILE * fp, char *filename);
graphic_file_t *wld_LoadGIF(FILE *fp, char *filename); graphic_file_t *wld_LoadGIF(FILE * fp, char *filename);
/************************************************************************* /*************************************************************************
* Private Data * Private Data
@ -65,7 +65,7 @@ static const char pcxExtension[] = ".PCX";
* Description: * Description:
************************************************************************/ ************************************************************************/
static graphic_file_format_t wld_CheckFormat(FILE *fp, char *filename) static graphic_file_format_t wld_CheckFormat(FILE * fp, char *filename)
{ {
char magic[MAGIC_LENGTH]; char magic[MAGIC_LENGTH];
@ -74,7 +74,7 @@ static graphic_file_format_t wld_CheckFormat(FILE *fp, char *filename)
wld_fatal_error("Error reading texture %s.", filename); wld_fatal_error("Error reading texture %s.", filename);
} }
if (strncmp(magic, PPM_MAGIC, sizeof(PPM_MAGIC) - 1) == 0) if (strncmp(magic, PPM_MAGIC, sizeof(PPM_MAGIC) - 1) == 0)
{ {
return formatPPM; return formatPPM;
} }
@ -101,7 +101,7 @@ static graphic_file_format_t wld_CheckFormat(FILE *fp, char *filename)
/* Check if the extension matches */ /* Check if the extension matches */
for (ptr2 = (char*)pcxExtension; ((*ptr1) && (*ptr2)); ptr1++, ptr2++) for (ptr2 = (char *)pcxExtension; ((*ptr1) && (*ptr2)); ptr1++, ptr2++)
{ {
if (toupper((int)*ptr1) != *ptr2) if (toupper((int)*ptr1) != *ptr2)
{ {
@ -109,17 +109,17 @@ static graphic_file_format_t wld_CheckFormat(FILE *fp, char *filename)
} }
} }
/* If it is an exact match, both pointers should refer to the /* If it is an exact match, both pointers should refer to the NULL
* NULL terminator. * terminator.
*/ */
if (!(*ptr1) && !(*ptr2)) if (!(*ptr1) && !(*ptr2))
{ {
return formatPCX; return formatPCX;
} }
} }
return formatUnknown; return formatUnknown;
} }
/************************************************************************* /*************************************************************************
@ -177,4 +177,3 @@ graphic_file_t *wld_readgraphic_file(char *filename)
fclose(fp); fclose(fp);
return gfile; return gfile;
} }

42
graphics/traveler/tools/libwld/wld_readtexturefile.c
View File

@ -75,16 +75,24 @@ static int wld_log2(int x)
unsigned int n; unsigned int n;
if (x <= 0) if (x <= 0)
return -1; {
return -1;
}
else else
n = (unsigned int) x; {
n = (unsigned int)x;
}
for (i = 0; (n & 0x1) == 0; i++, n >>= 1); for (i = 0; (n & 0x1) == 0; i++, n >>= 1);
if (n == 1) if (n == 1)
return i; {
return i;
}
else else
return -1; {
return -1;
}
} }
/************************************************************************* /*************************************************************************
@ -92,15 +100,17 @@ static int wld_log2(int x)
* Description: * Description:
************************************************************************/ ************************************************************************/
static wld_bitmap_t *wld_new_texture(uint16_t width, uint16_t height) static wld_bitmap_t *wld_new_texture(uint16_t width, uint16_t height)
{ {
wld_bitmap_t *t; wld_bitmap_t *t;
if (height <= 0 || width <= 0) if (height <= 0 || width <= 0)
wld_fatal_error("wld_new_texture: bad texture dimensions"); {
wld_fatal_error("wld_new_texture: bad texture dimensions");
}
t = (wld_bitmap_t*)wld_malloc(sizeof(wld_bitmap_t)); t = (wld_bitmap_t *) wld_malloc(sizeof(wld_bitmap_t));
t->bm = (trv_pixel_t*)wld_malloc(height * width * sizeof(trv_pixel_t)); t->bm = (trv_pixel_t *) wld_malloc(height * width * sizeof(trv_pixel_t));
t->w = width; t->w = width;
t->h = height; t->h = height;
@ -114,7 +124,7 @@ static wld_bitmap_t *wld_new_texture(uint16_t width, uint16_t height)
* Description: * Description:
************************************************************************/ ************************************************************************/
static void wld_quantize_texture(graphic_file_t *gFile, wld_bitmap_t *t) static void wld_quantize_texture(graphic_file_t * gFile, wld_bitmap_t * t)
{ {
RGBColor pixel; RGBColor pixel;
trv_pixel_t *destPixel = t->bm; trv_pixel_t *destPixel = t->bm;
@ -146,15 +156,17 @@ wld_bitmap_t *wld_read_texturefile(char *filename)
gFile = wld_readgraphic_file(filename); gFile = wld_readgraphic_file(filename);
if (gFile == NULL) if (gFile == NULL)
wld_fatal_error("Error reading texture %s.", filename); {
wld_fatal_error("Error reading texture %s.", filename);
}
/* The height and width should be powers of two for efficient /* The height and width should be powers of two for efficient texture
* texture mapping. Here, we enforce this. * mapping. Here, we enforce this. */
*/
if (wld_log2(gFile->width) == -1 || wld_log2(gFile->height) == -1) if (wld_log2(gFile->width) == -1 || wld_log2(gFile->height) == -1)
wld_fatal_error("Dimensions texture %s are not powers of two.", {
filename); wld_fatal_error("Dimensions texture %s are not powers of two.", filename);
}
t = wld_new_texture(gFile->width, gFile->height); t = wld_new_texture(gFile->width, gFile->height);
wld_quantize_texture(gFile, t); wld_quantize_texture(gFile, t);

3
graphics/traveler/tools/libwld/wld_realloc.c
View File

@ -61,5 +61,6 @@ void *wld_realloc(void *addr, size_t size)
{ {
wld_fatal_error("out of memory (wtrealloc %x bytes)", size); wld_fatal_error("out of memory (wtrealloc %x bytes)", size);
} }
return new;
return new;
} }

18
graphics/traveler/tools/libwld/wld_removeplane.c
View File

@ -54,21 +54,29 @@
* and "deallocates" it by saving it on the free list * and "deallocates" it by saving it on the free list
************************************************************************/ ************************************************************************/
void wld_remove_plane(rect_list_t *rect, rect_head_t *list) void wld_remove_plane(rect_list_t * rect, rect_head_t * list)
{ {
/* Un-hook the backward link to the rect */ /* Un-hook the backward link to the rect */
if (rect->flink) if (rect->flink)
rect->flink->blink = rect->blink; {
rect->flink->blink = rect->blink;
}
else else
list->tail = rect->blink; {
list->tail = rect->blink;
}
/* Un-hook the forward link to the rect */ /* Un-hook the forward link to the rect */
if (rect->blink) if (rect->blink)
rect->blink->flink = rect->flink; {
rect->blink->flink = rect->flink;
}
else else
list->head = rect->flink; {
list->head = rect->flink;
}
/* Then put the rect on the free list */ /* Then put the rect on the free list */

64
graphics/traveler/tools/libwld/wld_rgb2pixel.c
View File

@ -49,48 +49,48 @@
* TRV_PIXEL_MAX. * TRV_PIXEL_MAX.
****************************************************************************/ ****************************************************************************/
trv_pixel_t wld_rgb2pixel(color_rgb_t *pixel) trv_pixel_t wld_rgb2pixel(color_rgb_t * pixel)
{ {
#if RGB_CUBE_SIZE < MIN_LUM_LEVELS #if RGB_CUBE_SIZE < MIN_LUM_LEVELS
color_lum_t lum; color_lum_t lum;
/* Convert the RGB Value into a luminance value. /* Convert the RGB Value into a luminance value. Get the luminance associated
* Get the luminance associated with the RGB value. * with the RGB value.
*/ */
lum.luminance = sqrt(pixel->red * pixel->red lum.luminance = sqrt(pixel->red * pixel->red
+ pixel->green * pixel->green + pixel->green * pixel->green
+ pixel->blue * pixel->blue); + pixel->blue * pixel->blue);
/* Convert the RGB Component into unit vector + luminance */ /* Convert the RGB Component into unit vector + luminance */
if (lum.luminance > 0.0) if (lum.luminance > 0.0)
{ {
lum.red = (float)pixel->red / lum.luminance; lum.red = (float)pixel->red / lum.luminance;
lum.green = (float)pixel->green / lum.luminance; lum.green = (float)pixel->green / lum.luminance;
lum.blue = (float)pixel->blue / lum.luminance; lum.blue = (float)pixel->blue / lum.luminance;
} }
else else
{ {
lum.red = lum.green = lum.blue = g_unit_vector[GREY_NDX].red; lum.red = lum.green = lum.blue = g_unit_vector[GREY_NDX].red;
} }
return wld_lum2pixel(&lum); return wld_lum2pixel(&lum);
#else #else
trv_pixel_t ret; trv_pixel_t ret;
int red; int red;
int green; int green;
int blue; int blue;
red = MIN((pixel->red * RGB_CUBE_SIZE) / (TRV_PIXEL_MAX + 1), red = MIN((pixel->red * RGB_CUBE_SIZE) / (TRV_PIXEL_MAX + 1),
RGB_CUBE_SIZE - 1); RGB_CUBE_SIZE - 1);
green = MIN((pixel->green * RGB_CUBE_SIZE) / (TRV_PIXEL_MAX + 1), green = MIN((pixel->green * RGB_CUBE_SIZE) / (TRV_PIXEL_MAX + 1),
RGB_CUBE_SIZE - 1); RGB_CUBE_SIZE - 1);
blue = MIN((pixel->blue * RGB_CUBE_SIZE) / (TRV_PIXEL_MAX + 1), blue = MIN((pixel->blue * RGB_CUBE_SIZE) / (TRV_PIXEL_MAX + 1),
RGB_CUBE_SIZE - 1); RGB_CUBE_SIZE - 1);
ret = (red * RGB_CUBE_SIZE + green) * RGB_CUBE_SIZE + blue; ret = (red * RGB_CUBE_SIZE + green) * RGB_CUBE_SIZE + blue;
return ret; return ret;
#endif #endif
} }

113
graphics/traveler/tools/libwld/wld_rgblookup.c
View File

@ -59,6 +59,7 @@
****************************************************************************/ ****************************************************************************/
#if RGB_CUBE_SIZE < MIN_LUM_LEVELS #if RGB_CUBE_SIZE < MIN_LUM_LEVELS
/* These arrays map color forms into g_unit_vector array indices */ /* These arrays map color forms into g_unit_vector array indices */
static const enum unit_vector_index_e g_wld_bgrform_map[NCOLOR_FORMS] = static const enum unit_vector_index_e g_wld_bgrform_map[NCOLOR_FORMS] =
@ -100,42 +101,42 @@ static float g_wld_cube2pixel;
****************************************************************************/ ****************************************************************************/
#if RGB_CUBE_SIZE < MIN_LUM_LEVELS #if RGB_CUBE_SIZE < MIN_LUM_LEVELS
FAR color_lum_t *g_pixel2um_lut; color_lum_t *g_pixel2um_lut;
/* The following defines the "form" of each color in the g_unit_vector array */ /* The following defines the "form" of each color in the g_unit_vector array */
const color_form_t g_wld_colorform[NCOLOR_FORMS] = const color_form_t g_wld_colorform[NCOLOR_FORMS] =
{ {
{ 1.0, 0.0, 0.0 }, {1.0, 0.0, 0.0},
{ 0.875, 0.4841229, 0.0 }, {0.875, 0.4841229, 0.0},
{ 0.7071068, 0.7071068, 0.0 }, {0.7071068, 0.7071068, 0.0},
{ 0.6666667, 0.5270463, 0.5270463 }, {0.6666667, 0.5270463, 0.5270463},
{ 0.5773503, 0.5773503, 0.5773503 } {0.5773503, 0.5773503, 0.5773503}
}; };
/* This array defines each color supported in the luminance model */ /* This array defines each color supported in the luminance model */
const color_lum_t g_unit_vector[NUNIT_VECTORS] = const color_lum_t g_unit_vector[NUNIT_VECTORS] =
{ {
{ 0.5773503, 0.5773503, 0.5773503, 441.672932,}, /* GREY_NDX */ {0.5773503, 0.5773503, 0.5773503, 441.672932,}, /* GREY_NDX */
{ 0.0, 0.0, 1.0, 255.0 }, /* BLUE_NDX */ {0.0, 0.0, 1.0, 255.0}, /* BLUE_NDX */
{ 0.0, 0.4841229, 0.875, 291.428571 }, /* GREENERBLUE_NDX */ {0.0, 0.4841229, 0.875, 291.428571}, /* GREENERBLUE_NDX */
{ 0.0, 0.7071068, 0.7071068, 360.624445 }, /* BLUEGREEN_NDX */ {0.0, 0.7071068, 0.7071068, 360.624445}, /* BLUEGREEN_NDX */
{ 0.4841229, 0.0, 0.875, 291.428571 }, /* BLUEVIOLET_NDX */ {0.4841229, 0.0, 0.875, 291.428571}, /* BLUEVIOLET_NDX */
{ 0.7071068, 0.0, 0.7071068, 360.624445 }, /* VIOLET_NDX */ {0.7071068, 0.0, 0.7071068, 360.624445}, /* VIOLET_NDX */
{ 0.5270463, 0.5270463, 0.6666667, 382.499981 }, /* LIGHTBLUE_NDX */ {0.5270463, 0.5270463, 0.6666667, 382.499981}, /* LIGHTBLUE_NDX */
{ 0.0, 1.0, 0.0, 255.0 }, /* GREEN_NDX */ {0.0, 1.0, 0.0, 255.0}, /* GREEN_NDX */
{ 0.0, 0.875, 0.4841229, 291.428571 }, /* BLUERGREN_NDX */ {0.0, 0.875, 0.4841229, 291.428571}, /* BLUERGREN_NDX */
{ 0.4841229, 0.875, 0.0, 291.428571 }, /* YELLOWGREEN_NDX */ {0.4841229, 0.875, 0.0, 291.428571}, /* YELLOWGREEN_NDX */
{ 0.7071068, 0.7071068, 0.0, 360.624445 }, /* YELLOW_NDX */ {0.7071068, 0.7071068, 0.0, 360.624445}, /* YELLOW_NDX */
{ 0.5270463, 0.6666667, 0.5270463, 382.499981 }, /* LIGHTGREEN_NDX */ {0.5270463, 0.6666667, 0.5270463, 382.499981}, /* LIGHTGREEN_NDX */
{ 1.0, 0.0, 0.0, 255.0 }, /* RED_NDX */ {1.0, 0.0, 0.0, 255.0}, /* RED_NDX */
{ 0.875, 0.0, 0.4841229, 291.428571 }, /* REDVIOLET_NDX */ {0.875, 0.0, 0.4841229, 291.428571}, /* REDVIOLET_NDX */
{ 0.875, 0.4841229, 0.0, 291.428571 }, /* ORANGE_NDX */ {0.875, 0.4841229, 0.0, 291.428571}, /* ORANGE_NDX */
{ 0.6666667, 0.5270463, 0.5270463, 382.499981 }, /* PINK_NDX */ {0.6666667, 0.5270463, 0.5270463, 382.499981}, /* PINK_NDX */
}; };
#endif #endif
@ -159,8 +160,8 @@ void wld_rgblookup_allocate(void)
/* Check if a color lookup table has been allocated */ /* Check if a color lookup table has been allocated */
g_devpixel_lut = (dev_pixel_t*) g_devpixel_lut = (dev_pixel_t *)
wld_malloc(sizeof(dev_pixel_t) * (NUNIT_VECTORS*NLUMINANCES)); wld_malloc(sizeof(dev_pixel_t) * (NUNIT_VECTORS * NLUMINANCES));
if (!g_devpixel_lut) if (!g_devpixel_lut)
{ {
@ -169,12 +170,11 @@ void wld_rgblookup_allocate(void)
lut = g_devpixel_lut; lut = g_devpixel_lut;
/* Save the color information and color lookup table for use in /* Save the color information and color lookup table for use in color mapping
* color mapping below. * below. */
*/
g_pixel2um_lut = (color_lum_t*) g_pixel2um_lut = (color_lum_t *)
wld_malloc(sizeof(color_lum_t) * (NUNIT_VECTORS*NLUMINANCES)); wld_malloc(sizeof(color_lum_t) * (NUNIT_VECTORS * NLUMINANCES));
if (!g_pixel2um_lut) if (!g_pixel2um_lut)
{ {
@ -189,24 +189,22 @@ void wld_rgblookup_allocate(void)
for (lumndx = 0; lumndx < NLUMINANCES; lumndx++) for (lumndx = 0; lumndx < NLUMINANCES; lumndx++)
{ {
color_rgb_t color; color_rgb_t color;
FAR color_lum_t *lum; color_lum_t *lum;
/* Get a convenience pointer to the lookup table entry */ /* Get a convenience pointer to the lookup table entry */
lum = &g_pixel2um_lut[index]; lum = &g_pixel2um_lut[index];
*lum = g_unit_vector[uvndx]; *lum = g_unit_vector[uvndx];
/* Get the luminance associated with this lum for this /* Get the luminance associated with this lum for this unit vector. */
* unit vector.
*/
lum->luminance = (lum->luminance * (float)(lumndx + 1)) / NLUMINANCES; lum->luminance = (lum->luminance * (float)(lumndx + 1)) / NLUMINANCES;
/* Convert to RGB and allocate the color */ /* Convert to RGB and allocate the color */
color.red = (short) (lum->red * lum->luminance); color.red = (short)(lum->red * lum->luminance);
color.green = (short) (lum->green * lum->luminance); color.green = (short)(lum->green * lum->luminance);
color.blue = (short) (lum->blue * lum->luminance); color.blue = (short)(lum->blue * lum->luminance);
/* Save the RGB to pixel lookup data */ /* Save the RGB to pixel lookup data */
@ -221,24 +219,23 @@ void wld_rgblookup_allocate(void)
/* Check if a color lookup table has been allocated */ /* Check if a color lookup table has been allocated */
g_devpixel_lut = (dev_pixel_t*) g_devpixel_lut = (dev_pixel_t *)
wld_malloc(sizeof(dev_pixel_t) * (WLD_PIXEL_MAX+1)); wld_malloc(sizeof(dev_pixel_t) * (WLD_PIXEL_MAX + 1));
if (!g_devpixel_lut) if (!g_devpixel_lut)
{ {
wld_fatal_error("ERROR: Failed to allocate color lookup table\n"); wld_fatal_error("ERROR: Failed to allocate color lookup table\n");
} }
/* Save the color information and color lookup table for use in /* Save the color information and color lookup table for use in subsequent
* subsequent color mapping. * color mapping. */
*/
lut = g_devpixel_lut; lut = g_devpixel_lut;
/* Check if a Pixel-to-RGB color mapping table has been allocated */ /* Check if a Pixel-to-RGB color mapping table has been allocated */
g_devpixel_lut = (color_rgb_t*) g_devpixel_lut = (color_rgb_t *)
wld_malloc(sizeof(color_rgb_t) * (WLD_PIXEL_MAX+1)); wld_malloc(sizeof(color_rgb_t) * (WLD_PIXEL_MAX + 1));
if (!g_devpixel_lut) if (!g_devpixel_lut)
{ {
@ -248,28 +245,26 @@ void wld_rgblookup_allocate(void)
for (index = 0; index <= WLD_PIXEL_MAX; index++) for (index = 0; index <= WLD_PIXEL_MAX; index++)
{ {
g_devpixel_lut[index].red g_devpixel_lut[index].red
= g_devpixel_lut[index].green = g_devpixel_lut[index].green = g_devpixel_lut[index].blue = 0;
= g_devpixel_lut[index].blue = 0;
} }
/* Calculate the cube to trv_pixel_t scale factor. This factor will /* Calculate the cube to trv_pixel_t scale factor. This factor will convert
* convert an RGB component in the range {0..RGB_CUBE_SIZE-1} to * an RGB component in the range {0..RGB_CUBE_SIZE-1} to a value in the range
* a value in the range {0..WLD_PIXEL_MAX}. * {0..WLD_PIXEL_MAX}. */
*/
g_wld_cube2pixel = (float)WLD_PIXEL_MAX / (float)(RGB_CUBE_SIZE-1); g_wld_cube2pixel = (float)WLD_PIXEL_MAX / (float)(RGB_CUBE_SIZE - 1);
/* Allocate each color in the RGB Cube */ /* Allocate each color in the RGB Cube */
for (rgb.red = 0; rgb.red < RGB_CUBE_SIZE; rgb.red++) for (rgb.red = 0; rgb.red < RGB_CUBE_SIZE; rgb.red++)
for (rgb.green = 0; rgb.green < RGB_CUBE_SIZE; rgb.green++) for (rgb.green = 0; rgb.green < RGB_CUBE_SIZE; rgb.green++)
for (rgb.blue = 0; rgb.blue < RGB_CUBE_SIZE; rgb.blue++) for (rgb.blue = 0; rgb.blue < RGB_CUBE_SIZE; rgb.blue++)
{ {
color_rgb_t color; color_rgb_t color;
color.red = (short) (rgb.red * 65535 / (RGB_CUBE_SIZE - 1)); color.red = (short)(rgb.red * 65535 / (RGB_CUBE_SIZE - 1));
color.green = (short) (rgb.green * 65535 / (RGB_CUBE_SIZE - 1)); color.green = (short)(rgb.green * 65535 / (RGB_CUBE_SIZE - 1));
color.blue = (short) (rgb.blue * 65535 / (RGB_CUBE_SIZE - 1)); color.blue = (short)(rgb.blue * 65535 / (RGB_CUBE_SIZE - 1));
/* Save the RGB to pixel lookup data */ /* Save the RGB to pixel lookup data */
@ -278,9 +273,9 @@ void wld_rgblookup_allocate(void)
/* Save the pixel to RGB lookup data */ /* Save the pixel to RGB lookup data */
if (color.pixel <= WLD_PIXEL_MAX) if (color.pixel <= WLD_PIXEL_MAX)
{ {
g_devpixel_lut[color.pixel] = rgb; g_devpixel_lut[color.pixel] = rgb;
} }
} }
#endif #endif
} }

41
graphics/traveler/tools/libwld/wld_saveplanes.c
View File

@ -47,16 +47,15 @@
* Private Functions * Private Functions
*************************************************************************/ *************************************************************************/
/************************************************************************* /*************************************************************************
* Name: wld_CountRectangles * Name: wld_CountRectangles
* Description: * Description:
* This function counts the number of rectangles in one plane * This function counts the number of rectangles in one plane
************************************************************************/ ************************************************************************/
static uint16_t wld_CountRectangles(rect_list_t *rect) static uint16_t wld_CountRectangles(rect_list_t * rect)
{ {
uint16_t count; uint16_t count;
for (count = 0; (rect); count++, rect = rect->flink); for (count = 0; (rect); count++, rect = rect->flink);
return count; return count;
} }
@ -67,7 +66,7 @@ static uint16_t wld_CountRectangles(rect_list_t *rect)
* This function stores the world data for one plane * This function stores the world data for one plane
************************************************************************/ ************************************************************************/
static uint8_t wld_SaveWorldPlane(FILE *fp, rect_list_t *rect) static uint8_t wld_SaveWorldPlane(FILE * fp, rect_list_t * rect)
{ {
/* For each rectangle in the list */ /* For each rectangle in the list */
@ -75,7 +74,7 @@ static uint8_t wld_SaveWorldPlane(FILE *fp, rect_list_t *rect)
{ {
/* Write the rectangle to the output file */ /* Write the rectangle to the output file */
if (fwrite((char*)&rect->d, SIZEOF_RECTDATATYPE, 1, fp) != 1) if (fwrite((char *)&rect->d, SIZEOF_RECTDATATYPE, 1, fp) != 1)
return PLANE_DATA_WRITE_ERROR; return PLANE_DATA_WRITE_ERROR;
} }
@ -94,35 +93,45 @@ static uint8_t wld_SaveWorldPlane(FILE *fp, rect_list_t *rect)
uint8_t wld_save_planes(const char *wldFile) uint8_t wld_save_planes(const char *wldFile)
{ {
FILE *fp; FILE *fp;
plane_file_header_t fileHeader; plane_file_header_t fileHeader;
uint8_t result; uint8_t result;
/* Open the file which contains the description of the world */ /* Open the file which contains the description of the world */
fp = fopen(wldFile, "wb"); fp = fopen(wldFile, "wb");
if (!fp) return PLANE_WRITE_OPEN_ERROR; if (!fp)
{
return PLANE_WRITE_OPEN_ERROR;
}
/* Create world file header */ /* Create world file header */
fileHeader.numXRects = wld_CountRectangles(xPlane.head); fileHeader.numXRects = wld_CountRectangles(g_xplane_list.head);
fileHeader.numYRects = wld_CountRectangles(yPlane.head); fileHeader.numYRects = wld_CountRectangles(g_yplane_list.head);
fileHeader.numZRects = wld_CountRectangles(zPlane.head); fileHeader.numZRects = wld_CountRectangles(g_zplane_list.head);
/* Write the file header to the output file */ /* Write the file header to the output file */
if (fwrite((char*)&fileHeader, SIZEOF_PLANEFILEHEADERTYPE, 1, fp) != 1) if (fwrite((char *)&fileHeader, SIZEOF_PLANEFILEHEADERTYPE, 1, fp) != 1)
result = PLANE_HEADER_WRITE_ERROR; {
result = PLANE_HEADER_WRITE_ERROR;
}
/* Save the world, one plane at a time */ /* Save the world, one plane at a time */
else else
{ {
result = wld_SaveWorldPlane(fp, xPlane.head); result = wld_SaveWorldPlane(fp, g_xplane_list.head);
if (result == PLANE_SUCCESS) if (result == PLANE_SUCCESS)
result = wld_SaveWorldPlane(fp, yPlane.head); {
result = wld_SaveWorldPlane(fp, g_yplane_list.head);
}
if (result == PLANE_SUCCESS) if (result == PLANE_SUCCESS)
wld_SaveWorldPlane(fp, zPlane.head); {
wld_SaveWorldPlane(fp, g_zplane_list.head);
}
} }
/* Close the file */ /* Close the file */

2
graphics/traveler/tools/libwld/wld_world.h
View File

@ -112,7 +112,7 @@ extern wld_coord_t runStepHeight;
* Global Function Prototypes * Global Function Prototypes
*************************************************************************/ *************************************************************************/
uint8_t wld_create_world(FAR char *mapfile); uint8_t wld_create_world(char *mapfile);
void wld_deallocate_world(void); void wld_deallocate_world(void);
#ifdef __cplusplus #ifdef __cplusplus

248
graphics/traveler/tools/tcledit/tcl_edit.c
View File

@ -64,64 +64,68 @@ static const char astDefaultFileName[] = "planes.pll";
* Public Variables * Public Variables
***************************************************************************/ ***************************************************************************/
enum editModeEnum editMode = EDITMODE_NONE; enum editModeEnum editMode = EDITMODE_NONE;
enum editPlaneEnum editPlane = EDITPLANE_X; enum editPlaneEnum editPlane = EDITPLANE_X;
int viewSize = WORLD_INFINITY; int viewSize = WORLD_INFINITY;
int gridStep = WORLD_SIZE / 16; int gridStep = WORLD_SIZE / 16;
int coordOffset[NUM_PLANES]; int coordOffset[NUM_PLANES];
int planePosition[NUM_PLANES]; int planePosition[NUM_PLANES];
tcl_window_t windows[NUM_PLANES] = tcl_window_t windows[NUM_PLANES] =
{ {
{ {
.title = "X-Plane", .title = "X-Plane",
.plane = EDITPLANE_X, .plane = EDITPLANE_X,
.width = WINDOW_SIZE, .width = WINDOW_SIZE,
.height = WINDOW_SIZE, .height = WINDOW_SIZE,
.palette = { .palette =
Lavender, Red, Red, LemonChiffon, {
LightCyan, LightSkyBlue, DeepSkyBlue, LightGray, Lavender, Red, Red, LemonChiffon,
LightCyan, LightSkyBlue, DeepSkyBlue, LightGray,
Lavender, Red, Red, LemonChiffon, Lavender, Red, Red, LemonChiffon,
LightCyan, LightSkyBlue, DeepSkyBlue, LightGray, LightCyan, LightSkyBlue, DeepSkyBlue, LightGray,
LightGray, DarkGray, DarkGray, DarkGray, LightGray, DarkGray, DarkGray, DarkGray,
LightSteelBlue, SlateGray, SlateGray, SteelBlue, LightSteelBlue, SlateGray, SlateGray, SteelBlue,
}, },
}, },
{ {
.title = "Y-Plane", .title = "Y-Plane",
.plane = EDITPLANE_Y, .plane = EDITPLANE_Y,
.width = WINDOW_SIZE, .width = WINDOW_SIZE,
.height = WINDOW_SIZE, .height = WINDOW_SIZE,
.palette = { .palette =
Lavender, Red, Red, LemonChiffon, {
LightCyan, LightSkyBlue, DeepSkyBlue, LightGray, Lavender, Red, Red, LemonChiffon,
LightCyan, LightSkyBlue, DeepSkyBlue, LightGray,
Lavender, Red, Red, LemonChiffon, Lavender, Red, Red, LemonChiffon,
LightCyan, LightSkyBlue, DeepSkyBlue, LightGray, LightCyan, LightSkyBlue, DeepSkyBlue, LightGray,
LightGray, DarkGray, DarkGray, DarkGray, LightGray, DarkGray, DarkGray, DarkGray,
LightSteelBlue, SlateGray, SlateGray, SteelBlue, LightSteelBlue, SlateGray, SlateGray, SteelBlue,
}, },
}, },
{ {
.title = "Z-Plane", .title = "Z-Plane",
.plane = EDITPLANE_Z, .plane = EDITPLANE_Z,
.width = WINDOW_SIZE, .width = WINDOW_SIZE,
.height = WINDOW_SIZE, .height = WINDOW_SIZE,
.palette = { .palette =
Lavender, Red, Red, LemonChiffon, {
LightCyan, LightSkyBlue, DeepSkyBlue, LightGray, Lavender, Red, Red, LemonChiffon,
LightCyan, LightSkyBlue, DeepSkyBlue, LightGray,
Lavender, Red, Red, LemonChiffon, Lavender, Red, Red, LemonChiffon,
LightCyan, LightSkyBlue, DeepSkyBlue, LightGray, LightCyan, LightSkyBlue, DeepSkyBlue, LightGray,
LightGray, DarkGray, DarkGray, DarkGray, LightGray, DarkGray, DarkGray, DarkGray,
LightSteelBlue, SlateGray, SlateGray, SteelBlue, LightSteelBlue, SlateGray, SlateGray, SteelBlue,
}, },
}, }
}; };
rect_data_t editRect; rect_data_t editRect;
/**************************************************************************** /****************************************************************************
@ -166,15 +170,14 @@ static void astUpdateNEWModeDisplay(void)
*/ */
static int astSetEditMode(ClientData clientData, static int astSetEditMode(ClientData clientData,
Tcl_Interp *interp, Tcl_Interp * interp, int argc, const char *argv[])
int argc, const char *argv[])
{ {
ginfo("Processing command: %s\n", argv[0]); ginfo("Processing command: %s\n", argv[0]);
if (argc != 3) if (argc != 3)
{ {
wld_fatal_error("%s: Unexpected number of arguments: %d\n", wld_fatal_error("%s: Unexpected number of arguments: %d\n",
__FUNCTION__, argc); __FUNCTION__, argc);
} }
else if (strcmp(argv[1], "POS") == 0) else if (strcmp(argv[1], "POS") == 0)
{ {
@ -190,60 +193,59 @@ static int astSetEditMode(ClientData clientData,
if (strcmp(argv[2], "x") == 0) if (strcmp(argv[2], "x") == 0)
{ {
ginfo("Entering NEWX mode\n"); ginfo("Entering NEWX mode\n");
editPlane = EDITPLANE_X; editPlane = EDITPLANE_X;
editRect.plane = planePosition[EDITPLANE_X]; editRect.plane = planePosition[EDITPLANE_X];
editRect.hStart = planePosition[EDITPLANE_Y]; editRect.hStart = planePosition[EDITPLANE_Y];
editRect.hEnd = editRect.hStart; editRect.hEnd = editRect.hStart;
editRect.vStart = planePosition[EDITPLANE_Z]; editRect.vStart = planePosition[EDITPLANE_Z];
editRect.vEnd = editRect.vStart; editRect.vEnd = editRect.vStart;
} }
else if (strcmp(argv[2], "y") == 0) else if (strcmp(argv[2], "y") == 0)
{ {
ginfo("Entering NEWY mode\n"); ginfo("Entering NEWY mode\n");
editPlane = EDITPLANE_Y; editPlane = EDITPLANE_Y;
editRect.plane = planePosition[EDITPLANE_Y]; editRect.plane = planePosition[EDITPLANE_Y];
editRect.hStart = planePosition[EDITPLANE_X]; editRect.hStart = planePosition[EDITPLANE_X];
editRect.hEnd = editRect.hStart; editRect.hEnd = editRect.hStart;
editRect.vStart = planePosition[EDITPLANE_Z]; editRect.vStart = planePosition[EDITPLANE_Z];
editRect.vEnd = editRect.vStart; editRect.vEnd = editRect.vStart;
} }
else if (strcmp(argv[2], "z") == 0) else if (strcmp(argv[2], "z") == 0)
{ {
ginfo("Entering NEWZ mode\n"); ginfo("Entering NEWZ mode\n");
editPlane = EDITPLANE_Z; editPlane = EDITPLANE_Z;
editRect.plane = planePosition[EDITPLANE_Z]; editRect.plane = planePosition[EDITPLANE_Z];
editRect.hStart = planePosition[EDITPLANE_X]; editRect.hStart = planePosition[EDITPLANE_X];
editRect.hEnd = editRect.hStart; editRect.hEnd = editRect.hStart;
editRect.vStart = planePosition[EDITPLANE_Y]; editRect.vStart = planePosition[EDITPLANE_Y];
editRect.vEnd = editRect.vStart; editRect.vEnd = editRect.vStart;
} }
else else
{ {
wld_fatal_error("%s: Unrecognized NEW plane: %s\n", wld_fatal_error("%s: Unrecognized NEW plane: %s\n",
__FUNCTION__, argv[2]); __FUNCTION__, argv[2]);
} }
astUpdateNEWModeDisplay(); astUpdateNEWModeDisplay();
} }
else else
{ {
wld_fatal_error("%s: Unrecognized mode: %s\n", wld_fatal_error("%s: Unrecognized mode: %s\n", __FUNCTION__, argv[1]);
__FUNCTION__, argv[1]);
} }
return TCL_OK; return TCL_OK;
} }
/* Called in response to the "ast_position" Tcl command */ /* Called in response to the "ast_position" Tcl command */
static int astNewPosition(ClientData clientData, static int astNewPosition(ClientData clientData,
Tcl_Interp *interp, Tcl_Interp * interp, int argc, const char *argv[])
int argc, const char *argv[])
{ {
ginfo("Processing command: %s\n", argv[0]); ginfo("Processing command: %s\n", argv[0]);
if (argc != 4) if (argc != 4)
{ {
wld_fatal_error("%s: Unexpected number of arguments: %d\n", wld_fatal_error("%s: Unexpected number of arguments: %d\n",
__FUNCTION__, argc); __FUNCTION__, argc);
} }
planePosition[0] = atoi(argv[1]); planePosition[0] = atoi(argv[1]);
@ -251,7 +253,7 @@ static int astNewPosition(ClientData clientData,
planePosition[2] = atoi(argv[3]); planePosition[2] = atoi(argv[3]);
ginfo("New plane positions: {%d,%d,%d}\n", ginfo("New plane positions: {%d,%d,%d}\n",
planePosition[0], planePosition[1], planePosition[2]); planePosition[0], planePosition[1], planePosition[2]);
astUpdatePOSModeDisplay(); astUpdatePOSModeDisplay();
return TCL_OK; return TCL_OK;
@ -260,20 +262,19 @@ static int astNewPosition(ClientData clientData,
/* Called in response to the "ast_zoom" Tcl command */ /* Called in response to the "ast_zoom" Tcl command */
static int astNewZoom(ClientData clientData, static int astNewZoom(ClientData clientData,
Tcl_Interp *interp, Tcl_Interp * interp, int argc, const char *argv[])
int argc, const char *argv[])
{ {
ginfo("Processing command: %s\n", argv[0]); ginfo("Processing command: %s\n", argv[0]);
if (argc != 5) if (argc != 5)
{ {
wld_fatal_error("%s: Unexpected number of arguments: %d\n", wld_fatal_error("%s: Unexpected number of arguments: %d\n",
__FUNCTION__, argc); __FUNCTION__, argc);
} }
/* Get the zoom settings */ /* Get the zoom settings */
viewSize = atoi(argv[1]); viewSize = atoi(argv[1]);
coordOffset[0] = atoi(argv[2]); coordOffset[0] = atoi(argv[2]);
coordOffset[1] = atoi(argv[3]); coordOffset[1] = atoi(argv[3]);
coordOffset[2] = atoi(argv[4]); coordOffset[2] = atoi(argv[4]);
@ -282,40 +283,40 @@ static int astNewZoom(ClientData clientData,
if (viewSize <= 256) if (viewSize <= 256)
{ {
gridStep = 16; /* 16 lines at 256 */ gridStep = 16; /* 16 lines at 256 */
} }
else if (viewSize <= 512) else if (viewSize <= 512)
{ {
gridStep = 32; /* 16 lines at 512 */ gridStep = 32; /* 16 lines at 512 */
} }
else if (viewSize <= 1024) else if (viewSize <= 1024)
{ {
gridStep = 64; /* 16 lines at 1024 */ gridStep = 64; /* 16 lines at 1024 */
} }
else if (viewSize <= 2048) else if (viewSize <= 2048)
{ {
gridStep = 128; /* 16 lines at 2048 */ gridStep = 128; /* 16 lines at 2048 */
} }
else if (viewSize <= 4096) else if (viewSize <= 4096)
{ {
gridStep = 256; /* 16 lines at 4096 */ gridStep = 256; /* 16 lines at 4096 */
} }
else if (viewSize <= 8192) else if (viewSize <= 8192)
{ {
gridStep = 512; /* 16 lines at 8196 */ gridStep = 512; /* 16 lines at 8196 */
} }
else if (viewSize <= 16384) else if (viewSize <= 16384)
{ {
gridStep = 1024; /* 16 lines at 16384 */ gridStep = 1024; /* 16 lines at 16384 */
} }
else /* if (viewSize <= 32768) */ else /* if (viewSize <= 32768) */
{ {
gridStep = 2048; /* 16 lines at 32768 */ gridStep = 2048; /* 16 lines at 32768 */
} }
ginfo("New viewSize, gridStep: %d, %d\n", viewSize, gridStep); ginfo("New viewSize, gridStep: %d, %d\n", viewSize, gridStep);
ginfo("New coordinate offsets: {%d,%d,%d}\n", ginfo("New coordinate offsets: {%d,%d,%d}\n",
coordOffset[0], coordOffset[1], coordOffset[2]); coordOffset[0], coordOffset[1], coordOffset[2]);
if (editMode == EDITMODE_POS) if (editMode == EDITMODE_POS)
{ {
@ -331,8 +332,7 @@ static int astNewZoom(ClientData clientData,
/* Called in response to the "ast_edit" Tcl command */ /* Called in response to the "ast_edit" Tcl command */
static int astNewEdit(ClientData clientData, static int astNewEdit(ClientData clientData,
Tcl_Interp *interp, Tcl_Interp * interp, int argc, const char *argv[])
int argc, const char *argv[])
{ {
int start; int start;
int end; int end;
@ -343,7 +343,7 @@ static int astNewEdit(ClientData clientData,
if (argc != 4) if (argc != 4)
{ {
wld_fatal_error("%s: Unexpected number of arguments: %d\n", wld_fatal_error("%s: Unexpected number of arguments: %d\n",
__FUNCTION__, argc); __FUNCTION__, argc);
} }
/* Ignore the command if we are not in NEW mode */ /* Ignore the command if we are not in NEW mode */
@ -352,9 +352,9 @@ static int astNewEdit(ClientData clientData,
{ {
/* Get the new position information */ /* Get the new position information */
start = atoi(argv[2]); start = atoi(argv[2]);
extent = atoi(argv[3]); extent = atoi(argv[3]);
end = start + extent - 1; end = start + extent - 1;
/* Which plane are we editting? */ /* Which plane are we editting? */
@ -370,18 +370,18 @@ static int astNewEdit(ClientData clientData,
{ {
ginfo("New horizontal Y coordinates: {%d,%d}\n", start, end); ginfo("New horizontal Y coordinates: {%d,%d}\n", start, end);
editRect.hStart = start; editRect.hStart = start;
editRect.hEnd = end; editRect.hEnd = end;
} }
else if (strcmp(argv[1], "z") == 0) else if (strcmp(argv[1], "z") == 0)
{ {
ginfo("New vertical Z coordinates: {%d,%d}\n", start, end); ginfo("New vertical Z coordinates: {%d,%d}\n", start, end);
editRect.vStart = start; editRect.vStart = start;
editRect.vEnd = end; editRect.vEnd = end;
} }
else else
{ {
wld_fatal_error("%s: Unrecognized EDITX plane: %s\n", wld_fatal_error("%s: Unrecognized EDITX plane: %s\n",
__FUNCTION__, argv[1]); __FUNCTION__, argv[1]);
} }
break; break;
@ -390,7 +390,7 @@ static int astNewEdit(ClientData clientData,
{ {
ginfo("New horizontal X coordinates: {%d,%d}\n", start, end); ginfo("New horizontal X coordinates: {%d,%d}\n", start, end);
editRect.hStart = start; editRect.hStart = start;
editRect.hEnd = end; editRect.hEnd = end;
} }
else if (strcmp(argv[1], "y") == 0) else if (strcmp(argv[1], "y") == 0)
{ {
@ -401,12 +401,12 @@ static int astNewEdit(ClientData clientData,
{ {
ginfo("New vertical Z coordinates: {%d,%d}\n", start, end); ginfo("New vertical Z coordinates: {%d,%d}\n", start, end);
editRect.vStart = start; editRect.vStart = start;
editRect.vEnd = end; editRect.vEnd = end;
} }
else else
{ {
wld_fatal_error("%s: Unrecognized EDITY plane: %s\n", wld_fatal_error("%s: Unrecognized EDITY plane: %s\n",
__FUNCTION__, argv[1]); __FUNCTION__, argv[1]);
} }
break; break;
@ -415,13 +415,13 @@ static int astNewEdit(ClientData clientData,
{ {
ginfo("New horizontal X coordinates: {%d,%d}\n", start, end); ginfo("New horizontal X coordinates: {%d,%d}\n", start, end);
editRect.hStart = start; editRect.hStart = start;
editRect.hEnd = end; editRect.hEnd = end;
} }
else if (strcmp(argv[1], "y") == 0) else if (strcmp(argv[1], "y") == 0)
{ {
ginfo("New vertical Y coordinates: {%d,%d}\n", start, end); ginfo("New vertical Y coordinates: {%d,%d}\n", start, end);
editRect.vStart = start; editRect.vStart = start;
editRect.vEnd = end; editRect.vEnd = end;
} }
else if (strcmp(argv[1], "z") == 0) else if (strcmp(argv[1], "z") == 0)
{ {
@ -431,7 +431,7 @@ static int astNewEdit(ClientData clientData,
else else
{ {
wld_fatal_error("%s: Unrecognized EDITZ plane: %s\n", wld_fatal_error("%s: Unrecognized EDITZ plane: %s\n",
__FUNCTION__, argv[1]); __FUNCTION__, argv[1]);
} }
break; break;
@ -446,8 +446,7 @@ static int astNewEdit(ClientData clientData,
/* Called in response to the "ast_attribute" Tcl command */ /* Called in response to the "ast_attribute" Tcl command */
static int astNewAttributes(ClientData clientData, static int astNewAttributes(ClientData clientData,
Tcl_Interp *interp, Tcl_Interp * interp, int argc, const char *argv[])
int argc, const char *argv[])
{ {
const char *attributes; const char *attributes;
int tmp; int tmp;
@ -457,14 +456,14 @@ static int astNewAttributes(ClientData clientData,
if (argc != 4) if (argc != 4)
{ {
wld_fatal_error("%s: Unexpected number of arguments: %d\n", wld_fatal_error("%s: Unexpected number of arguments: %d\n",
__FUNCTION__, argc); __FUNCTION__, argc);
} }
attributes = argv[1]; attributes = argv[1];
if (strlen(attributes) != 3) if (strlen(attributes) != 3)
{ {
wld_fatal_error("%s: Unexpected attribute string length: %s\n", wld_fatal_error("%s: Unexpected attribute string length: %s\n",
__FUNCTION__, argv[1]); __FUNCTION__, argv[1]);
} }
/* Ignore the command if we are not in NEW mode */ /* Ignore the command if we are not in NEW mode */
@ -500,7 +499,7 @@ static int astNewAttributes(ClientData clientData,
ginfo("attributes: %s->%02x\n", attributes, editRect.attribute); ginfo("attributes: %s->%02x\n", attributes, editRect.attribute);
tmp = atoi(argv[2]); tmp = atoi(argv[2]);
if ((tmp >=0) && (tmp < 256)) if ((tmp >= 0) && (tmp < 256))
{ {
editRect.texture = tmp; editRect.texture = tmp;
} }
@ -511,7 +510,7 @@ static int astNewAttributes(ClientData clientData,
ginfo("texture: %s->%d\n", argv[2], editRect.texture); ginfo("texture: %s->%d\n", argv[2], editRect.texture);
tmp = atoi(argv[3]); tmp = atoi(argv[3]);
if ((tmp >=0) && (tmp <= MAXX_SCALING)) if ((tmp >= 0) && (tmp <= MAXX_SCALING))
{ {
editRect.scale = tmp; editRect.scale = tmp;
} }
@ -521,14 +520,14 @@ static int astNewAttributes(ClientData clientData,
} }
ginfo("scale: %s->%d\n", argv[3], editRect.scale); ginfo("scale: %s->%d\n", argv[3], editRect.scale);
} }
return TCL_OK; return TCL_OK;
} }
/* Called in response to the "ast_addrectangle" Tcl command */ /* Called in response to the "ast_addrectangle" Tcl command */
static int astAddRectangle(ClientData clientData, static int astAddRectangle(ClientData clientData,
Tcl_Interp *interp, Tcl_Interp * interp, int argc, const char *argv[])
int argc, const char *argv[])
{ {
ginfo("Processing command: %s\n", argv[0]); ginfo("Processing command: %s\n", argv[0]);
@ -536,7 +535,7 @@ static int astAddRectangle(ClientData clientData,
if (argc != 1) if (argc != 1)
{ {
wld_fatal_error("%s: Unexpected number of arguments: %d\n", wld_fatal_error("%s: Unexpected number of arguments: %d\n",
__FUNCTION__, argc); __FUNCTION__, argc);
} }
/* Ignore the command if we are not in NEW mode */ /* Ignore the command if we are not in NEW mode */
@ -556,15 +555,15 @@ static int astAddRectangle(ClientData clientData,
switch (editPlane) switch (editPlane)
{ {
case EDITPLANE_X: case EDITPLANE_X:
wld_add_plane(rect, &xPlane); wld_add_plane(rect, &g_xplane_list);
break; break;
case EDITPLANE_Y: case EDITPLANE_Y:
wld_add_plane(rect, &yPlane); wld_add_plane(rect, &g_yplane_list);
break; break;
case EDITPLANE_Z: case EDITPLANE_Z:
wld_add_plane(rect, &zPlane); wld_add_plane(rect, &g_zplane_list);
break; break;
} }
} }
@ -574,8 +573,7 @@ static int astAddRectangle(ClientData clientData,
/* Called in response to the "ast_save" Tcl command */ /* Called in response to the "ast_save" Tcl command */
static int astSaveRectangles(ClientData clientData, static int astSaveRectangles(ClientData clientData,
Tcl_Interp *interp, Tcl_Interp * interp, int argc, const char *argv[])
int argc, const char *argv[])
{ {
ginfo("Processing command: %s\n", argv[0]); ginfo("Processing command: %s\n", argv[0]);
@ -583,7 +581,7 @@ static int astSaveRectangles(ClientData clientData,
if (argc != 1) if (argc != 1)
{ {
wld_fatal_error("%s: Unexpected number of arguments: %d\n", wld_fatal_error("%s: Unexpected number of arguments: %d\n",
__FUNCTION__, argc); __FUNCTION__, argc);
} }
wld_save_planes(astOutFileName); wld_save_planes(astOutFileName);
@ -592,8 +590,7 @@ static int astSaveRectangles(ClientData clientData,
static void show_usage(const char *progname) static void show_usage(const char *progname)
{ {
fprintf(stderr, "USAGE:\n\t%s [-o <outfilename>] <infilename>\n", fprintf(stderr, "USAGE:\n\t%s [-o <outfilename>] <infilename>\n", progname);
progname);
exit(1); exit(1);
} }
@ -613,7 +610,7 @@ int main(int argc, char **argv, char **envp)
{ {
switch (option) switch (option)
{ {
case 'o' : case 'o':
astOutFileName = optarg; astOutFileName = optarg;
break; break;
default: default:
@ -623,29 +620,26 @@ int main(int argc, char **argv, char **envp)
} }
} }
/* We expect at least one argument after the options: The input /* We expect at least one argument after the options: The input file name. */
* file name.
*/
if (optind > argc - 1) if (optind > argc - 1)
{ {
fprintf(stderr, "Expected input file name\n"); fprintf(stderr, "Expected input file name\n");
show_usage(argv[0]); show_usage(argv[0]);
} }
astInFileName = argv[optind]; astInFileName = argv[optind];
/* Read the plane file now so that we can be certain that it is /* Read the plane file now so that we can be certain that it is a valid
* a valid plaine file. * plaine file. */
*/
if (wld_load_planefile(astInFileName) != PLANE_SUCCESS) if (wld_load_planefile(astInFileName) != PLANE_SUCCESS)
{ {
exit(1); exit(1);
} }
/* Tk_Main creates a Tcl interpreter and calls Tcl_AppInit() then /* Tk_Main creates a Tcl interpreter and calls Tcl_AppInit() then begins
* begins processing window events and interactive commands. * processing window events and interactive commands. */
*/
Tk_Main(1, argv, Tcl_AppInit); Tk_Main(1, argv, Tcl_AppInit);
exit(0); exit(0);
@ -665,7 +659,7 @@ int do_tcl_action(const char *script)
* is entered. * is entered.
*/ */
int Tcl_AppInit(Tcl_Interp *interp) int Tcl_AppInit(Tcl_Interp * interp)
{ {
int i; int i;
@ -695,19 +689,19 @@ int Tcl_AppInit(Tcl_Interp *interp)
/* Define application-specific commands */ /* Define application-specific commands */
Tcl_CreateCommand(astInterp, "ast_seteditmode", astSetEditMode, Tcl_CreateCommand(astInterp, "ast_seteditmode", astSetEditMode,
(ClientData)0, (Tcl_CmdDeleteProc *) NULL); (ClientData) 0, (Tcl_CmdDeleteProc *) NULL);
Tcl_CreateCommand(astInterp, "ast_position", astNewPosition, Tcl_CreateCommand(astInterp, "ast_position", astNewPosition,
(ClientData)0, (Tcl_CmdDeleteProc *) NULL); (ClientData) 0, (Tcl_CmdDeleteProc *) NULL);
Tcl_CreateCommand(astInterp, "ast_zoom", astNewZoom, Tcl_CreateCommand(astInterp, "ast_zoom", astNewZoom,
(ClientData)0, (Tcl_CmdDeleteProc *) NULL); (ClientData) 0, (Tcl_CmdDeleteProc *) NULL);
Tcl_CreateCommand(astInterp, "ast_edit", astNewEdit, Tcl_CreateCommand(astInterp, "ast_edit", astNewEdit,
(ClientData)0, (Tcl_CmdDeleteProc *) NULL); (ClientData) 0, (Tcl_CmdDeleteProc *) NULL);
Tcl_CreateCommand(astInterp, "ast_attributes", astNewAttributes, Tcl_CreateCommand(astInterp, "ast_attributes", astNewAttributes,
(ClientData)0, (Tcl_CmdDeleteProc *) NULL); (ClientData) 0, (Tcl_CmdDeleteProc *) NULL);
Tcl_CreateCommand(astInterp, "ast_addrectangle", astAddRectangle, Tcl_CreateCommand(astInterp, "ast_addrectangle", astAddRectangle,
(ClientData)0, (Tcl_CmdDeleteProc *) NULL); (ClientData) 0, (Tcl_CmdDeleteProc *) NULL);
Tcl_CreateCommand(astInterp, "ast_save", astSaveRectangles, Tcl_CreateCommand(astInterp, "ast_save", astSaveRectangles,
(ClientData)0, (Tcl_CmdDeleteProc *) NULL); (ClientData) 0, (Tcl_CmdDeleteProc *) NULL);
/* Initialize the Tcl parser */ /* Initialize the Tcl parser */
@ -723,12 +717,12 @@ int Tcl_AppInit(Tcl_Interp *interp)
void wld_fatal_error(char *message, ...) void wld_fatal_error(char *message, ...)
{ {
va_list args; va_list args;
va_start(args, message); va_start(args, message);
vfprintf(stderr, message, args); vfprintf(stderr, message, args);
putc('\n', stderr); putc('\n', stderr);
va_end(args); va_end(args);
exit(1); exit(1);
} }

102
graphics/traveler/tools/tcledit/tcl_x11graphics.c
View File

@ -46,8 +46,8 @@
#include <X11/Xutil.h> #include <X11/Xutil.h>
#include <sys/ipc.h> #include <sys/ipc.h>
#ifndef NO_XSHM #ifndef NO_XSHM
#include <sys/shm.h> # include <sys/shm.h>
#include <X11/extensions/XShm.h> # include <X11/extensions/XShm.h>
#endif #endif
#include "trv_types.h" #include "trv_types.h"
@ -75,11 +75,11 @@ static int useShm;
* Private Functions * Private Functions
****************************************************************************/ ****************************************************************************/
static void x11_create_window(tcl_window_t *w); static void x11_create_window(tcl_window_t * w);
static void x11_load_palette(tcl_window_t *w); static void x11_load_palette(tcl_window_t * w);
static bool x11_allocate_colors(tcl_window_t *w, Colormap colormap); static bool x11_allocate_colors(tcl_window_t * w, Colormap colormap);
static void x11_map_sharedmemory(tcl_window_t *w, int depth); static void x11_map_sharedmemory(tcl_window_t * w, int depth);
static void x11_unmap_sharedmemory(tcl_window_t *w); static void x11_unmap_sharedmemory(tcl_window_t * w);
static void x11_unmap_all_sharedmemory(void); static void x11_unmap_all_sharedmemory(void);
/**************************************************************************** /****************************************************************************
@ -91,7 +91,7 @@ static void x11_unmap_all_sharedmemory(void);
* Description: * Description:
***************************************************************************/ ***************************************************************************/
static void x11_create_window(tcl_window_t *w) static void x11_create_window(tcl_window_t * w)
{ {
XGCValues gcValues; XGCValues gcValues;
char *argv[2] = { "xast", NULL }; char *argv[2] = { "xast", NULL };
@ -114,8 +114,8 @@ static void x11_create_window(tcl_window_t *w)
XStringListToTextProperty(&iconName, 1, &iNameProp); XStringListToTextProperty(&iconName, 1, &iNameProp);
sizeHints.flags = PSize | PMinSize | PMaxSize; sizeHints.flags = PSize | PMinSize | PMaxSize;
sizeHints.width= sizeHints.min_width = sizeHints.max_width = w->width; sizeHints.width = sizeHints.min_width = sizeHints.max_width = w->width;
sizeHints.height= sizeHints.min_height = sizeHints.max_height = w->height; sizeHints.height = sizeHints.min_height = sizeHints.max_height = w->height;
XSetWMProperties(w->display, w->win, &wNameProp, &iNameProp, argv, 1, XSetWMProperties(w->display, w->win, &wNameProp, &iNameProp, argv, 1,
&sizeHints, NULL, NULL); &sizeHints, NULL, NULL);
@ -133,7 +133,7 @@ static void x11_create_window(tcl_window_t *w)
* Description: * Description:
***************************************************************************/ ***************************************************************************/
static void x11_load_palette(tcl_window_t *w) static void x11_load_palette(tcl_window_t * w)
{ {
Colormap cMap; Colormap cMap;
@ -147,8 +147,7 @@ static void x11_load_palette(tcl_window_t *w)
XFreeColors(w->display, cMap, w->colorLookup, w->ncolors, 0); XFreeColors(w->display, cMap, w->colorLookup, w->ncolors, 0);
cMap = XCreateColormap(w->display, w->win, cMap = XCreateColormap(w->display, w->win,
DefaultVisual(w->display, w->screen), DefaultVisual(w->display, w->screen), AllocNone);
AllocNone);
if (!x11_allocate_colors(w, cMap)) if (!x11_allocate_colors(w, cMap))
{ {
@ -166,7 +165,7 @@ static void x11_load_palette(tcl_window_t *w)
* Description: * Description:
***************************************************************************/ ***************************************************************************/
static bool x11_allocate_colors(tcl_window_t *w, Colormap colormap) static bool x11_allocate_colors(tcl_window_t * w, Colormap colormap)
{ {
int i; int i;
@ -184,9 +183,9 @@ static bool x11_allocate_colors(tcl_window_t *w, Colormap colormap)
* represented by (65535,65535,65535). * represented by (65535,65535,65535).
*/ */
color.red = ((unsigned short)w->palette[i].red << 8); color.red = ((unsigned short)w->palette[i].red << 8);
color.green = ((unsigned short)w->palette[i].green << 8); color.green = ((unsigned short)w->palette[i].green << 8);
color.blue = ((unsigned short)w->palette[i].blue << 8); color.blue = ((unsigned short)w->palette[i].blue << 8);
color.flags = DoRed | DoGreen | DoBlue; color.flags = DoRed | DoGreen | DoBlue;
/* Then allocate a color for this selection */ /* Then allocate a color for this selection */
@ -199,9 +198,9 @@ static bool x11_allocate_colors(tcl_window_t *w, Colormap colormap)
/* Save the RGB to pixel lookup data */ /* Save the RGB to pixel lookup data */
ginfo("%d.%d {%02x,%02x,%02x}->0x%06lx\n", ginfo("%d.%d {%02x,%02x,%02x}->0x%06lx\n",
w->plane, i, w->plane, i,
w->palette[i].red, w->palette[i].green, w->palette[i].blue, w->palette[i].red, w->palette[i].green, w->palette[i].blue,
color.pixel); color.pixel);
w->colorLookup[i] = color.pixel; w->colorLookup[i] = color.pixel;
w->ncolors++; w->ncolors++;
@ -215,7 +214,7 @@ static bool x11_allocate_colors(tcl_window_t *w, Colormap colormap)
***************************************************************************/ ***************************************************************************/
#ifndef NO_XSHM #ifndef NO_XSHM
static int errorHandler(Display *display, XErrorEvent *event) static int errorHandler(Display * display, XErrorEvent * event)
{ {
xError = 1; xError = 1;
@ -242,9 +241,9 @@ static void trapErrors(void)
***************************************************************************/ ***************************************************************************/
#ifndef NO_XSHM #ifndef NO_XSHM
static int untrapErrors(Display *display) static int untrapErrors(Display * display)
{ {
XSync(display,0); XSync(display, 0);
XSetErrorHandler(NULL); XSetErrorHandler(NULL);
return xError; return xError;
} }
@ -255,7 +254,7 @@ static int untrapErrors(Display *display)
* Description: * Description:
***************************************************************************/ ***************************************************************************/
static void x11_map_sharedmemory(tcl_window_t *w, int depth) static void x11_map_sharedmemory(tcl_window_t * w, int depth)
{ {
#ifndef NO_XSHM #ifndef NO_XSHM
Status result; Status result;
@ -264,7 +263,8 @@ static void x11_map_sharedmemory(tcl_window_t *w, int depth)
shmCheckPoint = 0; shmCheckPoint = 0;
x11_unmap_sharedmemory(w); x11_unmap_sharedmemory(w);
if (!shmCheckPoint) atexit(x11_unmap_all_sharedmemory); if (!shmCheckPoint)
atexit(x11_unmap_all_sharedmemory);
shmCheckPoint = 1; shmCheckPoint = 1;
useShm = 0; useShm = 0;
@ -303,8 +303,8 @@ static void x11_map_sharedmemory(tcl_window_t *w, int depth)
} }
shmCheckPoint++; shmCheckPoint++;
w->image->data = (char *) shmat(xshminfo.shmid, 0, 0); w->image->data = (char *)shmat(xshminfo.shmid, 0, 0);
if (image->data == ((char *) -1)) if (image->data == ((char *)-1))
{ {
x11_unmap_sharedmemory(w); x11_unmap_sharedmemory(w);
goto shmerror; goto shmerror;
@ -323,35 +323,35 @@ static void x11_map_sharedmemory(tcl_window_t *w, int depth)
} }
shmCheckPoint++; shmCheckPoint++;
} else }
else
#endif #endif
if (!useShm) if (!useShm)
{ {
#ifndef NO_XSHM #ifndef NO_XSHM
shmerror: shmerror:
#endif #endif
useShm = 0; useShm = 0;
w->frameBuffer = (dev_pixel_t*) w->frameBuffer = (dev_pixel_t *)
wld_malloc(w->width * w->height * sizeof(dev_pixel_t)); wld_malloc(w->width * w->height * sizeof(dev_pixel_t));
w->image = XCreateImage(w->display, w->image = XCreateImage(w->display,
DefaultVisual(w->display, w->screen), DefaultVisual(w->display, w->screen),
depth, depth,
ZPixmap, ZPixmap,
0, 0,
(char*)w->frameBuffer, (char *)w->frameBuffer,
w->width, w->height, w->width, w->height, 8, 0);
8, 0);
if (w->image == NULL) if (w->image == NULL)
{ {
wld_fatal_error("Unable to create image."); wld_fatal_error("Unable to create image.");
}
shmCheckPoint++;
} }
shmCheckPoint++;
}
} }
/**************************************************************************** /****************************************************************************
@ -359,7 +359,7 @@ static void x11_map_sharedmemory(tcl_window_t *w, int depth)
* Description: * Description:
***************************************************************************/ ***************************************************************************/
static void x11_unmap_sharedmemory(tcl_window_t *w) static void x11_unmap_sharedmemory(tcl_window_t * w)
{ {
#ifndef NO_XSHM #ifndef NO_XSHM
if (shmCheckPoint > 4) if (shmCheckPoint > 4)
@ -413,7 +413,7 @@ static void x11_unmap_all_sharedmemory(void)
* Description: * Description:
***************************************************************************/ ***************************************************************************/
void x11_UpdateScreen(tcl_window_t *w) void x11_UpdateScreen(tcl_window_t * w)
{ {
#ifndef NO_XSHM #ifndef NO_XSHM
if (useShm) if (useShm)
@ -439,7 +439,7 @@ void x11_UpdateScreen(tcl_window_t *w)
* Description: * Description:
***************************************************************************/ ***************************************************************************/
void x11_InitGraphics(tcl_window_t *w) void x11_InitGraphics(tcl_window_t * w)
{ {
XWindowAttributes windowAttributes; XWindowAttributes windowAttributes;
@ -467,7 +467,7 @@ void x11_InitGraphics(tcl_window_t *w)
* Description: * Description:
***************************************************************************/ ***************************************************************************/
void x11_EndGraphics(tcl_window_t *w) void x11_EndGraphics(tcl_window_t * w)
{ {
x11_unmap_all_sharedmemory(); x11_unmap_all_sharedmemory();
XCloseDisplay(w->display); XCloseDisplay(w->display);