X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fcore%2Ftexture2d.cpp;h=e38c99deb85e2dda60603b89e97405a013c763cd;hb=e1be82a4dfce8d90358c506f65be09da4dc9d5ec;hp=0e76128c7bc5666da5828f11fe98f5398ecaf380;hpb=7aaec9a70b8d7733429bec043f8e33e02956f266;p=libs%2Fgl.git diff --git a/source/core/texture2d.cpp b/source/core/texture2d.cpp index 0e76128c..e38c99de 100644 --- a/source/core/texture2d.cpp +++ b/source/core/texture2d.cpp @@ -1,12 +1,6 @@ -#include -#include -#include +#include #include -#include "bindable.h" -#include "buffer.h" #include "error.h" -#include "pixelstore.h" -#include "resources.h" #include "texture2d.h" using namespace std; @@ -19,12 +13,12 @@ class Texture2D::AsyncLoader: public Resource::AsyncLoader private: Texture2D &texture; IO::Seekable &io; - Buffer pixel_buffer; - char *mapped_address; + Texture2D::AsyncTransfer transfer; Graphics::Image image; - Graphics::ImageLoader *img_loader; - unsigned n_bytes; - int phase; + Graphics::ImageLoader *img_loader = 0; + DataFile::RawData *raw_data = 0; + unsigned n_bytes = 0; + int phase = 0; public: AsyncLoader(Texture2D &, IO::Seekable &); @@ -35,13 +29,6 @@ public: }; -Texture2D::Texture2D(ResourceManager *m): - Texture(GL_TEXTURE_2D, m), - width(0), - height(0), - allocated(0) -{ } - Texture2D::~Texture2D() { set_manager(0); @@ -50,162 +37,67 @@ Texture2D::~Texture2D() void Texture2D::storage(PixelFormat fmt, unsigned wd, unsigned ht, unsigned lv) { if(width>0) - throw invalid_operation("Texture2D::storage"); + { + if(fmt!=format || wd!=width || ht!=height || (lv && lv!=n_levels)) + throw incompatible_data("Texture2D::storage"); + return; + } if(wd==0 || ht==0) throw invalid_argument("Texture2D::storage"); set_format(fmt); width = wd; height = ht; - levels = get_n_levels(); + n_levels = count_levels(max(width, height)); if(lv>0) - levels = min(levels, lv); -} + n_levels = min(n_levels, lv); -void Texture2D::allocate(unsigned level) -{ - 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< size = get_level_size(level); + return sub_image(level, 0, 0, size.x, size.y, data); } -void Texture2D::sub_image(unsigned level, int x, int y, unsigned wd, unsigned ht, const void *data) +void Texture2D::sub_image(unsigned level, unsigned x, unsigned y, unsigned wd, unsigned ht, const void *data) { if(width==0 || height==0) throw invalid_operation("Texture2D::sub_image"); + if(level>=n_levels || x>width || x+wd>width || y>height || y+ht>height) + throw out_of_range("Texture2D::sub_image"); - Conditional _bind(!ARB_direct_state_access, this); - allocate(level); - - 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); - - if(auto_gen_mipmap && level==0) - generate_mipmap(); + Texture2DBackend::sub_image(level, x, y, wd, ht, data); } -void Texture2D::sub_image(unsigned level, int x, int y, unsigned wd, unsigned ht, PixelComponents comp, DataType type, const void *data) +Texture2D::AsyncTransfer Texture2D::sub_image_async(unsigned level, unsigned x, unsigned y, unsigned wd, unsigned ht) { - if(comp!=get_components(format) || type!=get_component_type(format)) - throw incompatible_data("Texture2D::sub_image"); - sub_image(level, x, y, wd, ht, data); + return AsyncTransfer(*this, level, x, y, wd, ht); } void Texture2D::image(const Graphics::Image &img, unsigned lv) { - image(img, lv, false); + storage(pixelformat_from_image(img, use_srgb_format), img.get_width(), img.get_height(), lv); + image(0, img.get_pixels()); } -void Texture2D::image(const Graphics::Image &img, unsigned lv, bool from_buffer) +LinAl::Vector Texture2D::get_level_size(unsigned level) const { - unsigned w = img.get_width(); - unsigned h = img.get_height(); - PixelFormat fmt = pixelformat_from_image(img); - if(width==0) - 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_pixels()); -} - -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; + unsigned w = width>>level; + unsigned h = height>>level; if(!w && h) w = 1; else if(!h && w) h = 1; -} -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; + return LinAl::Vector(w, h); } -void Texture2D::unload() +Resource::AsyncLoader *Texture2D::load(IO::Seekable &io, const Resources *) { - glDeleteTextures(1, &id); - id = 0; - allocated = 0; - default_sampler.unload(); + return new AsyncLoader(static_cast(*this), io); } @@ -223,16 +115,10 @@ Texture2D::Loader::Loader(Texture2D &t, Collection &c): void Texture2D::Loader::init() { - add("raw_data", &Loader::raw_data); add("storage", &Loader::storage); add("storage", &Loader::storage_levels); } -void Texture2D::Loader::raw_data(const string &data) -{ - obj.image(0, data.data()); -} - void Texture2D::Loader::storage(PixelFormat fmt, unsigned w, unsigned h) { obj.storage(fmt, w, h); @@ -244,20 +130,82 @@ void Texture2D::Loader::storage_levels(PixelFormat fmt, unsigned w, unsigned h, } +Texture2D::AsyncTransfer::AsyncTransfer(Texture2D &t, unsigned l, unsigned x_, unsigned y_, unsigned wd, unsigned ht): + texture(&t), + level(l), + x(x_), + y(y_), + width(wd), + height(ht), + data_size(width*height*get_pixel_size(texture->storage_fmt)), + dest_addr(0) +{ + dest_addr = allocate(); +} + +Texture2D::AsyncTransfer::AsyncTransfer(AsyncTransfer &&other): + Texture2DBackend::AsyncTransfer(move(other)), + texture(other.texture), + level(other.level), + x(other.x), + y(other.y), + width(other.width), + height(other.height), + data_size(other.data_size), + dest_addr(other.dest_addr) +{ + other.dest_addr = 0; +} + +Texture2D::AsyncTransfer &Texture2D::AsyncTransfer::operator=(AsyncTransfer &&other) +{ + if(dest_addr) + finalize(); + + Texture2DBackend::AsyncTransfer::operator=(move(other)); + + texture = other.texture; + level = other.level; + x = other.x; + y = other.y; + width = other.width; + height = other.height; + data_size = other.data_size; + dest_addr = other.dest_addr; + + other.dest_addr = 0; + + return *this; +} + +Texture2D::AsyncTransfer::~AsyncTransfer() +{ + if(dest_addr) + finalize(); +} + + Texture2D::AsyncLoader::AsyncLoader(Texture2D &t, IO::Seekable &i): texture(t), - io(i), - pixel_buffer(PIXEL_UNPACK_BUFFER), - mapped_address(0), - img_loader(Graphics::ImageLoader::open_io(io)), - phase(0) -{ } + io(i) +{ + char magic[4] = { }; + io.read(magic, 4); + io.seek(0, IO::S_BEG); + + if(DataFile::RawData::detect_signature(string(magic, 4))) + { + raw_data = new DataFile::RawData; + raw_data->open_io(io, "async"); + } + else + img_loader = Graphics::ImageLoader::open_io(io); +} Texture2D::AsyncLoader::~AsyncLoader() { - if(mapped_address) - pixel_buffer.unmap(); delete img_loader; + delete raw_data; } bool Texture2D::AsyncLoader::needs_sync() const @@ -269,34 +217,53 @@ bool Texture2D::AsyncLoader::process() { if(phase==0) { - image.load_headers(*img_loader); - n_bytes = image.get_stride()*image.get_height(); + if(raw_data) + n_bytes = raw_data->get_size(); + else + { + image.load_headers(*img_loader); + 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) - image.load_into(*img_loader, mapped_address); - else if(phase==3) - { - Bind _bind_buf(pixel_buffer, PIXEL_UNPACK_BUFFER); - mapped_address = 0; - if(!pixel_buffer.unmap()) + if(img_loader) { - phase = 1; - return false; + unsigned w = image.get_width(); + unsigned h = image.get_height(); + texture.storage(pixelformat_from_image(image, texture.use_srgb_format), w, h); } - if(!texture.id) + transfer = texture.sub_image_async(0, 0, 0, texture.width, texture.height); + } + else if(phase==2) + { + if(texture.swizzle==RGBA_TO_RGB) { - if(ARB_direct_state_access) - glCreateTextures(texture.target, 1, &texture.id); + const void *data; + if(raw_data) + { + raw_data->load(); + data = raw_data->get_data(); + } else - glGenTextures(1, &texture.id); + { + image.load(*img_loader); + data = image.get_pixels(); + } + texture.stage_pixels(transfer.get_address(), data, texture.width*texture.height); } - texture.image(image, 0, true); + else if(raw_data) + raw_data->load_into(transfer.get_address()); + else + image.load_into(*img_loader, transfer.get_address()); + } + else if(phase==3) + { + transfer = Texture2D::AsyncTransfer(); + + if(texture.auto_gen_mipmap) + texture.generate_mipmap(); } ++phase;