bool UIImage::initWithContentsOfFile(const string &strPath, eImageFormat imageType)
{
bool bRet = false;
switch (imageType)
{
case kCCImageFormatPNG:
// use libpng load image
bRet = loadPng(strPath.c_str());
break;
case kCCImageFormatJPG:
bRet = loadJpg(strPath.c_str());
break;
default:
// unsupported image type
bRet = false;
break;
}
if (!bRet && s_bPopupNotify)
{
// notify the loading error
std::string strErr = "Load ";
strErr += strPath;
strErr += " failed!";
std::wstring wsErr(strErr.length(), L'');
std::copy(strErr.begin(), strErr.end(), wsErr.begin());
MessageBox(NULL, wsErr.c_str(), L"cocos2d-x error", MB_OK);
}
return bRet;
}
void loadPng(GImage* pImage, const char* szFilename)
{
size_t nSize;
char* pRawData = GFile::loadFile(szFilename, &nSize);
ArrayHolder<char> hRawData(pRawData);
loadPng(pImage, (const unsigned char*)pRawData, nSize);
}
std::unique_ptr<uint8[]> loadLdr(const Path &path, TexelConversion request, int &w, int &h, bool gammaCorrect)
{
int channels;
DeletablePixels img(makeVoidPixels());
if (path.testExtension("png"))
img = loadPng(path, w, h, channels);
else
img = loadStbi(path, w, h, channels);
if (!img)
return nullptr;
int targetChannels = (request == TexelConversion::REQUEST_RGB) ? 4 : 1;
std::unique_ptr<uint8[]> texels(new uint8[w*h*targetChannels]);
if (targetChannels == 4) {
std::memcpy(texels.get(), img.get(), w*h*targetChannels*sizeof(uint8));
if (gammaCorrect)
for (int i = 0; i < w*h; ++i)
for (int t = 0; t < 3; ++t)
texels[i*4 + t] = GammaCorrection[texels[i*4 + t]];
} else {
for (int i = 0; i < w*h; ++i)
texels[i] = convertToScalar(request, int(img[i*4]), int(img[i*4 + 1]), int(img[i*4 + 2]),
int(img[i*4 + 3]), channels == 4);
}
return std::move(texels);
}
void loadPngFromHex(GImage* pImage, const char* szHex)
{
size_t len = strlen(szHex);
unsigned char* pBuf = new unsigned char[len / 2];
ArrayHolder<unsigned char> hBuf(pBuf);
GBits::hexToBuffer(szHex, len, pBuf);
loadPng(pImage, pBuf, len / 2);
}
APNGDATA * LoadAPNG_from_file( const wchar_t * pszFileName )
{
FILE *f = _wfopen(pszFileName,L"rb");
if(!f) return NULL;
IPngReader_File file(f);
APNGDATA *pRet = loadPng(&file);
fclose(f);
return pRet;
}
static int l_loadPng(lua_State *lua)
{
const char *file = luaL_checkstring(lua, 1);
const char *name = luaL_checkstring(lua, 2);
loadPng(file, name);
return 0;
}
int main(int argc, char *argv[])
{
HDRImage texture;
HDRImage collision;
std::cout<<"Loading images...";
if(!loadPng("data/mariotexture.png", texture) ||
!loadPng("data/mariocollision.png", collision))
{
std::cerr<<"failed :("<<std::endl;
return -1;
}
std::cout<<"done!"<<std::endl;
// Create a lightbuffer and add an ambient light
HDRImage lightbuffer(texture.width, texture.height);
lightbuffer.clear(vec3(32.0f));
// Simulate photon distribution into a lightbuffer
int photonCount = 1000000;
vec3 lightColor = vec3(1.0f, 0.9f, 0.9f);
simulate(texture, collision, lightbuffer, photonCount, lightColor);
// Multiplicatively blend texture with lightbuffer
HDRImage result(texture.width, texture.height);
for(int i = 0; i < texture.width * texture.height; ++i)
{
vec3 tex = texture.pixels[i];
vec3 light = lightbuffer.pixels[i];
result.pixels[i] = tex * light;
}
applyTonemap(result);
//applyTonemap(lightbuffer);
std::cout<<"Saving image...";
savePng("data/texturepp.png", result);
std::cout<<"done!\n";
std::cin.get();
return 0;
}
bool loadPng(const wchar_t* pNameFile, ImageBase** ppImage)
{
if (!(pNameFile && ppImage && !*ppImage)) return false;
FILE* pFile = ::_wfopen(pNameFile, L"rb");
if (!pFile) return false;
bool result = loadPng(pFile, ppImage);
::fclose(pFile);
return result;
}
int SliceMngr::loadSlice(const char *pFilename){
if (loadPng(&(mImage.image), pFilename) == false){
printf("failed to load\n");
return -1;
}else{
vc_dispmanx_resource_write_data(mImage.resource,
mImage.image.type,
mImage.image.pitch,
mImage.image.buffer,
&(mImage.dstRect));
}
return 0;
}
Image *ImageHelper::load(SDL_RWops *const rw)
{
SDL_Surface *const tmpImage = loadPng(rw);
if (!tmpImage)
{
logger->log("Error, image load failed: %s", IMG_GetError());
return nullptr;
}
Image *const image = loadSurface(tmpImage);
MSDL_FreeSurface(tmpImage);
return image;
}
s32 main(s32 argc, const char* argv[])
{
PadInfo padinfo;
PadData paddata;
int i;
atexit(appCleanup);
init_screen();
ioPadInit(7);
sysRegisterCallback(EVENT_SLOT0, eventHandle, NULL);
// Load texture
dice = loadPng(dice_bin);
assert(realityAddressToOffset(dice.data, &tx_offset) == 0);
//load_acid_texture((uint8_t *)tx_mem, 0);
// install fragment shader in rsx memory
u32 *frag_mem = rsxMemAlign(256, 256);
printf("frag_mem = 0x%08lx\n", (u64) frag_mem);
realityInstallFragmentProgram_old(context, &nv30_fp, frag_mem);
long frame = 0; // To keep track of how many frames we have rendered.
// Ok, everything is setup. Now for the main loop.
while(1){
// Check the pads.
ioPadGetInfo(&padinfo);
for(i=0; i<MAX_PADS; i++){
if(padinfo.status[i]){
ioPadGetData(i, &paddata);
if(paddata.BTN_CROSS || paddata.BTN_START){
return 0;
}
}
}
waitFlip(); // Wait for the last flip to finish, so we can draw to the old buffer
drawFrame(currentBuffer, frame++); // Draw into the unused buffer
flip(currentBuffer); // Flip buffer onto screen
currentBuffer = !currentBuffer;
sysCheckCallback();
}
return 0;
}
Image *OpenGLImageHelper::load(SDL_RWops *const rw, Dye const &dye)
{
SDL_Surface *const tmpImage = loadPng(rw);
if (!tmpImage)
{
reportAlways("Error, image load failed: %s", IMG_GetError());
return nullptr;
}
SDL_Surface *const surf = convertTo32Bit(tmpImage);
MSDL_FreeSurface(tmpImage);
if (!surf)
return nullptr;
uint32_t *pixels = static_cast<uint32_t *>(surf->pixels);
const int type = dye.getType();
switch (type)
{
case 1:
{
const DyePalette *const pal = dye.getSPalete();
if (pal)
pal->replaceSOGLColor(pixels, surf->w * surf->h);
break;
}
case 2:
{
const DyePalette *const pal = dye.getAPalete();
if (pal)
pal->replaceAOGLColor(pixels, surf->w * surf->h);
break;
}
case 0:
default:
{
dye.normalOGLDye(pixels, surf->w * surf->h);
break;
}
}
Image *const image = loadSurface(surf);
MSDL_FreeSurface(surf);
return image;
}
bool Bitmap::loadData(const uint8_t * data, size_t dataLen, const StrideFn &strideFn) {
bool ret = false;
if (isPng(data, dataLen)) {
#ifndef NOPNG
if (loadPng(data, dataLen, _data, _color, _alpha, _width, _height, _stride, strideFn)) {
ret = true;
}
#endif
} else if (isJpg(data, dataLen)) {
#ifndef NOJPEG
if (loadJpg(data, dataLen, _data, _color, _alpha, _width, _height, _stride, strideFn)) {
ret = true;
}
#endif
} /* else if (isWebp(data, dataLen)) {
if (loadWebp(data, dataLen, _data, _color, _alpha, _width, _height)) {
ret = true;
}
} */
return ret;
}
bool CTexture::Load(char *path){
FILE* fp;
fopen_s(&fp,path, "rb");
if(!fp) {
printf("ファイルが読み込めません[%s]",path);
m_bufID=0;
return false;
}
unsigned char crc[4];
fread(crc,4,1,fp);
if(crc[0]==0x42 && crc[1]==0x4D) {
fclose(fp);
return loadBmp(path);
}else {
// if(crc[1]==0x50 && crc[2]==0x4E && crc[3]==0x47) {
fclose(fp);
return loadPng(path);
}
}
int main(int argc, char *argv[])
{
uint16_t background = 0x000F;
int32_t layer = 1;
uint32_t displayNumber = 0;
int32_t xOffset = 0;
int32_t yOffset = 0;
uint32_t timeout = 0;
bool xOffsetSet = false;
bool yOffsetSet = false;
bool interactive = true;
program = basename(argv[0]);
//---------------------------------------------------------------------
int opt = 0;
while ((opt = getopt(argc, argv, "b:d:l:x:y:t:n")) != -1)
{
switch(opt)
{
case 'b':
background = strtol(optarg, NULL, 16);
break;
case 'd':
displayNumber = strtol(optarg, NULL, 10);
break;
case 'l':
layer = strtol(optarg, NULL, 10);
break;
case 'x':
xOffset = strtol(optarg, NULL, 10);
xOffsetSet = true;
break;
case 'y':
yOffset = strtol(optarg, NULL, 10);
yOffsetSet = true;
break;
case 't':
timeout = atoi(optarg);
break;
case 'n':
interactive = false;
break;
default:
usage();
break;
}
}
//---------------------------------------------------------------------
if (optind >= argc)
{
usage();
}
//---------------------------------------------------------------------
IMAGE_LAYER_T imageLayer;
const char *imagePath = argv[optind];
if(strcmp(imagePath, "-") == 0)
{
// Use stdin
if (loadPngFile(&(imageLayer.image), stdin) == false)
{
fprintf(stderr, "unable to load %s\n", imagePath);
exit(EXIT_FAILURE);
}
}
else
{
// Load image from path
if (loadPng(&(imageLayer.image), imagePath) == false)
{
fprintf(stderr, "unable to load %s\n", imagePath);
exit(EXIT_FAILURE);
}
}
//---------------------------------------------------------------------
if (signal(SIGINT, signalHandler) == SIG_ERR)
{
perror("installing SIGINT signal handler");
exit(EXIT_FAILURE);
}
//---------------------------------------------------------------------
if (signal(SIGTERM, signalHandler) == SIG_ERR)
{
perror("installing SIGTERM signal handler");
exit(EXIT_FAILURE);
}
//---------------------------------------------------------------------
bcm_host_init();
//---------------------------------------------------------------------
DISPMANX_DISPLAY_HANDLE_T display
= vc_dispmanx_display_open(displayNumber);
assert(display != 0);
//---------------------------------------------------------------------
DISPMANX_MODEINFO_T info;
int result = vc_dispmanx_display_get_info(display, &info);
assert(result == 0);
//---------------------------------------------------------------------
BACKGROUND_LAYER_T backgroundLayer;
if (background > 0)
{
initBackgroundLayer(&backgroundLayer, background, 0);
}
createResourceImageLayer(&imageLayer, layer);
//---------------------------------------------------------------------
DISPMANX_UPDATE_HANDLE_T update = vc_dispmanx_update_start(0);
assert(update != 0);
if (background > 0)
{
addElementBackgroundLayer(&backgroundLayer, display, update);
}
if (xOffsetSet == false)
{
xOffset = (info.width - imageLayer.image.width) / 2;
}
if (yOffsetSet == false)
{
yOffset = (info.height - imageLayer.image.height) / 2;
}
addElementImageLayerOffset(&imageLayer,
xOffset,
yOffset,
display,
update);
result = vc_dispmanx_update_submit_sync(update);
assert(result == 0);
//---------------------------------------------------------------------
int32_t step = 1;
uint32_t currentTime = 0;
// Sleep for 10 milliseconds every run-loop
const int sleepMilliseconds = 10;
while (run)
{
int c = 0;
if (interactive && keyPressed(&c))
{
c = tolower(c);
bool moveLayer = false;
switch (c)
{
case 27:
run = false;
break;
case 'a':
xOffset -= step;
moveLayer = true;
break;
case 'd':
xOffset += step;
moveLayer = true;
break;
case 'w':
yOffset -= step;
moveLayer = true;
break;
case 's':
yOffset += step;
moveLayer = true;
break;
case '+':
if (step == 1)
{
step = 5;
}
else if (step == 5)
{
step = 10;
}
else if (step == 10)
{
step = 20;
}
break;
case '-':
if (step == 20)
{
step = 10;
}
else if (step == 10)
{
step = 5;
}
else if (step == 5)
{
step = 1;
}
break;
}
if (moveLayer)
{
update = vc_dispmanx_update_start(0);
assert(update != 0);
moveImageLayer(&imageLayer, xOffset, yOffset, update);
result = vc_dispmanx_update_submit_sync(update);
assert(result == 0);
}
}
//---------------------------------------------------------------------
usleep(sleepMilliseconds * 1000);
currentTime += sleepMilliseconds;
if (timeout != 0 && currentTime >= timeout) {
run = false;
}
}
//---------------------------------------------------------------------
keyboardReset();
//---------------------------------------------------------------------
if (background > 0)
{
destroyBackgroundLayer(&backgroundLayer);
}
destroyImageLayer(&imageLayer);
//---------------------------------------------------------------------
result = vc_dispmanx_display_close(display);
assert(result == 0);
//---------------------------------------------------------------------
return 0;
}
APNGDATA * LoadAPNG_from_memory(const char * pBuf, size_t nLen )
{
IPngReader_Mem mem(pBuf,nLen);
return loadPng(&mem);
}
void loading() {
// where all are loading going be done :D
sprite_image = loadPng(sprite_bin);
assert(realityAddressToOffset(sprite_image.data, &sprite_offset) == 0);
}
if (!tmpImage)
{
logger->log("Error, image load failed: %s", IMG_GetError());
return nullptr;
}
Image *const image = loadSurface(tmpImage);
MSDL_FreeSurface(tmpImage);
return image;
}
Image *ImageHelper::load(SDL_RWops *const rw, Dye const &dye)
{
BLOCK_START("ImageHelper::load")
SDL_Surface *const tmpImage = loadPng(rw);
if (!tmpImage)
{
logger->log("Error, image load failed: %s", IMG_GetError());
BLOCK_END("ImageHelper::load")
return nullptr;
}
SDL_PixelFormat rgba;
rgba.palette = nullptr;
rgba.BitsPerPixel = 32;
rgba.BytesPerPixel = 4;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
rgba.Rmask = 0x000000FF;
rgba.Gmask = 0x0000FF00;
bool UrlValue::loadImg(UrlValue_Img &img) const {
return loadPng(img) || loadJpeg(img);
}
void
rsxgltest_init(int argc,const char ** argv)
{
tcp_printf("%s\n",__PRETTY_FUNCTION__);
// Set up us the program:
shaders[0] = glCreateShader(GL_VERTEX_SHADER);
shaders[1] = glCreateShader(GL_FRAGMENT_SHADER);
program = glCreateProgram();
glAttachShader(program,shaders[0]);
glAttachShader(program,shaders[1]);
// Supply shader binaries:
glShaderBinary(1,shaders,0,textures_vpo,textures_vpo_size);
glShaderBinary(1,shaders + 1,0,textures_fpo,textures_fpo_size);
// Link the program for real:
glLinkProgram(program);
glValidateProgram(program);
GLint
vertex_location = glGetAttribLocation(program,"vertex"),
texcoord_location = glGetAttribLocation(program,"texcoord");
tcp_printf("vertex_location: %i\n",vertex_location);
tcp_printf("texcoord_location: %i\n",texcoord_location);
ProjMatrix_location = glGetUniformLocation(program,"ProjMatrix");
TransMatrix_location = glGetUniformLocation(program,"TransMatrix");
c_location = glGetUniformLocation(program,"c");
texture_location = glGetUniformLocation(program,"texture");
tcp_printf("ProjMatrix_location: %i TransMatrix_location: %i c_location: %i texture_location: %i\n",
ProjMatrix_location,TransMatrix_location,c_location,texture_location);
// Report on attributes:
{
GLint num_attribs = 0, attrib_name_length = 0;
glGetProgramiv(program,GL_ACTIVE_ATTRIBUTES,&num_attribs);
glGetProgramiv(program,GL_ACTIVE_ATTRIBUTE_MAX_LENGTH,&attrib_name_length);
tcp_printf("%u attribs, name max length: %u\n",num_attribs,attrib_name_length);
char szName[attrib_name_length + 1];
for(size_t i = 0;i < num_attribs;++i) {
GLint size = 0;
GLenum type = 0;
GLint location = 0;
glGetActiveAttrib(program,i,attrib_name_length + 1,0,&size,&type,szName);
location = glGetAttribLocation(program,szName);
tcp_printf("\t%u: %s %u %u %u\n",i,szName,(unsigned int)location,(unsigned int)size,(unsigned int)type);
}
}
// Report on uniforms:
{
GLint num_uniforms = 0, uniform_name_length = 0;
glGetProgramiv(program,GL_ACTIVE_UNIFORMS,&num_uniforms);
glGetProgramiv(program,GL_ACTIVE_UNIFORM_MAX_LENGTH,&uniform_name_length);
tcp_printf("%u uniforms, name max length: %u\n",num_uniforms,uniform_name_length);
char szName[uniform_name_length + 1];
for(size_t i = 0;i < num_uniforms;++i) {
GLint size = 0;
GLenum type = 0;
GLint location = 0;
glGetActiveUniform(program,i,uniform_name_length + 1,0,&size,&type,szName);
location = glGetUniformLocation(program,szName);
tcp_printf("\t%u: %s %u %u %u\n",i,szName,(unsigned int)location,(unsigned int)size,(unsigned int)type);
}
}
glUseProgram(program);
const float identity[4][4] = { {1,0,0,0},{0,1,0,0},{0,0,1,0},{0,0,0,1} };
glUniformMatrix4fv(ProjMatrix_location,1,GL_FALSE,(const GLfloat *)identity);
glUniformMatrix4fv(TransMatrix_location,1,GL_FALSE,(const GLfloat *)identity);
glUniform1i(texture_location,0);
// Set up us the vertex data:
float geometry[] = {
0, 0, 0, 1,
0,0,
1.0, 0, 0, 1,
1,0,
0.0, 1.0, 0, 1,
0,1,
1.0, 0, 0, 1,
1,0,
1.0, 1.0, 0, 1,
1,1,
0.0, 1.0, 0, 1,
0,1
};
glGenBuffers(1,&buffer);
glBindBuffer(GL_ARRAY_BUFFER,buffer);
glBufferData(GL_ARRAY_BUFFER,sizeof(float) * 6 * 6,geometry,GL_STATIC_DRAW);
glEnableVertexAttribArray(vertex_location);
glEnableVertexAttribArray(texcoord_location);
glVertexAttribPointer(vertex_location,4,GL_FLOAT,GL_FALSE,sizeof(float) * 6,0);
glVertexAttribPointer(texcoord_location,2,GL_FLOAT,GL_FALSE,sizeof(float) * 6,(const GLvoid *)(sizeof(float) * 4));
glBindBuffer(GL_ARRAY_BUFFER,0);
// Textures:
dice = loadPng(dice_bin);
tcp_printf("dice size: %u %u\n",dice.width,dice.height);
GLuint dice_buffer = 0;
glGenBuffers(1,&dice_buffer);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER,dice_buffer);
glBufferData(GL_PIXEL_UNPACK_BUFFER,4 * dice.width * dice.height,dice.data,GL_STATIC_DRAW);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER,0);
uint8_t checkerboard_bgra[] = {
255,0,0,255, 0,255,0,255,
0,0,255,255, 255,255,255,255
};
uint8_t test_bgra[] = {
192,128,64,255, 192,128,64,255,
192,128,64,255, 192,128,64,255
};
glActiveTexture(GL_TEXTURE0);
glGenTextures(1,&texture);
glBindTexture(GL_TEXTURE_2D,texture);
tcp_printf("texture name: %u\n",texture);
//glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA8,2,2,0,GL_BGRA,GL_UNSIGNED_BYTE,checkerboard_bgra);
//glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA8,2,2,0,GL_BGRA,GL_UNSIGNED_BYTE,0);
//glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,dice.width,dice.height,0,GL_BGRA,GL_UNSIGNED_BYTE,dice.data);
//glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,dice.width,dice.height,0,GL_BGRA,GL_UNSIGNED_BYTE,0);
glTexStorage2D(GL_TEXTURE_2D,1,GL_RGBA,dice.width,dice.height);
//glTexSubImage2D(GL_TEXTURE_2D,0,0,0,dice.width,dice.height,GL_BGRA,GL_UNSIGNED_BYTE,dice.data);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER,dice_buffer);
glTexSubImage2D(GL_TEXTURE_2D,0,0,0,dice.width,dice.height,GL_BGRA,GL_UNSIGNED_BYTE,0);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER,0);
report_glerror("glTexImage2D");
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
}
