void MD2Model::Part::loadTextureFilenames(BinaryInput& b, int num, int offset) { _textureFilenames.resize(num); b.setPosition(offset); for (int t = 0; t < num; ++t) { _textureFilenames[t] = b.readString(); } }
inline static void readBGR(uint8* byte, BinaryInput& bi) { int b = bi.readUInt8(); int g = bi.readUInt8(); int r = bi.readUInt8(); byte[0] = r; byte[1] = g; byte[2] = b; }
void ServerDescription::deserialize(BinaryInput& b) { serverName = b.readString(); applicationAddress.deserialize(b); applicationName = b.readString(); maxClients = b.readInt32(); debugAssert(maxClients >= 0); currentClients = b.readInt32(); data = b.readString(); lastUpdateTime = System::time(); }
void ParseOBJ::parse(BinaryInput& bi, const ParseOBJ::Options& options, const String& basePath) { m_filename = bi.getFilename(); String bp = basePath; if (bp == "<AUTO>") { bp = FilePath::parent(FileSystem::resolve(m_filename)); } parse((const char*)bi.getCArray() + bi.getPosition(), size_t(bi.getLength() - bi.getPosition()), bp, options); }
void ModulesManager::loadInput() { // BinaryInput BinaryInput *binaryInput = new BinaryInput(); m_inputModules[binaryInput->name()] = binaryInput; // BinaryInput PcapInput *pcapInput = new PcapInput(); m_inputModules[pcapInput->name()] = pcapInput; // IndexFileInput IndexFileInput *indexFileInput = new IndexFileInput(); m_inputModules[indexFileInput->name()] = indexFileInput; }
UniversalBSDF::Ref UniversalBSDF::speedCreate(BinaryInput& b) { UniversalBSDF::Ref s(new UniversalBSDF()); SpeedLoad::readHeader(b, "UniversalBSDF"); s->m_lambertian.speedDeserialize(b); s->m_glossy.speedDeserialize(b); s->m_transmissive.speedDeserialize(b); s->m_eta_t = b.readFloat32(); s->m_extinction_t.deserialize(b); s->m_eta_r = b.readFloat32(); s->m_extinction_r.deserialize(b); return s; }
void readHeader(BinaryInput& b, const String& expectedString) { const String header = b.readString(SpeedLoad::HEADER_LENGTH); (void)header; alwaysAssertM(header == expectedString, format("SpeedLoad expected to read chunk \"%s\" but found chunk \"%s\"", expectedString.c_str(), header.c_str())); }
void deserialize(BinaryInput& b) { magic = b.readInt32(); version = b.readInt32(); skinWidth = b.readInt32(); skinHeight = b.readInt32(); frameSize = b.readInt32(); numSkins = b.readInt32(); numVertices = b.readInt32(); numTexCoords = b.readInt32(); numTriangles = b.readInt32(); numGlCommands = b.readInt32(); numFrames = b.readInt32(); offsetSkins = b.readInt32(); offsetTexCoords = b.readInt32(); offsetTriangles = b.readInt32(); offsetFrames = b.readInt32(); offsetGlCommands = b.readInt32(); offsetEnd = b.readInt32(); }
void Vector2::deserialize(BinaryInput& b) { x = b.readFloat32(); y = b.readFloat32(); }
void Color1::deserialize(BinaryInput& bi) { value = bi.readFloat32(); }
std::enable_if_t<std::is_arithmetic<T>::value, void> load(BinaryInput & a, T & t) { a.load_Data(std::addressof(t), sizeof(t)); }
void GImage::decodeTGA( BinaryInput& input) { // This is a simple TGA loader that can handle uncompressed // truecolor TGA files (TGA type 2). // Verify this is a TGA file by looking for the TRUEVISION tag. int pos = input.getPosition(); input.setPosition(input.size() - 18); std::string tag = input.readString(16); if (tag != "TRUEVISION-XFILE") { throw Error("Not a TGA file", input.getFilename()); } input.setPosition(pos); int IDLength = input.readUInt8(); int colorMapType = input.readUInt8(); int imageType = input.readUInt8(); (void)colorMapType; // 2 is the type supported by this routine. if (imageType != 2 && imageType != 10) { throw Error("TGA images must be type 2 (Uncompressed truecolor) or 10 (Run-length truecolor)", input.getFilename()); } // Color map specification input.skip(5); // Image specification // Skip x and y offsets input.skip(4); m_width = input.readInt16(); m_height = input.readInt16(); int colorDepth = input.readUInt8(); if ((colorDepth != 24) && (colorDepth != 32)) { throw Error("TGA files must be 24 or 32 bit.", input.getFilename()); } if (colorDepth == 32) { m_channels = 4; } else { m_channels = 3; } // Image descriptor contains overlay data as well // as data indicating where the origin is int imageDescriptor = input.readUInt8(); (void)imageDescriptor; // Image ID input.skip(IDLength); m_byte = (uint8*)m_memMan->alloc(m_width * m_height * m_channels); debugAssert(m_byte); // Pixel data int x; int y; if (imageType == 2) { // Uncompressed if (m_channels == 3) { for (y = m_height - 1; y >= 0; --y) { for (x = 0; x < m_width; ++x) { int i = (x + y * m_width) * 3; readBGR(m_byte + i, input); } } } else { for (y = m_height - 1; y >= 0; --y) { for (x = 0; x < m_width; ++x) { int i = (x + y * m_width) * 4; readBGRA(m_byte + i, input); } } } } else if (imageType == 10) { // Run-length encoded for (y = m_height - 1; y >= 0; --y) { for (int x = 0; x < m_width; /* intentionally no x increment */) { // The specification guarantees that no packet will wrap past the end of a row const uint8 repetitionCount = input.readUInt8(); const uint8 numValues = (repetitionCount & (~128)) + 1; int byteOffset = (x + y * m_width) * 3; if (repetitionCount & 128) { // When the high bit is 1, this is a run-length packet if (m_channels == 3) { Color3uint8 value; readBGR((uint8*)(&value), input); for (int i = 0; i < numValues; ++i, ++x) { for (int b = 0; b < 3; ++b, ++byteOffset) { m_byte[byteOffset] = value[b]; } } } else { Color4uint8 value; readBGRA((uint8*)(&value), input); for (int i = 0; i < numValues; ++i, ++x) { for (int b = 0; b < 3; ++b, ++byteOffset) { m_byte[byteOffset] = value[b]; } } } } else { // When the high bit is 0, this is a raw packet for (int i = 0; i < numValues; ++i, ++x, byteOffset += m_channels) { readBGR(m_byte + byteOffset, input); } } } } } else { alwaysAssertM(false, "Unsupported type"); } }
inline static void readBGRA(uint8* byte, BinaryInput& bi) { readBGR(byte, bi); byte[3] = bi.readUInt8(); }
void deserialize(BinaryInput& b) { scale.deserialize(b); translate.deserialize(b); name = b.readString(16); }
void GImage::decodeJPEG( BinaryInput& input) { struct jpeg_decompress_struct cinfo; struct jpeg_error_mgr jerr; int loc = 0; channels = 3; // We have to set up the error handler, in case initialization fails. cinfo.err = jpeg_std_error(&jerr); // Initialize the JPEG decompression object. jpeg_create_decompress(&cinfo); // Specify data source (eg, a file, for us, memory) jpeg_memory_src(&cinfo, const_cast<uint8*>(input.getCArray()), input.size()); // Read the parameters with jpeg_read_header() jpeg_read_header(&cinfo, TRUE); // Set parameters for decompression // (We do nothing here since the defaults are fine) // Start decompressor jpeg_start_decompress(&cinfo); // Get and set the values of interest to this object this->width = cinfo.output_width; this->height = cinfo.output_height; // Prepare the pointer object for the pixel data _byte = (uint8*)System::malloc(width * height * 3); // JSAMPLEs per row in output buffer int bpp = cinfo.output_components; int row_stride = cinfo.output_width * bpp; // Make a one-row-high sample array that will go away when done with image JSAMPARRAY temp = (*cinfo.mem->alloc_sarray) ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1); // Read data on a scanline by scanline basis while (cinfo.output_scanline < cinfo.output_height) { // We may need to adjust the output based on the // number of channels it has. switch (bpp) { case 1: // Grayscale; decompress to temp. jpeg_read_scanlines(&cinfo, temp, 1); // Expand to three channels { uint8* scan = &(_byte[loc * 3]); uint8* endScan = scan + (width * 3); uint8* t = *temp; while (scan < endScan) { uint8 value = t[0]; // Spread the value 3x. scan[0] = value; scan[1] = value; scan[2] = value; scan += 3; t += 1; } } break; case 3: // Read directly into the array { // Need one extra level of indirection. uint8* scan = _byte + loc; JSAMPARRAY ptr = &scan; jpeg_read_scanlines(&cinfo, ptr, 1); } break; case 4: // RGBA; decompress to temp. jpeg_read_scanlines(&cinfo, temp, 1); // Drop the 3rd channel { uint8* scan = &(_byte[loc * 3]); uint8* endScan = scan + width * 3; uint8* t = *temp; while (scan < endScan) { scan[0] = t[0]; scan[1] = t[1]; scan[2] = t[2]; scan += 3; t += 4; } } break; default: throw Error("Unexpected number6 of channels.", input.getFilename()); } loc += row_stride; } // Finish decompression jpeg_finish_decompress(&cinfo); // Release JPEG decompression object jpeg_destroy_decompress(&cinfo); }
void GImage::decodeBMP( BinaryInput& input) { // The BMP decoding uses these flags. static const uint16 PICTURE_NONE = 0x0000; static const uint16 PICTURE_BITMAP = 0x1000; // Compression Flags static const uint16 PICTURE_UNCOMPRESSED = 0x0100; static const uint16 PICTURE_MONOCHROME = 0x0001; static const uint16 PICTURE_4BIT = 0x0002; static const uint16 PICTURE_8BIT = 0x0004; static const uint16 PICTURE_16BIT = 0x0008; static const uint16 PICTURE_24BIT = 0x0010; static const uint16 PICTURE_32BIT = 0x0020; (void)PICTURE_16BIT; (void)PICTURE_32BIT; // This is a simple BMP loader that can handle uncompressed BMP files. // Verify this is a BMP file by looking for the BM tag. input.reset(); std::string tag = input.readString(2); if (tag != "BM") { throw Error("Not a BMP file", input.getFilename()); } m_channels = 3; // Skip to the BITMAPINFOHEADER's width and height input.skip(16); m_width = input.readUInt32(); m_height = input.readUInt32(); // Skip to the bit count and compression type input.skip(2); uint16 bitCount = input.readUInt16(); uint32 compressionType = input.readUInt32(); uint8 red; uint8 green; uint8 blue; uint8 blank; // Only uncompressed bitmaps are supported by this code if ((int32)compressionType != BI_RGB) { throw Error("BMP images must be uncompressed", input.getFilename()); } uint8* palette = NULL; // Create the palette if needed if (bitCount <= 8) { // Skip to the palette color count in the header input.skip(12); int numColors = input.readUInt32(); palette = (uint8*)System::malloc(numColors * 3); debugAssert(palette); // Skip past the end of the header to the palette info input.skip(4); int c; for (c = 0; c < numColors * 3; c += 3) { // Palette information in bitmaps is stored in BGR_ format. // That means it's blue-green-red-blank, for each entry. blue = input.readUInt8(); green = input.readUInt8(); red = input.readUInt8(); blank = input.readUInt8(); palette[c] = red; palette[c + 1] = green; palette[c + 2] = blue; } } int hStart = 0; int hEnd = 0; int hDir = 0; if (m_height < 0) { m_height = -m_height; hStart = 0; hEnd = m_height; hDir = 1; } else { //height = height; hStart = m_height - 1; hEnd = -1; hDir = -1; } m_byte = (uint8*)m_memMan->alloc(m_width * m_height * 3); debugAssert(m_byte); int BMScanWidth; int BMPadding; uint8 BMGroup; uint8 BMPixel8; int currPixel; int dest; int flags = PICTURE_NONE; if (bitCount == 1) { // Note that this file is not necessarily grayscale, since it's possible // the palette is blue-and-white, or whatever. But of course most image // programs only write 1-bit images if they're black-and-white. flags = PICTURE_BITMAP | PICTURE_UNCOMPRESSED | PICTURE_MONOCHROME; // For bitmaps, each scanline is dword-aligned. BMScanWidth = (m_width + 7) >> 3; if (BMScanWidth & 3) { BMScanWidth += 4 - (BMScanWidth & 3); } // Powers of 2 int pow2[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; for (int h = hStart; h != hEnd; h += hDir) { currPixel = 0; dest = 3 * h * m_width; for (int w = 0; w < BMScanWidth; ++w) { BMGroup = input.readUInt8(); // Now we read the pixels. Usually there are eight pixels per byte, // since each pixel is represented by one bit, but if the width // is not a multiple of eight, the last byte will have some bits // set, with the others just being extra. Plus there's the // dword-alignment padding. So we keep checking to see if we've // already read "width" number of pixels. for (int i = 7; i >= 0; --i) { if (currPixel < m_width) { int src = 3 * ((BMGroup & pow2[i]) >> i); m_byte[dest] = palette[src]; m_byte[dest + 1] = palette[src + 1]; m_byte[dest + 2] = palette[src + 2]; ++currPixel; dest += 3; } } } }
void deserialize(BinaryInput& b) { i32 = b.readInt32(); i64 = b.readInt64(); s = b.readString(); f = b.readFloat32(); }
GFont::GFont(const String& filename, BinaryInput& b) { int ver = b.readInt32(); debugAssertM(ver == 1 || ver == 2, "Can't read font files other than version 1"); (void)ver; if (ver == 1) { charsetSize = 128; } else { charsetSize = b.readInt32(); } // Read the widths subWidth.resize(charsetSize); for (int c = 0; c < charsetSize; ++c) { subWidth[c] = b.readUInt16(); } baseline = b.readUInt16(); int texWidth = b.readUInt16(); charWidth = texWidth / 16; charHeight = texWidth / 16; // The input may not be a power of 2 int width = ceilPow2(charWidth * 16); int height = ceilPow2(charHeight * (charsetSize / 16)); // Create a texture const uint8* ptr = ((uint8*)b.getCArray()) + b.getPosition(); debugAssertM((b.getLength() - b.getPosition()) >= width * height, "File does not contain enough data for this size texture"); Texture::Preprocess preprocess; preprocess.computeMinMaxMean = false; const bool generateMipMaps = true; m_texture = Texture::fromMemory ( filename, ptr, ImageFormat::R8(), width, height, 1, 1, ImageFormat::R8(), Texture::DIM_2D, generateMipMaps, preprocess); m_textureMatrix[0] = 1.0f / m_texture->width(); m_textureMatrix[1] = 0; m_textureMatrix[2] = 0; m_textureMatrix[3] = 0; m_textureMatrix[4] = 0; m_textureMatrix[5] = 1.0f / m_texture->height(); m_textureMatrix[6] = 0; m_textureMatrix[7] = 0; m_textureMatrix[8] = 0; m_textureMatrix[9] = 0; m_textureMatrix[10] = 1; m_textureMatrix[11] = 0; m_textureMatrix[12] = 0; m_textureMatrix[13] = 0; m_textureMatrix[14] = 0; m_textureMatrix[15] = 1; m_name = filename; }
void GImage::decodeTGA( BinaryInput& input) { // This is a simple TGA loader that can handle uncompressed // truecolor TGA files (TGA type 2). // Verify this is a TGA file by looking for the TRUEVISION tag. int pos = input.getPosition(); input.setPosition(input.size() - 18); std::string tag = input.readString(16); if (tag != "TRUEVISION-XFILE") { throw Error("Not a TGA file", input.getFilename()); } input.setPosition(pos); int IDLength = input.readUInt8(); int colorMapType = input.readUInt8(); int imageType = input.readUInt8(); (void)colorMapType; // 2 is the type supported by this routine. if (imageType != 2) { throw Error("TGA images must be type 2 (Uncompressed truecolor)", input.getFilename()); } // Color map specification input.skip(5); // Image specification // Skip x and y offsets input.skip(4); m_width = input.readInt16(); m_height = input.readInt16(); int colorDepth = input.readUInt8(); if ((colorDepth != 24) && (colorDepth != 32)) { throw Error("TGA files must be 24 or 32 bit.", input.getFilename()); } if (colorDepth == 32) { m_channels = 4; } else { m_channels = 3; } // Image descriptor contains overlay data as well // as data indicating where the origin is int imageDescriptor = input.readUInt8(); (void)imageDescriptor; // Image ID input.skip(IDLength); m_byte = (uint8*)m_memMan->alloc(m_width * m_height * m_channels); debugAssert(m_byte); // Pixel data int x; int y; if (m_channels == 3) { for (y = m_height - 1; y >= 0; --y) { for (x = 0; x < m_width; ++x) { int b = input.readUInt8(); int g = input.readUInt8(); int r = input.readUInt8(); int i = (x + y * m_width) * 3; m_byte[i + 0] = r; m_byte[i + 1] = g; m_byte[i + 2] = b; } } } else { for (y = m_height - 1; y >= 0; --y) { for (x = 0; x < m_width; ++x) { int b = input.readUInt8(); int g = input.readUInt8(); int r = input.readUInt8(); int a = input.readUInt8(); int i = (x + y * m_width) * 4; m_byte[i + 0] = r; m_byte[i + 1] = g; m_byte[i + 2] = b; m_byte[i + 3] = a; } } } }