texture.I

Go to the documentation of this file.

/**
 * 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.I
 * @author drose
 * @date 1999-02-05
 * @author fperazzi, PandaSE
 * @date 2010-04-29
 */

/**
 * Returns a new copy of the same Texture.  This copy, if applied to geometry,
 * will be copied into texture as a separate texture from the original, so it
 * will be duplicated in texture memory (and may be independently modified if
 * desired).
 *
 * If the Texture is a VideoTexture, the resulting duplicate may be animated
 * independently of the original.
 */
INLINE PT(Texture) Texture::
make_copy() const {
  PT(Texture) tex = make_copy_impl();
  CDWriter cdata_tex(tex->_cycler, true);
  cdata_tex->inc_properties_modified();
  cdata_tex->inc_image_modified();
  cdata_tex->inc_simple_image_modified();
  return tex;
}

/**
 * Reinitializes the texture to its default, empty state (except for the
 * name).
 */
INLINE void Texture::
clear() {
  CDWriter cdata(_cycler, true);
  do_clear(cdata);
}

/**
 * Sets the texture to the indicated type and dimensions, presumably in
 * preparation for calling read() or load(), or set_ram_image() or
 * modify_ram_image(), or use set_clear_color to let the texture be cleared to
 * a solid color.
 */
INLINE void Texture::
setup_texture(Texture::TextureType texture_type, int x_size, int y_size,
              int z_size, Texture::ComponentType component_type,
              Texture::Format format) {
  CDWriter cdata(_cycler, true);
  do_setup_texture(cdata, texture_type, x_size, y_size, z_size,
                   component_type, format);
}

/**
 * Sets the texture as an empty 1-d texture with no dimensions.  Follow up
 * with read() or load() to fill the texture properties and image data, or use
 * set_clear_color to let the texture be cleared to a solid color.
 */
INLINE void Texture::
setup_1d_texture() {
  setup_1d_texture(0, T_unsigned_byte, F_rgb);
}

/**
 * Sets the texture as an empty 1-d texture with the specified dimensions and
 * properties.  Follow up with set_ram_image() or modify_ram_image() to fill
 * the image data, or use set_clear_color to let the texture be cleared to a
 * solid color.
 */
INLINE void Texture::
setup_1d_texture(int x_size, ComponentType component_type, Format format) {
  setup_texture(TT_1d_texture, x_size, 1, 1, component_type, format);
}

/**
 * Sets the texture as an empty 2-d texture with no dimensions.  Follow up
 * with read() or load() to fill the texture properties and image data, or use
 * set_clear_color to let the texture be cleared to a solid color.
 */
INLINE void Texture::
setup_2d_texture() {
  setup_2d_texture(0, 1, T_unsigned_byte, F_rgb);
}

/**
 * Sets the texture as an empty 2-d texture with the specified dimensions and
 * properties.  Follow up with set_ram_image() or modify_ram_image() to fill
 * the image data, or use set_clear_color to let the texture be cleared to a
 * solid color.
 */
INLINE void Texture::
setup_2d_texture(int x_size, int y_size, ComponentType component_type,
                 Format format) {
  setup_texture(TT_2d_texture, x_size, y_size, 1, component_type, format);
}

/**
 * Sets the texture as an empty 3-d texture with no dimensions (though if you
 * know the depth ahead of time, it saves a bit of reallocation later). Follow
 * up with read() or load() to fill the texture properties and image data, or
 * use set_clear_color to let the texture be cleared to a solid color.
 */
INLINE void Texture::
setup_3d_texture(int z_size) {
  setup_3d_texture(0, 1, z_size, T_unsigned_byte, F_rgb);
}

/**
 * Sets the texture as an empty 3-d texture with the specified dimensions and
 * properties.  Follow up with set_ram_image() or modify_ram_image() to fill
 * the image data.
 */
INLINE void Texture::
setup_3d_texture(int x_size, int y_size, int z_size,
                 ComponentType component_type, Format format) {
  setup_texture(TT_3d_texture, x_size, y_size, z_size, component_type, format);
}

/**
 * Sets the texture as an empty 2-d texture array with no dimensions (though
 * if you know the depth ahead of time, it saves a bit of reallocation later).
 * Follow up with read() or load() to fill the texture properties and image
 * data, or use set_clear_color to let the texture be cleared to a solid
 * color.
 */
INLINE void Texture::
setup_2d_texture_array(int z_size) {
  setup_2d_texture_array(0, 1, z_size, T_unsigned_byte, F_rgb);
}

/**
 * Sets the texture as an empty 2-d texture array with the specified
 * dimensions and properties.  Follow up with set_ram_image() or
 * modify_ram_image() to fill the image data, or use set_clear_color to let
 * the texture be cleared to a solid color.
 */
INLINE void Texture::
setup_2d_texture_array(int x_size, int y_size, int z_size,
                       ComponentType component_type, Format format) {
  setup_texture(TT_2d_texture_array, x_size, y_size, z_size, component_type, format);
}

/**
 * Sets the texture as an empty cube map texture with no dimensions.  Follow
 * up with read() or load() to fill the texture properties and image data, or
 * use set_clear_color to let the texture be cleared to a solid color.
 */
INLINE void Texture::
setup_cube_map() {
  setup_cube_map(0, T_unsigned_byte, F_rgb);
}

/**
 * Sets the texture as an empty cube map texture with the specified dimensions
 * and properties.  Follow up with set_ram_image() or modify_ram_image() to
 * fill the image data, or use set_clear_color to let the texture be cleared
 * to a solid color.
 *
 * Note that a cube map should always consist of six square images, so x_size
 * and y_size will be the same, and z_size is always 6.
 */
INLINE void Texture::
setup_cube_map(int size, ComponentType component_type, Format format) {
  setup_texture(TT_cube_map, size, size, 6, component_type, format);
}

/**
 * Sets the texture as cube map array with N cube maps.  Note that this number
 * is not the same as the z_size.  Follow up with read() or load() to fill the
 * texture properties and image data, or use set_clear_color to let the
 * texture be cleared to a solid color.
 *
 * @since 1.10.0
 */
INLINE void Texture::
setup_cube_map_array(int num_cube_maps) {
  setup_cube_map_array(0, num_cube_maps, T_unsigned_byte, F_rgb);
}

/**
 * Sets the texture as cube map array with N cube maps with the specified
 * dimensions and format.  Follow up with set_ram_image() or
 * modify_ram_image() to fill the image data, or use set_clear_color to let
 * the texture be cleared to a solid color.
 *
 * The num_cube_maps given here is multiplied by six to become the z_size of
 * the image.
 *
 * @since 1.10.0
 */
INLINE void Texture::
setup_cube_map_array(int size, int num_cube_maps, ComponentType component_type, Format format) {
  setup_texture(TT_cube_map_array, size, size, num_cube_maps * 6, component_type, format);
}

/**
 * Sets the texture as an empty buffer texture with the specified size and
 * properties.  Follow up with set_ram_image() or modify_ram_image() to fill
 * the image data, or use set_clear_color to let the texture be cleared to a
 * solid color.
 *
 * Note that a buffer texture's format needs to match the component type.
 */
INLINE void Texture::
setup_buffer_texture(int size, ComponentType component_type, Format format,
                     GeomEnums::UsageHint usage) {
  setup_texture(TT_buffer_texture, size, 1, 1, component_type, format);
  CDWriter cdata(_cycler);
  cdata->_usage_hint = usage;
}

/**
 * Clears the texture data without changing its format or resolution.  The
 * texture is cleared on both the graphics hardware and from RAM, unlike
 * clear_ram_image, which only removes the data from RAM.
 *
 * If a clear color has been specified using set_clear_color, the texture will
 * be cleared using a solid color.
 *
 * The texture data will be cleared the first time in which the texture is
 * used after this method is called.
 */
INLINE void Texture::
clear_image() {
  CDWriter cdata(_cycler, true);
  do_clear_ram_image(cdata);
  do_clear_simple_ram_image(cdata);
  cdata->inc_image_modified();
  cdata->inc_simple_image_modified();
}

/**
 * Returns true if a color was previously set using set_clear_color.
 */
INLINE bool Texture::
has_clear_color() const {
  CDReader cdata(_cycler);
  return cdata->_has_clear_color;
}

/**
 * Returns the color that was previously set using set_clear_color.
 */
INLINE LColor Texture::
get_clear_color() const {
  CDReader cdata(_cycler);
  return cdata->_clear_color;
}

/**
 * Sets the color that will be used to fill the texture image in absence of
 * any image data.  It is used when any of the setup_texture functions or
 * clear_image is called and image data is not provided using read() or
 * modify_ram_image().
 *
 * This does not affect a texture that has already been cleared; call
 * clear_image to clear it again.
 */
INLINE void Texture::
set_clear_color(const LColor &color) {
  CDWriter cdata(_cycler, true);
  cdata->_clear_color = color;
  cdata->_has_clear_color = true;
}

/**
 * The opposite of set_clear_color.  If the image is cleared after setting
 * this, its contents may be undefined (or may in fact not be cleared at all).
 */
INLINE void Texture::
clear_clear_color() {
  CDWriter cdata(_cycler, true);
  cdata->_has_clear_color = true;
}

/**
 * Returns the raw image data for a single pixel if it were set to the clear
 * color.
 */
INLINE vector_uchar Texture::
get_clear_data() const {
  CDReader cdata(_cycler);
  vector_uchar data(16);
  data.resize(do_get_clear_data(cdata, &data[0]));
  return data;
}

/**
 * Writes the texture to the named filename.
 */
INLINE bool Texture::
write(const Filename &fullpath) {
  CDWriter cdata(_cycler);

  // do_write() is non-const, because it might have to reload the ram image.
  return do_write(cdata, fullpath, 0, 0, false, false);
}

/**
 * Writes a single page or mipmap level to a single file, or automatically
 * writes a series of pages and/or mipmap levels to a numbered series of
 * files.
 *
 * If the filename ends in the extension .txo, this implicitly writes a Panda
 * texture object (.txo) instead of an image file.  In this case, the
 * remaining parameters are ignored, and only one file is written, which will
 * contain all of the pages and resident mipmap levels in the texture.
 *
 * If write_pages is false, then z indicates the page number to write.  3-D
 * textures have one page number for each level of depth; cube maps have six
 * pages number 0 through 5.  Other kinds of textures have only one page,
 * numbered 0.  If there are multiple views, the range of z is increased; the
 * total range is [0, get_num_pages()).
 *
 * If write_pages is true, then all pages of the texture will be written.  In
 * this case z is ignored, and the filename should contain a sequence of hash
 * marks ("#") which will be filled in with the page index number.
 *
 * If write_mipmaps is false, then n indicates the mipmap level number to
 * write.  Normally, this is 0, for the base texture image.  Normally, the
 * mipmap levels of a texture are not available in RAM (they are generated
 * automatically by the graphics card). However, if you have the mipmap levels
 * available, for instance because you called generate_ram_mipmap_images() to
 * generate them internally, or you called
 * GraphicsEngine::extract_texture_data() to retrieve them from the graphics
 * card, then you may write out each mipmap level with this parameter.
 *
 * If write_mipmaps is true, then all mipmap levels of the texture will be
 * written.  In this case n is ignored, and the filename should contain a
 * sequence of hash marks ("#") which will be filled in with the mipmap level
 * number.
 *
 * If both write_pages and write_mipmaps is true, then all pages and all
 * mipmap levels will be written.  In this case, the filename should contain
 * two different sequences of hash marks, separated by a 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.
 */
INLINE bool Texture::
write(const Filename &fullpath, int z, int n,
      bool write_pages, bool write_mipmaps) {
  CDWriter cdata(_cycler, false);
  return do_write(cdata, fullpath, z, n, write_pages, write_mipmaps);
}

/**
 * Replaces the texture with the indicated image.
 */
INLINE bool Texture::
load(const PNMImage &pnmimage, const LoaderOptions &options) {
  CDWriter cdata(_cycler, true);
  do_clear(cdata);
  cdata->inc_properties_modified();
  cdata->inc_image_modified();
  if (do_load_one(cdata, pnmimage, get_name(), 0, 0, options)) {
    bool generate_mipmaps = ((options.get_texture_flags() & LoaderOptions::TF_generate_mipmaps) != 0);
    consider_auto_process_ram_image(generate_mipmaps || uses_mipmaps(), true);
    return true;
  }
  return false;
}

/**
 * Stores the indicated image in the given page and mipmap level.  See read().
 */
INLINE bool Texture::
load(const PNMImage &pnmimage, int z, int n, const LoaderOptions &options) {
  CDWriter cdata(_cycler, true);
  cdata->inc_properties_modified();
  cdata->inc_image_modified();
  if (do_load_one(cdata, pnmimage, get_name(), z, n, options)) {
    return true;
  }
  return false;
}

/**
 * Replaces the texture with the indicated image.
 */
INLINE bool Texture::
load(const PfmFile &pfm, const LoaderOptions &options) {
  CDWriter cdata(_cycler, true);
  do_clear(cdata);
  cdata->inc_properties_modified();
  cdata->inc_image_modified();
  if (do_load_one(cdata, pfm, get_name(), 0, 0, options)) {
    bool generate_mipmaps = ((options.get_texture_flags() & LoaderOptions::TF_generate_mipmaps) != 0);
    consider_auto_process_ram_image(generate_mipmaps || uses_mipmaps(), true);
    return true;
  }
  return false;
}

/**
 * Stores the indicated image in the given page and mipmap level.  See read().
 */
INLINE bool Texture::
load(const PfmFile &pfm, int z, int n, const LoaderOptions &options) {
  CDWriter cdata(_cycler, true);
  cdata->inc_properties_modified();
  cdata->inc_image_modified();
  if (do_load_one(cdata, pfm, get_name(), z, n, options)) {
    return true;
  }
  return false;
}

/**
 * Stores the indicated image in a region of the texture.  The texture
 * properties remain unchanged.  This can be more efficient than updating an
 * entire texture, but has a few restrictions: for one, you must ensure that
 * the texture is still in RAM (eg.  using set_keep_ram_image) and it may not
 * be compressed.
 */
INLINE bool Texture::
load_sub_image(const PNMImage &image, int x, int y, int z, int n) {
  CDWriter cdata(_cycler, true);
  return do_load_sub_image(cdata, image, x, y, z, n);
}

/**
 * Saves the texture to the indicated PNMImage, but does not write it to disk.
 */
INLINE bool Texture::
store(PNMImage &pnmimage) const {
  CDWriter cdata(((Texture *)this)->_cycler, false);
  return ((Texture *)this)->do_store_one(cdata, pnmimage, 0, 0);
}

/**
 * Saves the indicated page and mipmap level of the texture to the PNMImage.
 */
INLINE bool Texture::
store(PNMImage &pnmimage, int z, int n) const {
  CDWriter cdata(((Texture *)this)->_cycler, false);
  return ((Texture *)this)->do_store_one(cdata, pnmimage, z, n);
}

/**
 * Saves the texture to the indicated PfmFile, but does not write it to disk.
 */
INLINE bool Texture::
store(PfmFile &pfm) const {
  CDWriter cdata(((Texture *)this)->_cycler, false);
  return ((Texture *)this)->do_store_one(cdata, pfm, 0, 0);
}

/**
 * Saves the indicated page and mipmap level of the texture to the PfmFile.
 */
INLINE bool Texture::
store(PfmFile &pfm, int z, int n) const {
  CDWriter cdata(((Texture *)this)->_cycler, false);
  return ((Texture *)this)->do_store_one(cdata, pfm, z, n);
}

/**
 * Re-reads the Texture from its disk file.  Useful when you know the image on
 * disk has recently changed, and you want to update the Texture image.
 *
 * Returns true on success, false on failure (in which case, the Texture may
 * or may not still be valid).
 */
bool Texture::
reload() {
  CDWriter cdata(_cycler, true);
  return do_reload(cdata);
}

/**
 * Returns true if the filename has been set and is available.  See
 * set_filename().
 */
INLINE bool Texture::
has_filename() const {
  CDReader cdata(_cycler);
  return !cdata->_filename.empty();
}

/**
 * Returns the filename that has been set.  This is the name of the file as it
 * was requested.  Also see get_fullpath().
 */
INLINE const Filename &Texture::
get_filename() const {
  CDReader cdata(_cycler);
  return cdata->_filename;
}

/**
 * Returns true if the alpha_filename has been set and is available.  See
 * set_alpha_filename().
 */
INLINE bool Texture::
has_alpha_filename() const {
  CDReader cdata(_cycler);
  return !cdata->_alpha_filename.empty();
}

/**
 * Returns the alpha_filename that has been set.  If this is set, it
 * represents the name of the alpha component, which is stored in a separate
 * file.  See also get_filename(), and get_alpha_fullpath().
 */
INLINE const Filename &Texture::
get_alpha_filename() const {
  CDReader cdata(_cycler);
  return cdata->_alpha_filename;
}

/**
 * Returns true if the fullpath has been set and is available.  See
 * set_fullpath().
 */
INLINE bool Texture::
has_fullpath() const {
  CDReader cdata(_cycler);
  return !cdata->_fullpath.empty();
}

/**
 * Returns the fullpath that has been set.  This is the full path to the file
 * as it was found along the texture search path.
 */
INLINE const Filename &Texture::
get_fullpath() const {
  CDReader cdata(_cycler);
  return cdata->_fullpath;
}

/**
 * Returns true if the alpha_fullpath has been set and is available.  See
 * set_alpha_fullpath().
 */
INLINE bool Texture::
has_alpha_fullpath() const {
  CDReader cdata(_cycler);
  return !cdata->_alpha_fullpath.empty();
}

/**
 *
 * Returns the alpha_fullpath that has been set.  This is the full path to the
 * alpha part of the image file as it was found along the texture search path.
 */
INLINE const Filename &Texture::
get_alpha_fullpath() const {
  CDReader cdata(_cycler);
  return cdata->_alpha_fullpath;
}


/**
 * Returns the width of the texture image in texels.
 */
INLINE int Texture::
get_x_size() const {
  CDReader cdata(_cycler);
  return cdata->_x_size;
}

/**
 * Returns the height of the texture image in texels.  For a 1-d texture, this
 * will be 1.
 */
INLINE int Texture::
get_y_size() const {
  CDReader cdata(_cycler);
  return cdata->_y_size;
}

/**
 * Returns the depth of the texture image in texels.  For a 1-d texture or 2-d
 * texture, this will be 1. For a cube map texture, this will be 6.
 */
INLINE int Texture::
get_z_size() const {
  CDReader cdata(_cycler);
  return cdata->_z_size;
}

/**
 * Returns the number of "views" in the texture.  A view is a completely
 * separate image stored within the Texture object.  Most textures have only
 * one view, but a stereo texture, for instance, may have two views, a left
 * and a right image.  Other uses for multiple views are not yet defined.
 *
 * If this value is greater than one, the additional views are accessed as
 * additional pages beyond get_z_size().
 */
INLINE int Texture::
get_num_views() const {
  CDReader cdata(_cycler);
  return cdata->_num_views;
}

/**
 * Returns the total number of pages in the texture.  Each "page" is a 2-d
 * texture image within the larger image--a face of a cube map, or a level of
 * a 3-d texture.  Normally, get_num_pages() is the same as get_z_size().
 * However, in a multiview texture, this returns get_z_size() *
 * get_num_views().
 */
INLINE int Texture::
get_num_pages() const {
  return get_z_size() * get_num_views();
}

/**
 * Returns size of the pad region.  See set_pad_size.
 */
INLINE int Texture::
get_pad_x_size() const {
  CDReader cdata(_cycler);
  return cdata->_pad_x_size;
}

/**
 * Returns size of the pad region.  See set_pad_size.
 */
INLINE int Texture::
get_pad_y_size() const {
  CDReader cdata(_cycler);
  return cdata->_pad_y_size;
}

/**
 * Returns size of the pad region.  See set_pad_size.
 */
INLINE int Texture::
get_pad_z_size() const {
  CDReader cdata(_cycler);
  return cdata->_pad_z_size;
}

/**
 * Returns a scale pair that is suitable for applying to geometry via
 * NodePath::set_tex_scale(), which will convert texture coordinates on the
 * geometry from the range 0..1 into the appropriate range to render the video
 * part of the texture.
 *
 * This is necessary only if a padding size has been set via set_pad_size()
 * (or implicitly via something like "textures-power-2 pad" in the config.prc
 * file).  In this case, this is a convenient way to generate UV's that
 * reflect the built-in padding size.
 */
INLINE LVecBase2 Texture::
get_tex_scale() const {
  CDReader cdata(_cycler);
  if (cdata->_pad_x_size == 0 || cdata->_pad_y_size == 0 ||
      cdata->_x_size == 0 || cdata->_y_size == 0) {
    LVecBase2(1.0f, 1.0f);
  }
  return LVecBase2((PN_stdfloat)(cdata->_x_size - cdata->_pad_x_size) / (PN_stdfloat)cdata->_x_size,
                   (PN_stdfloat)(cdata->_y_size - cdata->_pad_y_size) / (PN_stdfloat)cdata->_y_size);
}

/**
 * Sets the size of the pad region.
 *
 * Sometimes, when a video card demands power-of-two textures, it is necessary
 * to create a big texture and then only use a portion of it.  The pad region
 * indicates which portion of the texture is not really in use.  All
 * operations use the texture as a whole, including the pad region, unless
 * they explicitly state that they use only the non-pad region.
 *
 * Changing the texture's size clears the pad region.
 */
INLINE void Texture::
set_pad_size(int x, int y, int z) {
  CDWriter cdata(_cycler, true);
  do_set_pad_size(cdata, x, y, z);
}

/**
 * Returns the X size of the original disk image that this Texture was loaded
 * from (if it came from a disk file), before any automatic rescaling by
 * Panda.
 */
INLINE int Texture::
get_orig_file_x_size() const {
  CDReader cdata(_cycler);
  return cdata->_orig_file_x_size;
}

/**
 * Returns the Y size of the original disk image that this Texture was loaded
 * from (if it came from a disk file), before any automatic rescaling by
 * Panda.
 */
INLINE int Texture::
get_orig_file_y_size() const {
  CDReader cdata(_cycler);
  return cdata->_orig_file_y_size;
}

/**
 * Returns the Z size of the original disk image that this Texture was loaded
 * from (if it came from a disk file), before any automatic rescaling by
 * Panda.
 */
INLINE int Texture::
get_orig_file_z_size() const {
  // At the moment, we perform no automatic adjustment of Z size.  So we can
  // just return the current value, since it would be the same thing.
  CDReader cdata(_cycler);
  return cdata->_z_size;
}

/**
 * Returns the number of color components for each texel of the texture image.
 * This is 3 for an rgb texture or 4 for an rgba texture; it may also be 1 or
 * 2 for a grayscale texture.
 */
INLINE int Texture::
get_num_components() const {
  CDReader cdata(_cycler);
  return cdata->_num_components;
}

/**
 * Returns the number of bytes stored for each color component of a texel.
 * Typically this is 1, but it may be 2 for 16-bit texels.
 */
INLINE int Texture::
get_component_width() const {
  CDReader cdata(_cycler);
  return cdata->_component_width;
}

/**
 * Returns the overall interpretation of the texture.
 */
INLINE Texture::TextureType Texture::
get_texture_type() const {
  CDReader cdata(_cycler);
  return cdata->_texture_type;
}

/**
 * Returns the format of the texture, which represents both the semantic
 * meaning of the texels and, to some extent, their storage information.
 */
INLINE Texture::Format Texture::
get_format() const {
  CDReader cdata(_cycler);
  return cdata->_format;
}

/**
 * Returns the numeric interpretation of each component of the texture.
 */
INLINE Texture::ComponentType Texture::
get_component_type() const {
  CDReader cdata(_cycler);
  return cdata->_component_type;
}

/**
 * Returns the usage hint specified for buffer textures, or UH_unspecified for
 * all other texture types.
 */
INLINE GeomEnums::UsageHint Texture::
get_usage_hint() const {
  CDReader cdata(_cycler);
  return cdata->_usage_hint;
}

/**
 * This setting determines what happens when the texture is sampled with a U
 * value outside the range 0.0-1.0.  The default is WM_repeat, which indicates
 * that the texture should repeat indefinitely.
 *
 * This sets the default sampler state for this texture; it may still be
 * overridden by a sampler state specified at a higher level.
 */
INLINE void Texture::
set_wrap_u(SamplerState::WrapMode wrap) {
  CDWriter cdata(_cycler, true);
  do_set_wrap_u(cdata, wrap);
}

/**
 * This setting determines what happens when the texture is sampled with a V
 * value outside the range 0.0-1.0.  The default is WM_repeat, which indicates
 * that the texture should repeat indefinitely.
 *
 * This sets the default sampler state for this texture; it may still be
 * overridden by a sampler state specified at a higher level.
 */
INLINE void Texture::
set_wrap_v(SamplerState::WrapMode wrap) {
  CDWriter cdata(_cycler, true);
  do_set_wrap_v(cdata, wrap);
}

/**
 * The W wrap direction is only used for 3-d textures.
 *
 * This sets the default sampler state for this texture; it may still be
 * overridden by a sampler state specified at a higher level.
 */
INLINE void Texture::
set_wrap_w(SamplerState::WrapMode wrap) {
  CDWriter cdata(_cycler, true);
  do_set_wrap_w(cdata, wrap);
}

/**
 * Sets the filtering method that should be used when viewing the texture from
 * a distance.
 *
 * This sets the default sampler state for this texture; it may still be
 * overridden by a sampler state specified at a higher level.
 */
INLINE void Texture::
set_minfilter(SamplerState::FilterType filter) {
  CDWriter cdata(_cycler, true);
  do_set_minfilter(cdata, filter);
}

/**
 * Sets the filtering method that should be used when viewing the texture up
 * close.
 *
 * This sets the default sampler state for this texture; it may still be
 * overridden by a sampler state specified at a higher level.
 */
INLINE void Texture::
set_magfilter(SamplerState::FilterType filter) {
  CDWriter cdata(_cycler, true);
  do_set_magfilter(cdata, filter);
}

/**
 * Specifies the level of anisotropic filtering to apply to the texture.  Set
 * this 0 to indicate the default value, which is specified in the texture-
 * anisotropic-degree config variable.
 *
 * To explicitly disable anisotropic filtering, set this value to 1.  To
 * explicitly enable anisotropic filtering, set it to a value higher than 1;
 * larger numbers indicate greater degrees of filtering.
 *
 * This sets the default sampler state for this texture; it may still be
 * overridden by a sampler state specified at a higher level.
 */
INLINE void Texture::
set_anisotropic_degree(int anisotropic_degree) {
  CDWriter cdata(_cycler, true);
  do_set_anisotropic_degree(cdata, anisotropic_degree);
}

/**
 * Specifies the solid color of the texture's border.  Some OpenGL
 * implementations use a border for tiling textures; in Panda, it is only used
 * for specifying the clamp color.
 *
 * This sets the default sampler state for this texture; it may still be
 * overridden by a sampler state specified at a higher level.
 */
INLINE void Texture::
set_border_color(const LColor &color) {
  CDWriter cdata(_cycler, true);
  do_set_border_color(cdata, color);
}

/**
 * Requests that this particular Texture be compressed when it is loaded into
 * texture memory.
 *
 * This refers to the internal compression of the texture image within texture
 * memory; it is not related to jpeg or png compression, which are disk file
 * compression formats.  The actual disk file that generated this texture may
 * be stored in a compressed or uncompressed format supported by Panda; it
 * will be decompressed on load, and then recompressed by the graphics API if
 * this parameter is not CM_off.
 *
 * If the GSG does not support this texture compression mode, the texture will
 * silently be loaded uncompressed.
 */
INLINE void Texture::
set_compression(Texture::CompressionMode compression) {
  CDWriter cdata(_cycler, true);
  do_set_compression(cdata, compression);
}

/**
 * Sets a flag on the texture that indicates whether the texture is intended
 * to be used as a direct-render target, by binding a framebuffer to a texture
 * and rendering directly into the texture.
 *
 * This controls some low-level choices made about the texture object itself.
 * For instance, compressed textures are disallowed when this flag is set
 * true.
 *
 * Normally, a user should not need to set this flag directly; it is set
 * automatically by the low-level display code when a texture is bound to a
 * framebuffer.
 */
INLINE void Texture::
set_render_to_texture(bool render_to_texture) {
  CDWriter cdata(_cycler, false);
  cdata->_render_to_texture = render_to_texture;
}

/**
 * This returns the default sampler state for this texture, containing the
 * wrap and filter properties specified on the texture level; it may still be
 * overridden by a sampler state specified at a higher level.
 */
INLINE const SamplerState &Texture::
get_default_sampler() const {
  CDReader cdata(_cycler);
  return cdata->_default_sampler;
}

/**
 * This sets the default sampler state for this texture, containing the wrap
 * and filter properties specified on the texture level; it may still be
 * overridden by a sampler state specified at a higher level.  This
 * encompasses the settings for get_wrap_u, get_minfilter,
 * get_anisotropic_degree, etc.
 *
 * This makes a copy of the SamplerState object, so future modifications of
 * the same SamplerState will have no effect on this texture unless you call
 * set_default_sampler again.
 */
INLINE void Texture::
set_default_sampler(const SamplerState &sampler) {
  CDWriter cdata(_cycler, true);
  cdata->_default_sampler = sampler;
  cdata->inc_properties_modified();
}

/**
 * Returns the wrap mode of the texture in the U direction.
 *
 * This returns the default sampler state for this texture; it may still be
 * overridden by a sampler state specified at a higher level.
 */
INLINE SamplerState::WrapMode Texture::
get_wrap_u() const {
  CDReader cdata(_cycler);
  return cdata->_default_sampler.get_wrap_u();
}

/**
 * Returns the wrap mode of the texture in the V direction.
 *
 * This returns the default sampler state for this texture; it may still be
 * overridden by a sampler state specified at a higher level.
 */
INLINE SamplerState::WrapMode Texture::
get_wrap_v() const {
  CDReader cdata(_cycler);
  return cdata->_default_sampler.get_wrap_v();
}

/**
 * Returns the wrap mode of the texture in the W direction.  This is the depth
 * direction of 3-d textures.
 *
 * This returns the default sampler state for this texture; it may still be
 * overridden by a sampler state specified at a higher level.
 */
INLINE SamplerState::WrapMode Texture::
get_wrap_w() const {
  CDReader cdata(_cycler);
  return cdata->_default_sampler.get_wrap_w();
}

/**
 * Returns the filter mode of the texture for minification.  If this is one of
 * the mipmap constants, then the texture requires mipmaps.  This may return
 * FT_default; see also get_effective_minfilter().
 *
 * This returns the default sampler state for this texture; it may still be
 * overridden by a sampler state specified at a higher level.
 */
INLINE SamplerState::FilterType Texture::
get_minfilter() const {
  CDReader cdata(_cycler);
  return cdata->_default_sampler.get_minfilter();
}

/**
 * Returns the filter mode of the texture for magnification.  The mipmap
 * constants are invalid here.  This may return FT_default; see also
 * get_effective_minfilter().
 *
 * This returns the default sampler state for this texture; it may still be
 * overridden by a sampler state specified at a higher level.
 */
INLINE SamplerState::FilterType Texture::
get_magfilter() const {
  CDReader cdata(_cycler);
  return cdata->_default_sampler.get_magfilter();
}

/**
 * Returns the filter mode of the texture for minification, with special
 * treatment for FT_default.  This will normally not return FT_default, unless
 * there is an error in the config file.
 *
 * This returns the default sampler state for this texture; it may still be
 * overridden by a sampler state specified at a higher level.
 */
SamplerState::FilterType Texture::
get_effective_minfilter() const {
  CDReader cdata(_cycler);
  return cdata->_default_sampler.get_effective_minfilter();
}

/**
 * Returns the filter mode of the texture for magnification, with special
 * treatment for FT_default.  This will normally not return FT_default, unless
 * there is an error in the config file.
 *
 * This returns the default sampler state for this texture; it may still be
 * overridden by a sampler state specified at a higher level.
 */
SamplerState::FilterType Texture::
get_effective_magfilter() const {
  CDReader cdata(_cycler);
  return cdata->_default_sampler.get_effective_magfilter();
}

/**
 * Returns the degree of anisotropic filtering that should be applied to the
 * texture.  This value may return 0, indicating the default value; see also
 * get_effective_anisotropic_degree.
 *
 * This returns the default sampler state for this texture; it may still be
 * overridden by a sampler state specified at a higher level.
 */
INLINE int Texture::
get_anisotropic_degree() const {
  CDReader cdata(_cycler);
  return cdata->_default_sampler.get_anisotropic_degree();
}

/**
 * Returns the degree of anisotropic filtering that should be applied to the
 * texture.  This value will normally not return 0, unless there is an error
 * in the config file.
 *
 * This returns the default sampler state for this texture; it may still be
 * overridden by a sampler state specified at a higher level.
 */
INLINE int Texture::
get_effective_anisotropic_degree() const {
  CDReader cdata(_cycler);
  return cdata->_default_sampler.get_effective_anisotropic_degree();
}

/**
 * Returns the solid color of the texture's border.  Some OpenGL
 * implementations use a border for tiling textures; in Panda, it is only used
 * for specifying the clamp color.
 *
 * This returns the default sampler state for this texture; it may still be
 * overridden by a sampler state specified at a higher level.
 */
INLINE LColor Texture::
get_border_color() const {
  CDReader cdata(_cycler);
  return cdata->_default_sampler.get_border_color();
}

/**
 * Returns the compression mode requested for this particular texture, or
 * CM_off if the texture is not to be compressed.
 *
 * If a value other than CM_off is returned, this is not a guarantee that the
 * texture is actually successfully compressed on the GSG.  It may be that the
 * GSG does not support the requested compression mode, in which case the
 * texture may actually be stored uncompressed in texture memory.
 */
INLINE Texture::CompressionMode Texture::
get_compression() const {
  CDReader cdata(_cycler);
  return cdata->_compression;
}

/**
 * Returns true if the texture indicates it wants to be compressed, either
 * with CM_on or higher, or CM_default and compressed-textures is true.
 *
 * If true returned, this is not a guarantee that the texture is actually
 * successfully compressed on the GSG.  It may be that the GSG does not
 * support the requested compression mode, in which case the texture may
 * actually be stored uncompressed in texture memory.
 */
INLINE bool Texture::
has_compression() const {
  CDReader cdata(_cycler);
  return do_has_compression(cdata);
}

/**
 * Returns a flag on the texture that indicates whether the texture is
 * intended to be used as a direct-render target, by binding a framebuffer to
 * a texture and rendering directly into the texture.
 *
 * Normally, a user should not need to set this flag directly; it is set
 * automatically by the low-level display code when a texture is bound to a
 * framebuffer.
 */
INLINE bool Texture::
get_render_to_texture() const {
  CDReader cdata(_cycler);
  return cdata->_render_to_texture;
}

/**
 * Returns true if the minfilter settings on this texture indicate the use of
 * mipmapping, false otherwise.
 */
INLINE bool Texture::
uses_mipmaps() const {
  return SamplerState::is_mipmap(get_effective_minfilter());
}

/**
 * Sets a hint to the renderer about the desired performance / quality
 * tradeoff for this particular texture.  This is most useful for the
 * tinydisplay software renderer; for normal, hardware-accelerated renderers,
 * this may have little or no effect.
 */
INLINE void Texture::
set_quality_level(Texture::QualityLevel quality_level) {
  CDWriter cdata(_cycler, true);
  do_set_quality_level(cdata, quality_level);
}

/**
 * Returns the current quality_level hint.  See set_quality_level().  This
 * value may return QL_default; see get_effective_quality_level().
 */
INLINE Texture::QualityLevel Texture::
get_quality_level() const {
  CDReader cdata(_cycler);
  return cdata->_quality_level;
}

/**
 * Returns the current quality_level hint, or the global default quality_level
 * if this texture doesn't specify a quality level.  This value will not
 * normally return QL_default (unless there is an error in the config file)
 */
INLINE Texture::QualityLevel Texture::
get_effective_quality_level() const {
  CDReader cdata(_cycler);
  if (cdata->_quality_level == QL_default) {
    return texture_quality_level;
  }
  return cdata->_quality_level;
}

/**
 * Returns the number of mipmap levels that should be defined for this
 * texture, given the texture's size.
 *
 * Note that this returns a number appropriate for mipmapping, even if the
 * texture does not currently have mipmapping enabled.
 */
INLINE int Texture::
get_expected_num_mipmap_levels() const {
  CDReader cdata(_cycler);
  return do_get_expected_num_mipmap_levels(cdata);
}

/**
 * Returns the x_size that the nth mipmap level should have, based on the
 * texture's size.
 */
INLINE int Texture::
get_expected_mipmap_x_size(int n) const {
  CDReader cdata(_cycler);
  return do_get_expected_mipmap_x_size(cdata, n);
}

/**
 * Returns the y_size that the nth mipmap level should have, based on the
 * texture's size.
 */
INLINE int Texture::
get_expected_mipmap_y_size(int n) const {
  CDReader cdata(_cycler);
  return do_get_expected_mipmap_y_size(cdata, n);
}

/**
 * Returns the z_size that the nth mipmap level should have, based on the
 * texture's size.
 */
INLINE int Texture::
get_expected_mipmap_z_size(int n) const {
  CDReader cdata(_cycler);
  return do_get_expected_mipmap_z_size(cdata, n);
}

/**
 * Returns the total number of pages that the nth mipmap level should have,
 * based on the texture's size.  This is usually the same as
 * get_expected_mipmap_z_size(), except for a multiview texture, in which case
 * it is get_expected_mipmap_z_size() * get_num_views().
 */
INLINE int Texture::
get_expected_mipmap_num_pages(int n) const {
  CDReader cdata(_cycler);
  return do_get_expected_mipmap_num_pages(cdata, n);
}

/**
 * Returns true if the Texture has its image contents available in main RAM,
 * false if it exists only in texture memory or in the prepared GSG context.
 *
 * Note that this has nothing to do with whether get_ram_image() will fail or
 * not.  Even if has_ram_image() returns false, get_ram_image() may still
 * return a valid RAM image, because get_ram_image() will automatically load
 * the texture from disk if necessary.  The only thing has_ram_image() tells
 * you is whether the texture is available right now without hitting the disk
 * first.
 *
 * Note also that if an application uses only one GSG, it may appear that
 * has_ram_image() returns true if the texture has not yet been loaded by the
 * GSG, but this correlation is not true in general and should not be depended
 * on.  Specifically, if an application ever uses multiple GSG's in its
 * lifetime (for instance, by opening more than one window, or by closing its
 * window and opening another one later), then has_ram_image() may well return
 * false on textures that have never been loaded on the current GSG.
 */
INLINE bool Texture::
has_ram_image() const {
  CDReader cdata(_cycler);
  return do_has_ram_image(cdata);
}

/**
 * Returns true if the Texture has its image contents available in main RAM
 * and is uncompressed, false otherwise.  See has_ram_image().
 */
INLINE bool Texture::
has_uncompressed_ram_image() const {
  CDReader cdata(_cycler);
  return do_has_uncompressed_ram_image(cdata);
}

/**
 * Returns true if the texture's image contents are currently available in
 * main RAM, or there is reason to believe it can be loaded on demand.  That
 * is, this function returns a "best guess" as to whether get_ram_image() will
 * succeed without actually calling it first.
 */
INLINE bool Texture::
might_have_ram_image() const {
  CDReader cdata(_cycler);
  return (do_has_ram_image(cdata) || !cdata->_fullpath.empty());
}

/**
 * Returns the total number of bytes used by the in-memory image, across all
 * pages and views, or 0 if there is no in-memory image.
 */
INLINE size_t Texture::
get_ram_image_size() const {
  CDReader cdata(_cycler);
  return do_get_ram_image_size(cdata);
}

/**
 * Returns the number of bytes used by the in-memory image per view, or 0 if
 * there is no in-memory image.  Since each view is a stack of z_size pages,
 * this is get_z_size() * get_ram_page_size().
 */
INLINE size_t Texture::
get_ram_view_size() const {
  CDReader cdata(_cycler);
  if (cdata->_ram_image_compression == CM_off || cdata->_ram_images.empty()) {
    return do_get_expected_ram_view_size(cdata);
  } else {
    return cdata->_z_size * cdata->_ram_images[0]._page_size;
  }
}

/**
 * Returns the number of bytes used by the in-memory image per page, or 0 if
 * there is no in-memory image.
 *
 * For a non-compressed texture, this is the same as
 * get_expected_ram_page_size().  For a compressed texture, this may be a
 * smaller value.  (We do assume that all pages will be the same size on a
 * compressed texture).
 */
INLINE size_t Texture::
get_ram_page_size() const {
  CDReader cdata(_cycler);
  if (cdata->_ram_image_compression == CM_off || cdata->_ram_images.empty()) {
    return do_get_expected_ram_page_size(cdata);
  } else {
    return cdata->_ram_images[0]._page_size;
  }
}

/**
 * Returns the number of bytes that *ought* to be used by the in-memory image,
 * based on the texture parameters.
 */
INLINE size_t Texture::
get_expected_ram_image_size() const {
  CDReader cdata(_cycler);
  return do_get_expected_ram_image_size(cdata);
}

/**
 * Returns the number of bytes that should be used per each Z page of the 3-d
 * texture.  For a 2-d or 1-d texture, this is the same as
 * get_expected_ram_image_size().
 */
INLINE size_t Texture::
get_expected_ram_page_size() const {
  CDReader cdata(_cycler);
  return do_get_expected_ram_page_size(cdata);
}

/**
 * Returns the system-RAM image data associated with the texture.  If the
 * texture does not currently have an associated RAM image, and the texture
 * was generated by loading an image from a disk file (the most common case),
 * this forces the reload of the same texture.  This can happen if
 * keep_texture_ram is configured to false, and we have previously prepared
 * this texture with a GSG.
 *
 * Note that it is not correct to call has_ram_image() first to test whether
 * this function will fail.  A false return value from has_ram_image()
 * indicates only that get_ram_image() may need to reload the texture from
 * disk, which it will do automatically.  However, you can call
 * might_have_ram_image(), which will return true if the ram image exists, or
 * there is a reasonable reason to believe it can be loaded.
 *
 * On the other hand, it is possible that the texture cannot be found on disk
 * or is otherwise unavailable.  If that happens, this function will return
 * NULL. There is no way to predict with 100% accuracy whether get_ram_image()
 * will return NULL without calling it first; might_have_ram_image() is the
 * closest.
 */
INLINE CPTA_uchar Texture::
get_ram_image() {
  CDWriter cdata(_cycler, unlocked_ensure_ram_image(true));
  return do_get_ram_image(cdata);
}

/**
 * Returns the compression mode in which the ram image is already stored pre-
 * compressed.  If this is other than CM_off, you cannot rely on the contents
 * of the ram image to be anything predicatable (it will not be an array of x
 * by y pixels, and it probably won't have the same length as
 * get_expected_ram_image_size()).
 */
INLINE Texture::CompressionMode Texture::
get_ram_image_compression() const {
  CDReader cdata(_cycler);
  return cdata->_ram_image_compression;
}

/**
 * Returns a modifiable pointer to the system-RAM image.  This assumes the RAM
 * image should be uncompressed.  If the RAM image has been dumped, or is
 * stored compressed, creates a new one.
 *
 * This does *not* affect keep_ram_image.
 */
INLINE PTA_uchar Texture::
modify_ram_image() {
  CDWriter cdata(_cycler, true);
  cdata->inc_image_modified();
  return do_modify_ram_image(cdata);
}

/**
 * Returns the system-RAM image associated with the texture, in an
 * uncompressed form if at all possible.
 *
 * If get_ram_image_compression() is CM_off, then the system-RAM image is
 * already uncompressed, and this returns the same thing as get_ram_image().
 *
 * If get_ram_image_compression() is anything else, then the system-RAM image
 * is compressed.  In this case, the image will be reloaded from the
 * *original* file (not from the cache), in the hopes that an uncompressed
 * image will be found there.
 *
 * If an uncompressed image cannot be found, returns NULL.
 */
INLINE CPTA_uchar Texture::
get_uncompressed_ram_image() {
  CDWriter cdata(_cycler, false);
  return do_get_uncompressed_ram_image(cdata);
}

/**
 * Discards the current system-RAM image for the texture, if any, and
 * allocates a new buffer of the appropriate size.  Returns the new buffer.
 *
 * This does *not* affect keep_ram_image.
 */
INLINE PTA_uchar Texture::
make_ram_image() {
  CDWriter cdata(_cycler, true);
  cdata->inc_image_modified();
  return do_make_ram_image(cdata);
}

/**
 * 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.
 */
INLINE void Texture::
set_ram_image(CPTA_uchar image, Texture::CompressionMode compression,
              size_t page_size) {
  CDWriter cdata(_cycler, true);
  do_set_ram_image(cdata, image, compression, page_size);
}

/**
 * Discards the current system-RAM image.
 */
INLINE void Texture::
clear_ram_image() {
  CDWriter cdata(_cycler, false);
  do_clear_ram_image(cdata);
}

/**
 * Sets 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.
 *
 * This will be false for most textures, which can reload their images if
 * needed by rereading the input file.  However, textures that were generated
 * dynamically and cannot be easily reloaded will want to set this flag to
 * true, so that the texture will always keep its image copy around.
 */
INLINE void Texture::
set_keep_ram_image(bool keep_ram_image) {
  CDWriter cdata(_cycler, true);
  cdata->_keep_ram_image = keep_ram_image;
}

/**
 * Attempts to compress the texture's RAM image internally, to a format
 * supported by the indicated GSG.  In order for this to work, the squish
 * library must have been compiled into Panda.
 *
 * If compression is CM_on, then an appropriate compression method that is
 * supported by the indicated GSG is automatically chosen.  If the GSG pointer
 * is NULL, any of the standard DXT1/3/5 compression methods will be used,
 * regardless of whether it is supported.
 *
 * If compression is any specific compression method, that method is used
 * regardless of whether the GSG supports it.
 *
 * quality_level determines the speed/quality tradeoff of the compression.  If
 * it is QL_default, the texture's own quality_level parameter is used.
 *
 * Returns true if successful, false otherwise.
 */
INLINE bool Texture::
compress_ram_image(Texture::CompressionMode compression,
                   Texture::QualityLevel quality_level,
                   GraphicsStateGuardianBase *gsg) {
  CDWriter cdata(_cycler, false);
  if (do_compress_ram_image(cdata, compression, quality_level, gsg)) {
    cdata->inc_image_modified();
    return true;
  }
  return false;
}

/**
 * Attempts to uncompress the texture's RAM image internally.  In order for
 * this to work, the squish library must have been compiled into Panda, and
 * the ram image must be compressed in a format supported by squish.
 *
 * Returns true if successful, false otherwise.
 */
INLINE bool Texture::
uncompress_ram_image() {
  CDWriter cdata(_cycler, false);
  if (do_uncompress_ram_image(cdata)) {
    cdata->inc_image_modified();
    return true;
  }
  return false;
}

/**
 * Returns the maximum number of mipmap level images available in system
 * memory.  The actual number may be less than this (that is, there might be
 * gaps in the sequence); use has_ram_mipmap_image() to verify each level.
 *
 * Also see get_num_loadable_ram_mipmap_images().
 */
INLINE int Texture::
get_num_ram_mipmap_images() const {
  CDReader cdata(_cycler);
  return cdata->_ram_images.size();
}

/**
 * Returns true if the Texture has the nth mipmap level available in system
 * memory, false otherwise.  If the texture's minfilter mode requires
 * mipmapping (see uses_mipmaps()), and all the texture's mipmap levels are
 * not available when the texture is rendered, they will be generated
 * automatically.
 */
INLINE bool Texture::
has_ram_mipmap_image(int n) const {
  CDReader cdata(_cycler);
  return do_has_ram_mipmap_image(cdata, n);
}

/**
 * Returns true if all expected mipmap levels have been defined and exist in
 * the system RAM, or false if even one mipmap level is missing.
 */
INLINE bool Texture::
has_all_ram_mipmap_images() const {
  CDReader cdata(_cycler);
  return do_has_all_ram_mipmap_images(cdata);
}

/**
 * Returns the number of bytes used by the in-memory image for mipmap level n,
 * or 0 if there is no in-memory image for this mipmap level.
 */
INLINE size_t Texture::
get_ram_mipmap_image_size(int n) const {
  CDReader cdata(_cycler);
  if (n >= 0 && n < (int)cdata->_ram_images.size()) {
    if (cdata->_ram_images[n]._pointer_image == nullptr) {
      return cdata->_ram_images[n]._image.size();
    } else {
      // Calculate it based on the given page size.
      return do_get_ram_mipmap_page_size(cdata, n) *
             do_get_expected_mipmap_z_size(cdata, n) *
             cdata->_num_views;
    }
  }
  return 0;
}

/**
 * Returns the number of bytes used by the in-memory image per view for mipmap
 * level n, or 0 if there is no in-memory image for this mipmap level.
 *
 * A "view" is a collection of z_size pages for each mipmap level.  Most
 * textures have only one view, except for multiview or stereo textures.
 *
 * For a non-compressed texture, this is the same as
 * get_expected_ram_mipmap_view_size().  For a compressed texture, this may be
 * a smaller value.  (We do assume that all pages will be the same size on a
 * compressed texture).
 */
INLINE size_t Texture::
get_ram_mipmap_view_size(int n) const {
  CDReader cdata(_cycler);
  return do_get_ram_mipmap_page_size(cdata, n) * do_get_expected_mipmap_z_size(cdata, n);
}

/**
 * Returns the number of bytes used by the in-memory image per page for mipmap
 * level n, or 0 if there is no in-memory image for this mipmap level.
 *
 * For a non-compressed texture, this is the same as
 * get_expected_ram_mipmap_page_size().  For a compressed texture, this may be
 * a smaller value.  (We do assume that all pages will be the same size on a
 * compressed texture).
 */
INLINE size_t Texture::
get_ram_mipmap_page_size(int n) const {
  CDReader cdata(_cycler);
  return do_get_ram_mipmap_page_size(cdata, n);
}

/**
 * Returns the number of bytes that *ought* to be used by the in-memory image
 * for mipmap level n, based on the texture parameters.
 */
INLINE size_t Texture::
get_expected_ram_mipmap_image_size(int n) const {
  CDReader cdata(_cycler);
  return do_get_expected_ram_mipmap_image_size(cdata, n);
}

/**
 * Returns the number of bytes that *ought* to be used by each view of the in-
 * memory image for mipmap level n, based on the texture parameters.  For a
 * normal, non-multiview texture, this is the same as
 * get_expected_ram_mipmap_image_size(n).
 */
INLINE size_t Texture::
get_expected_ram_mipmap_view_size(int n) const {
  CDReader cdata(_cycler);
  return do_get_expected_ram_mipmap_view_size(cdata, n);
}

/**
 * Returns the number of bytes that should be used per each Z page of the 3-d
 * texture, for mipmap level n.  For a 2-d or 1-d texture, this is the same as
 * get_expected_ram_mipmap_view_size(n).
 */
INLINE size_t Texture::
get_expected_ram_mipmap_page_size(int n) const {
  CDReader cdata(_cycler);
  return do_get_expected_ram_mipmap_page_size(cdata, n);
}

/**
 * Returns a modifiable pointer to the system-RAM image for the nth mipmap
 * level.  This assumes the RAM image is uncompressed; if this is not the
 * case, raises an assertion.
 *
 * This does *not* affect keep_ram_image.
 */
INLINE PTA_uchar Texture::
modify_ram_mipmap_image(int n) {
  CDWriter cdata(_cycler, false);
  cdata->inc_image_modified();
  return do_modify_ram_mipmap_image(cdata, n);
}

/**
 * Discards the current system-RAM image for the nth mipmap level, if any, and
 * allocates a new buffer of the appropriate size.  Returns the new buffer.
 *
 * This does *not* affect keep_ram_image.
 */
INLINE PTA_uchar Texture::
make_ram_mipmap_image(int n) {
  CDWriter cdata(_cycler, false);
  cdata->inc_image_modified();
  return do_make_ram_mipmap_image(cdata, n);
}

/**
 * Replaces the current system-RAM image for the indicated mipmap level 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.
 */
INLINE void Texture::
set_ram_mipmap_image(int n, CPTA_uchar image, size_t page_size) {
  CDWriter cdata(_cycler, false);
  do_set_ram_mipmap_image(cdata, n, image, page_size);
}

/**
 * Discards the current system-RAM image for all mipmap levels, except level 0
 * (the base image).
 */
INLINE void Texture::
clear_ram_mipmap_images() {
  CDWriter cdata(_cycler, false);
  cdata->inc_image_modified();
  do_clear_ram_mipmap_images(cdata);
}

/**
 * Automatically fills in the n mipmap levels of the Texture, based on the
 * texture's source image.  This requires the texture's uncompressed ram image
 * to be available in system memory.  If it is not already, it will be fetched
 * if possible.
 *
 * This call is not normally necessary, since the mipmap levels will be
 * generated automatically if needed.  But there may be certain cases in which
 * you would like to call this explicitly.
 */
INLINE void Texture::
generate_ram_mipmap_images() {
  // Don't use unlocked_ensure_ram_image here, because
  // do_generate_ram_mipmap_images will want to decompress and recompress the
  // image itself.
  CDWriter cdata(_cycler, false);
  cdata->inc_image_modified();
  do_generate_ram_mipmap_images(cdata, true);
}

/**
 * Returns the width of the "simple" image in texels.
 */
INLINE int Texture::
get_simple_x_size() const {
  CDReader cdata(_cycler);
  return cdata->_simple_x_size;
}

/**
 * Returns the height of the "simple" image in texels.
 */
INLINE int Texture::
get_simple_y_size() const {
  CDReader cdata(_cycler);
  return cdata->_simple_y_size;
}

/**
 * Returns true if the Texture has a "simple" image available in main RAM.
 */
INLINE bool Texture::
has_simple_ram_image() const {
  CDReader cdata(_cycler);
  return !cdata->_simple_ram_image._image.empty();
}

/**
 * Returns the number of bytes used by the "simple" image, or 0 if there is no
 * simple image.
 */
INLINE size_t Texture::
get_simple_ram_image_size() const {
  CDReader cdata(_cycler);
  return cdata->_simple_ram_image._image.size();
}

/**
 * Returns the image data associated with the "simple" texture image.  This is
 * provided for some textures as an option to display while the main texture
 * image is being loaded from disk.
 *
 * Unlike get_ram_image(), this function will always return immediately.
 * Either the simple image is available, or it is not.
 *
 * The "simple" image is always 4 components, 1 byte each, regardless of the
 * parameters of the full texture.  The simple image is only supported for
 * ordinary 2-d textures.
 */
INLINE CPTA_uchar Texture::
get_simple_ram_image() const {
  CDReader cdata(_cycler);
  return cdata->_simple_ram_image._image;
}

/**
 * Replaces the internal "simple" texture image.  This can be used as an
 * option to display while the main texture image is being loaded from disk.
 * It is normally a very small image, 16x16 or smaller (and maybe even 1x1),
 * that is designed to give just enough sense of color to serve as a
 * placeholder until the full texture is available.
 *
 * The "simple" image is always 4 components, 1 byte each, regardless of the
 * parameters of the full texture.  The simple image is only supported for
 * ordinary 2-d textures.
 *
 * Also see generate_simple_ram_image(), modify_simple_ram_image(), and
 * new_simple_ram_image().
 */
INLINE void Texture::
set_simple_ram_image(CPTA_uchar image, int x_size, int y_size) {
  CDWriter cdata(_cycler, true);
  do_set_simple_ram_image(cdata, image, x_size, y_size);
}

/**
 * Discards the current "simple" image.
 */
INLINE void Texture::
clear_simple_ram_image() {
  CDWriter cdata(_cycler, true);
  do_clear_simple_ram_image(cdata);
}

/**
 * Returns a sequence number which is guaranteed to change at least every time
 * the texture properties (unrelated to the image) are modified.
 */
INLINE UpdateSeq Texture::
get_properties_modified() const {
  CDReader cdata(_cycler);
  return cdata->_properties_modified;
}

/**
 * Returns a sequence number which is guaranteed to change at least every time
 * the texture image data (including mipmap levels) are modified.
 */
INLINE UpdateSeq Texture::
get_image_modified() const {
  CDReader cdata(_cycler);
  return cdata->_image_modified;
}

/**
 * Returns a sequence number which is guaranteed to change at least every time
 * the texture's "simple" image data is modified.
 */
INLINE UpdateSeq Texture::
get_simple_image_modified() const {
  CDReader cdata(_cycler);
  return cdata->_simple_image_modified;
}

/**
 * Specifies the power-of-2 texture-scaling mode that will be applied to this
 * particular texture when it is next loaded from disk.  See
 * set_textures_power_2().
 */
INLINE void Texture::
set_auto_texture_scale(AutoTextureScale scale) {
  CDWriter cdata(_cycler, true);
  cdata->_auto_texture_scale = scale;
}

/**
 * Returns the power-of-2 texture-scaling mode that will be applied to this
 * particular texture when it is next loaded from disk.  See
 * set_textures_power_2().
 */
INLINE AutoTextureScale Texture::
get_auto_texture_scale() const {
  CDReader cdata(_cycler);
  return do_get_auto_texture_scale(cdata);
}

/**
 * Returns true if set_auto_texture_scale() has been set to something other
 * than ATS_unspecified for this particular texture.
 */
INLINE bool Texture::
has_auto_texture_scale() const {
  CDReader cdata(_cycler);
  return (cdata->_auto_texture_scale != ATS_unspecified);
}

/**
 * Set this flag to ATS_none, ATS_up, ATS_down, or ATS_pad to control the
 * scaling of textures in general, if a particular texture does not override
 * this.  See also set_auto_texture_scale() for the per-texture override.
 */
INLINE void Texture::
set_textures_power_2(AutoTextureScale scale) {
  _textures_power_2 = scale;
}

/**
 * This flag returns ATS_none, ATS_up, or ATS_down and controls the scaling of
 * textures in general.  It is initialized from the config variable of the
 * same name, but it can be subsequently adjusted.  See also
 * get_auto_texture_scale().
 */
INLINE AutoTextureScale Texture::
get_textures_power_2() {
  if (_textures_power_2 == ATS_unspecified) {
    return textures_power_2;
  } else {
    return _textures_power_2;
  }
}

/**
 * If true, then get_textures_power_2 has been set using set_textures_power_2.
 * If false, then get_textures_power_2 simply returns the config variable of
 * the same name.
 */
INLINE bool Texture::
has_textures_power_2() {
  return (_textures_power_2 != ATS_unspecified);
}

/**
 * Sets the name of the file that contains the image's contents.  Normally,
 * this is set automatically when the image is loaded, for instance via
 * Texture::read().
 *
 * The Texture's get_name() function used to return the filename, but now
 * returns just the basename (without the extension), which is a more useful
 * name for identifying an image in show code.
 */
INLINE void Texture::
set_filename(const Filename &filename) {
  CDWriter cdata(_cycler, true);
  cdata->_filename = filename;
}

/**
 * Removes the alpha filename, if it was previously set.  See set_filename().
 */
INLINE void Texture::
clear_filename() {
  CDWriter cdata(_cycler, true);
  cdata->_filename = Filename();
}

/**
 * Sets the name of the file that contains the image's alpha channel contents.
 * Normally, this is set automatically when the image is loaded, for instance
 * via Texture::read().
 *
 * The Texture's get_filename() function returns the name of the image file
 * that was loaded into the buffer.  In the case where a texture specified two
 * separate files to load, a 1- or 3-channel color image and a 1-channel alpha
 * image, this Filename is update to contain the name of the image file that
 * was loaded into the buffer's alpha channel.
 */
INLINE void Texture::
set_alpha_filename(const Filename &alpha_filename) {
  CDWriter cdata(_cycler, true);
  cdata->_alpha_filename = alpha_filename;
}

/**
 * Removes the alpha filename, if it was previously set.  See
 * set_alpha_filename().
 */
INLINE void Texture::
clear_alpha_filename() {
  CDWriter cdata(_cycler, true);
  cdata->_alpha_filename = Filename();
}

/**
 * Sets the full pathname to the file that contains the image's contents, as
 * found along the search path.  Normally, this is set automatically when the
 * image is loaded, for instance via Texture::read().
 */
INLINE void Texture::
set_fullpath(const Filename &fullpath) {
  CDWriter cdata(_cycler, true);
  cdata->_fullpath = fullpath;
}

/**
 * Removes the alpha fullpath, if it was previously set.  See set_fullpath().
 */
INLINE void Texture::
clear_fullpath() {
  CDWriter cdata(_cycler, true);
  cdata->_fullpath = Filename();
}

/**
 * Sets the full pathname to the file that contains the image's alpha channel
 * contents, as found along the search path.  Normally, this is set
 * automatically when the image is loaded, for instance via Texture::read().
 */
INLINE void Texture::
set_alpha_fullpath(const Filename &alpha_fullpath) {
  CDWriter cdata(_cycler, true);
  cdata->_alpha_fullpath = alpha_fullpath;
}

/**
 * Removes the alpha fullpath, if it was previously set.  See
 * set_alpha_fullpath().
 */
INLINE void Texture::
clear_alpha_fullpath() {
  CDWriter cdata(_cycler, true);
  cdata->_alpha_fullpath = Filename();
}

/**
 * Changes the x size indicated for the texture.  This also implicitly unloads
 * the texture if it has already been loaded.
 */
INLINE void Texture::
set_x_size(int x_size) {
  CDWriter cdata(_cycler, true);
  do_set_x_size(cdata, x_size);
}

/**
 * Changes the y size indicated for the texture.  This also implicitly unloads
 * the texture if it has already been loaded.
 */
INLINE void Texture::
set_y_size(int y_size) {
  CDWriter cdata(_cycler, true);
  do_set_y_size(cdata, y_size);
}

/**
 * Changes the z size indicated for the texture.  This also implicitly unloads
 * the texture if it has already been loaded.
 */
INLINE void Texture::
set_z_size(int z_size) {
  CDWriter cdata(_cycler, true);
  do_set_z_size(cdata, z_size);
}

/**
 * Sets the number of "views" within a texture.  A view is a completely
 * separate image stored within the Texture object.  Most textures have only
 * one view, but a stereo texture, for instance, may have two views, a left
 * and a right image.  Other uses for multiple views are not yet defined.
 *
 * If this value is greater than one, the additional views are accessed as
 * additional pages beyond get_z_size().
 *
 * This also implicitly unloads the texture if it has already been loaded.
 */
INLINE void Texture::
set_num_views(int num_views) {
  CDWriter cdata(_cycler, true);
  do_set_num_views(cdata, num_views);
}

/**
 * Changes the format value for the texture components.  This implicitly sets
 * num_components as well.
 */
INLINE void Texture::
set_format(Texture::Format format) {
  CDWriter cdata(_cycler, true);
  do_set_format(cdata, format);
}

/**
 * Changes the data value for the texture components.  This implicitly sets
 * component_width as well.
 */
INLINE void Texture::
set_component_type(Texture::ComponentType component_type) {
  CDWriter cdata(_cycler, true);
  do_set_component_type(cdata, component_type);
}

/**
 * Sets the flag that indicates the texture has been loaded from a disk file
 * or PNMImage.  You should also ensure the filename has been set correctly.
 * When this flag is true, the texture may be automatically reloaded when its
 * ram image needs to be replaced.
 */
INLINE void Texture::
set_loaded_from_image(bool flag) {
  CDWriter cdata(_cycler, false);
  cdata->_loaded_from_image = flag;
}

/**
 * Returns the flag that indicates the texture has been loaded from a disk
 * file or PNMImage.  See set_loaded_from_image().
 */
INLINE bool Texture::
get_loaded_from_image() const {
  CDReader cdata(_cycler);
  return cdata->_loaded_from_image;
}

/**
 * Sets the flag that indicates the texture has been loaded from a txo file.
 * You probably shouldn't be setting this directly; it is set automatically
 * when a Texture is loaded.
 */
INLINE void Texture::
set_loaded_from_txo(bool flag) {
  CDWriter cdata(_cycler, false);
  cdata->_loaded_from_txo = flag;
}

/**
 * Returns the flag that indicates the texture has been loaded from a txo
 * file.
 */
INLINE bool Texture::
get_loaded_from_txo() const {
  CDReader cdata(_cycler);
  return cdata->_loaded_from_txo;
}

/**
 * Returns true if the special flag was set that indicates to the GSG that the
 * Texture's format should be chosen to exactly match the framebuffer's
 * format, presumably because the application intends to copy image data from
 * the framebuffer into the Texture (or vice-versa).
 */
INLINE bool Texture::
get_match_framebuffer_format() const {
  CDReader cdata(_cycler);
  return cdata->_match_framebuffer_format;
}

/**
 * Sets the special flag that, if true, indicates to the GSG that the
 * Texture's format should be chosen to exactly match the framebuffer's
 * format, presumably because the application intends to copy image data from
 * the framebuffer into the Texture (or vice-versa).
 *
 * This sets only the graphics card's idea of the texture format; it is not
 * related to the system-memory format.
 */
INLINE void Texture::
set_match_framebuffer_format(bool flag) {
  CDWriter cdata(_cycler, true);
  cdata->_match_framebuffer_format = flag;
}

/**
 * Returns the setting of the post_load_store_cache flag.  See
 * set_post_load_store_cache().
 */
INLINE bool Texture::
get_post_load_store_cache() const {
  CDReader cdata(_cycler);
  return cdata->_post_load_store_cache;
}

/**
 * Sets the post_load_store_cache flag.  When this is set, the next time the
 * texture is loaded on a GSG, it will automatically extract its RAM image
 * from the GSG and save it to the global BamCache.
 *
 * This is used to store compressed RAM images in the BamCache.  This flag
 * should not be set explicitly; it is set automatically by the TexturePool
 * when model-cache-compressed-textures is set true.
 */
INLINE void Texture::
set_post_load_store_cache(bool flag) {
  CDWriter cdata(_cycler, true);
  cdata->_post_load_store_cache = flag;
}

/**
 * This method is similar to consider_rescale(), but instead of scaling a
 * separate PNMImage, it will ask the Texture to rescale its own internal
 * image to a power of 2, according to the config file requirements.  This may
 * be useful after loading a Texture image by hand, instead of reading it from
 * a disk file.  Returns true if the texture is changed, false if it was not.
 */
INLINE bool Texture::
rescale_texture() {
  CDWriter cdata(_cycler, true);
  return do_rescale_texture(cdata);
}

/**
 * Works like adjust_size, but also considers the texture class.  Movie
 * textures, for instance, always pad outwards, regardless of textures-
 * power-2.
 */
INLINE bool Texture::
adjust_this_size(int &x_size, int &y_size, const std::string &name,
                 bool for_padding) const {
  CDReader cdata(_cycler);
  return do_adjust_this_size(cdata, x_size, y_size, name, for_padding);
}

/**
 *
 */
INLINE size_t Texture::
do_get_ram_image_size(const CData *cdata) const {
  if (cdata->_ram_images.empty()) {
    return 0;
  }
  return cdata->_ram_images[0]._image.size();
}

/**
 *
 */
INLINE bool Texture::
do_has_ram_mipmap_image(const CData *cdata, int n) const {
  return (n >= 0 && n < (int)cdata->_ram_images.size() &&
          !cdata->_ram_images[n]._image.empty());
}

/**
 *
 */
INLINE size_t Texture::
do_get_expected_ram_image_size(const CData *cdata) const {
  return do_get_expected_ram_view_size(cdata) * (size_t)cdata->_num_views;
}

/**
 *
 */
INLINE size_t Texture::
do_get_expected_ram_view_size(const CData *cdata) const {
  return do_get_expected_ram_page_size(cdata) * (size_t)cdata->_z_size;
}

/**
 *
 */
INLINE size_t Texture::
do_get_expected_ram_page_size(const CData *cdata) const {
  return (size_t)(cdata->_x_size * cdata->_y_size * cdata->_num_components * cdata->_component_width);
}

/**
 *
 */
INLINE size_t Texture::
do_get_expected_ram_mipmap_image_size(const CData *cdata, int n) const {
  return do_get_expected_ram_mipmap_view_size(cdata, n) * (size_t)cdata->_num_views;
}

/**
 *
 */
INLINE size_t Texture::
do_get_expected_ram_mipmap_view_size(const CData *cdata, int n) const {
  return do_get_expected_ram_mipmap_page_size(cdata, n) * (size_t)do_get_expected_mipmap_z_size(cdata, n);
}

/**
 *
 */
INLINE size_t Texture::
do_get_expected_ram_mipmap_page_size(const CData *cdata, int n) const {
  return (size_t)(do_get_expected_mipmap_x_size(cdata, n) * do_get_expected_mipmap_y_size(cdata, n) * cdata->_num_components * cdata->_component_width);
}

/**
 *
 */
INLINE int Texture::
do_get_expected_mipmap_num_pages(const CData *cdata, int n) const {
  return do_get_expected_mipmap_z_size(cdata, n) * cdata->_num_views;
}

/**
 *
 */
INLINE void Texture::
do_clear_ram_image(CData *cdata) {
  cdata->_ram_image_compression = CM_off;
  cdata->_ram_images.clear();
}

/**
 *
 */
INLINE AutoTextureScale Texture::
do_get_auto_texture_scale(const CData *cdata) const {
  if (cdata->_auto_texture_scale == ATS_unspecified) {
    return get_textures_power_2();
  } else {
    return cdata->_auto_texture_scale;
  }
}

/**
 * This is used by load() to store the next consecutive component value into
 * the indicated element of the array, which is taken to be an array of
 * unsigned bytes.  The value is assumed to be in the range 0-255.
 */
INLINE void Texture::
store_unscaled_byte(unsigned char *&p, int value) {
  (*p++) = (uchar)value;
}

/**
 * This is used by load() to store the next consecutive component value into
 * the indicated element of the array, which is taken to be an array of
 * unsigned shorts.  The value is assumed to be in the range 0-65535.
 */
INLINE void Texture::
store_unscaled_short(unsigned char *&p, int value) {
  union {
    ushort us;
    uchar uc[2];
  } v;
  v.us = (ushort)value;
  (*p++) = v.uc[0];
  (*p++) = v.uc[1];
}

/**
 * This is used by load() to store the next consecutive component value into
 * the indicated element of the array, which is taken to be an array of
 * unsigned bytes.  The value will be scaled by the indicated factor before
 * storing it.
 */
INLINE void Texture::
store_scaled_byte(unsigned char *&p, int value, double scale) {
  store_unscaled_byte(p, (int)(value * scale));
}

/**
 * This is used by load() to store the next consecutive component value into
 * the indicated element of the array, which is taken to be an array of
 * unsigned shorts.  The value will be scaled by the indicated factor before
 * storing it.
 */
INLINE void Texture::
store_scaled_short(unsigned char *&p, int value, double scale) {
  store_unscaled_short(p, (int)(value * scale));
}

/**
 * This is used by store() to retrieve the next consecutive component value
 * from the indicated element of the array, which is taken to be an array of
 * unsigned bytes.
 */
INLINE double Texture::
get_unsigned_byte(const unsigned char *&p) {
  return (double)(*p++) / 255.0;
}

/**
 * This is used by store() to retrieve the next consecutive component value
 * from the indicated element of the array, which is taken to be an array of
 * unsigned shorts.
 */
INLINE double Texture::
get_unsigned_short(const unsigned char *&p) {
  union {
    ushort us;
    uchar uc[2];
  } v;
  v.uc[0] = (*p++);
  v.uc[1] = (*p++);
  return (double)v.us / 65535.0;
}

/**
 * This is used by store() to retrieve the next consecutive component value
 * from the indicated element of the array, which is taken to be an array of
 * unsigned ints.
 */
INLINE double Texture::
get_unsigned_int(const unsigned char *&p) {
  union {
    unsigned int ui;
    uchar uc[4];
  } v;
  v.uc[0] = (*p++);
  v.uc[1] = (*p++);
  v.uc[2] = (*p++);
  v.uc[3] = (*p++);
  return (double)v.ui / 4294967295.0;
}

/**
 * This is used by store() to retrieve the next consecutive component value
 * from the indicated element of the array, which is taken to be an array of
 * unsigned ints with the value packed in the 24 least significant bits.
 */
INLINE double Texture::
get_unsigned_int_24(const unsigned char *&p) {
  union {
    uint32_t ui;
    uint8_t uc[4];
  } v;
  v.uc[0] = (*p++);
  v.uc[1] = (*p++);
  v.uc[2] = (*p++);
  v.uc[3] = (*p++);
  return (double)(v.ui & 0xffffff) / (double)0xffffff;
}

/**
 * This is used by store() to retrieve the next consecutive component value
 * from the indicated element of the array, which is taken to be an array of
 * floats.
 */
INLINE double Texture::
get_float(const unsigned char *&p) {
  double v = *((float *)p);
  p += 4;
  return v;
}

/**
 * This is used by store() to retrieve the next consecutive component value
 * from the indicated element of the array, which is taken to be an array of
 * half-floats.
 */
INLINE double Texture::
get_half_float(const unsigned char *&p) {
  union {
    uint32_t ui;
    float uf;
  } v;
  uint16_t in = *(uint16_t *)p;
  p += 2;
  uint32_t t1 = in & 0x7fff; // Non-sign bits
  uint32_t t2 = in & 0x8000; // Sign bit
  uint32_t t3 = in & 0x7c00; // Exponent
  t1 <<= 13; // Align mantissa on MSB
  t2 <<= 16; // Shift sign bit into position
  if (t3 != 0x7c00) {
    t1 += 0x38000000; // Adjust bias
    t1 = (t3 == 0 ? 0 : t1); // Denormals-as-zero
  } else {
    // Infinity / NaN
    t1 |= 0x7f800000;
  }
  t1 |= t2; // Re-insert sign bit
  v.ui = t1;
  return v.uf;
}

/**
 * Returns true if the indicated filename ends in .txo or .txo.pz or .txo.gz,
 * false otherwise.
 */
INLINE bool Texture::
is_txo_filename(const Filename &fullpath) {
  std::string extension = fullpath.get_extension();
#ifdef HAVE_ZLIB
  if (extension == "pz" || extension == "gz") {
    extension = Filename(fullpath.get_basename_wo_extension()).get_extension();
  }
#endif  // HAVE_ZLIB
  return (extension == "txo");
}

/**
 * Returns true if the indicated filename ends in .dds or .dds.pz or .dds.gz,
 * false otherwise.
 */
INLINE bool Texture::
is_dds_filename(const Filename &fullpath) {
  std::string extension = fullpath.get_extension();
#ifdef HAVE_ZLIB
  if (extension == "pz" || extension == "gz") {
    extension = Filename(fullpath.get_basename_wo_extension()).get_extension();
  }
#endif  // HAVE_ZLIB
  return (downcase(extension) == "dds");
}

/**
 * Returns true if the indicated filename ends in .ktx or .ktx.pz or .ktx.gz,
 * false otherwise.
 */
INLINE bool Texture::
is_ktx_filename(const Filename &fullpath) {
  std::string extension = fullpath.get_extension();
#ifdef HAVE_ZLIB
  if (extension == "pz" || extension == "gz") {
    extension = Filename(fullpath.get_basename_wo_extension()).get_extension();
  }
#endif  // HAVE_ZLIB
  return (downcase(extension) == "ktx");
}

/**
 *
 */
INLINE void Texture::CData::
inc_properties_modified() {
  ++_properties_modified;
}

/**
 *
 */
INLINE void Texture::CData::
inc_image_modified() {
  ++_image_modified;
}

/**
 *
 */
INLINE void Texture::CData::
inc_simple_image_modified() {
  ++_simple_image_modified;
}

/**
 *
 */
INLINE Texture::RamImage::
RamImage() :
  _page_size(0),
  _pointer_image(nullptr)
{
}