struct texture* texture_load_from_png(const char* file_path)
{
if(!file_path) {
fprintf(stderr, "texure, texture_load_from_png, file_path is nil?");
return NULL;
}
// load png data into memory
size_t file_size = 0;
unsigned char* origin_data = fs_read(file_path, &file_size, 0);
unsigned char* pixel_data = NULL;
unsigned int width = 0;
unsigned int height = 0;
unsigned int error = 0;
error = lodepng_decode32(&pixel_data,
&width, &height,
origin_data, file_size);
s_free(origin_data);
if(error) {
fprintf(stderr, "error %u: %s\n", error, lodepng_error_text(error));
return NULL;
}
struct texture* tex = texture_load_from_mem(pixel_data, width, height, GL_RGBA);
// TODO: third party use the standard malloc, we may replace that with s_malloc some day.
free(pixel_data);
return tex;
}
void load_texture(C3D_Tex *tex, const u8 *img, const u32 img_size) {
unsigned int width, height;
u8* image;
lodepng_decode32(&image, &width, &height, img, img_size);
u8 *gpusrc = (u8 *) linearAlloc(width * height * 4);
// lodepng outputs big endian rgba so we need to convert
convert_endianess(gpusrc, image, width * height);
// ensure data is in physical ram
GSPGPU_FlushDataCache(gpusrc, width * height * 4);
// Load the texture and bind it to the first texture unit
C3D_TexInit(tex, width, height, GPU_RGBA8);
// Convert image to 3DS tiled texture format
C3D_SyncDisplayTransfer((u32*)gpusrc, GX_BUFFER_DIM(width, height), (u32*) tex->data, GX_BUFFER_DIM(width, height), TEXTURE_TRANSFER_FLAGS);
C3D_TexSetFilter(tex, GPU_LINEAR, GPU_NEAREST);
free(image);
linearFree(gpusrc);
}
void load_png_texture_from_buffer(const char *in, int size) {
unsigned int error;
unsigned char *data;
unsigned int width, height;
error = lodepng_decode32(&data, &width, &height, (unsigned char *)in, size);
if (error) {
fprintf(stderr, "error %u: %s\n", error, lodepng_error_text(error));
}
flip_image_vertical(data, width, height);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA,
GL_UNSIGNED_BYTE, data);
free(data);
}
/*
Example 2
Load PNG file from disk to memory first, then decode to raw pixels in memory.
*/
void decodeTwoSteps(const char *filename)
{
unsigned error;
unsigned char *image;
unsigned width, height;
unsigned char *png;
size_t pngsize;
lodepng_load_file(&png, &pngsize, filename);
error = lodepng_decode32(&image, &width, &height, png, pngsize);
if (error) printf("error %u: %s\n", error, lodepng_error_text(error));
free(png);
/*use image here*/
free(image);
}
bool Image::loadPNGMem( unsigned char *ptr, size_t sz, bool multiply_color_by_alpha ) {
unsigned error;
unsigned char* image_data = (unsigned char*) MALLOC( 2048 * 2048 * 4 );
unsigned w, h;
error = lodepng_decode32( &image_data, &w, &h, ptr,sz );
if(error) {
fprintf(stderr, "decoder error %u: %s\n", error, lodepng_error_text(error) );
FREE(image_data);
return false;
}
width = w;
height = h;
if( multiply_color_by_alpha ) multiplyAlphaRGBA(image_data,width,height);
ensureBuffer();
IMAGE_BUFFER_COPY;
FREE(image_data);
return true;
}
int winpr_image_png_read_buffer(wImage* image, BYTE* buffer, int size)
{
UINT32 width;
UINT32 height;
int lodepng_status;
lodepng_status = lodepng_decode32(&(image->data), &width, &height, buffer, size);
if (lodepng_status)
return -1;
image->width = width;
image->height = height;
image->bitsPerPixel = 32;
image->bytesPerPixel = 4;
image->scanline = image->bytesPerPixel * image->width;
return 1;
}
int LodePngCoder::Decode(const unsigned char *inBuffer,
unsigned int bufferLen, unsigned char **outputBuffer,
unsigned int *output_width,
unsigned int *output_height)
{
unsigned int uw = 0, uh = 0;
unsigned char *buffer = NULL;
int error = lodepng_decode32(&buffer, &uw, &uh, inBuffer, bufferLen);
if (output_width) *output_width = uw;
if (output_height) *output_height = uh;
if (outputBuffer) *outputBuffer = buffer;
if (error)
{
LOG_I("[LodePngCoder] fail to decode, error:%d, %s", error,
lodepng_error_text(error));
}
return error;
}
static bool icvDecodePng24(std::string* dst, const char* data, int size, int* width, int* height) {
if(dst == NULL || data == NULL || size <= 0) {
return false;
}
if(width == NULL || height == NULL) {
return false;
}
unsigned char* img;
unsigned w, h;
unsigned err = lodepng_decode32(&img, &w, &h, (const unsigned char*)data, size);
if(err != 0) return false;
dst->assign((const char*)img, w*h*3);
free(img);
*width = w;
*height = h;
return true;
}
void so_img_loader_lodepng_load(const char* file, so_img_loader_data_t* info)
{
unsigned error;
unsigned char* image;
unsigned width, height;
unsigned char* png;
size_t pngsize;
char abs_file_path[FILENAME_MAX];
ks_helper_path_join_relative_app(abs_file_path, sizeof(abs_file_path), file);
lodepng_load_file(&png, &pngsize, abs_file_path);
error = lodepng_decode32(&image, &width, &height, png, pngsize);
if(error) printf("error %u: %s\n", error, lodepng_error_text(error));
free(png);
info->pixels = (char*)image;
info->width = width;
info->height = height;
}
int winpr_image_png_read_fp(wImage* image, FILE* fp)
{
INT64 size;
BYTE* data;
UINT32 width;
UINT32 height;
int lodepng_status;
_fseeki64(fp, 0, SEEK_END);
size = _ftelli64(fp);
_fseeki64(fp, 0, SEEK_SET);
data = (BYTE*) malloc(size);
if (!data)
return -1;
if (fread((void*) data, size, 1, fp) != 1)
{
free(data);
return -1;
}
lodepng_status = lodepng_decode32(&(image->data), &width, &height, data, size);
free(data);
if (lodepng_status)
return -1;
image->width = width;
image->height = height;
image->bitsPerPixel = 32;
image->bytesPerPixel = 4;
image->scanline = image->bytesPerPixel * image->width;
return 1;
}
static rt_bool_t rtgui_image_png_load(struct rtgui_image *image, struct rtgui_filerw *file, rt_bool_t load)
{
unsigned int width;
unsigned int height;
unsigned int error;
rt_uint8_t* pixel;
rt_uint8_t* in;
rt_uint32_t in_size;
RT_ASSERT(image != RT_NULL);
RT_ASSERT(file != RT_NULL);
rtgui_filerw_seek(file, 0, SEEK_END);
in_size = rtgui_filerw_tell(file);
in = rtgui_malloc(in_size);
if (in == RT_NULL) return RT_FALSE; /* out of memory */
rtgui_filerw_seek(file, 0, SEEK_SET);
rtgui_filerw_read(file, in, in_size, 1);
error = lodepng_decode32(&pixel, &width, &height, in, in_size);
if(error)
{
rt_kprintf("error %u: %s\n", error, lodepng_error_text(error));
rtgui_free(in);
return RT_FALSE;
}
rtgui_free(in);
/* set image information */
image->w = width;
image->h = height;
image->engine = &rtgui_image_png_engine;
image->data = pixel;
/* NOTE: the pixel format of PNG is ABGR888, bit0 R,G,B,A bit31 */
/* convert pixel to ARGB888, swap B/G */
{
rt_uint8_t* pixel_ptr;
rt_uint8_t* pixel_end;
pixel_ptr = (rt_uint8_t*) pixel;
pixel_end = pixel_ptr + width * height * 4;
while (pixel_ptr < pixel_end)
{
pixel_ptr[0] = pixel_ptr[0] ^ pixel_ptr[2];
pixel_ptr[2] = pixel_ptr[0] ^ pixel_ptr[2];
pixel_ptr[0] = pixel_ptr[0] ^ pixel_ptr[2];
pixel_ptr += 4;
}
}
/* close file handler */
rtgui_filerw_close(file);
return RT_TRUE;
}
void sprite_sheet::incremental_load(const application_folder & in_application_folder)
{
switch(internal_status)
{
case sprite_sheet_status::ready:
case sprite_sheet_status::failed:
break;
case sprite_sheet_status::waiting_to_load:
{
if(internal_loaded_file_data.status() == file_data_status::waiting_to_load)
{
internal_status = sprite_sheet_status::loading;
internal_loaded_file_data.load(in_application_folder, internal_sheet_file_path.c_str());
}
break;
}
case sprite_sheet_status::loading:
{
if(internal_loaded_file_data.status() == file_data_status::loading)
{
}
else if(internal_loaded_file_data.status() == file_data_status::ready)
{
auto file_data = internal_loaded_file_data.data();
atl::input_bit_string_type bit_string(file_data.data(), file_data.data() + file_data.size());
// Load frames:
glActiveTexture(GL_TEXTURE0);
uint32_t numSheets;
atl::bit_string_read_chunked_integer<uint32_t>(bit_string, numSheets, 3);
uint32_t totalSprites;
atl::bit_string_read_chunked_integer<uint32_t>(bit_string, totalSprites, 7);
sprites.resize(totalSprites);
textures.resize(numSheets);
for(auto & sheetId : textures)
{
// give the sheet a valid opengl texture ID
glGenTextures(1, &sheetId);
check_gl_errors();
uint32_t fontSheetWidthPower, fontSheetHeightPower;
atl::bit_string_read_ranged_integer<uint32_t>(bit_string, fontSheetWidthPower, 0, 12);
atl::bit_string_read_ranged_integer<uint32_t>(bit_string, fontSheetHeightPower, 0, 12);
uint32_t sheetWidth = 1 << fontSheetWidthPower;
uint32_t sheetHeight = 1 << fontSheetHeightPower;
atl::size2f sheetSize(sheetWidth, sheetHeight);
uint32_t sheetSprites;
atl::bit_string_read_ranged_integer<uint32_t>(bit_string, sheetSprites, 0, totalSprites);
while(sheetSprites-- > 0)
{
// Deserialize the frame index:
uint32_t spriteIndex;
atl::bit_string_read_ranged_integer<uint32_t>(bit_string, spriteIndex, 0, totalSprites - 1);
// Deserialize the texture coordinates:
atl::box2f l_texCoords;
{
uint32_t l_texT, l_texR, l_texB, l_texL;
atl::bit_string_read_ranged_integer<uint32_t>(bit_string, l_texT, 0, sheetHeight);
atl::bit_string_read_ranged_integer<uint32_t>(bit_string, l_texR, 0, sheetWidth);
atl::bit_string_read_ranged_integer<uint32_t>(bit_string, l_texB, 0, sheetHeight);
atl::bit_string_read_ranged_integer<uint32_t>(bit_string, l_texL, 0, sheetWidth);
if(l_texR - l_texL == 1)
{
l_texCoords.l = l_texCoords.r = (float(l_texL) + 0.5f) / float(sheetWidth);
}
else
{
l_texCoords.l = (float(l_texL)) / float(sheetWidth);
l_texCoords.r = (float(l_texR)) / float(sheetWidth);
}
if(l_texB - l_texT == 1)
{
l_texCoords.t = l_texCoords.b = (float(l_texT) + 0.5f) / float(sheetHeight);
}
else
{
l_texCoords.t = (float(l_texT)) / float(sheetHeight);
l_texCoords.b = (float(l_texB)) / float(sheetHeight);
}
}
// Deserialize the drawn area:
atl::box2f l_area;
atl::bit_string_read_values(bit_string, l_area.t, l_area.r, l_area.b, l_area.l);
sprites[spriteIndex].set(sheetId, l_texCoords, l_area);
}
// Decode PNG data and upload to card:
glBindTexture(GL_TEXTURE_2D, sheetId);
int32_t numPNGBytesInt32;
atl::bit_string_read_value(bit_string, numPNGBytesInt32);
size_t numPNGBytes = numPNGBytesInt32;
atl::bit_string_skip_to_next_byte(bit_string);
const unsigned char * l_pngBytes = bit_string.ptr;
bit_string.ptr += numPNGBytes;
unsigned char * imageDataOut = nullptr;
unsigned int imageWidthOut;
unsigned int imageHeightOut;
unsigned int decodeError = lodepng_decode32(&imageDataOut, &imageWidthOut, &imageHeightOut, l_pngBytes, numPNGBytes);
atl_fatal_if(decodeError > 0, "Couldn't decode PNG in sprite sheet");
atl_fatal_if(imageWidthOut != sheetWidth || imageHeightOut != sheetHeight, "PNG in sprite sheet of unexpected size");
// Allocate GL resource:
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
check_gl_errors();
glTexImage2D(GL_TEXTURE_2D,
0,
GL_RGBA,
atl::integer_cast<GLsizei>(sheetWidth, [](){}),
atl::integer_cast<GLsizei>(sheetHeight, [](){}),
0,
GL_RGBA,
GL_UNSIGNED_BYTE,
imageDataOut);
check_gl_errors();
GLint lFilteringMode = internal_texture_filtering_mode == texture_filtering_mode::linear ? GL_LINEAR : GL_NEAREST;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, lFilteringMode);
check_gl_errors();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, lFilteringMode);
check_gl_errors();
delete[] imageDataOut;
}
internal_loaded_file_data.free();
internal_status = sprite_sheet_status::ready;
}
else
{
internal_status = sprite_sheet_status::failed;
}
break;
}
}
}
//---------------------------------------------------------------------------------
static void sceneInit(void) {
//---------------------------------------------------------------------------------
int i;
// Load the vertex shader, create a shader program and bind it
vshader_dvlb = DVLB_ParseFile((u32*)vshader_shbin, vshader_shbin_size);
shaderProgramInit(&program);
shaderProgramSetVsh(&program, &vshader_dvlb->DVLE[0]);
C3D_BindProgram(&program);
// Get the location of the uniforms
uLoc_projection = shaderInstanceGetUniformLocation(program.vertexShader, "projection");
// Configure attributes for use with the vertex shader
// Attribute format and element count are ignored in immediate mode
C3D_AttrInfo* attrInfo = C3D_GetAttrInfo();
AttrInfo_Init(attrInfo);
AttrInfo_AddLoader(attrInfo, 0, GPU_FLOAT, 3); // v0=position
AttrInfo_AddLoader(attrInfo, 1, GPU_FLOAT, 2); // v2=texcoord
// Compute the projection matrix
// Note: we're setting top to 240 here so origin is at top left.
Mtx_OrthoTilt(&projection, 0.0, 400.0, 240.0, 0.0, 0.0, 1.0);
// Configure buffers
C3D_BufInfo* bufInfo = C3D_GetBufInfo();
BufInfo_Init(bufInfo);
unsigned char* image;
unsigned width, height;
lodepng_decode32(&image, &width, &height, ballsprites_png, ballsprites_png_size);
u8 *gpusrc = linearAlloc(width*height*4);
// GX_DisplayTransfer needs input buffer in linear RAM
u8* src=image; u8 *dst=gpusrc;
// lodepng outputs big endian rgba so we need to convert
for(int i = 0; i<width*height; i++) {
int r = *src++;
int g = *src++;
int b = *src++;
int a = *src++;
*dst++ = a;
*dst++ = b;
*dst++ = g;
*dst++ = r;
}
// ensure data is in physical ram
GSPGPU_FlushDataCache(gpusrc, width*height*4);
// Load the texture and bind it to the first texture unit
C3D_TexInit(&spritesheet_tex, width, height, GPU_RGBA8);
// Convert image to 3DS tiled texture format
C3D_SafeDisplayTransfer ((u32*)gpusrc, GX_BUFFER_DIM(width,height), (u32*)spritesheet_tex.data, GX_BUFFER_DIM(width,height), TEXTURE_TRANSFER_FLAGS);
gspWaitForPPF();
C3D_TexSetFilter(&spritesheet_tex, GPU_LINEAR, GPU_NEAREST);
C3D_TexBind(0, &spritesheet_tex);
free(image);
linearFree(gpusrc);
// Configure the first fragment shading substage to just pass through the texture color
// See https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnv.xml for more insight
C3D_TexEnv* env = C3D_GetTexEnv(0);
C3D_TexEnvSrc(env, C3D_Both, GPU_TEXTURE0, 0, 0);
C3D_TexEnvOp(env, C3D_Both, 0, 0, 0);
C3D_TexEnvFunc(env, C3D_Both, GPU_REPLACE);
srand(time(NULL));
for(i = 0; i < NUM_SPRITES; i++) {
//random place and speed
sprites[i].x = (rand() % (400 - 32 )) << 8;
sprites[i].y = (rand() % (240 - 32 )) << 8 ;
sprites[i].dx = (rand() & 0xFF) + 0x100;
sprites[i].dy = (rand() & 0xFF) + 0x100;
sprites[i].image = rand() & 3;
if(rand() & 1)
sprites[i].dx = -sprites[i].dx;
if(rand() & 1)
sprites[i].dy = -sprites[i].dy;
}
// Configure depth test to overwrite pixels with the same depth (needed to draw overlapping sprites)
C3D_DepthTest(true, GPU_GEQUAL, GPU_WRITE_ALL);
}
Bool png_load(u4 buffer_size, u1 *buffer, struct image *image) {
return lodepng_decode32((unsigned char **)&image->data, &image->width, &image->height, buffer, buffer_size) ? False : True;
}
