RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
open_toontown_panda3d/panda/src/gobj/texture.cxx

10590 lines
318 KiB
C++
Raw Blame History

/**
* PANDA 3D SOFTWARE
* Copyright (c) Carnegie Mellon University. All rights reserved.
*
* All use of this software is subject to the terms of the revised BSD
* license. You should have received a copy of this license along
* with this source code in a file named "LICENSE."
*
* @file texture.cxx
* @author mike
* @date 1997-01-09
* @author fperazzi, PandaSE
* @date 2010-04-29
*/
#include "pandabase.h"
#include "texture.h"
#include "config_gobj.h"
#include "config_putil.h"
#include "texturePool.h"
#include "textureContext.h"
#include "bamCache.h"
#include "bamCacheRecord.h"
#include "datagram.h"
#include "datagramIterator.h"
#include "bamReader.h"
#include "bamWriter.h"
#include "string_utils.h"
#include "preparedGraphicsObjects.h"
#include "pnmImage.h"
#include "pnmReader.h"
#include "pfmFile.h"
#include "virtualFileSystem.h"
#include "datagramInputFile.h"
#include "datagramOutputFile.h"
#include "bam.h"
#include "zStream.h"
#include "indent.h"
#include "cmath.h"
#include "pStatTimer.h"
#include "pbitops.h"
#include "streamReader.h"
#include "texturePeeker.h"
#include "convert_srgb.h"
#ifdef HAVE_SQUISH
#include <squish.h>
#endif // HAVE_SQUISH
#include <stddef.h>
using std::endl;
using std::istream;
using std::max;
using std::min;
using std::ostream;
using std::string;
using std::swap;
ConfigVariableEnum<Texture::QualityLevel> texture_quality_level
("texture-quality-level", Texture::QL_normal,
PRC_DESC("This specifies a global quality level for all textures. You "
"may specify either fastest, normal, or best. This actually "
"affects the meaning of Texture::set_quality_level(QL_default), "
"so it may be overridden on a per-texture basis. This generally "
"only has an effect when using the tinydisplay software renderer; "
"it has little or no effect on normal, hardware-accelerated "
"renderers. See Texture::set_quality_level()."));
PStatCollector Texture::_texture_read_pcollector("*:Texture:Read");
TypeHandle Texture::_type_handle;
TypeHandle Texture::CData::_type_handle;
AutoTextureScale Texture::_textures_power_2 = ATS_unspecified;
// Stuff to read and write DDS files.
// little-endian, of course
#define DDS_MAGIC 0x20534444
// DDS_header.dwFlags
#define DDSD_CAPS 0x00000001
#define DDSD_HEIGHT 0x00000002
#define DDSD_WIDTH 0x00000004
#define DDSD_PITCH 0x00000008
#define DDSD_PIXELFORMAT 0x00001000
#define DDSD_MIPMAPCOUNT 0x00020000
#define DDSD_LINEARSIZE 0x00080000
#define DDSD_DEPTH 0x00800000
// DDS_header.sPixelFormat.dwFlags
#define DDPF_ALPHAPIXELS 0x00000001
#define DDPF_FOURCC 0x00000004
#define DDPF_INDEXED 0x00000020
#define DDPF_RGB 0x00000040
// DDS_header.sCaps.dwCaps1
#define DDSCAPS_COMPLEX 0x00000008
#define DDSCAPS_TEXTURE 0x00001000
#define DDSCAPS_MIPMAP 0x00400000
// DDS_header.sCaps.dwCaps2
#define DDSCAPS2_CUBEMAP 0x00000200
#define DDSCAPS2_CUBEMAP_POSITIVEX 0x00000400
#define DDSCAPS2_CUBEMAP_NEGATIVEX 0x00000800
#define DDSCAPS2_CUBEMAP_POSITIVEY 0x00001000
#define DDSCAPS2_CUBEMAP_NEGATIVEY 0x00002000
#define DDSCAPS2_CUBEMAP_POSITIVEZ 0x00004000
#define DDSCAPS2_CUBEMAP_NEGATIVEZ 0x00008000
#define DDSCAPS2_VOLUME 0x00200000
struct DDSPixelFormat {
unsigned int pf_size;
unsigned int pf_flags;
unsigned int four_cc;
unsigned int rgb_bitcount;
unsigned int r_mask;
unsigned int g_mask;
unsigned int b_mask;
unsigned int a_mask;
};
struct DDSCaps2 {
unsigned int caps1;
unsigned int caps2;
unsigned int ddsx;
};
struct DDSHeader {
unsigned int dds_magic;
unsigned int dds_size;
unsigned int dds_flags;
unsigned int height;
unsigned int width;
unsigned int pitch;
unsigned int depth;
unsigned int num_levels;
DDSPixelFormat pf;
DDSCaps2 caps;
};
// Stuff to read KTX files.
enum KTXType {
KTX_BYTE = 0x1400,
KTX_UNSIGNED_BYTE = 0x1401,
KTX_SHORT = 0x1402,
KTX_UNSIGNED_SHORT = 0x1403,
KTX_INT = 0x1404,
KTX_UNSIGNED_INT = 0x1405,
KTX_FLOAT = 0x1406,
KTX_HALF_FLOAT = 0x140B,
KTX_UNSIGNED_BYTE_3_3_2 = 0x8032,
KTX_UNSIGNED_SHORT_4_4_4_4 = 0x8033,
KTX_UNSIGNED_SHORT_5_5_5_1 = 0x8034,
KTX_UNSIGNED_INT_8_8_8_8 = 0x8035,
KTX_UNSIGNED_INT_10_10_10_2 = 0x8036,
KTX_UNSIGNED_BYTE_2_3_3_REV = 0x8362,
KTX_UNSIGNED_SHORT_5_6_5 = 0x8363,
KTX_UNSIGNED_SHORT_5_6_5_REV = 0x8364,
KTX_UNSIGNED_SHORT_4_4_4_4_REV = 0x8365,
KTX_UNSIGNED_SHORT_1_5_5_5_REV = 0x8366,
KTX_UNSIGNED_INT_8_8_8_8_REV = 0x8367,
KTX_UNSIGNED_INT_2_10_10_10_REV = 0x8368,
KTX_UNSIGNED_INT_24_8 = 0x84FA,
KTX_UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B,
KTX_UNSIGNED_INT_5_9_9_9_REV = 0x8C3E,
KTX_FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD,
};
enum KTXFormat {
KTX_ALPHA = 0x1906,
KTX_ALPHA12 = 0x803D,
KTX_ALPHA16 = 0x803E,
KTX_ALPHA16_SNORM = 0x9018,
KTX_ALPHA4 = 0x803B,
KTX_ALPHA8 = 0x803C,
KTX_ALPHA8_SNORM = 0x9014,
KTX_ALPHA_SNORM = 0x9010,
KTX_BGR = 0x80E0,
KTX_BGR_INTEGER = 0x8D9A,
KTX_BGRA = 0x80E1,
KTX_BGRA_INTEGER = 0x8D9B,
KTX_BLUE = 0x1905,
KTX_BLUE_INTEGER = 0x8D96,
KTX_COLOR_INDEX = 0x1900,
KTX_DEPTH24_STENCIL8 = 0x88F0,
KTX_DEPTH32F_STENCIL8 = 0x8CAD,
KTX_DEPTH_COMPONENT = 0x1902,
KTX_DEPTH_COMPONENT16 = 0x81A5,
KTX_DEPTH_COMPONENT24 = 0x81A6,
KTX_DEPTH_COMPONENT32 = 0x81A7,
KTX_DEPTH_COMPONENT32F = 0x8CAC,
KTX_DEPTH_STENCIL = 0x84F9,
KTX_GREEN = 0x1904,
KTX_GREEN_INTEGER = 0x8D95,
KTX_INTENSITY = 0x8049,
KTX_INTENSITY12 = 0x804C,
KTX_INTENSITY16 = 0x804D,
KTX_INTENSITY16_SNORM = 0x901B,
KTX_INTENSITY4 = 0x804A,
KTX_INTENSITY8 = 0x804B,
KTX_INTENSITY8_SNORM = 0x9017,
KTX_INTENSITY_SNORM = 0x9013,
KTX_LUMINANCE = 0x1909,
KTX_LUMINANCE12 = 0x8041,
KTX_LUMINANCE12_ALPHA12 = 0x8047,
KTX_LUMINANCE12_ALPHA4 = 0x8046,
KTX_LUMINANCE16 = 0x8042,
KTX_LUMINANCE16_ALPHA16 = 0x8048,
KTX_LUMINANCE16_ALPHA16_SNORM = 0x901A,
KTX_LUMINANCE16_SNORM = 0x9019,
KTX_LUMINANCE4 = 0x803F,
KTX_LUMINANCE4_ALPHA4 = 0x8043,
KTX_LUMINANCE6_ALPHA2 = 0x8044,
KTX_LUMINANCE8 = 0x8040,
KTX_LUMINANCE8_ALPHA8 = 0x8045,
KTX_LUMINANCE8_ALPHA8_SNORM = 0x9016,
KTX_LUMINANCE8_SNORM = 0x9015,
KTX_LUMINANCE_ALPHA = 0x190A,
KTX_LUMINANCE_ALPHA_SNORM = 0x9012,
KTX_LUMINANCE_SNORM = 0x9011,
KTX_R11F_G11F_B10F = 0x8C3A,
KTX_R16 = 0x822A,
KTX_R16_SNORM = 0x8F98,
KTX_R16F = 0x822D,
KTX_R16I = 0x8233,
KTX_R16UI = 0x8234,
KTX_R32F = 0x822E,
KTX_R32I = 0x8235,
KTX_R32UI = 0x8236,
KTX_R3_G3_B2 = 0x2A10,
KTX_R8 = 0x8229,
KTX_R8_SNORM = 0x8F94,
KTX_R8I = 0x8231,
KTX_R8UI = 0x8232,
KTX_RED = 0x1903,
KTX_RED_INTEGER = 0x8D94,
KTX_RED_SNORM = 0x8F90,
KTX_RG = 0x8227,
KTX_RG16 = 0x822C,
KTX_RG16_SNORM = 0x8F99,
KTX_RG16F = 0x822F,
KTX_RG16I = 0x8239,
KTX_RG16UI = 0x823A,
KTX_RG32F = 0x8230,
KTX_RG32I = 0x823B,
KTX_RG32UI = 0x823C,
KTX_RG8 = 0x822B,
KTX_RG8_SNORM = 0x8F95,
KTX_RG8I = 0x8237,
KTX_RG8UI = 0x8238,
KTX_RG_INTEGER = 0x8228,
KTX_RG_SNORM = 0x8F91,
KTX_RGB = 0x1907,
KTX_RGB10 = 0x8052,
KTX_RGB10_A2 = 0x8059,
KTX_RGB12 = 0x8053,
KTX_RGB16 = 0x8054,
KTX_RGB16_SNORM = 0x8F9A,
KTX_RGB16F = 0x881B,
KTX_RGB16I = 0x8D89,
KTX_RGB16UI = 0x8D77,
KTX_RGB2 = 0x804E,
KTX_RGB32F = 0x8815,
KTX_RGB32I = 0x8D83,
KTX_RGB32UI = 0x8D71,
KTX_RGB4 = 0x804F,
KTX_RGB5 = 0x8050,
KTX_RGB5_A1 = 0x8057,
KTX_RGB8 = 0x8051,
KTX_RGB8_SNORM = 0x8F96,
KTX_RGB8I = 0x8D8F,
KTX_RGB8UI = 0x8D7D,
KTX_RGB9_E5 = 0x8C3D,
KTX_RGB_INTEGER = 0x8D98,
KTX_RGB_SNORM = 0x8F92,
KTX_RGBA = 0x1908,
KTX_RGBA12 = 0x805A,
KTX_RGBA16 = 0x805B,
KTX_RGBA16_SNORM = 0x8F9B,
KTX_RGBA16F = 0x881A,
KTX_RGBA16I = 0x8D88,
KTX_RGBA16UI = 0x8D76,
KTX_RGBA2 = 0x8055,
KTX_RGBA32F = 0x8814,
KTX_RGBA32I = 0x8D82,
KTX_RGBA32UI = 0x8D70,
KTX_RGBA4 = 0x8056,
KTX_RGBA8 = 0x8058,
KTX_RGBA8_SNORM = 0x8F97,
KTX_RGBA8I = 0x8D8E,
KTX_RGBA8UI = 0x8D7C,
KTX_RGBA_INTEGER = 0x8D99,
KTX_RGBA_SNORM = 0x8F93,
KTX_SLUMINANCE = 0x8C46,
KTX_SLUMINANCE8 = 0x8C47,
KTX_SLUMINANCE8_ALPHA8 = 0x8C45,
KTX_SLUMINANCE_ALPHA = 0x8C44,
KTX_SRGB = 0x8C40,
KTX_SRGB8 = 0x8C41,
KTX_SRGB8_ALPHA8 = 0x8C43,
KTX_SRGB_ALPHA = 0x8C42,
KTX_STENCIL_INDEX = 0x1901,
KTX_STENCIL_INDEX1 = 0x8D46,
KTX_STENCIL_INDEX16 = 0x8D49,
KTX_STENCIL_INDEX4 = 0x8D47,
KTX_STENCIL_INDEX8 = 0x8D48,
};
enum KTXCompressedFormat {
KTX_COMPRESSED_LUMINANCE_ALPHA_LATC2 = 0x8C72,
KTX_COMPRESSED_LUMINANCE_LATC1 = 0x8C70,
KTX_COMPRESSED_R11_EAC = 0x9270,
KTX_COMPRESSED_RED = 0x8225,
KTX_COMPRESSED_RED_RGTC1 = 0x8DBB,
KTX_COMPRESSED_RG = 0x8226,
KTX_COMPRESSED_RG11_EAC = 0x9272,
KTX_COMPRESSED_RG_RGTC2 = 0x8DBD,
KTX_COMPRESSED_RGB = 0x84ED,
KTX_COMPRESSED_RGB8_ETC2 = 0x9274,
KTX_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276,
KTX_COMPRESSED_RGB_BPTC_SIGNED_FLOAT = 0x8E8E,
KTX_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F,
KTX_COMPRESSED_RGB_FXT1_3DFX = 0x86B0,
KTX_COMPRESSED_RGB_PVRTC_2BPPV1_IMG = 0x8C01,
KTX_COMPRESSED_RGB_PVRTC_4BPPV1_IMG = 0x8C00,
KTX_COMPRESSED_RGB_S3TC_DXT1 = 0x83F0,
KTX_COMPRESSED_RGBA = 0x84EE,
KTX_COMPRESSED_RGBA8_ETC2_EAC = 0x9278,
KTX_COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C,
KTX_COMPRESSED_RGBA_FXT1_3DFX = 0x86B1,
KTX_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG = 0x8C03,
KTX_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG = 0x9137,
KTX_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = 0x8C02,
KTX_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG = 0x9138,
KTX_COMPRESSED_RGBA_S3TC_DXT1 = 0x83F1,
KTX_COMPRESSED_RGBA_S3TC_DXT3 = 0x83F2,
KTX_COMPRESSED_RGBA_S3TC_DXT5 = 0x83F3,
KTX_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2 = 0x8C73,
KTX_COMPRESSED_SIGNED_LUMINANCE_LATC1 = 0x8C71,
KTX_COMPRESSED_SIGNED_R11_EAC = 0x9271,
KTX_COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC,
KTX_COMPRESSED_SIGNED_RG11_EAC = 0x9273,
KTX_COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE,
KTX_COMPRESSED_SLUMINANCE = 0x8C4A,
KTX_COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B,
KTX_COMPRESSED_SRGB = 0x8C48,
KTX_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279,
KTX_COMPRESSED_SRGB8_ETC2 = 0x9275,
KTX_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277,
KTX_COMPRESSED_SRGB_ALPHA = 0x8C49,
KTX_COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D,
KTX_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1 = 0x8A56,
KTX_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2 = 0x93F0,
KTX_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1 = 0x8A57,
KTX_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2 = 0x93F1,
KTX_COMPRESSED_SRGB_ALPHA_S3TC_DXT1 = 0x8C4D,
KTX_COMPRESSED_SRGB_ALPHA_S3TC_DXT3 = 0x8C4E,
KTX_COMPRESSED_SRGB_ALPHA_S3TC_DXT5 = 0x8C4F,
KTX_COMPRESSED_SRGB_PVRTC_2BPPV1 = 0x8A54,
KTX_COMPRESSED_SRGB_PVRTC_4BPPV1 = 0x8A55,
KTX_COMPRESSED_SRGB_S3TC_DXT1 = 0x8C4C,
KTX_ETC1_RGB8 = 0x8D64,
KTX_ETC1_SRGB8 = 0x88EE,
};
/**
* Constructs an empty texture. The default is to set up the texture as an
* empty 2-d texture; follow up with one of the variants of setup_texture() if
* this is not what you want.
*/
Texture::
Texture(const string &name) :
Namable(name),
_lock(name),
_cvar(_lock)
{
_reloading = false;
CDWriter cdata(_cycler, true);
do_set_format(cdata, F_rgb);
do_set_component_type(cdata, T_unsigned_byte);
}
/**
* Use Texture::make_copy() to make a duplicate copy of an existing Texture.
*/
Texture::
Texture(const Texture &copy) :
Namable(copy),
_cycler(copy._cycler),
_lock(copy.get_name()),
_cvar(_lock)
{
_reloading = false;
}
/**
* Use Texture::make_copy() to make a duplicate copy of an existing Texture.
*/
void Texture::
operator = (const Texture &copy) {
Namable::operator = (copy);
_cycler = copy._cycler;
}
/**
*
*/
Texture::
~Texture() {
release_all();
nassertv(!_reloading);
}
/**
* Generates a special cube map image in the texture that can be used to apply
* bump mapping effects: for each texel in the cube map that is indexed by the
* 3-d texture coordinates (x, y, z), the resulting value is the normalized
* vector (x, y, z) (compressed from -1..1 into 0..1).
*/
void Texture::
generate_normalization_cube_map(int size) {
CDWriter cdata(_cycler, true);
do_setup_texture(cdata, TT_cube_map, size, size, 6, T_unsigned_byte, F_rgb);
PTA_uchar image = do_make_ram_image(cdata);
cdata->_keep_ram_image = true;
cdata->inc_image_modified();
cdata->inc_properties_modified();
PN_stdfloat half_size = (PN_stdfloat)size * 0.5f;
PN_stdfloat center = half_size - 0.5f;
LMatrix4 scale
(127.5f, 0.0f, 0.0f, 0.0f,
0.0f, 127.5f, 0.0f, 0.0f,
0.0f, 0.0f, 127.5f, 0.0f,
127.5f, 127.5f, 127.5f, 1.0f);
unsigned char *p = image;
int xi, yi;
// Page 0: positive X.
for (yi = 0; yi < size; ++yi) {
for (xi = 0; xi < size; ++xi) {
LVector3 vec(half_size, center - yi, center - xi);
vec.normalize();
vec = scale.xform_point(vec);
*p++ = (unsigned char)vec[2];
*p++ = (unsigned char)vec[1];
*p++ = (unsigned char)vec[0];
}
}
// Page 1: negative X.
for (yi = 0; yi < size; ++yi) {
for (xi = 0; xi < size; ++xi) {
LVector3 vec(-half_size, center - yi, xi - center);
vec.normalize();
vec = scale.xform_point(vec);
*p++ = (unsigned char)vec[2];
*p++ = (unsigned char)vec[1];
*p++ = (unsigned char)vec[0];
}
}
// Page 2: positive Y.
for (yi = 0; yi < size; ++yi) {
for (xi = 0; xi < size; ++xi) {
LVector3 vec(xi - center, half_size, yi - center);
vec.normalize();
vec = scale.xform_point(vec);
*p++ = (unsigned char)vec[2];
*p++ = (unsigned char)vec[1];
*p++ = (unsigned char)vec[0];
}
}
// Page 3: negative Y.
for (yi = 0; yi < size; ++yi) {
for (xi = 0; xi < size; ++xi) {
LVector3 vec(xi - center, -half_size, center - yi);
vec.normalize();
vec = scale.xform_point(vec);
*p++ = (unsigned char)vec[2];
*p++ = (unsigned char)vec[1];
*p++ = (unsigned char)vec[0];
}
}
// Page 4: positive Z.
for (yi = 0; yi < size; ++yi) {
for (xi = 0; xi < size; ++xi) {
LVector3 vec(xi - center, center - yi, half_size);
vec.normalize();
vec = scale.xform_point(vec);
*p++ = (unsigned char)vec[2];
*p++ = (unsigned char)vec[1];
*p++ = (unsigned char)vec[0];
}
}
// Page 5: negative Z.
for (yi = 0; yi < size; ++yi) {
for (xi = 0; xi < size; ++xi) {
LVector3 vec(center - xi, center - yi, -half_size);
vec.normalize();
vec = scale.xform_point(vec);
*p++ = (unsigned char)vec[2];
*p++ = (unsigned char)vec[1];
*p++ = (unsigned char)vec[0];
}
}
}
/**
* Generates a special 256x1 1-d texture that can be used to apply an
* arbitrary alpha scale to objects by judicious use of texture matrix. The
* texture is a gradient, with an alpha of 0 on the left (U = 0), and 255 on
* the right (U = 1).
*/
void Texture::
generate_alpha_scale_map() {
CDWriter cdata(_cycler, true);
do_setup_texture(cdata, TT_1d_texture, 256, 1, 1, T_unsigned_byte, F_alpha);
cdata->_default_sampler.set_wrap_u(SamplerState::WM_clamp);
cdata->_default_sampler.set_minfilter(SamplerState::FT_nearest);
cdata->_default_sampler.set_magfilter(SamplerState::FT_nearest);
cdata->_compression = CM_off;
cdata->inc_image_modified();
cdata->inc_properties_modified();
PTA_uchar image = do_make_ram_image(cdata);
cdata->_keep_ram_image = true;
unsigned char *p = image;
for (int xi = 0; xi < 256; ++xi) {
*p++ = xi;
}
}
/**
* Reads the named filename into the texture.
*/
bool Texture::
read(const Filename &fullpath, const LoaderOptions &options) {
CDWriter cdata(_cycler, true);
do_clear(cdata);
cdata->inc_properties_modified();
cdata->inc_image_modified();
return do_read(cdata, fullpath, Filename(), 0, 0, 0, 0, false, false,
options, nullptr);
}
/**
* Combine a 3-component image with a grayscale image to get a 4-component
* image.
*
* See the description of the full-parameter read() method for the meaning of
* the primary_file_num_channels and alpha_file_channel parameters.
*/
bool Texture::
read(const Filename &fullpath, const Filename &alpha_fullpath,
int primary_file_num_channels, int alpha_file_channel,
const LoaderOptions &options) {
CDWriter cdata(_cycler, true);
do_clear(cdata);
cdata->inc_properties_modified();
cdata->inc_image_modified();
return do_read(cdata, fullpath, alpha_fullpath, primary_file_num_channels,
alpha_file_channel, 0, 0, false, false,
options, nullptr);
}
/**
* Reads a single file into a single page or mipmap level, or automatically
* reads a series of files into a series of pages and/or mipmap levels.
*
* See the description of the full-parameter read() method for the meaning of
* the various parameters.
*/
bool Texture::
read(const Filename &fullpath, int z, int n,
bool read_pages, bool read_mipmaps,
const LoaderOptions &options) {
CDWriter cdata(_cycler, true);
cdata->inc_properties_modified();
cdata->inc_image_modified();
return do_read(cdata, fullpath, Filename(), 0, 0, z, n, read_pages, read_mipmaps,
options, nullptr);
}
/**
* Reads the texture from the indicated filename. If
* primary_file_num_channels is not 0, it specifies the number of components
* to downgrade the image to if it is greater than this number.
*
* If the filename has the extension .txo, this implicitly reads a texture
* object instead of a filename (which replaces all of the texture
* properties). In this case, all the rest of the parameters are ignored, and
* the filename should not contain any hash marks; just the one named file
* will be read, since a single .txo file can contain all pages and mipmaps
* necessary to define a texture.
*
* If alpha_fullpath is not empty, it specifies the name of a file from which
* to retrieve the alpha. In this case, alpha_file_channel represents the
* numeric channel of this image file to use as the resulting texture's alpha
* channel; usually, this is 0 to indicate the grayscale combination of r, g,
* b; or it may be a one-based channel number, e.g. 1 for the red channel, 2
* for the green channel, and so on.
*
* If read pages is false, then z indicates the page number into which this
* image will be assigned. Normally this is 0 for the first (or only) page of
* the texture. 3-D textures have one page for each level of depth, and cube
* map textures always have six pages.
*
* If read_pages is true, multiple images will be read at once, one for each
* page of a cube map or a 3-D texture. In this case, the filename should
* contain a sequence of one or more hash marks ("#") which will be filled in
* with the z value of each page, zero-based. In this case, the z parameter
* indicates the maximum z value that will be loaded, or 0 to load all
* filenames that exist.
*
* If read_mipmaps is false, then n indicates the mipmap level to which this
* image will be assigned. Normally this is 0 for the base texture image, but
* it is possible to load custom mipmap levels into the later images. After
* the base texture image is loaded (thus defining the size of the texture),
* you can call get_expected_num_mipmap_levels() to determine the maximum
* sensible value for n.
*
* If read_mipmaps is true, multiple images will be read as above, but this
* time the images represent the different mipmap levels of the texture image.
* In this case, the n parameter indicates the maximum n value that will be
* loaded, or 0 to load all filenames that exist (up to the expected number of
* mipmap levels).
*
* If both read_pages and read_mipmaps is true, then both sequences will be
* read; the filename should contain two sequences of hash marks, separated by
* some character such as a hyphen, underscore, or dot. The first hash mark
* sequence will be filled in with the mipmap level, while the second hash
* mark sequence will be the page index.
*
* This method implicitly sets keep_ram_image to false.
*/
bool Texture::
read(const Filename &fullpath, const Filename &alpha_fullpath,
int primary_file_num_channels, int alpha_file_channel,
int z, int n, bool read_pages, bool read_mipmaps,
BamCacheRecord *record,
const LoaderOptions &options) {
CDWriter cdata(_cycler, true);
cdata->inc_properties_modified();
cdata->inc_image_modified();
return do_read(cdata, fullpath, alpha_fullpath, primary_file_num_channels,
alpha_file_channel, z, n, read_pages, read_mipmaps,
options, record);
}
/**
* Estimates the amount of texture memory that will be consumed by loading
* this texture. This returns a value that is not specific to any particular
* graphics card or driver; it tries to make a reasonable assumption about how
* a driver will load the texture. It does not account for texture
* compression or anything fancy. This is mainly useful for debugging and
* reporting purposes.
*
* Returns a value in bytes.
*/
size_t Texture::
estimate_texture_memory() const {
CDReader cdata(_cycler);
size_t pixels = cdata->_x_size * cdata->_y_size * cdata->_z_size;
size_t bpp = 4;
switch (cdata->_format) {
case Texture::F_rgb332:
bpp = 1;
break;
case Texture::F_alpha:
case Texture::F_red:
case Texture::F_green:
case Texture::F_blue:
case Texture::F_luminance:
case Texture::F_sluminance:
case Texture::F_r8i:
bpp = 1;
break;
case Texture::F_luminance_alpha:
case Texture::F_luminance_alphamask:
case Texture::F_sluminance_alpha:
case Texture::F_rgba4:
case Texture::F_rgb5:
case Texture::F_rgba5:
case Texture::F_rg:
bpp = 2;
break;
case Texture::F_rgba:
case Texture::F_rgbm:
case Texture::F_rgb:
case Texture::F_srgb:
// Most of the above formats have only 3 bytes, but they are most likely
// to get padded by the driver
bpp = 4;
break;
case Texture::F_color_index:
case Texture::F_rgb8:
case Texture::F_rgba8:
case Texture::F_srgb_alpha:
case Texture::F_rgb8i:
case Texture::F_rgba8i:
bpp = 4;
break;
case Texture::F_depth_stencil:
bpp = 4;
break;
case Texture::F_depth_component:
case Texture::F_depth_component16:
bpp = 2;
break;
case Texture::F_depth_component24: // Gets padded
case Texture::F_depth_component32:
bpp = 4;
break;
case Texture::F_rgba12:
case Texture::F_rgb12:
bpp = 8;
break;
case Texture::F_rgba16:
bpp = 8;
break;
case Texture::F_rgba32:
bpp = 16;
break;
case Texture::F_r16:
case Texture::F_r16i:
case Texture::F_rg8i:
bpp = 2;
break;
case Texture::F_rg16:
bpp = 4;
break;
case Texture::F_rgb16:
bpp = 8;
break;
case Texture::F_r32i:
case Texture::F_r32:
bpp = 4;
break;
case Texture::F_rg32:
bpp = 8;
break;
case Texture::F_rgb32:
bpp = 16;
break;
case Texture::F_r11_g11_b10:
case Texture::F_rgb9_e5:
case Texture::F_rgb10_a2:
bpp = 4;
break;
default:
gobj_cat.warning() << "Unhandled format in estimate_texture_memory(): "
<< cdata->_format << "\n";
break;
}
size_t bytes = pixels * bpp;
if (uses_mipmaps()) {
bytes = (bytes * 4) / 3;
}
return bytes;
}
/**
* Records an arbitrary object in the Texture, associated with a specified
* key. The object may later be retrieved by calling get_aux_data() with the
* same key.
*
* These data objects are not recorded to a bam or txo file.
*/
void Texture::
set_aux_data(const string &key, TypedReferenceCount *aux_data) {
MutexHolder holder(_lock);
_aux_data[key] = aux_data;
}
/**
* Removes a record previously recorded via set_aux_data().
*/
void Texture::
clear_aux_data(const string &key) {
MutexHolder holder(_lock);
_aux_data.erase(key);
}
/**
* Returns a record previously recorded via set_aux_data(). Returns NULL if
* there was no record associated with the indicated key.
*/
TypedReferenceCount *Texture::
get_aux_data(const string &key) const {
MutexHolder holder(_lock);
AuxData::const_iterator di;
di = _aux_data.find(key);
if (di != _aux_data.end()) {
return (*di).second;
}
return nullptr;
}
/**
* Reads the texture from a Panda texture object. This defines the complete
* Texture specification, including the image data as well as all texture
* properties. This only works if the txo file contains a static Texture
* image, as opposed to a subclass of Texture such as a movie texture.
*
* Pass a real filename if it is available, or empty string if it is not.
*/
bool Texture::
read_txo(istream &in, const string &filename) {
CDWriter cdata(_cycler, true);
cdata->inc_properties_modified();
cdata->inc_image_modified();
return do_read_txo(cdata, in, filename);
}
/**
* Constructs a new Texture object from the txo file. This is similar to
* Texture::read_txo(), but it constructs and returns a new object, which
* allows it to return a subclass of Texture (for instance, a movie texture).
*
* Pass a real filename if it is available, or empty string if it is not.
*/
PT(Texture) Texture::
make_from_txo(istream &in, const string &filename) {
DatagramInputFile din;
if (!din.open(in, filename)) {
gobj_cat.error()
<< "Could not read texture object: " << filename << "\n";
return nullptr;
}
string head;
if (!din.read_header(head, _bam_header.size())) {
gobj_cat.error()
<< filename << " is not a texture object file.\n";
return nullptr;
}
if (head != _bam_header) {
gobj_cat.error()
<< filename << " is not a texture object file.\n";
return nullptr;
}
BamReader reader(&din);
if (!reader.init()) {
return nullptr;
}
TypedWritable *object = reader.read_object();
if (object != nullptr &&
object->is_exact_type(BamCacheRecord::get_class_type())) {
// Here's a special case: if the first object in the file is a
// BamCacheRecord, it's really a cache data file and not a true txo file;
// but skip over the cache data record and let the user treat it like an
// ordinary txo file.
object = reader.read_object();
}
if (object == nullptr) {
gobj_cat.error()
<< "Texture object " << filename << " is empty.\n";
return nullptr;
} else if (!object->is_of_type(Texture::get_class_type())) {
gobj_cat.error()
<< "Texture object " << filename << " contains a "
<< object->get_type() << ", not a Texture.\n";
return nullptr;
}
PT(Texture) other = DCAST(Texture, object);
if (!reader.resolve()) {
gobj_cat.error()
<< "Unable to fully resolve texture object file.\n";
return nullptr;
}
return other;
}
/**
* Writes the texture to a Panda texture object. This defines the complete
* Texture specification, including the image data as well as all texture
* properties.
*
* The filename is just for reference.
*/
bool Texture::
write_txo(ostream &out, const string &filename) const {
CDReader cdata(_cycler);
return do_write_txo(cdata, out, filename);
}
/**
* Reads the texture from a DDS file object. This is a Microsoft-defined file
* format; it is similar in principle to a txo object, in that it is designed
* to contain the texture image in a form as similar as possible to its
* runtime image, and it can contain mipmaps, pre-compressed textures, and so
* on.
*
* As with read_txo, the filename is just for reference.
*/
bool Texture::
read_dds(istream &in, const string &filename, bool header_only) {
CDWriter cdata(_cycler, true);
cdata->inc_properties_modified();
cdata->inc_image_modified();
return do_read_dds(cdata, in, filename, header_only);
}
/**
* Reads the texture from a KTX file object. This is a Khronos-defined file
* format; it is similar in principle to a dds object, in that it is designed
* to contain the texture image in a form as similar as possible to its
* runtime image, and it can contain mipmaps, pre-compressed textures, and so
* on.
*
* As with read_dds, the filename is just for reference.
*/
bool Texture::
read_ktx(istream &in, const string &filename, bool header_only) {
CDWriter cdata(_cycler, true);
cdata->inc_properties_modified();
cdata->inc_image_modified();
return do_read_ktx(cdata, in, filename, header_only);
}
/**
* Loads a texture whose filename is derived by concatenating a suffix to the
* filename of this texture. May return NULL, for example, if this texture
* doesn't have a filename.
*/
Texture *Texture::
load_related(const InternalName *suffix) const {
MutexHolder holder(_lock);
CDReader cdata(_cycler);
RelatedTextures::const_iterator ti;
ti = _related_textures.find(suffix);
if (ti != _related_textures.end()) {
return (*ti).second;
}
if (cdata->_fullpath.empty()) {
return nullptr;
}
Filename main = cdata->_fullpath;
main.set_basename_wo_extension(main.get_basename_wo_extension() +
suffix->get_name());
PT(Texture) res;
if (!cdata->_alpha_fullpath.empty()) {
Filename alph = cdata->_alpha_fullpath;
alph.set_basename_wo_extension(alph.get_basename_wo_extension() +
suffix->get_name());
VirtualFileSystem *vfs = VirtualFileSystem::get_global_ptr();
if (vfs->exists(alph)) {
// The alpha variant of the filename, with the suffix, exists. Use it
// to load the texture.
res = TexturePool::load_texture(main, alph,
cdata->_primary_file_num_channels,
cdata->_alpha_file_channel, false);
} else {
// If the alpha variant of the filename doesn't exist, just go ahead and
// load the related texture without alpha.
res = TexturePool::load_texture(main);
}
} else {
// No alpha filename--just load the single file. It doesn't necessarily
// have the same number of channels as this one.
res = TexturePool::load_texture(main);
}
// I'm casting away the const-ness of 'this' because this field is only a
// cache.
((Texture *)this)->_related_textures.insert(RelatedTextures::value_type(suffix, res));
return res;
}
/**
* Replaces the current system-RAM image with the new data, converting it
* first if necessary from the indicated component-order format. See
* get_ram_image_as() for specifications about the format. This method cannot
* support compressed image data or sub-pages; use set_ram_image() for that.
*/
void Texture::
set_ram_image_as(CPTA_uchar image, const string &supplied_format) {
CDWriter cdata(_cycler, true);
string format = upcase(supplied_format);
// Make sure we can grab something that's uncompressed.
int imgsize = cdata->_x_size * cdata->_y_size;
nassertv(image.size() == (size_t)(cdata->_component_width * format.size() * imgsize));
// Check if the format is already what we have internally.
if ((cdata->_num_components == 1 && format.size() == 1) ||
(cdata->_num_components == 2 && format.size() == 2 && format.at(1) == 'A' && format.at(0) != 'A') ||
(cdata->_num_components == 3 && format == "BGR") ||
(cdata->_num_components == 4 && format == "BGRA")) {
// The format string is already our format, so we just need to copy it.
do_set_ram_image(cdata, image);
return;
}
// Create a new empty array that can hold our image.
PTA_uchar newdata = PTA_uchar::empty_array(imgsize * cdata->_num_components * cdata->_component_width, get_class_type());
// These ifs are for optimization of commonly used image types.
if (cdata->_component_width == 1) {
if (format == "RGBA" && cdata->_num_components == 4) {
imgsize *= 4;
for (int p = 0; p < imgsize; p += 4) {
newdata[p + 2] = image[p ];
newdata[p + 1] = image[p + 1];
newdata[p ] = image[p + 2];
newdata[p + 3] = image[p + 3];
}
do_set_ram_image(cdata, newdata);
return;
}
if (format == "RGB" && cdata->_num_components == 3) {
imgsize *= 3;
for (int p = 0; p < imgsize; p += 3) {
newdata[p + 2] = image[p ];
newdata[p + 1] = image[p + 1];
newdata[p ] = image[p + 2];
}
do_set_ram_image(cdata, newdata);
return;
}
if (format == "A" && cdata->_num_components != 3) {
// We can generally rely on alpha to be the last component.
int component = cdata->_num_components - 1;
for (int p = 0; p < imgsize; ++p) {
newdata[component] = image[p];
}
do_set_ram_image(cdata, newdata);
return;
}
for (int p = 0; p < imgsize; ++p) {
for (uchar s = 0; s < format.size(); ++s) {
signed char component = -1;
if (format.at(s) == 'B' || (cdata->_num_components <= 2 && format.at(s) != 'A')) {
component = 0;
} else if (format.at(s) == 'G') {
component = 1;
} else if (format.at(s) == 'R') {
component = 2;
} else if (format.at(s) == 'A') {
if (cdata->_num_components != 3) {
component = cdata->_num_components - 1;
} else {
// Ignore.
}
} else if (format.at(s) == '0') {
// Ignore.
} else if (format.at(s) == '1') {
// Ignore.
} else {
gobj_cat.error() << "Unexpected component character '"
<< format.at(s) << "', expected one of RGBA!\n";
return;
}
if (component >= 0) {
newdata[p * cdata->_num_components + component] = image[p * format.size() + s];
}
}
}
do_set_ram_image(cdata, newdata);
return;
}
for (int p = 0; p < imgsize; ++p) {
for (uchar s = 0; s < format.size(); ++s) {
signed char component = -1;
if (format.at(s) == 'B' || (cdata->_num_components <= 2 && format.at(s) != 'A')) {
component = 0;
} else if (format.at(s) == 'G') {
component = 1;
} else if (format.at(s) == 'R') {
component = 2;
} else if (format.at(s) == 'A') {
if (cdata->_num_components != 3) {
component = cdata->_num_components - 1;
} else {
// Ignore.
}
} else if (format.at(s) == '0') {
// Ignore.
} else if (format.at(s) == '1') {
// Ignore.
} else {
gobj_cat.error() << "Unexpected component character '"
<< format.at(s) << "', expected one of RGBA!\n";
return;
}
if (component >= 0) {
memcpy((void*)(newdata + (p * cdata->_num_components + component) * cdata->_component_width),
(void*)(image + (p * format.size() + s) * cdata->_component_width),
cdata->_component_width);
}
}
}
do_set_ram_image(cdata, newdata);
return;
}
/**
* Returns the flag that indicates whether this Texture is eligible to have
* its main RAM copy of the texture memory dumped when the texture is prepared
* for rendering. See set_keep_ram_image().
*/
bool Texture::
get_keep_ram_image() const {
CDReader cdata(_cycler);
return cdata->_keep_ram_image;
}
/**
* Returns true if there is enough information in this Texture object to write
* it to the bam cache successfully, false otherwise. For most textures, this
* is the same as has_ram_image().
*/
bool Texture::
is_cacheable() const {
CDReader cdata(_cycler);
return do_has_bam_rawdata(cdata);
}
/**
* Returns the number of contiguous mipmap levels that exist in RAM, up until
* the first gap in the sequence. It is guaranteed that at least mipmap
* levels [0, get_num_ram_mipmap_images()) exist.
*
* The number returned will never exceed the number of required mipmap images
* based on the size of the texture and its filter mode.
*
* This method is different from get_num_ram_mipmap_images() in that it
* returns only the number of mipmap levels that can actually be usefully
* loaded, regardless of the actual number that may be stored.
*/
int Texture::
get_num_loadable_ram_mipmap_images() const {
CDReader cdata(_cycler);
if (cdata->_ram_images.empty() || cdata->_ram_images[0]._image.empty()) {
// If we don't even have a base image, the answer is none.
return 0;
}
if (!uses_mipmaps()) {
// If we have a base image and don't require mipmapping, the answer is 1.
return 1;
}
// Check that we have enough mipmap levels to meet the size requirements.
int size = max(cdata->_x_size, max(cdata->_y_size, cdata->_z_size));
int n = 0;
int x = 1;
while (x < size) {
x = (x << 1);
++n;
if (n >= (int)cdata->_ram_images.size() || cdata->_ram_images[n]._image.empty()) {
return n;
}
}
++n;
return n;
}
/**
* Returns the system-RAM image data associated with the nth mipmap level, if
* present. Returns NULL if the nth mipmap level is not present.
*/
CPTA_uchar Texture::
get_ram_mipmap_image(int n) const {
CDReader cdata(_cycler);
if (n < (int)cdata->_ram_images.size() && !cdata->_ram_images[n]._image.empty()) {
return cdata->_ram_images[n]._image;
}
return CPTA_uchar(get_class_type());
}
/**
* Similiar to get_ram_mipmap_image(), however, in this case the void pointer
* for the given ram image is returned. This will be NULL unless it has been
* explicitly set.
*/
void *Texture::
get_ram_mipmap_pointer(int n) const {
CDReader cdata(_cycler);
if (n < (int)cdata->_ram_images.size()) {
return cdata->_ram_images[n]._pointer_image;
}
return nullptr;
}
/**
* Sets an explicit void pointer as the texture's mipmap image for the
* indicated level. This is a special call to direct a texture to reference
* some external image location, for instance from a webcam input.
*
* The texture will henceforth reference this pointer directly, instead of its
* own internal storage; the user is responsible for ensuring the data at this
* address remains allocated and valid, and in the correct format, during the
* lifetime of the texture.
*/
void Texture::
set_ram_mipmap_pointer(int n, void *image, size_t page_size) {
CDWriter cdata(_cycler, true);
nassertv(cdata->_ram_image_compression != CM_off || do_get_expected_ram_mipmap_image_size(cdata, n));
while (n >= (int)cdata->_ram_images.size()) {
cdata->_ram_images.push_back(RamImage());
}
cdata->_ram_images[n]._page_size = page_size;
// _ram_images[n]._image.clear(); wtf is going on?!
cdata->_ram_images[n]._pointer_image = image;
cdata->inc_image_modified();
}
/**
* Accepts a raw pointer cast as an int, which is then passed to
* set_ram_mipmap_pointer(); see the documentation for that method.
*
* This variant is particularly useful to set an external pointer from a
* language like Python, which doesn't support void pointers directly.
*/
void Texture::
set_ram_mipmap_pointer_from_int(long long pointer, int n, int page_size) {
set_ram_mipmap_pointer(n, (void*)pointer, (size_t)page_size);
}
/**
* Discards the current system-RAM image for the nth mipmap level.
*/
void Texture::
clear_ram_mipmap_image(int n) {
CDWriter cdata(_cycler, true);
if (n >= (int)cdata->_ram_images.size()) {
return;
}
cdata->_ram_images[n]._page_size = 0;
cdata->_ram_images[n]._image.clear();
cdata->_ram_images[n]._pointer_image = nullptr;
}
/**
* Returns a modifiable pointer to the internal "simple" texture image. See
* set_simple_ram_image().
*/
PTA_uchar Texture::
modify_simple_ram_image() {
CDWriter cdata(_cycler, true);
cdata->_simple_image_date_generated = (int32_t)time(nullptr);
return cdata->_simple_ram_image._image;
}
/**
* Creates an empty array for the simple ram image of the indicated size, and
* returns a modifiable pointer to the new array. See set_simple_ram_image().
*/
PTA_uchar Texture::
new_simple_ram_image(int x_size, int y_size) {
CDWriter cdata(_cycler, true);
nassertr(cdata->_texture_type == TT_2d_texture, PTA_uchar());
size_t expected_page_size = (size_t)(x_size * y_size * 4);
cdata->_simple_x_size = x_size;
cdata->_simple_y_size = y_size;
cdata->_simple_ram_image._image = PTA_uchar::empty_array(expected_page_size);
cdata->_simple_ram_image._page_size = expected_page_size;
cdata->_simple_image_date_generated = (int32_t)time(nullptr);
cdata->inc_simple_image_modified();
return cdata->_simple_ram_image._image;
}
/**
* Computes the "simple" ram image by loading the main RAM image, if it is not
* already available, and reducing it to 16x16 or smaller. This may be an
* expensive operation.
*/
void Texture::
generate_simple_ram_image() {
CDWriter cdata(_cycler, true);
if (cdata->_texture_type != TT_2d_texture ||
cdata->_ram_image_compression != CM_off) {
return;
}
PNMImage pnmimage;
if (!do_store_one(cdata, pnmimage, 0, 0)) {
return;
}
// Start at the suggested size from the config file.
int x_size = simple_image_size.get_word(0);
int y_size = simple_image_size.get_word(1);
// Limit it to no larger than the source image, and also make it a power of
// two.
x_size = down_to_power_2(min(x_size, cdata->_x_size));
y_size = down_to_power_2(min(y_size, cdata->_y_size));
// Generate a reduced image of that size.
PNMImage scaled(x_size, y_size, pnmimage.get_num_channels());
scaled.quick_filter_from(pnmimage);
// Make sure the reduced image has 4 components, by convention.
if (!scaled.has_alpha()) {
scaled.add_alpha();
scaled.alpha_fill(1.0);
}
scaled.set_num_channels(4);
// Now see if we can go even smaller.
bool did_anything;
do {
did_anything = false;
// Try to reduce X.
if (x_size > 1) {
int new_x_size = (x_size >> 1);
PNMImage smaller(new_x_size, y_size, 4);
smaller.quick_filter_from(scaled);
PNMImage bigger(x_size, y_size, 4);
bigger.quick_filter_from(smaller);
if (compare_images(scaled, bigger)) {
scaled.take_from(smaller);
x_size = new_x_size;
did_anything = true;
}
}
// Try to reduce Y.
if (y_size > 1) {
int new_y_size = (y_size >> 1);
PNMImage smaller(x_size, new_y_size, 4);
smaller.quick_filter_from(scaled);
PNMImage bigger(x_size, y_size, 4);
bigger.quick_filter_from(smaller);
if (compare_images(scaled, bigger)) {
scaled.take_from(smaller);
y_size = new_y_size;
did_anything = true;
}
}
} while (did_anything);
size_t expected_page_size = (size_t)(x_size * y_size * 4);
PTA_uchar image = PTA_uchar::empty_array(expected_page_size, get_class_type());
convert_from_pnmimage(image, expected_page_size, x_size, 0, 0, 0, scaled, 4, 1);
do_set_simple_ram_image(cdata, image, x_size, y_size);
cdata->_simple_image_date_generated = (int32_t)time(nullptr);
}
/**
* Returns a TexturePeeker object that can be used to examine the individual
* texels stored within this Texture by (u, v) coordinate.
*
* If the texture has a ram image resident, that image is used. If it does
* not have a full ram image but does have a simple_ram_image resident, that
* image is used instead. If neither image is resident the full image is
* reloaded.
*
* Returns NULL if the texture cannot find an image to load, or the texture
* format is incompatible.
*/
PT(TexturePeeker) Texture::
peek() {
CDWriter cdata(_cycler, unlocked_ensure_ram_image(true));
PT(TexturePeeker) peeker = new TexturePeeker(this, cdata);
if (peeker->is_valid()) {
return peeker;
}
return nullptr;
}
/**
* Indicates that the texture should be enqueued to be prepared in the
* indicated prepared_objects at the beginning of the next frame. This will
* ensure the texture is already loaded into texture memory if it is expected
* to be rendered soon.
*
* Use this function instead of prepare_now() to preload textures from a user
* interface standpoint.
*/
PT(AsyncFuture) Texture::
prepare(PreparedGraphicsObjects *prepared_objects) {
return prepared_objects->enqueue_texture_future(this);
}
/**
* Returns true if the texture has already been prepared or enqueued for
* preparation on the indicated GSG, false otherwise.
*/
bool Texture::
is_prepared(PreparedGraphicsObjects *prepared_objects) const {
MutexHolder holder(_lock);
PreparedViews::const_iterator pvi;
pvi = _prepared_views.find(prepared_objects);
if (pvi != _prepared_views.end()) {
return true;
}
return prepared_objects->is_texture_queued(this);
}
/**
* Returns true if the texture needs to be re-loaded onto the indicated GSG,
* either because its image data is out-of-date, or because it's not fully
* prepared now.
*/
bool Texture::
was_image_modified(PreparedGraphicsObjects *prepared_objects) const {
MutexHolder holder(_lock);
CDReader cdata(_cycler);
PreparedViews::const_iterator pvi;
pvi = _prepared_views.find(prepared_objects);
if (pvi != _prepared_views.end()) {
const Contexts &contexts = (*pvi).second;
for (int view = 0; view < cdata->_num_views; ++view) {
Contexts::const_iterator ci;
ci = contexts.find(view);
if (ci == contexts.end()) {
return true;
}
TextureContext *tc = (*ci).second;
if (tc->was_image_modified()) {
return true;
}
}
return false;
}
return true;
}
/**
* Returns the number of bytes which the texture is reported to consume within
* graphics memory, for the indicated GSG. This may return a nonzero value
* even if the texture is not currently resident; you should also check
* get_resident() if you want to know how much space the texture is actually
* consuming right now.
*/
size_t Texture::
get_data_size_bytes(PreparedGraphicsObjects *prepared_objects) const {
MutexHolder holder(_lock);
CDReader cdata(_cycler);
PreparedViews::const_iterator pvi;
size_t total_size = 0;
pvi = _prepared_views.find(prepared_objects);
if (pvi != _prepared_views.end()) {
const Contexts &contexts = (*pvi).second;
for (int view = 0; view < cdata->_num_views; ++view) {
Contexts::const_iterator ci;
ci = contexts.find(view);
if (ci != contexts.end()) {
TextureContext *tc = (*ci).second;
total_size += tc->get_data_size_bytes();
}
}
}
return total_size;
}
/**
* Returns true if this Texture was rendered in the most recent frame within
* the indicated GSG.
*/
bool Texture::
get_active(PreparedGraphicsObjects *prepared_objects) const {
MutexHolder holder(_lock);
CDReader cdata(_cycler);
PreparedViews::const_iterator pvi;
pvi = _prepared_views.find(prepared_objects);
if (pvi != _prepared_views.end()) {
const Contexts &contexts = (*pvi).second;
for (int view = 0; view < cdata->_num_views; ++view) {
Contexts::const_iterator ci;
ci = contexts.find(view);
if (ci != contexts.end()) {
TextureContext *tc = (*ci).second;
if (tc->get_active()) {
return true;
}
}
}
}
return false;
}
/**
* Returns true if this Texture is reported to be resident within graphics
* memory for the indicated GSG.
*/
bool Texture::
get_resident(PreparedGraphicsObjects *prepared_objects) const {
MutexHolder holder(_lock);
CDReader cdata(_cycler);
PreparedViews::const_iterator pvi;
pvi = _prepared_views.find(prepared_objects);
if (pvi != _prepared_views.end()) {
const Contexts &contexts = (*pvi).second;
for (int view = 0; view < cdata->_num_views; ++view) {
Contexts::const_iterator ci;
ci = contexts.find(view);
if (ci != contexts.end()) {
TextureContext *tc = (*ci).second;
if (tc->get_resident()) {
return true;
}
}
}
}
return false;
}
/**
* Frees the texture context only on the indicated object, if it exists there.
* Returns true if it was released, false if it had not been prepared.
*/
bool Texture::
release(PreparedGraphicsObjects *prepared_objects) {
MutexHolder holder(_lock);
PreparedViews::iterator pvi;
pvi = _prepared_views.find(prepared_objects);
if (pvi != _prepared_views.end()) {
Contexts temp;
temp.swap((*pvi).second);
Contexts::iterator ci;
for (ci = temp.begin(); ci != temp.end(); ++ci) {
TextureContext *tc = (*ci).second;
if (tc != nullptr) {
prepared_objects->release_texture(tc);
}
}
_prepared_views.erase(pvi);
}
// Maybe it wasn't prepared yet, but it's about to be.
return prepared_objects->dequeue_texture(this);
}
/**
* Frees the context allocated on all objects for which the texture has been
* declared. Returns the number of contexts which have been freed.
*/
int Texture::
release_all() {
MutexHolder holder(_lock);
// We have to traverse a copy of the _prepared_views list, because the
// PreparedGraphicsObjects object will call clear_prepared() in response to
// each release_texture(), and we don't want to be modifying the
// _prepared_views list while we're traversing it.
PreparedViews temp;
temp.swap(_prepared_views);
int num_freed = (int)temp.size();
PreparedViews::iterator pvi;
for (pvi = temp.begin(); pvi != temp.end(); ++pvi) {
PreparedGraphicsObjects *prepared_objects = (*pvi).first;
Contexts temp;
temp.swap((*pvi).second);
Contexts::iterator ci;
for (ci = temp.begin(); ci != temp.end(); ++ci) {
TextureContext *tc = (*ci).second;
if (tc != nullptr) {
prepared_objects->release_texture(tc);
}
}
}
return num_freed;
}
/**
* Not to be confused with write(Filename), this method simply describes the
* texture properties.
*/
void Texture::
write(ostream &out, int indent_level) const {
CDReader cdata(_cycler);
indent(out, indent_level)
<< cdata->_texture_type << " " << get_name();
if (!cdata->_filename.empty()) {
out << " (from " << cdata->_filename << ")";
}
out << "\n";
indent(out, indent_level + 2);
switch (cdata->_texture_type) {
case TT_1d_texture:
out << "1-d, " << cdata->_x_size;
break;
case TT_2d_texture:
out << "2-d, " << cdata->_x_size << " x " << cdata->_y_size;
break;
case TT_3d_texture:
out << "3-d, " << cdata->_x_size << " x " << cdata->_y_size << " x " << cdata->_z_size;
break;
case TT_2d_texture_array:
out << "2-d array, " << cdata->_x_size << " x " << cdata->_y_size << " x " << cdata->_z_size;
break;
case TT_cube_map:
out << "cube map, " << cdata->_x_size << " x " << cdata->_y_size;
break;
case TT_cube_map_array:
out << "cube map array, " << cdata->_x_size << " x " << cdata->_y_size << " x " << cdata->_z_size;
break;
case TT_buffer_texture:
out << "buffer, " << cdata->_x_size;
break;
case TT_1d_texture_array:
out << "1-d array, " << cdata->_x_size << " x " << cdata->_y_size;
break;
}
if (cdata->_num_views > 1) {
out << " (x " << cdata->_num_views << " views)";
}
out << " pixels, each " << cdata->_num_components;
switch (cdata->_component_type) {
case T_unsigned_byte:
case T_byte:
out << " bytes";
break;
case T_unsigned_short:
case T_short:
out << " shorts";
break;
case T_half_float:
out << " half";
case T_float:
out << " floats";
break;
case T_unsigned_int_24_8:
case T_int:
case T_unsigned_int:
out << " ints";
break;
default:
break;
}
out << ", ";
switch (cdata->_format) {
case F_color_index:
out << "color_index";
break;
case F_depth_stencil:
out << "depth_stencil";
break;
case F_depth_component:
out << "depth_component";
break;
case F_depth_component16:
out << "depth_component16";
break;
case F_depth_component24:
out << "depth_component24";
break;
case F_depth_component32:
out << "depth_component32";
break;
case F_rgba:
out << "rgba";
break;
case F_rgbm:
out << "rgbm";
break;
case F_rgba32:
out << "rgba32";
break;
case F_rgba16:
out << "rgba16";
break;
case F_rgba12:
out << "rgba12";
break;
case F_rgba8:
out << "rgba8";
break;
case F_rgba4:
out << "rgba4";
break;
case F_rgb:
out << "rgb";
break;
case F_rgb12:
out << "rgb12";
break;
case F_rgb8:
out << "rgb8";
break;
case F_rgb5:
out << "rgb5";
break;
case F_rgba5:
out << "rgba5";
break;
case F_rgb332:
out << "rgb332";
break;
case F_red:
out << "red";
break;
case F_green:
out << "green";
break;
case F_blue:
out << "blue";
break;
case F_alpha:
out << "alpha";
break;
case F_luminance:
out << "luminance";
break;
case F_luminance_alpha:
out << "luminance_alpha";
break;
case F_luminance_alphamask:
out << "luminance_alphamask";
break;
case F_r16:
out << "r16";
break;
case F_r16i:
out << "r16i";
break;
case F_rg16:
out << "rg16";
break;
case F_rgb16:
out << "rgb16";
break;
case F_srgb:
out << "srgb";
break;
case F_srgb_alpha:
out << "srgb_alpha";
break;
case F_sluminance:
out << "sluminance";
break;
case F_sluminance_alpha:
out << "sluminance_alpha";
break;
case F_r32i:
out << "r32i";
break;
case F_r32:
out << "r32";
break;
case F_rg32:
out << "rg32";
break;
case F_rgb32:
out << "rgb32";
break;
case F_r8i:
out << "r8i";
break;
case F_rg8i:
out << "rg8i";
break;
case F_rgb8i:
out << "rgb8i";
break;
case F_rgba8i:
out << "rgba8i";
break;
case F_r11_g11_b10:
out << "r11_g11_b10";
break;
case F_rgb9_e5:
out << "rgb9_e5";
break;
case F_rgb10_a2:
out << "rgb10_a2";
break;
case F_rg:
out << "rg";
break;
}
if (cdata->_compression != CM_default) {
out << ", compression " << cdata->_compression;
}
out << "\n";
indent(out, indent_level + 2);
cdata->_default_sampler.output(out);
if (do_has_ram_image(cdata)) {
indent(out, indent_level + 2)
<< do_get_ram_image_size(cdata) << " bytes in ram, compression "
<< cdata->_ram_image_compression << "\n";
if (cdata->_ram_images.size() > 1) {
int count = 0;
size_t total_size = 0;
for (size_t n = 1; n < cdata->_ram_images.size(); ++n) {
if (!cdata->_ram_images[n]._image.empty()) {
++count;
total_size += cdata->_ram_images[n]._image.size();
} else {
// Stop at the first gap.
break;
}
}
indent(out, indent_level + 2)
<< count
<< " mipmap levels also present in ram (" << total_size
<< " bytes).\n";
}
} else {
indent(out, indent_level + 2)
<< "no ram image\n";
}
if (!cdata->_simple_ram_image._image.empty()) {
indent(out, indent_level + 2)
<< "simple image: " << cdata->_simple_x_size << " x "
<< cdata->_simple_y_size << ", "
<< cdata->_simple_ram_image._image.size() << " bytes\n";
}
}
/**
* Changes the size of the texture, padding if necessary, and setting the pad
* region as well.
*/
void Texture::
set_size_padded(int x, int y, int z) {
CDWriter cdata(_cycler, true);
if (do_get_auto_texture_scale(cdata) != ATS_none) {
do_set_x_size(cdata, up_to_power_2(x));
do_set_y_size(cdata, up_to_power_2(y));
if (cdata->_texture_type == TT_3d_texture) {
// Only pad 3D textures. It does not make sense to do so for cube maps
// or 2D texture arrays.
do_set_z_size(cdata, up_to_power_2(z));
} else {
do_set_z_size(cdata, z);
}
} else {
do_set_x_size(cdata, x);
do_set_y_size(cdata, y);
do_set_z_size(cdata, z);
}
do_set_pad_size(cdata,
cdata->_x_size - x,
cdata->_y_size - y,
cdata->_z_size - z);
}
/**
* Specifies the size of the texture as it exists in its original disk file,
* before any Panda scaling.
*/
void Texture::
set_orig_file_size(int x, int y, int z) {
CDWriter cdata(_cycler, true);
cdata->_orig_file_x_size = x;
cdata->_orig_file_y_size = y;
nassertv(z == cdata->_z_size);
}
/**
* Creates a context for the texture on the particular GSG, if it does not
* already exist. Returns the new (or old) TextureContext. This assumes that
* the GraphicsStateGuardian is the currently active rendering context and
* that it is ready to accept new textures. If this is not necessarily the
* case, you should use prepare() instead.
*
* Normally, this is not called directly except by the GraphicsStateGuardian;
* a texture does not need to be explicitly prepared by the user before it may
* be rendered.
*/
TextureContext *Texture::
prepare_now(int view,
PreparedGraphicsObjects *prepared_objects,
GraphicsStateGuardianBase *gsg) {
MutexHolder holder(_lock);
CDReader cdata(_cycler);
// Don't exceed the actual number of views.
view = max(min(view, cdata->_num_views - 1), 0);
// Get the list of PreparedGraphicsObjects for this view.
Contexts &contexts = _prepared_views[prepared_objects];
Contexts::const_iterator pvi;
pvi = contexts.find(view);
if (pvi != contexts.end()) {
return (*pvi).second;
}
TextureContext *tc = prepared_objects->prepare_texture_now(this, view, gsg);
contexts[view] = tc;
return tc;
}
/**
* Returns the smallest power of 2 greater than or equal to value.
*/
int Texture::
up_to_power_2(int value) {
if (value <= 1) {
return 1;
}
int bit = get_next_higher_bit(((unsigned int)value) - 1);
return (1 << bit);
}
/**
* Returns the largest power of 2 less than or equal to value.
*/
int Texture::
down_to_power_2(int value) {
if (value <= 1) {
return 1;
}
int bit = get_next_higher_bit(((unsigned int)value) >> 1);
return (1 << bit);
}
/**
* Asks the PNMImage to change its scale when it reads the image, according to
* the whims of the Config.prc file.
*
* For most efficient results, this method should be called after
* pnmimage.read_header() has been called, but before pnmimage.read(). This
* method may also be called after pnmimage.read(), i.e. when the pnmimage is
* already loaded; in this case it will rescale the image on the spot. Also
* see rescale_texture().
*/
void Texture::
consider_rescale(PNMImage &pnmimage) {
consider_rescale(pnmimage, get_name(), get_auto_texture_scale());
}
/**
* Asks the PNMImage to change its scale when it reads the image, according to
* the whims of the Config.prc file.
*
* For most efficient results, this method should be called after
* pnmimage.read_header() has been called, but before pnmimage.read(). This
* method may also be called after pnmimage.read(), i.e. when the pnmimage is
* already loaded; in this case it will rescale the image on the spot. Also
* see rescale_texture().
*/
void Texture::
consider_rescale(PNMImage &pnmimage, const string &name, AutoTextureScale auto_texture_scale) {
int new_x_size = pnmimage.get_x_size();
int new_y_size = pnmimage.get_y_size();
if (adjust_size(new_x_size, new_y_size, name, false, auto_texture_scale)) {
if (pnmimage.is_valid()) {
// The image is already loaded. Rescale on the spot.
PNMImage new_image(new_x_size, new_y_size, pnmimage.get_num_channels(),
pnmimage.get_maxval(), pnmimage.get_type(),
pnmimage.get_color_space());
new_image.quick_filter_from(pnmimage);
pnmimage.take_from(new_image);
} else {
// Rescale while reading. Some image types (e.g. jpeg) can take
// advantage of this.
pnmimage.set_read_size(new_x_size, new_y_size);
}
}
}
/**
* Returns the indicated TextureType converted to a string word.
*/
string Texture::
format_texture_type(TextureType tt) {
switch (tt) {
case TT_1d_texture:
return "1d_texture";
case TT_2d_texture:
return "2d_texture";
case TT_3d_texture:
return "3d_texture";
case TT_2d_texture_array:
return "2d_texture_array";
case TT_cube_map:
return "cube_map";
case TT_cube_map_array:
return "cube_map_array";
case TT_buffer_texture:
return "buffer_texture";
case TT_1d_texture_array:
return "1d_texture_array";
}
return "**invalid**";
}
/**
* Returns the TextureType corresponding to the indicated string word.
*/
Texture::TextureType Texture::
string_texture_type(const string &str) {
if (cmp_nocase(str, "1d_texture") == 0) {
return TT_1d_texture;
} else if (cmp_nocase(str, "2d_texture") == 0) {
return TT_2d_texture;
} else if (cmp_nocase(str, "3d_texture") == 0) {
return TT_3d_texture;
} else if (cmp_nocase(str, "2d_texture_array") == 0) {
return TT_2d_texture_array;
} else if (cmp_nocase(str, "cube_map") == 0) {
return TT_cube_map;
} else if (cmp_nocase(str, "cube_map_array") == 0) {
return TT_cube_map_array;
} else if (cmp_nocase(str, "buffer_texture") == 0) {
return TT_buffer_texture;
}
gobj_cat->error()
<< "Invalid Texture::TextureType value: " << str << "\n";
return TT_2d_texture;
}
/**
* Returns the indicated ComponentType converted to a string word.
*/
string Texture::
format_component_type(ComponentType ct) {
switch (ct) {
case T_unsigned_byte:
return "unsigned_byte";
case T_unsigned_short:
return "unsigned_short";
case T_float:
return "float";
case T_unsigned_int_24_8:
return "unsigned_int_24_8";
case T_int:
return "int";
case T_byte:
return "unsigned_byte";
case T_short:
return "short";
case T_half_float:
return "half_float";
case T_unsigned_int:
return "unsigned_int";
}
return "**invalid**";
}
/**
* Returns the ComponentType corresponding to the indicated string word.
*/
Texture::ComponentType Texture::
string_component_type(const string &str) {
if (cmp_nocase(str, "unsigned_byte") == 0) {
return T_unsigned_byte;
} else if (cmp_nocase(str, "unsigned_short") == 0) {
return T_unsigned_short;
} else if (cmp_nocase(str, "float") == 0) {
return T_float;
} else if (cmp_nocase(str, "unsigned_int_24_8") == 0) {
return T_unsigned_int_24_8;
} else if (cmp_nocase(str, "int") == 0) {
return T_int;
} else if (cmp_nocase(str, "byte") == 0) {
return T_byte;
} else if (cmp_nocase(str, "short") == 0) {
return T_short;
} else if (cmp_nocase(str, "half_float") == 0) {
return T_half_float;
} else if (cmp_nocase(str, "unsigned_int") == 0) {
return T_unsigned_int;
}
gobj_cat->error()
<< "Invalid Texture::ComponentType value: " << str << "\n";
return T_unsigned_byte;
}
/**
* Returns the indicated Format converted to a string word.
*/
string Texture::
format_format(Format format) {
switch (format) {
case F_depth_stencil:
return "depth_stencil";
case F_depth_component:
return "depth_component";
case F_depth_component16:
return "depth_component16";
case F_depth_component24:
return "depth_component24";
case F_depth_component32:
return "depth_component32";
case F_color_index:
return "color_index";
case F_red:
return "red";
case F_green:
return "green";
case F_blue:
return "blue";
case F_alpha:
return "alpha";
case F_rgb:
return "rgb";
case F_rgb5:
return "rgb5";
case F_rgb8:
return "rgb8";
case F_rgb12:
return "rgb12";
case F_rgb332:
return "rgb332";
case F_rgba:
return "rgba";
case F_rgbm:
return "rgbm";
case F_rgba4:
return "rgba4";
case F_rgba5:
return "rgba5";
case F_rgba8:
return "rgba8";
case F_rgba12:
return "rgba12";
case F_luminance:
return "luminance";
case F_luminance_alpha:
return "luminance_alpha";
case F_luminance_alphamask:
return "luminance_alphamask";
case F_rgba16:
return "rgba16";
case F_rgba32:
return "rgba32";
case F_r16:
return "r16";
case F_r16i:
return "r16i";
case F_rg16:
return "rg16";
case F_rgb16:
return "rgb16";
case F_srgb:
return "srgb";
case F_srgb_alpha:
return "srgb_alpha";
case F_sluminance:
return "sluminance";
case F_sluminance_alpha:
return "sluminance_alpha";
case F_r32i:
return "r32i";
case F_r32:
return "r32";
case F_rg32:
return "rg32";
case F_rgb32:
return "rgb32";
case F_r8i:
return "r8i";
case F_rg8i:
return "rg8i";
case F_rgb8i:
return "rgb8i";
case F_rgba8i:
return "rgba8i";
case F_r11_g11_b10:
return "r11g11b10";
case F_rgb9_e5:
return "rgb9_e5";
case F_rgb10_a2:
return "rgb10_a2";
case F_rg:
return "rg";
}
return "**invalid**";
}
/**
* Returns the Format corresponding to the indicated string word.
*/
Texture::Format Texture::
string_format(const string &str) {
if (cmp_nocase(str, "depth_stencil") == 0) {
return F_depth_stencil;
} else if (cmp_nocase(str, "depth_component") == 0) {
return F_depth_component;
} else if (cmp_nocase(str, "depth_component16") == 0 || cmp_nocase(str, "d16") == 0) {
return F_depth_component16;
} else if (cmp_nocase(str, "depth_component24") == 0 || cmp_nocase(str, "d24") == 0) {
return F_depth_component24;
} else if (cmp_nocase(str, "depth_component32") == 0 || cmp_nocase(str, "d32") == 0) {
return F_depth_component32;
} else if (cmp_nocase(str, "color_index") == 0) {
return F_color_index;
} else if (cmp_nocase(str, "red") == 0) {
return F_red;
} else if (cmp_nocase(str, "green") == 0) {
return F_green;
} else if (cmp_nocase(str, "blue") == 0) {
return F_blue;
} else if (cmp_nocase(str, "alpha") == 0) {
return F_alpha;
} else if (cmp_nocase(str, "rgb") == 0) {
return F_rgb;
} else if (cmp_nocase(str, "rgb5") == 0) {
return F_rgb5;
} else if (cmp_nocase(str, "rgb8") == 0 || cmp_nocase(str, "r8g8b8") == 0) {
return F_rgb8;
} else if (cmp_nocase(str, "rgb12") == 0) {
return F_rgb12;
} else if (cmp_nocase(str, "rgb332") == 0 || cmp_nocase(str, "r3g3b2") == 0) {
return F_rgb332;
} else if (cmp_nocase(str, "rgba") == 0) {
return F_rgba;
} else if (cmp_nocase(str, "rgbm") == 0) {
return F_rgbm;
} else if (cmp_nocase(str, "rgba4") == 0) {
return F_rgba4;
} else if (cmp_nocase(str, "rgba5") == 0) {
return F_rgba5;
} else if (cmp_nocase(str, "rgba8") == 0 || cmp_nocase(str, "r8g8b8a8") == 0) {
return F_rgba8;
} else if (cmp_nocase(str, "rgba12") == 0) {
return F_rgba12;
} else if (cmp_nocase(str, "luminance") == 0) {
return F_luminance;
} else if (cmp_nocase(str, "luminance_alpha") == 0) {
return F_luminance_alpha;
} else if (cmp_nocase(str, "luminance_alphamask") == 0) {
return F_luminance_alphamask;
} else if (cmp_nocase(str, "rgba16") == 0 || cmp_nocase(str, "r16g16b16a16") == 0) {
return F_rgba16;
} else if (cmp_nocase(str, "rgba32") == 0 || cmp_nocase(str, "r32g32b32a32") == 0) {
return F_rgba32;
} else if (cmp_nocase(str, "r16") == 0 || cmp_nocase(str, "red16") == 0) {
return F_r16;
} else if (cmp_nocase(str, "r16i") == 0) {
return F_r16i;
} else if (cmp_nocase(str, "rg16") == 0 || cmp_nocase(str, "r16g16") == 0) {
return F_rg16;
} else if (cmp_nocase(str, "rgb16") == 0 || cmp_nocase(str, "r16g16b16") == 0) {
return F_rgb16;
} else if (cmp_nocase(str, "srgb") == 0) {
return F_srgb;
} else if (cmp_nocase(str, "srgb_alpha") == 0) {
return F_srgb_alpha;
} else if (cmp_nocase(str, "sluminance") == 0) {
return F_sluminance;
} else if (cmp_nocase(str, "sluminance_alpha") == 0) {
return F_sluminance_alpha;
} else if (cmp_nocase(str, "r32i") == 0) {
return F_r32i;
} else if (cmp_nocase(str, "r32") == 0 || cmp_nocase(str, "red32") == 0) {
return F_r32;
} else if (cmp_nocase(str, "rg32") == 0 || cmp_nocase(str, "r32g32") == 0) {
return F_rg32;
} else if (cmp_nocase(str, "rgb32") == 0 || cmp_nocase(str, "r32g32b32") == 0) {
return F_rgb32;
} else if (cmp_nocase(str, "r11g11b10") == 0) {
return F_r11_g11_b10;
} else if (cmp_nocase(str, "rgb9_e5") == 0) {
return F_rgb9_e5;
} else if (cmp_nocase_uh(str, "rgb10_a2") == 0 || cmp_nocase(str, "r10g10b10a2") == 0) {
return F_rgb10_a2;
} else if (cmp_nocase_uh(str, "rg") == 0) {
return F_rg;
}
gobj_cat->error()
<< "Invalid Texture::Format value: " << str << "\n";
return F_rgba;
}
/**
* Returns the indicated CompressionMode converted to a string word.
*/
string Texture::
format_compression_mode(CompressionMode cm) {
switch (cm) {
case CM_default:
return "default";
case CM_off:
return "off";
case CM_on:
return "on";
case CM_fxt1:
return "fxt1";
case CM_dxt1:
return "dxt1";
case CM_dxt2:
return "dxt2";
case CM_dxt3:
return "dxt3";
case CM_dxt4:
return "dxt4";
case CM_dxt5:
return "dxt5";
case CM_pvr1_2bpp:
return "pvr1_2bpp";
case CM_pvr1_4bpp:
return "pvr1_4bpp";
case CM_rgtc:
return "rgtc";
case CM_etc1:
return "etc1";
case CM_etc2:
return "etc2";
case CM_eac:
return "eac";
}
return "**invalid**";
}
/**
* Returns the CompressionMode value associated with the given string
* representation.
*/
Texture::CompressionMode Texture::
string_compression_mode(const string &str) {
if (cmp_nocase_uh(str, "default") == 0) {
return CM_default;
} else if (cmp_nocase_uh(str, "off") == 0) {
return CM_off;
} else if (cmp_nocase_uh(str, "on") == 0) {
return CM_on;
} else if (cmp_nocase_uh(str, "fxt1") == 0) {
return CM_fxt1;
} else if (cmp_nocase_uh(str, "dxt1") == 0) {
return CM_dxt1;
} else if (cmp_nocase_uh(str, "dxt2") == 0) {
return CM_dxt2;
} else if (cmp_nocase_uh(str, "dxt3") == 0) {
return CM_dxt3;
} else if (cmp_nocase_uh(str, "dxt4") == 0) {
return CM_dxt4;
} else if (cmp_nocase_uh(str, "dxt5") == 0) {
return CM_dxt5;
} else if (cmp_nocase_uh(str, "pvr1_2bpp") == 0) {
return CM_pvr1_2bpp;
} else if (cmp_nocase_uh(str, "pvr1_4bpp") == 0) {
return CM_pvr1_4bpp;
} else if (cmp_nocase_uh(str, "rgtc") == 0) {
return CM_rgtc;
} else if (cmp_nocase_uh(str, "etc1") == 0) {
return CM_etc1;
} else if (cmp_nocase_uh(str, "etc2") == 0) {
return CM_etc2;
} else if (cmp_nocase_uh(str, "eac") == 0) {
return CM_eac;
}
gobj_cat->error()
<< "Invalid Texture::CompressionMode value: " << str << "\n";
return CM_default;
}
/**
* Returns the indicated QualityLevel converted to a string word.
*/
string Texture::
format_quality_level(QualityLevel ql) {
switch (ql) {
case QL_default:
return "default";
case QL_fastest:
return "fastest";
case QL_normal:
return "normal";
case QL_best:
return "best";
}
return "**invalid**";
}
/**
* Returns the QualityLevel value associated with the given string
* representation.
*/
Texture::QualityLevel Texture::
string_quality_level(const string &str) {
if (cmp_nocase(str, "default") == 0) {
return QL_default;
} else if (cmp_nocase(str, "fastest") == 0) {
return QL_fastest;
} else if (cmp_nocase(str, "normal") == 0) {
return QL_normal;
} else if (cmp_nocase(str, "best") == 0) {
return QL_best;
}
gobj_cat->error()
<< "Invalid Texture::QualityLevel value: " << str << "\n";
return QL_default;
}
/**
* This method is called by the GraphicsEngine at the beginning of the frame
* *after* a texture has been successfully uploaded to graphics memory. It is
* intended as a callback so the texture can release its RAM image, if
* _keep_ram_image is false.
*
* This is called indirectly when the GSG calls
* GraphicsEngine::texture_uploaded().
*/
void Texture::
texture_uploaded() {
CDLockedReader cdata(_cycler);
if (!keep_texture_ram && !cdata->_keep_ram_image) {
// Once we have prepared the texture, we can generally safely remove the
// pixels from main RAM. The GSG is now responsible for remembering what
// it looks like.
CDWriter cdataw(_cycler, cdata, false);
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< "Dumping RAM for texture " << get_name() << "\n";
}
do_clear_ram_image(cdataw);
}
}
/**
* Should be overridden by derived classes to return true if cull_callback()
* has been defined. Otherwise, returns false to indicate cull_callback()
* does not need to be called for this node during the cull traversal.
*/
bool Texture::
has_cull_callback() const {
return false;
}
/**
* If has_cull_callback() returns true, this function will be called during
* the cull traversal to perform any additional operations that should be
* performed at cull time.
*
* This is called each time the Texture is discovered applied to a Geom in the
* traversal. It should return true if the Geom is visible, false if it
* should be omitted.
*/
bool Texture::
cull_callback(CullTraverser *, const CullTraverserData &) const {
return true;
}
/**
* A factory function to make a new Texture, used to pass to the TexturePool.
*/
PT(Texture) Texture::
make_texture() {
return new Texture;
}
/**
* Returns true if the indicated component type is unsigned, false otherwise.
*/
bool Texture::
is_unsigned(Texture::ComponentType ctype) {
return (ctype == T_unsigned_byte ||
ctype == T_unsigned_short ||
ctype == T_unsigned_int_24_8 ||
ctype == T_unsigned_int);
}
/**
* Returns true if the indicated compression mode is one of the specific
* compression types, false otherwise.
*/
bool Texture::
is_specific(Texture::CompressionMode compression) {
switch (compression) {
case CM_default:
case CM_off:
case CM_on:
return false;
default:
return true;
}
}
/**
* Returns true if the indicated format includes alpha, false otherwise.
*/
bool Texture::
has_alpha(Format format) {
switch (format) {
case F_alpha:
case F_rgba:
case F_rgbm:
case F_rgba4:
case F_rgba5:
case F_rgba8:
case F_rgba12:
case F_rgba16:
case F_rgba32:
case F_luminance_alpha:
case F_luminance_alphamask:
case F_srgb_alpha:
case F_sluminance_alpha:
case F_rgba8i:
case F_rgb10_a2:
return true;
default:
return false;
}
}
/**
* Returns true if the indicated format includes a binary alpha only, false
* otherwise.
*/
bool Texture::
has_binary_alpha(Format format) {
switch (format) {
case F_rgbm:
return true;
default:
return false;
}
}
/**
* Returns true if the indicated format is in the sRGB color space, false
* otherwise.
*/
bool Texture::
is_srgb(Format format) {
switch (format) {
case F_srgb:
case F_srgb_alpha:
case F_sluminance:
case F_sluminance_alpha:
return true;
default:
return false;
}
}
/**
* Computes the proper size of the texture, based on the original size, the
* filename, and the resizing whims of the config file.
*
* x_size and y_size should be loaded with the texture image's original size
* on disk. On return, they will be loaded with the texture's in-memory
* target size. The return value is true if the size has been adjusted, or
* false if it is the same.
*/
bool Texture::
adjust_size(int &x_size, int &y_size, const string &name,
bool for_padding, AutoTextureScale auto_texture_scale) {
bool exclude = false;
int num_excludes = exclude_texture_scale.get_num_unique_values();
for (int i = 0; i < num_excludes && !exclude; ++i) {
GlobPattern pat(exclude_texture_scale.get_unique_value(i));
if (pat.matches(name)) {
exclude = true;
}
}
int new_x_size = x_size;
int new_y_size = y_size;
if (!exclude) {
new_x_size = (int)cfloor(new_x_size * texture_scale + 0.5);
new_y_size = (int)cfloor(new_y_size * texture_scale + 0.5);
// Don't auto-scale below 4 in either dimension. This causes problems for
// DirectX and texture compression.
new_x_size = min(max(new_x_size, (int)texture_scale_limit), x_size);
new_y_size = min(max(new_y_size, (int)texture_scale_limit), y_size);
}
AutoTextureScale ats = auto_texture_scale;
if (ats == ATS_unspecified) {
ats = get_textures_power_2();
}
if (!for_padding && ats == ATS_pad) {
// If we're not calculating the padding size--that is, we're calculating
// the initial scaling size instead--then ignore ATS_pad, and treat it the
// same as ATS_none.
ats = ATS_none;
}
switch (ats) {
case ATS_down:
new_x_size = down_to_power_2(new_x_size);
new_y_size = down_to_power_2(new_y_size);
break;
case ATS_up:
case ATS_pad:
new_x_size = up_to_power_2(new_x_size);
new_y_size = up_to_power_2(new_y_size);
break;
case ATS_none:
case ATS_unspecified:
break;
}
ats = textures_square.get_value();
if (!for_padding && ats == ATS_pad) {
ats = ATS_none;
}
switch (ats) {
case ATS_down:
new_x_size = new_y_size = min(new_x_size, new_y_size);
break;
case ATS_up:
case ATS_pad:
new_x_size = new_y_size = max(new_x_size, new_y_size);
break;
case ATS_none:
case ATS_unspecified:
break;
}
if (!exclude) {
int max_dimension = max_texture_dimension;
if (max_dimension < 0) {
GraphicsStateGuardianBase *gsg = GraphicsStateGuardianBase::get_default_gsg();
if (gsg != nullptr) {
max_dimension = gsg->get_max_texture_dimension();
}
}
if (max_dimension > 0) {
new_x_size = min(new_x_size, (int)max_dimension);
new_y_size = min(new_y_size, (int)max_dimension);
}
}
if (x_size != new_x_size || y_size != new_y_size) {
x_size = new_x_size;
y_size = new_y_size;
return true;
}
return false;
}
/**
* May be called prior to calling read_txo() or any bam-related Texture-
* creating callback, to ensure that the proper dynamic libraries for a
* Texture of the current class type, and the indicated filename, have been
* already loaded.
*
* This is a low-level function that should not normally need to be called
* directly by the user.
*
* Note that for best results you must first create a Texture object of the
* appropriate class type for your filename, for instance with
* TexturePool::make_texture().
*/
void Texture::
ensure_loader_type(const Filename &filename) {
// For a plain Texture type, this doesn't need to do anything.
}
/**
* Called by TextureContext to give the Texture a chance to mark itself dirty
* before rendering, if necessary.
*/
void Texture::
reconsider_dirty() {
}
/**
* Works like adjust_size, but also considers the texture class. Movie
* textures, for instance, always pad outwards, regardless of textures-
* power-2.
*/
bool Texture::
do_adjust_this_size(const CData *cdata, int &x_size, int &y_size, const string &name,
bool for_padding) const {
return adjust_size(x_size, y_size, name, for_padding, cdata->_auto_texture_scale);
}
/**
* The internal implementation of the various read() methods.
*/
bool Texture::
do_read(CData *cdata, const Filename &fullpath, const Filename &alpha_fullpath,
int primary_file_num_channels, int alpha_file_channel,
int z, int n, bool read_pages, bool read_mipmaps,
const LoaderOptions &options, BamCacheRecord *record) {
PStatTimer timer(_texture_read_pcollector);
if (options.get_auto_texture_scale() != ATS_unspecified) {
cdata->_auto_texture_scale = options.get_auto_texture_scale();
}
bool header_only = ((options.get_texture_flags() & (LoaderOptions::TF_preload | LoaderOptions::TF_preload_simple)) == 0);
if (record != nullptr) {
header_only = false;
}
if ((z == 0 || read_pages) && (n == 0 || read_mipmaps)) {
// When we re-read the page 0 of the base image, we clear everything and
// start over.
do_clear_ram_image(cdata);
}
if (is_txo_filename(fullpath)) {
if (record != nullptr) {
record->add_dependent_file(fullpath);
}
return do_read_txo_file(cdata, fullpath);
}
if (is_dds_filename(fullpath)) {
if (record != nullptr) {
record->add_dependent_file(fullpath);
}
return do_read_dds_file(cdata, fullpath, header_only);
}
if (is_ktx_filename(fullpath)) {
if (record != nullptr) {
record->add_dependent_file(fullpath);
}
return do_read_ktx_file(cdata, fullpath, header_only);
}
// If read_pages or read_mipmaps is specified, then z and n actually
// indicate z_size and n_size, respectively--the numerical limits on which
// to search for filenames.
int z_size = z;
int n_size = n;
// Certain texture types have an implicit z_size. If z_size is omitted,
// choose an appropriate default based on the texture type.
if (z_size == 0) {
switch (cdata->_texture_type) {
case TT_1d_texture:
case TT_2d_texture:
case TT_buffer_texture:
z_size = 1;
break;
case TT_cube_map:
z_size = 6;
break;
default:
break;
}
}
int num_views = 0;
if (options.get_texture_flags() & LoaderOptions::TF_multiview) {
// We'll be loading a multiview texture.
read_pages = true;
if (options.get_texture_num_views() != 0) {
num_views = options.get_texture_num_views();
do_set_num_views(cdata, num_views);
}
}
VirtualFileSystem *vfs = VirtualFileSystem::get_global_ptr();
if (read_pages && read_mipmaps) {
// Read a sequence of pages * mipmap levels.
Filename fullpath_pattern = Filename::pattern_filename(fullpath);
Filename alpha_fullpath_pattern = Filename::pattern_filename(alpha_fullpath);
do_set_z_size(cdata, z_size);
n = 0;
while (true) {
// For mipmap level 0, the total number of pages might be determined by
// the number of files we find. After mipmap level 0, though, the
// number of pages is predetermined.
if (n != 0) {
z_size = do_get_expected_mipmap_z_size(cdata, n);
}
z = 0;
Filename n_pattern = Filename::pattern_filename(fullpath_pattern.get_filename_index(z));
Filename alpha_n_pattern = Filename::pattern_filename(alpha_fullpath_pattern.get_filename_index(z));
if (!n_pattern.has_hash()) {
gobj_cat.error()
<< "Filename requires two different hash sequences: " << fullpath
<< "\n";
return false;
}
Filename file = n_pattern.get_filename_index(n);
Filename alpha_file = alpha_n_pattern.get_filename_index(n);
if ((n_size == 0 && (vfs->exists(file) || n == 0)) ||
(n_size != 0 && n < n_size)) {
// Continue through the loop.
} else {
// We've reached the end of the mipmap sequence.
break;
}
int num_pages = z_size * num_views;
while ((num_pages == 0 && (vfs->exists(file) || z == 0)) ||
(num_pages != 0 && z < num_pages)) {
if (!do_read_one(cdata, file, alpha_file, z, n, primary_file_num_channels,
alpha_file_channel, options, header_only, record)) {
return false;
}
++z;
n_pattern = Filename::pattern_filename(fullpath_pattern.get_filename_index(z));
file = n_pattern.get_filename_index(n);
alpha_file = alpha_n_pattern.get_filename_index(n);
}
if (n == 0 && n_size == 0) {
// If n_size is not specified, it gets implicitly set after we read
// the base texture image (which determines the size of the texture).
n_size = do_get_expected_num_mipmap_levels(cdata);
}
++n;
}
cdata->_fullpath = fullpath_pattern;
cdata->_alpha_fullpath = alpha_fullpath_pattern;
} else if (read_pages) {
// Read a sequence of cube map or 3-D texture pages.
Filename fullpath_pattern = Filename::pattern_filename(fullpath);
Filename alpha_fullpath_pattern = Filename::pattern_filename(alpha_fullpath);
if (!fullpath_pattern.has_hash()) {
gobj_cat.error()
<< "Filename requires a hash mark: " << fullpath
<< "\n";
return false;
}
do_set_z_size(cdata, z_size);
z = 0;
Filename file = fullpath_pattern.get_filename_index(z);
Filename alpha_file = alpha_fullpath_pattern.get_filename_index(z);
int num_pages = z_size * num_views;
while ((num_pages == 0 && (vfs->exists(file) || z == 0)) ||
(num_pages != 0 && z < num_pages)) {
if (!do_read_one(cdata, file, alpha_file, z, 0, primary_file_num_channels,
alpha_file_channel, options, header_only, record)) {
return false;
}
++z;
file = fullpath_pattern.get_filename_index(z);
alpha_file = alpha_fullpath_pattern.get_filename_index(z);
}
cdata->_fullpath = fullpath_pattern;
cdata->_alpha_fullpath = alpha_fullpath_pattern;
} else if (read_mipmaps) {
// Read a sequence of mipmap levels.
Filename fullpath_pattern = Filename::pattern_filename(fullpath);
Filename alpha_fullpath_pattern = Filename::pattern_filename(alpha_fullpath);
if (!fullpath_pattern.has_hash()) {
gobj_cat.error()
<< "Filename requires a hash mark: " << fullpath
<< "\n";
return false;
}
n = 0;
Filename file = fullpath_pattern.get_filename_index(n);
Filename alpha_file = alpha_fullpath_pattern.get_filename_index(n);
while ((n_size == 0 && (vfs->exists(file) || n == 0)) ||
(n_size != 0 && n < n_size)) {
if (!do_read_one(cdata, file, alpha_file, z, n,
primary_file_num_channels, alpha_file_channel,
options, header_only, record)) {
return false;
}
++n;
if (n_size == 0 && n >= do_get_expected_num_mipmap_levels(cdata)) {
// Don't try to read more than the requisite number of mipmap levels
// (unless the user insisted on it for some reason).
break;
}
file = fullpath_pattern.get_filename_index(n);
alpha_file = alpha_fullpath_pattern.get_filename_index(n);
}
cdata->_fullpath = fullpath_pattern;
cdata->_alpha_fullpath = alpha_fullpath_pattern;
} else {
// Just an ordinary read of one file.
if (!do_read_one(cdata, fullpath, alpha_fullpath, z, n,
primary_file_num_channels, alpha_file_channel,
options, header_only, record)) {
return false;
}
}
cdata->_has_read_pages = read_pages;
cdata->_has_read_mipmaps = read_mipmaps;
cdata->_num_mipmap_levels_read = cdata->_ram_images.size();
if (header_only) {
// If we were only supposed to be checking the image header information,
// don't let the Texture think that it's got the image now.
do_clear_ram_image(cdata);
} else {
if ((options.get_texture_flags() & LoaderOptions::TF_preload) != 0) {
// If we intend to keep the ram image around, consider compressing it
// etc.
bool generate_mipmaps = ((options.get_texture_flags() & LoaderOptions::TF_generate_mipmaps) != 0);
bool allow_compression = ((options.get_texture_flags() & LoaderOptions::TF_allow_compression) != 0);
do_consider_auto_process_ram_image(cdata, generate_mipmaps || uses_mipmaps(), allow_compression);
}
}
return true;
}
/**
* Called only from do_read(), this method reads a single image file, either
* one page or one mipmap level.
*/
bool Texture::
do_read_one(CData *cdata, const Filename &fullpath, const Filename &alpha_fullpath,
int z, int n, int primary_file_num_channels, int alpha_file_channel,
const LoaderOptions &options, bool header_only, BamCacheRecord *record) {
if (record != nullptr) {
nassertr(!header_only, false);
record->add_dependent_file(fullpath);
}
PNMImage image;
PfmFile pfm;
PNMReader *image_reader = image.make_reader(fullpath, nullptr, false);
if (image_reader == nullptr) {
gobj_cat.error()
<< "Texture::read() - couldn't read: " << fullpath << endl;
return false;
}
image.copy_header_from(*image_reader);
AutoTextureScale auto_texture_scale = do_get_auto_texture_scale(cdata);
// If it's a floating-point image file, read it by default into a floating-
// point texture.
bool read_floating_point;
int texture_load_type = (options.get_texture_flags() & (LoaderOptions::TF_integer | LoaderOptions::TF_float));
switch (texture_load_type) {
case LoaderOptions::TF_integer:
read_floating_point = false;
break;
case LoaderOptions::TF_float:
read_floating_point = true;
break;
default:
// Neither TF_integer nor TF_float was specified; determine which way the
// texture wants to be loaded.
read_floating_point = (image_reader->is_floating_point());
if (!alpha_fullpath.empty()) {
read_floating_point = false;
}
}
if (header_only || textures_header_only) {
int x_size = image.get_x_size();
int y_size = image.get_y_size();
if (z == 0 && n == 0) {
cdata->_orig_file_x_size = x_size;
cdata->_orig_file_y_size = y_size;
}
if (textures_header_only) {
// In this mode, we never intend to load the actual texture image
// anyway, so we don't even need to make the size right.
x_size = 1;
y_size = 1;
} else {
adjust_size(x_size, y_size, fullpath.get_basename(), false, auto_texture_scale);
}
if (read_floating_point) {
pfm.clear(x_size, y_size, image.get_num_channels());
} else {
image = PNMImage(x_size, y_size, image.get_num_channels(),
image.get_maxval(), image.get_type(),
image.get_color_space());
image.fill(0.2, 0.3, 1.0);
if (image.has_alpha()) {
image.alpha_fill(1.0);
}
}
delete image_reader;
} else {
if (z == 0 && n == 0) {
int x_size = image.get_x_size();
int y_size = image.get_y_size();
cdata->_orig_file_x_size = x_size;
cdata->_orig_file_y_size = y_size;
if (adjust_size(x_size, y_size, fullpath.get_basename(), false, auto_texture_scale)) {
image.set_read_size(x_size, y_size);
}
} else {
image.set_read_size(do_get_expected_mipmap_x_size(cdata, n),
do_get_expected_mipmap_y_size(cdata, n));
}
if (image.get_x_size() != image.get_read_x_size() ||
image.get_y_size() != image.get_read_y_size()) {
gobj_cat.info()
<< "Implicitly rescaling " << fullpath.get_basename() << " from "
<< image.get_x_size() << " by " << image.get_y_size() << " to "
<< image.get_read_x_size() << " by " << image.get_read_y_size()
<< "\n";
}
bool success;
if (read_floating_point) {
success = pfm.read(image_reader);
} else {
success = image.read(image_reader);
}
if (!success) {
gobj_cat.error()
<< "Texture::read() - couldn't read: " << fullpath << endl;
return false;
}
Thread::consider_yield();
}
PNMImage alpha_image;
if (!alpha_fullpath.empty()) {
PNMReader *alpha_image_reader = alpha_image.make_reader(alpha_fullpath, nullptr, false);
if (alpha_image_reader == nullptr) {
gobj_cat.error()
<< "Texture::read() - couldn't read: " << alpha_fullpath << endl;
return false;
}
alpha_image.copy_header_from(*alpha_image_reader);
if (record != nullptr) {
record->add_dependent_file(alpha_fullpath);
}
if (header_only || textures_header_only) {
int x_size = image.get_x_size();
int y_size = image.get_y_size();
alpha_image = PNMImage(x_size, y_size, alpha_image.get_num_channels(),
alpha_image.get_maxval(), alpha_image.get_type(),
alpha_image.get_color_space());
alpha_image.fill(1.0);
if (alpha_image.has_alpha()) {
alpha_image.alpha_fill(1.0);
}
delete alpha_image_reader;
} else {
if (image.get_x_size() != alpha_image.get_x_size() ||
image.get_y_size() != alpha_image.get_y_size()) {
gobj_cat.info()
<< "Implicitly rescaling " << alpha_fullpath.get_basename()
<< " from " << alpha_image.get_x_size() << " by "
<< alpha_image.get_y_size() << " to " << image.get_x_size()
<< " by " << image.get_y_size() << "\n";
alpha_image.set_read_size(image.get_x_size(), image.get_y_size());
}
if (!alpha_image.read(alpha_image_reader)) {
gobj_cat.error()
<< "Texture::read() - couldn't read (alpha): " << alpha_fullpath << endl;
return false;
}
Thread::consider_yield();
}
}
if (z == 0 && n == 0) {
if (!has_name()) {
set_name(fullpath.get_basename_wo_extension());
}
if (cdata->_filename.empty()) {
cdata->_filename = fullpath;
cdata->_alpha_filename = alpha_fullpath;
// The first time we set the filename via a read() operation, we clear
// keep_ram_image. The user can always set it again later if he needs
// to.
cdata->_keep_ram_image = false;
}
cdata->_fullpath = fullpath;
cdata->_alpha_fullpath = alpha_fullpath;
}
if (!alpha_fullpath.empty()) {
// The grayscale (alpha channel) image must be the same size as the main
// image. This should really have been already guaranteed by the above.
if (image.get_x_size() != alpha_image.get_x_size() ||
image.get_y_size() != alpha_image.get_y_size()) {
gobj_cat.info()
<< "Automatically rescaling " << alpha_fullpath.get_basename()
<< " from " << alpha_image.get_x_size() << " by "
<< alpha_image.get_y_size() << " to " << image.get_x_size()
<< " by " << image.get_y_size() << "\n";
PNMImage scaled(image.get_x_size(), image.get_y_size(),
alpha_image.get_num_channels(),
alpha_image.get_maxval(), alpha_image.get_type(),
alpha_image.get_color_space());
scaled.quick_filter_from(alpha_image);
Thread::consider_yield();
alpha_image = scaled;
}
}
if (n == 0) {
consider_downgrade(image, primary_file_num_channels, get_name());
cdata->_primary_file_num_channels = image.get_num_channels();
cdata->_alpha_file_channel = 0;
}
if (!alpha_fullpath.empty()) {
// Make the original image a 4-component image by taking the grayscale
// value from the second image.
image.add_alpha();
if (alpha_file_channel == 4 ||
(alpha_file_channel == 2 && alpha_image.get_num_channels() == 2)) {
if (!alpha_image.has_alpha()) {
gobj_cat.error()
<< alpha_fullpath.get_basename() << " has no channel " << alpha_file_channel << ".\n";
} else {
// Use the alpha channel.
for (int x = 0; x < image.get_x_size(); x++) {
for (int y = 0; y < image.get_y_size(); y++) {
image.set_alpha(x, y, alpha_image.get_alpha(x, y));
}
}
}
cdata->_alpha_file_channel = alpha_image.get_num_channels();
} else if (alpha_file_channel >= 1 && alpha_file_channel <= 3 &&
alpha_image.get_num_channels() >= 3) {
// Use the appropriate red, green, or blue channel.
for (int x = 0; x < image.get_x_size(); x++) {
for (int y = 0; y < image.get_y_size(); y++) {
image.set_alpha(x, y, alpha_image.get_channel_val(x, y, alpha_file_channel - 1));
}
}
cdata->_alpha_file_channel = alpha_file_channel;
} else {
// Use the grayscale channel.
for (int x = 0; x < image.get_x_size(); x++) {
for (int y = 0; y < image.get_y_size(); y++) {
image.set_alpha(x, y, alpha_image.get_gray(x, y));
}
}
cdata->_alpha_file_channel = 0;
}
}
if (read_floating_point) {
if (!do_load_one(cdata, pfm, fullpath.get_basename(), z, n, options)) {
return false;
}
} else {
// Now see if we want to pad the image within a larger power-of-2 image.
int pad_x_size = 0;
int pad_y_size = 0;
if (do_get_auto_texture_scale(cdata) == ATS_pad) {
int new_x_size = image.get_x_size();
int new_y_size = image.get_y_size();
if (do_adjust_this_size(cdata, new_x_size, new_y_size, fullpath.get_basename(), true)) {
pad_x_size = new_x_size - image.get_x_size();
pad_y_size = new_y_size - image.get_y_size();
PNMImage new_image(new_x_size, new_y_size, image.get_num_channels(),
image.get_maxval(), image.get_type(),
image.get_color_space());
new_image.copy_sub_image(image, 0, new_y_size - image.get_y_size());
image.take_from(new_image);
}
}
if (!do_load_one(cdata, image, fullpath.get_basename(), z, n, options)) {
return false;
}
do_set_pad_size(cdata, pad_x_size, pad_y_size, 0);
}
return true;
}
/**
* Internal method to load a single page or mipmap level.
*/
bool Texture::
do_load_one(CData *cdata, const PNMImage &pnmimage, const string &name, int z, int n,
const LoaderOptions &options) {
if (cdata->_ram_images.size() <= 1 && n == 0) {
// A special case for mipmap level 0. When we load mipmap level 0, unless
// we already have mipmap levels, it determines the image properties like
// size and number of components.
if (!do_reconsider_z_size(cdata, z, options)) {
return false;
}
nassertr(z >= 0 && z < cdata->_z_size * cdata->_num_views, false);
if (z == 0) {
ComponentType component_type = T_unsigned_byte;
xelval maxval = pnmimage.get_maxval();
if (maxval > 255) {
component_type = T_unsigned_short;
}
if (!do_reconsider_image_properties(cdata, pnmimage.get_x_size(), pnmimage.get_y_size(),
pnmimage.get_num_channels(), component_type,
z, options)) {
return false;
}
}
do_modify_ram_image(cdata);
cdata->_loaded_from_image = true;
}
do_modify_ram_mipmap_image(cdata, n);
// Ensure the PNMImage is an appropriate size.
int x_size = do_get_expected_mipmap_x_size(cdata, n);
int y_size = do_get_expected_mipmap_y_size(cdata, n);
if (pnmimage.get_x_size() != x_size ||
pnmimage.get_y_size() != y_size) {
gobj_cat.info()
<< "Automatically rescaling " << name;
if (n != 0) {
gobj_cat.info(false)
<< " mipmap level " << n;
}
gobj_cat.info(false)
<< " from " << pnmimage.get_x_size() << " by "
<< pnmimage.get_y_size() << " to " << x_size << " by "
<< y_size << "\n";
PNMImage scaled(x_size, y_size, pnmimage.get_num_channels(),
pnmimage.get_maxval(), pnmimage.get_type(),
pnmimage.get_color_space());
scaled.quick_filter_from(pnmimage);
Thread::consider_yield();
convert_from_pnmimage(cdata->_ram_images[n]._image,
do_get_expected_ram_mipmap_page_size(cdata, n),
x_size, 0, 0, z, scaled,
cdata->_num_components, cdata->_component_width);
} else {
// Now copy the pixel data from the PNMImage into our internal
// cdata->_image component.
convert_from_pnmimage(cdata->_ram_images[n]._image,
do_get_expected_ram_mipmap_page_size(cdata, n),
x_size, 0, 0, z, pnmimage,
cdata->_num_components, cdata->_component_width);
}
Thread::consider_yield();
return true;
}
/**
* Internal method to load a single page or mipmap level.
*/
bool Texture::
do_load_one(CData *cdata, const PfmFile &pfm, const string &name, int z, int n,
const LoaderOptions &options) {
if (cdata->_ram_images.size() <= 1 && n == 0) {
// A special case for mipmap level 0. When we load mipmap level 0, unless
// we already have mipmap levels, it determines the image properties like
// size and number of components.
if (!do_reconsider_z_size(cdata, z, options)) {
return false;
}
nassertr(z >= 0 && z < cdata->_z_size * cdata->_num_views, false);
if (z == 0) {
ComponentType component_type = T_float;
if (!do_reconsider_image_properties(cdata, pfm.get_x_size(), pfm.get_y_size(),
pfm.get_num_channels(), component_type,
z, options)) {
return false;
}
}
do_modify_ram_image(cdata);
cdata->_loaded_from_image = true;
}
do_modify_ram_mipmap_image(cdata, n);
// Ensure the PfmFile is an appropriate size.
int x_size = do_get_expected_mipmap_x_size(cdata, n);
int y_size = do_get_expected_mipmap_y_size(cdata, n);
if (pfm.get_x_size() != x_size ||
pfm.get_y_size() != y_size) {
gobj_cat.info()
<< "Automatically rescaling " << name;
if (n != 0) {
gobj_cat.info(false)
<< " mipmap level " << n;
}
gobj_cat.info(false)
<< " from " << pfm.get_x_size() << " by "
<< pfm.get_y_size() << " to " << x_size << " by "
<< y_size << "\n";
PfmFile scaled(pfm);
scaled.resize(x_size, y_size);
Thread::consider_yield();
convert_from_pfm(cdata->_ram_images[n]._image,
do_get_expected_ram_mipmap_page_size(cdata, n), z,
scaled, cdata->_num_components, cdata->_component_width);
} else {
// Now copy the pixel data from the PfmFile into our internal
// cdata->_image component.
convert_from_pfm(cdata->_ram_images[n]._image,
do_get_expected_ram_mipmap_page_size(cdata, n), z,
pfm, cdata->_num_components, cdata->_component_width);
}
Thread::consider_yield();
return true;
}
/**
* Internal method to load an image into a section of a texture page or mipmap
* level.
*/
bool Texture::
do_load_sub_image(CData *cdata, const PNMImage &image, int x, int y, int z, int n) {
nassertr(n >= 0 && (size_t)n < cdata->_ram_images.size(), false);
int tex_x_size = do_get_expected_mipmap_x_size(cdata, n);
int tex_y_size = do_get_expected_mipmap_y_size(cdata, n);
int tex_z_size = do_get_expected_mipmap_z_size(cdata, n);
nassertr(x >= 0 && x < tex_x_size, false);
nassertr(y >= 0 && y < tex_y_size, false);
nassertr(z >= 0 && z < tex_z_size, false);
nassertr(image.get_x_size() + x <= tex_x_size, false);
nassertr(image.get_y_size() + y <= tex_y_size, false);
// Flip y
y = cdata->_y_size - (image.get_y_size() + y);
cdata->inc_image_modified();
do_modify_ram_mipmap_image(cdata, n);
convert_from_pnmimage(cdata->_ram_images[n]._image,
do_get_expected_ram_mipmap_page_size(cdata, n),
tex_x_size, x, y, z, image,
cdata->_num_components, cdata->_component_width);
return true;
}
/**
* Called internally when read() detects a txo file. Assumes the lock is
* already held.
*/
bool Texture::
do_read_txo_file(CData *cdata, const Filename &fullpath) {
VirtualFileSystem *vfs = VirtualFileSystem::get_global_ptr();
Filename filename = Filename::binary_filename(fullpath);
PT(VirtualFile) file = vfs->get_file(filename);
if (file == nullptr) {
// No such file.
gobj_cat.error()
<< "Could not find " << fullpath << "\n";
return false;
}
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< "Reading texture object " << filename << "\n";
}
istream *in = file->open_read_file(true);
bool success = do_read_txo(cdata, *in, fullpath);
vfs->close_read_file(in);
cdata->_fullpath = fullpath;
cdata->_alpha_fullpath = Filename();
cdata->_keep_ram_image = false;
return success;
}
/**
*
*/
bool Texture::
do_read_txo(CData *cdata, istream &in, const string &filename) {
PT(Texture) other = make_from_txo(in, filename);
if (other == nullptr) {
return false;
}
CDReader cdata_other(other->_cycler);
Namable::operator = (*other);
do_assign(cdata, other, cdata_other);
cdata->_loaded_from_image = true;
cdata->_loaded_from_txo = true;
cdata->_has_read_pages = false;
cdata->_has_read_mipmaps = false;
cdata->_num_mipmap_levels_read = 0;
return true;
}
/**
* Called internally when read() detects a DDS file. Assumes the lock is
* already held.
*/
bool Texture::
do_read_dds_file(CData *cdata, const Filename &fullpath, bool header_only) {
VirtualFileSystem *vfs = VirtualFileSystem::get_global_ptr();
Filename filename = Filename::binary_filename(fullpath);
PT(VirtualFile) file = vfs->get_file(filename);
if (file == nullptr) {
// No such file.
gobj_cat.error()
<< "Could not find " << fullpath << "\n";
return false;
}
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< "Reading DDS file " << filename << "\n";
}
istream *in = file->open_read_file(true);
bool success = do_read_dds(cdata, *in, fullpath, header_only);
vfs->close_read_file(in);
if (!has_name()) {
set_name(fullpath.get_basename_wo_extension());
}
cdata->_fullpath = fullpath;
cdata->_alpha_fullpath = Filename();
cdata->_keep_ram_image = false;
return success;
}
/**
*
*/
bool Texture::
do_read_dds(CData *cdata, istream &in, const string &filename, bool header_only) {
StreamReader dds(in);
// DDS header (19 words)
DDSHeader header;
header.dds_magic = dds.get_uint32();
header.dds_size = dds.get_uint32();
header.dds_flags = dds.get_uint32();
header.height = dds.get_uint32();
header.width = dds.get_uint32();
header.pitch = dds.get_uint32();
header.depth = dds.get_uint32();
header.num_levels = dds.get_uint32();
dds.skip_bytes(44);
// Pixelformat (8 words)
header.pf.pf_size = dds.get_uint32();
header.pf.pf_flags = dds.get_uint32();
header.pf.four_cc = dds.get_uint32();
header.pf.rgb_bitcount = dds.get_uint32();
header.pf.r_mask = dds.get_uint32();
header.pf.g_mask = dds.get_uint32();
header.pf.b_mask = dds.get_uint32();
header.pf.a_mask = dds.get_uint32();
// Caps (4 words)
header.caps.caps1 = dds.get_uint32();
header.caps.caps2 = dds.get_uint32();
header.caps.ddsx = dds.get_uint32();
dds.skip_bytes(4);
// Pad out to 32 words
dds.skip_bytes(4);
if (header.dds_magic != DDS_MAGIC || (in.fail() || in.eof())) {
gobj_cat.error()
<< filename << " is not a DDS file.\n";
return false;
}
if ((header.dds_flags & DDSD_MIPMAPCOUNT) == 0) {
// No bit set means only the base mipmap level.
header.num_levels = 1;
} else if (header.num_levels == 0) {
// Some files seem to have this set to 0 for some reason--existing readers
// assume 0 means 1.
header.num_levels = 1;
}
TextureType texture_type;
if (header.caps.caps2 & DDSCAPS2_CUBEMAP) {
static const unsigned int all_faces =
(DDSCAPS2_CUBEMAP_POSITIVEX |
DDSCAPS2_CUBEMAP_POSITIVEY |
DDSCAPS2_CUBEMAP_POSITIVEZ |
DDSCAPS2_CUBEMAP_NEGATIVEX |
DDSCAPS2_CUBEMAP_NEGATIVEY |
DDSCAPS2_CUBEMAP_NEGATIVEZ);
if ((header.caps.caps2 & all_faces) != all_faces) {
gobj_cat.error()
<< filename << " is missing some cube map faces; cannot load.\n";
return false;
}
header.depth = 6;
texture_type = TT_cube_map;
} else if (header.caps.caps2 & DDSCAPS2_VOLUME) {
texture_type = TT_3d_texture;
} else {
texture_type = TT_2d_texture;
header.depth = 1;
}
// Determine the function to use to read the DDS image.
typedef PTA_uchar (*ReadDDSLevelFunc)(Texture *tex, Texture::CData *cdata,
const DDSHeader &header, int n, istream &in);
ReadDDSLevelFunc func = nullptr;
Format format = F_rgb;
ComponentType component_type = T_unsigned_byte;
do_clear_ram_image(cdata);
CompressionMode compression = CM_off;
if ((header.pf.pf_flags & DDPF_FOURCC) != 0 &&
header.pf.four_cc == 0x30315844) { // 'DX10'
// A DirectX 10 style texture, which has an additional header.
func = read_dds_level_generic_uncompressed;
unsigned int dxgi_format = dds.get_uint32();
unsigned int dimension = dds.get_uint32();
unsigned int misc_flag = dds.get_uint32();
unsigned int array_size = dds.get_uint32();
/*unsigned int alpha_mode = */dds.get_uint32();
switch (dxgi_format) {
case 2: // DXGI_FORMAT_R32G32B32A32_FLOAT
format = F_rgba32;
component_type = T_float;
func = read_dds_level_abgr32;
break;
case 10: // DXGI_FORMAT_R16G16B16A16_FLOAT
format = F_rgba16;
component_type = T_half_float;
func = read_dds_level_abgr16;
break;
case 11: // DXGI_FORMAT_R16G16B16A16_UNORM
format = F_rgba16;
component_type = T_unsigned_short;
func = read_dds_level_abgr16;
break;
case 16: // DXGI_FORMAT_R32G32_FLOAT
format = F_rg32;
component_type = T_float;
func = read_dds_level_raw;
break;
case 27: // DXGI_FORMAT_R8G8B8A8_TYPELESS
case 28: // DXGI_FORMAT_R8G8B8A8_UNORM
format = F_rgba8;
func = read_dds_level_abgr8;
break;
case 29: // DXGI_FORMAT_R8G8B8A8_UNORM_SRGB
format = F_srgb_alpha;
func = read_dds_level_abgr8;
break;
case 30: // DXGI_FORMAT_R8G8B8A8_UINT
format = F_rgba8i;
func = read_dds_level_abgr8;
break;
case 31: // DXGI_FORMAT_R8G8B8A8_SNORM
format = F_rgba8;
component_type = T_byte;
func = read_dds_level_abgr8;
break;
case 32: // DXGI_FORMAT_R8G8B8A8_SINT
format = F_rgba8i;
component_type = T_byte;
func = read_dds_level_abgr8;
break;
case 34: // DXGI_FORMAT_R16G16_FLOAT:
format = F_rg16;
component_type = T_half_float;
func = read_dds_level_raw;
break;
case 35: // DXGI_FORMAT_R16G16_UNORM:
format = F_rg16;
component_type = T_unsigned_short;
func = read_dds_level_raw;
break;
case 37: // DXGI_FORMAT_R16G16_SNORM:
format = F_rg16;
component_type = T_short;
func = read_dds_level_raw;
break;
case 40: // DXGI_FORMAT_D32_FLOAT
format = F_depth_component32;
component_type = T_float;
func = read_dds_level_raw;
break;
case 41: // DXGI_FORMAT_R32_FLOAT
format = F_r32;
component_type = T_float;
func = read_dds_level_raw;
break;
case 42: // DXGI_FORMAT_R32_UINT
format = F_r32i;
component_type = T_unsigned_int;
func = read_dds_level_raw;
break;
case 43: // DXGI_FORMAT_R32_SINT
format = F_r32i;
component_type = T_int;
func = read_dds_level_raw;
break;
case 48: // DXGI_FORMAT_R8G8_TYPELESS
case 49: // DXGI_FORMAT_R8G8_UNORM
format = F_rg;
break;
case 50: // DXGI_FORMAT_R8G8_UINT
format = F_rg8i;
break;
case 51: // DXGI_FORMAT_R8G8_SNORM
format = F_rg;
component_type = T_byte;
break;
case 52: // DXGI_FORMAT_R8G8_SINT
format = F_rg8i;
component_type = T_byte;
break;
case 54: // DXGI_FORMAT_R16_FLOAT:
format = F_r16;
component_type = T_half_float;
func = read_dds_level_raw;
break;
case 55: // DXGI_FORMAT_D16_UNORM:
format = F_depth_component16;
component_type = T_unsigned_short;
func = read_dds_level_raw;
break;
case 56: // DXGI_FORMAT_R16_UNORM:
format = F_r16;
component_type = T_unsigned_short;
func = read_dds_level_raw;
break;
case 57: // DXGI_FORMAT_R16_UINT:
format = F_r16i;
component_type = T_unsigned_short;
func = read_dds_level_raw;
break;
case 58: // DXGI_FORMAT_R16_SNORM:
format = F_r16;
component_type = T_short;
func = read_dds_level_raw;
break;
case 59: // DXGI_FORMAT_R16_SINT:
format = F_r16i;
component_type = T_short;
func = read_dds_level_raw;
break;
case 60: // DXGI_FORMAT_R8_TYPELESS
case 61: // DXGI_FORMAT_R8_UNORM
format = F_red;
break;
case 62: // DXGI_FORMAT_R8_UINT
format = F_r8i;
break;
case 63: // DXGI_FORMAT_R8_SNORM
format = F_red;
component_type = T_byte;
break;
case 64: // DXGI_FORMAT_R8_SINT
format = F_r8i;
component_type = T_byte;
break;
case 65: // DXGI_FORMAT_A8_UNORM
format = F_alpha;
break;
case 70: // DXGI_FORMAT_BC1_TYPELESS
case 71: // DXGI_FORMAT_BC1_UNORM
format = F_rgb;
compression = CM_dxt1;
func = read_dds_level_bc1;
break;
case 72: // DXGI_FORMAT_BC1_UNORM_SRGB
format = F_srgb;
compression = CM_dxt1;
func = read_dds_level_bc1;
break;
case 73: // DXGI_FORMAT_BC2_TYPELESS
case 74: // DXGI_FORMAT_BC2_UNORM
format = F_rgba;
compression = CM_dxt3;
func = read_dds_level_bc2;
break;
case 75: // DXGI_FORMAT_BC2_UNORM_SRGB
format = F_srgb_alpha;
compression = CM_dxt3;
func = read_dds_level_bc2;
break;
case 76: // DXGI_FORMAT_BC3_TYPELESS
case 77: // DXGI_FORMAT_BC3_UNORM
format = F_rgba;
compression = CM_dxt5;
func = read_dds_level_bc3;
break;
case 78: // DXGI_FORMAT_BC3_UNORM_SRGB
format = F_srgb_alpha;
compression = CM_dxt5;
func = read_dds_level_bc3;
break;
case 79: // DXGI_FORMAT_BC4_TYPELESS
case 80: // DXGI_FORMAT_BC4_UNORM
format = F_red;
compression = CM_rgtc;
func = read_dds_level_bc4;
break;
case 82: // DXGI_FORMAT_BC5_TYPELESS
case 83: // DXGI_FORMAT_BC5_UNORM
format = F_rg;
compression = CM_rgtc;
func = read_dds_level_bc5;
break;
case 87: // DXGI_FORMAT_B8G8R8A8_UNORM
case 90: // DXGI_FORMAT_B8G8R8A8_TYPELESS
format = F_rgba8;
break;
case 88: // DXGI_FORMAT_B8G8R8X8_UNORM
case 92: // DXGI_FORMAT_B8G8R8X8_TYPELESS
format = F_rgb8;
break;
case 91: // DXGI_FORMAT_B8G8R8A8_UNORM_SRGB
format = F_srgb_alpha;
break;
case 93: // DXGI_FORMAT_B8G8R8X8_UNORM_SRGB
format = F_srgb;
break;
case 115: // DXGI_FORMAT_B4G4R4A4_UNORM
format = F_rgba4;
break;
default:
gobj_cat.error()
<< filename << ": unsupported DXGI format " << dxgi_format << ".\n";
return false;
}
switch (dimension) {
case 2: // DDS_DIMENSION_TEXTURE1D
texture_type = TT_1d_texture;
header.depth = 1;
break;
case 3: // DDS_DIMENSION_TEXTURE2D
if (misc_flag & 0x4) { // DDS_RESOURCE_MISC_TEXTURECUBE
if (array_size > 1) {
texture_type = TT_cube_map_array;
header.depth = array_size * 6;
} else {
texture_type = TT_cube_map;
header.depth = 6;
}
} else {
if (array_size > 1) {
texture_type = TT_2d_texture_array;
header.depth = array_size;
} else {
texture_type = TT_2d_texture;
header.depth = 1;
}
}
break;
case 4: // DDS_DIMENSION_TEXTURE3D
texture_type = TT_3d_texture;
break;
default:
gobj_cat.error()
<< filename << ": unsupported dimension.\n";
return false;
}
} else if (header.pf.pf_flags & DDPF_FOURCC) {
// Some compressed texture format.
if (texture_type == TT_3d_texture) {
gobj_cat.error()
<< filename << ": unsupported compression on 3-d texture.\n";
return false;
}
// Most of the compressed formats support alpha.
format = F_rgba;
switch (header.pf.four_cc) {
case 0x31545844: // 'DXT1', little-endian.
compression = CM_dxt1;
func = read_dds_level_bc1;
format = F_rgbm;
break;
case 0x32545844: // 'DXT2'
compression = CM_dxt2;
func = read_dds_level_bc2;
break;
case 0x33545844: // 'DXT3'
compression = CM_dxt3;
func = read_dds_level_bc2;
break;
case 0x34545844: // 'DXT4'
compression = CM_dxt4;
func = read_dds_level_bc3;
break;
case 0x35545844: // 'DXT5'
compression = CM_dxt5;
func = read_dds_level_bc3;
break;
case 0x31495441: // 'ATI1'
case 0x55344342: // 'BC4U'
compression = CM_rgtc;
func = read_dds_level_bc4;
format = F_red;
break;
case 0x32495441: // 'ATI2'
case 0x55354342: // 'BC5U'
compression = CM_rgtc;
func = read_dds_level_bc5;
format = F_rg;
break;
case 36: // D3DFMT_A16B16G16R16
func = read_dds_level_abgr16;
format = F_rgba16;
component_type = T_unsigned_short;
break;
case 110: // D3DFMT_Q16W16V16U16
func = read_dds_level_abgr16;
format = F_rgba16;
component_type = T_short;
break;
case 113: // D3DFMT_A16B16G16R16F
func = read_dds_level_abgr16;
format = F_rgba16;
component_type = T_half_float;
break;
case 116: // D3DFMT_A32B32G32R32F
func = read_dds_level_abgr32;
format = F_rgba32;
component_type = T_float;
break;
default:
gobj_cat.error()
<< filename << ": unsupported texture compression (FourCC: 0x"
<< std::hex << header.pf.four_cc << std::dec << ").\n";
return false;
}
} else {
// An uncompressed texture format.
func = read_dds_level_generic_uncompressed;
if (header.pf.pf_flags & DDPF_ALPHAPIXELS) {
// An uncompressed format that involves alpha.
format = F_rgba;
if (header.pf.rgb_bitcount == 32 &&
header.pf.r_mask == 0x000000ff &&
header.pf.g_mask == 0x0000ff00 &&
header.pf.b_mask == 0x00ff0000 &&
header.pf.a_mask == 0xff000000U) {
func = read_dds_level_abgr8;
} else if (header.pf.rgb_bitcount == 32 &&
header.pf.r_mask == 0x00ff0000 &&
header.pf.g_mask == 0x0000ff00 &&
header.pf.b_mask == 0x000000ff &&
header.pf.a_mask == 0xff000000U) {
func = read_dds_level_rgba8;
} else if (header.pf.r_mask != 0 &&
header.pf.g_mask == 0 &&
header.pf.b_mask == 0) {
func = read_dds_level_luminance_uncompressed;
format = F_luminance_alpha;
}
} else {
// An uncompressed format that doesn't involve alpha.
if (header.pf.rgb_bitcount == 24 &&
header.pf.r_mask == 0x00ff0000 &&
header.pf.g_mask == 0x0000ff00 &&
header.pf.b_mask == 0x000000ff) {
func = read_dds_level_bgr8;
} else if (header.pf.rgb_bitcount == 24 &&
header.pf.r_mask == 0x000000ff &&
header.pf.g_mask == 0x0000ff00 &&
header.pf.b_mask == 0x00ff0000) {
func = read_dds_level_rgb8;
} else if (header.pf.r_mask != 0 &&
header.pf.g_mask == 0 &&
header.pf.b_mask == 0) {
func = read_dds_level_luminance_uncompressed;
format = F_luminance;
}
}
}
do_setup_texture(cdata, texture_type, header.width, header.height, header.depth,
component_type, format);
cdata->_orig_file_x_size = cdata->_x_size;
cdata->_orig_file_y_size = cdata->_y_size;
cdata->_compression = compression;
cdata->_ram_image_compression = compression;
if (!header_only) {
switch (texture_type) {
case TT_3d_texture:
{
// 3-d textures store all the depth slices for mipmap level 0, then
// all the depth slices for mipmap level 1, and so on.
for (int n = 0; n < (int)header.num_levels; ++n) {
int z_size = do_get_expected_mipmap_z_size(cdata, n);
pvector<PTA_uchar> pages;
size_t page_size = 0;
int z;
for (z = 0; z < z_size; ++z) {
PTA_uchar page = func(this, cdata, header, n, in);
if (page.is_null()) {
return false;
}
nassertr(page_size == 0 || page_size == page.size(), false);
page_size = page.size();
pages.push_back(page);
}
// Now reassemble the pages into one big image. Because this is a
// Microsoft format, the images are stacked in reverse order; re-
// reverse them.
PTA_uchar image = PTA_uchar::empty_array(page_size * z_size);
unsigned char *imagep = (unsigned char *)image.p();
for (z = 0; z < z_size; ++z) {
int fz = z_size - 1 - z;
memcpy(imagep + z * page_size, pages[fz].p(), page_size);
}
do_set_ram_mipmap_image(cdata, n, image, page_size);
}
}
break;
case TT_cube_map:
{
// Cube maps store all the mipmap levels for face 0, then all the
// mipmap levels for face 1, and so on.
pvector<pvector<PTA_uchar> > pages;
pages.reserve(6);
int z, n;
for (z = 0; z < 6; ++z) {
pages.push_back(pvector<PTA_uchar>());
pvector<PTA_uchar> &levels = pages.back();
levels.reserve(header.num_levels);
for (n = 0; n < (int)header.num_levels; ++n) {
PTA_uchar image = func(this, cdata, header, n, in);
if (image.is_null()) {
return false;
}
levels.push_back(image);
}
}
// Now, for each level, reassemble the pages into one big image.
// Because this is a Microsoft format, the levels are arranged in a
// rotated order.
static const int level_remap[6] = {
0, 1, 5, 4, 2, 3
};
for (n = 0; n < (int)header.num_levels; ++n) {
size_t page_size = pages[0][n].size();
PTA_uchar image = PTA_uchar::empty_array(page_size * 6);
unsigned char *imagep = (unsigned char *)image.p();
for (z = 0; z < 6; ++z) {
int fz = level_remap[z];
nassertr(pages[fz][n].size() == page_size, false);
memcpy(imagep + z * page_size, pages[fz][n].p(), page_size);
}
do_set_ram_mipmap_image(cdata, n, image, page_size);
}
}
break;
case TT_2d_texture_array:
case TT_cube_map_array: //TODO: rearrange cube map array faces?
{
// Texture arrays store all the mipmap levels for layer 0, then all
// the mipmap levels for layer 1, and so on.
pvector<pvector<PTA_uchar> > pages;
pages.reserve(header.depth);
int z, n;
for (z = 0; z < (int)header.depth; ++z) {
pages.push_back(pvector<PTA_uchar>());
pvector<PTA_uchar> &levels = pages.back();
levels.reserve(header.num_levels);
for (n = 0; n < (int)header.num_levels; ++n) {
PTA_uchar image = func(this, cdata, header, n, in);
if (image.is_null()) {
return false;
}
levels.push_back(image);
}
}
// Now, for each level, reassemble the pages into one big image.
for (n = 0; n < (int)header.num_levels; ++n) {
size_t page_size = pages[0][n].size();
PTA_uchar image = PTA_uchar::empty_array(page_size * header.depth);
unsigned char *imagep = (unsigned char *)image.p();
for (z = 0; z < (int)header.depth; ++z) {
nassertr(pages[z][n].size() == page_size, false);
memcpy(imagep + z * page_size, pages[z][n].p(), page_size);
}
do_set_ram_mipmap_image(cdata, n, image, page_size);
}
}
break;
default:
// Normal 2-d textures simply store the mipmap levels.
{
for (int n = 0; n < (int)header.num_levels; ++n) {
PTA_uchar image = func(this, cdata, header, n, in);
if (image.is_null()) {
return false;
}
do_set_ram_mipmap_image(cdata, n, image, 0);
}
}
}
cdata->_has_read_pages = true;
cdata->_has_read_mipmaps = true;
cdata->_num_mipmap_levels_read = cdata->_ram_images.size();
}
if (in.fail()) {
gobj_cat.error()
<< filename << ": truncated DDS file.\n";
return false;
}
cdata->_loaded_from_image = true;
cdata->_loaded_from_txo = true;
return true;
}
/**
* Called internally when read() detects a KTX file. Assumes the lock is
* already held.
*/
bool Texture::
do_read_ktx_file(CData *cdata, const Filename &fullpath, bool header_only) {
VirtualFileSystem *vfs = VirtualFileSystem::get_global_ptr();
Filename filename = Filename::binary_filename(fullpath);
PT(VirtualFile) file = vfs->get_file(filename);
if (file == nullptr) {
// No such file.
gobj_cat.error()
<< "Could not find " << fullpath << "\n";
return false;
}
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< "Reading KTX file " << filename << "\n";
}
istream *in = file->open_read_file(true);
bool success = do_read_ktx(cdata, *in, fullpath, header_only);
vfs->close_read_file(in);
if (!has_name()) {
set_name(fullpath.get_basename_wo_extension());
}
cdata->_fullpath = fullpath;
cdata->_alpha_fullpath = Filename();
cdata->_keep_ram_image = false;
return success;
}
/**
*
*/
bool Texture::
do_read_ktx(CData *cdata, istream &in, const string &filename, bool header_only) {
StreamReader ktx(in);
unsigned char magic[12];
if (ktx.extract_bytes(magic, 12) != 12 ||
memcmp(magic, "\xABKTX 11\xBB\r\n\x1A\n", 12) != 0) {
gobj_cat.error()
<< filename << " is not a KTX file.\n";
return false;
}
// See: https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/
uint32_t gl_type, /*type_size,*/ gl_format, internal_format, gl_base_format,
width, height, depth, num_array_elements, num_faces, num_mipmap_levels,
kvdata_size;
bool big_endian;
if (ktx.get_uint32() == 0x04030201) {
big_endian = false;
gl_type = ktx.get_uint32();
/*type_size = */ktx.get_uint32();
gl_format = ktx.get_uint32();
internal_format = ktx.get_uint32();
gl_base_format = ktx.get_uint32();
width = ktx.get_uint32();
height = ktx.get_uint32();
depth = ktx.get_uint32();
num_array_elements = ktx.get_uint32();
num_faces = ktx.get_uint32();
num_mipmap_levels = ktx.get_uint32();
kvdata_size = ktx.get_uint32();
} else {
big_endian = true;
gl_type = ktx.get_be_uint32();
/*type_size = */ktx.get_be_uint32();
gl_format = ktx.get_be_uint32();
internal_format = ktx.get_be_uint32();
gl_base_format = ktx.get_be_uint32();
width = ktx.get_be_uint32();
height = ktx.get_be_uint32();
depth = ktx.get_be_uint32();
num_array_elements = ktx.get_be_uint32();
num_faces = ktx.get_be_uint32();
num_mipmap_levels = ktx.get_be_uint32();
kvdata_size = ktx.get_be_uint32();
}
// Skip metadata section.
ktx.skip_bytes(kvdata_size);
ComponentType type;
CompressionMode compression;
Format format;
bool swap_bgr = false;
if (gl_type == 0 || gl_format == 0) {
// Compressed texture.
if (gl_type > 0 || gl_format > 0) {
gobj_cat.error()
<< "Compressed textures must have both type and format set to 0.\n";
return false;
}
type = T_unsigned_byte;
compression = CM_on;
KTXFormat base_format;
switch ((KTXCompressedFormat)internal_format) {
case KTX_COMPRESSED_RED:
format = F_red;
base_format = KTX_RED;
break;
case KTX_COMPRESSED_RG:
format = F_rg;
base_format = KTX_RG;
break;
case KTX_COMPRESSED_RGB:
format = F_rgb;
base_format = KTX_RGB;
break;
case KTX_COMPRESSED_RGBA:
format = F_rgba;
base_format = KTX_RGBA;
break;
case KTX_COMPRESSED_SRGB:
format = F_srgb;
base_format = KTX_SRGB;
break;
case KTX_COMPRESSED_SRGB_ALPHA:
format = F_srgb_alpha;
base_format = KTX_SRGB_ALPHA;
break;
case KTX_COMPRESSED_RGB_FXT1_3DFX:
format = F_rgb;
base_format = KTX_RGB;
compression = CM_fxt1;
break;
case KTX_COMPRESSED_RGBA_FXT1_3DFX:
format = F_rgba;
base_format = KTX_RGBA;
compression = CM_fxt1;
break;
case KTX_COMPRESSED_RGB_S3TC_DXT1:
format = F_rgb;
base_format = KTX_RGB;
compression = CM_dxt1;
break;
case KTX_COMPRESSED_RGBA_S3TC_DXT1:
format = F_rgbm;
base_format = KTX_RGB;
compression = CM_dxt1;
break;
case KTX_COMPRESSED_RGBA_S3TC_DXT3:
format = F_rgba;
base_format = KTX_RGBA;
compression = CM_dxt3;
break;
case KTX_COMPRESSED_RGBA_S3TC_DXT5:
format = F_rgba;
base_format = KTX_RGBA;
compression = CM_dxt5;
break;
case KTX_COMPRESSED_SRGB_ALPHA_S3TC_DXT1:
format = F_srgb_alpha;
base_format = KTX_SRGB_ALPHA;
compression = CM_dxt1;
break;
case KTX_COMPRESSED_SRGB_ALPHA_S3TC_DXT3:
format = F_srgb_alpha;
base_format = KTX_SRGB_ALPHA;
compression = CM_dxt3;
break;
case KTX_COMPRESSED_SRGB_ALPHA_S3TC_DXT5:
format = F_srgb_alpha;
base_format = KTX_SRGB_ALPHA;
compression = CM_dxt5;
break;
case KTX_COMPRESSED_SRGB_S3TC_DXT1:
format = F_srgb;
base_format = KTX_SRGB;
compression = CM_dxt1;
break;
case KTX_COMPRESSED_RED_RGTC1:
case KTX_COMPRESSED_SIGNED_RED_RGTC1:
format = F_red;
base_format = KTX_RED;
compression = CM_rgtc;
break;
case KTX_COMPRESSED_RG_RGTC2:
case KTX_COMPRESSED_SIGNED_RG_RGTC2:
format = F_rg;
base_format = KTX_RG;
compression = CM_rgtc;
break;
case KTX_ETC1_RGB8:
format = F_rgb;
base_format = KTX_RGB;
compression = CM_etc1;
break;
case KTX_ETC1_SRGB8:
format = F_srgb;
base_format = KTX_SRGB;
compression = CM_etc1;
break;
case KTX_COMPRESSED_RGB8_ETC2:
format = F_rgb;
base_format = KTX_RGB;
compression = CM_etc2;
break;
case KTX_COMPRESSED_SRGB8_ETC2:
format = F_srgb;
base_format = KTX_SRGB;
compression = CM_etc2;
break;
case KTX_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
format = F_rgbm;
base_format = KTX_RGBA;
compression = CM_etc2;
break;
case KTX_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
format = F_rgbm;
base_format = KTX_SRGB8_ALPHA8;
compression = CM_etc2;
break;
case KTX_COMPRESSED_RGBA8_ETC2_EAC:
format = F_rgba;
base_format = KTX_RGBA;
compression = CM_etc2;
break;
case KTX_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
format = F_srgb_alpha;
base_format = KTX_SRGB8_ALPHA8;
compression = CM_etc2;
break;
case KTX_COMPRESSED_R11_EAC:
case KTX_COMPRESSED_SIGNED_R11_EAC:
format = F_red;
base_format = KTX_RED;
compression = CM_eac;
break;
case KTX_COMPRESSED_RG11_EAC:
case KTX_COMPRESSED_SIGNED_RG11_EAC:
format = F_rg;
base_format = KTX_RG;
compression = CM_eac;
break;
case KTX_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1:
format = F_srgb_alpha;
base_format = KTX_SRGB_ALPHA;
compression = CM_pvr1_2bpp;
break;
case KTX_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1:
format = F_srgb_alpha;
base_format = KTX_SRGB_ALPHA;
compression = CM_pvr1_4bpp;
break;
case KTX_COMPRESSED_RGBA_BPTC_UNORM:
case KTX_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:
case KTX_COMPRESSED_RGB_BPTC_SIGNED_FLOAT:
case KTX_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT:
default:
gobj_cat.error()
<< filename << " has unsupported compressed internal format " << internal_format << "\n";
return false;
}
if (base_format != gl_base_format) {
gobj_cat.error()
<< filename << " has internal format that is incompatible with base "
"format (0x" << std::hex << gl_base_format << ", expected 0x"
<< base_format << std::dec << ")\n";
return false;
}
} else {
// Uncompressed texture.
compression = CM_off;
switch ((KTXType)gl_type) {
case KTX_BYTE:
type = T_byte;
break;
case KTX_UNSIGNED_BYTE:
type = T_unsigned_byte;
break;
case KTX_SHORT:
type = T_short;
break;
case KTX_UNSIGNED_SHORT:
type = T_unsigned_short;
break;
case KTX_INT:
type = T_int;
break;
case KTX_UNSIGNED_INT:
type = T_unsigned_int;
break;
case KTX_FLOAT:
type = T_float;
break;
case KTX_HALF_FLOAT:
type = T_half_float;
break;
case KTX_UNSIGNED_INT_24_8:
type = T_unsigned_int_24_8;
break;
default:
gobj_cat.error()
<< filename << " has unsupported component type " << gl_type << "\n";
return false;
}
if (gl_format != gl_base_format) {
gobj_cat.error()
<< filename << " has mismatched formats: " << gl_format << " != "
<< gl_base_format << "\n";
}
switch (gl_format) {
case KTX_DEPTH_COMPONENT:
switch (internal_format) {
case KTX_DEPTH_COMPONENT:
format = F_depth_component;
break;
case KTX_DEPTH_COMPONENT16:
format = F_depth_component16;
break;
case KTX_DEPTH_COMPONENT24:
format = F_depth_component24;
break;
case KTX_DEPTH_COMPONENT32:
case KTX_DEPTH_COMPONENT32F:
format = F_depth_component32;
break;
default:
format = F_depth_component;
gobj_cat.warning()
<< filename << " has unsupported depth component format " << internal_format << "\n";
}
break;
case KTX_DEPTH_STENCIL:
format = F_depth_stencil;
if (internal_format != KTX_DEPTH_STENCIL &&
internal_format != KTX_DEPTH24_STENCIL8) {
gobj_cat.warning()
<< filename << " has unsupported depth stencil format " << internal_format << "\n";
}
break;
case KTX_RED:
switch (internal_format) {
case KTX_RED:
case KTX_RED_SNORM:
case KTX_R8:
case KTX_R8_SNORM:
format = F_red;
break;
case KTX_R16:
case KTX_R16_SNORM:
case KTX_R16F:
format = F_r16;
break;
case KTX_R32F:
format = F_r32;
break;
default:
format = F_red;
gobj_cat.warning()
<< filename << " has unsupported red format " << internal_format << "\n";
}
break;
case KTX_RED_INTEGER:
switch (internal_format) {
case KTX_R8I:
case KTX_R8UI:
format = F_r8i;
break;
case KTX_R16I:
case KTX_R16UI:
format = F_r16i;
break;
case KTX_R32I:
case KTX_R32UI:
format = F_r32i;
break;
default:
gobj_cat.error()
<< filename << " has unsupported red integer format " << internal_format << "\n";
return false;
}
break;
case KTX_GREEN:
format = F_green;
if (internal_format != KTX_GREEN) {
gobj_cat.warning()
<< filename << " has unsupported green format " << internal_format << "\n";
}
break;
case KTX_BLUE:
format = F_blue;
if (internal_format != KTX_BLUE) {
gobj_cat.warning()
<< filename << " has unsupported blue format " << internal_format << "\n";
}
break;
case KTX_RG:
switch (internal_format) {
case KTX_RG:
case KTX_RG_SNORM:
case KTX_RG8:
case KTX_RG8_SNORM:
format = F_rg;
break;
case KTX_RG16:
case KTX_RG16_SNORM:
case KTX_RG16F:
format = F_rg16;
break;
case KTX_RG32F:
format = F_rg32;
break;
default:
format = F_rg;
gobj_cat.warning()
<< filename << " has unsupported RG format " << internal_format << "\n";
}
break;
case KTX_RG_INTEGER:
switch (internal_format) {
case KTX_RG8I:
case KTX_RG8UI:
format = F_rg8i;
break;
case KTX_RG16I:
case KTX_RG16UI:
case KTX_RG32I:
case KTX_RG32UI:
default:
gobj_cat.error()
<< filename << " has unsupported RG integer format " << internal_format << "\n";
return false;
}
break;
case KTX_RGB:
swap_bgr = true;
case KTX_BGR:
switch (internal_format) {
case KTX_RGB:
case KTX_RGB_SNORM:
format = F_rgb;
break;
case KTX_RGB5:
format = F_rgb5;
break;
case KTX_RGB12:
format = F_rgb12;
break;
case KTX_R3_G3_B2:
format = F_rgb332;
break;
case KTX_RGB9_E5:
format = F_rgb9_e5;
break;
case KTX_R11F_G11F_B10F:
format = F_r11_g11_b10;
break;
case KTX_RGB8:
case KTX_RGB8_SNORM:
format = F_rgb8;
break;
case KTX_RGB16:
case KTX_RGB16_SNORM:
case KTX_RGB16F:
format = F_rgb16;
break;
case KTX_RGB32F:
format = F_rgb32;
break;
case KTX_SRGB:
case KTX_SRGB8:
format = F_srgb;
break;
default:
format = F_rgb;
gobj_cat.warning()
<< filename << " has unsupported RGB format " << internal_format << "\n";
}
break;
case KTX_RGB_INTEGER:
swap_bgr = true;
case KTX_BGR_INTEGER:
switch (internal_format) {
case KTX_RGB8I:
case KTX_RGB8UI:
format = F_rgb8i;
break;
case KTX_RGB16I:
case KTX_RGB16UI:
case KTX_RGB32I:
case KTX_RGB32UI:
default:
gobj_cat.error()
<< filename << " has unsupported RGB integer format " << internal_format << "\n";
return false;
}
break;
case KTX_RGBA:
swap_bgr = true;
case KTX_BGRA:
switch (internal_format) {
case KTX_RGBA:
case KTX_RGBA_SNORM:
format = F_rgba;
break;
case KTX_RGBA4:
format = F_rgba4;
break;
case KTX_RGB5_A1:
format = F_rgba5;
break;
case KTX_RGBA12:
format = F_rgba12;
break;
case KTX_RGB10_A2:
format = F_rgb10_a2;
break;
case KTX_RGBA8:
case KTX_RGBA8_SNORM:
format = F_rgba8;
break;
case KTX_RGBA16:
case KTX_RGBA16_SNORM:
case KTX_RGBA16F:
format = F_rgba16;
break;
case KTX_RGBA32F:
format = F_rgba32;
break;
case KTX_SRGB_ALPHA:
case KTX_SRGB8_ALPHA8:
format = F_srgb_alpha;
break;
default:
format = F_rgba;
gobj_cat.warning()
<< filename << " has unsupported RGBA format " << internal_format << "\n";
}
break;
break;
case KTX_RGBA_INTEGER:
swap_bgr = true;
case KTX_BGRA_INTEGER:
switch (internal_format) {
case KTX_RGBA8I:
case KTX_RGBA8UI:
format = F_rgba8i;
break;
case KTX_RGBA16I:
case KTX_RGBA16UI:
case KTX_RGBA32I:
case KTX_RGBA32UI:
default:
gobj_cat.error()
<< filename << " has unsupported RGBA integer format " << internal_format << "\n";
return false;
}
break;
case KTX_LUMINANCE:
format = F_luminance;
break;
case KTX_LUMINANCE_ALPHA:
format = F_luminance_alpha;
break;
case KTX_ALPHA:
format = F_alpha;
break;
case KTX_STENCIL_INDEX:
default:
gobj_cat.error()
<< filename << " has unsupported format " << gl_format << "\n";
return false;
}
}
TextureType texture_type;
if (depth > 0) {
texture_type = TT_3d_texture;
} else if (num_faces > 1) {
if (num_faces != 6) {
gobj_cat.error()
<< filename << " has " << num_faces << " cube map faces, expected 6\n";
return false;
}
if (width != height) {
gobj_cat.error()
<< filename << " is cube map, but does not have square dimensions\n";
return false;
}
if (num_array_elements > 0) {
depth = num_array_elements * 6;
texture_type = TT_cube_map_array;
} else {
depth = 6;
texture_type = TT_cube_map;
}
} else if (height > 0) {
if (num_array_elements > 0) {
depth = num_array_elements;
texture_type = TT_2d_texture_array;
} else {
depth = 1;
texture_type = TT_2d_texture;
}
} else if (width > 0) {
depth = 1;
if (num_array_elements > 0) {
height = num_array_elements;
texture_type = TT_1d_texture_array;
} else {
height = 1;
texture_type = TT_1d_texture;
}
} else {
gobj_cat.error()
<< filename << " has zero size\n";
return false;
}
do_setup_texture(cdata, texture_type, width, height, depth, type, format);
cdata->_orig_file_x_size = cdata->_x_size;
cdata->_orig_file_y_size = cdata->_y_size;
cdata->_compression = compression;
cdata->_ram_image_compression = compression;
if (!header_only) {
bool generate_mipmaps = false;
if (num_mipmap_levels == 0) {
generate_mipmaps = true;
num_mipmap_levels = 1;
}
for (uint32_t n = 0; n < num_mipmap_levels; ++n) {
uint32_t image_size;
if (big_endian) {
image_size = ktx.get_be_uint32();
} else {
image_size = ktx.get_uint32();
}
PTA_uchar image;
if (compression == CM_off) {
uint32_t row_size = do_get_expected_mipmap_x_size(cdata, (int)n) * cdata->_num_components * cdata->_component_width;
uint32_t num_rows = do_get_expected_mipmap_y_size(cdata, (int)n) * do_get_expected_mipmap_z_size(cdata, (int)n);
uint32_t row_padded = (row_size + 3) & ~3;
if (image_size == row_size * num_rows) {
if (row_padded != row_size) {
// Someone tightly packed the image. This is invalid, but because
// we like it tightly packed too, we'll read it anyway.
gobj_cat.warning()
<< filename << " does not have proper row padding for mipmap "
"level " << n << "\n";
}
image = PTA_uchar::empty_array(image_size);
ktx.extract_bytes(image.p(), image_size);
} else if (image_size != row_padded * num_rows) {
gobj_cat.error()
<< filename << " has invalid image size " << image_size
<< " for mipmap level " << n << " (expected "
<< row_padded * num_rows << ")\n";
return false;
} else {
// Read it row by row.
image = PTA_uchar::empty_array(row_size * num_rows);
uint32_t skip = row_padded - row_size;
unsigned char *p = image.p();
for (uint32_t row = 0; row < num_rows; ++row) {
ktx.extract_bytes(p, row_size);
ktx.skip_bytes(skip);
p += row_size;
}
}
// Swap red and blue channels if necessary to match Panda conventions.
if (swap_bgr) {
unsigned char *begin = image.p();
const unsigned char *end = image.p() + image.size();
size_t skip = cdata->_num_components;
nassertr(skip == 3 || skip == 4, false);
switch (cdata->_component_width) {
case 1:
for (unsigned char *p = begin; p < end; p += skip) {
swap(p[0], p[2]);
}
break;
case 2:
for (short *p = (short *)begin; p < (short *)end; p += skip) {
swap(p[0], p[2]);
}
break;
case 4:
for (int *p = (int *)begin; p < (int *)end; p += skip) {
swap(p[0], p[2]);
}
break;
default:
nassert_raise("unexpected channel count");
return false;
}
}
do_set_ram_mipmap_image(cdata, (int)n, std::move(image),
row_size * do_get_expected_mipmap_y_size(cdata, (int)n));
} else {
// Compressed image. We'll trust that the file has the right size.
image = PTA_uchar::empty_array(image_size);
ktx.extract_bytes(image.p(), image_size);
do_set_ram_mipmap_image(cdata, (int)n, std::move(image), image_size / depth);
}
ktx.skip_bytes(3 - ((image_size + 3) & 3));
}
cdata->_has_read_pages = true;
cdata->_has_read_mipmaps = true;
cdata->_num_mipmap_levels_read = cdata->_ram_images.size();
if (generate_mipmaps) {
do_generate_ram_mipmap_images(cdata, false);
}
}
if (in.fail()) {
gobj_cat.error()
<< filename << ": truncated KTX file.\n";
return false;
}
cdata->_loaded_from_image = true;
cdata->_loaded_from_txo = true;
return true;
}
/**
* Internal method to write a series of pages and/or mipmap levels to disk
* files.
*/
bool Texture::
do_write(CData *cdata,
const Filename &fullpath, int z, int n, bool write_pages, bool write_mipmaps) {
if (is_txo_filename(fullpath)) {
if (!do_has_bam_rawdata(cdata)) {
do_get_bam_rawdata(cdata);
}
nassertr(do_has_bam_rawdata(cdata), false);
return do_write_txo_file(cdata, fullpath);
}
if (!do_has_uncompressed_ram_image(cdata)) {
do_get_uncompressed_ram_image(cdata);
}
nassertr(do_has_ram_mipmap_image(cdata, n), false);
nassertr(cdata->_ram_image_compression == CM_off, false);
if (write_pages && write_mipmaps) {
// Write a sequence of pages * mipmap levels.
Filename fullpath_pattern = Filename::pattern_filename(fullpath);
int num_levels = cdata->_ram_images.size();
for (int n = 0; n < num_levels; ++n) {
int num_pages = do_get_expected_mipmap_num_pages(cdata, n);
for (z = 0; z < num_pages; ++z) {
Filename n_pattern = Filename::pattern_filename(fullpath_pattern.get_filename_index(z));
if (!n_pattern.has_hash()) {
gobj_cat.error()
<< "Filename requires two different hash sequences: " << fullpath
<< "\n";
return false;
}
if (!do_write_one(cdata, n_pattern.get_filename_index(n), z, n)) {
return false;
}
}
}
} else if (write_pages) {
// Write a sequence of pages.
Filename fullpath_pattern = Filename::pattern_filename(fullpath);
if (!fullpath_pattern.has_hash()) {
gobj_cat.error()
<< "Filename requires a hash mark: " << fullpath
<< "\n";
return false;
}
int num_pages = cdata->_z_size * cdata->_num_views;
for (z = 0; z < num_pages; ++z) {
if (!do_write_one(cdata, fullpath_pattern.get_filename_index(z), z, n)) {
return false;
}
}
} else if (write_mipmaps) {
// Write a sequence of mipmap images.
Filename fullpath_pattern = Filename::pattern_filename(fullpath);
if (!fullpath_pattern.has_hash()) {
gobj_cat.error()
<< "Filename requires a hash mark: " << fullpath
<< "\n";
return false;
}
int num_levels = cdata->_ram_images.size();
for (int n = 0; n < num_levels; ++n) {
if (!do_write_one(cdata, fullpath_pattern.get_filename_index(n), z, n)) {
return false;
}
}
} else {
// Write a single file.
if (!do_write_one(cdata, fullpath, z, n)) {
return false;
}
}
return true;
}
/**
* Internal method to write the indicated page and mipmap level to a disk
* image file.
*/
bool Texture::
do_write_one(CData *cdata, const Filename &fullpath, int z, int n) {
if (!do_has_ram_mipmap_image(cdata, n)) {
return false;
}
nassertr(cdata->_ram_image_compression == CM_off, false);
bool success;
if (cdata->_component_type == T_float) {
// Writing a floating-point texture.
PfmFile pfm;
if (!do_store_one(cdata, pfm, z, n)) {
return false;
}
success = pfm.write(fullpath);
} else {
// Writing a normal, integer texture.
PNMImage pnmimage;
if (!do_store_one(cdata, pnmimage, z, n)) {
return false;
}
success = pnmimage.write(fullpath);
}
if (!success) {
gobj_cat.error()
<< "Texture::write() - couldn't write: " << fullpath << endl;
return false;
}
return true;
}
/**
* Internal method to copy a page and/or mipmap level to a PNMImage.
*/
bool Texture::
do_store_one(CData *cdata, PNMImage &pnmimage, int z, int n) {
// First, reload the ram image if necessary.
do_get_uncompressed_ram_image(cdata);
if (!do_has_ram_mipmap_image(cdata, n)) {
return false;
}
nassertr(z >= 0 && z < do_get_expected_mipmap_num_pages(cdata, n), false);
nassertr(cdata->_ram_image_compression == CM_off, false);
if (cdata->_component_type == T_float) {
// PNMImage by way of PfmFile.
PfmFile pfm;
bool success = convert_to_pfm(pfm,
do_get_expected_mipmap_x_size(cdata, n),
do_get_expected_mipmap_y_size(cdata, n),
cdata->_num_components, cdata->_component_width,
cdata->_ram_images[n]._image,
do_get_ram_mipmap_page_size(cdata, n), z);
if (!success) {
return false;
}
return pfm.store(pnmimage);
}
return convert_to_pnmimage(pnmimage,
do_get_expected_mipmap_x_size(cdata, n),
do_get_expected_mipmap_y_size(cdata, n),
cdata->_num_components, cdata->_component_type,
is_srgb(cdata->_format),
cdata->_ram_images[n]._image,
do_get_ram_mipmap_page_size(cdata, n), z);
}
/**
* Internal method to copy a page and/or mipmap level to a PfmFile.
*/
bool Texture::
do_store_one(CData *cdata, PfmFile &pfm, int z, int n) {
// First, reload the ram image if necessary.
do_get_uncompressed_ram_image(cdata);
if (!do_has_ram_mipmap_image(cdata, n)) {
return false;
}
nassertr(z >= 0 && z < do_get_expected_mipmap_num_pages(cdata, n), false);
nassertr(cdata->_ram_image_compression == CM_off, false);
if (cdata->_component_type != T_float) {
// PfmFile by way of PNMImage.
PNMImage pnmimage;
bool success =
convert_to_pnmimage(pnmimage,
do_get_expected_mipmap_x_size(cdata, n),
do_get_expected_mipmap_y_size(cdata, n),
cdata->_num_components, cdata->_component_type,
is_srgb(cdata->_format),
cdata->_ram_images[n]._image,
do_get_ram_mipmap_page_size(cdata, n), z);
if (!success) {
return false;
}
return pfm.load(pnmimage);
}
return convert_to_pfm(pfm,
do_get_expected_mipmap_x_size(cdata, n),
do_get_expected_mipmap_y_size(cdata, n),
cdata->_num_components, cdata->_component_width,
cdata->_ram_images[n]._image,
do_get_ram_mipmap_page_size(cdata, n), z);
}
/**
* Called internally when write() detects a txo filename.
*/
bool Texture::
do_write_txo_file(const CData *cdata, const Filename &fullpath) const {
VirtualFileSystem *vfs = VirtualFileSystem::get_global_ptr();
Filename filename = Filename::binary_filename(fullpath);
ostream *out = vfs->open_write_file(filename, true, true);
if (out == nullptr) {
gobj_cat.error()
<< "Unable to open " << filename << "\n";
return false;
}
bool success = do_write_txo(cdata, *out, fullpath);
vfs->close_write_file(out);
return success;
}
/**
*
*/
bool Texture::
do_write_txo(const CData *cdata, ostream &out, const string &filename) const {
DatagramOutputFile dout;
if (!dout.open(out, filename)) {
gobj_cat.error()
<< "Could not write texture object: " << filename << "\n";
return false;
}
if (!dout.write_header(_bam_header)) {
gobj_cat.error()
<< "Unable to write to " << filename << "\n";
return false;
}
BamWriter writer(&dout);
if (!writer.init()) {
return false;
}
writer.set_file_texture_mode(BamWriter::BTM_rawdata);
if (!writer.write_object(this)) {
return false;
}
if (!do_has_bam_rawdata(cdata)) {
gobj_cat.error()
<< get_name() << " does not have ram image\n";
return false;
}
return true;
}
/**
* If the texture has a ram image already, this acquires the CData write lock
* and returns it.
*
* If the texture lacks a ram image, this performs do_reload_ram_image(), but
* without holding the lock on this particular Texture object, to avoid
* holding the lock across what might be a slow operation. Instead, the
* reload is performed in a copy of the texture object, and then the lock is
* acquired and the data is copied in.
*
* In any case, the return value is a locked CData object, which must be
* released with an explicit call to release_write(). The CData object will
* have a ram image unless for some reason do_reload_ram_image() fails.
*/
Texture::CData *Texture::
unlocked_ensure_ram_image(bool allow_compression) {
Thread *current_thread = Thread::get_current_thread();
// First, wait for any other threads that might be simultaneously performing
// the same operation.
MutexHolder holder(_lock);
while (_reloading) {
_cvar.wait();
}
// Then make sure we still need to reload before continuing.
const CData *cdata = _cycler.read(current_thread);
bool has_ram_image = do_has_ram_image(cdata);
if (has_ram_image && !allow_compression && cdata->_ram_image_compression != Texture::CM_off) {
// If we don't want compression, but the ram image we have is pre-
// compressed, we don't consider it.
has_ram_image = false;
}
if (has_ram_image || !do_can_reload(cdata)) {
// We don't need to reload after all, or maybe we can't reload anyway.
// Return, but elevate the lock first, as we promised.
return _cycler.elevate_read_upstream(cdata, false, current_thread);
}
// We need to reload.
nassertr(!_reloading, nullptr);
_reloading = true;
PT(Texture) tex = do_make_copy(cdata);
_cycler.release_read(cdata);
_lock.unlock();
// Perform the actual reload in a copy of the texture, while our own mutex
// is left unlocked.
CDWriter cdata_tex(tex->_cycler, true);
tex->do_reload_ram_image(cdata_tex, allow_compression);
_lock.lock();
CData *cdataw = _cycler.write_upstream(false, current_thread);
// Rather than calling do_assign(), which would copy *all* of the reloaded
// texture's properties over, we only copy in the ones which are relevant to
// the ram image. This way, if the properties have changed during the
// reload (for instance, because we reloaded a txo), it won't contaminate
// the original texture.
cdataw->_orig_file_x_size = cdata_tex->_orig_file_x_size;
cdataw->_orig_file_y_size = cdata_tex->_orig_file_y_size;
// If any of *these* properties have changed, the texture has changed in
// some fundamental way. Update it appropriately.
if (cdata_tex->_x_size != cdataw->_x_size ||
cdata_tex->_y_size != cdataw->_y_size ||
cdata_tex->_z_size != cdataw->_z_size ||
cdata_tex->_num_views != cdataw->_num_views ||
cdata_tex->_num_components != cdataw->_num_components ||
cdata_tex->_component_width != cdataw->_component_width ||
cdata_tex->_texture_type != cdataw->_texture_type ||
cdata_tex->_component_type != cdataw->_component_type) {
cdataw->_x_size = cdata_tex->_x_size;
cdataw->_y_size = cdata_tex->_y_size;
cdataw->_z_size = cdata_tex->_z_size;
cdataw->_num_views = cdata_tex->_num_views;
cdataw->_num_components = cdata_tex->_num_components;
cdataw->_component_width = cdata_tex->_component_width;
cdataw->_texture_type = cdata_tex->_texture_type;
cdataw->_format = cdata_tex->_format;
cdataw->_component_type = cdata_tex->_component_type;
cdataw->inc_properties_modified();
cdataw->inc_image_modified();
}
cdataw->_keep_ram_image = cdata_tex->_keep_ram_image;
cdataw->_ram_image_compression = cdata_tex->_ram_image_compression;
cdataw->_ram_images = cdata_tex->_ram_images;
nassertr(_reloading, nullptr);
_reloading = false;
// We don't generally increment the cdata->_image_modified semaphore,
// because this is just a reload, and presumably the image hasn't changed
// (unless we hit the if condition above).
_cvar.notify_all();
// Return the still-locked cdata.
return cdataw;
}
/**
* Called when the Texture image is required but the ram image is not
* available, this will reload it from disk or otherwise do whatever is
* required to make it available, if possible.
*
* Assumes the lock is already held. The lock will be held during the
* duration of this operation.
*/
void Texture::
do_reload_ram_image(CData *cdata, bool allow_compression) {
BamCache *cache = BamCache::get_global_ptr();
PT(BamCacheRecord) record;
if (!do_has_compression(cdata)) {
allow_compression = false;
}
if ((cache->get_cache_textures() || (allow_compression && cache->get_cache_compressed_textures())) && !textures_header_only) {
// See if the texture can be found in the on-disk cache, if it is active.
record = cache->lookup(cdata->_fullpath, "txo");
if (record != nullptr &&
record->has_data()) {
PT(Texture) tex = DCAST(Texture, record->get_data());
// But don't use the cache record if the config parameters have changed,
// and we want a different-sized texture now.
int x_size = cdata->_orig_file_x_size;
int y_size = cdata->_orig_file_y_size;
do_adjust_this_size(cdata, x_size, y_size, cdata->_filename.get_basename(), true);
if (x_size != tex->get_x_size() || y_size != tex->get_y_size()) {
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< "Cached texture " << *this << " has size "
<< tex->get_x_size() << " x " << tex->get_y_size()
<< " instead of " << x_size << " x " << y_size
<< "; ignoring cache.\n";
}
} else {
// Also don't keep the cached version if it's compressed but we want
// uncompressed.
if (!allow_compression && tex->get_ram_image_compression() != Texture::CM_off) {
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< "Cached texture " << *this
<< " is compressed in cache; ignoring cache.\n";
}
} else {
gobj_cat.info()
<< "Texture " << get_name() << " reloaded from disk cache\n";
// We don't want to replace all the texture parameters--for
// instance, we don't want to change the filter type or the border
// color or anything--we just want to get the image and necessary
// associated parameters.
CDReader cdata_tex(tex->_cycler);
cdata->_x_size = cdata_tex->_x_size;
cdata->_y_size = cdata_tex->_y_size;
if (cdata->_num_components != cdata_tex->_num_components) {
cdata->_num_components = cdata_tex->_num_components;
cdata->_format = cdata_tex->_format;
}
cdata->_component_type = cdata_tex->_component_type;
cdata->_compression = cdata_tex->_compression;
cdata->_ram_image_compression = cdata_tex->_ram_image_compression;
cdata->_ram_images = cdata_tex->_ram_images;
cdata->_loaded_from_image = true;
bool was_compressed = (cdata->_ram_image_compression != CM_off);
if (do_consider_auto_process_ram_image(cdata, uses_mipmaps(), allow_compression)) {
bool is_compressed = (cdata->_ram_image_compression != CM_off);
if (!was_compressed && is_compressed &&
cache->get_cache_compressed_textures()) {
// We've re-compressed the image after loading it from the
// cache. To keep the cache current, rewrite it to the cache
// now, in its newly compressed form.
record->set_data(this, this);
cache->store(record);
}
}
return;
}
}
}
}
gobj_cat.info()
<< "Reloading texture " << get_name() << "\n";
int z = 0;
int n = 0;
if (cdata->_has_read_pages) {
z = cdata->_z_size;
}
if (cdata->_has_read_mipmaps) {
n = cdata->_num_mipmap_levels_read;
}
cdata->_loaded_from_image = false;
Format orig_format = cdata->_format;
int orig_num_components = cdata->_num_components;
LoaderOptions options;
if (allow_compression) {
options.set_texture_flags(LoaderOptions::TF_preload |
LoaderOptions::TF_allow_compression);
} else {
options.set_texture_flags(LoaderOptions::TF_preload);
}
do_read(cdata, cdata->_fullpath, cdata->_alpha_fullpath,
cdata->_primary_file_num_channels, cdata->_alpha_file_channel,
z, n, cdata->_has_read_pages, cdata->_has_read_mipmaps, options, nullptr);
if (orig_num_components == cdata->_num_components) {
// Restore the original format, in case it was needlessly changed during
// the reload operation.
cdata->_format = orig_format;
}
if (do_has_ram_image(cdata) && record != nullptr) {
if (cache->get_cache_textures() || (cdata->_ram_image_compression != CM_off && cache->get_cache_compressed_textures())) {
// Update the cache.
if (record != nullptr) {
record->add_dependent_file(cdata->_fullpath);
}
record->set_data(this, this);
cache->store(record);
}
}
}
/**
* This is called internally to uniquify the ram image pointer without
* updating cdata->_image_modified.
*/
PTA_uchar Texture::
do_modify_ram_image(CData *cdata) {
if (cdata->_ram_images.empty() || cdata->_ram_images[0]._image.empty() ||
cdata->_ram_image_compression != CM_off) {
do_make_ram_image(cdata);
} else {
do_clear_ram_mipmap_images(cdata);
}
return cdata->_ram_images[0]._image;
}
/**
* This is called internally to make a new ram image without updating
* cdata->_image_modified.
*/
PTA_uchar Texture::
do_make_ram_image(CData *cdata) {
int image_size = do_get_expected_ram_image_size(cdata);
cdata->_ram_images.clear();
cdata->_ram_images.push_back(RamImage());
cdata->_ram_images[0]._page_size = do_get_expected_ram_page_size(cdata);
cdata->_ram_images[0]._image = PTA_uchar::empty_array(image_size, get_class_type());
cdata->_ram_images[0]._pointer_image = nullptr;
cdata->_ram_image_compression = CM_off;
if (cdata->_has_clear_color) {
// Fill the image with the clear color.
unsigned char pixel[16];
const int pixel_size = do_get_clear_data(cdata, pixel);
nassertr(pixel_size > 0, cdata->_ram_images[0]._image);
unsigned char *image_data = cdata->_ram_images[0]._image;
for (int i = 0; i < image_size; i += pixel_size) {
memcpy(image_data + i, pixel, pixel_size);
}
}
return cdata->_ram_images[0]._image;
}
/**
* Replaces the current system-RAM image with the new data. If compression is
* not CM_off, it indicates that the new data is already pre-compressed in the
* indicated format.
*
* This does *not* affect keep_ram_image.
*/
void Texture::
do_set_ram_image(CData *cdata, CPTA_uchar image, Texture::CompressionMode compression,
size_t page_size) {
nassertv(compression != CM_default);
nassertv(compression != CM_off || image.size() == do_get_expected_ram_image_size(cdata));
if (cdata->_ram_images.empty()) {
cdata->_ram_images.push_back(RamImage());
} else {
do_clear_ram_mipmap_images(cdata);
}
if (page_size == 0) {
page_size = image.size();
}
if (cdata->_ram_images[0]._image != image ||
cdata->_ram_images[0]._page_size != page_size ||
cdata->_ram_image_compression != compression) {
cdata->_ram_images[0]._image = image.cast_non_const();
cdata->_ram_images[0]._page_size = page_size;
cdata->_ram_images[0]._pointer_image = nullptr;
cdata->_ram_image_compression = compression;
cdata->inc_image_modified();
}
}
/**
* This is called internally to uniquify the nth mipmap image pointer without
* updating cdata->_image_modified.
*/
PTA_uchar Texture::
do_modify_ram_mipmap_image(CData *cdata, int n) {
nassertr(cdata->_ram_image_compression == CM_off, PTA_uchar());
if (n >= (int)cdata->_ram_images.size() ||
cdata->_ram_images[n]._image.empty()) {
do_make_ram_mipmap_image(cdata, n);
}
return cdata->_ram_images[n]._image;
}
/**
*
*/
PTA_uchar Texture::
do_make_ram_mipmap_image(CData *cdata, int n) {
nassertr(cdata->_ram_image_compression == CM_off, PTA_uchar(get_class_type()));
while (n >= (int)cdata->_ram_images.size()) {
cdata->_ram_images.push_back(RamImage());
}
size_t image_size = do_get_expected_ram_mipmap_image_size(cdata, n);
cdata->_ram_images[n]._image = PTA_uchar::empty_array(image_size, get_class_type());
cdata->_ram_images[n]._pointer_image = nullptr;
cdata->_ram_images[n]._page_size = do_get_expected_ram_mipmap_page_size(cdata, n);
if (cdata->_has_clear_color) {
// Fill the image with the clear color.
unsigned char pixel[16];
const size_t pixel_size = (size_t)do_get_clear_data(cdata, pixel);
nassertr(pixel_size > 0, cdata->_ram_images[n]._image);
unsigned char *image_data = cdata->_ram_images[n]._image;
for (size_t i = 0; i < image_size; i += pixel_size) {
memcpy(image_data + i, pixel, pixel_size);
}
}
return cdata->_ram_images[n]._image;
}
/**
*
*/
void Texture::
do_set_ram_mipmap_image(CData *cdata, int n, CPTA_uchar image, size_t page_size) {
nassertv(cdata->_ram_image_compression != CM_off || image.size() == do_get_expected_ram_mipmap_image_size(cdata, n));
while (n >= (int)cdata->_ram_images.size()) {
cdata->_ram_images.push_back(RamImage());
}
if (page_size == 0) {
page_size = image.size();
}
if (cdata->_ram_images[n]._image != image ||
cdata->_ram_images[n]._page_size != page_size) {
cdata->_ram_images[n]._image = image.cast_non_const();
cdata->_ram_images[n]._pointer_image = nullptr;
cdata->_ram_images[n]._page_size = page_size;
cdata->inc_image_modified();
}
}
/**
* Returns a string with a single pixel representing the clear color of the
* texture in the format of this texture.
*
* In other words, to create an uncompressed RAM texture filled with the clear
* color, it should be initialized with this string repeated for every pixel.
*/
size_t Texture::
do_get_clear_data(const CData *cdata, unsigned char *into) const {
nassertr(cdata->_has_clear_color, 0);
int num_components = cdata->_num_components;
nassertr(num_components > 0, 0);
nassertr(num_components <= 4, 0);
LVecBase4 clear_value = cdata->_clear_color;
// Swap red and blue components.
if (num_components >= 3) {
std::swap(clear_value[0], clear_value[2]);
}
switch (cdata->_component_type) {
case T_unsigned_byte:
if (is_srgb(cdata->_format)) {
xel color;
xelval alpha;
encode_sRGB_uchar(clear_value, color, alpha);
switch (num_components) {
case 4: into[3] = (unsigned char)alpha;
case 3: into[2] = (unsigned char)color.b;
case 2: into[1] = (unsigned char)color.g;
case 1: into[0] = (unsigned char)color.r;
}
} else {
LColor scaled = clear_value.fmin(LColor(1)).fmax(LColor::zero());
scaled *= 255;
for (int i = 0; i < num_components; ++i) {
into[i] = (unsigned char)scaled[i];
}
}
break;
case T_unsigned_short:
{
LColor scaled = clear_value.fmin(LColor(1)).fmax(LColor::zero());
scaled *= 65535;
for (int i = 0; i < num_components; ++i) {
((unsigned short *)into)[i] = (unsigned short)scaled[i];
}
break;
}
case T_float:
for (int i = 0; i < num_components; ++i) {
((float *)into)[i] = clear_value[i];
}
break;
case T_unsigned_int_24_8:
nassertr(num_components == 1, 0);
*((unsigned int *)into) =
((unsigned int)(clear_value[0] * 16777215) << 8) +
(unsigned int)max(min(clear_value[1], (PN_stdfloat)255), (PN_stdfloat)0);
break;
case T_int:
// Note: there are no 32-bit UNORM textures. Therefore, we don't do any
// normalization here, either.
for (int i = 0; i < num_components; ++i) {
((int *)into)[i] = (int)clear_value[i];
}
break;
case T_byte:
{
LColor scaled = clear_value.fmin(LColor(1)).fmax(LColor(-1));
scaled *= 127;
for (int i = 0; i < num_components; ++i) {
((signed char *)into)[i] = (signed char)scaled[i];
}
break;
}
case T_short:
{
LColor scaled = clear_value.fmin(LColor(1)).fmax(LColor(-1));
scaled *= 32767;
for (int i = 0; i < num_components; ++i) {
((short *)into)[i] = (short)scaled[i];
}
break;
}
case T_half_float:
for (int i = 0; i < num_components; ++i) {
union {
uint32_t ui;
float uf;
} v;
v.uf = clear_value[i];
uint16_t sign = ((v.ui & 0x80000000u) >> 16u);
uint32_t mantissa = (v.ui & 0x007fffffu);
uint16_t exponent = (uint16_t)std::min(std::max((int)((v.ui & 0x7f800000u) >> 23u) - 112, 0), 31);
mantissa += (mantissa & 0x00001000u) << 1u;
((uint16_t *)into)[i] = (uint16_t)(sign | ((exponent << 10u) | (mantissa >> 13u)));
}
break;
case T_unsigned_int:
// Note: there are no 32-bit UNORM textures. Therefore, we don't do any
// normalization here, either.
for (int i = 0; i < num_components; ++i) {
((unsigned int *)into)[i] = (unsigned int)clear_value[i];
}
}
return num_components * cdata->_component_width;
}
/**
* Should be called after a texture has been loaded into RAM, this considers
* generating mipmaps and/or compressing the RAM image.
*
* Returns true if the image was modified by this operation, false if it
* wasn't.
*/
bool Texture::
consider_auto_process_ram_image(bool generate_mipmaps, bool allow_compression) {
CDWriter cdata(_cycler, false);
return do_consider_auto_process_ram_image(cdata, generate_mipmaps, allow_compression);
}
/**
* Should be called after a texture has been loaded into RAM, this considers
* generating mipmaps and/or compressing the RAM image.
*
* Returns true if the image was modified by this operation, false if it
* wasn't.
*/
bool Texture::
do_consider_auto_process_ram_image(CData *cdata, bool generate_mipmaps,
bool allow_compression) {
bool modified = false;
if (generate_mipmaps && !driver_generate_mipmaps &&
cdata->_ram_images.size() == 1) {
do_generate_ram_mipmap_images(cdata, false);
modified = true;
}
if (allow_compression && !driver_compress_textures) {
CompressionMode compression = cdata->_compression;
if (compression == CM_default && compressed_textures) {
compression = CM_on;
}
if (compression != CM_off && cdata->_ram_image_compression == CM_off) {
GraphicsStateGuardianBase *gsg = GraphicsStateGuardianBase::get_default_gsg();
if (do_compress_ram_image(cdata, compression, QL_default, gsg)) {
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< "Compressed " << get_name() << " with "
<< cdata->_ram_image_compression << "\n";
}
modified = true;
}
}
}
return modified;
}
/**
*
*/
bool Texture::
do_compress_ram_image(CData *cdata, Texture::CompressionMode compression,
Texture::QualityLevel quality_level,
GraphicsStateGuardianBase *gsg) {
nassertr(compression != CM_off, false);
if (cdata->_ram_images.empty() || cdata->_ram_image_compression != CM_off) {
return false;
}
if (compression == CM_on) {
// Select an appropriate compression mode automatically.
switch (cdata->_format) {
case Texture::F_rgbm:
case Texture::F_rgb:
case Texture::F_rgb5:
case Texture::F_rgba5:
case Texture::F_rgb8:
case Texture::F_rgb12:
case Texture::F_rgb332:
case Texture::F_rgb16:
case Texture::F_rgb32:
case Texture::F_rgb10_a2:
if (gsg == nullptr || gsg->get_supports_compressed_texture_format(CM_dxt1)) {
compression = CM_dxt1;
} else if (gsg->get_supports_compressed_texture_format(CM_dxt3)) {
compression = CM_dxt3;
} else if (gsg->get_supports_compressed_texture_format(CM_dxt5)) {
compression = CM_dxt5;
} else if (gsg->get_supports_compressed_texture_format(CM_etc2)) {
compression = CM_etc2;
} else if (gsg->get_supports_compressed_texture_format(CM_etc1)) {
compression = CM_etc1;
}
break;
case Texture::F_rgba4:
if (gsg == nullptr || gsg->get_supports_compressed_texture_format(CM_dxt3)) {
compression = CM_dxt3;
} else if (gsg->get_supports_compressed_texture_format(CM_dxt5)) {
compression = CM_dxt5;
} else if (gsg->get_supports_compressed_texture_format(CM_etc2)) {
compression = CM_etc2;
}
break;
case Texture::F_rgba:
case Texture::F_rgba8:
case Texture::F_rgba12:
case Texture::F_rgba16:
case Texture::F_rgba32:
if (gsg == nullptr || gsg->get_supports_compressed_texture_format(CM_dxt5)) {
compression = CM_dxt5;
} else if (gsg->get_supports_compressed_texture_format(CM_etc2)) {
compression = CM_etc2;
}
break;
case Texture::F_red:
case Texture::F_rg:
if (gsg == nullptr || gsg->get_supports_compressed_texture_format(CM_rgtc)) {
compression = CM_rgtc;
} else if (gsg->get_supports_compressed_texture_format(CM_eac)) {
compression = CM_eac;
}
break;
default:
break;
}
}
// Choose an appropriate quality level.
if (quality_level == Texture::QL_default) {
quality_level = cdata->_quality_level;
}
if (quality_level == Texture::QL_default) {
quality_level = texture_quality_level;
}
if (compression == CM_rgtc) {
// We should compress RGTC ourselves, as squish does not support it.
if (cdata->_component_type != T_unsigned_byte) {
return false;
}
if (!do_has_all_ram_mipmap_images(cdata)) {
// If we're about to compress the RAM image, we should ensure that we
// have all of the mipmap levels first.
do_generate_ram_mipmap_images(cdata, false);
}
RamImages compressed_ram_images;
compressed_ram_images.resize(cdata->_ram_images.size());
for (size_t n = 0; n < cdata->_ram_images.size(); ++n) {
const RamImage *uncompressed_image = &cdata->_ram_images[n];
int x_size = do_get_expected_mipmap_x_size(cdata, n);
int y_size = do_get_expected_mipmap_y_size(cdata, n);
int num_pages = do_get_expected_mipmap_num_pages(cdata, n);
// It is important that we handle image sizes that aren't a multiple of
// the block size, since this method may be used to compress mipmaps,
// which go all the way to 1x1. Pad the image if necessary.
RamImage temp_image;
if ((x_size | y_size) & 0x3) {
int virtual_x_size = x_size;
int virtual_y_size = y_size;
x_size = (x_size + 3) & ~0x3;
y_size = (y_size + 3) & ~0x3;
temp_image._page_size = x_size * y_size * cdata->_num_components;
temp_image._image = PTA_uchar::empty_array(temp_image._page_size * num_pages);
for (int z = 0; z < num_pages; ++z) {
unsigned char *dest = temp_image._image.p() + z * temp_image._page_size;
unsigned const char *src = uncompressed_image->_image.p() + z * uncompressed_image->_page_size;
for (int y = 0; y < virtual_y_size; ++y) {
memcpy(dest, src, virtual_x_size);
src += virtual_x_size;
dest += x_size;
}
}
uncompressed_image = &temp_image;
}
// Create a new image to hold the compressed texture pages.
RamImage &compressed_image = compressed_ram_images[n];
compressed_image._page_size = (x_size * y_size * cdata->_num_components) >> 1;
compressed_image._image = PTA_uchar::empty_array(compressed_image._page_size * num_pages);
if (cdata->_num_components == 1) {
do_compress_ram_image_bc4(*uncompressed_image, compressed_image,
x_size, y_size, num_pages);
} else if (cdata->_num_components == 2) {
do_compress_ram_image_bc5(*uncompressed_image, compressed_image,
x_size, y_size, num_pages);
} else {
// Invalid.
return false;
}
}
cdata->_ram_images.swap(compressed_ram_images);
cdata->_ram_image_compression = CM_rgtc;
return true;
}
#ifdef HAVE_SQUISH
if (cdata->_texture_type != TT_3d_texture &&
cdata->_texture_type != TT_2d_texture_array &&
cdata->_component_type == T_unsigned_byte) {
int squish_flags = 0;
switch (compression) {
case CM_dxt1:
squish_flags |= squish::kDxt1;
break;
case CM_dxt3:
squish_flags |= squish::kDxt3;
break;
case CM_dxt5:
squish_flags |= squish::kDxt5;
break;
default:
break;
}
if (squish_flags != 0) {
// This compression mode is supported by squish; use it.
switch (quality_level) {
case QL_fastest:
squish_flags |= squish::kColourRangeFit;
break;
case QL_normal:
// ColourClusterFit is just too slow for everyday use.
squish_flags |= squish::kColourRangeFit;
// squish_flags |= squish::kColourClusterFit;
break;
case QL_best:
squish_flags |= squish::kColourIterativeClusterFit;
break;
default:
break;
}
if (do_squish(cdata, compression, squish_flags)) {
return true;
}
}
}
#endif // HAVE_SQUISH
return false;
}
/**
*
*/
bool Texture::
do_uncompress_ram_image(CData *cdata) {
nassertr(!cdata->_ram_images.empty(), false);
if (cdata->_ram_image_compression == CM_rgtc) {
// We should decompress RGTC ourselves, as squish doesn't support it.
RamImages uncompressed_ram_images;
uncompressed_ram_images.resize(cdata->_ram_images.size());
for (size_t n = 0; n < cdata->_ram_images.size(); ++n) {
const RamImage &compressed_image = cdata->_ram_images[n];
int x_size = do_get_expected_mipmap_x_size(cdata, n);
int y_size = do_get_expected_mipmap_y_size(cdata, n);
int num_pages = do_get_expected_mipmap_num_pages(cdata, n);
RamImage &uncompressed_image = uncompressed_ram_images[n];
uncompressed_image._page_size = do_get_expected_ram_mipmap_page_size(cdata, n);
uncompressed_image._image = PTA_uchar::empty_array(uncompressed_image._page_size * num_pages);
if (cdata->_num_components == 1) {
do_uncompress_ram_image_bc4(compressed_image, uncompressed_image,
x_size, y_size, num_pages);
} else if (cdata->_num_components == 2) {
do_uncompress_ram_image_bc5(compressed_image, uncompressed_image,
x_size, y_size, num_pages);
} else {
// Invalid.
return false;
}
}
cdata->_ram_images.swap(uncompressed_ram_images);
cdata->_ram_image_compression = CM_off;
return true;
}
#ifdef HAVE_SQUISH
if (cdata->_texture_type != TT_3d_texture &&
cdata->_texture_type != TT_2d_texture_array &&
cdata->_component_type == T_unsigned_byte) {
int squish_flags = 0;
switch (cdata->_ram_image_compression) {
case CM_dxt1:
squish_flags |= squish::kDxt1;
break;
case CM_dxt3:
squish_flags |= squish::kDxt3;
break;
case CM_dxt5:
squish_flags |= squish::kDxt5;
break;
default:
break;
}
if (squish_flags != 0) {
// This compression mode is supported by squish; use it.
if (do_unsquish(cdata, squish_flags)) {
return true;
}
}
}
#endif // HAVE_SQUISH
return false;
}
/**
* Compresses a RAM image using BC4 compression.
*/
void Texture::
do_compress_ram_image_bc4(const RamImage &uncompressed_image,
RamImage &compressed_image,
int x_size, int y_size, int num_pages) {
int x_blocks = (x_size >> 2);
int y_blocks = (y_size >> 2);
// NB. This algorithm isn't fully optimal, since it doesn't try to make use
// of the secondary interpolation mode supported by BC4. This is not
// important for most textures, but it may be added in the future.
nassertv((size_t)x_blocks * (size_t)y_blocks * 4 * 4 <= uncompressed_image._page_size);
nassertv((size_t)x_size * (size_t)y_size == uncompressed_image._page_size);
static const int remap[] = {1, 7, 6, 5, 4, 3, 2, 0};
for (int z = 0; z < num_pages; ++z) {
unsigned char *dest = compressed_image._image.p() + z * compressed_image._page_size;
unsigned const char *src = uncompressed_image._image.p() + z * uncompressed_image._page_size;
// Convert one 4 x 4 block at a time.
for (int y = 0; y < y_blocks; ++y) {
for (int x = 0; x < x_blocks; ++x) {
int a, b, c, d;
float fac, add;
unsigned char minv, maxv;
unsigned const char *blk = src;
// Find the minimum and maximum value in the block.
minv = blk[0];
maxv = blk[0];
minv = min(blk[1], minv); maxv = max(blk[1], maxv);
minv = min(blk[2], minv); maxv = max(blk[2], maxv);
minv = min(blk[3], minv); maxv = max(blk[3], maxv);
blk += x_size;
minv = min(blk[0], minv); maxv = max(blk[0], maxv);
minv = min(blk[1], minv); maxv = max(blk[1], maxv);
minv = min(blk[2], minv); maxv = max(blk[2], maxv);
minv = min(blk[3], minv); maxv = max(blk[3], maxv);
blk += x_size;
minv = min(blk[0], minv); maxv = max(blk[0], maxv);
minv = min(blk[1], minv); maxv = max(blk[1], maxv);
minv = min(blk[2], minv); maxv = max(blk[2], maxv);
minv = min(blk[3], minv); maxv = max(blk[3], maxv);
blk += x_size;
minv = min(blk[0], minv); maxv = max(blk[0], maxv);
minv = min(blk[1], minv); maxv = max(blk[1], maxv);
minv = min(blk[2], minv); maxv = max(blk[2], maxv);
minv = min(blk[3], minv); maxv = max(blk[3], maxv);
// Now calculate the index for each pixel.
blk = src;
if (maxv > minv) {
fac = 7.5f / (maxv - minv);
} else {
fac = 0;
}
add = -minv * fac;
a = (remap[(int)(blk[0] * fac + add)])
| (remap[(int)(blk[1] * fac + add)] << 3)
| (remap[(int)(blk[2] * fac + add)] << 6)
| (remap[(int)(blk[3] * fac + add)] << 9);
blk += x_size;
b = (remap[(int)(blk[0] * fac + add)] << 4)
| (remap[(int)(blk[1] * fac + add)] << 7)
| (remap[(int)(blk[2] * fac + add)] << 10)
| (remap[(int)(blk[3] * fac + add)] << 13);
blk += x_size;
c = (remap[(int)(blk[0] * fac + add)])
| (remap[(int)(blk[1] * fac + add)] << 3)
| (remap[(int)(blk[2] * fac + add)] << 6)
| (remap[(int)(blk[3] * fac + add)] << 9);
blk += x_size;
d = (remap[(int)(blk[0] * fac + add)] << 4)
| (remap[(int)(blk[1] * fac + add)] << 7)
| (remap[(int)(blk[2] * fac + add)] << 10)
| (remap[(int)(blk[3] * fac + add)] << 13);
*(dest++) = maxv;
*(dest++) = minv;
*(dest++) = a & 0xff;
*(dest++) = (a >> 8) | (b & 0xf0);
*(dest++) = b >> 8;
*(dest++) = c & 0xff;
*(dest++) = (c >> 8) | (d & 0xf0);
*(dest++) = d >> 8;
// Advance to the beginning of the next 4x4 block.
src += 4;
}
src += x_size * 3;
}
Thread::consider_yield();
}
}
/**
* Compresses a RAM image using BC5 compression.
*/
void Texture::
do_compress_ram_image_bc5(const RamImage &uncompressed_image,
RamImage &compressed_image,
int x_size, int y_size, int num_pages) {
int x_blocks = (x_size >> 2);
int y_blocks = (y_size >> 2);
int stride = x_size * 2;
// BC5 uses the same compression algorithm as BC4, except repeated for two
// channels.
nassertv((size_t)x_blocks * (size_t)y_blocks * 4 * 4 * 2 <= uncompressed_image._page_size);
nassertv((size_t)stride * (size_t)y_size == uncompressed_image._page_size);
static const int remap[] = {1, 7, 6, 5, 4, 3, 2, 0};
for (int z = 0; z < num_pages; ++z) {
unsigned char *dest = compressed_image._image.p() + z * compressed_image._page_size;
unsigned const char *src = uncompressed_image._image.p() + z * uncompressed_image._page_size;
// Convert one 4 x 4 block at a time.
for (int y = 0; y < y_blocks; ++y) {
for (int x = 0; x < x_blocks; ++x) {
int a, b, c, d;
float fac, add;
unsigned char minv, maxv;
unsigned const char *blk = src;
// Find the minimum and maximum red value in the block.
minv = blk[0];
maxv = blk[0];
minv = min(blk[2], minv); maxv = max(blk[2], maxv);
minv = min(blk[4], minv); maxv = max(blk[4], maxv);
minv = min(blk[6], minv); maxv = max(blk[6], maxv);
blk += stride;
minv = min(blk[0], minv); maxv = max(blk[0], maxv);
minv = min(blk[2], minv); maxv = max(blk[2], maxv);
minv = min(blk[4], minv); maxv = max(blk[4], maxv);
minv = min(blk[6], minv); maxv = max(blk[6], maxv);
blk += stride;
minv = min(blk[0], minv); maxv = max(blk[0], maxv);
minv = min(blk[2], minv); maxv = max(blk[2], maxv);
minv = min(blk[4], minv); maxv = max(blk[4], maxv);
minv = min(blk[6], minv); maxv = max(blk[6], maxv);
blk += stride;
minv = min(blk[0], minv); maxv = max(blk[0], maxv);
minv = min(blk[2], minv); maxv = max(blk[2], maxv);
minv = min(blk[4], minv); maxv = max(blk[4], maxv);
minv = min(blk[6], minv); maxv = max(blk[6], maxv);
// Now calculate the index for each pixel.
if (maxv > minv) {
fac = 7.5f / (maxv - minv);
} else {
fac = 0;
}
add = -minv * fac;
blk = src;
a = (remap[(int)(blk[0] * fac + add)])
| (remap[(int)(blk[2] * fac + add)] << 3)
| (remap[(int)(blk[4] * fac + add)] << 6)
| (remap[(int)(blk[6] * fac + add)] << 9);
blk += stride;
b = (remap[(int)(blk[0] * fac + add)] << 4)
| (remap[(int)(blk[2] * fac + add)] << 7)
| (remap[(int)(blk[4] * fac + add)] << 10)
| (remap[(int)(blk[6] * fac + add)] << 13);
blk += stride;
c = (remap[(int)(blk[0] * fac + add)])
| (remap[(int)(blk[2] * fac + add)] << 3)
| (remap[(int)(blk[4] * fac + add)] << 6)
| (remap[(int)(blk[6] * fac + add)] << 9);
blk += stride;
d = (remap[(int)(blk[0] * fac + add)] << 4)
| (remap[(int)(blk[2] * fac + add)] << 7)
| (remap[(int)(blk[4] * fac + add)] << 10)
| (remap[(int)(blk[6] * fac + add)] << 13);
*(dest++) = maxv;
*(dest++) = minv;
*(dest++) = a & 0xff;
*(dest++) = (a >> 8) | (b & 0xf0);
*(dest++) = b >> 8;
*(dest++) = c & 0xff;
*(dest++) = (c >> 8) | (d & 0xf0);
*(dest++) = d >> 8;
// Find the minimum and maximum green value in the block.
blk = src + 1;
minv = blk[0];
maxv = blk[0];
minv = min(blk[2], minv); maxv = max(blk[2], maxv);
minv = min(blk[4], minv); maxv = max(blk[4], maxv);
minv = min(blk[6], minv); maxv = max(blk[6], maxv);
blk += stride;
minv = min(blk[0], minv); maxv = max(blk[0], maxv);
minv = min(blk[2], minv); maxv = max(blk[2], maxv);
minv = min(blk[4], minv); maxv = max(blk[4], maxv);
minv = min(blk[6], minv); maxv = max(blk[6], maxv);
blk += stride;
minv = min(blk[0], minv); maxv = max(blk[0], maxv);
minv = min(blk[2], minv); maxv = max(blk[2], maxv);
minv = min(blk[4], minv); maxv = max(blk[4], maxv);
minv = min(blk[6], minv); maxv = max(blk[6], maxv);
blk += stride;
minv = min(blk[0], minv); maxv = max(blk[0], maxv);
minv = min(blk[2], minv); maxv = max(blk[2], maxv);
minv = min(blk[4], minv); maxv = max(blk[4], maxv);
minv = min(blk[6], minv); maxv = max(blk[6], maxv);
// Now calculate the index for each pixel.
if (maxv > minv) {
fac = 7.5f / (maxv - minv);
} else {
fac = 0;
}
add = -minv * fac;
blk = src + 1;
a = (remap[(int)(blk[0] * fac + add)])
| (remap[(int)(blk[2] * fac + add)] << 3)
| (remap[(int)(blk[4] * fac + add)] << 6)
| (remap[(int)(blk[6] * fac + add)] << 9);
blk += stride;
b = (remap[(int)(blk[0] * fac + add)] << 4)
| (remap[(int)(blk[2] * fac + add)] << 7)
| (remap[(int)(blk[4] * fac + add)] << 10)
| (remap[(int)(blk[6] * fac + add)] << 13);
blk += stride;
c = (remap[(int)(blk[0] * fac + add)])
| (remap[(int)(blk[2] * fac + add)] << 3)
| (remap[(int)(blk[4] * fac + add)] << 6)
| (remap[(int)(blk[6] * fac + add)] << 9);
blk += stride;
d = (remap[(int)(blk[0] * fac + add)] << 4)
| (remap[(int)(blk[2] * fac + add)] << 7)
| (remap[(int)(blk[4] * fac + add)] << 10)
| (remap[(int)(blk[6] * fac + add)] << 13);
*(dest++) = maxv;
*(dest++) = minv;
*(dest++) = a & 0xff;
*(dest++) = (a >> 8) | (b & 0xf0);
*(dest++) = b >> 8;
*(dest++) = c & 0xff;
*(dest++) = (c >> 8) | (d & 0xf0);
*(dest++) = d >> 8;
// Advance to the beginning of the next 4x4 block.
src += 8;
}
src += stride * 3;
}
Thread::consider_yield();
}
}
/**
* Decompresses a RAM image compressed using BC4.
*/
void Texture::
do_uncompress_ram_image_bc4(const RamImage &compressed_image,
RamImage &uncompressed_image,
int x_size, int y_size, int num_pages) {
int x_blocks = (x_size >> 2);
int y_blocks = (y_size >> 2);
for (int z = 0; z < num_pages; ++z) {
unsigned char *dest = uncompressed_image._image.p() + z * uncompressed_image._page_size;
unsigned const char *src = compressed_image._image.p() + z * compressed_image._page_size;
// Unconvert one 4 x 4 block at a time.
uint8_t tbl[8];
for (int y = 0; y < y_blocks; ++y) {
for (int x = 0; x < x_blocks; ++x) {
unsigned char *blk = dest;
tbl[0] = src[0];
tbl[1] = src[1];
if (tbl[0] > tbl[1]) {
tbl[2] = (tbl[0] * 6 + tbl[1] * 1) / 7.0f;
tbl[3] = (tbl[0] * 5 + tbl[1] * 2) / 7.0f;
tbl[4] = (tbl[0] * 4 + tbl[1] * 3) / 7.0f;
tbl[5] = (tbl[0] * 3 + tbl[1] * 4) / 7.0f;
tbl[6] = (tbl[0] * 2 + tbl[1] * 5) / 7.0f;
tbl[7] = (tbl[0] * 1 + tbl[1] * 6) / 7.0f;
} else {
tbl[2] = (tbl[0] * 4 + tbl[1] * 1) / 5.0f;
tbl[3] = (tbl[0] * 3 + tbl[1] * 2) / 5.0f;
tbl[4] = (tbl[0] * 2 + tbl[1] * 3) / 5.0f;
tbl[5] = (tbl[0] * 1 + tbl[1] * 4) / 5.0f;
tbl[6] = 0;
tbl[7] = 255;
}
int v = src[2] + (src[3] << 8) + (src[4] << 16);
blk[0] = tbl[v & 0x7];
blk[1] = tbl[(v & 0x000038) >> 3];
blk[2] = tbl[(v & 0x0001c0) >> 6];
blk[3] = tbl[(v & 0x000e00) >> 9];
blk += x_size;
blk[0] = tbl[(v & 0x007000) >> 12];
blk[1] = tbl[(v & 0x038000) >> 15];
blk[2] = tbl[(v & 0x1c0000) >> 18];
blk[3] = tbl[(v & 0xe00000) >> 21];
blk += x_size;
v = src[5] + (src[6] << 8) + (src[7] << 16);
blk[0] = tbl[v & 0x7];
blk[1] = tbl[(v & 0x000038) >> 3];
blk[2] = tbl[(v & 0x0001c0) >> 6];
blk[3] = tbl[(v & 0x000e00) >> 9];
blk += x_size;
blk[0] = tbl[(v & 0x007000) >> 12];
blk[1] = tbl[(v & 0x038000) >> 15];
blk[2] = tbl[(v & 0x1c0000) >> 18];
blk[3] = tbl[(v & 0xe00000) >> 21];
src += 8;
dest += 4;
}
dest += x_size * 3;
}
Thread::consider_yield();
}
}
/**
* Decompresses a RAM image compressed using BC5.
*/
void Texture::
do_uncompress_ram_image_bc5(const RamImage &compressed_image,
RamImage &uncompressed_image,
int x_size, int y_size, int num_pages) {
int x_blocks = (x_size >> 2);
int y_blocks = (y_size >> 2);
int stride = x_size * 2;
for (int z = 0; z < num_pages; ++z) {
unsigned char *dest = uncompressed_image._image.p() + z * uncompressed_image._page_size;
unsigned const char *src = compressed_image._image.p() + z * compressed_image._page_size;
// Unconvert one 4 x 4 block at a time.
uint8_t red[8];
uint8_t grn[8];
for (int y = 0; y < y_blocks; ++y) {
for (int x = 0; x < x_blocks; ++x) {
unsigned char *blk = dest;
red[0] = src[0];
red[1] = src[1];
if (red[0] > red[1]) {
red[2] = (red[0] * 6 + red[1] * 1) / 7.0f;
red[3] = (red[0] * 5 + red[1] * 2) / 7.0f;
red[4] = (red[0] * 4 + red[1] * 3) / 7.0f;
red[5] = (red[0] * 3 + red[1] * 4) / 7.0f;
red[6] = (red[0] * 2 + red[1] * 5) / 7.0f;
red[7] = (red[0] * 1 + red[1] * 6) / 7.0f;
} else {
red[2] = (red[0] * 4 + red[1] * 1) / 5.0f;
red[3] = (red[0] * 3 + red[1] * 2) / 5.0f;
red[4] = (red[0] * 2 + red[1] * 3) / 5.0f;
red[5] = (red[0] * 1 + red[1] * 4) / 5.0f;
red[6] = 0;
red[7] = 255;
}
grn[0] = src[8];
grn[1] = src[9];
if (grn[0] > grn[1]) {
grn[2] = (grn[0] * 6 + grn[1] * 1) / 7.0f;
grn[3] = (grn[0] * 5 + grn[1] * 2) / 7.0f;
grn[4] = (grn[0] * 4 + grn[1] * 3) / 7.0f;
grn[5] = (grn[0] * 3 + grn[1] * 4) / 7.0f;
grn[6] = (grn[0] * 2 + grn[1] * 5) / 7.0f;
grn[7] = (grn[0] * 1 + grn[1] * 6) / 7.0f;
} else {
grn[2] = (grn[0] * 4 + grn[1] * 1) / 5.0f;
grn[3] = (grn[0] * 3 + grn[1] * 2) / 5.0f;
grn[4] = (grn[0] * 2 + grn[1] * 3) / 5.0f;
grn[5] = (grn[0] * 1 + grn[1] * 4) / 5.0f;
grn[6] = 0;
grn[7] = 255;
}
int r = src[2] + (src[3] << 8) + (src[4] << 16);
int g = src[10] + (src[11] << 8) + (src[12] << 16);
blk[0] = red[r & 0x7];
blk[1] = grn[g & 0x7];
blk[2] = red[(r & 0x000038) >> 3];
blk[3] = grn[(g & 0x000038) >> 3];
blk[4] = red[(r & 0x0001c0) >> 6];
blk[5] = grn[(g & 0x0001c0) >> 6];
blk[6] = red[(r & 0x000e00) >> 9];
blk[7] = grn[(g & 0x000e00) >> 9];
blk += stride;
blk[0] = red[(r & 0x007000) >> 12];
blk[1] = grn[(g & 0x007000) >> 12];
blk[2] = red[(r & 0x038000) >> 15];
blk[3] = grn[(g & 0x038000) >> 15];
blk[4] = red[(r & 0x1c0000) >> 18];
blk[5] = grn[(g & 0x1c0000) >> 18];
blk[6] = red[(r & 0xe00000) >> 21];
blk[7] = grn[(g & 0xe00000) >> 21];
blk += stride;
r = src[5] + (src[6] << 8) + (src[7] << 16);
g = src[13] + (src[14] << 8) + (src[15] << 16);
blk[0] = red[r & 0x7];
blk[1] = grn[g & 0x7];
blk[2] = red[(r & 0x000038) >> 3];
blk[3] = grn[(g & 0x000038) >> 3];
blk[4] = red[(r & 0x0001c0) >> 6];
blk[5] = grn[(g & 0x0001c0) >> 6];
blk[6] = red[(r & 0x000e00) >> 9];
blk[7] = grn[(g & 0x000e00) >> 9];
blk += stride;
blk[0] = red[(r & 0x007000) >> 12];
blk[1] = grn[(g & 0x007000) >> 12];
blk[2] = red[(r & 0x038000) >> 15];
blk[3] = grn[(g & 0x038000) >> 15];
blk[4] = red[(r & 0x1c0000) >> 18];
blk[5] = grn[(g & 0x1c0000) >> 18];
blk[6] = red[(r & 0xe00000) >> 21];
blk[7] = grn[(g & 0xe00000) >> 21];
src += 16;
dest += 8;
}
dest += stride * 3;
}
Thread::consider_yield();
}
}
/**
*
*/
bool Texture::
do_has_all_ram_mipmap_images(const CData *cdata) const {
if (cdata->_ram_images.empty() || cdata->_ram_images[0]._image.empty()) {
// If we don't even have a base image, the answer is no.
return false;
}
if (!uses_mipmaps()) {
// If we have a base image and don't require mipmapping, the answer is
// yes.
return true;
}
// Check that we have enough mipmap levels to meet the size requirements.
int size = max(cdata->_x_size, max(cdata->_y_size, cdata->_z_size));
int n = 0;
int x = 1;
while (x < size) {
x = (x << 1);
++n;
if (n >= (int)cdata->_ram_images.size() || cdata->_ram_images[n]._image.empty()) {
return false;
}
}
return true;
}
/**
* Considers whether the z_size (or num_views) should automatically be
* adjusted when the user loads a new page. Returns true if the z size is
* valid, false otherwise.
*
* Assumes the lock is already held.
*/
bool Texture::
do_reconsider_z_size(CData *cdata, int z, const LoaderOptions &options) {
if (z >= cdata->_z_size * cdata->_num_views) {
bool num_views_specified = true;
if (options.get_texture_flags() & LoaderOptions::TF_multiview) {
// This flag is false if is a multiview texture with a specified number
// of views. It is true if it is not a multiview texture, or if it is
// but the number of views is explicitly specified.
num_views_specified = (options.get_texture_num_views() != 0);
}
if (num_views_specified &&
(cdata->_texture_type == Texture::TT_3d_texture ||
cdata->_texture_type == Texture::TT_2d_texture_array)) {
// If we're loading a page past _z_size, treat it as an implicit request
// to enlarge _z_size. However, this is only legal if this is, in fact,
// a 3-d texture or a 2d texture array (cube maps always have z_size 6,
// and other types have z_size 1).
nassertr(cdata->_num_views != 0, false);
cdata->_z_size = (z / cdata->_num_views) + 1;
} else if (cdata->_z_size != 0) {
// In the case of a 2-d texture or cube map, or a 3-d texture with an
// unspecified _num_views, assume we're loading views of a multiview
// texture.
cdata->_num_views = (z / cdata->_z_size) + 1;
} else {
// The first image loaded sets an implicit z-size.
cdata->_z_size = 1;
}
// Increase the size of the data buffer to make room for the new texture
// level.
do_allocate_pages(cdata);
}
return true;
}
/**
* Called internally by do_reconsider_z_size() to allocate new memory in
* _ram_images[0] for the new number of pages.
*
* Assumes the lock is already held.
*/
void Texture::
do_allocate_pages(CData *cdata) {
size_t new_size = do_get_expected_ram_image_size(cdata);
if (!cdata->_ram_images.empty() &&
!cdata->_ram_images[0]._image.empty() &&
new_size > cdata->_ram_images[0]._image.size()) {
cdata->_ram_images[0]._image.insert(cdata->_ram_images[0]._image.end(), new_size - cdata->_ram_images[0]._image.size(), 0);
nassertv(cdata->_ram_images[0]._image.size() == new_size);
}
}
/**
* Resets the internal Texture properties when a new image file is loaded.
* Returns true if the new image is valid, false otherwise.
*
* Assumes the lock is already held.
*/
bool Texture::
do_reconsider_image_properties(CData *cdata, int x_size, int y_size, int num_components,
Texture::ComponentType component_type, int z,
const LoaderOptions &options) {
if (!cdata->_loaded_from_image || num_components != cdata->_num_components || component_type != cdata->_component_type) {
// Come up with a default format based on the number of channels. But
// only do this the first time the file is loaded, or if the number of
// channels in the image changes on subsequent loads.
// TODO: handle sRGB properly
switch (num_components) {
case 1:
cdata->_format = F_luminance;
break;
case 2:
cdata->_format = F_luminance_alpha;
break;
case 3:
cdata->_format = F_rgb;
break;
case 4:
cdata->_format = F_rgba;
break;
default:
// Eh?
nassert_raise("unexpected channel count");
cdata->_format = F_rgb;
return false;
}
}
if (!cdata->_loaded_from_image) {
if ((options.get_texture_flags() & LoaderOptions::TF_allow_1d) &&
cdata->_texture_type == TT_2d_texture && x_size != 1 && y_size == 1) {
// If we're loading an Nx1 size texture, infer a 1-d texture type.
cdata->_texture_type = TT_1d_texture;
}
#ifndef NDEBUG
switch (cdata->_texture_type) {
case TT_1d_texture:
case TT_buffer_texture:
nassertr(y_size == 1, false);
break;
case TT_cube_map:
case TT_cube_map_array:
nassertr(x_size == y_size, false);
break;
default:
break;
}
#endif
if ((cdata->_x_size != x_size)||(cdata->_y_size != y_size)) {
do_set_pad_size(cdata, 0, 0, 0);
}
cdata->_x_size = x_size;
cdata->_y_size = y_size;
cdata->_num_components = num_components;
do_set_component_type(cdata, component_type);
} else {
if (cdata->_x_size != x_size ||
cdata->_y_size != y_size ||
cdata->_num_components != num_components ||
cdata->_component_type != component_type) {
gobj_cat.error()
<< "Texture properties have changed for texture " << get_name()
<< " page " << z << ".\n";
return false;
}
}
return true;
}
/**
*
*/
bool Texture::
do_rescale_texture(CData *cdata) {
int new_x_size = cdata->_x_size;
int new_y_size = cdata->_y_size;
if (cdata->_z_size * cdata->_num_views != 1) {
nassert_raise("rescale_texture() doesn't support 3-d or multiview textures.");
return false;
}
if (do_adjust_this_size(cdata, new_x_size, new_y_size, get_name(), false)) {
// OK, we have to scale the image.
PNMImage orig_image;
if (!do_store_one(cdata, orig_image, 0, 0)) {
gobj_cat.warning()
<< "Couldn't get image in rescale_texture()\n";
return false;
}
gobj_cat.info()
<< "Resizing " << get_name() << " to " << new_x_size << " x "
<< new_y_size << "\n";
PNMImage new_image(new_x_size, new_y_size, orig_image.get_num_channels(),
orig_image.get_maxval(), orig_image.get_type(),
orig_image.get_color_space());
new_image.quick_filter_from(orig_image);
do_clear_ram_image(cdata);
cdata->inc_image_modified();
cdata->_x_size = new_x_size;
cdata->_y_size = new_y_size;
if (!do_load_one(cdata, new_image, get_name(), 0, 0, LoaderOptions())) {
return false;
}
return true;
}
// Maybe we should pad the image.
int pad_x_size = 0;
int pad_y_size = 0;
if (do_get_auto_texture_scale(cdata) == ATS_pad) {
new_x_size = cdata->_x_size;
new_y_size = cdata->_y_size;
if (do_adjust_this_size(cdata, new_x_size, new_y_size, get_name(), true)) {
pad_x_size = new_x_size - cdata->_x_size;
pad_y_size = new_y_size - cdata->_y_size;
PNMImage orig_image;
if (!do_store_one(cdata, orig_image, 0, 0)) {
gobj_cat.warning()
<< "Couldn't get image in rescale_texture()\n";
return false;
}
PNMImage new_image(new_x_size, new_y_size, orig_image.get_num_channels(),
orig_image.get_maxval(), orig_image.get_type(),
orig_image.get_color_space());
new_image.copy_sub_image(orig_image, 0, new_y_size - orig_image.get_y_size());
do_clear_ram_image(cdata);
cdata->_loaded_from_image = false;
cdata->inc_image_modified();
if (!do_load_one(cdata, new_image, get_name(), 0, 0, LoaderOptions())) {
return false;
}
do_set_pad_size(cdata, pad_x_size, pad_y_size, 0);
return true;
}
}
// No changes needed.
return false;
}
/**
*
*/
PT(Texture) Texture::
make_copy_impl() const {
CDReader cdata(_cycler);
return do_make_copy(cdata);
}
/**
*
*/
PT(Texture) Texture::
do_make_copy(const CData *cdata) const {
PT(Texture) tex = new Texture(get_name());
CDWriter cdata_tex(tex->_cycler, true);
tex->do_assign(cdata_tex, this, cdata);
return tex;
}
/**
* The internal implementation of operator =(). Assumes the lock is already
* held on both Textures.
*/
void Texture::
do_assign(CData *cdata, const Texture *copy, const CData *cdata_copy) {
cdata->do_assign(cdata_copy);
}
/**
* The protected implementation of clear(). Assumes the lock is already held.
*/
void Texture::
do_clear(CData *cdata) {
Texture tex;
tex.local_object();
CDReader cdata_tex(tex._cycler);
do_assign(cdata, &tex, cdata_tex);
cdata->inc_properties_modified();
cdata->inc_image_modified();
cdata->inc_simple_image_modified();
}
/**
*
*/
void Texture::
do_setup_texture(CData *cdata, Texture::TextureType texture_type,
int x_size, int y_size, int z_size,
Texture::ComponentType component_type,
Texture::Format format) {
switch (texture_type) {
case TT_1d_texture:
nassertv(y_size == 1 && z_size == 1);
break;
case TT_2d_texture:
nassertv(z_size == 1);
break;
case TT_3d_texture:
break;
case TT_2d_texture_array:
break;
case TT_cube_map:
// Cube maps must always consist of six square images.
nassertv(x_size == y_size && z_size == 6);
// In principle the wrap mode shouldn't mean anything to a cube map, but
// some drivers seem to misbehave if it's other than
// SamplerState::WM_clamp.
cdata->_default_sampler.set_wrap_u(SamplerState::WM_clamp);
cdata->_default_sampler.set_wrap_v(SamplerState::WM_clamp);
cdata->_default_sampler.set_wrap_w(SamplerState::WM_clamp);
break;
case TT_cube_map_array:
// Cube maps array z_size needs to be a multiple of 6.
nassertv(x_size == y_size && z_size % 6 == 0);
cdata->_default_sampler.set_wrap_u(SamplerState::WM_clamp);
cdata->_default_sampler.set_wrap_v(SamplerState::WM_clamp);
cdata->_default_sampler.set_wrap_w(SamplerState::WM_clamp);
break;
case TT_buffer_texture:
nassertv(y_size == 1 && z_size == 1);
break;
case TT_1d_texture_array:
nassertv(z_size == 1);
break;
}
if (texture_type != TT_2d_texture) {
do_clear_simple_ram_image(cdata);
}
cdata->_texture_type = texture_type;
cdata->_x_size = x_size;
cdata->_y_size = y_size;
cdata->_z_size = z_size;
cdata->_num_views = 1;
do_set_component_type(cdata, component_type);
do_set_format(cdata, format);
do_clear_ram_image(cdata);
do_set_pad_size(cdata, 0, 0, 0);
cdata->_orig_file_x_size = 0;
cdata->_orig_file_y_size = 0;
cdata->_loaded_from_image = false;
cdata->_loaded_from_txo = false;
cdata->_has_read_pages = false;
cdata->_has_read_mipmaps = false;
}
/**
*
*/
void Texture::
do_set_format(CData *cdata, Texture::Format format) {
if (format == cdata->_format) {
return;
}
cdata->_format = format;
cdata->inc_properties_modified();
switch (cdata->_format) {
case F_color_index:
case F_depth_stencil:
case F_depth_component:
case F_depth_component16:
case F_depth_component24:
case F_depth_component32:
case F_red:
case F_green:
case F_blue:
case F_alpha:
case F_luminance:
case F_r16:
case F_r16i:
case F_sluminance:
case F_r32i:
case F_r32:
case F_r8i:
cdata->_num_components = 1;
break;
case F_luminance_alpha:
case F_luminance_alphamask:
case F_rg16:
case F_sluminance_alpha:
case F_rg32:
case F_rg8i:
case F_rg:
cdata->_num_components = 2;
break;
case F_rgb:
case F_rgb5:
case F_rgb8:
case F_rgb12:
case F_rgb332:
case F_rgb16:
case F_srgb:
case F_rgb32:
case F_rgb8i:
case F_r11_g11_b10:
case F_rgb9_e5:
cdata->_num_components = 3;
break;
case F_rgba:
case F_rgbm:
case F_rgba4:
case F_rgba5:
case F_rgba8:
case F_rgba12:
case F_rgba16:
case F_rgba32:
case F_srgb_alpha:
case F_rgba8i:
case F_rgb10_a2:
cdata->_num_components = 4;
break;
}
}
/**
*
*/
void Texture::
do_set_component_type(CData *cdata, Texture::ComponentType component_type) {
cdata->_component_type = component_type;
switch (component_type) {
case T_unsigned_byte:
case T_byte:
cdata->_component_width = 1;
break;
case T_unsigned_short:
case T_short:
case T_half_float:
cdata->_component_width = 2;
break;
case T_float:
case T_unsigned_int_24_8:
case T_int:
case T_unsigned_int:
cdata->_component_width = 4;
break;
}
}
/**
*
*/
void Texture::
do_set_x_size(CData *cdata, int x_size) {
if (cdata->_x_size != x_size) {
cdata->_x_size = x_size;
cdata->inc_image_modified();
do_clear_ram_image(cdata);
do_set_pad_size(cdata, 0, 0, 0);
}
}
/**
*
*/
void Texture::
do_set_y_size(CData *cdata, int y_size) {
if (cdata->_y_size != y_size) {
nassertv((cdata->_texture_type != Texture::TT_buffer_texture &&
cdata->_texture_type != Texture::TT_1d_texture) || y_size == 1);
cdata->_y_size = y_size;
cdata->inc_image_modified();
do_clear_ram_image(cdata);
do_set_pad_size(cdata, 0, 0, 0);
}
}
/**
* Changes the z size indicated for the texture. This also implicitly unloads
* the texture if it has already been loaded.
*/
void Texture::
do_set_z_size(CData *cdata, int z_size) {
if (cdata->_z_size != z_size) {
nassertv((cdata->_texture_type == Texture::TT_3d_texture) ||
(cdata->_texture_type == Texture::TT_cube_map && z_size == 6) ||
(cdata->_texture_type == Texture::TT_cube_map_array && z_size % 6 == 0) ||
(cdata->_texture_type == Texture::TT_2d_texture_array) || (z_size == 1));
cdata->_z_size = z_size;
cdata->inc_image_modified();
do_clear_ram_image(cdata);
do_set_pad_size(cdata, 0, 0, 0);
}
}
/**
*
*/
void Texture::
do_set_num_views(CData *cdata, int num_views) {
nassertv(num_views >= 1);
if (cdata->_num_views != num_views) {
cdata->_num_views = num_views;
if (do_has_ram_image(cdata)) {
cdata->inc_image_modified();
do_clear_ram_image(cdata);
}
do_set_pad_size(cdata, 0, 0, 0);
}
}
/**
*
*/
void Texture::
do_set_wrap_u(CData *cdata, SamplerState::WrapMode wrap) {
if (cdata->_default_sampler.get_wrap_u() != wrap) {
cdata->inc_properties_modified();
cdata->_default_sampler.set_wrap_u(wrap);
}
}
/**
*
*/
void Texture::
do_set_wrap_v(CData *cdata, SamplerState::WrapMode wrap) {
if (cdata->_default_sampler.get_wrap_v() != wrap) {
cdata->inc_properties_modified();
cdata->_default_sampler.set_wrap_v(wrap);
}
}
/**
*
*/
void Texture::
do_set_wrap_w(CData *cdata, SamplerState::WrapMode wrap) {
if (cdata->_default_sampler.get_wrap_w() != wrap) {
cdata->inc_properties_modified();
cdata->_default_sampler.set_wrap_w(wrap);
}
}
/**
*
*/
void Texture::
do_set_minfilter(CData *cdata, SamplerState::FilterType filter) {
if (cdata->_default_sampler.get_minfilter() != filter) {
cdata->inc_properties_modified();
cdata->_default_sampler.set_minfilter(filter);
}
}
/**
*
*/
void Texture::
do_set_magfilter(CData *cdata, SamplerState::FilterType filter) {
if (cdata->_default_sampler.get_magfilter() != filter) {
cdata->inc_properties_modified();
cdata->_default_sampler.set_magfilter(filter);
}
}
/**
*
*/
void Texture::
do_set_anisotropic_degree(CData *cdata, int anisotropic_degree) {
if (cdata->_default_sampler.get_anisotropic_degree() != anisotropic_degree) {
cdata->inc_properties_modified();
cdata->_default_sampler.set_anisotropic_degree(anisotropic_degree);
}
}
/**
*
*/
void Texture::
do_set_border_color(CData *cdata, const LColor &color) {
if (cdata->_default_sampler.get_border_color() != color) {
cdata->inc_properties_modified();
cdata->_default_sampler.set_border_color(color);
}
}
/**
*
*/
void Texture::
do_set_compression(CData *cdata, Texture::CompressionMode compression) {
if (cdata->_compression != compression) {
cdata->inc_properties_modified();
cdata->_compression = compression;
if (do_has_ram_image(cdata)) {
bool has_compression = do_has_compression(cdata);
bool has_ram_image_compression = (cdata->_ram_image_compression != CM_off);
if (has_compression != has_ram_image_compression ||
has_compression) {
// Reload if we're turning compression on or off, or if we're changing
// the compression mode to a different kind of compression.
do_reload(cdata);
}
}
}
}
/**
*
*/
void Texture::
do_set_quality_level(CData *cdata, Texture::QualityLevel quality_level) {
if (cdata->_quality_level != quality_level) {
cdata->inc_properties_modified();
cdata->_quality_level = quality_level;
}
}
/**
*
*/
bool Texture::
do_has_compression(const CData *cdata) const {
if (cdata->_compression == CM_default) {
return compressed_textures;
} else {
return (cdata->_compression != CM_off);
}
}
/**
* The protected implementation of has_ram_image(). Assumes the lock is
* already held.
*/
bool Texture::
do_has_ram_image(const CData *cdata) const {
return !cdata->_ram_images.empty() && !cdata->_ram_images[0]._image.empty();
}
/**
* The protected implementation of has_uncompressed_ram_image(). Assumes the
* lock is already held.
*/
bool Texture::
do_has_uncompressed_ram_image(const CData *cdata) const {
return !cdata->_ram_images.empty() && !cdata->_ram_images[0]._image.empty() && cdata->_ram_image_compression == CM_off;
}
/**
*
*/
CPTA_uchar Texture::
do_get_ram_image(CData *cdata) {
if (!do_has_ram_image(cdata) && do_can_reload(cdata)) {
do_reload_ram_image(cdata, true);
if (do_has_ram_image(cdata)) {
// Normally, we don't update the cdata->_modified semaphores in a
// do_blah method, but we'll make an exception in this case, because
// it's easiest to modify these here, and only when we know it's needed.
cdata->inc_image_modified();
cdata->inc_properties_modified();
}
}
if (cdata->_ram_images.empty()) {
return CPTA_uchar(get_class_type());
}
return cdata->_ram_images[0]._image;
}
/**
*
*/
CPTA_uchar Texture::
do_get_uncompressed_ram_image(CData *cdata) {
if (!cdata->_ram_images.empty() && cdata->_ram_image_compression != CM_off) {
// We have an image in-ram, but it's compressed. Try to uncompress it
// first.
if (do_uncompress_ram_image(cdata)) {
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< "Uncompressed " << get_name() << "\n";
}
return cdata->_ram_images[0]._image;
}
}
// Couldn't uncompress the existing image. Try to reload it.
if ((!do_has_ram_image(cdata) || cdata->_ram_image_compression != CM_off) && do_can_reload(cdata)) {
do_reload_ram_image(cdata, false);
}
if (!cdata->_ram_images.empty() && cdata->_ram_image_compression != CM_off) {
// Great, now we have an image.
if (do_uncompress_ram_image(cdata)) {
gobj_cat.info()
<< "Uncompressed " << get_name() << "\n";
return cdata->_ram_images[0]._image;
}
}
if (cdata->_ram_images.empty() || cdata->_ram_image_compression != CM_off) {
return CPTA_uchar(get_class_type());
}
return cdata->_ram_images[0]._image;
}
/**
* Returns the uncompressed system-RAM image data associated with the texture.
* Rather than just returning a pointer to the data, like
* get_uncompressed_ram_image, this function first processes the data and
* reorders the components using the specified format string, and places these
* into a new char array.
*
* The 'format' argument should specify in which order the components of the
* texture must be. For example, valid format strings are "RGBA", "GA",
* "ABRG" or "AAA". A component can also be written as "0" or "1", which
* means an empty/black or a full/white channel, respectively.
*
* This function is particularly useful to copy an image in-memory to a
* different library (for example, PIL or wxWidgets) that require a different
* component order than Panda's internal format, BGRA. Note, however, that
* this conversion can still be too slow if you want to do it every frame, and
* should thus be avoided for that purpose.
*
* The only requirement for the reordering is that an uncompressed image must
* be available. If the RAM image is compressed, it will attempt to re-load
* the texture from disk, if it doesn't find an uncompressed image there, it
* will return NULL.
*/
CPTA_uchar Texture::
get_ram_image_as(const string &requested_format) {
CDWriter cdata(_cycler, false);
string format = upcase(requested_format);
// Make sure we can grab something that's uncompressed.
CPTA_uchar data = do_get_uncompressed_ram_image(cdata);
if (data == nullptr) {
gobj_cat.error() << "Couldn't find an uncompressed RAM image!\n";
return CPTA_uchar(get_class_type());
}
int imgsize = cdata->_x_size * cdata->_y_size;
nassertr(cdata->_num_components > 0 && cdata->_num_components <= 4, CPTA_uchar(get_class_type()));
nassertr(data.size() == (size_t)(cdata->_component_width * cdata->_num_components * imgsize), CPTA_uchar(get_class_type()));
// Check if the format is already what we have internally.
if ((cdata->_num_components == 1 && format.size() == 1) ||
(cdata->_num_components == 2 && format.size() == 2 && format.at(1) == 'A' && format.at(0) != 'A') ||
(cdata->_num_components == 3 && format == "BGR") ||
(cdata->_num_components == 4 && format == "BGRA")) {
// The format string is already our format, so we just need to copy it.
return CPTA_uchar(data);
}
// Check if we have an alpha channel, and remember which channel we use.
int alpha = -1;
if (Texture::has_alpha(cdata->_format)) {
alpha = cdata->_num_components - 1;
}
// Validate the format beforehand.
for (size_t i = 0; i < format.size(); ++i) {
if (format[i] != 'B' && format[i] != 'G' && format[i] != 'R' &&
format[i] != 'A' && format[i] != '0' && format[i] != '1') {
gobj_cat.error() << "Unexpected component character '"
<< format[i] << "', expected one of RGBA01!\n";
return CPTA_uchar(get_class_type());
}
}
// Create a new empty array that can hold our image.
PTA_uchar newdata = PTA_uchar::empty_array(imgsize * format.size() * cdata->_component_width, get_class_type());
// These ifs are for optimization of commonly used image types.
if (cdata->_component_width == 1) {
if (format == "RGBA" && cdata->_num_components == 4) {
const uint32_t *src = (const uint32_t *)data.p();
uint32_t *dst = (uint32_t *)newdata.p();
for (int p = 0; p < imgsize; ++p) {
uint32_t v = *src++;
*dst++ = ((v & 0xff00ff00u)) |
((v & 0x00ff0000u) >> 16) |
((v & 0x000000ffu) << 16);
}
return newdata;
}
if (format == "RGB" && cdata->_num_components == 4) {
const uint32_t *src = (const uint32_t *)data.p();
uint32_t *dst = (uint32_t *)newdata.p();
// Convert blocks of 4 pixels at a time, so that we can treat both the
// source and destination as 32-bit integers.
int blocks = imgsize >> 2;
for (int i = 0; i < blocks; ++i) {
uint32_t v0 = *src++;
uint32_t v1 = *src++;
uint32_t v2 = *src++;
uint32_t v3 = *src++;
*dst++ = ((v0 & 0x00ff0000u) >> 16) |
((v0 & 0x0000ff00u)) |
((v0 & 0x000000ffu) << 16) |
((v1 & 0x00ff0000u) << 8);
*dst++ = ((v1 & 0x0000ff00u) >> 8) |
((v1 & 0x000000ffu) << 8) |
((v2 & 0x00ff0000u)) |
((v2 & 0x0000ff00u) << 16);
*dst++ = ((v2 & 0x000000ffu)) |
((v3 & 0x00ff0000u) >> 8) |
((v3 & 0x0000ff00u) << 8) |
((v3 & 0x000000ffu) << 24);
}
// If the image size wasn't a multiple of 4, we may have a handful of
// pixels left over. Convert those the slower way.
uint8_t *tail = (uint8_t *)dst;
for (int i = (imgsize & ~0x3); i < imgsize; ++i) {
uint32_t v = *src++;
*tail++ = (v & 0x00ff0000u) >> 16;
*tail++ = (v & 0x0000ff00u) >> 8;
*tail++ = (v & 0x000000ffu);
}
return newdata;
}
if (format == "BGR" && cdata->_num_components == 4) {
const uint32_t *src = (const uint32_t *)data.p();
uint32_t *dst = (uint32_t *)newdata.p();
// Convert blocks of 4 pixels at a time, so that we can treat both the
// source and destination as 32-bit integers.
int blocks = imgsize >> 2;
for (int i = 0; i < blocks; ++i) {
uint32_t v0 = *src++;
uint32_t v1 = *src++;
uint32_t v2 = *src++;
uint32_t v3 = *src++;
*dst++ = (v0 & 0x00ffffffu) | ((v1 & 0x000000ffu) << 24);
*dst++ = ((v1 & 0x00ffff00u) >> 8) | ((v2 & 0x0000ffffu) << 16);
*dst++ = ((v2 & 0x00ff0000u) >> 16) | ((v3 & 0x00ffffffu) << 8);
}
// If the image size wasn't a multiple of 4, we may have a handful of
// pixels left over. Convert those the slower way.
uint8_t *tail = (uint8_t *)dst;
for (int i = (imgsize & ~0x3); i < imgsize; ++i) {
uint32_t v = *src++;
*tail++ = (v & 0x000000ffu);
*tail++ = (v & 0x0000ff00u) >> 8;
*tail++ = (v & 0x00ff0000u) >> 16;
}
return newdata;
}
const uint8_t *src = (const uint8_t *)data.p();
uint8_t *dst = (uint8_t *)newdata.p();
if (format == "RGB" && cdata->_num_components == 3) {
for (int i = 0; i < imgsize; ++i) {
*dst++ = src[2];
*dst++ = src[1];
*dst++ = src[0];
src += 3;
}
return newdata;
}
if (format == "A" && cdata->_num_components != 3) {
// We can generally rely on alpha to be the last component.
for (int p = 0; p < imgsize; ++p) {
dst[p] = src[alpha];
src += cdata->_num_components;
}
return newdata;
}
// Fallback case for other 8-bit-per-channel formats.
for (int p = 0; p < imgsize; ++p) {
for (size_t i = 0; i < format.size(); ++i) {
if (format[i] == 'B' || (cdata->_num_components <= 2 && format[i] != 'A')) {
*dst++ = src[0];
} else if (format[i] == 'G') {
*dst++ = src[1];
} else if (format[i] == 'R') {
*dst++ = src[2];
} else if (format[i] == 'A') {
if (alpha >= 0) {
*dst++ = src[alpha];
} else {
*dst++ = 0xff;
}
} else if (format[i] == '1') {
*dst++ = 0xff;
} else {
*dst++ = 0x00;
}
}
src += cdata->_num_components;
}
return newdata;
}
// The slow and general case.
for (int p = 0; p < imgsize; ++p) {
for (size_t i = 0; i < format.size(); ++i) {
int component = 0;
if (format[i] == 'B' || (cdata->_num_components <= 2 && format[i] != 'A')) {
component = 0;
} else if (format[i] == 'G') {
component = 1;
} else if (format[i] == 'R') {
component = 2;
} else if (format[i] == 'A') {
if (alpha >= 0) {
component = alpha;
} else {
memset((void*)(newdata + (p * format.size() + i) * cdata->_component_width), -1, cdata->_component_width);
continue;
}
} else if (format[i] == '1') {
memset((void*)(newdata + (p * format.size() + i) * cdata->_component_width), -1, cdata->_component_width);
continue;
} else {
memset((void*)(newdata + (p * format.size() + i) * cdata->_component_width), 0, cdata->_component_width);
continue;
}
memcpy((void*)(newdata + (p * format.size() + i) * cdata->_component_width),
(void*)(data + (p * cdata->_num_components + component) * cdata->_component_width),
cdata->_component_width);
}
}
return newdata;
}
/**
*
*/
void Texture::
do_set_simple_ram_image(CData *cdata, CPTA_uchar image, int x_size, int y_size) {
nassertv(cdata->_texture_type == TT_2d_texture);
size_t expected_page_size = (size_t)(x_size * y_size * 4);
nassertv(image.size() == expected_page_size);
cdata->_simple_x_size = x_size;
cdata->_simple_y_size = y_size;
cdata->_simple_ram_image._image = image.cast_non_const();
cdata->_simple_ram_image._page_size = image.size();
cdata->_simple_image_date_generated = (int32_t)time(nullptr);
cdata->inc_simple_image_modified();
}
/**
*
*/
int Texture::
do_get_expected_num_mipmap_levels(const CData *cdata) const {
if (cdata->_texture_type == Texture::TT_buffer_texture) {
return 1;
}
int size = max(cdata->_x_size, cdata->_y_size);
if (cdata->_texture_type == Texture::TT_3d_texture) {
size = max(size, cdata->_z_size);
}
int count = 1;
while (size > 1) {
size >>= 1;
++count;
}
return count;
}
/**
*
*/
size_t Texture::
do_get_ram_mipmap_page_size(const CData *cdata, int n) const {
if (cdata->_ram_image_compression != CM_off) {
if (n >= 0 && n < (int)cdata->_ram_images.size()) {
return cdata->_ram_images[n]._page_size;
}
return 0;
} else {
return do_get_expected_ram_mipmap_page_size(cdata, n);
}
}
/**
*
*/
int Texture::
do_get_expected_mipmap_x_size(const CData *cdata, int n) const {
int size = max(cdata->_x_size, 1);
while (n > 0 && size > 1) {
size >>= 1;
--n;
}
return size;
}
/**
*
*/
int Texture::
do_get_expected_mipmap_y_size(const CData *cdata, int n) const {
int size = max(cdata->_y_size, 1);
while (n > 0 && size > 1) {
size >>= 1;
--n;
}
return size;
}
/**
*
*/
int Texture::
do_get_expected_mipmap_z_size(const CData *cdata, int n) const {
// 3-D textures have a different number of pages per each mipmap level.
// Other kinds of textures--especially, cube map textures--always have the
// same.
if (cdata->_texture_type == Texture::TT_3d_texture) {
int size = max(cdata->_z_size, 1);
while (n > 0 && size > 1) {
size >>= 1;
--n;
}
return size;
} else {
return cdata->_z_size;
}
}
/**
*
*/
void Texture::
do_clear_simple_ram_image(CData *cdata) {
cdata->_simple_x_size = 0;
cdata->_simple_y_size = 0;
cdata->_simple_ram_image._image.clear();
cdata->_simple_ram_image._page_size = 0;
cdata->_simple_image_date_generated = 0;
// We allow this exception: we update the _simple_image_modified here, since
// no one really cares much about that anyway, and it's convenient to do it
// here.
cdata->inc_simple_image_modified();
}
/**
*
*/
void Texture::
do_clear_ram_mipmap_images(CData *cdata) {
if (!cdata->_ram_images.empty()) {
cdata->_ram_images.erase(cdata->_ram_images.begin() + 1, cdata->_ram_images.end());
}
}
/**
* Generates the RAM mipmap images for this texture, first uncompressing it as
* required. Will recompress the image if it was originally compressed,
* unless allow_recompress is true.
*/
void Texture::
do_generate_ram_mipmap_images(CData *cdata, bool allow_recompress) {
nassertv(do_has_ram_image(cdata));
if (do_get_expected_num_mipmap_levels(cdata) == 1) {
// Don't bother.
return;
}
RamImage orig_compressed_image;
CompressionMode orig_compression_mode = CM_off;
if (cdata->_ram_image_compression != CM_off) {
// The RAM image is compressed. This means we need to uncompress it in
// order to generate mipmap images. Save the original first, to avoid
// lossy recompression.
orig_compressed_image = cdata->_ram_images[0];
orig_compression_mode = cdata->_ram_image_compression;
// Now try to get the uncompressed source image.
do_get_uncompressed_ram_image(cdata);
if (cdata->_ram_image_compression != CM_off) {
gobj_cat.error()
<< "Cannot generate mipmap levels for image with compression "
<< cdata->_ram_image_compression << "\n";
return;
}
}
do_clear_ram_mipmap_images(cdata);
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< "Generating mipmap levels for " << *this << "\n";
}
if (cdata->_texture_type == Texture::TT_3d_texture && cdata->_z_size != 1) {
// Eek, a 3-D texture.
int x_size = cdata->_x_size;
int y_size = cdata->_y_size;
int z_size = cdata->_z_size;
int n = 0;
while (x_size > 1 || y_size > 1 || z_size > 1) {
cdata->_ram_images.push_back(RamImage());
do_filter_3d_mipmap_level(cdata, cdata->_ram_images[n + 1], cdata->_ram_images[n],
x_size, y_size, z_size);
x_size = max(x_size >> 1, 1);
y_size = max(y_size >> 1, 1);
z_size = max(z_size >> 1, 1);
++n;
}
} else {
// A 1-D, 2-D, or cube map texture.
int x_size = cdata->_x_size;
int y_size = cdata->_y_size;
int n = 0;
while (x_size > 1 || y_size > 1) {
cdata->_ram_images.push_back(RamImage());
do_filter_2d_mipmap_pages(cdata, cdata->_ram_images[n + 1], cdata->_ram_images[n],
x_size, y_size);
x_size = max(x_size >> 1, 1);
y_size = max(y_size >> 1, 1);
++n;
}
}
if (orig_compression_mode != CM_off && allow_recompress) {
// Now attempt to recompress the mipmap images according to the original
// compression mode. We don't need to bother compressing the first image
// (it was already compressed, after all), so temporarily remove it from
// the top of the mipmap stack, and compress all of the rest of them
// instead.
nassertv(cdata->_ram_images.size() > 1);
int l0_x_size = cdata->_x_size;
int l0_y_size = cdata->_y_size;
int l0_z_size = cdata->_z_size;
cdata->_x_size = do_get_expected_mipmap_x_size(cdata, 1);
cdata->_y_size = do_get_expected_mipmap_y_size(cdata, 1);
cdata->_z_size = do_get_expected_mipmap_z_size(cdata, 1);
RamImage uncompressed_image = cdata->_ram_images[0];
cdata->_ram_images.erase(cdata->_ram_images.begin());
bool success = do_compress_ram_image(cdata, orig_compression_mode, QL_default, nullptr);
// Now restore the toplevel image.
if (success) {
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< "Compressed " << get_name() << " generated mipmaps with "
<< cdata->_ram_image_compression << "\n";
}
cdata->_ram_images.insert(cdata->_ram_images.begin(), orig_compressed_image);
} else {
cdata->_ram_images.insert(cdata->_ram_images.begin(), uncompressed_image);
}
cdata->_x_size = l0_x_size;
cdata->_y_size = l0_y_size;
cdata->_z_size = l0_z_size;
}
}
/**
*
*/
void Texture::
do_set_pad_size(CData *cdata, int x, int y, int z) {
if (x > cdata->_x_size) {
x = cdata->_x_size;
}
if (y > cdata->_y_size) {
y = cdata->_y_size;
}
if (z > cdata->_z_size) {
z = cdata->_z_size;
}
cdata->_pad_x_size = x;
cdata->_pad_y_size = y;
cdata->_pad_z_size = z;
}
/**
* Returns true if we can safely call do_reload_ram_image() in order to make
* the image available, or false if we shouldn't do this (because we know from
* a priori knowledge that it wouldn't work anyway).
*/
bool Texture::
do_can_reload(const CData *cdata) const {
return (cdata->_loaded_from_image && !cdata->_fullpath.empty());
}
/**
*
*/
bool Texture::
do_reload(CData *cdata) {
if (do_can_reload(cdata)) {
do_clear_ram_image(cdata);
do_reload_ram_image(cdata, true);
if (do_has_ram_image(cdata)) {
// An explicit call to reload() should increment image_modified.
cdata->inc_image_modified();
return true;
}
return false;
}
// We don't have a filename to load from.
return false;
}
/**
* Returns true if there is a rawdata image that we have available to write to
* the bam stream. For a normal Texture, this is the same thing as
* do_has_ram_image(), but a movie texture might define it differently.
*/
bool Texture::
do_has_bam_rawdata(const CData *cdata) const {
return do_has_ram_image(cdata);
}
/**
* If do_has_bam_rawdata() returned false, this attempts to reload the rawdata
* image if possible.
*/
void Texture::
do_get_bam_rawdata(CData *cdata) {
do_get_ram_image(cdata);
}
/**
* Internal method to convert pixel data from the indicated PNMImage into the
* given ram_image.
*/
void Texture::
convert_from_pnmimage(PTA_uchar &image, size_t page_size,
int row_stride, int x, int y, int z,
const PNMImage &pnmimage, int num_components,
int component_width) {
int x_size = pnmimage.get_x_size();
int y_size = pnmimage.get_y_size();
xelval maxval = pnmimage.get_maxval();
int pixel_size = num_components * component_width;
int row_skip = 0;
if (row_stride == 0) {
row_stride = x_size;
} else {
row_skip = (row_stride - x_size) * pixel_size;
nassertv(row_skip >= 0);
}
bool is_grayscale = (num_components == 1 || num_components == 2);
bool has_alpha = (num_components == 2 || num_components == 4);
bool img_has_alpha = pnmimage.has_alpha();
int idx = page_size * z;
nassertv(idx + page_size <= image.size());
unsigned char *p = &image[idx];
if (x != 0 || y != 0) {
p += (row_stride * y + x) * pixel_size;
}
if (maxval == 255 && component_width == 1) {
// Most common case: one byte per pixel, and the source image shows a
// maxval of 255. No scaling is necessary. Because this is such a common
// case, we break it out per component for best performance.
const xel *array = pnmimage.get_array();
switch (num_components) {
case 1:
for (int j = y_size-1; j >= 0; j--) {
const xel *row = array + j * x_size;
for (int i = 0; i < x_size; i++) {
*p++ = (uchar)PPM_GETB(row[i]);
}
p += row_skip;
}
break;
case 2:
if (img_has_alpha) {
const xelval *alpha = pnmimage.get_alpha_array();
for (int j = y_size-1; j >= 0; j--) {
const xel *row = array + j * x_size;
const xelval *alpha_row = alpha + j * x_size;
for (int i = 0; i < x_size; i++) {
*p++ = (uchar)PPM_GETB(row[i]);
*p++ = (uchar)alpha_row[i];
}
p += row_skip;
}
} else {
for (int j = y_size-1; j >= 0; j--) {
const xel *row = array + j * x_size;
for (int i = 0; i < x_size; i++) {
*p++ = (uchar)PPM_GETB(row[i]);
*p++ = (uchar)255;
}
p += row_skip;
}
}
break;
case 3:
for (int j = y_size-1; j >= 0; j--) {
const xel *row = array + j * x_size;
for (int i = 0; i < x_size; i++) {
*p++ = (uchar)PPM_GETB(row[i]);
*p++ = (uchar)PPM_GETG(row[i]);
*p++ = (uchar)PPM_GETR(row[i]);
}
p += row_skip;
}
break;
case 4:
if (img_has_alpha) {
const xelval *alpha = pnmimage.get_alpha_array();
for (int j = y_size-1; j >= 0; j--) {
const xel *row = array + j * x_size;
const xelval *alpha_row = alpha + j * x_size;
for (int i = 0; i < x_size; i++) {
*p++ = (uchar)PPM_GETB(row[i]);
*p++ = (uchar)PPM_GETG(row[i]);
*p++ = (uchar)PPM_GETR(row[i]);
*p++ = (uchar)alpha_row[i];
}
p += row_skip;
}
} else {
for (int j = y_size-1; j >= 0; j--) {
const xel *row = array + j * x_size;
for (int i = 0; i < x_size; i++) {
*p++ = (uchar)PPM_GETB(row[i]);
*p++ = (uchar)PPM_GETG(row[i]);
*p++ = (uchar)PPM_GETR(row[i]);
*p++ = (uchar)255;
}
p += row_skip;
}
}
break;
default:
nassertv(num_components >= 1 && num_components <= 4);
break;
}
} else if (maxval == 65535 && component_width == 2) {
// Another possible case: two bytes per pixel, and the source image shows
// a maxval of 65535. Again, no scaling is necessary.
for (int j = y_size-1; j >= 0; j--) {
for (int i = 0; i < x_size; i++) {
if (is_grayscale) {
store_unscaled_short(p, pnmimage.get_gray_val(i, j));
} else {
store_unscaled_short(p, pnmimage.get_blue_val(i, j));
store_unscaled_short(p, pnmimage.get_green_val(i, j));
store_unscaled_short(p, pnmimage.get_red_val(i, j));
}
if (has_alpha) {
if (img_has_alpha) {
store_unscaled_short(p, pnmimage.get_alpha_val(i, j));
} else {
store_unscaled_short(p, 65535);
}
}
}
p += row_skip;
}
} else if (component_width == 1) {
// A less common case: one byte per pixel, but the maxval is something
// other than 255. In this case, we should scale the pixel values up to
// the appropriate amount.
double scale = 255.0 / (double)maxval;
for (int j = y_size-1; j >= 0; j--) {
for (int i = 0; i < x_size; i++) {
if (is_grayscale) {
store_scaled_byte(p, pnmimage.get_gray_val(i, j), scale);
} else {
store_scaled_byte(p, pnmimage.get_blue_val(i, j), scale);
store_scaled_byte(p, pnmimage.get_green_val(i, j), scale);
store_scaled_byte(p, pnmimage.get_red_val(i, j), scale);
}
if (has_alpha) {
if (img_has_alpha) {
store_scaled_byte(p, pnmimage.get_alpha_val(i, j), scale);
} else {
store_unscaled_byte(p, 255);
}
}
}
p += row_skip;
}
} else { // component_width == 2
// Another uncommon case: two bytes per pixel, and the maxval is something
// other than 65535. Again, we must scale the pixel values.
double scale = 65535.0 / (double)maxval;
for (int j = y_size-1; j >= 0; j--) {
for (int i = 0; i < x_size; i++) {
if (is_grayscale) {
store_scaled_short(p, pnmimage.get_gray_val(i, j), scale);
} else {
store_scaled_short(p, pnmimage.get_blue_val(i, j), scale);
store_scaled_short(p, pnmimage.get_green_val(i, j), scale);
store_scaled_short(p, pnmimage.get_red_val(i, j), scale);
}
if (has_alpha) {
if (img_has_alpha) {
store_scaled_short(p, pnmimage.get_alpha_val(i, j), 1.0);
} else {
store_unscaled_short(p, 65535);
}
}
}
p += row_skip;
}
}
}
/**
* Internal method to convert pixel data from the indicated PfmFile into the
* given ram_image.
*/
void Texture::
convert_from_pfm(PTA_uchar &image, size_t page_size, int z,
const PfmFile &pfm, int num_components, int component_width) {
nassertv(component_width == 4); // Currently only PN_float32 is expected.
int x_size = pfm.get_x_size();
int y_size = pfm.get_y_size();
int idx = page_size * z;
nassertv(idx + page_size <= image.size());
PN_float32 *p = (PN_float32 *)&image[idx];
switch (num_components) {
case 1:
{
for (int j = y_size-1; j >= 0; j--) {
for (int i = 0; i < x_size; i++) {
p[0] = pfm.get_channel(i, j, 0);
++p;
}
}
}
break;
case 2:
{
for (int j = y_size-1; j >= 0; j--) {
for (int i = 0; i < x_size; i++) {
p[0] = pfm.get_channel(i, j, 0);
p[1] = pfm.get_channel(i, j, 1);
p += 2;
}
}
}
break;
case 3:
{
// RGB -> BGR
for (int j = y_size-1; j >= 0; j--) {
for (int i = 0; i < x_size; i++) {
p[0] = pfm.get_channel(i, j, 2);
p[1] = pfm.get_channel(i, j, 1);
p[2] = pfm.get_channel(i, j, 0);
p += 3;
}
}
}
break;
case 4:
{
// RGBA -> BGRA
for (int j = y_size-1; j >= 0; j--) {
for (int i = 0; i < x_size; i++) {
p[0] = pfm.get_channel(i, j, 2);
p[1] = pfm.get_channel(i, j, 1);
p[2] = pfm.get_channel(i, j, 0);
p[3] = pfm.get_channel(i, j, 3);
p += 4;
}
}
}
break;
default:
nassert_raise("unexpected channel count");
return;
}
nassertv((unsigned char *)p == &image[idx] + page_size);
}
/**
* Internal method to convert pixel data to the indicated PNMImage from the
* given ram_image.
*/
bool Texture::
convert_to_pnmimage(PNMImage &pnmimage, int x_size, int y_size,
int num_components, ComponentType component_type,
bool is_srgb, CPTA_uchar image, size_t page_size, int z) {
xelval maxval = 0xff;
if (component_type != T_unsigned_byte && component_type != T_byte) {
maxval = 0xffff;
}
ColorSpace color_space = is_srgb ? CS_sRGB : CS_linear;
pnmimage.clear(x_size, y_size, num_components, maxval, nullptr, color_space);
bool has_alpha = pnmimage.has_alpha();
bool is_grayscale = pnmimage.is_grayscale();
int idx = page_size * z;
nassertr(idx + page_size <= image.size(), false);
xel *array = pnmimage.get_array();
xelval *alpha = pnmimage.get_alpha_array();
switch (component_type) {
case T_unsigned_byte:
if (is_grayscale) {
const unsigned char *p = &image[idx];
if (has_alpha) {
for (int j = y_size-1; j >= 0; j--) {
xel *row = array + j * x_size;
xelval *alpha_row = alpha + j * x_size;
for (int i = 0; i < x_size; i++) {
PPM_PUTB(row[i], *p++);
alpha_row[i] = *p++;
}
}
} else {
for (int j = y_size-1; j >= 0; j--) {
xel *row = array + j * x_size;
for (int i = 0; i < x_size; i++) {
PPM_PUTB(row[i], *p++);
}
}
}
nassertr(p == &image[idx] + page_size, false);
} else {
const unsigned char *p = &image[idx];
if (has_alpha) {
for (int j = y_size-1; j >= 0; j--) {
xel *row = array + j * x_size;
xelval *alpha_row = alpha + j * x_size;
for (int i = 0; i < x_size; i++) {
PPM_PUTB(row[i], *p++);
PPM_PUTG(row[i], *p++);
PPM_PUTR(row[i], *p++);
alpha_row[i] = *p++;
}
}
} else {
for (int j = y_size-1; j >= 0; j--) {
xel *row = array + j * x_size;
for (int i = 0; i < x_size; i++) {
PPM_PUTB(row[i], *p++);
PPM_PUTG(row[i], *p++);
PPM_PUTR(row[i], *p++);
}
}
}
nassertr(p == &image[idx] + page_size, false);
}
break;
case T_unsigned_short:
{
const uint16_t *p = (const uint16_t *)&image[idx];
for (int j = y_size-1; j >= 0; j--) {
xel *row = array + j * x_size;
xelval *alpha_row = alpha + j * x_size;
for (int i = 0; i < x_size; i++) {
PPM_PUTB(row[i], *p++);
if (!is_grayscale) {
PPM_PUTG(row[i], *p++);
PPM_PUTR(row[i], *p++);
}
if (has_alpha) {
alpha_row[i] = *p++;
}
}
}
nassertr((const unsigned char *)p == &image[idx] + page_size, false);
}
break;
case T_unsigned_int:
{
const uint32_t *p = (const uint32_t *)&image[idx];
for (int j = y_size-1; j >= 0; j--) {
xel *row = array + j * x_size;
xelval *alpha_row = alpha + j * x_size;
for (int i = 0; i < x_size; i++) {
PPM_PUTB(row[i], (*p++) >> 16u);
if (!is_grayscale) {
PPM_PUTG(row[i], (*p++) >> 16u);
PPM_PUTR(row[i], (*p++) >> 16u);
}
if (has_alpha) {
alpha_row[i] = (*p++) >> 16u;
}
}
}
nassertr((const unsigned char *)p == &image[idx] + page_size, false);
}
break;
case T_half_float:
{
const unsigned char *p = &image[idx];
for (int j = y_size-1; j >= 0; j--) {
for (int i = 0; i < x_size; i++) {
pnmimage.set_blue(i, j, get_half_float(p));
if (!is_grayscale) {
pnmimage.set_green(i, j, get_half_float(p));
pnmimage.set_red(i, j, get_half_float(p));
}
if (has_alpha) {
pnmimage.set_alpha(i, j, get_half_float(p));
}
}
}
nassertr(p == &image[idx] + page_size, false);
}
break;
default:
return false;
}
return true;
}
/**
* Internal method to convert pixel data to the indicated PfmFile from the
* given ram_image.
*/
bool Texture::
convert_to_pfm(PfmFile &pfm, int x_size, int y_size,
int num_components, int component_width,
CPTA_uchar image, size_t page_size, int z) {
nassertr(component_width == 4, false); // Currently only PN_float32 is expected.
pfm.clear(x_size, y_size, num_components);
int idx = page_size * z;
nassertr(idx + page_size <= image.size(), false);
const PN_float32 *p = (const PN_float32 *)&image[idx];
switch (num_components) {
case 1:
for (int j = y_size-1; j >= 0; j--) {
for (int i = 0; i < x_size; i++) {
pfm.set_channel(i, j, 0, p[0]);
++p;
}
}
break;
case 2:
for (int j = y_size-1; j >= 0; j--) {
for (int i = 0; i < x_size; i++) {
pfm.set_channel(i, j, 0, p[0]);
pfm.set_channel(i, j, 1, p[1]);
p += 2;
}
}
break;
case 3:
// BGR -> RGB
for (int j = y_size-1; j >= 0; j--) {
for (int i = 0; i < x_size; i++) {
pfm.set_channel(i, j, 2, p[0]);
pfm.set_channel(i, j, 1, p[1]);
pfm.set_channel(i, j, 0, p[2]);
p += 3;
}
}
break;
case 4:
// BGRA -> RGBA
for (int j = y_size-1; j >= 0; j--) {
for (int i = 0; i < x_size; i++) {
pfm.set_channel(i, j, 2, p[0]);
pfm.set_channel(i, j, 1, p[1]);
pfm.set_channel(i, j, 0, p[2]);
pfm.set_channel(i, j, 3, p[3]);
p += 4;
}
}
break;
default:
nassert_raise("unexpected channel count");
return false;
}
nassertr((unsigned char *)p == &image[idx] + page_size, false);
return true;
}
/**
* Called by read_dds for a DDS file in BGR8 format.
*/
PTA_uchar Texture::
read_dds_level_bgr8(Texture *tex, CData *cdata, const DDSHeader &header, int n, istream &in) {
// This is in order B, G, R.
int x_size = tex->do_get_expected_mipmap_x_size(cdata, n);
int y_size = tex->do_get_expected_mipmap_y_size(cdata, n);
size_t size = tex->do_get_expected_ram_mipmap_page_size(cdata, n);
size_t row_bytes = x_size * 3;
PTA_uchar image = PTA_uchar::empty_array(size);
for (int y = y_size - 1; y >= 0; --y) {
unsigned char *p = image.p() + y * row_bytes;
nassertr(p + row_bytes <= image.p() + size, PTA_uchar());
in.read((char *)p, row_bytes);
}
return image;
}
/**
* Called by read_dds for a DDS file in RGB8 format.
*/
PTA_uchar Texture::
read_dds_level_rgb8(Texture *tex, CData *cdata, const DDSHeader &header, int n, istream &in) {
// This is in order R, G, B.
int x_size = tex->do_get_expected_mipmap_x_size(cdata, n);
int y_size = tex->do_get_expected_mipmap_y_size(cdata, n);
size_t size = tex->do_get_expected_ram_mipmap_page_size(cdata, n);
size_t row_bytes = x_size * 3;
PTA_uchar image = PTA_uchar::empty_array(size);
for (int y = y_size - 1; y >= 0; --y) {
unsigned char *p = image.p() + y * row_bytes;
nassertr(p + row_bytes <= image.p() + size, PTA_uchar());
in.read((char *)p, row_bytes);
// Now reverse the r, g, b triples.
for (int x = 0; x < x_size; ++x) {
unsigned char r = p[0];
p[0] = p[2];
p[2] = r;
p += 3;
}
nassertr(p <= image.p() + size, PTA_uchar());
}
return image;
}
/**
* Called by read_dds for a DDS file in ABGR8 format.
*/
PTA_uchar Texture::
read_dds_level_abgr8(Texture *tex, CData *cdata, const DDSHeader &header, int n, istream &in) {
// This is laid out in order R, G, B, A.
int x_size = tex->do_get_expected_mipmap_x_size(cdata, n);
int y_size = tex->do_get_expected_mipmap_y_size(cdata, n);
size_t size = tex->do_get_expected_ram_mipmap_page_size(cdata, n);
size_t row_bytes = x_size * 4;
PTA_uchar image = PTA_uchar::empty_array(size);
for (int y = y_size - 1; y >= 0; --y) {
unsigned char *p = image.p() + y * row_bytes;
in.read((char *)p, row_bytes);
uint32_t *pw = (uint32_t *)p;
for (int x = 0; x < x_size; ++x) {
uint32_t w = *pw;
#ifdef WORDS_BIGENDIAN
// bigendian: convert R, G, B, A to B, G, R, A.
w = ((w & 0xff00) << 16) | ((w & 0xff000000U) >> 16) | (w & 0xff00ff);
#else
// littendian: convert A, B, G, R to to A, R, G, B.
w = ((w & 0xff) << 16) | ((w & 0xff0000) >> 16) | (w & 0xff00ff00U);
#endif
*pw = w;
++pw;
}
nassertr((unsigned char *)pw <= image.p() + size, PTA_uchar());
}
return image;
}
/**
* Called by read_dds for a DDS file in RGBA8 format.
*/
PTA_uchar Texture::
read_dds_level_rgba8(Texture *tex, CData *cdata, const DDSHeader &header, int n, istream &in) {
// This is actually laid out in order B, G, R, A.
int x_size = tex->do_get_expected_mipmap_x_size(cdata, n);
int y_size = tex->do_get_expected_mipmap_y_size(cdata, n);
size_t size = tex->do_get_expected_ram_mipmap_page_size(cdata, n);
size_t row_bytes = x_size * 4;
PTA_uchar image = PTA_uchar::empty_array(size);
for (int y = y_size - 1; y >= 0; --y) {
unsigned char *p = image.p() + y * row_bytes;
nassertr(p + row_bytes <= image.p() + size, PTA_uchar());
in.read((char *)p, row_bytes);
}
return image;
}
/**
* Called by read_dds for a DDS file in ABGR16 format.
*/
PTA_uchar Texture::
read_dds_level_abgr16(Texture *tex, CData *cdata, const DDSHeader &header, int n, istream &in) {
// This is laid out in order R, G, B, A.
int x_size = tex->do_get_expected_mipmap_x_size(cdata, n);
int y_size = tex->do_get_expected_mipmap_y_size(cdata, n);
size_t size = tex->do_get_expected_ram_mipmap_page_size(cdata, n);
size_t row_bytes = x_size * 8;
PTA_uchar image = PTA_uchar::empty_array(size);
for (int y = y_size - 1; y >= 0; --y) {
unsigned char *p = image.p() + y * row_bytes;
in.read((char *)p, row_bytes);
uint16_t *pw = (uint16_t *)p;
for (int x = 0; x < x_size; ++x) {
swap(pw[0], pw[2]);
pw += 4;
}
nassertr((unsigned char *)pw <= image.p() + size, PTA_uchar());
}
return image;
}
/**
* Called by read_dds for a DDS file in ABGR32 format.
*/
PTA_uchar Texture::
read_dds_level_abgr32(Texture *tex, CData *cdata, const DDSHeader &header, int n, istream &in) {
// This is laid out in order R, G, B, A.
int x_size = tex->do_get_expected_mipmap_x_size(cdata, n);
int y_size = tex->do_get_expected_mipmap_y_size(cdata, n);
size_t size = tex->do_get_expected_ram_mipmap_page_size(cdata, n);
size_t row_bytes = x_size * 16;
nassertr(row_bytes * y_size == size, PTA_uchar());
PTA_uchar image = PTA_uchar::empty_array(size);
for (int y = y_size - 1; y >= 0; --y) {
unsigned char *p = image.p() + y * row_bytes;
in.read((char *)p, row_bytes);
uint32_t *pw = (uint32_t *)p;
for (int x = 0; x < x_size; ++x) {
swap(pw[0], pw[2]);
pw += 4;
}
nassertr((unsigned char *)pw <= image.p() + size, PTA_uchar());
}
return image;
}
/**
* Called by read_dds for a DDS file that needs no transformations applied.
*/
PTA_uchar Texture::
read_dds_level_raw(Texture *tex, CData *cdata, const DDSHeader &header, int n, istream &in) {
int x_size = tex->do_get_expected_mipmap_x_size(cdata, n);
int y_size = tex->do_get_expected_mipmap_y_size(cdata, n);
size_t size = tex->do_get_expected_ram_mipmap_page_size(cdata, n);
size_t row_bytes = x_size * cdata->_num_components * cdata->_component_width;
nassertr(row_bytes * y_size == size, PTA_uchar());
PTA_uchar image = PTA_uchar::empty_array(size);
for (int y = y_size - 1; y >= 0; --y) {
unsigned char *p = image.p() + y * row_bytes;
in.read((char *)p, row_bytes);
}
return image;
}
/**
* Called by read_dds for a DDS file whose format isn't one we've specifically
* optimized.
*/
PTA_uchar Texture::
read_dds_level_generic_uncompressed(Texture *tex, CData *cdata, const DDSHeader &header,
int n, istream &in) {
int x_size = tex->do_get_expected_mipmap_x_size(cdata, n);
int y_size = tex->do_get_expected_mipmap_y_size(cdata, n);
int pitch = (x_size * header.pf.rgb_bitcount) / 8;
// MS says the pitch can be supplied in the header file and must be DWORD
// aligned, but this appears to apply to level 0 mipmaps only (where it
// almost always will be anyway). Other mipmap levels seem to be tightly
// packed, but there isn't a separate pitch for each mipmap level. Weird.
if (n == 0) {
pitch = ((pitch + 3) / 4) * 4;
if (header.dds_flags & DDSD_PITCH) {
pitch = header.pitch;
}
}
int bpp = header.pf.rgb_bitcount / 8;
int skip_bytes = pitch - (bpp * x_size);
nassertr(skip_bytes >= 0, PTA_uchar());
unsigned int r_mask = header.pf.r_mask;
unsigned int g_mask = header.pf.g_mask;
unsigned int b_mask = header.pf.b_mask;
unsigned int a_mask = header.pf.a_mask;
// Determine the number of bits to shift each mask to the right so that the
// lowest on bit is at bit 0.
int r_shift = get_lowest_on_bit(r_mask);
int g_shift = get_lowest_on_bit(g_mask);
int b_shift = get_lowest_on_bit(b_mask);
int a_shift = get_lowest_on_bit(a_mask);
// Then determine the scale factor required to raise the highest color value
// to 0xff000000.
unsigned int r_scale = 0;
if (r_mask != 0) {
r_scale = 0xff000000 / (r_mask >> r_shift);
}
unsigned int g_scale = 0;
if (g_mask != 0) {
g_scale = 0xff000000 / (g_mask >> g_shift);
}
unsigned int b_scale = 0;
if (b_mask != 0) {
b_scale = 0xff000000 / (b_mask >> b_shift);
}
unsigned int a_scale = 0;
if (a_mask != 0) {
a_scale = 0xff000000 / (a_mask >> a_shift);
}
bool add_alpha = has_alpha(cdata->_format);
size_t size = tex->do_get_expected_ram_mipmap_page_size(cdata, n);
size_t row_bytes = x_size * cdata->_num_components;
PTA_uchar image = PTA_uchar::empty_array(size);
for (int y = y_size - 1; y >= 0; --y) {
unsigned char *p = image.p() + y * row_bytes;
for (int x = 0; x < x_size; ++x) {
// Read a little-endian numeric value of bpp bytes.
unsigned int pixel = 0;
int shift = 0;
for (int bi = 0; bi < bpp; ++bi) {
unsigned int ch = (unsigned char)in.get();
pixel |= (ch << shift);
shift += 8;
}
// Then break apart that value into its R, G, B, and maybe A components.
unsigned int r = (((pixel & r_mask) >> r_shift) * r_scale) >> 24;
unsigned int g = (((pixel & g_mask) >> g_shift) * g_scale) >> 24;
unsigned int b = (((pixel & b_mask) >> b_shift) * b_scale) >> 24;
// Store the components in the Texture's image data.
store_unscaled_byte(p, b);
store_unscaled_byte(p, g);
store_unscaled_byte(p, r);
if (add_alpha) {
unsigned int a = (((pixel & a_mask) >> a_shift) * a_scale) >> 24;
store_unscaled_byte(p, a);
}
}
nassertr(p <= image.p() + size, PTA_uchar());
for (int bi = 0; bi < skip_bytes; ++bi) {
in.get();
}
}
return image;
}
/**
* Called by read_dds for a DDS file in uncompressed luminance or luminance-
* alpha format.
*/
PTA_uchar Texture::
read_dds_level_luminance_uncompressed(Texture *tex, CData *cdata, const DDSHeader &header,
int n, istream &in) {
int x_size = tex->do_get_expected_mipmap_x_size(cdata, n);
int y_size = tex->do_get_expected_mipmap_y_size(cdata, n);
int pitch = (x_size * header.pf.rgb_bitcount) / 8;
// MS says the pitch can be supplied in the header file and must be DWORD
// aligned, but this appears to apply to level 0 mipmaps only (where it
// almost always will be anyway). Other mipmap levels seem to be tightly
// packed, but there isn't a separate pitch for each mipmap level. Weird.
if (n == 0) {
pitch = ((pitch + 3) / 4) * 4;
if (header.dds_flags & DDSD_PITCH) {
pitch = header.pitch;
}
}
int bpp = header.pf.rgb_bitcount / 8;
int skip_bytes = pitch - (bpp * x_size);
nassertr(skip_bytes >= 0, PTA_uchar());
unsigned int r_mask = header.pf.r_mask;
unsigned int a_mask = header.pf.a_mask;
// Determine the number of bits to shift each mask to the right so that the
// lowest on bit is at bit 0.
int r_shift = get_lowest_on_bit(r_mask);
int a_shift = get_lowest_on_bit(a_mask);
// Then determine the scale factor required to raise the highest color value
// to 0xff000000.
unsigned int r_scale = 0;
if (r_mask != 0) {
r_scale = 0xff000000 / (r_mask >> r_shift);
}
unsigned int a_scale = 0;
if (a_mask != 0) {
a_scale = 0xff000000 / (a_mask >> a_shift);
}
bool add_alpha = has_alpha(cdata->_format);
size_t size = tex->do_get_expected_ram_mipmap_page_size(cdata, n);
size_t row_bytes = x_size * cdata->_num_components;
PTA_uchar image = PTA_uchar::empty_array(size);
for (int y = y_size - 1; y >= 0; --y) {
unsigned char *p = image.p() + y * row_bytes;
for (int x = 0; x < x_size; ++x) {
// Read a little-endian numeric value of bpp bytes.
unsigned int pixel = 0;
int shift = 0;
for (int bi = 0; bi < bpp; ++bi) {
unsigned int ch = (unsigned char)in.get();
pixel |= (ch << shift);
shift += 8;
}
unsigned int r = (((pixel & r_mask) >> r_shift) * r_scale) >> 24;
// Store the components in the Texture's image data.
store_unscaled_byte(p, r);
if (add_alpha) {
unsigned int a = (((pixel & a_mask) >> a_shift) * a_scale) >> 24;
store_unscaled_byte(p, a);
}
}
nassertr(p <= image.p() + size, PTA_uchar());
for (int bi = 0; bi < skip_bytes; ++bi) {
in.get();
}
}
return image;
}
/**
* Called by read_dds for DXT1 file format.
*/
PTA_uchar Texture::
read_dds_level_bc1(Texture *tex, CData *cdata, const DDSHeader &header, int n, istream &in) {
int x_size = tex->do_get_expected_mipmap_x_size(cdata, n);
int y_size = tex->do_get_expected_mipmap_y_size(cdata, n);
static const int div = 4;
static const int block_bytes = 8;
// The DXT1 image is divided into num_rows x num_cols blocks, where each
// block represents 4x4 pixels.
int num_cols = max(div, x_size) / div;
int num_rows = max(div, y_size) / div;
int row_length = num_cols * block_bytes;
int linear_size = row_length * num_rows;
if (n == 0) {
if (header.dds_flags & DDSD_LINEARSIZE) {
nassertr(linear_size == (int)header.pitch, PTA_uchar());
}
}
PTA_uchar image = PTA_uchar::empty_array(linear_size);
if (y_size >= 4) {
// We have to flip the image as we read it, because of DirectX's inverted
// sense of up. That means we (a) reverse the order of the rows of blocks
// . . .
for (int ri = num_rows - 1; ri >= 0; --ri) {
unsigned char *p = image.p() + row_length * ri;
in.read((char *)p, row_length);
for (int ci = 0; ci < num_cols; ++ci) {
// . . . and (b) within each block, we reverse the 4 individual rows
// of 4 pixels.
uint32_t *cells = (uint32_t *)p;
uint32_t w = cells[1];
w = ((w & 0xff) << 24) | ((w & 0xff00) << 8) | ((w & 0xff0000) >> 8) | ((w & 0xff000000U) >> 24);
cells[1] = w;
p += block_bytes;
}
}
} else if (y_size >= 2) {
// To invert a two-pixel high image, we just flip two rows within a cell.
unsigned char *p = image.p();
in.read((char *)p, row_length);
for (int ci = 0; ci < num_cols; ++ci) {
uint32_t *cells = (uint32_t *)p;
uint32_t w = cells[1];
w = ((w & 0xff) << 8) | ((w & 0xff00) >> 8);
cells[1] = w;
p += block_bytes;
}
} else if (y_size >= 1) {
// No need to invert a one-pixel-high image.
unsigned char *p = image.p();
in.read((char *)p, row_length);
}
return image;
}
/**
* Called by read_dds for DXT2 or DXT3 file format.
*/
PTA_uchar Texture::
read_dds_level_bc2(Texture *tex, CData *cdata, const DDSHeader &header, int n, istream &in) {
int x_size = tex->do_get_expected_mipmap_x_size(cdata, n);
int y_size = tex->do_get_expected_mipmap_y_size(cdata, n);
static const int div = 4;
static const int block_bytes = 16;
// The DXT3 image is divided into num_rows x num_cols blocks, where each
// block represents 4x4 pixels. Unlike DXT1, each block consists of two
// 8-byte chunks, representing the alpha and color separately.
int num_cols = max(div, x_size) / div;
int num_rows = max(div, y_size) / div;
int row_length = num_cols * block_bytes;
int linear_size = row_length * num_rows;
if (n == 0) {
if (header.dds_flags & DDSD_LINEARSIZE) {
nassertr(linear_size == (int)header.pitch, PTA_uchar());
}
}
PTA_uchar image = PTA_uchar::empty_array(linear_size);
if (y_size >= 4) {
// We have to flip the image as we read it, because of DirectX's inverted
// sense of up. That means we (a) reverse the order of the rows of blocks
// . . .
for (int ri = num_rows - 1; ri >= 0; --ri) {
unsigned char *p = image.p() + row_length * ri;
in.read((char *)p, row_length);
for (int ci = 0; ci < num_cols; ++ci) {
// . . . and (b) within each block, we reverse the 4 individual rows
// of 4 pixels.
uint32_t *cells = (uint32_t *)p;
// Alpha. The block is four 16-bit words of pixel data.
uint32_t w0 = cells[0];
uint32_t w1 = cells[1];
w0 = ((w0 & 0xffff) << 16) | ((w0 & 0xffff0000U) >> 16);
w1 = ((w1 & 0xffff) << 16) | ((w1 & 0xffff0000U) >> 16);
cells[0] = w1;
cells[1] = w0;
// Color. Only the second 32-bit dword of the color block represents
// the pixel data.
uint32_t w = cells[3];
w = ((w & 0xff) << 24) | ((w & 0xff00) << 8) | ((w & 0xff0000) >> 8) | ((w & 0xff000000U) >> 24);
cells[3] = w;
p += block_bytes;
}
}
} else if (y_size >= 2) {
// To invert a two-pixel high image, we just flip two rows within a cell.
unsigned char *p = image.p();
in.read((char *)p, row_length);
for (int ci = 0; ci < num_cols; ++ci) {
uint32_t *cells = (uint32_t *)p;
uint32_t w0 = cells[0];
w0 = ((w0 & 0xffff) << 16) | ((w0 & 0xffff0000U) >> 16);
cells[0] = w0;
uint32_t w = cells[3];
w = ((w & 0xff) << 8) | ((w & 0xff00) >> 8);
cells[3] = w;
p += block_bytes;
}
} else if (y_size >= 1) {
// No need to invert a one-pixel-high image.
unsigned char *p = image.p();
in.read((char *)p, row_length);
}
return image;
}
/**
* Called by read_dds for DXT4 or DXT5 file format.
*/
PTA_uchar Texture::
read_dds_level_bc3(Texture *tex, CData *cdata, const DDSHeader &header, int n, istream &in) {
int x_size = tex->do_get_expected_mipmap_x_size(cdata, n);
int y_size = tex->do_get_expected_mipmap_y_size(cdata, n);
static const int div = 4;
static const int block_bytes = 16;
// The DXT5 image is similar to DXT3, in that there each 4x4 block of pixels
// consists of an alpha block and a color block, but the layout of the alpha
// block is different.
int num_cols = max(div, x_size) / div;
int num_rows = max(div, y_size) / div;
int row_length = num_cols * block_bytes;
int linear_size = row_length * num_rows;
if (n == 0) {
if (header.dds_flags & DDSD_LINEARSIZE) {
nassertr(linear_size == (int)header.pitch, PTA_uchar());
}
}
PTA_uchar image = PTA_uchar::empty_array(linear_size);
if (y_size >= 4) {
// We have to flip the image as we read it, because of DirectX's inverted
// sense of up. That means we (a) reverse the order of the rows of blocks
// . . .
for (int ri = num_rows - 1; ri >= 0; --ri) {
unsigned char *p = image.p() + row_length * ri;
in.read((char *)p, row_length);
for (int ci = 0; ci < num_cols; ++ci) {
// . . . and (b) within each block, we reverse the 4 individual rows
// of 4 pixels.
uint32_t *cells = (uint32_t *)p;
// Alpha. The block is one 16-bit word of reference values, followed
// by six words of pixel values, in 12-bit rows. Tricky to invert.
unsigned char p2 = p[2];
unsigned char p3 = p[3];
unsigned char p4 = p[4];
unsigned char p5 = p[5];
unsigned char p6 = p[6];
unsigned char p7 = p[7];
p[2] = ((p7 & 0xf) << 4) | ((p6 & 0xf0) >> 4);
p[3] = ((p5 & 0xf) << 4) | ((p7 & 0xf0) >> 4);
p[4] = ((p6 & 0xf) << 4) | ((p5 & 0xf0) >> 4);
p[5] = ((p4 & 0xf) << 4) | ((p3 & 0xf0) >> 4);
p[6] = ((p2 & 0xf) << 4) | ((p4 & 0xf0) >> 4);
p[7] = ((p3 & 0xf) << 4) | ((p2 & 0xf0) >> 4);
// Color. Only the second 32-bit dword of the color block represents
// the pixel data.
uint32_t w = cells[3];
w = ((w & 0xff) << 24) | ((w & 0xff00) << 8) | ((w & 0xff0000) >> 8) | ((w & 0xff000000U) >> 24);
cells[3] = w;
p += block_bytes;
}
}
} else if (y_size >= 2) {
// To invert a two-pixel high image, we just flip two rows within a cell.
unsigned char *p = image.p();
in.read((char *)p, row_length);
for (int ci = 0; ci < num_cols; ++ci) {
uint32_t *cells = (uint32_t *)p;
unsigned char p2 = p[2];
unsigned char p3 = p[3];
unsigned char p4 = p[4];
p[2] = ((p4 & 0xf) << 4) | ((p3 & 0xf0) >> 4);
p[3] = ((p2 & 0xf) << 4) | ((p4 & 0xf0) >> 4);
p[4] = ((p3 & 0xf) << 4) | ((p2 & 0xf0) >> 4);
uint32_t w0 = cells[0];
w0 = ((w0 & 0xffff) << 16) | ((w0 & 0xffff0000U) >> 16);
cells[0] = w0;
uint32_t w = cells[3];
w = ((w & 0xff) << 8) | ((w & 0xff00) >> 8);
cells[3] = w;
p += block_bytes;
}
} else if (y_size >= 1) {
// No need to invert a one-pixel-high image.
unsigned char *p = image.p();
in.read((char *)p, row_length);
}
return image;
}
/**
* Called by read_dds for ATI1 compression.
*/
PTA_uchar Texture::
read_dds_level_bc4(Texture *tex, CData *cdata, const DDSHeader &header, int n, istream &in) {
int x_size = tex->do_get_expected_mipmap_x_size(cdata, n);
int y_size = tex->do_get_expected_mipmap_y_size(cdata, n);
static const int div = 4;
static const int block_bytes = 8;
// The ATI1 (BC4) format uses the same compression mechanism as the alpha
// channel of DXT5.
int num_cols = max(div, x_size) / div;
int num_rows = max(div, y_size) / div;
int row_length = num_cols * block_bytes;
int linear_size = row_length * num_rows;
if (n == 0) {
if (header.dds_flags & DDSD_LINEARSIZE) {
nassertr(linear_size == (int)header.pitch, PTA_uchar());
}
}
PTA_uchar image = PTA_uchar::empty_array(linear_size);
if (y_size >= 4) {
// We have to flip the image as we read it, because of DirectX's inverted
// sense of up. That means we (a) reverse the order of the rows of blocks
// . . .
for (int ri = num_rows - 1; ri >= 0; --ri) {
unsigned char *p = image.p() + row_length * ri;
in.read((char *)p, row_length);
for (int ci = 0; ci < num_cols; ++ci) {
// . . . and (b) within each block, we reverse the 4 individual rows
// of 4 pixels. The block is one 16-bit word of reference values,
// followed by six words of pixel values, in 12-bit rows. Tricky to
// invert.
unsigned char p2 = p[2];
unsigned char p3 = p[3];
unsigned char p4 = p[4];
unsigned char p5 = p[5];
unsigned char p6 = p[6];
unsigned char p7 = p[7];
p[2] = ((p7 & 0xf) << 4) | ((p6 & 0xf0) >> 4);
p[3] = ((p5 & 0xf) << 4) | ((p7 & 0xf0) >> 4);
p[4] = ((p6 & 0xf) << 4) | ((p5 & 0xf0) >> 4);
p[5] = ((p4 & 0xf) << 4) | ((p3 & 0xf0) >> 4);
p[6] = ((p2 & 0xf) << 4) | ((p4 & 0xf0) >> 4);
p[7] = ((p3 & 0xf) << 4) | ((p2 & 0xf0) >> 4);
p += block_bytes;
}
}
} else if (y_size >= 2) {
// To invert a two-pixel high image, we just flip two rows within a cell.
unsigned char *p = image.p();
in.read((char *)p, row_length);
for (int ci = 0; ci < num_cols; ++ci) {
unsigned char p2 = p[2];
unsigned char p3 = p[3];
unsigned char p4 = p[4];
p[2] = ((p4 & 0xf) << 4) | ((p3 & 0xf0) >> 4);
p[3] = ((p2 & 0xf) << 4) | ((p4 & 0xf0) >> 4);
p[4] = ((p3 & 0xf) << 4) | ((p2 & 0xf0) >> 4);
p += block_bytes;
}
} else if (y_size >= 1) {
// No need to invert a one-pixel-high image.
unsigned char *p = image.p();
in.read((char *)p, row_length);
}
return image;
}
/**
* Called by read_dds for ATI2 compression.
*/
PTA_uchar Texture::
read_dds_level_bc5(Texture *tex, CData *cdata, const DDSHeader &header, int n, istream &in) {
int x_size = tex->do_get_expected_mipmap_x_size(cdata, n);
int y_size = tex->do_get_expected_mipmap_y_size(cdata, n);
// The ATI2 (BC5) format uses the same compression mechanism as the ATI1
// (BC4) format, but doubles the channels.
int num_cols = max(4, x_size) / 2;
int num_rows = max(4, y_size) / 4;
int row_length = num_cols * 8;
int linear_size = row_length * num_rows;
if (n == 0) {
if (header.dds_flags & DDSD_LINEARSIZE) {
nassertr(linear_size == (int)header.pitch, PTA_uchar());
}
}
PTA_uchar image = PTA_uchar::empty_array(linear_size);
if (y_size >= 4) {
// We have to flip the image as we read it, because of DirectX's inverted
// sense of up. That means we (a) reverse the order of the rows of blocks
// . . .
for (int ri = num_rows - 1; ri >= 0; --ri) {
unsigned char *p = image.p() + row_length * ri;
in.read((char *)p, row_length);
for (int ci = 0; ci < num_cols; ++ci) {
// . . . and (b) within each block, we reverse the 4 individual rows
// of 4 pixels. The block is one 16-bit word of reference values,
// followed by six words of pixel values, in 12-bit rows. Tricky to
// invert.
unsigned char p2 = p[2];
unsigned char p3 = p[3];
unsigned char p4 = p[4];
unsigned char p5 = p[5];
unsigned char p6 = p[6];
unsigned char p7 = p[7];
p[2] = ((p7 & 0xf) << 4) | ((p6 & 0xf0) >> 4);
p[3] = ((p5 & 0xf) << 4) | ((p7 & 0xf0) >> 4);
p[4] = ((p6 & 0xf) << 4) | ((p5 & 0xf0) >> 4);
p[5] = ((p4 & 0xf) << 4) | ((p3 & 0xf0) >> 4);
p[6] = ((p2 & 0xf) << 4) | ((p4 & 0xf0) >> 4);
p[7] = ((p3 & 0xf) << 4) | ((p2 & 0xf0) >> 4);
p += 8;
}
}
} else if (y_size >= 2) {
// To invert a two-pixel high image, we just flip two rows within a cell.
unsigned char *p = image.p();
in.read((char *)p, row_length);
for (int ci = 0; ci < num_cols; ++ci) {
unsigned char p2 = p[2];
unsigned char p3 = p[3];
unsigned char p4 = p[4];
p[2] = ((p4 & 0xf) << 4) | ((p3 & 0xf0) >> 4);
p[3] = ((p2 & 0xf) << 4) | ((p4 & 0xf0) >> 4);
p[4] = ((p3 & 0xf) << 4) | ((p2 & 0xf0) >> 4);
p += 8;
}
} else if (y_size >= 1) {
// No need to invert a one-pixel-high image.
unsigned char *p = image.p();
in.read((char *)p, row_length);
}
return image;
}
/**
* Removes the indicated PreparedGraphicsObjects table from the Texture's
* table, without actually releasing the texture. This is intended to be
* called only from PreparedGraphicsObjects::release_texture(); it should
* never be called by user code.
*/
void Texture::
clear_prepared(int view, PreparedGraphicsObjects *prepared_objects) {
PreparedViews::iterator pvi;
pvi = _prepared_views.find(prepared_objects);
if (pvi != _prepared_views.end()) {
Contexts &contexts = (*pvi).second;
Contexts::iterator ci;
ci = contexts.find(view);
if (ci != contexts.end()) {
contexts.erase(ci);
}
if (contexts.empty()) {
_prepared_views.erase(pvi);
}
}
}
/**
* Reduces the number of channels in the texture, if necessary, according to
* num_channels.
*/
void Texture::
consider_downgrade(PNMImage &pnmimage, int num_channels, const string &name) {
if (num_channels != 0 && num_channels < pnmimage.get_num_channels()) {
// One special case: we can't reduce from 3 to 2 components, since that
// would require adding an alpha channel.
if (pnmimage.get_num_channels() == 3 && num_channels == 2) {
return;
}
gobj_cat.info()
<< "Downgrading " << name << " from "
<< pnmimage.get_num_channels() << " components to "
<< num_channels << ".\n";
pnmimage.set_num_channels(num_channels);
}
}
/**
* Called by generate_simple_ram_image(), this compares the two PNMImages
* pixel-by-pixel. If they're similar enough (within a given threshold),
* returns true.
*/
bool Texture::
compare_images(const PNMImage &a, const PNMImage &b) {
nassertr(a.get_maxval() == 255 && b.get_maxval() == 255, false);
nassertr(a.get_num_channels() == 4 && b.get_num_channels() == 4, false);
nassertr(a.get_x_size() == b.get_x_size() &&
a.get_y_size() == b.get_y_size(), false);
const xel *a_array = a.get_array();
const xel *b_array = b.get_array();
const xelval *a_alpha = a.get_alpha_array();
const xelval *b_alpha = b.get_alpha_array();
int x_size = a.get_x_size();
int delta = 0;
for (int yi = 0; yi < a.get_y_size(); ++yi) {
const xel *a_row = a_array + yi * x_size;
const xel *b_row = b_array + yi * x_size;
const xelval *a_alpha_row = a_alpha + yi * x_size;
const xelval *b_alpha_row = b_alpha + yi * x_size;
for (int xi = 0; xi < x_size; ++xi) {
delta += abs(PPM_GETR(a_row[xi]) - PPM_GETR(b_row[xi]));
delta += abs(PPM_GETG(a_row[xi]) - PPM_GETG(b_row[xi]));
delta += abs(PPM_GETB(a_row[xi]) - PPM_GETB(b_row[xi]));
delta += abs(a_alpha_row[xi] - b_alpha_row[xi]);
}
}
double average_delta = (double)delta / ((double)a.get_x_size() * (double)b.get_y_size() * (double)a.get_maxval());
return (average_delta <= simple_image_threshold);
}
/**
* Generates the next mipmap level from the previous one. If there are
* multiple pages (e.g. a cube map), generates each page independently.
*
* x_size and y_size are the size of the previous level. They need not be a
* power of 2, or even a multiple of 2.
*
* Assumes the lock is already held.
*/
void Texture::
do_filter_2d_mipmap_pages(const CData *cdata,
Texture::RamImage &to, const Texture::RamImage &from,
int x_size, int y_size) const {
Filter2DComponent *filter_component;
Filter2DComponent *filter_alpha;
if (is_srgb(cdata->_format)) {
// We currently only support sRGB mipmap generation for unsigned byte
// textures, due to our use of a lookup table.
nassertv(cdata->_component_type == T_unsigned_byte);
if (has_sse2_sRGB_encode()) {
filter_component = &filter_2d_unsigned_byte_srgb_sse2;
} else {
filter_component = &filter_2d_unsigned_byte_srgb;
}
// Alpha is always linear.
filter_alpha = &filter_2d_unsigned_byte;
} else {
switch (cdata->_component_type) {
case T_unsigned_byte:
filter_component = &filter_2d_unsigned_byte;
break;
case T_unsigned_short:
filter_component = &filter_2d_unsigned_short;
break;
case T_float:
filter_component = &filter_2d_float;
break;
default:
gobj_cat.error()
<< "Unable to generate mipmaps for 2D texture with component type "
<< cdata->_component_type << "!";
return;
}
filter_alpha = filter_component;
}
size_t pixel_size = cdata->_num_components * cdata->_component_width;
size_t row_size = (size_t)x_size * pixel_size;
int to_x_size = max(x_size >> 1, 1);
int to_y_size = max(y_size >> 1, 1);
size_t to_row_size = (size_t)to_x_size * pixel_size;
to._page_size = (size_t)to_y_size * to_row_size;
to._image = PTA_uchar::empty_array(to._page_size * cdata->_z_size * cdata->_num_views, get_class_type());
bool alpha = has_alpha(cdata->_format);
int num_color_components = cdata->_num_components;
if (alpha) {
--num_color_components;
}
int num_pages = cdata->_z_size * cdata->_num_views;
for (int z = 0; z < num_pages; ++z) {
// For each level.
unsigned char *p = to._image.p() + z * to._page_size;
nassertv(p <= to._image.p() + to._image.size() + to._page_size);
const unsigned char *q = from._image.p() + z * from._page_size;
nassertv(q <= from._image.p() + from._image.size() + from._page_size);
if (y_size != 1) {
int y;
for (y = 0; y < y_size - 1; y += 2) {
// For each row.
nassertv(p == to._image.p() + z * to._page_size + (y / 2) * to_row_size);
nassertv(q == from._image.p() + z * from._page_size + y * row_size);
if (x_size != 1) {
int x;
for (x = 0; x < x_size - 1; x += 2) {
// For each pixel.
for (int c = 0; c < num_color_components; ++c) {
// For each component.
filter_component(p, q, pixel_size, row_size);
}
if (alpha) {
filter_alpha(p, q, pixel_size, row_size);
}
q += pixel_size;
}
if (x < x_size) {
// Skip the last odd pixel.
q += pixel_size;
}
} else {
// Just one pixel.
for (int c = 0; c < num_color_components; ++c) {
// For each component.
filter_component(p, q, 0, row_size);
}
if (alpha) {
filter_alpha(p, q, 0, row_size);
}
}
q += row_size;
Thread::consider_yield();
}
if (y < y_size) {
// Skip the last odd row.
q += row_size;
}
} else {
// Just one row.
if (x_size != 1) {
int x;
for (x = 0; x < x_size - 1; x += 2) {
// For each pixel.
for (int c = 0; c < num_color_components; ++c) {
// For each component.
filter_component(p, q, pixel_size, 0);
}
if (alpha) {
filter_alpha(p, q, pixel_size, 0);
}
q += pixel_size;
}
if (x < x_size) {
// Skip the last odd pixel.
q += pixel_size;
}
} else {
// Just one pixel.
for (int c = 0; c < num_color_components; ++c) {
// For each component.
filter_component(p, q, 0, 0);
}
if (alpha) {
filter_alpha(p, q, pixel_size, 0);
}
}
}
nassertv(p == to._image.p() + (z + 1) * to._page_size);
nassertv(q == from._image.p() + (z + 1) * from._page_size);
}
}
/**
* Generates the next mipmap level from the previous one, treating all the
* pages of the level as a single 3-d block of pixels.
*
* x_size, y_size, and z_size are the size of the previous level. They need
* not be a power of 2, or even a multiple of 2.
*
* Assumes the lock is already held.
*/
void Texture::
do_filter_3d_mipmap_level(const CData *cdata,
Texture::RamImage &to, const Texture::RamImage &from,
int x_size, int y_size, int z_size) const {
Filter3DComponent *filter_component;
Filter3DComponent *filter_alpha;
if (is_srgb(cdata->_format)) {
// We currently only support sRGB mipmap generation for unsigned byte
// textures, due to our use of a lookup table.
nassertv(cdata->_component_type == T_unsigned_byte);
if (has_sse2_sRGB_encode()) {
filter_component = &filter_3d_unsigned_byte_srgb_sse2;
} else {
filter_component = &filter_3d_unsigned_byte_srgb;
}
// Alpha is always linear.
filter_alpha = &filter_3d_unsigned_byte;
} else {
switch (cdata->_component_type) {
case T_unsigned_byte:
filter_component = &filter_3d_unsigned_byte;
break;
case T_unsigned_short:
filter_component = &filter_3d_unsigned_short;
break;
case T_float:
filter_component = &filter_3d_float;
break;
default:
gobj_cat.error()
<< "Unable to generate mipmaps for 3D texture with component type "
<< cdata->_component_type << "!";
return;
}
filter_alpha = filter_component;
}
size_t pixel_size = cdata->_num_components * cdata->_component_width;
size_t row_size = (size_t)x_size * pixel_size;
size_t page_size = (size_t)y_size * row_size;
size_t view_size = (size_t)z_size * page_size;
int to_x_size = max(x_size >> 1, 1);
int to_y_size = max(y_size >> 1, 1);
int to_z_size = max(z_size >> 1, 1);
size_t to_row_size = (size_t)to_x_size * pixel_size;
size_t to_page_size = (size_t)to_y_size * to_row_size;
size_t to_view_size = (size_t)to_z_size * to_page_size;
to._page_size = to_page_size;
to._image = PTA_uchar::empty_array(to_page_size * to_z_size * cdata->_num_views, get_class_type());
bool alpha = has_alpha(cdata->_format);
int num_color_components = cdata->_num_components;
if (alpha) {
--num_color_components;
}
for (int view = 0; view < cdata->_num_views; ++view) {
unsigned char *start_to = to._image.p() + view * to_view_size;
const unsigned char *start_from = from._image.p() + view * view_size;
nassertv(start_to + to_view_size <= to._image.p() + to._image.size());
nassertv(start_from + view_size <= from._image.p() + from._image.size());
unsigned char *p = start_to;
const unsigned char *q = start_from;
if (z_size != 1) {
int z;
for (z = 0; z < z_size - 1; z += 2) {
// For each level.
nassertv(p == start_to + (z / 2) * to_page_size);
nassertv(q == start_from + z * page_size);
if (y_size != 1) {
int y;
for (y = 0; y < y_size - 1; y += 2) {
// For each row.
nassertv(p == start_to + (z / 2) * to_page_size + (y / 2) * to_row_size);
nassertv(q == start_from + z * page_size + y * row_size);
if (x_size != 1) {
int x;
for (x = 0; x < x_size - 1; x += 2) {
// For each pixel.
for (int c = 0; c < num_color_components; ++c) {
// For each component.
filter_component(p, q, pixel_size, row_size, page_size);
}
if (alpha) {
filter_alpha(p, q, pixel_size, row_size, page_size);
}
q += pixel_size;
}
if (x < x_size) {
// Skip the last odd pixel.
q += pixel_size;
}
} else {
// Just one pixel.
for (int c = 0; c < num_color_components; ++c) {
// For each component.
filter_component(p, q, 0, row_size, page_size);
}
if (alpha) {
filter_alpha(p, q, 0, row_size, page_size);
}
}
q += row_size;
Thread::consider_yield();
}
if (y < y_size) {
// Skip the last odd row.
q += row_size;
}
} else {
// Just one row.
if (x_size != 1) {
int x;
for (x = 0; x < x_size - 1; x += 2) {
// For each pixel.
for (int c = 0; c < num_color_components; ++c) {
// For each component.
filter_component(p, q, pixel_size, 0, page_size);
}
if (alpha) {
filter_alpha(p, q, pixel_size, 0, page_size);
}
q += pixel_size;
}
if (x < x_size) {
// Skip the last odd pixel.
q += pixel_size;
}
} else {
// Just one pixel.
for (int c = 0; c < num_color_components; ++c) {
// For each component.
filter_component(p, q, 0, 0, page_size);
}
if (alpha) {
filter_alpha(p, q, 0, 0, page_size);
}
}
}
q += page_size;
}
if (z < z_size) {
// Skip the last odd page.
q += page_size;
}
} else {
// Just one page.
if (y_size != 1) {
int y;
for (y = 0; y < y_size - 1; y += 2) {
// For each row.
nassertv(p == start_to + (y / 2) * to_row_size);
nassertv(q == start_from + y * row_size);
if (x_size != 1) {
int x;
for (x = 0; x < x_size - 1; x += 2) {
// For each pixel.
for (int c = 0; c < num_color_components; ++c) {
// For each component.
filter_component(p, q, pixel_size, row_size, 0);
}
if (alpha) {
filter_alpha(p, q, pixel_size, row_size, 0);
}
q += pixel_size;
}
if (x < x_size) {
// Skip the last odd pixel.
q += pixel_size;
}
} else {
// Just one pixel.
for (int c = 0; c < num_color_components; ++c) {
// For each component.
filter_component(p, q, 0, row_size, 0);
}
if (alpha) {
filter_alpha(p, q, 0, row_size, 0);
}
}
q += row_size;
Thread::consider_yield();
}
if (y < y_size) {
// Skip the last odd row.
q += row_size;
}
} else {
// Just one row.
if (x_size != 1) {
int x;
for (x = 0; x < x_size - 1; x += 2) {
// For each pixel.
for (int c = 0; c < num_color_components; ++c) {
// For each component.
filter_component(p, q, pixel_size, 0, 0);
}
if (alpha) {
filter_alpha(p, q, pixel_size, 0, 0);
}
q += pixel_size;
}
if (x < x_size) {
// Skip the last odd pixel.
q += pixel_size;
}
} else {
// Just one pixel.
for (int c = 0; c < num_color_components; ++c) {
// For each component.
filter_component(p, q, 0, 0, 0);
}
if (alpha) {
filter_alpha(p, q, 0, 0, 0);
}
}
}
}
nassertv(p == start_to + to_z_size * to_page_size);
nassertv(q == start_from + z_size * page_size);
}
}
/**
* Averages a 2x2 block of pixel components into a single pixel component, for
* producing the next mipmap level. Increments p and q to the next component.
*/
void Texture::
filter_2d_unsigned_byte(unsigned char *&p, const unsigned char *&q,
size_t pixel_size, size_t row_size) {
unsigned int result = ((unsigned int)q[0] +
(unsigned int)q[pixel_size] +
(unsigned int)q[row_size] +
(unsigned int)q[pixel_size + row_size]) >> 2;
*p = (unsigned char)result;
++p;
++q;
}
/**
* Averages a 2x2 block of pixel components into a single pixel component, for
* producing the next mipmap level. Increments p and q to the next component.
*/
void Texture::
filter_2d_unsigned_byte_srgb(unsigned char *&p, const unsigned char *&q,
size_t pixel_size, size_t row_size) {
float result = (decode_sRGB_float(q[0]) +
decode_sRGB_float(q[pixel_size]) +
decode_sRGB_float(q[row_size]) +
decode_sRGB_float(q[pixel_size + row_size]));
*p = encode_sRGB_uchar(result * 0.25f);
++p;
++q;
}
/**
* Averages a 2x2 block of pixel components into a single pixel component, for
* producing the next mipmap level. Increments p and q to the next component.
*/
void Texture::
filter_2d_unsigned_byte_srgb_sse2(unsigned char *&p, const unsigned char *&q,
size_t pixel_size, size_t row_size) {
float result = (decode_sRGB_float(q[0]) +
decode_sRGB_float(q[pixel_size]) +
decode_sRGB_float(q[row_size]) +
decode_sRGB_float(q[pixel_size + row_size]));
*p = encode_sRGB_uchar_sse2(result * 0.25f);
++p;
++q;
}
/**
* Averages a 2x2 block of pixel components into a single pixel component, for
* producing the next mipmap level. Increments p and q to the next component.
*/
void Texture::
filter_2d_unsigned_short(unsigned char *&p, const unsigned char *&q,
size_t pixel_size, size_t row_size) {
unsigned int result = ((unsigned int)*(unsigned short *)&q[0] +
(unsigned int)*(unsigned short *)&q[pixel_size] +
(unsigned int)*(unsigned short *)&q[row_size] +
(unsigned int)*(unsigned short *)&q[pixel_size + row_size]) >> 2;
store_unscaled_short(p, result);
q += 2;
}
/**
* Averages a 2x2 block of pixel components into a single pixel component, for
* producing the next mipmap level. Increments p and q to the next component.
*/
void Texture::
filter_2d_float(unsigned char *&p, const unsigned char *&q,
size_t pixel_size, size_t row_size) {
*(float *)p = (*(float *)&q[0] +
*(float *)&q[pixel_size] +
*(float *)&q[row_size] +
*(float *)&q[pixel_size + row_size]) / 4.0f;
p += 4;
q += 4;
}
/**
* Averages a 2x2x2 block of pixel components into a single pixel component,
* for producing the next mipmap level. Increments p and q to the next
* component.
*/
void Texture::
filter_3d_unsigned_byte(unsigned char *&p, const unsigned char *&q,
size_t pixel_size, size_t row_size, size_t page_size) {
unsigned int result = ((unsigned int)q[0] +
(unsigned int)q[pixel_size] +
(unsigned int)q[row_size] +
(unsigned int)q[pixel_size + row_size] +
(unsigned int)q[page_size] +
(unsigned int)q[pixel_size + page_size] +
(unsigned int)q[row_size + page_size] +
(unsigned int)q[pixel_size + row_size + page_size]) >> 3;
*p = (unsigned char)result;
++p;
++q;
}
/**
* Averages a 2x2x2 block of pixel components into a single pixel component,
* for producing the next mipmap level. Increments p and q to the next
* component.
*/
void Texture::
filter_3d_unsigned_byte_srgb(unsigned char *&p, const unsigned char *&q,
size_t pixel_size, size_t row_size, size_t page_size) {
float result = (decode_sRGB_float(q[0]) +
decode_sRGB_float(q[pixel_size]) +
decode_sRGB_float(q[row_size]) +
decode_sRGB_float(q[pixel_size + row_size]) +
decode_sRGB_float(q[page_size]) +
decode_sRGB_float(q[pixel_size + page_size]) +
decode_sRGB_float(q[row_size + page_size]) +
decode_sRGB_float(q[pixel_size + row_size + page_size]));
*p = encode_sRGB_uchar(result * 0.125f);
++p;
++q;
}
/**
* Averages a 2x2x2 block of pixel components into a single pixel component,
* for producing the next mipmap level. Increments p and q to the next
* component.
*/
void Texture::
filter_3d_unsigned_byte_srgb_sse2(unsigned char *&p, const unsigned char *&q,
size_t pixel_size, size_t row_size, size_t page_size) {
float result = (decode_sRGB_float(q[0]) +
decode_sRGB_float(q[pixel_size]) +
decode_sRGB_float(q[row_size]) +
decode_sRGB_float(q[pixel_size + row_size]) +
decode_sRGB_float(q[page_size]) +
decode_sRGB_float(q[pixel_size + page_size]) +
decode_sRGB_float(q[row_size + page_size]) +
decode_sRGB_float(q[pixel_size + row_size + page_size]));
*p = encode_sRGB_uchar_sse2(result * 0.125f);
++p;
++q;
}
/**
* Averages a 2x2x2 block of pixel components into a single pixel component,
* for producing the next mipmap level. Increments p and q to the next
* component.
*/
void Texture::
filter_3d_unsigned_short(unsigned char *&p, const unsigned char *&q,
size_t pixel_size, size_t row_size,
size_t page_size) {
unsigned int result = ((unsigned int)*(unsigned short *)&q[0] +
(unsigned int)*(unsigned short *)&q[pixel_size] +
(unsigned int)*(unsigned short *)&q[row_size] +
(unsigned int)*(unsigned short *)&q[pixel_size + row_size] +
(unsigned int)*(unsigned short *)&q[page_size] +
(unsigned int)*(unsigned short *)&q[pixel_size + page_size] +
(unsigned int)*(unsigned short *)&q[row_size + page_size] +
(unsigned int)*(unsigned short *)&q[pixel_size + row_size + page_size]) >> 3;
store_unscaled_short(p, result);
q += 2;
}
/**
* Averages a 2x2x2 block of pixel components into a single pixel component,
* for producing the next mipmap level. Increments p and q to the next
* component.
*/
void Texture::
filter_3d_float(unsigned char *&p, const unsigned char *&q,
size_t pixel_size, size_t row_size, size_t page_size) {
*(float *)p = (*(float *)&q[0] +
*(float *)&q[pixel_size] +
*(float *)&q[row_size] +
*(float *)&q[pixel_size + row_size] +
*(float *)&q[page_size] +
*(float *)&q[pixel_size + page_size] +
*(float *)&q[row_size + page_size] +
*(float *)&q[pixel_size + row_size + page_size]) / 8.0f;
p += 4;
q += 4;
}
/**
* Invokes the squish library to compress the RAM image(s).
*/
bool Texture::
do_squish(CData *cdata, Texture::CompressionMode compression, int squish_flags) {
#ifdef HAVE_SQUISH
if (!do_has_all_ram_mipmap_images(cdata)) {
// If we're about to compress the RAM image, we should ensure that we have
// all of the mipmap levels first.
do_generate_ram_mipmap_images(cdata, false);
}
RamImages compressed_ram_images;
compressed_ram_images.reserve(cdata->_ram_images.size());
for (size_t n = 0; n < cdata->_ram_images.size(); ++n) {
RamImage compressed_image;
int x_size = do_get_expected_mipmap_x_size(cdata, n);
int y_size = do_get_expected_mipmap_y_size(cdata, n);
int num_pages = do_get_expected_mipmap_num_pages(cdata, n);
int page_size = squish::GetStorageRequirements(x_size, y_size, squish_flags);
int cell_size = squish::GetStorageRequirements(4, 4, squish_flags);
compressed_image._page_size = page_size;
compressed_image._image = PTA_uchar::empty_array(page_size * num_pages);
for (int z = 0; z < num_pages; ++z) {
unsigned char *dest_page = compressed_image._image.p() + z * page_size;
unsigned const char *source_page = cdata->_ram_images[n]._image.p() + z * cdata->_ram_images[n]._page_size;
unsigned const char *source_page_end = source_page + cdata->_ram_images[n]._page_size;
// Convert one 4 x 4 cell at a time.
unsigned char *d = dest_page;
for (int y = 0; y < y_size; y += 4) {
for (int x = 0; x < x_size; x += 4) {
unsigned char tb[16 * 4];
int mask = 0;
unsigned char *t = tb;
for (int i = 0; i < 16; ++i) {
int xi = x + i % 4;
int yi = y + i / 4;
unsigned const char *s = source_page + (yi * x_size + xi) * cdata->_num_components;
if (s < source_page_end) {
switch (cdata->_num_components) {
case 1:
t[0] = s[0]; // r
t[1] = s[0]; // g
t[2] = s[0]; // b
t[3] = 255; // a
break;
case 2:
t[0] = s[0]; // r
t[1] = s[0]; // g
t[2] = s[0]; // b
t[3] = s[1]; // a
break;
case 3:
t[0] = s[2]; // r
t[1] = s[1]; // g
t[2] = s[0]; // b
t[3] = 255; // a
break;
case 4:
t[0] = s[2]; // r
t[1] = s[1]; // g
t[2] = s[0]; // b
t[3] = s[3]; // a
break;
}
mask |= (1 << i);
}
t += 4;
}
squish::CompressMasked(tb, mask, d, squish_flags);
d += cell_size;
Thread::consider_yield();
}
}
}
compressed_ram_images.push_back(compressed_image);
}
cdata->_ram_images.swap(compressed_ram_images);
cdata->_ram_image_compression = compression;
return true;
#else // HAVE_SQUISH
return false;
#endif // HAVE_SQUISH
}
/**
* Invokes the squish library to uncompress the RAM image(s).
*/
bool Texture::
do_unsquish(CData *cdata, int squish_flags) {
#ifdef HAVE_SQUISH
RamImages uncompressed_ram_images;
uncompressed_ram_images.reserve(cdata->_ram_images.size());
for (size_t n = 0; n < cdata->_ram_images.size(); ++n) {
RamImage uncompressed_image;
int x_size = do_get_expected_mipmap_x_size(cdata, n);
int y_size = do_get_expected_mipmap_y_size(cdata, n);
int num_pages = do_get_expected_mipmap_num_pages(cdata, n);
int page_size = squish::GetStorageRequirements(x_size, y_size, squish_flags);
int cell_size = squish::GetStorageRequirements(4, 4, squish_flags);
uncompressed_image._page_size = do_get_expected_ram_mipmap_page_size(cdata, n);
uncompressed_image._image = PTA_uchar::empty_array(uncompressed_image._page_size * num_pages);
for (int z = 0; z < num_pages; ++z) {
unsigned char *dest_page = uncompressed_image._image.p() + z * uncompressed_image._page_size;
unsigned char *dest_page_end = dest_page + uncompressed_image._page_size;
unsigned const char *source_page = cdata->_ram_images[n]._image.p() + z * page_size;
// Unconvert one 4 x 4 cell at a time.
unsigned const char *s = source_page;
for (int y = 0; y < y_size; y += 4) {
for (int x = 0; x < x_size; x += 4) {
unsigned char tb[16 * 4];
squish::Decompress(tb, s, squish_flags);
s += cell_size;
unsigned char *t = tb;
for (int i = 0; i < 16; ++i) {
int xi = x + i % 4;
int yi = y + i / 4;
unsigned char *d = dest_page + (yi * x_size + xi) * cdata->_num_components;
if (d < dest_page_end) {
switch (cdata->_num_components) {
case 1:
d[0] = t[1]; // g
break;
case 2:
d[0] = t[1]; // g
d[1] = t[3]; // a
break;
case 3:
d[2] = t[0]; // r
d[1] = t[1]; // g
d[0] = t[2]; // b
break;
case 4:
d[2] = t[0]; // r
d[1] = t[1]; // g
d[0] = t[2]; // b
d[3] = t[3]; // a
break;
}
}
t += 4;
}
}
Thread::consider_yield();
}
}
uncompressed_ram_images.push_back(uncompressed_image);
}
cdata->_ram_images.swap(uncompressed_ram_images);
cdata->_ram_image_compression = CM_off;
return true;
#else // HAVE_SQUISH
return false;
#endif // HAVE_SQUISH
}
/**
* Factory method to generate a Texture object
*/
void Texture::
register_with_read_factory() {
BamReader::get_factory()->register_factory(get_class_type(), make_from_bam);
}
/**
* Function to write the important information in the particular object to a
* Datagram
*/
void Texture::
write_datagram(BamWriter *manager, Datagram &me) {
CDWriter cdata(_cycler, false);
bool has_rawdata = false;
do_write_datagram_header(cdata, manager, me, has_rawdata);
do_write_datagram_body(cdata, manager, me);
// If we are also including the texture's image data, then stuff it in here.
if (has_rawdata) {
do_write_datagram_rawdata(cdata, manager, me);
}
}
/**
* Called by the BamReader to perform any final actions needed for setting up
* the object after all objects have been read and all pointers have been
* completed.
*/
void Texture::
finalize(BamReader *) {
// Unref the pointer that we explicitly reffed in make_from_bam().
unref();
// We should never get back to zero after unreffing our own count, because
// we expect to have been stored in a pointer somewhere. If we do get to
// zero, it's a memory leak; the way to avoid this is to call unref_delete()
// above instead of unref(), but this is dangerous to do from within a
// virtual function.
nassertv(get_ref_count() != 0);
}
/**
* Writes the header part of the texture to the Datagram. This is the common
* part that is shared by all Texture subclasses, and contains the filename
* and rawdata flags. This method is not virtual because all Texture
* subclasses must write the same data at this step.
*
* This part must be read first before calling do_fillin_body() to determine
* whether to load the Texture from the TexturePool or directly from the bam
* stream.
*
* After this call, has_rawdata will be filled with either true or false,
* according to whether we expect to write the texture rawdata to the bam
* stream following the texture body.
*/
void Texture::
do_write_datagram_header(CData *cdata, BamWriter *manager, Datagram &me, bool &has_rawdata) {
// Write out the texture's raw pixel data if (a) the current Bam Texture
// Mode requires that, or (b) there's no filename, so the file can't be
// loaded up from disk, but the raw pixel data is currently available in
// RAM.
// Otherwise, we just write out the filename, and assume whoever loads the
// bam file later will have access to the image file on disk.
BamWriter::BamTextureMode file_texture_mode = manager->get_file_texture_mode();
has_rawdata = (file_texture_mode == BamWriter::BTM_rawdata ||
(cdata->_filename.empty() && do_has_bam_rawdata(cdata)));
if (has_rawdata && !do_has_bam_rawdata(cdata)) {
do_get_bam_rawdata(cdata);
if (!do_has_bam_rawdata(cdata)) {
// No image data after all.
has_rawdata = false;
}
}
bool has_bam_dir = !manager->get_filename().empty();
Filename bam_dir = manager->get_filename().get_dirname();
Filename filename = cdata->_filename;
Filename alpha_filename = cdata->_alpha_filename;
VirtualFileSystem *vfs = VirtualFileSystem::get_global_ptr();
switch (file_texture_mode) {
case BamWriter::BTM_unchanged:
case BamWriter::BTM_rawdata:
break;
case BamWriter::BTM_fullpath:
filename = cdata->_fullpath;
alpha_filename = cdata->_alpha_fullpath;
break;
case BamWriter::BTM_relative:
filename = cdata->_fullpath;
alpha_filename = cdata->_alpha_fullpath;
bam_dir.make_absolute(vfs->get_cwd());
if (!has_bam_dir || !filename.make_relative_to(bam_dir, true)) {
filename.find_on_searchpath(get_model_path());
}
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< "Texture file " << cdata->_fullpath
<< " found as " << filename << "\n";
}
if (!has_bam_dir || !alpha_filename.make_relative_to(bam_dir, true)) {
alpha_filename.find_on_searchpath(get_model_path());
}
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< "Alpha image " << cdata->_alpha_fullpath
<< " found as " << alpha_filename << "\n";
}
break;
case BamWriter::BTM_basename:
filename = cdata->_fullpath.get_basename();
alpha_filename = cdata->_alpha_fullpath.get_basename();
break;
default:
gobj_cat.error()
<< "Unsupported bam-texture-mode: " << (int)file_texture_mode << "\n";
}
if (filename.empty() && do_has_bam_rawdata(cdata)) {
// If we don't have a filename, we have to store rawdata anyway.
has_rawdata = true;
}
me.add_string(get_name());
me.add_string(filename);
me.add_string(alpha_filename);
me.add_uint8(cdata->_primary_file_num_channels);
me.add_uint8(cdata->_alpha_file_channel);
me.add_bool(has_rawdata);
if (manager->get_file_minor_ver() < 25 &&
cdata->_texture_type == TT_cube_map) {
// Between Panda3D releases 1.7.2 and 1.8.0 (bam versions 6.24 and 6.25),
// we added TT_2d_texture_array, shifting the definition for TT_cube_map.
me.add_uint8(TT_2d_texture_array);
} else {
me.add_uint8(cdata->_texture_type);
}
if (manager->get_file_minor_ver() >= 32) {
me.add_bool(cdata->_has_read_mipmaps);
}
}
/**
* Writes the body part of the texture to the Datagram. This is generally all
* of the texture parameters except for the header and the rawdata.
*/
void Texture::
do_write_datagram_body(CData *cdata, BamWriter *manager, Datagram &me) {
if (manager->get_file_minor_ver() >= 36) {
cdata->_default_sampler.write_datagram(me);
} else {
const SamplerState &s = cdata->_default_sampler;
me.add_uint8(s.get_wrap_u());
me.add_uint8(s.get_wrap_v());
me.add_uint8(s.get_wrap_w());
me.add_uint8(s.get_minfilter());
me.add_uint8(s.get_magfilter());
me.add_int16(s.get_anisotropic_degree());
s.get_border_color().write_datagram(me);
}
me.add_uint8(cdata->_compression);
me.add_uint8(cdata->_quality_level);
me.add_uint8(cdata->_format);
me.add_uint8(cdata->_num_components);
if (cdata->_texture_type == TT_buffer_texture) {
me.add_uint8(cdata->_usage_hint);
}
if (manager->get_file_minor_ver() >= 28) {
me.add_uint8(cdata->_auto_texture_scale);
}
me.add_uint32(cdata->_orig_file_x_size);
me.add_uint32(cdata->_orig_file_y_size);
bool has_simple_ram_image = !cdata->_simple_ram_image._image.empty();
me.add_bool(has_simple_ram_image);
// Write out the simple image too, so it will be available later.
if (has_simple_ram_image) {
me.add_uint32(cdata->_simple_x_size);
me.add_uint32(cdata->_simple_y_size);
me.add_int32(cdata->_simple_image_date_generated);
me.add_uint32(cdata->_simple_ram_image._image.size());
me.append_data(cdata->_simple_ram_image._image, cdata->_simple_ram_image._image.size());
}
}
/**
* Writes the rawdata part of the texture to the Datagram.
*/
void Texture::
do_write_datagram_rawdata(CData *cdata, BamWriter *manager, Datagram &me) {
me.add_uint32(cdata->_x_size);
me.add_uint32(cdata->_y_size);
me.add_uint32(cdata->_z_size);
if (manager->get_file_minor_ver() >= 30) {
me.add_uint32(cdata->_pad_x_size);
me.add_uint32(cdata->_pad_y_size);
me.add_uint32(cdata->_pad_z_size);
}
if (manager->get_file_minor_ver() >= 26) {
me.add_uint32(cdata->_num_views);
}
me.add_uint8(cdata->_component_type);
me.add_uint8(cdata->_component_width);
me.add_uint8(cdata->_ram_image_compression);
me.add_uint8(cdata->_ram_images.size());
for (size_t n = 0; n < cdata->_ram_images.size(); ++n) {
me.add_uint32(cdata->_ram_images[n]._page_size);
me.add_uint32(cdata->_ram_images[n]._image.size());
me.append_data(cdata->_ram_images[n]._image, cdata->_ram_images[n]._image.size());
}
}
/**
* Factory method to generate a Texture object
*/
TypedWritable *Texture::
make_from_bam(const FactoryParams &params) {
PT(Texture) dummy = new Texture;
return dummy->make_this_from_bam(params);
}
/**
* Called by make_from_bam() once the particular subclass of Texture is known.
* This is called on a newly-constructed Texture object of the appropriate
* subclass. It will return either the same Texture object (e.g. this), or a
* different Texture object loaded via the TexturePool, as appropriate.
*/
TypedWritable *Texture::
make_this_from_bam(const FactoryParams &params) {
// The process of making a texture is slightly different than making other
// TypedWritable objects. That is because all creation of Textures should
// be done through calls to TexturePool, which ensures that any loads of the
// same filename refer to the same memory.
DatagramIterator scan;
BamReader *manager;
parse_params(params, scan, manager);
// Get the header information--the filenames and texture type--so we can
// look up the file on disk first.
string name = scan.get_string();
Filename filename = scan.get_string();
Filename alpha_filename = scan.get_string();
int primary_file_num_channels = scan.get_uint8();
int alpha_file_channel = scan.get_uint8();
bool has_rawdata = scan.get_bool();
TextureType texture_type = (TextureType)scan.get_uint8();
if (manager->get_file_minor_ver() < 25) {
// Between Panda3D releases 1.7.2 and 1.8.0 (bam versions 6.24 and 6.25),
// we added TT_2d_texture_array, shifting the definition for TT_cube_map.
if (texture_type == TT_2d_texture_array) {
texture_type = TT_cube_map;
}
}
bool has_read_mipmaps = false;
if (manager->get_file_minor_ver() >= 32) {
has_read_mipmaps = scan.get_bool();
}
Texture *me = nullptr;
if (has_rawdata) {
// If the raw image data is included, then just load the texture directly
// from the stream, and return it. In this case we return the "this"
// pointer, since it's a newly-created Texture object of the appropriate
// type.
me = this;
me->set_name(name);
CDWriter cdata_me(me->_cycler, true);
cdata_me->_filename = filename;
cdata_me->_alpha_filename = alpha_filename;
cdata_me->_primary_file_num_channels = primary_file_num_channels;
cdata_me->_alpha_file_channel = alpha_file_channel;
cdata_me->_texture_type = texture_type;
cdata_me->_has_read_mipmaps = has_read_mipmaps;
// Read the texture attributes directly from the bam stream.
me->do_fillin_body(cdata_me, scan, manager);
me->do_fillin_rawdata(cdata_me, scan, manager);
// To manage the reference count, explicitly ref it now, then unref it in
// the finalize callback.
me->ref();
manager->register_finalize(me);
} else {
// The raw image data isn't included, so we'll be loading the Texture via
// the TexturePool. In this case we use the "this" pointer as a temporary
// object to read all of the attributes from the bam stream.
Texture *dummy = this;
AutoTextureScale auto_texture_scale = ATS_unspecified;
{
CDWriter cdata_dummy(dummy->_cycler, true);
dummy->do_fillin_body(cdata_dummy, scan, manager);
auto_texture_scale = cdata_dummy->_auto_texture_scale;
}
if (filename.empty()) {
// This texture has no filename; since we don't have an image to load,
// we can't actually create the texture.
gobj_cat.info()
<< "Cannot create texture '" << name << "' with no filename.\n";
} else {
// This texture does have a filename, so try to load it from disk.
VirtualFileSystem *vfs = VirtualFileSystem::get_global_ptr();
if (!manager->get_filename().empty()) {
// If texture filename was given relative to the bam filename, expand
// it now.
Filename bam_dir = manager->get_filename().get_dirname();
vfs->resolve_filename(filename, bam_dir);
if (!alpha_filename.empty()) {
vfs->resolve_filename(alpha_filename, bam_dir);
}
}
LoaderOptions options = manager->get_loader_options();
if (dummy->uses_mipmaps()) {
options.set_texture_flags(options.get_texture_flags() | LoaderOptions::TF_generate_mipmaps);
}
options.set_auto_texture_scale(auto_texture_scale);
switch (texture_type) {
case TT_buffer_texture:
case TT_1d_texture:
case TT_2d_texture:
case TT_1d_texture_array:
if (alpha_filename.empty()) {
me = TexturePool::load_texture(filename, primary_file_num_channels,
has_read_mipmaps, options);
} else {
me = TexturePool::load_texture(filename, alpha_filename,
primary_file_num_channels,
alpha_file_channel,
has_read_mipmaps, options);
}
break;
case TT_3d_texture:
me = TexturePool::load_3d_texture(filename, has_read_mipmaps, options);
break;
case TT_2d_texture_array:
case TT_cube_map_array:
me = TexturePool::load_2d_texture_array(filename, has_read_mipmaps, options);
break;
case TT_cube_map:
me = TexturePool::load_cube_map(filename, has_read_mipmaps, options);
break;
}
}
if (me != nullptr) {
me->set_name(name);
CDWriter cdata_me(me->_cycler, true);
me->do_fillin_from(cdata_me, dummy);
// Since in this case me was loaded from the TexturePool, there's no
// need to explicitly manage the reference count. TexturePool will hold
// it safely.
}
}
return me;
}
/**
* Reads in the part of the Texture that was written with
* do_write_datagram_body().
*/
void Texture::
do_fillin_body(CData *cdata, DatagramIterator &scan, BamReader *manager) {
cdata->_default_sampler.read_datagram(scan, manager);
if (manager->get_file_minor_ver() >= 1) {
cdata->_compression = (CompressionMode)scan.get_uint8();
}
if (manager->get_file_minor_ver() >= 16) {
cdata->_quality_level = (QualityLevel)scan.get_uint8();
}
cdata->_format = (Format)scan.get_uint8();
cdata->_num_components = scan.get_uint8();
if (cdata->_texture_type == TT_buffer_texture) {
cdata->_usage_hint = (GeomEnums::UsageHint)scan.get_uint8();
}
cdata->inc_properties_modified();
cdata->_auto_texture_scale = ATS_unspecified;
if (manager->get_file_minor_ver() >= 28) {
cdata->_auto_texture_scale = (AutoTextureScale)scan.get_uint8();
}
bool has_simple_ram_image = false;
if (manager->get_file_minor_ver() >= 18) {
cdata->_orig_file_x_size = scan.get_uint32();
cdata->_orig_file_y_size = scan.get_uint32();
has_simple_ram_image = scan.get_bool();
}
if (has_simple_ram_image) {
cdata->_simple_x_size = scan.get_uint32();
cdata->_simple_y_size = scan.get_uint32();
cdata->_simple_image_date_generated = scan.get_int32();
size_t u_size = scan.get_uint32();
// Protect against large allocation.
if (u_size > scan.get_remaining_size()) {
gobj_cat.error()
<< "simple RAM image extends past end of datagram, is texture corrupt?\n";
return;
}
PTA_uchar image = PTA_uchar::empty_array(u_size, get_class_type());
scan.extract_bytes(image.p(), u_size);
cdata->_simple_ram_image._image = image;
cdata->_simple_ram_image._page_size = u_size;
cdata->inc_simple_image_modified();
}
}
/**
* Reads in the part of the Texture that was written with
* do_write_datagram_rawdata().
*/
void Texture::
do_fillin_rawdata(CData *cdata, DatagramIterator &scan, BamReader *manager) {
cdata->_x_size = scan.get_uint32();
cdata->_y_size = scan.get_uint32();
cdata->_z_size = scan.get_uint32();
if (manager->get_file_minor_ver() >= 30) {
cdata->_pad_x_size = scan.get_uint32();
cdata->_pad_y_size = scan.get_uint32();
cdata->_pad_z_size = scan.get_uint32();
} else {
do_set_pad_size(cdata, 0, 0, 0);
}
cdata->_num_views = 1;
if (manager->get_file_minor_ver() >= 26) {
cdata->_num_views = scan.get_uint32();
}
cdata->_component_type = (ComponentType)scan.get_uint8();
cdata->_component_width = scan.get_uint8();
cdata->_ram_image_compression = CM_off;
if (manager->get_file_minor_ver() >= 1) {
cdata->_ram_image_compression = (CompressionMode)scan.get_uint8();
}
int num_ram_images = 1;
if (manager->get_file_minor_ver() >= 3) {
num_ram_images = scan.get_uint8();
}
cdata->_ram_images.clear();
cdata->_ram_images.reserve(num_ram_images);
for (int n = 0; n < num_ram_images; ++n) {
cdata->_ram_images.push_back(RamImage());
cdata->_ram_images[n]._page_size = get_expected_ram_page_size();
if (manager->get_file_minor_ver() >= 1) {
cdata->_ram_images[n]._page_size = scan.get_uint32();
}
// fill the cdata->_image buffer with image data
size_t u_size = scan.get_uint32();
// Protect against large allocation.
if (u_size > scan.get_remaining_size()) {
gobj_cat.error()
<< "RAM image " << n << " extends past end of datagram, is texture corrupt?\n";
return;
}
PTA_uchar image = PTA_uchar::empty_array(u_size, get_class_type());
scan.extract_bytes(image.p(), u_size);
cdata->_ram_images[n]._image = image;
}
cdata->_loaded_from_image = true;
cdata->inc_image_modified();
}
/**
* Called in make_from_bam(), this method properly copies the attributes from
* the bam stream (as stored in dummy) into this texture, updating the
* modified flags appropriately.
*/
void Texture::
do_fillin_from(CData *cdata, const Texture *dummy) {
// Use the setters instead of setting these directly, so we can correctly
// avoid incrementing cdata->_properties_modified if none of these actually
// change. (Otherwise, we'd have to reload the texture to the GSG every
// time we loaded a new bam file that reference the texture, since each bam
// file reference passes through this function.)
CDReader cdata_dummy(dummy->_cycler);
do_set_wrap_u(cdata, cdata_dummy->_default_sampler.get_wrap_u());
do_set_wrap_v(cdata, cdata_dummy->_default_sampler.get_wrap_v());
do_set_wrap_w(cdata, cdata_dummy->_default_sampler.get_wrap_w());
do_set_border_color(cdata, cdata_dummy->_default_sampler.get_border_color());
if (cdata_dummy->_default_sampler.get_minfilter() != SamplerState::FT_default) {
do_set_minfilter(cdata, cdata_dummy->_default_sampler.get_minfilter());
}
if (cdata_dummy->_default_sampler.get_magfilter() != SamplerState::FT_default) {
do_set_magfilter(cdata, cdata_dummy->_default_sampler.get_magfilter());
}
if (cdata_dummy->_default_sampler.get_anisotropic_degree() != 0) {
do_set_anisotropic_degree(cdata, cdata_dummy->_default_sampler.get_anisotropic_degree());
}
if (cdata_dummy->_compression != CM_default) {
do_set_compression(cdata, cdata_dummy->_compression);
}
if (cdata_dummy->_quality_level != QL_default) {
do_set_quality_level(cdata, cdata_dummy->_quality_level);
}
Format format = cdata_dummy->_format;
int num_components = cdata_dummy->_num_components;
if (num_components == cdata->_num_components) {
// Only reset the format if the number of components hasn't changed, since
// if the number of components has changed our texture no longer matches
// what it was when the bam was written.
do_set_format(cdata, format);
}
if (!cdata_dummy->_simple_ram_image._image.empty()) {
// Only replace the simple ram image if it was generated more recently
// than the one we already have.
if (cdata->_simple_ram_image._image.empty() ||
cdata_dummy->_simple_image_date_generated > cdata->_simple_image_date_generated) {
do_set_simple_ram_image(cdata,
cdata_dummy->_simple_ram_image._image,
cdata_dummy->_simple_x_size,
cdata_dummy->_simple_y_size);
cdata->_simple_image_date_generated = cdata_dummy->_simple_image_date_generated;
}
}
}
/**
*
*/
Texture::CData::
CData() {
_primary_file_num_channels = 0;
_alpha_file_channel = 0;
_keep_ram_image = true;
_compression = CM_default;
_auto_texture_scale = ATS_unspecified;
_ram_image_compression = CM_off;
_render_to_texture = false;
_match_framebuffer_format = false;
_post_load_store_cache = false;
_quality_level = QL_default;
_texture_type = TT_2d_texture;
_x_size = 0;
_y_size = 1;
_z_size = 1;
_num_views = 1;
// We will override the format in a moment (in the Texture constructor), but
// set it to something else first to avoid the check in do_set_format
// depending on an uninitialized value.
_format = F_rgba;
// Only used for buffer textures.
_usage_hint = GeomEnums::UH_unspecified;
_pad_x_size = 0;
_pad_y_size = 0;
_pad_z_size = 0;
_orig_file_x_size = 0;
_orig_file_y_size = 0;
_loaded_from_image = false;
_loaded_from_txo = false;
_has_read_pages = false;
_has_read_mipmaps = false;
_num_mipmap_levels_read = 0;
_simple_x_size = 0;
_simple_y_size = 0;
_simple_ram_image._page_size = 0;
_has_clear_color = false;
}
/**
*
*/
Texture::CData::
CData(const Texture::CData &copy) {
_num_mipmap_levels_read = 0;
do_assign(&copy);
_properties_modified = copy._properties_modified;
_image_modified = copy._image_modified;
_simple_image_modified = copy._simple_image_modified;
}
/**
*
*/
CycleData *Texture::CData::
make_copy() const {
return new CData(*this);
}
/**
*
*/
void Texture::CData::
do_assign(const Texture::CData *copy) {
_filename = copy->_filename;
_alpha_filename = copy->_alpha_filename;
if (!copy->_fullpath.empty()) {
// Since the fullpath is often empty on a file loaded directly from a txo,
// we only assign the fullpath if it is not empty.
_fullpath = copy->_fullpath;
_alpha_fullpath = copy->_alpha_fullpath;
}
_primary_file_num_channels = copy->_primary_file_num_channels;
_alpha_file_channel = copy->_alpha_file_channel;
_x_size = copy->_x_size;
_y_size = copy->_y_size;
_z_size = copy->_z_size;
_num_views = copy->_num_views;
_pad_x_size = copy->_pad_x_size;
_pad_y_size = copy->_pad_y_size;
_pad_z_size = copy->_pad_z_size;
_orig_file_x_size = copy->_orig_file_x_size;
_orig_file_y_size = copy->_orig_file_y_size;
_num_components = copy->_num_components;
_component_width = copy->_component_width;
_texture_type = copy->_texture_type;
_format = copy->_format;
_component_type = copy->_component_type;
_loaded_from_image = copy->_loaded_from_image;
_loaded_from_txo = copy->_loaded_from_txo;
_has_read_pages = copy->_has_read_pages;
_has_read_mipmaps = copy->_has_read_mipmaps;
_num_mipmap_levels_read = copy->_num_mipmap_levels_read;
_default_sampler = copy->_default_sampler;
_keep_ram_image = copy->_keep_ram_image;
_compression = copy->_compression;
_match_framebuffer_format = copy->_match_framebuffer_format;
_quality_level = copy->_quality_level;
_auto_texture_scale = copy->_auto_texture_scale;
_ram_image_compression = copy->_ram_image_compression;
_ram_images = copy->_ram_images;
_simple_x_size = copy->_simple_x_size;
_simple_y_size = copy->_simple_y_size;
_simple_ram_image = copy->_simple_ram_image;
}
/**
* Writes the contents of this object to the datagram for shipping out to a
* Bam file.
*/
void Texture::CData::
write_datagram(BamWriter *manager, Datagram &dg) const {
}
/**
* Receives an array of pointers, one for each time manager->read_pointer()
* was called in fillin(). Returns the number of pointers processed.
*/
int Texture::CData::
complete_pointers(TypedWritable **p_list, BamReader *manager) {
return 0;
}
/**
* This internal function is called by make_from_bam to read in all of the
* relevant data from the BamFile for the new Geom.
*/
void Texture::CData::
fillin(DatagramIterator &scan, BamReader *manager) {
}
/**
*
*/
ostream &
operator << (ostream &out, Texture::TextureType tt) {
return out << Texture::format_texture_type(tt);
}
/**
*
*/
ostream &
operator << (ostream &out, Texture::ComponentType ct) {
return out << Texture::format_component_type(ct);
}
/**
*
*/
ostream &
operator << (ostream &out, Texture::Format f) {
return out << Texture::format_format(f);
}
/**
*
*/
ostream &
operator << (ostream &out, Texture::CompressionMode cm) {
return out << Texture::format_compression_mode(cm);
}
/**
*
*/
ostream &
operator << (ostream &out, Texture::QualityLevel tql) {
return out << Texture::format_quality_level(tql);
}
/**
*
*/
istream &
operator >> (istream &in, Texture::QualityLevel &tql) {
string word;
in >> word;
tql = Texture::string_quality_level(word);
return in;
}
Reference in New Issue View Git Blame Copy Permalink