void Image::read_png(const char* filename) { std::vector<unsigned char> buffer, image; //load the image file with given filename LodePNG::loadFile(buffer, filename); //decode the png LodePNG::Decoder decoder; decoder.decode(image, buffer.empty() ? 0 : &buffer[0], (unsigned)buffer.size()); if (decoder.getChannels()<3 || decoder.getBpp()<24) { cerr << "Error: only color (RGBA), 8 bit per channel png images are supported." << endl; cerr << "Either convert your image or change the sourcecode." << endl; exit(1); } int w = decoder.getWidth(); int h = decoder.getHeight(); set_extent(w,h); // now convert the image data std::vector<unsigned char>::iterator imageIterator = image.begin(); Color *currentPixel = _pixel; while (imageIterator != image.end()) { currentPixel->r = (*imageIterator)/255.0; imageIterator++; currentPixel->g = (*imageIterator)/255.0; imageIterator++; currentPixel->b = (*imageIterator)/255.0; imageIterator++; // Let's just ignore the alpha channel imageIterator++; currentPixel++; } }
bool Res::Init() { Shader* shader = nullptr; Texture* texture = nullptr; // block shader shader = new Shader(); if (!shader->Init("res/block.vert", "res/block.frag")) return false; AddShader("block", shader); // simpler color shader shader = new Shader(); if (!shader->Init("res/color.vert", "res/color.frag")) return false; AddShader("color", shader); std::vector<byte> buffer, image; LodePNG::loadFile(buffer, "res/blocks.png"); LodePNG::Decoder decoder; decoder.decode(image, buffer); int dim = decoder.getWidth(); texture = Texture::Create3DTexture(dim, dim, decoder.getHeight() / dim, image.data()); AddTexture("blocks", texture); return true; }
bool ProceduralTexture::loadPNG(char *png_map) { LodePNG::Decoder pngDecoder; std::vector<unsigned char> buffer; Logger::log("Loading png file %s..\n",png_map); LodePNG::loadFile(buffer,png_map); Logger::log("Calling PNG decoder..\n"); pngDecoder.decode(image, buffer); Logger::log("Checking decoder state..\n"); if(pngDecoder.hasError()) { Logger::log("[loadTextureFromPng] Error %d\n", pngDecoder.getError()); Logger::log(" while trying to load \'%s\'\n",png_map); return false; } width = pngDecoder.getWidth(); height = pngDecoder.getHeight(); Logger::log("PNG Decoder Info [ width: %d, height: %d ]..\n",width,height); Logger::log("image size: %d\n",image.size()); Logger::log("isGreyScale: %s\n",pngDecoder.isGreyscaleType()?"true":"false"); Logger::log("isAlphaType: %s\n",pngDecoder.isAlphaType()?"true":"false"); Logger::log("Channels: %d\n",pngDecoder.getChannels()); Logger::log("BPP: %d\n",pngDecoder.getBpp()); return true; }
Image* FW::importLodePngImage(InputStream& stream) { // Read the entire input stream. Array<U8> dataBuffer; int blockSize = 4096; for (;;) { int pos = dataBuffer.getSize(); dataBuffer.resize(pos + blockSize); int num = stream.read(dataBuffer.getPtr(pos), blockSize); if (num < blockSize) { dataBuffer.resize(pos + num); break; } } if (hasError()) return NULL; // Decode image info. LodePNG::Decoder decoder; decoder.inspect(dataBuffer.getPtr(), dataBuffer.getSize()); Vec2i size(decoder.getWidth(), decoder.getHeight()); bool hasAlpha = (LodePNG_InfoColor_canHaveAlpha(&decoder.getInfoPng().color) != 0); if (decoder.hasError()) setError("importLodePngImage(): LodePNG error %d!", decoder.getError()); if (min(size) <= 0) setError("importLodePngImage(): Invalid image size!"); if (hasError()) return NULL; // Decode image data. int numBytes = size.x * size.y * ((hasAlpha) ? 4 : 3); std::vector<U8> pixelBuffer; pixelBuffer.reserve(numBytes); decoder.getInfoRaw().color.colorType = (hasAlpha) ? 6 : 2; decoder.decode(pixelBuffer, dataBuffer.getPtr(), dataBuffer.getSize()); if (decoder.hasError()) setError("importLodePngImage(): LodePNG error %d!", decoder.getError()); if ((int)pixelBuffer.size() != numBytes) setError("importLodePngImage(): Incorrect amount of pixel data!"); if (hasError()) return NULL; // Create image. Image* image = new Image(size, (hasAlpha) ? ImageFormat::R8_G8_B8_A8 : ImageFormat::R8_G8_B8); image->getBuffer().set(&pixelBuffer[0], numBytes); return image; }
bool C_TexturePNG::Load(S_Texture * texture, const char * filename) { std::vector<unsigned char> buffer, image; LodePNG::loadFile(buffer, filename); LodePNG::Decoder decoder; decoder.decode(image, buffer); if(decoder.hasError()) return false; texture->width = decoder.getWidth(); texture->height = decoder.getHeight(); texture->bpp = decoder.getBpp(); texture->imageData = new GLubyte[image.size()]; std::copy(image.begin(), image.end(), texture->imageData); texture->type = GL_RGBA; return true; }
// Load image from file [true = success, false otherwise] bool PNG::load(string pathname){ std::vector<unsigned char> buffer; LodePNG::loadFile(buffer, pathname); //load the image file with given filename LodePNG::Decoder decoder; decoder.inspect(buffer); if (decoder.isGreyscaleType()){ decoder.getInfoRaw().color.colorType = 0; decoder.getInfoRaw().color.bitDepth = 16; // is grayscale } decoder.decode(image, buffer); width = decoder.getWidth(); height = decoder.getHeight(); if(decoder.hasError()) { return false; } return true; }
int LuaCube::testScreenshot(lua_State *L) { const char *filename = luaL_checkstring(L, 1); const lua_Integer tolerance = lua_tointeger(L, 2); Cube::LCD &lcd = LuaSystem::sys->cubes[id].lcd; std::vector<uint8_t> pngData; std::vector<uint8_t> pixels; LodePNG::Decoder decoder; LodePNG::loadFile(pngData, filename); if (!pngData.empty()) decoder.decode(pixels, pngData); if (pixels.empty()) { lua_pushfstring(L, "error loading PNG file \"%s\"", filename); lua_error(L); } for (unsigned i = 0; i < lcd.FB_SIZE; i++) { RGB565 fbColor = lcd.fb_mem[i]; RGB565 refColor = &pixels[i*4]; int dR = int(fbColor.red()) - int(refColor.red()); int dG = int(fbColor.green()) - int(refColor.green()); int dB = int(fbColor.blue()) - int(refColor.blue()); int error = dR*dR + dG*dG + dB*dB; if (error > tolerance) { // Image mismatch. Return (x, y, lcdPixel, refPixel, error) lua_pushinteger(L, i % lcd.WIDTH); lua_pushinteger(L, i / lcd.WIDTH); lua_pushinteger(L, fbColor.value); lua_pushinteger(L, refColor.value); lua_pushinteger(L, error); return 5; } } return 0; }
static bool Load(Image *img, ImageDesc *desc, uchar *data, int data_size) { //lodepng를 기반으로 적절히 로딩하기 SR_ASSERT(data != NULL); SR_ASSERT(data_size > 0); img->image_data_.clear(); LodePNG::Decoder decoder; decoder.decode(img->image_data(), data, data_size); if(decoder.hasError()) { return false; } else { desc->width = decoder.getWidth(); desc->height = decoder.getHeight(); desc->bit_depth = decoder.getInfoPng().color.bitDepth; desc->bpp = decoder.getBpp(); desc->color_channels = decoder.getChannels(); desc->is_grayscale = decoder.isGreyscaleType() > 0 ? true : false; desc->is_alpha = decoder.isAlphaType() > 0 ? true : false; return true; } }
void Level::LoadFromPng(std::string pngFile) { File file; if (!file.Load(pngFile)) { return; } LodePNG::Decoder decoder; std::vector<unsigned char> image; decoder.decode(image, (const unsigned char*)file.Data(), file.Size()); for(int i=0; i<image.size();i+=4) { int pixelIndex = i/4; unsigned char r = image[i]; unsigned char g = image[i+1]; unsigned char b = image[i+2]; unsigned char a = image[i+3]; /* "Green", "Red", "Blue", "Yellow" */ if (r==255 && g == 0 && b == 255) continue; //magenta is nothing int x = pixelIndex % decoder.getWidth(); int y = pixelIndex / decoder.getWidth(); Point p = {x,y}; allPoints.insert(p); if (r==255 && g == 255 && b == 255) { blockable.insert(p); } else if (r == 0 && g == 0 && b == 0) { spawnable.insert(p); } else if (r==0 && g == 255 && b == 0) { colorSpawnPoints[0].insert(p); }else if (r==255 && g == 0 && b == 0) { colorSpawnPoints[1].insert(p); }else if (r==0 && g == 0 && b == 255) { colorSpawnPoints[2].insert(p); }else if (r==255 && g == 255 && b == 0) { colorSpawnPoints[3].insert(p); } } if (allPoints.empty()) return; Point min = *allPoints.begin(); Point max = min; for(auto p : allPoints) { if (p.x>max.x) max.x = p.x; if (p.x<min.x) min.x = p.x; if (p.y>max.y) max.y = p.y; if (p.y<min.y) min.y = p.y; } Point mid = (max - min)/2; Point size = (max - min)/2 ; ModifyList(blockable, -mid - size); ModifyList(spawnable, -mid-size); }
GLuint createTexture(const char* filename) { std::vector< unsigned char > rawImage; LodePNG::loadFile( rawImage, filename ); LodePNG::Decoder decoder; std::vector< unsigned char > image; decoder.decode( image, rawImage.empty() ? 0 : &rawImage[0], (unsigned)rawImage.size() ); // // Flip and invert the PNG image since OpenGL likes to load everything // backwards from what is considered normal! // unsigned char *imagePtr = &image[0]; int halfTheHeightInPixels = decoder.getHeight() / 2; int heightInPixels = decoder.getHeight(); // Assuming RGBA for 4 components per pixel. int numColorComponents = 4; // Assuming each color component is an unsigned char. int widthInChars = decoder.getWidth() * numColorComponents; unsigned char *top = NULL; unsigned char *bottom = NULL; unsigned char temp = 0; for( int h = 0; h < halfTheHeightInPixels; ++h ) { top = imagePtr + h * widthInChars; bottom = imagePtr + (heightInPixels - h - 1) * widthInChars; for( int w = 0; w < widthInChars; ++w ) { // Swap the chars around. temp = *top; *top = *bottom; *bottom = temp; ++top; ++bottom; } } GLuint texid; //glEnable(GL_TEXTURE_2D); glGenTextures( 1, &texid ); glActiveTexture(GL_TEXTURE0); glBindTexture( GL_TEXTURE_2D, texid ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, decoder.getWidth(), decoder.getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, &image[0] ); if (isGLError()) return -1; return texid; }