mirror of
https://github.com/ClassiCube/ClassiCube.git
synced 2025-09-13 09:35:23 -04:00
Bitmap shouldn't be typedefed
This commit is contained in:
UnknownShadow200
parent
f2cfdb372d
commit
e221e9f343
@ -15,7 +15,7 @@
|
||||
#define LIQUID_ANIM_MAX 64
|
||||
#define WATER_TEX_LOC 14
|
||||
#define LAVA_TEX_LOC 30
|
||||
static void Animations_Update(int loc, Bitmap* bmp, int stride);
|
||||
static void Animations_Update(int loc, struct Bitmap* bmp, int stride);
|
||||
|
||||
#ifndef CC_BUILD_WEB
|
||||
/* Based off the incredible work from https://dl.dropboxusercontent.com/u/12694594/lava.txt
|
||||
@ -37,7 +37,7 @@ static void LavaAnimation_Tick(void) {
|
||||
float soupHeat, potHeat, col;
|
||||
int size, mask, shift;
|
||||
int x, y, i = 0;
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
|
||||
size = min(Atlas2D.TileSize, LIQUID_ANIM_MAX);
|
||||
mask = size - 1;
|
||||
@ -118,7 +118,7 @@ static void WaterAnimation_Tick(void) {
|
||||
float soupHeat, col;
|
||||
int size, mask, shift;
|
||||
int x, y, i = 0;
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
|
||||
size = min(Atlas2D.TileSize, LIQUID_ANIM_MAX);
|
||||
mask = size - 1;
|
||||
@ -179,7 +179,7 @@ struct AnimationData {
|
||||
cc_uint16 frameDelay; /* Delay between each frame */
|
||||
};
|
||||
|
||||
static Bitmap anims_bmp;
|
||||
static struct Bitmap anims_bmp;
|
||||
static struct AnimationData anims_list[ATLAS1D_MAX_ATLASES];
|
||||
static int anims_count;
|
||||
static cc_bool anims_validated, useLavaAnim, useWaterAnim, alwaysLavaAnim, alwaysWaterAnim;
|
||||
@ -242,7 +242,7 @@ static void Animations_ReadDescription(struct Stream* stream, const String* path
|
||||
}
|
||||
}
|
||||
|
||||
static void Animations_Update(int texLoc, Bitmap* bmp, int stride) {
|
||||
static void Animations_Update(int texLoc, struct Bitmap* bmp, int stride) {
|
||||
int dstX = Atlas1D_Index(texLoc);
|
||||
int dstY = Atlas1D_RowId(texLoc) * Atlas2D.TileSize;
|
||||
GfxResourceID tex;
|
||||
@ -252,8 +252,8 @@ static void Animations_Update(int texLoc, Bitmap* bmp, int stride) {
|
||||
}
|
||||
|
||||
static void Animations_Apply(struct AnimationData* data) {
|
||||
struct Bitmap frame;
|
||||
int loc, size;
|
||||
Bitmap frame;
|
||||
if (data->delay) { data->delay--; return; }
|
||||
|
||||
data->state++;
|
||||
|
||||
23
src/Bitmap.c
23
src/Bitmap.c
@ -8,7 +8,8 @@
|
||||
#include "Errors.h"
|
||||
#include "Utils.h"
|
||||
|
||||
void Bitmap_UNSAFE_CopyBlock(int srcX, int srcY, int dstX, int dstY, Bitmap* src, Bitmap* dst, int size) {
|
||||
void Bitmap_UNSAFE_CopyBlock(int srcX, int srcY, int dstX, int dstY,
|
||||
struct Bitmap* src, struct Bitmap* dst, int size) {
|
||||
int x, y;
|
||||
for (y = 0; y < size; y++) {
|
||||
BitmapCol* srcRow = Bitmap_GetRow(src, srcY + y) + srcX;
|
||||
@ -17,17 +18,17 @@ void Bitmap_UNSAFE_CopyBlock(int srcX, int srcY, int dstX, int dstY, Bitmap* src
|
||||
}
|
||||
}
|
||||
|
||||
void Bitmap_Allocate(Bitmap* bmp, int width, int height) {
|
||||
void Bitmap_Allocate(struct Bitmap* bmp, int width, int height) {
|
||||
bmp->width = width; bmp->height = height;
|
||||
bmp->scan0 = (BitmapCol*)Mem_Alloc(width * height, 4, "bitmap data");
|
||||
}
|
||||
|
||||
void Bitmap_TryAllocate(Bitmap* bmp, int width, int height) {
|
||||
void Bitmap_TryAllocate(struct Bitmap* bmp, int width, int height) {
|
||||
bmp->width = width; bmp->height = height;
|
||||
bmp->scan0 = (BitmapCol*)Mem_TryAlloc(width * height, 4);
|
||||
}
|
||||
|
||||
void Bitmap_AllocateClearedPow2(Bitmap* bmp, int width, int height) {
|
||||
void Bitmap_AllocateClearedPow2(struct Bitmap* bmp, int width, int height) {
|
||||
width = Math_NextPowOf2(width);
|
||||
height = Math_NextPowOf2(height);
|
||||
|
||||
@ -35,7 +36,7 @@ void Bitmap_AllocateClearedPow2(Bitmap* bmp, int width, int height) {
|
||||
bmp->scan0 = (BitmapCol*)Mem_AllocCleared(width * height, 4, "bitmap data");
|
||||
}
|
||||
|
||||
void Bitmap_TryAllocateClearedPow2(Bitmap* bmp, int width, int height) {
|
||||
void Bitmap_TryAllocateClearedPow2(struct Bitmap* bmp, int width, int height) {
|
||||
width = Math_NextPowOf2(width);
|
||||
height = Math_NextPowOf2(height);
|
||||
|
||||
@ -43,7 +44,8 @@ void Bitmap_TryAllocateClearedPow2(Bitmap* bmp, int width, int height) {
|
||||
bmp->scan0 = (BitmapCol*)Mem_TryAllocCleared(width * height, 4);
|
||||
}
|
||||
|
||||
void Bitmap_Scale(Bitmap* dst, Bitmap* src, int srcX, int srcY, int srcWidth, int srcHeight) {
|
||||
void Bitmap_Scale(struct Bitmap* dst, struct Bitmap* src,
|
||||
int srcX, int srcY, int srcWidth, int srcHeight) {
|
||||
BitmapCol* dstRow;
|
||||
BitmapCol* srcRow;
|
||||
int x, y, width, height;
|
||||
@ -320,7 +322,7 @@ static Png_RowExpander Png_GetExpander(cc_uint8 col, cc_uint8 bitsPerSample) {
|
||||
}
|
||||
|
||||
/* Sets alpha to 0 for any pixels in the bitmap whose RGB is same as col */
|
||||
static void ComputeTransparency(Bitmap* bmp, BitmapCol col) {
|
||||
static void ComputeTransparency(struct Bitmap* bmp, BitmapCol col) {
|
||||
BitmapCol trnsRGB = col & BITMAPCOL_RGB_MASK;
|
||||
int x, y, width = bmp->width, height = bmp->height;
|
||||
|
||||
@ -338,7 +340,7 @@ static void ComputeTransparency(Bitmap* bmp, BitmapCol col) {
|
||||
#define PNG_BUFFER_SIZE ((PNG_MAX_DIMS * 2 * 4 + 1) * 2)
|
||||
|
||||
/* TODO: Test a lot of .png files and ensure output is right */
|
||||
cc_result Png_Decode(Bitmap* bmp, struct Stream* stream) {
|
||||
cc_result Png_Decode(struct Bitmap* bmp, struct Stream* stream) {
|
||||
cc_uint8 tmp[PNG_PALETTE * 3];
|
||||
cc_uint32 dataSize, fourCC;
|
||||
cc_result res;
|
||||
@ -630,8 +632,9 @@ static void Png_EncodeRow(const cc_uint8* cur, const cc_uint8* prior, cc_uint8*
|
||||
best[0] = bestFilter;
|
||||
}
|
||||
|
||||
static int Png_SelectRow(Bitmap* bmp, int y) { return y; }
|
||||
cc_result Png_Encode(Bitmap* bmp, struct Stream* stream, Png_RowSelector selectRow, cc_bool alpha) {
|
||||
static int Png_SelectRow(struct Bitmap* bmp, int y) { return y; }
|
||||
cc_result Png_Encode(struct Bitmap* bmp, struct Stream* stream,
|
||||
Png_RowSelector selectRow, cc_bool alpha) {
|
||||
cc_uint8 tmp[32];
|
||||
/* TODO: This should be * 4 for alpha (should switch to mem_alloc though) */
|
||||
cc_uint8 prevLine[PNG_MAX_DIMS * 3], curLine[PNG_MAX_DIMS * 3];
|
||||
|
||||
23
src/Bitmap.h
23
src/Bitmap.h
@ -42,7 +42,7 @@ typedef cc_uint32 BitmapCol;
|
||||
#define BITMAPCOL_WHITE BitmapCol_Make(255, 255, 255, 255)
|
||||
|
||||
/* A 2D array of BitmapCol pixels */
|
||||
typedef struct Bitmap_ { BitmapCol* scan0; int width, height; } Bitmap;
|
||||
struct Bitmap { BitmapCol* scan0; int width, height; };
|
||||
#define PNG_MAX_DIMS 0x8000
|
||||
|
||||
/* Returns number of bytes a bitmap consumes. */
|
||||
@ -58,34 +58,37 @@ typedef struct Bitmap_ { BitmapCol* scan0; int width, height; } Bitmap;
|
||||
/* Copies a rectangle of pixels from one bitmap to another. */
|
||||
/* NOTE: If src and dst are the same, src and dst rectangles MUST NOT overlap. */
|
||||
/* NOTE: Rectangles are NOT checked for whether they lie inside the bitmaps. */
|
||||
void Bitmap_UNSAFE_CopyBlock(int srcX, int srcY, int dstX, int dstY, Bitmap* src, Bitmap* dst, int size);
|
||||
void Bitmap_UNSAFE_CopyBlock(int srcX, int srcY, int dstX, int dstY,
|
||||
struct Bitmap* src, struct Bitmap* dst, int size);
|
||||
/* Allocates a new bitmap of the given dimensions. */
|
||||
/* NOTE: You are responsible for freeing its memory! */
|
||||
void Bitmap_Allocate(Bitmap* bmp, int width, int height);
|
||||
void Bitmap_Allocate(struct Bitmap* bmp, int width, int height);
|
||||
/* Attemps to allocates a new bitmap of the given dimensions. */
|
||||
/* NOTE: You are responsible for freeing its memory! */
|
||||
void Bitmap_TryAllocate(Bitmap* bmp, int width, int height);
|
||||
void Bitmap_TryAllocate(struct Bitmap* bmp, int width, int height);
|
||||
/* Allocates a power-of-2 sized bitmap equal to or greater than the given size, and clears it to 0. */
|
||||
/* NOTE: You are responsible for freeing its memory! */
|
||||
void Bitmap_AllocateClearedPow2(Bitmap* bmp, int width, int height);
|
||||
void Bitmap_AllocateClearedPow2(struct Bitmap* bmp, int width, int height);
|
||||
/* Attempts to allocate a power-of-2 sized bitmap >= than the given size, and clears it to 0. */
|
||||
/* NOTE: You are responsible for freeing its memory! */
|
||||
void Bitmap_TryAllocateClearedPow2(Bitmap* bmp, int width, int height);
|
||||
void Bitmap_TryAllocateClearedPow2(struct Bitmap* bmp, int width, int height);
|
||||
/* Scales a region of the source bitmap to occupy the entirety of the destination bitmap. */
|
||||
/* The pixels from the region are scaled upwards or downwards depending on destination width and height. */
|
||||
CC_API void Bitmap_Scale(Bitmap* dst, Bitmap* src, int srcX, int srcY, int srcWidth, int srcHeight);
|
||||
CC_API void Bitmap_Scale(struct Bitmap* dst, struct Bitmap* src,
|
||||
int srcX, int srcY, int srcWidth, int srcHeight);
|
||||
|
||||
/* Whether data starts with PNG format signature/identifier. */
|
||||
cc_bool Png_Detect(const cc_uint8* data, cc_uint32 len);
|
||||
typedef int (*Png_RowSelector)(Bitmap* bmp, int row);
|
||||
typedef int (*Png_RowSelector)(struct Bitmap* bmp, int row);
|
||||
/*
|
||||
Decodes a bitmap in PNG format. Partially based off information from
|
||||
https://handmade.network/forums/wip/t/2363-implementing_a_basic_png_reader_the_handmade_way
|
||||
https://github.com/nothings/stb/blob/master/stb_image.h
|
||||
*/
|
||||
CC_API cc_result Png_Decode(Bitmap* bmp, struct Stream* stream);
|
||||
CC_API cc_result Png_Decode(struct Bitmap* bmp, struct Stream* stream);
|
||||
/* Encodes a bitmap in PNG format. */
|
||||
/* selectRow is optional. Can be used to modify how rows are encoded. (e.g. flip image) */
|
||||
/* if alpha is non-zero, RGBA channels are saved, otherwise only RGB channels are. */
|
||||
CC_API cc_result Png_Encode(Bitmap* bmp, struct Stream* stream, Png_RowSelector selectRow, cc_bool alpha);
|
||||
CC_API cc_result Png_Encode(struct Bitmap* bmp, struct Stream* stream,
|
||||
Png_RowSelector selectRow, cc_bool alpha);
|
||||
#endif
|
||||
|
||||
18
src/Block.c
18
src/Block.c
@ -342,7 +342,7 @@ void Block_RecalculateAllSpriteBB(void) {
|
||||
}
|
||||
}
|
||||
|
||||
static float Block_GetSpriteBB_MinX(int size, int tileX, int tileY, const Bitmap* bmp) {
|
||||
static float GetSpriteBB_MinX(int size, int tileX, int tileY, const struct Bitmap* bmp) {
|
||||
BitmapCol* row;
|
||||
int x, y;
|
||||
|
||||
@ -355,7 +355,7 @@ static float Block_GetSpriteBB_MinX(int size, int tileX, int tileY, const Bitmap
|
||||
return 1.0f;
|
||||
}
|
||||
|
||||
static float Block_GetSpriteBB_MinY(int size, int tileX, int tileY, const Bitmap* bmp) {
|
||||
static float GetSpriteBB_MinY(int size, int tileX, int tileY, const struct Bitmap* bmp) {
|
||||
BitmapCol* row;
|
||||
int x, y;
|
||||
|
||||
@ -368,7 +368,7 @@ static float Block_GetSpriteBB_MinY(int size, int tileX, int tileY, const Bitmap
|
||||
return 1.0f;
|
||||
}
|
||||
|
||||
static float Block_GetSpriteBB_MaxX(int size, int tileX, int tileY, const Bitmap* bmp) {
|
||||
static float GetSpriteBB_MaxX(int size, int tileX, int tileY, const struct Bitmap* bmp) {
|
||||
BitmapCol* row;
|
||||
int x, y;
|
||||
|
||||
@ -381,7 +381,7 @@ static float Block_GetSpriteBB_MaxX(int size, int tileX, int tileY, const Bitmap
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
static float Block_GetSpriteBB_MaxY(int size, int tileX, int tileY, const Bitmap* bmp) {
|
||||
static float GetSpriteBB_MaxY(int size, int tileX, int tileY, const struct Bitmap* bmp) {
|
||||
BitmapCol* row;
|
||||
int x, y;
|
||||
|
||||
@ -395,7 +395,7 @@ static float Block_GetSpriteBB_MaxY(int size, int tileX, int tileY, const Bitmap
|
||||
}
|
||||
|
||||
void Block_RecalculateBB(BlockID block) {
|
||||
Bitmap* bmp = &Atlas2D.Bmp;
|
||||
struct Bitmap* bmp = &Atlas2D.Bmp;
|
||||
int tileSize = Atlas2D.TileSize;
|
||||
TextureLoc texLoc = Block_Tex(block, FACE_XMAX);
|
||||
int x = Atlas2D_TileX(texLoc), y = Atlas2D_TileY(texLoc);
|
||||
@ -405,10 +405,10 @@ void Block_RecalculateBB(BlockID block) {
|
||||
Vec3 minRaw, maxRaw;
|
||||
|
||||
if (y < Atlas2D.RowsCount) {
|
||||
minX = Block_GetSpriteBB_MinX(tileSize, x, y, bmp);
|
||||
minY = Block_GetSpriteBB_MinY(tileSize, x, y, bmp);
|
||||
maxX = Block_GetSpriteBB_MaxX(tileSize, x, y, bmp);
|
||||
maxY = Block_GetSpriteBB_MaxY(tileSize, x, y, bmp);
|
||||
minX = GetSpriteBB_MinX(tileSize, x, y, bmp);
|
||||
minY = GetSpriteBB_MinY(tileSize, x, y, bmp);
|
||||
maxX = GetSpriteBB_MaxX(tileSize, x, y, bmp);
|
||||
maxY = GetSpriteBB_MaxY(tileSize, x, y, bmp);
|
||||
}
|
||||
|
||||
minRaw = Vec3_RotateY3(minX - 0.5f, minY, 0.0f, 45.0f * MATH_DEG2RAD);
|
||||
|
||||
@ -100,7 +100,7 @@ static void CheckFont(void) {
|
||||
Logger_Abort("Unable to init default font");
|
||||
}
|
||||
|
||||
static Bitmap fontBitmap;
|
||||
static struct Bitmap fontBitmap;
|
||||
static int tileSize = 8; /* avoid divide by 0 if default.png missing */
|
||||
/* So really 16 characters per row */
|
||||
#define LOG2_CHARS_PER_ROW 4
|
||||
@ -138,7 +138,7 @@ static void FreeFontBitmap(void) {
|
||||
Mem_Free(fontBitmap.scan0);
|
||||
}
|
||||
|
||||
cc_bool Drawer2D_SetFontBitmap(Bitmap* bmp) {
|
||||
cc_bool Drawer2D_SetFontBitmap(struct Bitmap* bmp) {
|
||||
/* If not all of these cases are accounted for, end up overwriting memory after tileWidths */
|
||||
if (bmp->width != bmp->height) {
|
||||
static const String msg = String_FromConst("&cWidth of default.png must equal its height");
|
||||
@ -174,13 +174,13 @@ void Font_ReducePadding(struct FontDesc* desc, int scale) {
|
||||
/* Measures width of the given text when drawn with the given system font. */
|
||||
static int Font_SysTextWidth(struct DrawTextArgs* args);
|
||||
/* Draws the given text with the given system font onto the given bitmap. */
|
||||
static void Font_SysTextDraw(struct DrawTextArgs* args, Bitmap* bmp, int x, int y, cc_bool shadow);
|
||||
static void Font_SysTextDraw(struct DrawTextArgs* args, struct Bitmap* bmp, int x, int y, cc_bool shadow);
|
||||
|
||||
|
||||
/*########################################################################################################################*
|
||||
*---------------------------------------------------Drawing functions-----------------------------------------------------*
|
||||
*#########################################################################################################################*/
|
||||
cc_bool Drawer2D_Clamp(Bitmap* bmp, int* x, int* y, int* width, int* height) {
|
||||
cc_bool Drawer2D_Clamp(struct Bitmap* bmp, int* x, int* y, int* width, int* height) {
|
||||
if (*x >= bmp->width || *y >= bmp->height) return false;
|
||||
|
||||
/* origin is negative, move inside */
|
||||
@ -193,7 +193,7 @@ cc_bool Drawer2D_Clamp(Bitmap* bmp, int* x, int* y, int* width, int* height) {
|
||||
}
|
||||
#define Drawer2D_ClampPixel(p) p = (p < 0 ? 0 : (p > 255 ? 255 : p))
|
||||
|
||||
void Gradient_Noise(Bitmap* bmp, BitmapCol col, int variation,
|
||||
void Gradient_Noise(struct Bitmap* bmp, BitmapCol col, int variation,
|
||||
int x, int y, int width, int height) {
|
||||
BitmapCol* dst;
|
||||
int R, G, B, xx, yy, n;
|
||||
@ -217,7 +217,7 @@ void Gradient_Noise(Bitmap* bmp, BitmapCol col, int variation,
|
||||
}
|
||||
}
|
||||
|
||||
void Gradient_Vertical(Bitmap* bmp, BitmapCol a, BitmapCol b,
|
||||
void Gradient_Vertical(struct Bitmap* bmp, BitmapCol a, BitmapCol b,
|
||||
int x, int y, int width, int height) {
|
||||
BitmapCol* row, col;
|
||||
int xx, yy;
|
||||
@ -238,7 +238,7 @@ void Gradient_Vertical(Bitmap* bmp, BitmapCol a, BitmapCol b,
|
||||
}
|
||||
}
|
||||
|
||||
void Gradient_Blend(Bitmap* bmp, BitmapCol col, int blend,
|
||||
void Gradient_Blend(struct Bitmap* bmp, BitmapCol col, int blend,
|
||||
int x, int y, int width, int height) {
|
||||
BitmapCol* dst;
|
||||
int R, G, B, xx, yy;
|
||||
@ -267,7 +267,7 @@ void Gradient_Blend(Bitmap* bmp, BitmapCol col, int blend,
|
||||
}
|
||||
}
|
||||
|
||||
void Gradient_Tint(Bitmap* bmp, cc_uint8 tintA, cc_uint8 tintB,
|
||||
void Gradient_Tint(struct Bitmap* bmp, cc_uint8 tintA, cc_uint8 tintB,
|
||||
int x, int y, int width, int height) {
|
||||
BitmapCol* row, col;
|
||||
cc_uint8 tint;
|
||||
@ -291,7 +291,7 @@ void Gradient_Tint(Bitmap* bmp, cc_uint8 tintA, cc_uint8 tintB,
|
||||
}
|
||||
}
|
||||
|
||||
void Drawer2D_BmpCopy(Bitmap* dst, int x, int y, Bitmap* src) {
|
||||
void Drawer2D_BmpCopy(struct Bitmap* dst, int x, int y, struct Bitmap* src) {
|
||||
int width = src->width, height = src->height;
|
||||
BitmapCol* dstRow;
|
||||
BitmapCol* srcRow;
|
||||
@ -306,7 +306,8 @@ void Drawer2D_BmpCopy(Bitmap* dst, int x, int y, Bitmap* src) {
|
||||
}
|
||||
}
|
||||
|
||||
void Drawer2D_Clear(Bitmap* bmp, BitmapCol col, int x, int y, int width, int height) {
|
||||
void Drawer2D_Clear(struct Bitmap* bmp, BitmapCol col,
|
||||
int x, int y, int width, int height) {
|
||||
BitmapCol* row;
|
||||
int xx, yy;
|
||||
if (!Drawer2D_Clamp(bmp, &x, &y, &width, &height)) return;
|
||||
@ -320,8 +321,8 @@ void Drawer2D_Clear(Bitmap* bmp, BitmapCol col, int x, int y, int width, int hei
|
||||
|
||||
void Drawer2D_MakeTextTexture(struct Texture* tex, struct DrawTextArgs* args) {
|
||||
static struct Texture empty = { 0, Tex_Rect(0,0, 0,0), Tex_UV(0,0, 1,1) };
|
||||
struct Bitmap bmp;
|
||||
int width, height;
|
||||
Bitmap bmp;
|
||||
/* pointless to draw anything when context is lost */
|
||||
if (Gfx.LostContext) { *tex = empty; return; }
|
||||
|
||||
@ -337,7 +338,7 @@ void Drawer2D_MakeTextTexture(struct Texture* tex, struct DrawTextArgs* args) {
|
||||
Mem_Free(bmp.scan0);
|
||||
}
|
||||
|
||||
void Drawer2D_MakeTexture(struct Texture* tex, Bitmap* bmp, int width, int height) {
|
||||
void Drawer2D_MakeTexture(struct Texture* tex, struct Bitmap* bmp, int width, int height) {
|
||||
tex->ID = Gfx_CreateTexture(bmp, false, false);
|
||||
tex->X = 0; tex->Width = width;
|
||||
tex->Y = 0; tex->Height = height;
|
||||
@ -417,7 +418,7 @@ void Drawer2D_ReducePadding_Height(int* height, int point, int scale) {
|
||||
}
|
||||
|
||||
/* Quickly fills the given box region */
|
||||
static void Drawer2D_Underline(Bitmap* bmp, int x, int y, int width, int height, BitmapCol col) {
|
||||
static void Drawer2D_Underline(struct Bitmap* bmp, int x, int y, int width, int height, BitmapCol col) {
|
||||
BitmapCol* row;
|
||||
int xx, yy;
|
||||
|
||||
@ -432,7 +433,7 @@ static void Drawer2D_Underline(Bitmap* bmp, int x, int y, int width, int height,
|
||||
}
|
||||
}
|
||||
|
||||
static void DrawBitmappedTextCore(Bitmap* bmp, struct DrawTextArgs* args, int x, int y, cc_bool shadow) {
|
||||
static void DrawBitmappedTextCore(struct Bitmap* bmp, struct DrawTextArgs* args, int x, int y, cc_bool shadow) {
|
||||
BitmapCol col;
|
||||
String text = args->text;
|
||||
int i, point = args->font->size, count = 0;
|
||||
@ -530,7 +531,7 @@ static void DrawBitmappedTextCore(Bitmap* bmp, struct DrawTextArgs* args, int x,
|
||||
}
|
||||
}
|
||||
|
||||
static void DrawBitmappedText(Bitmap* bmp, struct DrawTextArgs* args, int x, int y) {
|
||||
static void DrawBitmappedText(struct Bitmap* bmp, struct DrawTextArgs* args, int x, int y) {
|
||||
int offset = Drawer2D_ShadowOffset(args->font->size);
|
||||
|
||||
if (args->useShadow) {
|
||||
@ -565,7 +566,7 @@ static int MeasureBitmappedWidth(const struct DrawTextArgs* args) {
|
||||
return width;
|
||||
}
|
||||
|
||||
void Drawer2D_DrawText(Bitmap* bmp, struct DrawTextArgs* args, int x, int y) {
|
||||
void Drawer2D_DrawText(struct Bitmap* bmp, struct DrawTextArgs* args, int x, int y) {
|
||||
if (Drawer2D_IsEmptyText(&args->text)) return;
|
||||
if (Drawer2D_BitmappedText) { DrawBitmappedText(bmp, args, x, y); return; }
|
||||
|
||||
@ -593,7 +594,8 @@ int Drawer2D_FontHeight(const struct FontDesc* font, cc_bool useShadow) {
|
||||
return height;
|
||||
}
|
||||
|
||||
void Drawer2D_DrawClippedText(Bitmap* bmp, struct DrawTextArgs* args, int x, int y, int maxWidth) {
|
||||
void Drawer2D_DrawClippedText(struct Bitmap* bmp, struct DrawTextArgs* args,
|
||||
int x, int y, int maxWidth) {
|
||||
char strBuffer[512];
|
||||
struct DrawTextArgs part;
|
||||
int i, width;
|
||||
@ -652,7 +654,7 @@ static void OnReset(void) {
|
||||
}
|
||||
|
||||
static void OnFileChanged(void* obj, struct Stream* src, const String* name) {
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
cc_result res;
|
||||
if (!String_CaselessEqualsConst(name, "default.png")) return;
|
||||
|
||||
@ -712,7 +714,7 @@ void Font_Free(struct FontDesc* desc) {
|
||||
|
||||
void SysFonts_Register(const String* path) { }
|
||||
static int Font_SysTextWidth(struct DrawTextArgs* args) { return 0; }
|
||||
static void Font_SysTextDraw(struct DrawTextArgs* args, Bitmap* bmp, int x, int y, cc_bool shadow) { }
|
||||
static void Font_SysTextDraw(struct DrawTextArgs* args, struct Bitmap* bmp, int x, int y, cc_bool shadow) { }
|
||||
#else
|
||||
#include "freetype/ft2build.h"
|
||||
#include "freetype/freetype.h"
|
||||
@ -1057,7 +1059,7 @@ static int Font_SysTextWidth(struct DrawTextArgs* args) {
|
||||
return width;
|
||||
}
|
||||
|
||||
static void DrawGrayscaleGlyph(FT_Bitmap* img, Bitmap* bmp, int x, int y, BitmapCol col) {
|
||||
static void DrawGrayscaleGlyph(FT_Bitmap* img, struct Bitmap* bmp, int x, int y, BitmapCol col) {
|
||||
cc_uint8* src;
|
||||
BitmapCol* dst;
|
||||
cc_uint8 I, invI; /* intensity */
|
||||
@ -1085,7 +1087,7 @@ static void DrawGrayscaleGlyph(FT_Bitmap* img, Bitmap* bmp, int x, int y, Bitmap
|
||||
}
|
||||
}
|
||||
|
||||
static void DrawBlackWhiteGlyph(FT_Bitmap* img, Bitmap* bmp, int x, int y, BitmapCol col) {
|
||||
static void DrawBlackWhiteGlyph(FT_Bitmap* img, struct Bitmap* bmp, int x, int y, BitmapCol col) {
|
||||
cc_uint8* src;
|
||||
BitmapCol* dst;
|
||||
cc_uint8 intensity;
|
||||
@ -1109,7 +1111,7 @@ static void DrawBlackWhiteGlyph(FT_Bitmap* img, Bitmap* bmp, int x, int y, Bitma
|
||||
}
|
||||
|
||||
static FT_Vector shadow_delta = { 83, -83 };
|
||||
static void Font_SysTextDraw(struct DrawTextArgs* args, Bitmap* bmp, int x, int y, cc_bool shadow) {
|
||||
static void Font_SysTextDraw(struct DrawTextArgs* args, struct Bitmap* bmp, int x, int y, cc_bool shadow) {
|
||||
struct SysFont* font = (struct SysFont*)args->font->handle;
|
||||
FT_BitmapGlyph* glyphs = font->glyphs;
|
||||
|
||||
|
||||
@ -31,39 +31,41 @@ extern String Drawer2D_FontName;
|
||||
|
||||
/* Clamps the given rectangle to line inside the bitmap. */
|
||||
/* Returns false if rectangle is completely outside bitmap's rectangle. */
|
||||
cc_bool Drawer2D_Clamp(Bitmap* bmp, int* x, int* y, int* width, int* height);
|
||||
cc_bool Drawer2D_Clamp(struct Bitmap* bmp, int* x, int* y, int* width, int* height);
|
||||
|
||||
/* Fills the given area with a simple noisy pattern. */
|
||||
/* Variation determines how 'visible/obvious' the noise is. */
|
||||
CC_API void Gradient_Noise(Bitmap* bmp, BitmapCol col, int variation,
|
||||
CC_API void Gradient_Noise(struct Bitmap* bmp, BitmapCol col, int variation,
|
||||
int x, int y, int width, int height);
|
||||
/* Fills the given area with a vertical gradient, linerarly interpolating from a to b. */
|
||||
/* First drawn row is filled with 'a', while last drawn is filled with 'b'. */
|
||||
CC_API void Gradient_Vertical(Bitmap* bmp, BitmapCol a, BitmapCol b,
|
||||
CC_API void Gradient_Vertical(struct Bitmap* bmp, BitmapCol a, BitmapCol b,
|
||||
int x, int y, int width, int height);
|
||||
/* Blends the given area with the given colour. */
|
||||
/* Note that this only blends RGB, A is not blended. */
|
||||
CC_API void Gradient_Blend(Bitmap* bmp, BitmapCol col, int blend,
|
||||
CC_API void Gradient_Blend(struct Bitmap* bmp, BitmapCol col, int blend,
|
||||
int x, int y, int width, int height);
|
||||
/* Tints the given area, linearly interpolating from a to b. */
|
||||
/* Note that this only tints RGB, A is not tinted. */
|
||||
CC_API void Gradient_Tint(Bitmap* bmp, cc_uint8 tintA, cc_uint8 tintB,
|
||||
CC_API void Gradient_Tint(struct Bitmap* bmp, cc_uint8 tintA, cc_uint8 tintB,
|
||||
int x, int y, int width, int height);
|
||||
|
||||
/* Fills the given area using pixels from the source bitmap. */
|
||||
CC_API void Drawer2D_BmpCopy(Bitmap* dst, int x, int y, Bitmap* src);
|
||||
CC_API void Drawer2D_BmpCopy(struct Bitmap* dst, int x, int y, struct Bitmap* src);
|
||||
/* Fills the area with the given colour. */
|
||||
CC_API void Drawer2D_Clear(Bitmap* bmp, BitmapCol col, int x, int y, int width, int height);
|
||||
CC_API void Drawer2D_Clear(struct Bitmap* bmp, BitmapCol col,
|
||||
int x, int y, int width, int height);
|
||||
|
||||
/* Draws text using the given font at the given coordinates. */
|
||||
CC_API void Drawer2D_DrawText(Bitmap* bmp, struct DrawTextArgs* args, int x, int y);
|
||||
CC_API void Drawer2D_DrawText(struct Bitmap* bmp, struct DrawTextArgs* args, int x, int y);
|
||||
/* Returns how wide the given text would be when drawn. */
|
||||
CC_API int Drawer2D_TextWidth(struct DrawTextArgs* args);
|
||||
/* Returns how tall the given text would be when drawn. */
|
||||
/* NOTE: Height returned only depends on the font. (see Drawer2D_FontHeight). */
|
||||
CC_API int Drawer2D_TextHeight(struct DrawTextArgs* args);
|
||||
/* Similar to Drawer2D_DrawText, but trims the text with trailing ".." if wider than maxWidth. */
|
||||
void Drawer2D_DrawClippedText(Bitmap* bmp, struct DrawTextArgs* args, int x, int y, int maxWidth);
|
||||
void Drawer2D_DrawClippedText(struct Bitmap* bmp, struct DrawTextArgs* args,
|
||||
int x, int y, int maxWidth);
|
||||
/* Returns the line height for drawing any character in the font. */
|
||||
int Drawer2D_FontHeight(const struct FontDesc* font, cc_bool useShadow);
|
||||
|
||||
@ -73,7 +75,7 @@ CC_API void Drawer2D_MakeTextTexture(struct Texture* tex, struct DrawTextArgs* a
|
||||
/* Creates a texture consisting of the pixels from the given bitmap. */
|
||||
/* NOTE: bmp must always have power of two dimensions. */
|
||||
/* width/height specifies what region of the texture actually should be drawn. */
|
||||
CC_API void Drawer2D_MakeTexture(struct Texture* tex, Bitmap* bmp, int width, int height);
|
||||
CC_API void Drawer2D_MakeTexture(struct Texture* tex, struct Bitmap* bmp, int width, int height);
|
||||
|
||||
/* Returns whether the given colour code is used/valid. */
|
||||
/* NOTE: This can change if the server defines custom colour codes. */
|
||||
@ -89,7 +91,7 @@ void Drawer2D_ReducePadding_Tex(struct Texture* tex, int point, int scale);
|
||||
void Drawer2D_ReducePadding_Height(int* height, int point, int scale);
|
||||
/* Sets the bitmap used for drawing bitmapped fonts. (i.e. default.png) */
|
||||
/* The bitmap must be square and consist of a 16x16 tile layout. */
|
||||
cc_bool Drawer2D_SetFontBitmap(Bitmap* bmp);
|
||||
cc_bool Drawer2D_SetFontBitmap(struct Bitmap* bmp);
|
||||
|
||||
/* Gets the list of all supported system font names on this platform. */
|
||||
CC_API void Font_GetNames(struct StringsBuffer* buffer);
|
||||
|
||||
10
src/Entity.c
10
src/Entity.c
@ -234,10 +234,10 @@ static void MakeNameTexture(struct Entity* e) {
|
||||
|
||||
struct DrawTextArgs args;
|
||||
struct FontDesc font;
|
||||
struct Bitmap bmp;
|
||||
cc_bool bitmapped;
|
||||
int width, height;
|
||||
String name;
|
||||
Bitmap bmp;
|
||||
|
||||
/* Names are always drawn not using the system font */
|
||||
bitmapped = Drawer2D_BitmappedText;
|
||||
@ -387,7 +387,7 @@ static void Entity_SetSkinAll(struct Entity* source, cc_bool reset) {
|
||||
|
||||
/* Clears hat area from a skin bitmap if it's completely white or black,
|
||||
so skins edited with Microsoft Paint or similiar don't have a solid hat */
|
||||
static void Entity_ClearHat(Bitmap* bmp, cc_uint8 skinType) {
|
||||
static void Entity_ClearHat(struct Bitmap* bmp, cc_uint8 skinType) {
|
||||
int sizeX = (bmp->width / 64) * 32;
|
||||
int yScale = skinType == SKIN_64x32 ? 32 : 64;
|
||||
int sizeY = (bmp->height / yScale) * 16;
|
||||
@ -412,10 +412,10 @@ static void Entity_ClearHat(Bitmap* bmp, cc_uint8 skinType) {
|
||||
}
|
||||
|
||||
/* Ensures skin is a power of two size, resizing if needed. */
|
||||
static cc_result Entity_EnsurePow2(struct Entity* e, Bitmap* bmp) {
|
||||
static cc_result Entity_EnsurePow2(struct Entity* e, struct Bitmap* bmp) {
|
||||
struct Bitmap scaled;
|
||||
cc_uint32 stride;
|
||||
int width, height;
|
||||
Bitmap scaled;
|
||||
int y;
|
||||
|
||||
width = Math_NextPowOf2(bmp->width);
|
||||
@ -446,7 +446,7 @@ static void Entity_CheckSkin(struct Entity* e) {
|
||||
|
||||
struct HttpRequest item;
|
||||
struct Stream mem;
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
cc_result res;
|
||||
|
||||
/* Don't check skin if don't have to */
|
||||
|
||||
@ -566,7 +566,7 @@ static cc_bool ShadowComponent_GetBlocks(struct Entity* e, int x, int y, int z,
|
||||
static void ShadowComponent_MakeTex(void) {
|
||||
BitmapCol pixels[sh_size * sh_size];
|
||||
BitmapCol col = BitmapCol_Make(0, 0, 0, 200);
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
cc_uint32 x, y;
|
||||
|
||||
Bitmap_Init(bmp, sh_size, sh_size, pixels);
|
||||
|
||||
@ -220,7 +220,7 @@ cc_bool Game_CanPick(BlockID block) {
|
||||
}
|
||||
|
||||
cc_bool Game_UpdateTexture(GfxResourceID* texId, struct Stream* src, const String* file, cc_uint8* skinType) {
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
cc_bool success;
|
||||
cc_result res;
|
||||
|
||||
@ -238,7 +238,7 @@ cc_bool Game_UpdateTexture(GfxResourceID* texId, struct Stream* src, const Strin
|
||||
return success;
|
||||
}
|
||||
|
||||
cc_bool Game_ValidateBitmap(const String* file, Bitmap* bmp) {
|
||||
cc_bool Game_ValidateBitmap(const String* file, struct Bitmap* bmp) {
|
||||
int maxWidth = Gfx.MaxTexWidth, maxHeight = Gfx.MaxTexHeight;
|
||||
if (!bmp->scan0) {
|
||||
Chat_Add1("&cError loading %s from the texture pack.", file);
|
||||
|
||||
@ -72,7 +72,7 @@ cc_bool Game_CanPick(BlockID block);
|
||||
cc_bool Game_UpdateTexture(GfxResourceID* texId, struct Stream* src, const String* file, cc_uint8* skinType);
|
||||
/* Checks that the given bitmap can be loaded into a native gfx texture. */
|
||||
/* (must be power of two size and be <= Gfx_MaxTexWidth/Gfx_MaxHeight) */
|
||||
cc_bool Game_ValidateBitmap(const String* file, Bitmap* bmp);
|
||||
cc_bool Game_ValidateBitmap(const String* file, struct Bitmap* bmp);
|
||||
/* Updates Game_Width and Game_Height. */
|
||||
void Game_UpdateDimensions(void);
|
||||
/* Sets the strategy/method used to limit frames per second. */
|
||||
|
||||
@ -201,11 +201,11 @@ void Gfx_RestoreAlphaState(cc_uint8 draw) {
|
||||
}
|
||||
|
||||
|
||||
void Gfx_UpdateTexturePart(GfxResourceID texId, int x, int y, Bitmap* part, cc_bool mipmaps) {
|
||||
void Gfx_UpdateTexturePart(GfxResourceID texId, int x, int y, struct Bitmap* part, cc_bool mipmaps) {
|
||||
Gfx_UpdateTexture(texId, x, y, part, part->width, mipmaps);
|
||||
}
|
||||
|
||||
static void CopyTextureData(void* dst, int dstStride, const Bitmap* src, int srcStride) {
|
||||
static void CopyTextureData(void* dst, int dstStride, const struct Bitmap* src, int srcStride) {
|
||||
/* We need to copy scanline by scanline, as generally srcStride != dstStride */
|
||||
cc_uint8* src_ = (cc_uint8*)src->scan0;
|
||||
cc_uint8* dst_ = (cc_uint8*)dst;
|
||||
@ -482,7 +482,7 @@ static void Gfx_RestoreState(void) {
|
||||
/*########################################################################################################################*
|
||||
*---------------------------------------------------------Textures--------------------------------------------------------*
|
||||
*#########################################################################################################################*/
|
||||
static void D3D9_SetTextureData(IDirect3DTexture9* texture, Bitmap* bmp, int lvl) {
|
||||
static void D3D9_SetTextureData(IDirect3DTexture9* texture, struct Bitmap* bmp, int lvl) {
|
||||
D3DLOCKED_RECT rect;
|
||||
cc_result res = IDirect3DTexture9_LockRect(texture, lvl, &rect, NULL, 0);
|
||||
if (res) Logger_Abort2(res, "D3D9_LockTextureData");
|
||||
@ -494,7 +494,7 @@ static void D3D9_SetTextureData(IDirect3DTexture9* texture, Bitmap* bmp, int lvl
|
||||
if (res) Logger_Abort2(res, "D3D9_UnlockTextureData");
|
||||
}
|
||||
|
||||
static void D3D9_SetTexturePartData(IDirect3DTexture9* texture, int x, int y, const Bitmap* bmp, int rowWidth, int lvl) {
|
||||
static void D3D9_SetTexturePartData(IDirect3DTexture9* texture, int x, int y, const struct Bitmap* bmp, int rowWidth, int lvl) {
|
||||
D3DLOCKED_RECT rect;
|
||||
cc_result res;
|
||||
RECT part;
|
||||
@ -510,10 +510,10 @@ static void D3D9_SetTexturePartData(IDirect3DTexture9* texture, int x, int y, co
|
||||
if (res) Logger_Abort2(res, "D3D9_UnlockTexturePartData");
|
||||
}
|
||||
|
||||
static void D3D9_DoMipmaps(IDirect3DTexture9* texture, int x, int y, Bitmap* bmp, int rowWidth, cc_bool partial) {
|
||||
static void D3D9_DoMipmaps(IDirect3DTexture9* texture, int x, int y, struct Bitmap* bmp, int rowWidth, cc_bool partial) {
|
||||
BitmapCol* prev = bmp->scan0;
|
||||
BitmapCol* cur;
|
||||
Bitmap mipmap;
|
||||
struct Bitmap mipmap;
|
||||
|
||||
int lvls = CalcMipmapsLevels(bmp->width, bmp->height);
|
||||
int lvl, width = bmp->width, height = bmp->height;
|
||||
@ -540,7 +540,7 @@ static void D3D9_DoMipmaps(IDirect3DTexture9* texture, int x, int y, Bitmap* bmp
|
||||
if (prev != bmp->scan0) Mem_Free(prev);
|
||||
}
|
||||
|
||||
GfxResourceID Gfx_CreateTexture(Bitmap* bmp, cc_bool managedPool, cc_bool mipmaps) {
|
||||
GfxResourceID Gfx_CreateTexture(struct Bitmap* bmp, cc_bool managedPool, cc_bool mipmaps) {
|
||||
IDirect3DTexture9* tex;
|
||||
cc_result res;
|
||||
int mipmapsLevels = CalcMipmapsLevels(bmp->width, bmp->height);
|
||||
@ -578,7 +578,7 @@ GfxResourceID Gfx_CreateTexture(Bitmap* bmp, cc_bool managedPool, cc_bool mipmap
|
||||
return tex;
|
||||
}
|
||||
|
||||
void Gfx_UpdateTexture(GfxResourceID texId, int x, int y, Bitmap* part, int rowWidth, cc_bool mipmaps) {
|
||||
void Gfx_UpdateTexture(GfxResourceID texId, int x, int y, struct Bitmap* part, int rowWidth, cc_bool mipmaps) {
|
||||
IDirect3DTexture9* texture = (IDirect3DTexture9*)texId;
|
||||
D3D9_SetTexturePartData(texture, x, y, part, rowWidth, 0);
|
||||
if (mipmaps) D3D9_DoMipmaps(texture, x, y, part, rowWidth, true);
|
||||
@ -905,7 +905,7 @@ cc_result Gfx_TakeScreenshot(struct Stream* output) {
|
||||
IDirect3DSurface9* temp = NULL;
|
||||
D3DSURFACE_DESC desc;
|
||||
D3DLOCKED_RECT rect;
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
cc_result res;
|
||||
|
||||
res = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
|
||||
@ -1129,7 +1129,7 @@ static void* FastAllocTempMem(int size) {
|
||||
/*########################################################################################################################*
|
||||
*---------------------------------------------------------Textures--------------------------------------------------------*
|
||||
*#########################################################################################################################*/
|
||||
static void Gfx_DoMipmaps(int x, int y, Bitmap* bmp, int rowWidth, cc_bool partial) {
|
||||
static void Gfx_DoMipmaps(int x, int y, struct Bitmap* bmp, int rowWidth, cc_bool partial) {
|
||||
BitmapCol* prev = bmp->scan0;
|
||||
BitmapCol* cur;
|
||||
|
||||
@ -1157,7 +1157,7 @@ static void Gfx_DoMipmaps(int x, int y, Bitmap* bmp, int rowWidth, cc_bool parti
|
||||
if (prev != bmp->scan0) Mem_Free(prev);
|
||||
}
|
||||
|
||||
GfxResourceID Gfx_CreateTexture(Bitmap* bmp, cc_bool managedPool, cc_bool mipmaps) {
|
||||
GfxResourceID Gfx_CreateTexture(struct Bitmap* bmp, cc_bool managedPool, cc_bool mipmaps) {
|
||||
GLuint texId;
|
||||
glGenTextures(1, &texId);
|
||||
glBindTexture(GL_TEXTURE_2D, texId);
|
||||
@ -1185,7 +1185,7 @@ GfxResourceID Gfx_CreateTexture(Bitmap* bmp, cc_bool managedPool, cc_bool mipmap
|
||||
}
|
||||
|
||||
#define UPDATE_FAST_SIZE (64 * 64)
|
||||
static CC_NOINLINE void UpdateTextureSlow(int x, int y, Bitmap* part, int rowWidth) {
|
||||
static CC_NOINLINE void UpdateTextureSlow(int x, int y, struct Bitmap* part, int rowWidth) {
|
||||
BitmapCol buffer[UPDATE_FAST_SIZE];
|
||||
void* ptr = (void*)buffer;
|
||||
int count = part->width * part->height;
|
||||
@ -1200,7 +1200,7 @@ static CC_NOINLINE void UpdateTextureSlow(int x, int y, Bitmap* part, int rowWid
|
||||
if (count > UPDATE_FAST_SIZE) Mem_Free(ptr);
|
||||
}
|
||||
|
||||
void Gfx_UpdateTexture(GfxResourceID texId, int x, int y, Bitmap* part, int rowWidth, cc_bool mipmaps) {
|
||||
void Gfx_UpdateTexture(GfxResourceID texId, int x, int y, struct Bitmap* part, int rowWidth, cc_bool mipmaps) {
|
||||
glBindTexture(GL_TEXTURE_2D, (GLuint)texId);
|
||||
/* TODO: Use GL_UNPACK_ROW_LENGTH for Desktop OpenGL */
|
||||
|
||||
@ -1423,9 +1423,10 @@ void Gfx_SetDynamicVbData(GfxResourceID vb, void* vertices, int vCount) {
|
||||
/*########################################################################################################################*
|
||||
*-----------------------------------------------------------Misc----------------------------------------------------------*
|
||||
*#########################################################################################################################*/
|
||||
static int GL_SelectRow(Bitmap* bmp, int y) { return (bmp->height - 1) - y; }
|
||||
/* OpenGL stores bitmap in bottom-up order, so flip order when saving */
|
||||
static int SelectRow(struct Bitmap* bmp, int y) { return (bmp->height - 1) - y; }
|
||||
cc_result Gfx_TakeScreenshot(struct Stream* output) {
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
cc_result res;
|
||||
GLint vp[4];
|
||||
|
||||
@ -1437,7 +1438,7 @@ cc_result Gfx_TakeScreenshot(struct Stream* output) {
|
||||
if (!bmp.scan0) return ERR_OUT_OF_MEMORY;
|
||||
glReadPixels(0, 0, bmp.width, bmp.height, PIXEL_FORMAT, TRANSFER_FORMAT, bmp.scan0);
|
||||
|
||||
res = Png_Encode(&bmp, output, GL_SelectRow, false);
|
||||
res = Png_Encode(&bmp, output, SelectRow, false);
|
||||
Mem_Free(bmp.scan0);
|
||||
return res;
|
||||
}
|
||||
|
||||
@ -59,12 +59,12 @@ extern GfxResourceID Gfx_quadVb, Gfx_texVb;
|
||||
/* Creates a new texture. (and also generates mipmaps if mipmaps) */
|
||||
/* NOTE: Only set mipmaps to true if Gfx_Mipmaps is also true, because whether textures
|
||||
use mipmapping may be either a per-texture or global state depending on the backend. */
|
||||
CC_API GfxResourceID Gfx_CreateTexture(Bitmap* bmp, cc_bool managedPool, cc_bool mipmaps);
|
||||
CC_API GfxResourceID Gfx_CreateTexture(struct Bitmap* bmp, cc_bool managedPool, cc_bool mipmaps);
|
||||
/* Updates a region of the given texture. (and mipmapped regions if mipmaps) */
|
||||
CC_API void Gfx_UpdateTexturePart(GfxResourceID texId, int x, int y, Bitmap* part, cc_bool mipmaps); /* OBSOLETE */
|
||||
CC_API void Gfx_UpdateTexturePart(GfxResourceID texId, int x, int y, struct Bitmap* part, cc_bool mipmaps); /* OBSOLETE */
|
||||
/* Updates a region of the given texture. (and mipmapped regions if mipmaps) */
|
||||
/* NOTE: rowWidth is in pixels (so for normal bitmaps, rowWidth equals width) */
|
||||
CC_API void Gfx_UpdateTexture(GfxResourceID texId, int x, int y, Bitmap* part, int rowWidth, cc_bool mipmaps);
|
||||
CC_API void Gfx_UpdateTexture(GfxResourceID texId, int x, int y, struct Bitmap* part, int rowWidth, cc_bool mipmaps);
|
||||
/* Sets the currently active texture. */
|
||||
CC_API void Gfx_BindTexture(GfxResourceID texId);
|
||||
/* Deletes the given texture, then sets it to 0. */
|
||||
|
||||
@ -294,7 +294,7 @@ void Gui_Layout(void) {
|
||||
void TextAtlas_Make(struct TextAtlas* atlas, const String* chars, struct FontDesc* font, const String* prefix) {
|
||||
struct DrawTextArgs args;
|
||||
int width, height;
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
int i, charWidth;
|
||||
|
||||
Gfx_DeleteTexture(&atlas->tex.ID);
|
||||
|
||||
@ -541,14 +541,14 @@ struct FetchFlagsData FetchFlagsTask;
|
||||
static int flagsCount, flagsCapacity;
|
||||
|
||||
struct Flag {
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
char country[2];
|
||||
};
|
||||
static struct Flag* flags;
|
||||
|
||||
/* Scales up flag bitmap if necessary */
|
||||
static void FetchFlagsTask_Scale(Bitmap* bmp) {
|
||||
Bitmap scaled;
|
||||
static void FetchFlagsTask_Scale(struct Bitmap* bmp) {
|
||||
struct Bitmap scaled;
|
||||
int width = Display_ScaleX(bmp->width);
|
||||
int height = Display_ScaleY(bmp->height);
|
||||
/* at default DPI don't need to rescale it */
|
||||
@ -624,7 +624,7 @@ void FetchFlagsTask_Add(const struct ServerInfo* server) {
|
||||
FetchFlagsTask_DownloadNext();
|
||||
}
|
||||
|
||||
Bitmap* Flags_Get(const struct ServerInfo* server) {
|
||||
struct Bitmap* Flags_Get(const struct ServerInfo* server) {
|
||||
int i;
|
||||
for (i = 0; i < FetchFlagsTask.count; i++) {
|
||||
if (flags[i].country[0] != server->country[0]) continue;
|
||||
|
||||
@ -114,7 +114,7 @@ extern struct FetchFlagsData {
|
||||
/* Asynchronously downloads the flag associated with the given server's country. */
|
||||
void FetchFlagsTask_Add(const struct ServerInfo* server);
|
||||
/* Gets the bitmap for the flag associated with the given server's country. */
|
||||
Bitmap* Flags_Get(const struct ServerInfo* server);
|
||||
struct Bitmap* Flags_Get(const struct ServerInfo* server);
|
||||
/* Frees all flag bitmaps. */
|
||||
void Flags_Free(void);
|
||||
#endif
|
||||
|
||||
@ -706,7 +706,7 @@ void LSlider_Init(struct LScreen* s, struct LSlider* w, int width, int height, B
|
||||
*------------------------------------------------------TableWidget--------------------------------------------------------*
|
||||
*#########################################################################################################################*/
|
||||
static void FlagColumn_Draw(struct ServerInfo* row, struct DrawTextArgs* args, int x, int y) {
|
||||
Bitmap* bmp = Flags_Get(row);
|
||||
struct Bitmap* bmp = Flags_Get(row);
|
||||
if (!bmp) return;
|
||||
Drawer2D_BmpCopy(&Launcher_Framebuffer, x + flagXOffset, y + flagYOffset, bmp);
|
||||
}
|
||||
|
||||
@ -20,7 +20,7 @@
|
||||
#ifndef CC_BUILD_WEB
|
||||
static struct LScreen* activeScreen;
|
||||
Rect2D Launcher_Dirty;
|
||||
Bitmap Launcher_Framebuffer;
|
||||
struct Bitmap Launcher_Framebuffer;
|
||||
cc_bool Launcher_ClassicBackground;
|
||||
struct FontDesc Launcher_TitleFont, Launcher_TextFont, Launcher_HintFont;
|
||||
|
||||
@ -33,7 +33,7 @@ static char hashBuffer[STRING_SIZE];
|
||||
String Launcher_AutoHash = String_FromArray(hashBuffer);
|
||||
|
||||
static cc_bool useBitmappedFont;
|
||||
static Bitmap dirtBmp, stoneBmp, fontBmp;
|
||||
static struct Bitmap dirtBmp, stoneBmp, fontBmp;
|
||||
#define TILESIZE 48
|
||||
|
||||
void Launcher_SetScreen(struct LScreen* screen) {
|
||||
@ -428,7 +428,7 @@ static cc_bool Launcher_SelectZipEntry(const String* path) {
|
||||
String_CaselessEqualsConst(path, "terrain.png");
|
||||
}
|
||||
|
||||
static void LoadTextures(Bitmap* bmp) {
|
||||
static void LoadTextures(struct Bitmap* bmp) {
|
||||
int tileSize = bmp->width / 16;
|
||||
Bitmap_Allocate(&dirtBmp, TILESIZE, TILESIZE);
|
||||
Bitmap_Allocate(&stoneBmp, TILESIZE, TILESIZE);
|
||||
@ -442,7 +442,7 @@ static void LoadTextures(Bitmap* bmp) {
|
||||
}
|
||||
|
||||
static cc_result Launcher_ProcessZipEntry(const String* path, struct Stream* data, struct ZipState* s) {
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
cc_result res;
|
||||
|
||||
if (String_CaselessEqualsConst(path, "default.png")) {
|
||||
@ -518,8 +518,8 @@ void Launcher_UpdateLogoFont(void) {
|
||||
}
|
||||
|
||||
/* Fills the given area using pixels from the source bitmap, by repeatedly tiling the bitmap. */
|
||||
CC_NOINLINE static void ClearTile(int x, int y, int width, int height, Bitmap* src) {
|
||||
Bitmap* dst = &Launcher_Framebuffer;
|
||||
CC_NOINLINE static void ClearTile(int x, int y, int width, int height, struct Bitmap* src) {
|
||||
struct Bitmap* dst = &Launcher_Framebuffer;
|
||||
BitmapCol* dstRow;
|
||||
BitmapCol* srcRow;
|
||||
int xx, yy;
|
||||
|
||||
@ -12,7 +12,7 @@ struct FontDesc;
|
||||
/* If width is 0, means no area needs to be redrawn. */
|
||||
extern Rect2D Launcher_Dirty;
|
||||
/* Contains the pixels that are drawn to the window. */
|
||||
extern Bitmap Launcher_Framebuffer;
|
||||
extern struct Bitmap Launcher_Framebuffer;
|
||||
/* Whether to use stone tile background like minecraft.net. */
|
||||
extern cc_bool Launcher_ClassicBackground;
|
||||
/* Default font for buttons and labels. */
|
||||
|
||||
@ -526,7 +526,6 @@ void CustomModel_BuildPart(struct CustomModel* cm, struct CustomModelPartDef* pa
|
||||
part->rotationOrigin.X, part->rotationOrigin.Y, part->rotationOrigin.Z);
|
||||
}
|
||||
|
||||
static void CustomModel_MakeParts(void) { }
|
||||
static struct ModelVertex oldVertices[MODEL_BOX_VERTICES];
|
||||
static float CustomModel_GetAnimationValue(
|
||||
struct CustomModelAnim* anim,
|
||||
@ -762,7 +761,7 @@ void CustomModel_Register(struct CustomModel* cm) {
|
||||
cm->model.name = cm->name;
|
||||
cm->model.defaultTex = &customDefaultTex;
|
||||
|
||||
cm->model.MakeParts = CustomModel_MakeParts;
|
||||
cm->model.MakeParts = Model_NoParts;
|
||||
cm->model.Draw = CustomModel_Draw;
|
||||
cm->model.GetNameY = CustomModel_GetNameY;
|
||||
cm->model.GetEyeY = CustomModel_GetEyeY;
|
||||
|
||||
@ -340,7 +340,7 @@ static cc_result ZipPatcher_WriteZipEntry(struct Stream* src, struct ResourceTex
|
||||
return 0;
|
||||
}
|
||||
|
||||
static cc_result ZipPatcher_WritePng(struct Stream* s, struct ResourceTexture* tex, Bitmap* src) {
|
||||
static cc_result ZipPatcher_WritePng(struct Stream* s, struct ResourceTexture* tex, struct Bitmap* src) {
|
||||
cc_result res;
|
||||
|
||||
if ((res = ZipPatcher_LocalFile(s, tex))) return res;
|
||||
@ -370,7 +370,7 @@ static cc_result ZipPatcher_WritePng(struct Stream* s, struct ResourceTexture* t
|
||||
"\r\n" \
|
||||
"# fire\r\n" \
|
||||
"6 2 0 0 16 32 0"
|
||||
static Bitmap terrainBmp;
|
||||
static struct Bitmap terrainBmp;
|
||||
|
||||
static cc_bool ClassicPatcher_SelectEntry(const String* path) {
|
||||
String name = *path;
|
||||
@ -434,7 +434,7 @@ CC_NOINLINE static const struct TilePatch* ModernPatcher_GetTile(const String* p
|
||||
}
|
||||
|
||||
static cc_result ModernPatcher_PatchTile(struct Stream* data, const struct TilePatch* tile) {
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
cc_result res;
|
||||
|
||||
if ((res = Png_Decode(&bmp, data))) return res;
|
||||
@ -462,7 +462,7 @@ static cc_result ModernPatcher_MakeAnimations(struct Stream* s, struct Stream* d
|
||||
static const String animsPng = String_FromConst("animations.png");
|
||||
struct ResourceTexture* entry;
|
||||
BitmapCol pixels[512 * 16];
|
||||
Bitmap anim, bmp;
|
||||
struct Bitmap anim, bmp;
|
||||
cc_result res;
|
||||
int i;
|
||||
|
||||
@ -532,14 +532,14 @@ static cc_result TexPatcher_NewFiles(struct Stream* s) {
|
||||
return res;
|
||||
}
|
||||
|
||||
static void TexPatcher_PatchTile(Bitmap* src, int srcX, int srcY, int dstX, int dstY) {
|
||||
static void TexPatcher_PatchTile(struct Bitmap* src, int srcX, int srcY, int dstX, int dstY) {
|
||||
Bitmap_UNSAFE_CopyBlock(srcX, srcY, dstX * 16, dstY * 16, src, &terrainBmp, 16);
|
||||
}
|
||||
|
||||
static cc_result TexPatcher_Terrain(struct Stream* s) {
|
||||
static const String terrainPng = String_FromConst("terrain.png");
|
||||
struct ResourceTexture* entry;
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
struct Stream src;
|
||||
cc_result res;
|
||||
|
||||
|
||||
@ -37,7 +37,7 @@ static void Atlas_Convert2DTo1D(void) {
|
||||
int tileSize = Atlas2D.TileSize;
|
||||
int tilesPerAtlas = Atlas1D.TilesPerAtlas;
|
||||
int atlasesCount = Atlas1D.Count;
|
||||
Bitmap atlas1D;
|
||||
struct Bitmap atlas1D;
|
||||
int atlasX, atlasY;
|
||||
int tile = 0, i, y;
|
||||
|
||||
@ -73,7 +73,7 @@ static void Atlas_Update1D(void) {
|
||||
}
|
||||
|
||||
/* Loads the given atlas and converts it into an array of 1D atlases. */
|
||||
static void Atlas_Update(Bitmap* bmp) {
|
||||
static void Atlas_Update(struct Bitmap* bmp) {
|
||||
Atlas2D.Bmp = *bmp;
|
||||
Atlas2D.TileSize = bmp->width / ATLAS2D_TILES_PER_ROW;
|
||||
Atlas2D.RowsCount = bmp->height / Atlas2D.TileSize;
|
||||
@ -83,7 +83,7 @@ static void Atlas_Update(Bitmap* bmp) {
|
||||
Atlas_Convert2DTo1D();
|
||||
}
|
||||
|
||||
static GfxResourceID Atlas_LoadTile_Raw(TextureLoc texLoc, Bitmap* element) {
|
||||
static GfxResourceID Atlas_LoadTile_Raw(TextureLoc texLoc, struct Bitmap* element) {
|
||||
int size = Atlas2D.TileSize;
|
||||
int x = Atlas2D_TileX(texLoc), y = Atlas2D_TileY(texLoc);
|
||||
if (y >= Atlas2D.RowsCount) return 0;
|
||||
@ -95,7 +95,7 @@ static GfxResourceID Atlas_LoadTile_Raw(TextureLoc texLoc, Bitmap* element) {
|
||||
GfxResourceID Atlas2D_LoadTile(TextureLoc texLoc) {
|
||||
BitmapCol pixels[64 * 64];
|
||||
int size = Atlas2D.TileSize;
|
||||
Bitmap tile;
|
||||
struct Bitmap tile;
|
||||
GfxResourceID texId;
|
||||
|
||||
/* Try to allocate bitmap on stack if possible */
|
||||
@ -122,7 +122,7 @@ static void Atlas1D_Free(void) {
|
||||
}
|
||||
}
|
||||
|
||||
cc_bool Atlas_TryChange(Bitmap* atlas) {
|
||||
cc_bool Atlas_TryChange(struct Bitmap* atlas) {
|
||||
static const String terrain = String_FromConst("terrain.png");
|
||||
if (!Game_ValidateBitmap(&terrain, atlas)) return false;
|
||||
|
||||
@ -299,7 +299,7 @@ static cc_result ExtractZip(struct Stream* stream) {
|
||||
}
|
||||
|
||||
static cc_result ExtractPng(struct Stream* stream) {
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
cc_result res = Png_Decode(&bmp, stream);
|
||||
if (!res && Atlas_TryChange(&bmp)) return 0;
|
||||
|
||||
@ -416,7 +416,7 @@ void TexturePack_DownloadAsync(const String* url, const String* id) {
|
||||
*---------------------------------------------------Textures component----------------------------------------------------*
|
||||
*#########################################################################################################################*/
|
||||
static void OnFileChanged(void* obj, struct Stream* stream, const String* name) {
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
cc_result res;
|
||||
|
||||
if (!String_CaselessEqualsConst(name, "terrain.png")) return;
|
||||
|
||||
@ -30,7 +30,7 @@ extern struct IGameComponent Textures_Component;
|
||||
CC_VAR extern struct _Atlas2DData {
|
||||
/* Bitmap that contains the textures of all tiles. */
|
||||
/* Tiles are indexed left to right, top to bottom. */
|
||||
Bitmap Bmp;
|
||||
struct Bitmap Bmp;
|
||||
/* Size of each tile in pixels. (default 16x16) */
|
||||
int TileSize;
|
||||
/* Number of rows in the atlas. (default 16, can be 32) */
|
||||
@ -61,7 +61,7 @@ CC_VAR extern struct _Atlas1DData {
|
||||
/* Loads the given tile into a new separate texture. */
|
||||
GfxResourceID Atlas2D_LoadTile(TextureLoc texLoc);
|
||||
/* Attempts to change the terrain atlas. (bitmap containing textures for all blocks) */
|
||||
cc_bool Atlas_TryChange(Bitmap* bmp);
|
||||
cc_bool Atlas_TryChange(struct Bitmap* bmp);
|
||||
/* Returns the UV rectangle of the given tile id in the 1D atlases. */
|
||||
/* That is, returns U1/U2/V1/V2 coords that make up the tile in a 1D atlas. */
|
||||
/* index is set to the index of the 1D atlas that the tile is in. */
|
||||
|
||||
@ -68,7 +68,7 @@ int Utils_AccumulateWheelDelta(float* accumulator, float delta) {
|
||||
}
|
||||
|
||||
/* Checks if an area is completely black, so Alex skins edited with Microsoft Paint are still treated as Alex */
|
||||
static cc_bool Utils_IsAllBlack(const Bitmap* bmp, int x1, int y1, int width, int height) {
|
||||
static cc_bool IsAllBlack(const struct Bitmap* bmp, int x1, int y1, int width, int height) {
|
||||
int x, y;
|
||||
for (y = y1; y < y1 + height; y++) {
|
||||
BitmapCol* row = Bitmap_GetRow(bmp, y);
|
||||
@ -80,7 +80,7 @@ static cc_bool Utils_IsAllBlack(const Bitmap* bmp, int x1, int y1, int width, in
|
||||
return true;
|
||||
}
|
||||
|
||||
cc_uint8 Utils_CalcSkinType(const Bitmap* bmp) {
|
||||
cc_uint8 Utils_CalcSkinType(const struct Bitmap* bmp) {
|
||||
BitmapCol col;
|
||||
int scale;
|
||||
if (bmp->width == bmp->height * 2) return SKIN_64x32;
|
||||
@ -91,8 +91,8 @@ cc_uint8 Utils_CalcSkinType(const Bitmap* bmp) {
|
||||
col = Bitmap_GetPixel(bmp, 54 * scale, 20 * scale);
|
||||
if (BitmapCol_A(col) < 128) return SKIN_64x64_SLIM;
|
||||
|
||||
return Utils_IsAllBlack(bmp, 54 * scale, 20 * scale, 2 * scale, 12 * scale)
|
||||
&& Utils_IsAllBlack(bmp, 50 * scale, 16 * scale, 2 * scale, 4 * scale) ? SKIN_64x64_SLIM : SKIN_64x64;
|
||||
return IsAllBlack(bmp, 54 * scale, 20 * scale, 2 * scale, 12 * scale)
|
||||
&& IsAllBlack(bmp, 50 * scale, 16 * scale, 2 * scale, 4 * scale) ? SKIN_64x64_SLIM : SKIN_64x64;
|
||||
}
|
||||
|
||||
cc_uint32 Utils_CRC32(const cc_uint8* data, cc_uint32 length) {
|
||||
|
||||
@ -37,7 +37,7 @@ void Utils_UNSAFE_TrimFirstDirectory(STRING_REF String* path);
|
||||
int Utils_AccumulateWheelDelta(float* accumulator, float delta);
|
||||
#define Utils_AdjViewDist(value) ((int)(1.4142135f * (value)))
|
||||
|
||||
cc_uint8 Utils_CalcSkinType(const Bitmap* bmp);
|
||||
cc_uint8 Utils_CalcSkinType(const struct Bitmap* bmp);
|
||||
cc_uint32 Utils_CRC32(const cc_uint8* data, cc_uint32 length);
|
||||
/* CRC32 lookup table, for faster CRC32 calculations. */
|
||||
/* NOTE: This cannot be just indexed by byte value - see Utils_CRC32 implementation. */
|
||||
|
||||
@ -1435,7 +1435,7 @@ static void MenuInputWidget_RemakeTexture(void* widget) {
|
||||
struct Texture* tex;
|
||||
int textWidth, lineHeight;
|
||||
int width, height, hintX, y;
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
|
||||
DrawTextArgs_Make(&args, &w->base.text, w->base.font, false);
|
||||
textWidth = Drawer2D_TextWidth(&args);
|
||||
@ -1540,7 +1540,7 @@ static void ChatInputWidget_RemakeTexture(void* widget) {
|
||||
struct InputWidget* w = (struct InputWidget*)widget;
|
||||
struct DrawTextArgs args;
|
||||
int width = 0, height = 0;
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
char lastCol;
|
||||
int i, x, y;
|
||||
|
||||
@ -2056,7 +2056,7 @@ static void TextGroupWidget_DrawAdvanced(struct TextGroupWidget* w, struct Textu
|
||||
struct Portion bit;
|
||||
int width, height;
|
||||
int partWidths[Array_Elems(portions)];
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
int portionsCount;
|
||||
int i, x, ul;
|
||||
|
||||
@ -2281,7 +2281,7 @@ static int SpecialInputWidget_MeasureTitles(struct SpecialInputWidget* w) {
|
||||
return width;
|
||||
}
|
||||
|
||||
static void SpecialInputWidget_DrawTitles(struct SpecialInputWidget* w, Bitmap* bmp) {
|
||||
static void SpecialInputWidget_DrawTitles(struct SpecialInputWidget* w, struct Bitmap* bmp) {
|
||||
BitmapCol col_selected = BitmapCol_Make(30, 30, 30, 200);
|
||||
BitmapCol col_inactive = BitmapCol_Make( 0, 0, 0, 127);
|
||||
BitmapCol col;
|
||||
@ -2325,7 +2325,7 @@ static int SpecialInputWidget_ContentHeight(struct SpecialInputWidget* w, struct
|
||||
return w->elementHeight * rows;
|
||||
}
|
||||
|
||||
static void SpecialInputWidget_DrawContent(struct SpecialInputWidget* w, struct SpecialInputTab* tab, Bitmap* bmp, int yOffset) {
|
||||
static void SpecialInputWidget_DrawContent(struct SpecialInputWidget* w, struct SpecialInputTab* tab, struct Bitmap* bmp, int yOffset) {
|
||||
struct DrawTextArgs args;
|
||||
int i, x, y, item;
|
||||
|
||||
@ -2348,7 +2348,7 @@ static void SpecialInputWidget_Make(struct SpecialInputWidget* w, struct Special
|
||||
int titlesWidth, titlesHeight;
|
||||
int contentWidth, contentHeight;
|
||||
int width, height;
|
||||
Bitmap bmp;
|
||||
struct Bitmap bmp;
|
||||
|
||||
titlesWidth = SpecialInputWidget_MeasureTitles(w);
|
||||
titlesHeight = w->titleHeight;
|
||||
|
||||
34
src/Window.c
34
src/Window.c
@ -376,7 +376,7 @@ static void ShowDialogCore(const char* title, const char* msg) {
|
||||
}
|
||||
|
||||
static SDL_Surface* surface;
|
||||
void Window_AllocFramebuffer(Bitmap* bmp) {
|
||||
void Window_AllocFramebuffer(struct Bitmap* bmp) {
|
||||
surface = SDL_GetWindowSurface(win_handle);
|
||||
if (!surface) Window_SDLFail("getting window surface");
|
||||
|
||||
@ -394,7 +394,7 @@ void Window_DrawFramebuffer(Rect2D r) {
|
||||
SDL_UpdateWindowSurfaceRects(win_handle, &rect, 1);
|
||||
}
|
||||
|
||||
void Window_FreeFramebuffer(Bitmap* bmp) {
|
||||
void Window_FreeFramebuffer(struct Bitmap* bmp) {
|
||||
/* SDL docs explicitly say to NOT free the surface */
|
||||
/* https://wiki.libsdl.org/SDL_GetWindowSurface */
|
||||
/* TODO: Do we still need to unlock it though? */
|
||||
@ -887,7 +887,7 @@ static void ShowDialogCore(const char* title, const char* msg) {
|
||||
|
||||
static HDC draw_DC;
|
||||
static HBITMAP draw_DIB;
|
||||
void Window_AllocFramebuffer(Bitmap* bmp) {
|
||||
void Window_AllocFramebuffer(struct Bitmap* bmp) {
|
||||
BITMAPINFO hdr = { 0 };
|
||||
if (!draw_DC) draw_DC = CreateCompatibleDC(win_DC);
|
||||
|
||||
@ -906,7 +906,7 @@ void Window_DrawFramebuffer(Rect2D r) {
|
||||
SelectObject(draw_DC, oldSrc);
|
||||
}
|
||||
|
||||
void Window_FreeFramebuffer(Bitmap* bmp) {
|
||||
void Window_FreeFramebuffer(struct Bitmap* bmp) {
|
||||
DeleteObject(draw_DIB);
|
||||
}
|
||||
|
||||
@ -1796,7 +1796,7 @@ static void ShowDialogCore(const char* title, const char* msg) {
|
||||
|
||||
static GC fb_gc;
|
||||
static XImage* fb_image;
|
||||
void Window_AllocFramebuffer(Bitmap* bmp) {
|
||||
void Window_AllocFramebuffer(struct Bitmap* bmp) {
|
||||
if (!fb_gc) fb_gc = XCreateGC(win_display, win_handle, 0, NULL);
|
||||
|
||||
bmp->scan0 = (BitmapCol*)Mem_Alloc(bmp->width * bmp->height, 4, "window pixels");
|
||||
@ -1810,7 +1810,7 @@ void Window_DrawFramebuffer(Rect2D r) {
|
||||
r.X, r.Y, r.X, r.Y, r.Width, r.Height);
|
||||
}
|
||||
|
||||
void Window_FreeFramebuffer(Bitmap* bmp) {
|
||||
void Window_FreeFramebuffer(struct Bitmap* bmp) {
|
||||
XFree(fb_image);
|
||||
Mem_Free(bmp->scan0);
|
||||
}
|
||||
@ -2492,10 +2492,10 @@ static void ShowDialogCore(const char* title, const char* msg) {
|
||||
}
|
||||
|
||||
static CGrafPtr fb_port;
|
||||
static Bitmap fb_bmp;
|
||||
static struct Bitmap fb_bmp;
|
||||
static CGColorSpaceRef colorSpace;
|
||||
|
||||
void Window_AllocFramebuffer(Bitmap* bmp) {
|
||||
void Window_AllocFramebuffer(struct Bitmap* bmp) {
|
||||
if (!fb_port) fb_port = GetWindowPort(win_handle);
|
||||
|
||||
bmp->scan0 = Mem_Alloc(bmp->width * bmp->height, 4, "window pixels");
|
||||
@ -2542,7 +2542,7 @@ void Window_DrawFramebuffer(Rect2D r) {
|
||||
CGDataProviderRelease(provider);
|
||||
}
|
||||
|
||||
void Window_FreeFramebuffer(Bitmap* bmp) {
|
||||
void Window_FreeFramebuffer(struct Bitmap* bmp) {
|
||||
Mem_Free(bmp->scan0);
|
||||
CGColorSpaceRelease(colorSpace);
|
||||
}
|
||||
@ -2966,8 +2966,8 @@ static void ShowDialogCore(const char* title, const char* msg) {
|
||||
CFRelease(msgCF);
|
||||
}
|
||||
|
||||
static Bitmap fb_bmp;
|
||||
void Window_AllocFramebuffer(Bitmap* bmp) {
|
||||
static struct Bitmap fb_bmp;
|
||||
void Window_AllocFramebuffer(struct Bitmap* bmp) {
|
||||
bmp->scan0 = (BitmapCol*)Mem_Alloc(bmp->width * bmp->height, 4, "window pixels");
|
||||
fb_bmp = *bmp;
|
||||
}
|
||||
@ -3017,7 +3017,7 @@ void Window_DrawFramebuffer(Rect2D r) {
|
||||
objc_msgSend(viewHandle, selDisplayIfNeeded);
|
||||
}
|
||||
|
||||
void Window_FreeFramebuffer(Bitmap* bmp) {
|
||||
void Window_FreeFramebuffer(struct Bitmap* bmp) {
|
||||
Mem_Free(bmp->scan0);
|
||||
}
|
||||
#endif
|
||||
@ -3465,9 +3465,9 @@ static void ShowDialogCore(const char* title, const char* msg) {
|
||||
EM_ASM_({ alert(UTF8ToString($0) + "\n\n" + UTF8ToString($1)); }, title, msg);
|
||||
}
|
||||
|
||||
void Window_AllocFramebuffer(Bitmap* bmp) { }
|
||||
void Window_AllocFramebuffer(struct Bitmap* bmp) { }
|
||||
void Window_DrawFramebuffer(Rect2D r) { }
|
||||
void Window_FreeFramebuffer(Bitmap* bmp) { }
|
||||
void Window_FreeFramebuffer(struct Bitmap* bmp) { }
|
||||
|
||||
EMSCRIPTEN_KEEPALIVE void Window_OnTextChanged(const char* src) {
|
||||
char buffer[800];
|
||||
@ -3822,8 +3822,8 @@ static void ShowDialogCore(const char* title, const char* msg) {
|
||||
(*env)->DeleteLocalRef(env, args[1].l);
|
||||
}
|
||||
|
||||
static Bitmap fb_bmp;
|
||||
void Window_AllocFramebuffer(Bitmap* bmp) {
|
||||
static struct Bitmap fb_bmp;
|
||||
void Window_AllocFramebuffer(struct Bitmap* bmp) {
|
||||
bmp->scan0 = (BitmapCol*)Mem_Alloc(bmp->width * bmp->height, 4, "window pixels");
|
||||
fb_bmp = *bmp;
|
||||
}
|
||||
@ -3865,7 +3865,7 @@ void Window_DrawFramebuffer(Rect2D r) {
|
||||
if (res) Logger_Abort2(res, "Unlocking window pixels");
|
||||
}
|
||||
|
||||
void Window_FreeFramebuffer(Bitmap* bmp) {
|
||||
void Window_FreeFramebuffer(struct Bitmap* bmp) {
|
||||
Mem_Free(bmp->scan0);
|
||||
}
|
||||
|
||||
|
||||
@ -78,7 +78,6 @@ void Window_Init(void);
|
||||
void Window_Create(int width, int height);
|
||||
/* Sets the text of the titlebar above the window. */
|
||||
CC_API void Window_SetTitle(const String* title);
|
||||
/* TODO: IMPLEMENT void Window_SetIcon(Bitmap* bmp); */
|
||||
|
||||
typedef void (*RequestClipboardCallback)(String* value, void* obj);
|
||||
/* Gets the text currently on the clipboard. */
|
||||
@ -121,12 +120,12 @@ CC_API void Window_ShowDialog(const char* title, const char* msg);
|
||||
/* Allocates a framebuffer that can be drawn/transferred to the window. */
|
||||
/* NOTE: Do NOT free bmp->Scan0, use Window_FreeFramebuffer. */
|
||||
/* NOTE: This MUST be called whenever the window is resized. */
|
||||
void Window_AllocFramebuffer(Bitmap* bmp);
|
||||
void Window_AllocFramebuffer(struct Bitmap* bmp);
|
||||
/* Transfers pixels from the allocated framebuffer to the on-screen window. */
|
||||
/* r can be used to only update a small region of pixels (may be ignored) */
|
||||
void Window_DrawFramebuffer(Rect2D r);
|
||||
/* Frees the previously allocated framebuffer. */
|
||||
void Window_FreeFramebuffer(Bitmap* bmp);
|
||||
void Window_FreeFramebuffer(struct Bitmap* bmp);
|
||||
|
||||
/* Displays on-screen keyboard for platforms that lack physical keyboard input. */
|
||||
/* NOTE: On desktop platforms, this won't do anything. */
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user