X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Ftexture2d.cpp;h=cee932f7231e9fb23adcfb4ce86ba28e736dd17a;hb=635e5dc;hp=c1f6e0e9e7bd75f664cc682209b551746d3f4e48;hpb=927a1aa0a3a27e463ec0efc08bd08e7c4e969909;p=libs%2Fgl.git diff --git a/source/texture2d.cpp b/source/texture2d.cpp index c1f6e0e9..cee932f7 100644 --- a/source/texture2d.cpp +++ b/source/texture2d.cpp @@ -1,11 +1,11 @@ -/* $Id$ - -This file is part of libmspgl -Copyright © 2007 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - -#include "except.h" +#include +#include +#include +#include "bindable.h" +#include "buffer.h" +#include "error.h" +#include "pixelstore.h" +#include "resources.h" #include "texture2d.h" using namespace std; @@ -13,94 +13,287 @@ using namespace std; namespace Msp { namespace GL { -Texture2D::Texture2D(): +class Texture2D::AsyncLoader: public Resource::AsyncLoader +{ +private: + Texture2D &texture; + IO::Seekable &io; + Buffer pixel_buffer; + char *mapped_address; + Graphics::Image image; + unsigned n_bytes; + int phase; + +public: + AsyncLoader(Texture2D &, IO::Seekable &); + + virtual bool needs_sync() const; + virtual bool process(); +}; + + +Texture2D::Texture2D(ResourceManager *m): + Texture(GL_TEXTURE_2D, m), width(0), - height(0) + height(0), + allocated(0) +{ } + +Texture2D::~Texture2D() { - target=GL_TEXTURE_2D; - bind(); + set_manager(0); } -void Texture2D::storage(PixelFormat fmt, sizei wd, sizei ht, int brd) +void Texture2D::storage(PixelFormat fmt, unsigned wd, unsigned ht, unsigned lv) { if(width>0) - throw InvalidState("Texture storage may only be specified once"); + throw invalid_operation("Texture2D::storage"); if(wd==0 || ht==0) - throw InvalidParameterValue("Invalid texture dimensions"); + throw invalid_argument("Texture2D::storage"); - ifmt=fmt; - width=wd; - height=ht; - border=brd; + set_format(fmt); + width = wd; + height = ht; + levels = get_n_levels(); + if(lv>0) + levels = min(levels, lv); } -void Texture2D::image(int level, PixelFormat fmt, DataType type, const void *data) +void Texture2D::allocate(unsigned level) { - if(width==0) - throw InvalidState("Texture storage has not been specified"); + if(width==0 || height==0) + throw invalid_operation("Texture2D::allocate"); + if(level>=levels) + throw invalid_argument("Texture2D::allocate"); + if(allocated&(1< _bind(!ARB_direct_state_access, this); + if(ARB_direct_state_access) + glTextureStorage2D(id, levels, storage_fmt, width, height); + else + glTexStorage2D(target, levels, storage_fmt, width, height); + apply_swizzle(); + allocated |= (1< _bind(!ARB_direct_state_access, this); + allocate(level); - maybe_bind(); + PixelComponents comp = get_components(storage_fmt); + DataType type = get_component_type(storage_fmt); + if(ARB_direct_state_access) + glTextureSubImage2D(id, level, x, y, wd, ht, comp, type, data); + else + glTexSubImage2D(target, level, x, y, wd, ht, comp, type, data); - glTexSubImage2D(target, level, x, y, wd, ht, fmt, type, data); + if(auto_gen_mipmap && level==0) + generate_mipmap(); } -void Texture2D::load_image(const string &fn) +void Texture2D::sub_image(unsigned level, int x, int y, unsigned wd, unsigned ht, PixelComponents comp, DataType type, const void *data) { - Graphics::Image img; - img.load_file(fn); + if(comp!=get_components(format) || type!=get_component_type(format)) + throw incompatible_data("Texture2D::sub_image"); + sub_image(level, x, y, wd, ht, data); +} - image(img); +void Texture2D::image(const Graphics::Image &img, unsigned lv) +{ + image(img, lv, false); } -void Texture2D::image(const Graphics::Image &img) +void Texture2D::image(const Graphics::Image &img, unsigned lv, bool from_buffer) { - unsigned w=img.get_width(); - unsigned h=img.get_height(); - PixelFormat fmt=pixelformat_from_graphics(img.get_format()); + unsigned w = img.get_width(); + unsigned h = img.get_height(); + PixelFormat fmt = pixelformat_from_image(img); if(width==0) - storage(fmt, w, h, 0); - else if(w!=width || h!=height) - throw IncompatibleData("Image does not match texture storage"); + storage(make_pixelformat(get_components(fmt), get_component_type(fmt), use_srgb_format), w, h, lv); + else if(w!=width || h!=height || (lv && lv!=levels)) + throw incompatible_data("Texture2D::image"); + + PixelStore pstore = PixelStore::from_image(img); + BindRestore _bind_ps(pstore); + + image(0, from_buffer ? 0 : img.get_data()); +} + +unsigned Texture2D::get_n_levels() const +{ + unsigned n = 0; + for(unsigned s=max(width, height); s; s>>=1, ++n) ; + return n; +} + +void Texture2D::get_level_size(unsigned level, unsigned &w, unsigned &h) const +{ + w >>= level; + h >>= level; + + if(!w && h) + w = 1; + else if(!h && w) + h = 1; +} - image(0, fmt, UNSIGNED_BYTE, img.get_data()); +Resource::AsyncLoader *Texture2D::load(IO::Seekable &io, const Resources *) +{ + AsyncLoader *ldr = new AsyncLoader(*this, io); + return ldr; +} + +UInt64 Texture2D::get_data_size() const +{ + return id ? width*height*get_pixel_size(format) : 0; +} + +void Texture2D::unload() +{ + glDeleteTextures(1, &id); + id = 0; + allocated = 0; + default_sampler.unload(); } Texture2D::Loader::Loader(Texture2D &t): - Texture::Loader(t) + DataFile::DerivedObjectLoader(t) +{ + init(); +} + +Texture2D::Loader::Loader(Texture2D &t, Collection &c): + DataFile::DerivedObjectLoader(t, c) +{ + init(); +} + +void Texture2D::Loader::init() { - add("image_data", &Loader::image_data); add("raw_data", &Loader::raw_data); add("storage", &Loader::storage); + add("storage", &Loader::storage_levels); } -void Texture2D::Loader::image_data(const string &data) +void Texture2D::Loader::raw_data(const string &data) { - Graphics::Image img; - img.load_memory(data.data(), data.size()); + obj.image(0, data.data()); +} - static_cast(obj).image(img); +void Texture2D::Loader::storage(PixelFormat fmt, unsigned w, unsigned h) +{ + obj.storage(fmt, w, h); } -void Texture2D::Loader::raw_data(const string &data) +void Texture2D::Loader::storage_levels(PixelFormat fmt, unsigned w, unsigned h, unsigned l) { - Texture2D &t2d=static_cast(obj); - t2d.image(0, t2d.ifmt, UNSIGNED_BYTE, data.data()); + obj.storage(fmt, w, h, l); } -void Texture2D::Loader::storage(PixelFormat fmt, unsigned w, unsigned h, unsigned b) + +Texture2D::AsyncLoader::AsyncLoader(Texture2D &t, IO::Seekable &i): + texture(t), + io(i), + pixel_buffer(PIXEL_UNPACK_BUFFER), + mapped_address(0), + phase(0) +{ } + +bool Texture2D::AsyncLoader::needs_sync() const { - static_cast(obj).storage(fmt, w, h, b); + return phase%2; +} + +bool Texture2D::AsyncLoader::process() +{ + if(phase==0) + { + /* TODO Enhance the ImageLoader system so that the image can be loaded + directly to the buffer */ + image.load_io(io); + n_bytes = image.get_stride()*image.get_height(); + } + else if(phase==1) + { + pixel_buffer.storage(n_bytes); + mapped_address = reinterpret_cast(pixel_buffer.map()); + } + else if(phase==2) + { + const char *data = reinterpret_cast(image.get_data()); + copy(data, data+n_bytes, mapped_address); + } + else if(phase==3) + { + Bind _bind_buf(pixel_buffer, PIXEL_UNPACK_BUFFER); + if(!pixel_buffer.unmap()) + { + phase = 1; + return false; + } + + if(!texture.id) + { + if(ARB_direct_state_access) + glCreateTextures(texture.target, 1, &texture.id); + else + glGenTextures(1, &texture.id); + } + texture.image(image, 0, true); + } + + ++phase; + return phase>3; } } // namespace GL