mirror of
https://github.com/izzy2lost/Diddy-Kong-Racing.git
synced 2026-06-19 01:16:26 -07:00
Remove unused tools/n64graphics
This commit is contained in:
queueRAM
File diff suppressed because it is too large
Load Diff
@@ -1,100 +0,0 @@
|
||||
#ifndef N64GRAPHICS_H_
|
||||
#define N64GRAPHICS_H_
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
// intermediate formats
|
||||
typedef struct _rgba
|
||||
{
|
||||
uint8_t red;
|
||||
uint8_t green;
|
||||
uint8_t blue;
|
||||
uint8_t alpha;
|
||||
} rgba;
|
||||
|
||||
typedef struct _ia
|
||||
{
|
||||
uint8_t intensity;
|
||||
uint8_t alpha;
|
||||
} ia;
|
||||
|
||||
// CI palette
|
||||
typedef struct
|
||||
{
|
||||
uint16_t data[256];
|
||||
int max; // max number of entries
|
||||
int used; // number of entries used
|
||||
} palette_t;
|
||||
|
||||
//---------------------------------------------------------
|
||||
// N64 RGBA/IA/I/CI -> intermediate RGBA/IA
|
||||
//---------------------------------------------------------
|
||||
|
||||
// N64 raw RGBA16/RGBA32 -> intermediate RGBA
|
||||
rgba *raw2rgba(const uint8_t *raw, int width, int height, int depth);
|
||||
|
||||
// N64 raw IA1/IA4/IA8/IA16 -> intermediate IA
|
||||
ia *raw2ia(const uint8_t *raw, int width, int height, int depth);
|
||||
|
||||
// N64 raw I4/I8 -> intermediate IA
|
||||
ia *raw2i(const uint8_t *raw, int width, int height, int depth);
|
||||
|
||||
//---------------------------------------------------------
|
||||
// intermediate RGBA/IA -> N64 RGBA/IA/I/CI
|
||||
// returns length written to 'raw' used or -1 on error
|
||||
//---------------------------------------------------------
|
||||
|
||||
// intermediate RGBA -> N64 raw RGBA16/RGBA32
|
||||
int rgba2raw(uint8_t *raw, const rgba *img, int width, int height, int depth);
|
||||
|
||||
// intermediate IA -> N64 raw IA1/IA4/IA8/IA16
|
||||
int ia2raw(uint8_t *raw, const ia *img, int width, int height, int depth);
|
||||
|
||||
// intermediate IA -> N64 raw I4/I8
|
||||
int i2raw(uint8_t *raw, const ia *img, int width, int height, int depth);
|
||||
|
||||
|
||||
//---------------------------------------------------------
|
||||
// N64 CI <-> N64 RGBA16/IA16
|
||||
//---------------------------------------------------------
|
||||
|
||||
// N64 CI raw data and palette to raw data (either RGBA16 or IA16)
|
||||
uint8_t *ci2raw(const uint8_t *rawci, const uint8_t *palette, int width, int height, int ci_depth);
|
||||
|
||||
// convert from raw (RGBA16 or IA16) format to CI + palette
|
||||
int raw2ci(uint8_t *rawci, palette_t *pal, const uint8_t *raw, int raw_len, int ci_depth);
|
||||
|
||||
|
||||
//---------------------------------------------------------
|
||||
// intermediate RGBA/IA -> PNG
|
||||
//---------------------------------------------------------
|
||||
|
||||
// intermediate RGBA write to PNG file
|
||||
int rgba2png(const char *png_filename, const rgba *img, int width, int height);
|
||||
|
||||
// intermediate IA write to grayscale PNG file
|
||||
int ia2png(const char *png_filename, const ia *img, int width, int height);
|
||||
|
||||
|
||||
//---------------------------------------------------------
|
||||
// PNG -> intermediate RGBA/IA
|
||||
//---------------------------------------------------------
|
||||
|
||||
// PNG file -> intermediate RGBA
|
||||
rgba *png2rgba(const char *png_filename, int *width, int *height);
|
||||
|
||||
// PNG file -> intermediate IA
|
||||
ia *png2ia(const char *png_filename, int *width, int *height);
|
||||
|
||||
|
||||
//---------------------------------------------------------
|
||||
// version
|
||||
//---------------------------------------------------------
|
||||
|
||||
// get version of underlying graphics reading library
|
||||
const char *n64graphics_get_read_version(void);
|
||||
|
||||
// get version of underlying graphics writing library
|
||||
const char *n64graphics_get_write_version(void);
|
||||
|
||||
#endif // N64GRAPHICS_H_
|
||||
@@ -1,276 +0,0 @@
|
||||
#include <dirent.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
#if defined(_MSC_VER) || defined(__MINGW32__)
|
||||
#include <io.h>
|
||||
#include <sys/utime.h>
|
||||
#else
|
||||
#include <unistd.h>
|
||||
#include <utime.h>
|
||||
#endif
|
||||
|
||||
#include "utils.h"
|
||||
|
||||
// global verbosity setting
|
||||
int g_verbosity = 0;
|
||||
|
||||
int read_s16_be(unsigned char *buf)
|
||||
{
|
||||
unsigned tmp = read_u16_be(buf);
|
||||
int ret;
|
||||
if (tmp > 0x7FFF) {
|
||||
ret = -((int)0x10000 - (int)tmp);
|
||||
} else {
|
||||
ret = (int)tmp;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
float read_f32_be(unsigned char *buf)
|
||||
{
|
||||
union {uint32_t i; float f;} ret;
|
||||
ret.i = read_u32_be(buf);
|
||||
return ret.f;
|
||||
}
|
||||
|
||||
int is_power2(unsigned int val)
|
||||
{
|
||||
while (((val & 1) == 0) && (val > 1)) {
|
||||
val >>= 1;
|
||||
}
|
||||
return (val == 1);
|
||||
}
|
||||
|
||||
void fprint_hex(FILE *fp, const unsigned char *buf, int length)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < length; i++) {
|
||||
fprint_byte(fp, buf[i]);
|
||||
fputc(' ', fp);
|
||||
}
|
||||
}
|
||||
|
||||
void fprint_hex_source(FILE *fp, const unsigned char *buf, int length)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < length; i++) {
|
||||
if (i > 0) fputs(", ", fp);
|
||||
fputs("0x", fp);
|
||||
fprint_byte(fp, buf[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void print_hex(const unsigned char *buf, int length)
|
||||
{
|
||||
fprint_hex(stdout, buf, length);
|
||||
}
|
||||
|
||||
void swap_bytes(unsigned char *data, long length)
|
||||
{
|
||||
long i;
|
||||
unsigned char tmp;
|
||||
for (i = 0; i < length; i += 2) {
|
||||
tmp = data[i];
|
||||
data[i] = data[i+1];
|
||||
data[i+1] = tmp;
|
||||
}
|
||||
}
|
||||
|
||||
void reverse_endian(unsigned char *data, long length)
|
||||
{
|
||||
long i;
|
||||
unsigned char tmp;
|
||||
for (i = 0; i < length; i += 4) {
|
||||
tmp = data[i];
|
||||
data[i] = data[i+3];
|
||||
data[i+3] = tmp;
|
||||
tmp = data[i+1];
|
||||
data[i+1] = data[i+2];
|
||||
data[i+2] = tmp;
|
||||
}
|
||||
}
|
||||
|
||||
long filesize(const char *filename)
|
||||
{
|
||||
struct stat st;
|
||||
|
||||
if (stat(filename, &st) == 0) {
|
||||
return st.st_size;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
void touch_file(const char *filename)
|
||||
{
|
||||
int fd;
|
||||
//fd = open(filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK, 0666);
|
||||
fd = open(filename, O_WRONLY|O_CREAT, 0666);
|
||||
if (fd >= 0) {
|
||||
utime(filename, NULL);
|
||||
close(fd);
|
||||
}
|
||||
}
|
||||
|
||||
long read_file(const char *file_name, unsigned char **data)
|
||||
{
|
||||
FILE *in;
|
||||
unsigned char *in_buf = NULL;
|
||||
long file_size;
|
||||
long bytes_read;
|
||||
in = fopen(file_name, "rb");
|
||||
if (in == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// allocate buffer to read from offset to end of file
|
||||
fseek(in, 0, SEEK_END);
|
||||
file_size = ftell(in);
|
||||
|
||||
// sanity check
|
||||
if (file_size > 256*MB) {
|
||||
return -2;
|
||||
}
|
||||
|
||||
in_buf = (unsigned char *)malloc(file_size);
|
||||
fseek(in, 0, SEEK_SET);
|
||||
|
||||
// read bytes
|
||||
bytes_read = fread(in_buf, 1, file_size, in);
|
||||
if (bytes_read != file_size) {
|
||||
return -3;
|
||||
}
|
||||
|
||||
fclose(in);
|
||||
*data = in_buf;
|
||||
return bytes_read;
|
||||
}
|
||||
|
||||
long write_file(const char *file_name, unsigned char *data, long length)
|
||||
{
|
||||
FILE *out;
|
||||
long bytes_written;
|
||||
// open output file
|
||||
out = fopen(file_name, "wb");
|
||||
if (out == NULL) {
|
||||
perror(file_name);
|
||||
return -1;
|
||||
}
|
||||
bytes_written = fwrite(data, 1, length, out);
|
||||
fclose(out);
|
||||
return bytes_written;
|
||||
}
|
||||
|
||||
void generate_filename(const char *in_name, char *out_name, char *extension)
|
||||
{
|
||||
char tmp_name[FILENAME_MAX];
|
||||
int len;
|
||||
int i;
|
||||
strcpy(tmp_name, in_name);
|
||||
len = strlen(tmp_name);
|
||||
for (i = len - 1; i > 0; i--) {
|
||||
if (tmp_name[i] == '.') {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (i <= 0) {
|
||||
i = len;
|
||||
}
|
||||
tmp_name[i] = '\0';
|
||||
sprintf(out_name, "%s.%s", tmp_name, extension);
|
||||
}
|
||||
|
||||
char *basename_(const char *name)
|
||||
{
|
||||
const char *base = name;
|
||||
while (*name) {
|
||||
if (*name++ == '/') {
|
||||
base = name;
|
||||
}
|
||||
}
|
||||
return (char *)base;
|
||||
}
|
||||
|
||||
void make_dir(const char *dir_name)
|
||||
{
|
||||
struct stat st = {0};
|
||||
if (stat(dir_name, &st) == -1) {
|
||||
mkdir(dir_name, 0755);
|
||||
}
|
||||
}
|
||||
|
||||
long copy_file(const char *src_name, const char *dst_name)
|
||||
{
|
||||
unsigned char *buf;
|
||||
long bytes_written;
|
||||
long bytes_read;
|
||||
|
||||
bytes_read = read_file(src_name, &buf);
|
||||
|
||||
if (bytes_read > 0) {
|
||||
bytes_written = write_file(dst_name, buf, bytes_read);
|
||||
if (bytes_written != bytes_read) {
|
||||
bytes_read = -1;
|
||||
}
|
||||
free(buf);
|
||||
}
|
||||
|
||||
return bytes_read;
|
||||
}
|
||||
|
||||
void dir_list_ext(const char *dir, const char *extension, dir_list *list)
|
||||
{
|
||||
char *pool;
|
||||
char *pool_ptr;
|
||||
struct dirent *entry;
|
||||
DIR *dfd;
|
||||
int idx;
|
||||
|
||||
dfd = opendir(dir);
|
||||
if (dfd == NULL) {
|
||||
ERROR("Can't open '%s'\n", dir);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
pool = (char *)malloc(FILENAME_MAX * MAX_DIR_FILES);
|
||||
pool_ptr = pool;
|
||||
|
||||
idx = 0;
|
||||
while ((entry = readdir(dfd)) != NULL && idx < MAX_DIR_FILES) {
|
||||
if (!extension || str_ends_with(entry->d_name, extension)) {
|
||||
sprintf(pool_ptr, "%s/%s", dir, entry->d_name);
|
||||
list->files[idx] = pool_ptr;
|
||||
pool_ptr += strlen(pool_ptr) + 1;
|
||||
idx++;
|
||||
}
|
||||
}
|
||||
list->count = idx;
|
||||
|
||||
closedir(dfd);
|
||||
}
|
||||
|
||||
void dir_list_free(dir_list *list)
|
||||
{
|
||||
// assume first entry in array is allocated
|
||||
if (list->files[0]) {
|
||||
free(list->files[0]);
|
||||
list->files[0] = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
int str_ends_with(const char *str, const char *suffix)
|
||||
{
|
||||
if (!str || !suffix) {
|
||||
return 0;
|
||||
}
|
||||
size_t len_str = strlen(str);
|
||||
size_t len_suffix = strlen(suffix);
|
||||
if (len_suffix > len_str) {
|
||||
return 0;
|
||||
}
|
||||
return (0 == strncmp(str + len_str - len_suffix, suffix, len_suffix));
|
||||
}
|
||||
@@ -1,153 +0,0 @@
|
||||
#ifndef UTILS_H_
|
||||
#define UTILS_H_
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
// defines
|
||||
|
||||
// printing size_t varies by compiler
|
||||
#if defined(_MSC_VER) || defined(__MINGW32__)
|
||||
#define SIZE_T_FORMAT "%Iu"
|
||||
#else
|
||||
#define SIZE_T_FORMAT "%zu"
|
||||
#endif
|
||||
|
||||
#define KB 1024
|
||||
#define MB (1024 * KB)
|
||||
|
||||
// number of elements in statically declared array
|
||||
#define DIM(S_ARR_) (sizeof(S_ARR_) / sizeof(S_ARR_[0]))
|
||||
|
||||
#define MIN(A_, B_) ((A_) < (B_) ? (A_) : (B_))
|
||||
#define MAX(A_, B_) ((A_) > (B_) ? (A_) : (B_))
|
||||
|
||||
// align value to N-byte boundary
|
||||
#define ALIGN(VAL_, ALIGNMENT_) (((VAL_) + ((ALIGNMENT_) - 1)) & ~((ALIGNMENT_) - 1))
|
||||
|
||||
// read/write u32/16 big/little endian
|
||||
#define read_u32_be(buf) (unsigned int)(((buf)[0] << 24) + ((buf)[1] << 16) + ((buf)[2] << 8) + ((buf)[3]))
|
||||
#define read_u32_le(buf) (unsigned int)(((buf)[1] << 24) + ((buf)[0] << 16) + ((buf)[3] << 8) + ((buf)[2]))
|
||||
#define write_u32_be(buf, val) do { \
|
||||
(buf)[0] = ((val) >> 24) & 0xFF; \
|
||||
(buf)[1] = ((val) >> 16) & 0xFF; \
|
||||
(buf)[2] = ((val) >> 8) & 0xFF; \
|
||||
(buf)[3] = (val) & 0xFF; \
|
||||
} while(0)
|
||||
#define read_u16_be(buf) (((buf)[0] << 8) + ((buf)[1]))
|
||||
#define write_u16_be(buf, val) do { \
|
||||
(buf)[0] = ((val) >> 8) & 0xFF; \
|
||||
(buf)[1] = ((val)) & 0xFF; \
|
||||
} while(0)
|
||||
|
||||
// print nibbles and bytes
|
||||
#define fprint_nibble(FP, NIB_) fputc((NIB_) < 10 ? ('0' + (NIB_)) : ('A' + (NIB_) - 0xA), FP)
|
||||
#define fprint_byte(FP, BYTE_) do { \
|
||||
fprint_nibble(FP, (BYTE_) >> 4); \
|
||||
fprint_nibble(FP, (BYTE_) & 0x0F); \
|
||||
} while(0)
|
||||
#define print_nibble(NIB_) fprint_nibble(stdout, NIB_)
|
||||
#define print_byte(BYTE_) fprint_byte(stdout, BYTE_)
|
||||
|
||||
// Windows compatibility
|
||||
#if defined(_MSC_VER) || defined(__MINGW32__)
|
||||
#include <direct.h>
|
||||
#define mkdir(DIR_, PERM_) _mkdir(DIR_)
|
||||
#ifndef strcasecmp
|
||||
#define strcasecmp(A, B) stricmp(A, B)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// typedefs
|
||||
|
||||
#define MAX_DIR_FILES 128
|
||||
typedef struct
|
||||
{
|
||||
char *files[MAX_DIR_FILES];
|
||||
int count;
|
||||
} dir_list;
|
||||
|
||||
// global verbosity setting
|
||||
extern int g_verbosity;
|
||||
|
||||
#define ERROR(...) fprintf(stderr, __VA_ARGS__)
|
||||
#define INFO(...) if (g_verbosity) printf(__VA_ARGS__)
|
||||
#define INFO_HEX(...) if (g_verbosity) print_hex(__VA_ARGS__)
|
||||
|
||||
// functions
|
||||
|
||||
// convert two bytes in big-endian to signed int
|
||||
int read_s16_be(unsigned char *buf);
|
||||
|
||||
// convert four bytes in big-endian to float
|
||||
float read_f32_be(unsigned char *buf);
|
||||
|
||||
// determine if value is power of 2
|
||||
// returns 1 if val is power of 2, 0 otherwise
|
||||
int is_power2(unsigned int val);
|
||||
|
||||
// print buffer as hex bytes
|
||||
// fp: file pointer
|
||||
// buf: buffer to read bytes from
|
||||
// length: length of buffer to print
|
||||
void fprint_hex(FILE *fp, const unsigned char *buf, int length);
|
||||
void fprint_hex_source(FILE *fp, const unsigned char *buf, int length);
|
||||
void print_hex(const unsigned char *buf, int length);
|
||||
|
||||
// perform byteswapping to convert from v64 to z64 ordering
|
||||
void swap_bytes(unsigned char *data, long length);
|
||||
|
||||
// reverse endian to convert from n64 to z64 ordering
|
||||
void reverse_endian(unsigned char *data, long length);
|
||||
|
||||
// get size of file without opening it;
|
||||
// returns file size or negative on error
|
||||
long filesize(const char *file_name);
|
||||
|
||||
// update file timestamp to now, creating it if it doesn't exist
|
||||
void touch_file(const char *filename);
|
||||
|
||||
// read entire contents of file into buffer
|
||||
// returns file size or negative on error
|
||||
long read_file(const char *file_name, unsigned char **data);
|
||||
|
||||
// write buffer to file
|
||||
// returns number of bytes written out or -1 on failure
|
||||
long write_file(const char *file_name, unsigned char *data, long length);
|
||||
|
||||
// generate an output file name from input name by replacing file extension
|
||||
// in_name: input file name
|
||||
// out_name: buffer to write output name in
|
||||
// extension: new file extension to use
|
||||
void generate_filename(const char *in_name, char *out_name, char *extension);
|
||||
|
||||
// extract base filename from file path
|
||||
// name: path to file
|
||||
// returns just the file name after the last '/'
|
||||
char *basename_(const char *name);
|
||||
|
||||
// make a directory if it doesn't exist
|
||||
// dir_name: name of the directory
|
||||
void make_dir(const char *dir_name);
|
||||
|
||||
// copy a file from src_name to dst_name. will not make directories
|
||||
// src_name: source file name
|
||||
// dst_name: destination file name
|
||||
long copy_file(const char *src_name, const char *dst_name);
|
||||
|
||||
// list a directory, optionally filtering files by extension
|
||||
// dir: directory to list files in
|
||||
// extension: extension to filter files by (NULL if no filtering)
|
||||
// list: output list and count
|
||||
void dir_list_ext(const char *dir, const char *extension, dir_list *list);
|
||||
|
||||
// free associated date from a directory list
|
||||
// list: directory list filled in by dir_list_ext() call
|
||||
void dir_list_free(dir_list *list);
|
||||
|
||||
// determine if a string ends with another string
|
||||
// str: string to check if ends with 'suffix'
|
||||
// suffix: string to see if 'str' ends with
|
||||
// returns 1 if 'str' ends with 'suffix'
|
||||
int str_ends_with(const char *str, const char *suffix);
|
||||
|
||||
#endif // UTILS_H_
|
||||
Reference in New Issue
Block a user