LandscapeOptions *View_GetLandscapeOptions(shape_descriptor Desc)
{
// Pull out frame and collection ID's:
short Frame = GET_DESCRIPTOR_SHAPE(Desc);
short CollCT = GET_DESCRIPTOR_COLLECTION(Desc);
short Collection = GET_COLLECTION(CollCT);
vector<LandscapeOptionsEntry>& LOL = LOList[Collection];
for (vector<LandscapeOptionsEntry>::iterator LOIter = LOL.begin();
LOIter < LOL.end(); LOIter++)
{
if (LOIter->Frame == Frame || LOIter->Frame == AnyFrame) {
// Get a pointer from the iterator in order to return it
return &(LOIter->OptionsData);
}
}
// Return the default if no matching entry was found
return &DefaultLandscape;
}
void HUD_SW_Class::DrawTexture(shape_descriptor shape, short texture_type, short x, short y, int size)
{
Shape_Blitter b(
GET_COLLECTION(GET_DESCRIPTOR_COLLECTION(shape)),
GET_DESCRIPTOR_SHAPE(shape),
texture_type,
GET_COLLECTION_CLUT(GET_DESCRIPTOR_COLLECTION(shape)));
int w = b.Width();
int h = b.Height();
if (!w || !h) return;
if (w >= h)
b.Rescale(size, size * h / w);
else
b.Rescale(size * w / h, size);
SDL_Rect r;
r.w = b.Width();
r.h = b.Height();
r.x = x + (size - r.w)/2;
r.y = y + (size - r.h)/2;
b.SDL_Draw(HUD_Buffer, r);
}
PixMapHandle get_shape_pixmap(
short shape,
boolean force_copy)
{
OSErr error;
struct collection_definition *collection;
struct low_level_shape_definition *low_level_shape;
struct bitmap_definition *bitmap;
short collection_index, low_level_shape_index, clut_index;
collection_index= GET_COLLECTION(GET_DESCRIPTOR_COLLECTION(shape));
clut_index= GET_COLLECTION_CLUT(GET_DESCRIPTOR_COLLECTION(shape));
low_level_shape_index= GET_DESCRIPTOR_SHAPE(shape);
collection= get_collection_definition(collection_index);
switch (interface_bit_depth)
{
case 8:
/* if the ctSeed of our offscreen pixmap is different from the ctSeed of the world
device then the color environment has changed since the last call to our routine,
and we just HandToHand the deviceÕs ctTable and throw away our old one. */
if ((*(*(*world_device)->gdPMap)->pmTable)->ctSeed!=(*(*hollow_pixmap)->pmTable)->ctSeed)
{
DisposeHandle((Handle)(*hollow_pixmap)->pmTable);
(*hollow_pixmap)->pmTable= (*(*world_device)->gdPMap)->pmTable;
HLock((Handle)hollow_pixmap);
error= HandToHand((Handle *)&(*hollow_pixmap)->pmTable);
HUnlock((Handle)hollow_pixmap);
assert(error==noErr);
/* this is a device color table so we donÕt clear ctFlags (well, it isnÕt a device
color table anymore, but itÕs formatted like one */
}
break;
case 16:
case 32:
if (!hollow_pixmap_color_table)
{
hollow_pixmap_color_table= (CTabHandle) NewHandle(sizeof(ColorTable)+PIXEL8_MAXIMUM_COLORS*sizeof(ColorSpec));
MoveHHi((Handle)hollow_pixmap_color_table);
HLock((Handle)hollow_pixmap_color_table);
assert(hollow_pixmap_color_table);
}
(*hollow_pixmap_color_table)->ctSeed= GetCTSeed();
(*hollow_pixmap_color_table)->ctSize= collection->color_count-NUMBER_OF_PRIVATE_COLORS-1;
(*hollow_pixmap_color_table)->ctFlags= 0;
BlockMove(get_collection_colors(collection_index, clut_index)+NUMBER_OF_PRIVATE_COLORS, &(*hollow_pixmap_color_table)->ctTable,
(collection->color_count-NUMBER_OF_PRIVATE_COLORS)*sizeof(ColorSpec));
(*hollow_pixmap)->pmTable= hollow_pixmap_color_table;
break;
default:
halt();
}
low_level_shape= get_low_level_shape_definition(collection_index, low_level_shape_index);
bitmap= get_bitmap_definition(collection_index, low_level_shape->bitmap_index);
/* setup the pixmap (canÕt wait to change this for Copland) */
SetRect(&(*hollow_pixmap)->bounds, 0, 0, bitmap->width, bitmap->height);
(*hollow_pixmap)->rowBytes= bitmap->width|0x8000;
(*hollow_pixmap)->baseAddr= (Ptr)bitmap->row_addresses[0];
if (bitmap->bytes_per_row==NONE) /* is this a compressed shape? */
{
register pixel8 *read, *write;
register short run_count;
short x;
/* for now all RLE shapes are in column-order */
assert(bitmap->flags&_COLUMN_ORDER_BIT);
/* donÕt overflow the buffer */
assert(bitmap->width*bitmap->height<=HOLLOW_PIXMAP_BUFFER_SIZE);
/* decompress column-order shape into row-order buffer */
for (x=0;x<bitmap->width;x+=1)
{
short bytes_per_row= bitmap->width;
write= hollow_data+x;
read= bitmap->row_addresses[x];
while (run_count= *((short*)read)++)
{
if (run_count<0) while ((run_count+=1)<=0) *write= iBLACK, write+= bytes_per_row; /* fill transparent areas with black */
else while ((run_count-=1)>=0) *write= *read++, write+= bytes_per_row; /* copy shape data */
}
}
(*hollow_pixmap)->baseAddr= (Ptr)hollow_data;
}
else
{
/* if this is a raw, row-order shape then only copy it if weÕve been asked to */
if (force_copy)
{
assert(bitmap->width*bitmap->height<=HOLLOW_PIXMAP_BUFFER_SIZE);
BlockMove(bitmap->row_addresses[0], hollow_data, bitmap->width*bitmap->height);
(*hollow_pixmap)->baseAddr= (Ptr)hollow_data;
}
}
return hollow_pixmap;
}
PixMapHandle editor_get_shape_pixmap(
short shape)
{
OSErr error;
struct collection_definition *collection;
struct low_level_shape_definition *low_level_shape;
struct bitmap_definition *bitmap;
short collection_index, low_level_shape_index, clut_index;
collection_index= GET_COLLECTION(GET_DESCRIPTOR_COLLECTION(shape));
clut_index= GET_COLLECTION_CLUT(GET_DESCRIPTOR_COLLECTION(shape));
low_level_shape_index= GET_DESCRIPTOR_SHAPE(shape);
collection= get_collection_definition(collection_index);
switch (interface_bit_depth)
{
case 8:
/* if the ctSeed of our offscreen pixmap is different from the ctSeed of the world
device then the color environment has changed since the last call to our routine,
and we just HandToHand the deviceÕs ctTable and throw away our old one. */
if ((*(*(*world_device)->gdPMap)->pmTable)->ctSeed!=(*(*hollow_pixmap)->pmTable)->ctSeed)
{
DisposeHandle((Handle)(*hollow_pixmap)->pmTable);
(*hollow_pixmap)->pmTable= (*(*world_device)->gdPMap)->pmTable;
HLock((Handle)hollow_pixmap);
error= HandToHand((Handle *)&(*hollow_pixmap)->pmTable);
HUnlock((Handle)hollow_pixmap);
assert(error==noErr);
/* this is a device color table so we donÕt clear ctFlags (well, it isnÕt a device
color table anymore, but itÕs formatted like one */
}
break;
case 16:
case 32:
if (!hollow_pixmap_color_table)
{
hollow_pixmap_color_table= (CTabHandle) NewHandle(sizeof(ColorTable)+PIXEL8_MAXIMUM_COLORS*sizeof(ColorSpec));
MoveHHi((Handle)hollow_pixmap_color_table);
HLock((Handle)hollow_pixmap_color_table);
assert(hollow_pixmap_color_table);
}
(*hollow_pixmap_color_table)->ctSeed= GetCTSeed();
(*hollow_pixmap_color_table)->ctSize= collection->color_count-NUMBER_OF_PRIVATE_COLORS-1;
(*hollow_pixmap_color_table)->ctFlags= 0;
BlockMove(get_collection_colors(collection_index, clut_index)+NUMBER_OF_PRIVATE_COLORS, &(*hollow_pixmap_color_table)->ctTable,
(collection->color_count-NUMBER_OF_PRIVATE_COLORS)*sizeof(ColorSpec));
(*hollow_pixmap)->pmTable= hollow_pixmap_color_table;
break;
default:
halt();
}
low_level_shape= get_low_level_shape_definition(collection_index, low_level_shape_index);
bitmap= get_bitmap_definition(collection_index, low_level_shape->bitmap_index);
/* setup the pixmap (canÕt wait to change this for Copland) */
SetRect(&(*hollow_pixmap)->bounds, 0, 0, bitmap->width, bitmap->height);
(*hollow_pixmap)->rowBytes= bitmap->width|0x8000;
(*hollow_pixmap)->baseAddr= (Ptr)bitmap->row_addresses[0];
/* Rotate if necessary */
if ((bitmap->flags&_COLUMN_ORDER_BIT) && bitmap->width==128 && bitmap->height==128)
{
static char *buffer= NULL;
if(!buffer)
{
buffer= (char *)malloc(bitmap->width*bitmap->height*sizeof(pixel8));
}
if(buffer)
{
short x, y;
pixel8 *dest= (pixel8 *) buffer;
/* decompress column-order shape into row-order buffer */
for (x=0;x<bitmap->width;x+=1)
{
for(y= 0; y<bitmap->height; y+=1)
{
*dest++= bitmap->row_addresses[y][x];
}
}
(*hollow_pixmap)->baseAddr= buffer;
}
}
return hollow_pixmap;
}