// NewImage will create a new texture for this image and return the *Image. If the // file does not exist or cannot be decoded it will return an error. func NewImage(path string) (*Image, error) { //we do this first time to check the image before volitile load imgFile, new_err := file.NewFile(path) defer imgFile.Close() if new_err != nil { return nil, new_err } decoded_img, _, img_err := image.Decode(imgFile) if img_err != nil { return nil, img_err } bounds := decoded_img.Bounds() new_image := &Image{ filePath: path, mipmaps: false, Texture: &Texture{ Width: int32(bounds.Dx()), Height: int32(bounds.Dy()), }, } registerVolatile(new_image) return new_image, nil }
// Decode will get the file at the path provided. It will then send it to the decoder // that will handle its file type by the extention on the path. Supported formats // are wav, ogg, and flac. If there is an error retrieving the file or decoding it, // will return that error. func Decode(filepath string) (Decoder, error) { src, err := file.NewFile(filepath) if err != nil { return nil, err } base := decoderBase{ src: src, src_path: filepath, } var decoder Decoder switch file.Ext(filepath) { case ".wav": decoder = &waveDecoder{decoderBase: base} case ".ogg": decoder = &vorbisDecoder{decoderBase: base} case ".flac": decoder = &flacDecoder{decoderBase: base} default: src.Close() return nil, errors.New("unsupported audio file extention") } if err = decoder.read(); err != nil { src.Close() return nil, err } return decoder, nil }
func (rast *imageFontRasterizer) loadVolatile() bool { glyph_rune_hints := []rune(rast.glyph_hints) imgFile, err := file.NewFile(rast.filepath) if err != nil { return false } defer imgFile.Close() img, _, err := image.Decode(imgFile) if err != nil { return false } rast.glyphs = make(map[rune]glyphData) glyphsPerRow := int32(16) glyphsPerCol := (int32(len(glyph_rune_hints)) / glyphsPerRow) + 1 rast.advance = img.Bounds().Dx() / len(glyph_rune_hints) rast.height = img.Bounds().Dy() rast.ascent = rast.height rast.descent = 0 image_width := pow2(uint32(int32(rast.advance) * glyphsPerRow)) image_height := pow2(uint32(int32(rast.height) * glyphsPerCol)) rgba := image.NewRGBA(image.Rect(0, 0, int(image_width), int(image_height))) var gx, gy int for i := 0; i < len(glyph_rune_hints); i++ { dst_rec := image.Rect(gx, gy, gx+rast.advance, gy+rast.height) draw.Draw(rgba, dst_rec, img, image.Pt(i*rast.advance, 0), draw.Src) rast.glyphs[glyph_rune_hints[i]] = glyphData{ rec: NewQuad(int32(gx), int32(gy), int32(rast.advance), int32(rast.height), int32(image_width), int32(image_height)), leftSideBearing: 0, advanceWidth: rast.advance, topSideBearing: 0, advanceHeight: rast.height + 5, ascent: rast.height, descent: 0, } if i%16 == 0 { gx = 0 gy += rast.height } else { gx += rast.advance } } rast.Texture, err = newImageTexture(rgba, false) return err == nil }
// loadConfig will find the config file (works with bundle) and load it into the // struct and the return it. If the config does not exist it will return a default // config. If there was an issue reading the file it will return the error, possibly // permission errors. func loadConfig() (*windowConfig, error) { var config windowConfig path := path.Join(".", config_file_name) if _, err := file.NewFileData(path); os.IsNotExist(err) { return &config, nil //no added config bail out early } config_file, file_err := file.NewFile(config_file_name) if file_err != nil { return nil, file_err } if _, err := toml.DecodeReader(config_file, &config); err != nil { return nil, err } return &config, nil }
// loadVolatile will create the volatile objects func (img *Image) loadVolatile() bool { imgFile, new_err := file.NewFile(img.filePath) defer imgFile.Close() if new_err != nil { return false } decoded_img, _, img_err := image.Decode(imgFile) if img_err != nil { return false } img.Texture, img_err = newImageTexture(decoded_img, img.mipmaps) if img_err != nil { return false } return true }