static PtrT ReadFileToCustomMemory(const StrT fileName, uint32_t memFlags) {
BPTR fh;
PtrT data = NULL;
PtrT path = AbsPath(fileName);
if ((fh = Open(path, MODE_OLDFILE))) {
struct FileInfoBlock *infoBlock;
if ((infoBlock = (struct FileInfoBlock *) AllocDosObject(DOS_FIB, NULL))) {
if (ExamineFH(fh, infoBlock)) {
size_t dataLen = infoBlock->fib_Size;
if ((data = MemNewCustom(dataLen, memFlags, NULL))) {
if (dataLen != Read(fh, data, dataLen)) {
MemUnref(data);
data = NULL;
}
}
}
FreeDosObject(DOS_FIB, infoBlock);
}
Close(fh);
}
MemUnref(path);
return data;
}
int main(int argc, char **argv) {
ZipT *zip;
int i;
if (argc < 2)
Usage(argv[0]);
if ((zip = ZipOpen(argv[1]))) {
if (argc == 2) {
ZipList(zip);
} else {
for (i = 2; i < argc; i++) {
RwOpsT *file;
if ((file = ZipRead(zip, argv[i]))) {
int size = IoSize(file);
uint8_t *data = MemNew(size);
IoRead(file, data, size);
IoClose(file);
fwrite(data, size, 1, stdout);
MemUnref(data);
} else {
printf("%s: no such file!", argv[i]);
}
}
}
MemUnref(zip);
}
return 0;
}
static void DeleteHashMap(HashMapT *self) {
size_t n = TableSize(self->map);
size_t i;
for (i = 0; i < n; i++) {
EntryT *entry = &self->map[i];
bool firstEntry = TRUE;
if (!entry->key)
continue;
while (entry) {
EntryT *next = entry->next;
MemUnref(entry->key);
if (entry->ownership)
MemUnref(entry->value);
if (!firstEntry)
MemUnref(entry);
firstEntry = FALSE;
entry = next;
}
}
MemUnref(self->map);
}
/* Collapse multiple IDAT chunks into single one. */
static void MergeIDATs(PngT *png) {
if (png->idat.next) {
uint32_t length, i;
uint8_t *data;
IdatT *idat;
for (idat = &png->idat, length = 0; idat; idat = idat->next)
length += idat->length;
LOG("Merged chunk length: %d.", length);
data = MemNew(length);
for (idat = &png->idat, i = 0; idat;) {
IdatT *next = idat->next;
MemCopy(data + i, idat->data, idat->length);
i += idat->length;
MemUnref(idat->data);
if (idat != &png->idat)
MemUnref(idat);
idat = next;
}
png->idat.data = data;
png->idat.length = length;
png->idat.next = NULL;
}
}
static void Kill() {
KillDisplay();
MemUnref(canvas);
MemUnref(map[0]);
MemUnref(map[1]);
MemUnref(shade);
}
/*
* Transition to demo.
*/
void BeginDemo() {
/* Release loading screen image... */
MemUnref(TheLoadImg);
MemUnref(TheLoadPal);
/* Play the audio stream... */
AudioStreamPlay(TheMusic);
}
static void Kill() {
KillDisplay();
MemUnref(canvas);
MemUnref(uvmap);
MemUnref(shades);
MemUnref(smallMap);
MemUnref(lightFunc);
}
static void Kill() {
KillDisplay();
MemUnref(uvmap);
MemUnref(shades);
MemUnref(canvas);
MemUnref(scene);
MemUnref(orig);
}
static void Kill() {
KillDisplay();
MemUnref(origU);
MemUnref(origU);
MemUnref(flare);
MemUnref(uvmap);
MemUnref(canvas);
}
static void Kill() {
KillDisplay();
MemUnref(canvas);
MemUnref(shades);
MemUnref(uvmap);
MemUnref(component);
MemUnref(colorFunc);
}
/*
* Tear down demo.
*/
void KillDemo() {
UnlinkPalettes(R_("11.pal"));
UnlinkPalettes(R_("texture-1.pal"));
UnlinkPalettes(R_("texture-2.pal"));
UnlinkPalettes(R_("texture-3.pal"));
UnlinkPalettes(R_("texture-4.pal"));
UnlinkPalettes(R_("texture-5.pal"));
AudioStreamStop(TheMusic);
MemUnref(TheMusic);
MemUnref(TheCanvas);
}
void LoadPng(const char *path) {
PngT *png = PngLoadFromFile(path);
if (png) {
PixBufT *pixbuf;
int16_t type;
puts("IHDR:");
printf(" width : %d\n", png->ihdr.width);
printf(" height : %d\n", png->ihdr.height);
printf(" bit depth : %d\n", png->ihdr.bit_depth);
printf(" color type : ");
if (png->ihdr.colour_type == PNG_GRAYSCALE) {
type = PIXBUF_GRAY;
puts("gray scale");
} else if (png->ihdr.colour_type == PNG_TRUECOLOR) {
type = PIXBUF_RGB;
puts("true color");
} else if (png->ihdr.colour_type == PNG_INDEXED) {
type = PIXBUF_CLUT;
puts("indexed color");
} else if (png->ihdr.colour_type == PNG_GRAYSCALE_ALPHA) {
type = PIXBUF_GRAY;
puts("gray scale (with alpha)");
} else {
type = PIXBUF_RGBA;
puts("true color (with alpha)");
}
printf(" interlace : %s\n", png->ihdr.interlace_method ? "yes" : "no");
if (png->plte.no_colors) {
puts("PLTE:");
printf(" colors : %d\n", png->plte.no_colors);
}
if (png->trns) {
puts("tRNS:");
if (png->ihdr.colour_type == PNG_INDEXED)
printf(" color : %d\n", png->trns->type3.alpha[0]);
}
pixbuf = NewPixBuf(type, png->ihdr.width, png->ihdr.height);
PngDecodeImage(png, pixbuf);
MemUnref(pixbuf);
}
puts("");
MemUnref(png);
}
void KillDisplay() {
if (Display) {
size_t i;
CloseScreen(Display->Screen);
for (i = 0; i < 2; i++)
FreeBitMap(Display->Bitmap[i]);
MemUnref(Display->Palette);
MemUnref(Display);
Display = NULL;
}
}
UVMapT *NewUVMapFromFile(const char *fileName) {
DiskUVMapT *file = (DiskUVMapT *)ReadFileSimple(fileName);
if (file) {
UVMapT *map = NewUVMap(file->width, file->height, UV_FAST, 256, 256);
LOG("Distortion map '%s' has size (%d,%d).",
fileName, (int)file->width, (int)file->height);
{
uint8_t *dstU = map->map.fast.u;
uint8_t *dstV = map->map.fast.v;
uint8_t *src = file->data;
int n = map->width * map->height;
do {
*dstU++ = *src++;
*dstV++ = *src++;
} while (--n);
}
MemUnref(file);
return map;
}
return NULL;
}
void BlurV3(PixBufT *dstBuf, PixBufT *srcBuf) {
uint8_t *dst = dstBuf->data;
uint8_t *prev = srcBuf->data;
uint8_t *next = srcBuf->data + 2 * srcBuf->width;
int16_t x, y;
/* at any given moment keeps a sum of three pixels */
int16_t *line = NewTable(int16_t, srcBuf->width);
/* initially line is a sum of srcLine[0] and srcLine[1] */
for (x = 0; x < srcBuf->width; x++) {
line[x] = srcBuf->data[x] + srcBuf->data[x + srcBuf->width];
*dst++ = DIV_BY_3(line[x]);
}
ASSERT(dstBuf->width == srcBuf->width,
"Width does not match (%d != %d)", dstBuf->width, srcBuf->width);
ASSERT(dstBuf->height == srcBuf->height,
"Height does not match (%d != %d)", dstBuf->height, srcBuf->height);
y = srcBuf->height - 2;
do {
for (x = 0; x < srcBuf->width; x++) {
line[x] += *next++;
*dst++ = DIV_BY_3(line[x]);
line[x] -= *prev++;
}
} while (--y >= 0);
for (x = 0; x < srcBuf->width; x++)
*dst++ = DIV_BY_3(line[x]);
MemUnref(line);
}
static void Render(int frameNumber) {
PixBufT *umap;
int du = frameNumber;
int dv = 2 * frameNumber;
int i;
umap = NewPixBufWrapper(WIDTH, HEIGHT, uvmap->map.fast.u);
UVMapSetOffset(uvmap, du, dv);
PixBufBlit(umap, 0, 0, origU, NULL);
for (i = 0; i < 8; i++) {
PixBufSetBlitMode(flare, BLIT_ADDITIVE);
PixBufBlit(umap,
(int)(128.0f + sin(-frameNumber * M_PI / 45.0f + M_PI * i / 4) * 80.0f),
(int)(96.0f + cos(-frameNumber * M_PI / 45.0f + M_PI * i / 4) * 48.0f),
flare, NULL);
}
UVMapRender(uvmap, canvas);
c2p1x1_8_c5_bm(canvas->data, GetCurrentBitMap(), WIDTH, HEIGHT, 0, 0);
MemUnref(umap);
}
bool PngDecodeImage(PngT *png, PixBufT *pixbuf) {
if (png->ihdr.interlace_method != 0) {
LOG("Interlaced PNG not supported.");
} else if (png->ihdr.bit_depth != 8) {
LOG("Non 8-bit components not supported.");
} else {
uint32_t pixelWidth = GetPixelWidth(png);
uint32_t length = png->ihdr.width * png->ihdr.height * pixelWidth;
uint32_t dstLength = length + png->ihdr.height;
uint8_t *encoded = MemNew(dstLength);
MergeIDATs(png);
LOG("Uncompressing the image.");
Inflate(png->idat.data + 2, encoded);
LOG("Decoding pixels.");
ReconstructImage(pixbuf->data, encoded,
png->ihdr.width, png->ihdr.height, pixelWidth);
MemUnref(encoded);
return true;
}
return false;
}
MeshT *NewMeshFromFile(const char *fileName) {
DiskMeshT *header = ReadFileSimple(fileName);
if (header) {
MeshT *mesh = NewMesh(header->vertices, header->polygons, header->surfaces);
uint8_t *data = header->data;
int i;
/* vertices */
MemCopy(mesh->vertex, data, sizeof(Vector3D) * header->vertices);
for (i = 0; i < header->vertices; i++) {
mesh->vertex[i].y = - mesh->vertex[i].y;
mesh->vertex[i].z = - mesh->vertex[i].z;
}
data += sizeof(Vector3D) * header->vertices;
/* triangles */
for (i = 0; i < header->polygons; i++) {
DiskTriangleT *triangle = (DiskTriangleT *)data;
mesh->polygon[i].surface = triangle->surface;
mesh->polygon[i].p[0] = triangle->p[0];
mesh->polygon[i].p[1] = triangle->p[1];
mesh->polygon[i].p[2] = triangle->p[2];
data += sizeof(DiskTriangleT);
}
MeshCalculateEdges(mesh);
/* surfaces */
for (i = 0; i < header->surfaces; i++) {
DiskSurfaceT *surface = (DiskSurfaceT *)data;
mesh->surface[i].name = StrDup(surface->name);
mesh->surface[i].color.rgb = surface->color;
mesh->surface[i].sideness = surface->flags;
data += sizeof(DiskSurfaceT) + strlen(surface->name) + 1;
}
LOG("Mesh '%s' has %d vertices, %d polygons, %d edges "
"and %d surfaces.", fileName, mesh->vertexNum, mesh->polygonNum,
mesh->edgeNum, mesh->surfaceNum);
MemUnref(header);
CalculateVertexToPolygonMap(mesh);
return mesh;
}
return NULL;
}
static void DeletePng(PngT *png) {
IdatT *idat = &png->idat;
do {
IdatT *next = idat->next;
MemUnref(idat->data);
if (idat != &png->idat)
MemUnref(idat);
idat = next;
} while (idat);
if (png->plte.colors)
MemUnref(png->plte.colors);
if (png->trns)
MemUnref(png->trns);
}
static void DeleteMesh(MeshT *mesh) {
MemUnref(mesh->vertexToPoly.vertex);
MemUnref(mesh->vertexToPoly.indices);
MemUnref(mesh->surfaceNormal);
MemUnref(mesh->vertexNormal);
MemUnref(mesh->surface);
MemUnref(mesh->polygon);
MemUnref(mesh->vertex);
}
static void FreeJsonNode(JsonNodeT *node) {
int i;
if (!node)
return;
switch (node->type) {
case JSON_NULL:
case JSON_BOOLEAN:
case JSON_INTEGER:
case JSON_REAL:
break;
case JSON_STRING:
MemUnref(node->u.string);
break;
case JSON_ARRAY:
for (i = 0; i < node->u.array.num; i++)
MemUnref(node->u.array.item[i]);
MemUnref(node->u.array.item);
break;
case JSON_OBJECT:
for (i = 0; i < node->u.object.num; i++) {
MemUnref(node->u.object.item[i].value);
MemUnref(node->u.object.item[i].key);
}
MemUnref(node->u.object.item);
break;
}
}
PtrT HashMapRemove(HashMapT *self, StrT key) {
EntryT *prev;
EntryT *entry = FindEntry(self, key, &prev);
PtrT value = NULL;
if (entry) {
value = entry->value;
MemUnref(entry->key);
if (!prev) {
entry->next = NULL;
entry->key = NULL;
entry->value = NULL;
} else {
prev->next = entry->next;
MemUnref(entry);
}
}
return value;
}
void UVMapGenerateSine(UVMapT *map,
size_t xFreq, float xAmp, float xShift,
size_t yFreq, float yAmp, float yShift)
{
float *sinU = CalcSineTable(map->width,
xFreq, xAmp / (int)map->textureW, xShift);
float *sinV = CalcSineTable(map->height,
yFreq, yAmp / (int)map->textureH, yShift);
float du = 1.0f / (int)map->width;
float dv = 1.0f / (int)map->height;
float u, v;
size_t x, y, i;
for (y = 0, i = 0, v = 0.0f; y < map->height; y++, v += dv)
for (x = 0, u = 0.0f; x < map->width; x++, u += du, i++)
UVMapSet(map, i, u + sinU[x], v + sinV[y]);
MemUnref(sinU);
MemUnref(sinV);
}
void LoadPngImage(PixBufT **imgPtr, PaletteT **palPtr, const char *pngFile) {
PngT *png = PngLoadFromFile(pngFile);
if (!png)
PANIC("Could not load '%s' file.", pngFile);
if (imgPtr)
*imgPtr = PngToPixBuf(png);
if (palPtr)
*palPtr = PngToPalette(png);
MemUnref(png);
}
JsonNodeT *JsonParse(const char *json) {
JsonNodeT *node = NULL;
int num = 0;
LOG("Lexing JSON.");
if (CountTokens(json, &num)) {
ParserT parser;
/* read tokens into an array */
TokenT *tokens = ReadTokens(json, num);
/* now... parse! */
ParserInit(&parser, tokens, num);
LOG("Parsing JSON.");
if (!ParseValue(&parser, &node)) {
#ifdef DEBUG_LEXER
LOG("Parse error: %s at token ", parser.errmsg);
TokenPrint(&parser.tokens[parser.pos]);
#else
LOG("Parse error: %s at position %d.", parser.errmsg,
parser.tokens[parser.pos].pos);
#endif
MemUnref(node);
node = NULL;
} else {
LOG("Parsing finished.");
}
MemUnref(tokens);
}
return node;
}
static void Render(int frameNumber) {
PixBufT *umap;
int du = 2 * frameNumber;
int dv = 4 * frameNumber;
{
MatrixStack3D *ms = GetObjectTranslation(scene, "Object");
StackReset(ms);
PushScaling3D(ms, 1.25f, 1.25f, 1.25f);
PushRotation3D(ms, 0, (float)(-frameNumber * 2), frameNumber);
PushTranslation3D(ms, 0.0f, 0.0f, -2.0f);
}
if (effectNum == 0) {
umap = NewPixBufWrapper(WIDTH, HEIGHT, uvmap->map.fast.u);
PROFILE(PixBufClear)
PixBufClear(shades);
PROFILE(RenderScene)
RenderScene(scene, shades);
PixBufSetBlitMode(shades, BLIT_ADDITIVE);
PixBufBlit(umap, 0, 0, orig, NULL);
PixBufBlit(umap, 0, 0, shades, NULL);
UVMapSetOffset(uvmap, du, dv);
UVMapRender(uvmap, canvas);
MemUnref(umap);
} else {
UVMapSetOffset(uvmap, du, dv);
UVMapRender(uvmap, canvas);
PROFILE(PixBufClear)
PixBufClear(shades);
PROFILE(RenderScene)
RenderScene(scene, shades);
PixBufSetColorMap(shades, colorMap);
PixBufSetBlitMode(shades, BLIT_COLOR_MAP);
PixBufBlit(canvas, 0, 0, shades, NULL);
}
c2p1x1_8_c5_bm(canvas->data, GetCurrentBitMap(), WIDTH, HEIGHT, 0, 0);
}
static void DeleteUVMap(UVMapT *map) {
if (map->type == UV_FAST) {
MemUnref(map->map.fast.u);
MemUnref(map->map.fast.v);
} else if (map->type == UV_NORMAL) {
MemUnref(map->map.normal.u);
MemUnref(map->map.normal.v);
} else if (map->type == UV_ACCURATE) {
MemUnref(map->map.accurate.u);
MemUnref(map->map.accurate.v);
}
}
static PixBufT *PngToPixBuf(PngT *png) {
PixBufT *pixbuf = NULL;
if (png->ihdr.bit_depth == 8) {
int16_t type;
switch (png->ihdr.colour_type) {
case PNG_GRAYSCALE:
type = PIXBUF_GRAY;
break;
case PNG_INDEXED:
type = PIXBUF_CLUT;
break;
default:
type = -1;
break;
}
if (type >= 0) {
pixbuf = NewPixBuf(type, png->ihdr.width, png->ihdr.height);
if (!PngDecodeImage(png, pixbuf)) {
MemUnref(pixbuf);
pixbuf = NULL;
} else {
PixBufCalculateHistogram(pixbuf);
LOG("The image has %d (%d..%d) colors.",
(int)pixbuf->lastColor - (int)pixbuf->baseColor + 1,
pixbuf->baseColor, pixbuf->lastColor);
if (png->trns) {
pixbuf->mode = BLIT_TRANSPARENT;
pixbuf->baseColor = png->trns->type3.alpha[0];
LOG("The image is transparent (color = %d).", pixbuf->baseColor);
}
}
}
}
return pixbuf;
}
PngT *PngLoadFromFile(const char *path) {
RwOpsT *stream;
if ((stream = RwOpsFromFile(path, "r"))) {
PngT *png = NewInstance(PngT);
if (ReadPNG(png, stream)) {
LOG("Loaded '%s' file.", path);
} else {
MemUnref(png);
png = NULL;
}
IoClose(stream);
return png;
}
return NULL;
}
PaletteT *NewPaletteFromFile(const StrT fileName) {
DiskPaletteT *file = ReadFileSimple(fileName);
if (file) {
PaletteT *palette = NewPalette(file->count);
palette->start = file->start;
LOG("Palette '%s' has %d colors.", fileName, file->count);
MemCopy(palette->colors, file->colors, sizeof(RGB) * file->count);
MemUnref(file);
return palette;
}
return NULL;
}
