Christophe Riccio
ago%!(EXTRA string=14 years)
parent
f1a56a6ba1
commit
124780e826
46 changed files with 4668 additions and 6 deletions
@ -0,0 +1,27 @@ |
||||
set(NAME gli) |
||||
|
||||
file(GLOB ROOT_SOURCE *.cpp) |
||||
file(GLOB ROOT_INLINE *.inl) |
||||
file(GLOB ROOT_HEADER *.hpp) |
||||
|
||||
file(GLOB_RECURSE CORE_SOURCE ./core/*.cpp) |
||||
file(GLOB_RECURSE CORE_INLINE ./core/*.inl) |
||||
file(GLOB_RECURSE CORE_HEADER ./core/*.hpp) |
||||
|
||||
file(GLOB_RECURSE GTX_SOURCE ./gtx/*.cpp) |
||||
file(GLOB_RECURSE GTX_INLINE ./gtx/*.inl) |
||||
file(GLOB_RECURSE GTX_HEADER ./gtx/*.hpp) |
||||
|
||||
source_group("Core Files" FILES ${CORE_SOURCE}) |
||||
source_group("Core Files" FILES ${CORE_INLINE}) |
||||
source_group("Core Files" FILES ${CORE_HEADER}) |
||||
source_group("GTX Files" FILES ${GTX_SOURCE}) |
||||
source_group("GTX Files" FILES ${GTX_INLINE}) |
||||
source_group("GTX Files" FILES ${GTX_HEADER}) |
||||
|
||||
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..) |
||||
|
||||
add_executable(${NAME} |
||||
${ROOT_SOURCE} ${ROOT_INLINE} ${ROOT_HEADER} |
||||
${CORE_SOURCE} ${CORE_INLINE} ${CORE_HEADER} |
||||
${GTX_SOURCE} ${GTX_INLINE} ${GTX_HEADER} ) |
||||
@ -0,0 +1,4 @@ |
||||
int main() |
||||
{ |
||||
|
||||
} |
||||
@ -0,0 +1,25 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2010-09-27
|
||||
// Updated : 2010-09-27
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/core/generate_mipmaps.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_GENERATE_MIPMAPS_INCLUDED |
||||
#define GLI_GENERATE_MIPMAPS_INCLUDED |
||||
|
||||
#include "texture2d.hpp" |
||||
|
||||
namespace gli |
||||
{ |
||||
texture2D generateMipmaps( |
||||
texture2D const & Texture,
|
||||
texture2D::level_type const & BaseLevel); |
||||
|
||||
}//namespace gli
|
||||
|
||||
#include "generate_mipmaps.inl" |
||||
|
||||
#endif//GLI_GENERATE_MIPMAPS_INCLUDED
|
||||
@ -0,0 +1,69 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2010-09-27 |
||||
// Updated : 2010-09-27 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/core/generate_mipmaps.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace gli |
||||
{ |
||||
inline texture2D generateMipmaps |
||||
( |
||||
texture2D const & Image, |
||||
texture2D::level_type const & BaseLevel |
||||
) |
||||
{ |
||||
assert(BaseLevel < Image.levels()); |
||||
texture2D::format_type Format = Image[BaseLevel].format(); |
||||
|
||||
assert(Format == R8U || Format == RG8U || Format == RGB8U || Format == RGBA8U); |
||||
texture2D::level_type Levels = std::size_t(glm::log2(float(glm::compMax(Image[0].dimensions())))) + 1; |
||||
|
||||
texture2D Result(Levels); |
||||
for(texture2D::level_type Level = 0; Level <= BaseLevel; ++Level) |
||||
Result[Level] = detail::duplicate(Image[Level]); |
||||
|
||||
for(texture2D::level_type Level = BaseLevel; Level < Levels - 1; ++Level) |
||||
{ |
||||
std::size_t BaseWidth = Result[Level + 0].dimensions().x; |
||||
texture2D::value_type * DataSrc = Result[Level + 0].data(); |
||||
|
||||
texture2D::dimensions_type LevelDimensions = Result[Level + 0].dimensions() >> texture2D::dimensions_type(1); |
||||
LevelDimensions = glm::max(LevelDimensions, texture2D::dimensions_type(1)); |
||||
texture2D::size_type ValueSize = Result[Level + 0].value_size(); |
||||
texture2D::size_type Components = Result[Level + 0].components(); |
||||
|
||||
texture2D::data_type DataDst(glm::compMul(LevelDimensions) * Components); |
||||
|
||||
for(std::size_t j = 0; j < LevelDimensions.y; ++j) |
||||
for(std::size_t i = 0; i < LevelDimensions.x; ++i) |
||||
for(std::size_t c = 0; c < Components; ++c) |
||||
{ |
||||
std::size_t x = (i << 1); |
||||
std::size_t y = (j << 1); |
||||
|
||||
std::size_t Index00 = ((x + 0) + (y + 0) * BaseWidth) * Components + c; |
||||
std::size_t Index01 = ((x + 0) + (y + 1) * BaseWidth) * Components + c; |
||||
std::size_t Index11 = ((x + 1) + (y + 1) * BaseWidth) * Components + c; |
||||
std::size_t Index10 = ((x + 1) + (y + 0) * BaseWidth) * Components + c; |
||||
|
||||
glm::u32 Data00 = reinterpret_cast<texture2D::value_type*>(DataSrc)[Index00]; |
||||
glm::u32 Data01 = reinterpret_cast<texture2D::value_type*>(DataSrc)[Index01]; |
||||
glm::u32 Data11 = reinterpret_cast<texture2D::value_type*>(DataSrc)[Index11]; |
||||
glm::u32 Data10 = reinterpret_cast<texture2D::value_type*>(DataSrc)[Index10]; |
||||
|
||||
texture2D::value_type Result = (Data00 + Data01 + Data11 + Data10) >> 2; |
||||
texture2D::value_type * Data = reinterpret_cast<texture2D::value_type*>(DataDst.data()); |
||||
|
||||
*(Data + ((i + j * LevelDimensions.x) * Components + c)) = Result; |
||||
} |
||||
|
||||
Result[Level + 1] = image2D(LevelDimensions, Format, DataDst); |
||||
} |
||||
|
||||
return Result; |
||||
} |
||||
|
||||
}//namespace gli |
||||
@ -0,0 +1,169 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2011-04-05
|
||||
// Updated : 2011-04-05
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/core/image2d.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_CORE_IMAGE2D_INCLUDED |
||||
#define GLI_CORE_IMAGE2D_INCLUDED |
||||
|
||||
// STD
|
||||
#include <vector> |
||||
#include <cassert> |
||||
#include <cmath> |
||||
#include <cstring> |
||||
|
||||
// GLM
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtx/number_precision.hpp> |
||||
#include <glm/gtx/raw_data.hpp> |
||||
#include <glm/gtx/gradient_paint.hpp> |
||||
#include <glm/gtx/component_wise.hpp> |
||||
|
||||
namespace gli |
||||
{ |
||||
enum format |
||||
{ |
||||
FORMAT_NULL, |
||||
|
||||
// Unsigned integer formats
|
||||
R8U, |
||||
RG8U, |
||||
RGB8U, |
||||
RGBA8U, |
||||
|
||||
R16U, |
||||
RG16U, |
||||
RGB16U, |
||||
RGBA16U, |
||||
|
||||
R32U, |
||||
RG32U, |
||||
RGB32U, |
||||
RGBA32U, |
||||
|
||||
// Signed integer formats
|
||||
R8I, |
||||
RG8I, |
||||
RGB8I, |
||||
RGBA8I, |
||||
|
||||
R16I, |
||||
RG16I, |
||||
RGB16I, |
||||
RGBA16I, |
||||
|
||||
R32I, |
||||
RG32I, |
||||
RGB32I, |
||||
RGBA32I, |
||||
|
||||
// Floating formats
|
||||
R16F, |
||||
RG16F, |
||||
RGB16F, |
||||
RGBA16F, |
||||
|
||||
R32F, |
||||
RG32F, |
||||
RGB32F, |
||||
RGBA32F, |
||||
|
||||
// Packed formats
|
||||
RGBE8, |
||||
RGB9E5, |
||||
RG11B10F, |
||||
R5G6B5, |
||||
RGBA4, |
||||
RGB10A2, |
||||
|
||||
// Depth formats
|
||||
D16, |
||||
D24X8, |
||||
D24S8, |
||||
D32F, |
||||
D32FS8X24, |
||||
|
||||
// Compressed formats
|
||||
DXT1, |
||||
DXT3, |
||||
DXT5, |
||||
ATI1N_UNORM, |
||||
ATI1N_SNORM, |
||||
ATI2N_UNORM, |
||||
ATI2N_SNORM, |
||||
BP_UF16, |
||||
BP_SF16, |
||||
BP, |
||||
|
||||
FORMAT_MAX |
||||
}; |
||||
|
||||
enum size_type |
||||
{ |
||||
LINEAR_SIZE, |
||||
BLOCK_SIZE, |
||||
BIT_PER_PIXEL,
|
||||
COMPONENT |
||||
}; |
||||
|
||||
class image2D |
||||
{ |
||||
public: |
||||
typedef glm::uvec2 dimensions_type; |
||||
typedef glm::vec2 texcoord_type; |
||||
typedef glm::uint32 size_type; |
||||
typedef glm::byte value_type; |
||||
typedef gli::format format_type; |
||||
typedef std::vector<value_type> data_type; |
||||
|
||||
public: |
||||
image2D(); |
||||
image2D( |
||||
image2D const & Image); |
||||
|
||||
explicit image2D( |
||||
dimensions_type const & Dimensions, |
||||
format_type const & Format); |
||||
|
||||
template <typename genType> |
||||
explicit image2D( |
||||
dimensions_type const & Dimensions, |
||||
format_type const & Format,
|
||||
genType const & Value); |
||||
|
||||
explicit image2D( |
||||
dimensions_type const & Dimensions, |
||||
format_type const & Format,
|
||||
std::vector<value_type> const & Data); |
||||
|
||||
~image2D(); |
||||
|
||||
template <typename genType> |
||||
void setPixel( |
||||
dimensions_type const & TexelCoord, |
||||
genType const & TexelData); |
||||
|
||||
size_type value_size() const; |
||||
size_type capacity() const; |
||||
dimensions_type dimensions() const; |
||||
size_type components() const; |
||||
format_type format() const; |
||||
|
||||
value_type * data(); |
||||
value_type const * const data() const; |
||||
|
||||
private: |
||||
data_type Data; |
||||
dimensions_type Dimensions; |
||||
format_type Format; |
||||
}; |
||||
|
||||
}//namespace gli
|
||||
|
||||
#include "image2d.inl" |
||||
|
||||
#endif//GLI_CORE_IMAGE2D_INCLUDED
|
||||
@ -0,0 +1,231 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2011-04-05 |
||||
// Updated : 2011-04-05 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/core/image2d.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace gli |
||||
{ |
||||
namespace detail |
||||
{ |
||||
struct format_desc |
||||
{ |
||||
image2D::size_type BlockSize; |
||||
image2D::size_type BBP; |
||||
image2D::size_type Component; |
||||
}; |
||||
|
||||
inline format_desc getFormatInfo(format const & Format) |
||||
{ |
||||
format_desc Desc[FORMAT_MAX] = |
||||
{ |
||||
{ 0, 0, 0}, //FORMAT_NULL |
||||
|
||||
// Unsigned integer formats |
||||
{ 1, 8, 1}, //R8U, |
||||
{ 2, 16, 2}, //RG8U, |
||||
{ 3, 24, 3}, //RGB8U, |
||||
{ 4, 32, 4}, //RGBA8U, |
||||
|
||||
{ 2, 16, 1}, //R16U, |
||||
{ 4, 32, 2}, //RG16U, |
||||
{ 6, 48, 3}, //RGB16U, |
||||
{ 8, 64, 4}, //RGBA16U, |
||||
|
||||
{ 4, 32, 1}, //R32U, |
||||
{ 8, 64, 2}, //RG32U, |
||||
{ 12, 96, 3}, //RGB32U, |
||||
{ 16, 128, 4}, //RGBA32U, |
||||
|
||||
//// Signed integer formats |
||||
{ 4, 32, 1}, //R8I, |
||||
{ 8, 64, 2}, //RG8I, |
||||
{ 12, 96, 3}, //RGB8I, |
||||
{ 16, 128, 4}, //RGBA8I, |
||||
|
||||
{ 2, 16, 1}, //R16I, |
||||
{ 4, 32, 2}, //RG16I, |
||||
{ 6, 48, 3}, //RGB16I, |
||||
{ 8, 64, 4}, //RGBA16I, |
||||
|
||||
{ 4, 32, 1}, //R32I, |
||||
{ 8, 64, 2}, //RG32I, |
||||
{ 12, 96, 3}, //RGB32I, |
||||
{ 16, 128, 4}, //RGBA32I, |
||||
|
||||
//// Floating formats |
||||
{ 2, 16, 1}, //R16F, |
||||
{ 4, 32, 2}, //RG16F, |
||||
{ 6, 48, 3}, //RGB16F, |
||||
{ 8, 64, 4}, //RGBA16F, |
||||
|
||||
{ 4, 32, 1}, //R32F, |
||||
{ 8, 64, 2}, //RG32F, |
||||
{ 12, 96, 3}, //RGB32F, |
||||
{ 16, 128, 4}, //RGBA32F, |
||||
|
||||
//// Packed formats |
||||
{ 4, 32, 3}, //RGBE8, |
||||
{ 4, 32, 3}, //RGB9E5, |
||||
{ 4, 32, 3}, //RG11B10F, |
||||
{ 2, 16, 3}, //R5G6B5, |
||||
{ 2, 16, 4}, //RGBA4, |
||||
{ 4, 32, 3}, //RGB10A2, |
||||
|
||||
//// Depth formats |
||||
{ 2, 16, 1}, //D16, |
||||
{ 4, 32, 1}, //D24X8, |
||||
{ 4, 32, 2}, //D24S8, |
||||
{ 4, 32, 1}, //D32F, |
||||
{ 8, 64, 2}, //D32FS8X24, |
||||
|
||||
//// Compressed formats |
||||
{ 8, 4, 4}, //DXT1, |
||||
{ 16, 8, 4}, //DXT3, |
||||
{ 16, 8, 4}, //DXT5, |
||||
{ 8, 4, 1}, //ATI1N_UNORM, |
||||
{ 8, 4, 1}, //ATI1N_SNORM, |
||||
{ 16, 8, 2}, //ATI2N_UNORM, |
||||
{ 16, 8, 2}, //ATI2N_SNORM, |
||||
{ 16, 8, 3}, //BP_UF16, |
||||
{ 16, 8, 3}, //BP_SF16, |
||||
{ 16, 8, 4}, //BP, |
||||
}; |
||||
|
||||
return Desc[Format]; |
||||
}; |
||||
|
||||
inline image2D::size_type sizeBlock |
||||
( |
||||
format const & Format |
||||
) |
||||
{ |
||||
return getFormatInfo(Format).BlockSize; |
||||
} |
||||
|
||||
inline image2D::size_type sizeBitPerPixel |
||||
( |
||||
format const & Format |
||||
) |
||||
{ |
||||
return getFormatInfo(Format).BBP; |
||||
} |
||||
|
||||
inline image2D::size_type sizeComponent |
||||
( |
||||
format const & Format |
||||
) |
||||
{ |
||||
return getFormatInfo(Format).Component; |
||||
} |
||||
|
||||
inline image2D::size_type sizeLinear |
||||
( |
||||
image2D const & Image |
||||
) |
||||
{ |
||||
image2D::dimensions_type Dimension = Image.dimensions(); |
||||
Dimension = glm::max(Dimension, image2D::dimensions_type(1)); |
||||
|
||||
image2D::size_type BlockSize = sizeBlock(Image.format()); |
||||
image2D::size_type BPP = sizeBitPerPixel(Image.format()); |
||||
image2D::size_type BlockCount = 0; |
||||
if((BlockSize << 3) == BPP) |
||||
BlockCount = Dimension.x * Dimension.y; |
||||
else |
||||
BlockCount = ((Dimension.x + 3) >> 2) * ((Dimension.y + 3) >> 2); |
||||
|
||||
return BlockCount * BlockSize; |
||||
} |
||||
}//namespace detail |
||||
|
||||
inline image2D::image2D() : |
||||
Data(0), |
||||
Dimensions(0), |
||||
Format(FORMAT_NULL) |
||||
{} |
||||
|
||||
inline image2D::image2D |
||||
( |
||||
image2D const & Image |
||||
) : |
||||
Data(Image.Data), |
||||
Dimensions(Image.Dimensions), |
||||
Format(Image.Format) |
||||
{} |
||||
|
||||
inline image2D::image2D |
||||
( |
||||
dimensions_type const & Dimensions, |
||||
format_type const & Format |
||||
) : |
||||
Data((glm::compMul(Dimensions) * detail::sizeBitPerPixel(Format)) >> 3), |
||||
Dimensions(Dimensions), |
||||
Format(Format) |
||||
{ |
||||
std::size_t Size = (glm::compMul(Dimensions) * detail::sizeBitPerPixel(Format)) >> 3; |
||||
} |
||||
|
||||
inline image2D::image2D |
||||
( |
||||
dimensions_type const & Dimensions, |
||||
format_type const & Format, |
||||
std::vector<value_type> const & Data |
||||
) : |
||||
Data(Data), |
||||
Dimensions(Dimensions), |
||||
Format(Format) |
||||
{} |
||||
|
||||
inline image2D::~image2D() |
||||
{} |
||||
|
||||
template <typename genType> |
||||
inline void image2D::setPixel |
||||
( |
||||
dimensions_type const & TexelCoord, |
||||
genType const & TexelData |
||||
) |
||||
{ |
||||
size_type Index = this->dimensions().x * sizeof(genType) * TexelCoord.y + sizeof(genType) * TexelCoord.x; |
||||
memcpy(this->data() + Index, &TexelData[0], sizeof(genType)); |
||||
} |
||||
|
||||
inline image2D::size_type image2D::value_size() const |
||||
{ |
||||
return detail::sizeBitPerPixel(this->format()); |
||||
} |
||||
|
||||
inline image2D::size_type image2D::capacity() const |
||||
{ |
||||
return detail::sizeLinear(*this); |
||||
} |
||||
|
||||
inline image2D::dimensions_type image2D::dimensions() const |
||||
{ |
||||
return this->Dimensions; |
||||
} |
||||
|
||||
inline image2D::size_type image2D::components() const |
||||
{ |
||||
return detail::sizeComponent(this->format()); |
||||
} |
||||
|
||||
inline image2D::format_type image2D::format() const |
||||
{ |
||||
return this->Format; |
||||
} |
||||
|
||||
inline image2D::value_type * image2D::data() |
||||
{ |
||||
return &this->Data[0]; |
||||
} |
||||
|
||||
inline image2D::value_type const * const image2D::data() const |
||||
{ |
||||
return &this->Data[0]; |
||||
} |
||||
}//namespace gli |
||||
@ -0,0 +1,82 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2008-12-19
|
||||
// Updated : 2010-01-09
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/operation.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_OPERATION_INCLUDED |
||||
#define GLI_OPERATION_INCLUDED |
||||
|
||||
#include "texture2d.hpp" |
||||
|
||||
namespace gli |
||||
{ |
||||
texture2D duplicate(texture2D const & Texture); |
||||
texture2D flip(texture2D const & Texture); |
||||
texture2D mirror(texture2D const & Texture); |
||||
texture2D swizzle( |
||||
texture2D const & Texture,
|
||||
glm::uvec4 const & Channel); |
||||
texture2D crop( |
||||
texture2D const & Texture,
|
||||
texture2D::dimensions_type const & Position, |
||||
texture2D::dimensions_type const & Size); |
||||
|
||||
image2D crop( |
||||
image2D const & Image,
|
||||
texture2D::dimensions_type const & Position, |
||||
texture2D::dimensions_type const & Size); |
||||
|
||||
image2D copy( |
||||
image2D const & SrcImage,
|
||||
image2D::dimensions_type const & SrcPosition, |
||||
image2D::dimensions_type const & SrcSize, |
||||
image2D & DstImage,
|
||||
image2D::dimensions_type const & DstPosition); |
||||
|
||||
//image operator+(image const & MipmapA, image const & MipmapB);
|
||||
//image operator-(image const & MipmapA, image const & MipmapB);
|
||||
//image operator*(image const & MipmapA, image const & MipmapB);
|
||||
//image operator/(image const & MipmapA, image const & MipmapB);
|
||||
|
||||
//namespace wip
|
||||
//{
|
||||
// template <typename GENTYPE, template <typename> class SURFACE>
|
||||
// GENTYPE fetch(SURFACE<GENTYPE> const & Image)
|
||||
// {
|
||||
// return GENTYPE();
|
||||
// }
|
||||
|
||||
// template
|
||||
// <
|
||||
// typename GENTYPE,
|
||||
// template
|
||||
// <
|
||||
// typename
|
||||
// >
|
||||
// class SURFACE,
|
||||
// template
|
||||
// <
|
||||
// typename,
|
||||
// template
|
||||
// <
|
||||
// typename
|
||||
// >
|
||||
// class
|
||||
// >
|
||||
// class IMAGE
|
||||
// >
|
||||
// GENTYPE fetch(IMAGE<GENTYPE, SURFACE> const & Image)
|
||||
// {
|
||||
// return GENTYPE();
|
||||
// }
|
||||
//}//namespace wip
|
||||
|
||||
}//namespace gli
|
||||
|
||||
#include "operation.inl" |
||||
|
||||
#endif//GLI_OPERATION_INCLUDED
|
||||
@ -0,0 +1,233 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2008-12-19 |
||||
// Updated : 2010-09-08 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/core/operation.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
#include <cstring> |
||||
|
||||
namespace gli |
||||
{ |
||||
namespace detail |
||||
{ |
||||
inline image2D duplicate(image2D const & Mipmap2D) |
||||
{ |
||||
image2D Result(Mipmap2D.dimensions(), Mipmap2D.format()); |
||||
memcpy(Result.data(), Mipmap2D.data(), Mipmap2D.capacity()); |
||||
return Result; |
||||
} |
||||
|
||||
inline image2D flip(image2D const & Mipmap2D) |
||||
{ |
||||
image2D Result(Mipmap2D.dimensions(), Mipmap2D.format()); |
||||
|
||||
std::size_t ValueSize = Result.value_size(); |
||||
glm::byte * DstPtr = Result.data(); |
||||
glm::byte const * const SrcPtr = Mipmap2D.data(); |
||||
|
||||
for(std::size_t j = 0; j < Result.dimensions().y; ++j) |
||||
for(std::size_t i = 0; i < Result.dimensions().x; ++i) |
||||
{ |
||||
std::size_t DstIndex = (i + j * Result.dimensions().y) * ValueSize; |
||||
std::size_t SrcIndex = (i + (Result.dimensions().y - j) * Result.dimensions().x) * ValueSize; |
||||
memcpy(DstPtr + DstIndex, SrcPtr + SrcIndex, ValueSize); |
||||
} |
||||
|
||||
return Result; |
||||
} |
||||
|
||||
inline image2D mirror(image2D const & Mipmap2D) |
||||
{ |
||||
image2D Result(Mipmap2D.dimensions(), Mipmap2D.format()); |
||||
|
||||
std::size_t ValueSize = Mipmap2D.value_size(); |
||||
glm::byte * DstPtr = Result.data(); |
||||
glm::byte const * const SrcPtr = Mipmap2D.data(); |
||||
|
||||
for(std::size_t j = 0; j < Result.dimensions().y; ++j) |
||||
for(std::size_t i = 0; i < Result.dimensions().x; ++i) |
||||
{ |
||||
std::size_t DstIndex = (i + j * Result.dimensions().x) * ValueSize; |
||||
std::size_t SrcIndex = ((Result.dimensions().x - i) + j * Result.dimensions().x) * ValueSize; |
||||
memcpy(DstPtr + DstIndex, SrcPtr + SrcIndex, ValueSize); |
||||
} |
||||
|
||||
return Result; |
||||
} |
||||
|
||||
inline image2D swizzle |
||||
( |
||||
image2D const & Mipmap, |
||||
glm::uvec4 const & Channel |
||||
) |
||||
{ |
||||
image2D Result = detail::duplicate(Mipmap); |
||||
|
||||
glm::byte * DataDst = Result.data(); |
||||
glm::byte const * const DataSrc = Mipmap.data(); |
||||
|
||||
gli::texture2D::size_type CompSize = Mipmap.value_size() / Mipmap.components(); |
||||
gli::texture2D::size_type TexelCount = Mipmap.capacity() / Mipmap.value_size(); |
||||
|
||||
for(gli::texture2D::size_type t = 0; t < TexelCount; ++t) |
||||
for(gli::texture2D::size_type c = 0; c < Mipmap.components(); ++c) |
||||
{ |
||||
gli::texture2D::size_type IndexSrc = t * Mipmap.components() + Channel[glm::uvec4::size_type(c)]; |
||||
gli::texture2D::size_type IndexDst = t * Mipmap.components() + c; |
||||
|
||||
memcpy(DataDst + IndexDst, DataSrc + IndexSrc, CompSize); |
||||
} |
||||
|
||||
return Result; |
||||
} |
||||
|
||||
inline image2D crop |
||||
( |
||||
image2D const & Image, |
||||
image2D::dimensions_type const & Position, |
||||
image2D::dimensions_type const & Size |
||||
) |
||||
{ |
||||
assert((Position.x + Size.x) <= Image.dimensions().x && (Position.y + Size.y) <= Image.dimensions().y); |
||||
|
||||
image2D Result(Size, Image.format()); |
||||
|
||||
glm::byte* DstData = Result.data(); |
||||
glm::byte const * const SrcData = Image.data(); |
||||
|
||||
for(std::size_t j = 0; j < Size.y; ++j) |
||||
{ |
||||
std::size_t DstIndex = 0 + (0 + j) * Size.x * Image.value_size(); |
||||
std::size_t SrcIndex = Position.x * Image.value_size() + (Position.y + j) * Image.dimensions().x * Image.value_size(); |
||||
memcpy(DstData + DstIndex, SrcData + SrcIndex, Image.value_size() * Size.x); |
||||
} |
||||
|
||||
return Result; |
||||
} |
||||
|
||||
inline image2D copy |
||||
( |
||||
image2D const & SrcMipmap, |
||||
image2D::dimensions_type const & SrcPosition, |
||||
image2D::dimensions_type const & SrcSize, |
||||
image2D & DstMipmap, |
||||
image2D::dimensions_type const & DstPosition |
||||
) |
||||
{ |
||||
assert((SrcPosition.x + SrcSize.x) <= SrcMipmap.dimensions().x && (SrcPosition.y + SrcSize.y) <= SrcMipmap.dimensions().y); |
||||
assert(SrcMipmap.format() == DstMipmap.format()); |
||||
|
||||
glm::byte * DstData = DstMipmap.data(); |
||||
glm::byte const * const SrcData = SrcMipmap.data(); |
||||
|
||||
std::size_t SizeX = std::min(std::size_t(SrcSize.x + SrcPosition.x), std::size_t(DstMipmap.dimensions().x + DstPosition.x)); |
||||
std::size_t SizeY = std::min(std::size_t(SrcSize.y + SrcPosition.y), std::size_t(DstMipmap.dimensions().y + DstPosition.y)); |
||||
|
||||
for(std::size_t j = 0; j < SizeY; ++j) |
||||
{ |
||||
std::size_t DstIndex = DstPosition.x * DstMipmap.value_size() + (DstPosition.y + j) * DstMipmap.dimensions().x * DstMipmap.value_size(); |
||||
std::size_t SrcIndex = SrcPosition.x * SrcMipmap.value_size() + (SrcPosition.y + j) * SrcMipmap.dimensions().x * SrcMipmap.value_size(); |
||||
memcpy(DstData + DstIndex, SrcData + SrcIndex, SrcMipmap.value_size() * SizeX); |
||||
} |
||||
|
||||
return DstMipmap; |
||||
} |
||||
|
||||
}//namespace detail |
||||
|
||||
inline texture2D duplicate(texture2D const & Texture2D) |
||||
{ |
||||
texture2D Result(Texture2D.levels()); |
||||
for(texture2D::level_type Level = 0; Level < Texture2D.levels(); ++Level) |
||||
Result[Level] = detail::duplicate(Texture2D[Level]); |
||||
return Result; |
||||
} |
||||
|
||||
inline texture2D flip(texture2D const & Texture2D) |
||||
{ |
||||
texture2D Result(Texture2D.levels()); |
||||
for(texture2D::level_type Level = 0; Level < Texture2D.levels(); ++Level) |
||||
Result[Level] = detail::flip(Texture2D[Level]); |
||||
return Result; |
||||
} |
||||
|
||||
inline texture2D mirror(texture2D const & Texture2D) |
||||
{ |
||||
texture2D Result(Texture2D.levels()); |
||||
for(texture2D::level_type Level = 0; Level < Texture2D.levels(); ++Level) |
||||
Result[Level] = detail::mirror(Texture2D[Level]); |
||||
return Result; |
||||
} |
||||
|
||||
inline texture2D crop |
||||
( |
||||
texture2D const & Texture2D, |
||||
texture2D::dimensions_type const & Position, |
||||
texture2D::dimensions_type const & Size |
||||
) |
||||
{ |
||||
texture2D Result(Texture2D.levels()); |
||||
for(texture2D::level_type Level = 0; Level < Texture2D.levels(); ++Level) |
||||
Result[Level] = detail::crop( |
||||
Texture2D[Level], |
||||
Position >> texture2D::dimensions_type(Level), |
||||
Size >> texture2D::dimensions_type(Level)); |
||||
return Result; |
||||
} |
||||
|
||||
inline texture2D swizzle |
||||
( |
||||
texture2D const & Texture2D, |
||||
glm::uvec4 const & Channel |
||||
) |
||||
{ |
||||
texture2D Result(Texture2D.levels()); |
||||
for(texture2D::level_type Level = 0; Level < Texture2D.levels(); ++Level) |
||||
Result[Level] = detail::swizzle(Texture2D[Level], Channel); |
||||
return Result; |
||||
} |
||||
|
||||
inline texture2D copy |
||||
( |
||||
texture2D const & SrcImage, |
||||
texture2D::level_type const & SrcLevel, |
||||
texture2D::dimensions_type const & SrcPosition, |
||||
texture2D::dimensions_type const & SrcDimensions, |
||||
texture2D & DstMipmap, |
||||
texture2D::level_type const & DstLevel, |
||||
texture2D::dimensions_type const & DstDimensions |
||||
) |
||||
{ |
||||
detail::copy( |
||||
SrcImage[SrcLevel], |
||||
SrcPosition, |
||||
SrcDimensions, |
||||
DstMipmap[DstLevel], |
||||
DstDimensions); |
||||
return DstMipmap; |
||||
} |
||||
|
||||
//inline image operator+(image const & MipmapA, image const & MipmapB) |
||||
//{ |
||||
// |
||||
//} |
||||
|
||||
//inline image operator-(image const & MipmapA, image const & MipmapB) |
||||
//{ |
||||
// |
||||
//} |
||||
|
||||
//inline image operator*(image const & MipmapA, image const & MipmapB) |
||||
//{ |
||||
// |
||||
//} |
||||
|
||||
//inline image operator/(image const & MipmapA, image const & MipmapB) |
||||
//{ |
||||
// |
||||
//} |
||||
|
||||
}//namespace gli |
||||
@ -0,0 +1,28 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2010-01-19
|
||||
// Updated : 2010-01-19
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/core/operator.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_OPERATOR_INCLUDED |
||||
#define GLI_OPERATOR_INCLUDED |
||||
|
||||
#include "texture2d.hpp" |
||||
|
||||
namespace gli{ |
||||
namespace detail |
||||
{ |
||||
|
||||
}//namespace detail
|
||||
|
||||
texture2D operator+(texture2D const & TextureA, texture2D const & TextureB); |
||||
texture2D operator-(texture2D const & TextureA, texture2D const & TextureB); |
||||
|
||||
}//namespace gli
|
||||
|
||||
#include "operator.inl" |
||||
|
||||
#endif//GLI_OPERATOR_INCLUDED
|
||||
@ -0,0 +1,210 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2010-01-19 |
||||
// Updated : 2010-01-19 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/core/operator.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace gli |
||||
{ |
||||
namespace detail |
||||
{ |
||||
template <typename T> |
||||
void element |
||||
( |
||||
T & DataDst, |
||||
T const & DataSrcA, |
||||
T const & DataSrcB, |
||||
std::binary_function<T, T, T> const & Func |
||||
) |
||||
{ |
||||
*DataDst = Func(DataSrcA, DataSrcB); |
||||
} |
||||
|
||||
void op |
||||
( |
||||
texture2D::value_type * DataDst, |
||||
texture2D::value_type const * const DataSrcA, |
||||
texture2D::value_type const * const DataSrcB, |
||||
format Format |
||||
) |
||||
{ |
||||
std::plus<>() |
||||
switch(Format) |
||||
{ |
||||
case R8U: |
||||
*((glm::u8*)DataDst) = *((glm::u8*)DataSrcA) + *((glm::u8*)DataSrcB); |
||||
break; |
||||
case RG8U: |
||||
*((glm::u8vec2*)DataDst) = *((glm::u8vec2*)DataSrcA) + *((glm::u8vec2*)DataSrcB); |
||||
break; |
||||
case RGB8U: |
||||
*((glm::u8vec3*)DataDst) = *((glm::u8vec3*)DataSrcA) + *((glm::u8vec3*)DataSrcB); |
||||
break; |
||||
case RGBA8U: |
||||
*((glm::u8vec4*)DataDst) = *((glm::u8vec4*)DataSrcA) + *((glm::u8vec4*)DataSrcB); |
||||
break; |
||||
|
||||
case R16U: |
||||
*((glm::u16*)DataDst) = *((glm::u16*)DataSrcA) + *((glm::u16*)DataSrcB); |
||||
break; |
||||
case RG16U: |
||||
*((glm::u16vec2*)DataDst) = *((glm::u16vec2*)DataSrcA) + *((glm::u16vec2*)DataSrcB); |
||||
break; |
||||
case RGB16U: |
||||
*((glm::u16vec3*)DataDst) = *((glm::u16vec3*)DataSrcA) + *((glm::u16vec3*)DataSrcB); |
||||
break; |
||||
case RGBA16U: |
||||
*((glm::u16vec4*)DataDst) = *((glm::u16vec4*)DataSrcA) + *((glm::u16vec4*)DataSrcB); |
||||
break; |
||||
|
||||
case R32U: |
||||
*((glm::u32*)DataDst) = *((glm::u32*)DataSrcA) + *((glm::u32*)DataSrcB); |
||||
break; |
||||
case RG32U: |
||||
*((glm::u32vec2*)DataDst) = *((glm::u32vec2*)DataSrcA) + *((glm::u32vec2*)DataSrcB); |
||||
break; |
||||
case RGB32U: |
||||
*((glm::u32vec3*)DataDst) = *((glm::u32vec3*)DataSrcA) + *((glm::u32vec3*)DataSrcB); |
||||
break; |
||||
case RGBA32U: |
||||
*((glm::u32vec4*)DataDst) = *((glm::u32vec4*)DataSrcA) + *((glm::u32vec4*)DataSrcB); |
||||
break; |
||||
|
||||
case R8I: |
||||
*((glm::i8*)DataDst) = *((glm::i8*)DataSrcA) + *((glm::i8*)DataSrcB); |
||||
break; |
||||
case RG8I: |
||||
*((glm::i8vec2*)DataDst) = *((glm::i8vec2*)DataSrcA) + *((glm::i8vec2*)DataSrcB); |
||||
break; |
||||
case RGB8I: |
||||
*((glm::i8vec3*)DataDst) = *((glm::i8vec3*)DataSrcA) + *((glm::i8vec3*)DataSrcB); |
||||
break; |
||||
case RGBA8I: |
||||
*((glm::i8vec4*)DataDst) = *((glm::i8vec4*)DataSrcA) + *((glm::i8vec4*)DataSrcB); |
||||
break; |
||||
|
||||
case R16I: |
||||
*((glm::i16*)DataDst) = *((glm::i16*)DataSrcA) + *((glm::i16*)DataSrcB); |
||||
break; |
||||
case RG16I: |
||||
*((glm::i16vec2*)DataDst) = *((glm::i16vec2*)DataSrcA) + *((glm::i16vec2*)DataSrcB); |
||||
break; |
||||
case RGB16I: |
||||
*((glm::i16vec3*)DataDst) = *((glm::i16vec3*)DataSrcA) + *((glm::i16vec3*)DataSrcB); |
||||
break; |
||||
case RGBA16I: |
||||
*((glm::i16vec4*)DataDst) = *((glm::i16vec4*)DataSrcA) + *((glm::i16vec4*)DataSrcB); |
||||
break; |
||||
|
||||
case R32I: |
||||
*((glm::i32*)DataDst) = *((glm::i32*)DataSrcA) + *((glm::i32*)DataSrcB); |
||||
break; |
||||
case RG32I: |
||||
*((glm::i32vec2*)DataDst) = *((glm::i32vec2*)DataSrcA) + *((glm::i32vec2*)DataSrcB); |
||||
break; |
||||
case RGB32I: |
||||
*((glm::i32vec3*)DataDst) = *((glm::i32vec3*)DataSrcA) + *((glm::i32vec3*)DataSrcB); |
||||
break; |
||||
case RGBA32I: |
||||
*((glm::i32vec4*)DataDst) = *((glm::i32vec4*)DataSrcA) + *((glm::i32vec4*)DataSrcB); |
||||
break; |
||||
|
||||
case R16F: |
||||
*((glm::f16*)DataDst) = *((glm::f16*)DataSrcA) + *((glm::f16*)DataSrcB); |
||||
break; |
||||
case RG16F: |
||||
*((glm::f16vec2*)DataDst) = *((glm::f16vec2*)DataSrcA) + *((glm::f16vec2*)DataSrcB); |
||||
break; |
||||
case RGB16F: |
||||
*((glm::f16vec3*)DataDst) = *((glm::f16vec3*)DataSrcA) + *((glm::f16vec3*)DataSrcB); |
||||
break; |
||||
case RGBA16F: |
||||
*((glm::f16vec4*)DataDst) = *((glm::f16vec4*)DataSrcA) + *((glm::f16vec4*)DataSrcB); |
||||
break; |
||||
|
||||
case R32F: |
||||
*((glm::f32*)DataDst) = *((glm::f32*)DataSrcA) + *((glm::f32*)DataSrcB); |
||||
break; |
||||
case RG32F: |
||||
*((glm::f32vec2*)DataDst) = *((glm::f32vec2*)DataSrcA) + *((glm::f32vec2*)DataSrcB); |
||||
break; |
||||
case RGB32F: |
||||
*((glm::f32vec3*)DataDst) = *((glm::f32vec3*)DataSrcA) + *((glm::f32vec3*)DataSrcB); |
||||
break; |
||||
case RGBA32F: |
||||
*((glm::f32vec4*)DataDst) = *((glm::f32vec4*)DataSrcA) + *((glm::f32vec4*)DataSrcB); |
||||
break; |
||||
default: |
||||
assert(0); |
||||
} |
||||
} |
||||
|
||||
void add |
||||
( |
||||
texture2D::image & Result, |
||||
texture2D::image const & ImageA, |
||||
texture2D::image const & ImageB, |
||||
) |
||||
{ |
||||
|
||||
} |
||||
|
||||
}//namespace detail |
||||
|
||||
texture2D operator+ |
||||
( |
||||
texture2D const & ImageA, |
||||
texture2D const & ImageB |
||||
) |
||||
{ |
||||
assert(ImageA.levels() == ImageB.levels()); |
||||
texture2D Result[ImageA.levels()]; |
||||
|
||||
for(texture2D::level_type Level = 0; Level < Result.levels(); ++Level) |
||||
{ |
||||
assert(ImageA.capacity() == ImageB.capacity()); |
||||
assert(ImageA.format() == ImageB.format()); |
||||
|
||||
Result[Level] = texture2D::image(ImageA[Level].dimensions(), ImageA[Level].format()); |
||||
|
||||
add(Result[Level], ImageA[Level], ImageB[Level]); |
||||
|
||||
texture2D::size_type ValueSize = Result.value_size(); |
||||
texture2D::size_type TexelCount = this->capacity() / ValueSize; |
||||
for(texture2D::size_type Texel = 0; Texel < TexelCount; ++Texel) |
||||
{ |
||||
texture2D::value_type * DataDst = Result[Level].data() + Texel * ValueSize; |
||||
texture2D::value_type const * const DataSrcA = ImageA[Level].data() + Texel * ValueSize; |
||||
texture2D::value_type const * const DataSrcB = ImageB[Level].data() + Texel * ValueSize; |
||||
|
||||
detail::op(DataDst, DataSrcA, DataSrcB, Result.format(), std::plus); |
||||
} |
||||
} |
||||
|
||||
return Result; |
||||
} |
||||
|
||||
texture2D operator- |
||||
( |
||||
texture2D const & ImageA, |
||||
texture2D const & ImageB |
||||
) |
||||
{ |
||||
assert(ImageA.levels() == ImageB.levels()); |
||||
texture2D Result[ImageA.levels()]; |
||||
|
||||
|
||||
for(texture2D::level_type Level = 0; Level < ImageA.levels(); ++Level) |
||||
{ |
||||
assert(ImageA.capacity() == ImageB.capacity()); |
||||
|
||||
|
||||
} |
||||
|
||||
return Result; |
||||
} |
||||
|
||||
}//namespace gli |
||||
@ -0,0 +1,48 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2008-12-19
|
||||
// Updated : 2005-06-13
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/shared_array.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_SHARED_ARRAY_INCLUDED |
||||
#define GLI_SHARED_ARRAY_INCLUDED |
||||
|
||||
namespace gli |
||||
{ |
||||
template <typename T> |
||||
class shared_array |
||||
{ |
||||
public: |
||||
|
||||
shared_array(); |
||||
shared_array(shared_array const & SharedArray); |
||||
shared_array(T * Pointer); |
||||
virtual ~shared_array(); |
||||
|
||||
void reset(); |
||||
void reset(T * Pointer); |
||||
|
||||
T & operator*(); |
||||
T * operator->(); |
||||
T const & operator*() const; |
||||
T const * const operator->() const; |
||||
|
||||
T * get(); |
||||
T const * const get() const; |
||||
|
||||
shared_array & operator=(shared_array const & SharedArray); |
||||
bool operator==(shared_array const & SharedArray) const; |
||||
bool operator!=(shared_array const & SharedArray) const; |
||||
|
||||
private: |
||||
int * Counter; |
||||
T * Pointer; |
||||
}; |
||||
}//namespace gli
|
||||
|
||||
#include "shared_array.inl" |
||||
|
||||
#endif //GLI_SHARED_ARRAY_INCLUDED
|
||||
@ -0,0 +1,151 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2008-12-19 |
||||
// Updated : 2005-06-13 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/shared_array.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace gli |
||||
{ |
||||
template <typename T> |
||||
shared_array<T>::shared_array() : |
||||
Counter(0), |
||||
Pointer(0) |
||||
{} |
||||
|
||||
template <typename T> |
||||
shared_array<T>::shared_array |
||||
( |
||||
shared_array<T> const & SharedArray |
||||
) |
||||
{ |
||||
this->Counter = SharedArray.Counter; |
||||
this->Pointer = SharedArray.Pointer; |
||||
(*this->Counter)++; |
||||
} |
||||
|
||||
template <typename T> |
||||
shared_array<T>::shared_array |
||||
( |
||||
T * Pointer |
||||
) |
||||
{ |
||||
this->reset(Pointer); |
||||
} |
||||
|
||||
template <typename T> |
||||
shared_array<T>::~shared_array() |
||||
{ |
||||
this->reset(); |
||||
} |
||||
|
||||
template <typename T> |
||||
void shared_array<T>::reset() |
||||
{ |
||||
if(this->Pointer) |
||||
{ |
||||
(*this->Counter)--; |
||||
if(*this->Counter <= 0) |
||||
{ |
||||
delete this->Counter; |
||||
this->Counter = 0; |
||||
delete[] this->Pointer; |
||||
this->Pointer = 0; |
||||
} |
||||
} |
||||
} |
||||
|
||||
template <typename T> |
||||
void shared_array<T>::reset(T * Pointer) |
||||
{ |
||||
this->Counter = new int; |
||||
this->Pointer = Pointer; |
||||
*this->Counter = 1; |
||||
} |
||||
|
||||
template <typename T> |
||||
shared_array<T>& shared_array<T>::operator= |
||||
( |
||||
shared_array<T> const & SharedArray |
||||
) |
||||
{ |
||||
this->reset(); |
||||
|
||||
this->Counter = SharedArray.Counter; |
||||
this->Pointer = SharedArray.Pointer; |
||||
(*this->Counter)++; |
||||
|
||||
return *this; |
||||
} |
||||
|
||||
//template <typename T> |
||||
//shared_array<T> & shared_array<T>::operator=(T * Pointer) |
||||
//{ |
||||
// if(this->Pointer) |
||||
// { |
||||
// (*this->Counter)--; |
||||
// if(*this->Counter <= 0) |
||||
// { |
||||
// delete this->Counter; |
||||
// delete[] this->Pointer; |
||||
// } |
||||
// } |
||||
|
||||
// this->Counter = new int; |
||||
// this->Pointer = this->Pointer; |
||||
// (*this->Counter) = 1; |
||||
|
||||
// return *this; |
||||
//} |
||||
|
||||
template <typename T> |
||||
bool shared_array<T>::operator==(shared_array<T> const & SharedArray) const |
||||
{ |
||||
return this->Pointer == SharedArray.Pointer; |
||||
} |
||||
|
||||
template <typename T> |
||||
bool shared_array<T>::operator!=(shared_array<T> const & SharedArray) const |
||||
{ |
||||
return this->Pointer != SharedArray.Pointer; |
||||
} |
||||
|
||||
template <typename T> |
||||
T & shared_array<T>::operator*() |
||||
{ |
||||
return *this->Pointer; |
||||
} |
||||
|
||||
template <typename T> |
||||
T * shared_array<T>::operator->() |
||||
{ |
||||
return this->Pointer; |
||||
} |
||||
|
||||
template <typename T> |
||||
T const & shared_array<T>::operator*() const |
||||
{ |
||||
return * this->Pointer; |
||||
} |
||||
|
||||
template <typename T> |
||||
T const * const shared_array<T>::operator->() const |
||||
{ |
||||
return this->Pointer; |
||||
} |
||||
|
||||
template <typename T> |
||||
T * shared_array<T>::get() |
||||
{ |
||||
return this->Pointer; |
||||
} |
||||
|
||||
template <typename T> |
||||
T const * const shared_array<T>::get() const |
||||
{ |
||||
return this->Pointer; |
||||
} |
||||
|
||||
}//namespace gli |
||||
@ -0,0 +1,41 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2008-12-19
|
||||
// Updated : 2005-06-13
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/fetch.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_SHARED_PTR_INCLUDED |
||||
#define GLI_SHARED_PTR_INCLUDED |
||||
|
||||
namespace gli |
||||
{ |
||||
template <typename T> |
||||
class shared_ptr |
||||
{ |
||||
public: |
||||
shared_ptr(); |
||||
shared_ptr(shared_ptr const & SmartPtr); |
||||
shared_ptr(T* pPointer); |
||||
~shared_ptr(); |
||||
|
||||
T& operator*(); |
||||
T* operator->(); |
||||
const T& operator*() const; |
||||
const T* operator->() const; |
||||
shared_ptr& operator=(shared_ptr const & SmartPtr); |
||||
shared_ptr& operator=(T* pPointer); |
||||
bool operator==(shared_ptr const & SmartPtr) const; |
||||
bool operator!=(shared_ptr const & SmartPtr) const; |
||||
|
||||
private: |
||||
int* m_pReference; |
||||
T* m_pPointer; |
||||
}; |
||||
}//namespace gli
|
||||
|
||||
#include "shared_ptr.inl" |
||||
|
||||
#endif //GLI_SHARED_PTR_INCLUDED
|
||||
@ -0,0 +1,125 @@ |
||||
/////////////////////////////////////////////////////////////////////////// |
||||
// Interstate Gangs : smart_ptr.inl |
||||
/////////////////////////////////////////////////////////////////////////// |
||||
// This file is under GPL licence |
||||
/////////////////////////////////////////////////////////////////////////// |
||||
// CHANGELOG |
||||
// Groove - 13/06/2005 : |
||||
// - Create file |
||||
/////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace gli |
||||
{ |
||||
template <typename T> |
||||
util::CSmartPtr<T>::CSmartPtr() |
||||
{ |
||||
m_pPointer = 0; |
||||
} |
||||
|
||||
template <typename T> |
||||
util::CSmartPtr<T>::CSmartPtr(const util::CSmartPtr<T> & SmartPtr) |
||||
{ |
||||
m_pReference = SmartPtr.m_pReference; |
||||
m_pPointer = SmartPtr.m_pPointer; |
||||
(*m_pReference)++; |
||||
} |
||||
|
||||
template <typename T> |
||||
util::CSmartPtr<T>::CSmartPtr(T* pPointer) |
||||
{ |
||||
m_pReference = new int; |
||||
m_pPointer = pPointer; |
||||
(*m_pReference) = 1; |
||||
} |
||||
|
||||
template <typename T> |
||||
util::CSmartPtr<T>::~CSmartPtr() |
||||
{ |
||||
if(!m_pPointer) |
||||
return; |
||||
|
||||
(*m_pReference)--; |
||||
if(*m_pReference <= 0) |
||||
{ |
||||
delete m_pReference; |
||||
delete m_pPointer; |
||||
} |
||||
} |
||||
|
||||
template <typename T> |
||||
util::CSmartPtr<T>& util::CSmartPtr<T>::operator=(const util::CSmartPtr<T> & SmartPtr) |
||||
{ |
||||
if(m_pPointer) |
||||
{ |
||||
(*m_pReference)--; |
||||
if(*m_pReference <= 0) |
||||
{ |
||||
delete m_pReference; |
||||
delete m_pPointer; |
||||
} |
||||
} |
||||
|
||||
m_pReference = SmartPtr.m_pReference; |
||||
m_pPointer = SmartPtr.m_pPointer; |
||||
(*m_pReference)++; |
||||
|
||||
return *this; |
||||
} |
||||
|
||||
template <typename T> |
||||
util::CSmartPtr<T>& util::CSmartPtr<T>::operator=(T* pPointer) |
||||
{ |
||||
if(m_pPointer) |
||||
{ |
||||
(*m_pReference)--; |
||||
if(*m_pReference <= 0) |
||||
{ |
||||
delete m_pReference; |
||||
delete m_pPointer; |
||||
} |
||||
} |
||||
|
||||
m_pReference = new int; |
||||
m_pPointer = pPointer; |
||||
(*m_pReference) = 1; |
||||
|
||||
return *this; |
||||
} |
||||
|
||||
template <typename T> |
||||
bool util::CSmartPtr<T>::operator==(const util::CSmartPtr<T> & SmartPtr) const |
||||
{ |
||||
return m_pPointer == SmartPtr.m_pPointer; |
||||
} |
||||
|
||||
template <typename T> |
||||
bool util::CSmartPtr<T>::operator!=(const util::CSmartPtr<T> & SmartPtr) const |
||||
{ |
||||
return m_pPointer != SmartPtr.m_pPointer; |
||||
} |
||||
|
||||
template <typename T> |
||||
T& util::CSmartPtr<T>::operator*() |
||||
{ |
||||
return *m_pPointer; |
||||
} |
||||
|
||||
template <typename T> |
||||
T* util::CSmartPtr<T>::operator->() |
||||
{ |
||||
return m_pPointer; |
||||
} |
||||
|
||||
template <typename T> |
||||
const T& util::CSmartPtr<T>::operator*() const |
||||
{ |
||||
return *m_pPointer; |
||||
} |
||||
|
||||
template <typename T> |
||||
const T* util::CSmartPtr<T>::operator->() const |
||||
{ |
||||
return m_pPointer; |
||||
} |
||||
|
||||
}//namespace gli |
||||
@ -0,0 +1,31 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2010-09-08
|
||||
// Updated : 2010-09-08
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/core/size.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_CORE_SIZE_INCLUDED |
||||
#define GLI_CORE_SIZE_INCLUDED |
||||
|
||||
#include "texture2d.hpp" |
||||
|
||||
namespace gli |
||||
{ |
||||
//template <size_type sizeType>
|
||||
image2D::size_type size( |
||||
image2D const & Image,
|
||||
image2D::size_type const & SizeType); |
||||
|
||||
//template <size_type sizeType>
|
||||
texture2D::size_type size( |
||||
texture2D const & Texture,
|
||||
texture2D::size_type const & SizeType); |
||||
|
||||
}//namespace gli
|
||||
|
||||
#include "size.inl" |
||||
|
||||
#endif//GLI_CORE_SIZE_INCLUDED
|
||||
@ -0,0 +1,47 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2008-12-19 |
||||
// Updated : 2010-09-08 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/core/size.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace gli |
||||
{ |
||||
inline image2D::size_type size |
||||
( |
||||
image2D const & Image, |
||||
image2D::size_type const & SizeType |
||||
) |
||||
{ |
||||
switch(SizeType) |
||||
{ |
||||
case LINEAR_SIZE: |
||||
return detail::sizeLinear(Image); |
||||
case BLOCK_SIZE: |
||||
return detail::sizeBlock(Image.format()); |
||||
case BIT_PER_PIXEL: |
||||
return detail::sizeBitPerPixel(Image.format()); |
||||
case COMPONENT: |
||||
return detail::sizeComponent(Image.format()); |
||||
default: |
||||
assert(0); |
||||
return 0; |
||||
}; |
||||
} |
||||
|
||||
inline texture2D::size_type size |
||||
( |
||||
texture2D const & Texture, |
||||
texture2D::size_type const & SizeType |
||||
) |
||||
{ |
||||
texture2D::size_type Size = 0; |
||||
for(texture2D::level_type Level = 0; Level < Texture.levels(); ++Level) |
||||
Size += size(Texture[Level], SizeType); |
||||
|
||||
return Size; |
||||
} |
||||
|
||||
}//namespace |
||||
@ -0,0 +1,106 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2010-01-09
|
||||
// Updated : 2010-01-09
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/core/texture2d.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_CORE_TEXTURE2D_INCLUDED |
||||
#define GLI_CORE_TEXTURE2D_INCLUDED |
||||
|
||||
#include "image2d.hpp" |
||||
|
||||
namespace gli |
||||
{ |
||||
//template <template <typename> class mem>
|
||||
class texture2D |
||||
{ |
||||
public: |
||||
typedef image2D::dimensions_type dimensions_type; |
||||
typedef image2D::texcoord_type texcoord_type; |
||||
typedef image2D::size_type size_type; |
||||
typedef image2D::value_type value_type; |
||||
typedef image2D::format_type format_type; |
||||
typedef image2D::data_type data_type; |
||||
typedef std::size_t level_type; |
||||
|
||||
public: |
||||
texture2D(); |
||||
|
||||
explicit texture2D(level_type const & Levels); |
||||
//texture2D(image const & Mipmap, bool GenerateMipmaps = false);
|
||||
|
||||
~texture2D(); |
||||
|
||||
image2D & operator[] ( |
||||
level_type const & Level); |
||||
image2D const & operator[] ( |
||||
level_type const & Level) const; |
||||
|
||||
bool empty() const; |
||||
format_type format() const; |
||||
level_type levels() const; |
||||
void resize(level_type const & Levels); |
||||
|
||||
template <typename genType> |
||||
void swizzle(glm::comp X, glm::comp Y, glm::comp Z, glm::comp W); |
||||
|
||||
private: |
||||
std::vector<image2D> Images; |
||||
}; |
||||
|
||||
//namespace wip
|
||||
//{
|
||||
// // plain
|
||||
// template <typename genType>
|
||||
// class plain
|
||||
// {
|
||||
// public:
|
||||
//
|
||||
// private:
|
||||
// boost::shared_array<genType> Data;
|
||||
// };
|
||||
//
|
||||
// // texture2D
|
||||
// template
|
||||
// <
|
||||
// typename genType,
|
||||
// template <typename> class surface = plain
|
||||
// >
|
||||
// class texture2D
|
||||
// {
|
||||
// public:
|
||||
// typedef genType value_type;
|
||||
//
|
||||
// private:
|
||||
// class image_impl
|
||||
// {
|
||||
// public:
|
||||
// template <typename coordType>
|
||||
// value_type const & operator() (coordType const & Coord) const;
|
||||
//
|
||||
// private:
|
||||
// surface<value_type> Surface;
|
||||
// };
|
||||
//
|
||||
// public:
|
||||
// typedef image_impl image;
|
||||
// typedef std::vector<image> mipmaps;
|
||||
// typedef typename mipmaps::size_type level_type;
|
||||
//
|
||||
// level_type levels() const;
|
||||
// image & operator[] (level_type Level);
|
||||
// image const & operator[] (level_type Level) const;
|
||||
//
|
||||
// private:
|
||||
// mipmaps Mipmaps;
|
||||
// };
|
||||
//
|
||||
//}//namespace wip
|
||||
}//namespace gli
|
||||
|
||||
#include "texture2d.inl" |
||||
|
||||
#endif//GLI_CORE_TEXTURE2D_INCLUDED
|
||||
@ -0,0 +1,304 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2010-09-27 |
||||
// Updated : 2010-09-27 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/core/texture2D.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace gli |
||||
{ |
||||
namespace detail |
||||
{ |
||||
inline texture2D::size_type sizeLinear |
||||
( |
||||
texture2D const & Texture |
||||
) |
||||
{ |
||||
texture2D::size_type Result = 0; |
||||
for(texture2D::level_type Level = 0; Level < Texture.levels(); ++Level) |
||||
Result += sizeLinear(Texture[Level]); |
||||
return Result; |
||||
} |
||||
}//namespace detail |
||||
|
||||
inline texture2D::texture2D() |
||||
{} |
||||
|
||||
inline texture2D::texture2D |
||||
( |
||||
level_type const & Levels |
||||
) |
||||
{ |
||||
this->Images.resize(Levels); |
||||
} |
||||
|
||||
//inline texture2D::texture2D |
||||
//( |
||||
// image const & Mipmap, |
||||
// bool GenerateMipmaps // ToDo |
||||
//) |
||||
//{ |
||||
// //std::size_t Levels = !GenerateMipmaps ? 1 : std::size_t(glm::log2(float(glm::max(Mipmap.width(), Mipmap.height())))); |
||||
// texture2D::level_type Levels = !GenerateMipmaps ? 1 : std::size_t(glm::log2(float(glm::compMax(Mipmap.dimensions())))); |
||||
// this->Mipmaps.resize(Levels); |
||||
// this->Mipmaps[0] = Mipmap; |
||||
|
||||
// if(GenerateMipmaps) |
||||
// this->generateMipmaps(0); |
||||
//} |
||||
|
||||
inline texture2D::~texture2D() |
||||
{} |
||||
|
||||
inline image2D & texture2D::operator[] (level_type const & Level) |
||||
{ |
||||
return this->Images[Level]; |
||||
} |
||||
|
||||
inline image2D const & texture2D::operator[] (level_type const & Level) const |
||||
{ |
||||
return this->Images[Level]; |
||||
} |
||||
|
||||
inline bool texture2D::empty() const |
||||
{ |
||||
return this->Images.size() == 0; |
||||
} |
||||
|
||||
inline texture2D::format_type texture2D::format() const |
||||
{ |
||||
return this->Images.empty() ? FORMAT_NULL : this->Images[0].format(); |
||||
} |
||||
|
||||
inline texture2D::level_type texture2D::levels() const |
||||
{ |
||||
return this->Images.size(); |
||||
} |
||||
|
||||
inline void texture2D::resize |
||||
( |
||||
texture2D::level_type const & Levels |
||||
) |
||||
{ |
||||
this->Images.resize(Levels); |
||||
} |
||||
|
||||
template <typename genType> |
||||
inline void texture2D::swizzle(glm::comp X, glm::comp Y, glm::comp Z, glm::comp W) |
||||
{ |
||||
for(texture2D::level_type Level = 0; Level < this->levels(); ++Level) |
||||
{ |
||||
genType * Data = reinterpret_cast<genType*>(this->Images[Level].data()); |
||||
texture2D::size_type Components = this->Images[Level].components(); |
||||
//gli::detail::getComponents(this->Images[Level].format()); |
||||
texture2D::size_type Size = (glm::compMul(this->Images[Level].dimensions()) * Components) / sizeof(genType); |
||||
|
||||
for(texture2D::size_type i = 0; i < Size; ++i) |
||||
{ |
||||
genType Copy = Data[i]; |
||||
if(Components > 0) |
||||
Data[i][0] = Copy[X]; |
||||
if(Components > 1) |
||||
Data[i][1] = Copy[Y]; |
||||
if(Components > 2) |
||||
Data[i][2] = Copy[Z]; |
||||
if(Components > 3) |
||||
Data[i][3] = Copy[W]; |
||||
} |
||||
} |
||||
} |
||||
|
||||
/* |
||||
template <typename T> |
||||
inline T texture<T>::texture(float x, float y) const |
||||
{ |
||||
size_type x_below = size_type(std::floor(x * (_width - 1))); |
||||
size_type x_above = size_type(std::ceil(x * (_width - 1))); |
||||
size_type y_below = size_type(std::floor(y * (_height - 1))); |
||||
size_type y_above = size_type(std::ceil(y * (_height - 1))); |
||||
|
||||
float x_step = 1.0f / float(_width); |
||||
float y_step = 1.0f / float(_height); |
||||
|
||||
float x_below_normalized = float(x_below) / float(_width - 1); |
||||
float x_above_normalized = float(x_above) / float(_width - 1); |
||||
float y_below_normalized = float(y_below) / float(_height - 1); |
||||
float y_above_normalized = float(y_above) / float(_height - 1); |
||||
|
||||
T value1 = _data[x_below + y_below * _width]; |
||||
T value2 = _data[x_above + y_below * _width]; |
||||
T value3 = _data[x_above + y_above * _width]; |
||||
T value4 = _data[x_below + y_above * _width]; |
||||
|
||||
T valueA = glm::mix(value1, value2, x - x_below_normalized); |
||||
T valueB = glm::mix(value4, value3, x - x_below_normalized); |
||||
T valueC = glm::mix(valueA, valueB, y - y_below_normalized); |
||||
return valueC; |
||||
} |
||||
*/ |
||||
/* |
||||
template <typename T> |
||||
inline T texture(const texture2D<T>& Image2D, const glm::vec2& TexCoord) |
||||
{ |
||||
texture2D<T>::size_type s_below = texture2D<T>::size_type(std::floor(TexCoord.s * (Image2D.width() - 1))); |
||||
texture2D<T>::size_type s_above = texture2D<T>::size_type(std::ceil(TexCoord.s * (Image2D.width() - 1))); |
||||
texture2D<T>::size_type t_below = texture2D<T>::size_type(std::floor(TexCoord.t * (Image2D.height() - 1))); |
||||
texture2D<T>::size_type t_above = texture2D<T>::size_type(std::ceil(TexCoord.t * (Image2D.height() - 1))); |
||||
|
||||
glm::vec2::value_type s_step = 1.0f / glm::vec2::value_type(Image2D.width()); |
||||
glm::vec2::value_type t_step = 1.0f / glm::vec2::value_type(Image2D.height()); |
||||
|
||||
glm::vec2::value_type s_below_normalized = glm::vec2::value_type(s_below) / glm::vec2::value_type(Image2D.width() - 1); |
||||
glm::vec2::value_type s_above_normalized = glm::vec2::value_type(s_above) / glm::vec2::value_type(Image2D.width() - 1); |
||||
glm::vec2::value_type t_below_normalized = glm::vec2::value_type(t_below) / glm::vec2::value_type(Image2D.height() - 1); |
||||
glm::vec2::value_type t_above_normalized = glm::vec2::value_type(t_above) / glm::vec2::value_type(Image2D.height() - 1); |
||||
|
||||
T value1 = Image2D[s_below + t_below * Image2D.width()]; |
||||
T value2 = Image2D[s_above + t_below * Image2D.width()]; |
||||
T value3 = Image2D[s_above + t_above * Image2D.width()]; |
||||
T value4 = Image2D[s_below + t_above * Image2D.width()]; |
||||
|
||||
T valueA = glm::mix(value1, value2, TexCoord.s - s_below_normalized); |
||||
T valueB = glm::mix(value4, value3, TexCoord.s - s_below_normalized); |
||||
T valueC = glm::mix(valueA, valueB, TexCoord.t - t_below_normalized); |
||||
return valueC; |
||||
} |
||||
|
||||
template <typename T> |
||||
inline T textureNearest(const texture2D<T>& Image2D, const glm::vec2& TexCoord) |
||||
{ |
||||
texture2D<T>::size_type s = texture2D<T>::size_type(glm::roundGTX(TexCoord.s * (Image2D.width() - 1))); |
||||
texture2D<T>::size_type t = texture2D<T>::size_type(std::roundGTX(TexCoord.t * (Image2D.height() - 1))); |
||||
|
||||
return Image2D[s + t * Image2D.width()]; |
||||
} |
||||
*/ |
||||
|
||||
namespace wip |
||||
{ |
||||
//////////////// |
||||
// image |
||||
/* |
||||
// |
||||
template |
||||
< |
||||
typename coordType |
||||
> |
||||
template |
||||
< |
||||
typename genType, |
||||
template <typename> class surface |
||||
> |
||||
typename texture2D<genType, surface>::value_type & |
||||
texture2D<genType, surface>::image_impl<coordType>::operator() |
||||
( |
||||
coordType const & Coord |
||||
) |
||||
{ |
||||
|
||||
} |
||||
*/ |
||||
/* |
||||
// |
||||
template |
||||
< |
||||
typename coordType |
||||
> |
||||
template |
||||
< |
||||
typename genType, |
||||
template <typename> class surface |
||||
> |
||||
typename texture2D<genType, surface>::value_type const & |
||||
texture2D<genType, surface>::image_impl::operator() |
||||
( |
||||
coordType const & Coord |
||||
) const |
||||
{ |
||||
return value_type(0); |
||||
} |
||||
*/ |
||||
/* |
||||
// |
||||
template |
||||
< |
||||
typename coordType |
||||
> |
||||
template |
||||
< |
||||
typename genType, |
||||
template <typename> class surface |
||||
> |
||||
void texture2D<genType, surface>::image_impl::operator() |
||||
( |
||||
coordType const & Coord |
||||
) const |
||||
{ |
||||
|
||||
} |
||||
*/ |
||||
//// |
||||
//template |
||||
//< |
||||
// typename genType, |
||||
// template <typename> class surface |
||||
//> |
||||
//template |
||||
//< |
||||
// typename coordType |
||||
//> |
||||
//typename texture2D<genType, surface>::value_type const & |
||||
//texture2D<genType, surface>::image_impl::operator() |
||||
//( |
||||
// coordType const & Coord |
||||
//) const |
||||
//{ |
||||
// return value_type(0); |
||||
//} |
||||
|
||||
////////////////// |
||||
//// texture2D |
||||
|
||||
//// |
||||
//template |
||||
//< |
||||
// typename genType, |
||||
// template <typename> class surface |
||||
//> |
||||
//typename texture2D<genType, surface>::level_type texture2D<genType, surface>::levels() const |
||||
//{ |
||||
// return this->Mipmaps.size(); |
||||
//} |
||||
|
||||
//// |
||||
//template |
||||
//< |
||||
// typename genType, |
||||
// template <typename> class surface |
||||
//> |
||||
//typename texture2D<genType, surface>::image & texture2D<genType, surface>::operator[] |
||||
//( |
||||
// typename texture2D<genType, surface>::level_type Level |
||||
//) |
||||
//{ |
||||
// return this->Mipmaps[Level]; |
||||
//} |
||||
|
||||
//// |
||||
//template |
||||
//< |
||||
// typename genType, |
||||
// template <typename> class surface |
||||
//> |
||||
//typename texture2D<genType, surface>::image const & texture2D<genType, surface>::operator[] |
||||
//( |
||||
// typename texture2D<genType, surface>::level_type Level |
||||
//) const |
||||
//{ |
||||
// return this->Mipmaps[Level]; |
||||
//} |
||||
|
||||
}//namespace wip |
||||
}//namespace gli |
||||
@ -0,0 +1,59 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2011-04-06
|
||||
// Updated : 2011-04-06
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/core/texture2d_array.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_CORE_TEXTURE2D_ARRAY_INCLUDED |
||||
#define GLI_CORE_TEXTURE2D_ARRAY_INCLUDED |
||||
|
||||
#include "texture2d.hpp" |
||||
|
||||
namespace gli |
||||
{ |
||||
class texture2DArray |
||||
{ |
||||
public: |
||||
typedef texture2D::dimensions_type dimensions_type; |
||||
typedef texture2D::texcoord_type texcoord_type; |
||||
typedef texture2D::size_type size_type; |
||||
typedef texture2D::value_type value_type; |
||||
typedef texture2D::format_type format_type; |
||||
typedef texture2D::data_type data_type; |
||||
typedef texture2D::level_type level_type; |
||||
typedef std::vector<texture2D>::size_type layer_type; |
||||
|
||||
public: |
||||
texture2DArray(); |
||||
|
||||
explicit texture2DArray( |
||||
layer_type const & Layers,
|
||||
level_type const & Levels); |
||||
|
||||
~texture2DArray(); |
||||
|
||||
texture2D & operator[] ( |
||||
layer_type const & Layer); |
||||
texture2D const & operator[] ( |
||||
layer_type const & Layer) const; |
||||
|
||||
bool empty() const; |
||||
format_type format() const; |
||||
layer_type layers() const; |
||||
level_type levels() const; |
||||
void resize( |
||||
layer_type const & Layers,
|
||||
level_type const & Levels); |
||||
|
||||
private: |
||||
std::vector<texture2D> Arrays; |
||||
}; |
||||
|
||||
}//namespace gli
|
||||
|
||||
#include "texture2d_array.inl" |
||||
|
||||
#endif//GLI_CORE_TEXTURE2D_ARRAY_INCLUDED
|
||||
@ -0,0 +1,78 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2011-04-06 |
||||
// Updated : 2011-04-06 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/core/texture_cube.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace gli |
||||
{ |
||||
inline texture2DArray::texture2DArray() |
||||
{} |
||||
|
||||
inline texture2DArray::texture2DArray |
||||
( |
||||
texture2DArray::layer_type const & Layers, |
||||
texture2DArray::level_type const & Levels |
||||
) |
||||
{ |
||||
this->Arrays.resize(Layers); |
||||
for(texture2DArray::size_type i = 0; i < this->Arrays.size(); ++i) |
||||
this->Arrays[i].resize(Levels); |
||||
} |
||||
|
||||
inline texture2DArray::~texture2DArray() |
||||
{} |
||||
|
||||
inline texture2D & texture2DArray::operator[] |
||||
( |
||||
layer_type const & Layer |
||||
) |
||||
{ |
||||
return this->Arrays[Layer]; |
||||
} |
||||
|
||||
inline texture2D const & texture2DArray::operator[] |
||||
( |
||||
layer_type const & Layer |
||||
) const |
||||
{ |
||||
return this->Arrays[Layer]; |
||||
} |
||||
|
||||
inline bool texture2DArray::empty() const |
||||
{ |
||||
return this->Arrays.empty(); |
||||
} |
||||
|
||||
inline texture2DArray::format_type texture2DArray::format() const |
||||
{ |
||||
return this->Arrays.empty() ? FORMAT_NULL : this->Arrays[0].format(); |
||||
} |
||||
|
||||
inline texture2DArray::layer_type texture2DArray::layers() const |
||||
{ |
||||
return this->Arrays.size(); |
||||
} |
||||
|
||||
inline texture2DArray::level_type texture2DArray::levels() const |
||||
{ |
||||
if(this->empty()) |
||||
return 0; |
||||
return this->Arrays[0].levels(); |
||||
} |
||||
|
||||
inline void texture2DArray::resize |
||||
( |
||||
texture2DArray::layer_type const & Layers, |
||||
texture2DArray::level_type const & Levels |
||||
) |
||||
{ |
||||
this->Arrays.resize(Layers); |
||||
for(texture2DArray::layer_type i = 0; i < this->Arrays.size(); ++i) |
||||
this->Arrays[i].resize(Levels); |
||||
} |
||||
|
||||
}//namespace gli |
||||
@ -0,0 +1,65 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2011-04-06
|
||||
// Updated : 2011-04-06
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/core/texture_cube.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_CORE_TEXTURE_CUBE_INCLUDED |
||||
#define GLI_CORE_TEXTURE_CUBE_INCLUDED |
||||
|
||||
#include "texture2d.hpp" |
||||
|
||||
namespace gli |
||||
{ |
||||
enum face |
||||
{ |
||||
POSITIVE_X, |
||||
NEGATIVE_X, |
||||
POSITIVE_Y, |
||||
NEGATIVE_Y, |
||||
POSITIVE_Z, |
||||
NEGATIVE_Z, |
||||
FACE_MAX |
||||
}; |
||||
|
||||
class textureCube |
||||
{ |
||||
public: |
||||
typedef texture2D::dimensions_type dimensions_type; |
||||
typedef texture2D::texcoord_type texcoord_type; |
||||
typedef texture2D::size_type size_type; |
||||
typedef texture2D::value_type value_type; |
||||
typedef texture2D::format_type format_type; |
||||
typedef texture2D::data_type data_type; |
||||
typedef texture2D::level_type level_type; |
||||
typedef face face_type; |
||||
|
||||
public: |
||||
textureCube(); |
||||
|
||||
explicit textureCube(level_type const & Levels); |
||||
|
||||
~textureCube(); |
||||
|
||||
texture2D & operator[] ( |
||||
face_type const & Face); |
||||
texture2D const & operator[] ( |
||||
face_type const & Face) const; |
||||
|
||||
bool empty() const; |
||||
format_type format() const; |
||||
level_type levels() const; |
||||
void resize(level_type const & Levels); |
||||
|
||||
private: |
||||
std::vector<texture2D> Faces; |
||||
}; |
||||
|
||||
}//namespace gli
|
||||
|
||||
#include "texture_cube.inl" |
||||
|
||||
#endif//GLI_CORE_TEXTURE_CUBE_INCLUDED
|
||||
@ -0,0 +1,70 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2011-04-06 |
||||
// Updated : 2011-04-06 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/core/texture_cube.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace gli |
||||
{ |
||||
inline textureCube::textureCube() |
||||
{} |
||||
|
||||
inline textureCube::textureCube |
||||
( |
||||
level_type const & Levels |
||||
) |
||||
{ |
||||
this->Faces.resize(FACE_MAX); |
||||
for(textureCube::size_type i = 0; i < FACE_MAX; ++i) |
||||
this->Faces[i].resize(Levels); |
||||
} |
||||
|
||||
inline textureCube::~textureCube() |
||||
{} |
||||
|
||||
inline texture2D & textureCube::operator[] |
||||
( |
||||
face_type const & Face |
||||
) |
||||
{ |
||||
return this->Faces[Face]; |
||||
} |
||||
|
||||
inline texture2D const & textureCube::operator[] |
||||
( |
||||
face_type const & Face |
||||
) const |
||||
{ |
||||
return this->Faces[Face]; |
||||
} |
||||
|
||||
inline bool textureCube::empty() const |
||||
{ |
||||
return this->Faces.size() == 0; |
||||
} |
||||
|
||||
inline textureCube::format_type textureCube::format() const |
||||
{ |
||||
return this->Faces.empty() ? FORMAT_NULL : this->Faces[0].format(); |
||||
} |
||||
|
||||
inline textureCube::level_type textureCube::levels() const |
||||
{ |
||||
if(this->empty()) |
||||
return 0; |
||||
return this->Faces[POSITIVE_X].levels(); |
||||
} |
||||
|
||||
inline void textureCube::resize |
||||
( |
||||
level_type const & Levels |
||||
) |
||||
{ |
||||
for(textureCube::size_type i = 0; i < FACE_MAX; ++i) |
||||
this->Faces[i].resize(Levels); |
||||
} |
||||
|
||||
}//namespace gli |
||||
@ -0,0 +1,59 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2011-04-06
|
||||
// Updated : 2011-04-06
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/core/texture_cube_array.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_CORE_TEXTURE_CUBE_ARRAY_INCLUDED |
||||
#define GLI_CORE_TEXTURE_CUBE_ARRAY_INCLUDED |
||||
|
||||
#include "texture_cube.hpp" |
||||
|
||||
namespace gli |
||||
{ |
||||
class textureCubeArray |
||||
{ |
||||
public: |
||||
typedef textureCube::dimensions_type dimensions_type; |
||||
typedef textureCube::texcoord_type texcoord_type; |
||||
typedef textureCube::size_type size_type; |
||||
typedef textureCube::value_type value_type; |
||||
typedef textureCube::format_type format_type; |
||||
typedef std::vector<textureCube> data_type; |
||||
typedef textureCube::level_type level_type; |
||||
typedef data_type::size_type layer_type; |
||||
|
||||
public: |
||||
textureCubeArray(); |
||||
|
||||
explicit textureCubeArray( |
||||
layer_type const & Layers,
|
||||
level_type const & Levels); |
||||
|
||||
~textureCubeArray(); |
||||
|
||||
textureCube & operator[] ( |
||||
layer_type const & Layer); |
||||
textureCube const & operator[] ( |
||||
layer_type const & Layer) const; |
||||
|
||||
bool empty() const; |
||||
format_type format() const; |
||||
layer_type layers() const; |
||||
level_type levels() const; |
||||
void resize( |
||||
layer_type const & Layers,
|
||||
level_type const & Levels); |
||||
|
||||
private: |
||||
data_type Arrays; |
||||
}; |
||||
|
||||
}//namespace gli
|
||||
|
||||
#include "texture_cube_array.inl" |
||||
|
||||
#endif//GLI_CORE_TEXTURE_CUBE_ARRAY_INCLUDED
|
||||
@ -0,0 +1,72 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2011-04-06 |
||||
// Updated : 2011-04-06 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/core/texture_cube_array.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace gli |
||||
{ |
||||
inline textureCubeArray::textureCubeArray() |
||||
{} |
||||
|
||||
inline textureCubeArray::textureCubeArray |
||||
( |
||||
layer_type const & Layers, |
||||
level_type const & Levels |
||||
) |
||||
{ |
||||
this->Arrays.resize(Layers); |
||||
for(textureCubeArray::size_type i = 0; i < this->Arrays.size(); ++i) |
||||
this->Arrays[i].resize(Levels); |
||||
} |
||||
|
||||
inline textureCubeArray::~textureCubeArray() |
||||
{} |
||||
|
||||
inline textureCube & textureCubeArray::operator[] |
||||
( |
||||
layer_type const & Layer |
||||
) |
||||
{ |
||||
return this->Arrays[Layer]; |
||||
} |
||||
|
||||
inline textureCube const & textureCubeArray::operator[] |
||||
( |
||||
layer_type const & Layer |
||||
) const |
||||
{ |
||||
return this->Arrays[Layer]; |
||||
} |
||||
|
||||
inline bool textureCubeArray::empty() const |
||||
{ |
||||
return this->Arrays.empty(); |
||||
} |
||||
|
||||
inline textureCubeArray::format_type textureCubeArray::format() const |
||||
{ |
||||
return this->Arrays.empty() ? FORMAT_NULL : this->Arrays[0].format(); |
||||
} |
||||
|
||||
inline textureCubeArray::level_type textureCubeArray::levels() const |
||||
{ |
||||
if(this->empty()) |
||||
return 0; |
||||
return this->Arrays[0].levels(); |
||||
} |
||||
|
||||
inline void textureCubeArray::resize |
||||
( |
||||
layer_type const & Layers, |
||||
level_type const & Levels |
||||
) |
||||
{ |
||||
for(textureCubeArray::size_type i = 0; i < this->Arrays.size(); ++i) |
||||
this->Arrays[i].resize(Levels); |
||||
} |
||||
|
||||
}//namespace gli |
||||
@ -0,0 +1,31 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2008-12-19
|
||||
// Updated : 2010-09-29
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/gli.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/*! \mainpage OpenGL Image
|
||||
* |
||||
*/ |
||||
|
||||
#ifndef GLI_GLI_INCLUDED |
||||
#define GLI_GLI_INCLUDED |
||||
|
||||
#define GLI_VERSION 31 |
||||
#define GLI_VERSION_MAJOR 0 |
||||
#define GLI_VERSION_MINOR 3 |
||||
#define GLI_VERSION_PATCH 1 |
||||
#define GLI_VERSION_REVISION 0 |
||||
|
||||
#include "./core/texture2d.hpp" |
||||
#include "./core/texture2d_array.hpp" |
||||
#include "./core/texture_cube.hpp" |
||||
#include "./core/texture_cube_array.hpp" |
||||
#include "./core/size.hpp" |
||||
#include "./core/operation.hpp" |
||||
#include "./core/generate_mipmaps.hpp" |
||||
|
||||
#endif//GLI_GLI_INCLUDED
|
||||
@ -0,0 +1,27 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2008-12-19
|
||||
// Updated : 2010-01-09
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/gtx/compression.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_GTX_COMPRESSION_INCLUDED |
||||
#define GLI_GTX_COMPRESSION_INCLUDED |
||||
|
||||
namespace gli{ |
||||
namespace gtx{ |
||||
namespace compression |
||||
{ |
||||
|
||||
|
||||
}//namespace compression
|
||||
}//namespace gtx
|
||||
}//namespace gli
|
||||
|
||||
namespace gli{using namespace gtx::compression;} |
||||
|
||||
#include "compression.inl" |
||||
|
||||
#endif//GLI_GTX_COMPRESSION_INCLUDED
|
||||
@ -0,0 +1,8 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2008-12-19 |
||||
// Updated : 2010-01-09 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/gtx/compression.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
@ -0,0 +1,46 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2008-12-19
|
||||
// Updated : 2010-09-27
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/gtx/fetch.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_GTX_FETCH_INCLUDED |
||||
#define GLI_GTX_FETCH_INCLUDED |
||||
|
||||
#include "../gli.hpp" |
||||
|
||||
namespace gli{ |
||||
namespace gtx{ |
||||
namespace fetch |
||||
{ |
||||
template <typename genType> |
||||
genType texelFetch( |
||||
texture2D const & Texture,
|
||||
texture2D::dimensions_type const & Texcoord, |
||||
texture2D::level_type const & Level); |
||||
|
||||
template <typename genType> |
||||
genType textureLod( |
||||
texture2D const & Texture,
|
||||
texture2D::texcoord_type const & Texcoord, |
||||
texture2D::level_type const & Level); |
||||
|
||||
template <typename genType> |
||||
void texelWrite( |
||||
texture2D & Texture, |
||||
texture2D::dimensions_type const & Texcoord, |
||||
texture2D::level_type const & Level, |
||||
genType const & Color); |
||||
|
||||
}//namespace fetch
|
||||
}//namespace gtx
|
||||
}//namespace gli
|
||||
|
||||
namespace gli{using namespace gtx::fetch;} |
||||
|
||||
#include "fetch.inl" |
||||
|
||||
#endif//GLI_GTX_FETCH_INCLUDED
|
||||
@ -0,0 +1,91 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2008-12-19 |
||||
// Updated : 2010-09-27 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/gtx/fetch.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace gli{ |
||||
namespace gtx{ |
||||
namespace fetch |
||||
{ |
||||
template <typename genType> |
||||
inline genType texelFetch |
||||
( |
||||
texture2D const & Image, |
||||
texture2D::dimensions_type const & TexCoord, |
||||
texture2D::level_type const & Level |
||||
) |
||||
{ |
||||
assert(Image[Level].format() == R8U || Image[Level].format() == RG8U || Image[Level].format() == RGB8U || Image[Level].format() == RGBA8U); |
||||
|
||||
texture2D::dimensions_type Dimensions = Image[Level].dimensions(); |
||||
texture2D::value_type const * const Data = Image[Level].data(); |
||||
|
||||
return reinterpret_cast<genType const * const>(Data)[TexCoord.x + TexCoord.y * Dimensions.x]; |
||||
} |
||||
|
||||
template <typename genType> |
||||
inline genType textureLod |
||||
( |
||||
texture2D const & Image, |
||||
texture2D::texcoord_type const & TexCoord, |
||||
texture2D::level_type const & Level |
||||
) |
||||
{ |
||||
assert(Image[Level].format() == R8U || Image[Level].format() == RG8U || Image[Level].format() == RGB8U || Image[Level].format() == RGBA8U); |
||||
|
||||
texture2D::dimensions_type Dimensions = Image[Level].dimensions(); |
||||
texture2D::value_type const * const Data = Image[Level].data(); |
||||
|
||||
std::size_t s_below = std::size_t(glm::floor(TexCoord.s * float(Dimensions.x - 1))); |
||||
std::size_t s_above = std::size_t(glm::ceil( TexCoord.s * float(Dimensions.x - 1))); |
||||
std::size_t t_below = std::size_t(glm::floor(TexCoord.t * float(Dimensions.y - 1))); |
||||
std::size_t t_above = std::size_t(glm::ceil( TexCoord.t * float(Dimensions.y - 1))); |
||||
|
||||
float s_step = 1.0f / float(Dimensions.x); |
||||
float t_step = 1.0f / float(Dimensions.y); |
||||
|
||||
float s_below_normalized = s_below / float(Dimensions.x); |
||||
float s_above_normalized = s_above / float(Dimensions.x); |
||||
float t_below_normalized = t_below / float(Dimensions.y); |
||||
float t_above_normalized = t_above / float(Dimensions.y); |
||||
|
||||
genType Value1 = reinterpret_cast<genType const * const>(Data)[s_below + t_below * Dimensions.x]; |
||||
genType Value2 = reinterpret_cast<genType const * const>(Data)[s_above + t_below * Dimensions.x]; |
||||
genType Value3 = reinterpret_cast<genType const * const>(Data)[s_above + t_above * Dimensions.x]; |
||||
genType Value4 = reinterpret_cast<genType const * const>(Data)[s_below + t_above * Dimensions.x]; |
||||
|
||||
float BlendA = float(TexCoord.s - s_below_normalized) * float(Dimensions.x - 1); |
||||
float BlendB = float(TexCoord.s - s_below_normalized) * float(Dimensions.x - 1); |
||||
float BlendC = float(TexCoord.t - t_below_normalized) * float(Dimensions.y - 1); |
||||
|
||||
genType ValueA(glm::mix(Value1, Value2, BlendA)); |
||||
genType ValueB(glm::mix(Value4, Value3, BlendB)); |
||||
|
||||
return genType(glm::mix(ValueA, ValueB, BlendC)); |
||||
} |
||||
|
||||
template <typename genType> |
||||
void texelWrite |
||||
( |
||||
texture2D & Image, |
||||
texture2D::dimensions_type const & Texcoord, |
||||
texture2D::level_type const & Level, |
||||
genType const & Color |
||||
) |
||||
{ |
||||
genType * Data = (genType*)Image[Level].data(); |
||||
std::size_t Index = Texcoord.x + Texcoord.y * Image[Level].dimensions().x; |
||||
|
||||
std::size_t Capacity = Image[Level].capacity(); |
||||
assert(Index < Capacity); |
||||
|
||||
*(Data + Index) = Color; |
||||
} |
||||
|
||||
}//namespace fetch |
||||
}//namespace gtx |
||||
}//namespace gli |
||||
@ -0,0 +1,33 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2010-09-27
|
||||
// Updated : 2010-10-01
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/gtx/gl_texture2d.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_GTX_GL_TEXTURE2D_INCLUDED |
||||
#define GLI_GTX_GL_TEXTURE2D_INCLUDED |
||||
|
||||
#include "../gli.hpp" |
||||
#include "../gtx/loader.hpp" |
||||
|
||||
#ifndef GL_VERSION_1_1 |
||||
#error "ERROR: OpenGL must be included before GLI_GTX_gl_texture2d" |
||||
#endif//GL_VERSION_1_1
|
||||
|
||||
namespace gli{ |
||||
namespace gtx{ |
||||
namespace gl_texture2d |
||||
{ |
||||
GLuint createTexture2D(std::string const & Filename); |
||||
}//namespace gl_texture2d
|
||||
}//namespace gtx
|
||||
}//namespace gli
|
||||
|
||||
namespace gli{using namespace gtx::gl_texture2d;} |
||||
|
||||
#include "gl_texture2d.inl" |
||||
|
||||
#endif//GLI_GTX_GL_TEXTURE2D_INCLUDED
|
||||
@ -0,0 +1,210 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2010-09-27 |
||||
// Updated : 2010-10-01 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/gtx/gl_texture2d.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace gli{ |
||||
namespace gtx{ |
||||
namespace gl_texture2d{ |
||||
namespace detail |
||||
{ |
||||
//GL_COMPRESSED_RED, GL_COMPRESSED_RG, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_COMPRESSED_SRGB, GL_COMPRESSED_SRGB_ALPHA, |
||||
//GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, or GL_SRGB8_ALPHA8 |
||||
struct texture_desc |
||||
{ |
||||
GLint InternalFormat; |
||||
GLint InternalFormatCompressed; |
||||
GLint InternalFormatSRGB; |
||||
GLint InternalFormatCompressedSRGB; |
||||
GLenum ExternalFormat; |
||||
GLenum ExternalFormatRev; |
||||
GLenum Type; |
||||
}; |
||||
|
||||
//GL_RED, GL_RG, GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. |
||||
//GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, |
||||
//GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, |
||||
//GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, |
||||
//GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, |
||||
//GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, |
||||
//GL_UNSIGNED_INT_2_10_10_10_REV |
||||
|
||||
# ifndef GL_COMPRESSED_RGBA_BPTC_UNORM_ARB |
||||
# define GL_COMPRESSED_RGBA_BPTC_UNORM_ARB 0x8E8C |
||||
# endif |
||||
|
||||
# ifndef GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB |
||||
# define GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB 0x8E8D |
||||
# endif |
||||
|
||||
# ifndef GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB |
||||
# define GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB 0x8E8E |
||||
# endif |
||||
|
||||
# ifndef GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB |
||||
# define GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB 0x8E8F |
||||
# endif |
||||
|
||||
inline texture_desc gli2ogl_cast(format const & Format) |
||||
{ |
||||
texture_desc Cast[] = |
||||
{ |
||||
{GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE}, |
||||
|
||||
//// Normalized |
||||
//{GL_RED, GL_COMPRESSED_RED, GL_RED, GL_COMPRESSED_RED, GL_RED, GL_RED, GL_UNSIGNED_BYTE}, |
||||
//{GL_RG, GL_COMPRESSED_RG, GL_RG, GL_COMPRESSED_RG, GL_RG, GL_RG, GL_UNSIGNED_BYTE}, |
||||
//{GL_RGB, GL_COMPRESSED_RGB, GL_SRGB8, GL_COMPRESSED_SRGB, GL_RGB, GL_BGR, GL_UNSIGNED_BYTE}, |
||||
//{GL_RGBA, GL_COMPRESSED_RGBA, GL_SRGB8_ALPHA8, GL_COMPRESSED_SRGB_ALPHA, GL_RGBA, GL_BGRA, GL_UNSIGNED_BYTE}, |
||||
|
||||
//{GL_RED, GL_COMPRESSED_RED, GL_RED, GL_COMPRESSED_RED, GL_RED, GL_RED, GL_UNSIGNED_SHORT}, |
||||
//{GL_RG, GL_COMPRESSED_RG, GL_RG, GL_COMPRESSED_RG, GL_RG, GL_RG, GL_UNSIGNED_SHORT}, |
||||
//{GL_RGB, GL_COMPRESSED_RGB, GL_SRGB8, GL_COMPRESSED_SRGB, GL_RGB, GL_BGR, GL_UNSIGNED_SHORT}, |
||||
//{GL_RGBA, GL_COMPRESSED_RGBA, GL_SRGB8_ALPHA8, GL_COMPRESSED_SRGB_ALPHA, GL_RGBA, GL_BGRA, GL_UNSIGNED_SHORT}, |
||||
|
||||
//{GL_RED, GL_COMPRESSED_RED, GL_RED, GL_COMPRESSED_RED, GL_RED, GL_RED, GL_UNSIGNED_INT}, |
||||
//{GL_RG, GL_COMPRESSED_RG, GL_RG, GL_COMPRESSED_RG, GL_RG, GL_RG, GL_UNSIGNED_INT}, |
||||
//{GL_RGB, GL_COMPRESSED_RGB, GL_SRGB8, GL_COMPRESSED_SRGB, GL_RGB, GL_BGR, GL_UNSIGNED_INT}, |
||||
//{GL_RGBA, GL_COMPRESSED_RGBA, GL_SRGB8_ALPHA8, GL_COMPRESSED_SRGB_ALPHA, GL_RGBA, GL_BGRA, GL_UNSIGNED_INT}, |
||||
|
||||
// Unsigned |
||||
{GL_RED, GL_COMPRESSED_RED, GL_RED, GL_COMPRESSED_RED, GL_RED, GL_RED, GL_UNSIGNED_BYTE}, |
||||
{GL_RG, GL_COMPRESSED_RG, GL_RG, GL_COMPRESSED_RG, GL_RG, GL_RG, GL_UNSIGNED_BYTE}, |
||||
{GL_RGB, GL_COMPRESSED_RGB, GL_SRGB8, GL_COMPRESSED_SRGB, GL_RGB, GL_BGR, GL_UNSIGNED_BYTE}, |
||||
{GL_RGBA, GL_COMPRESSED_RGBA, GL_SRGB8_ALPHA8, GL_COMPRESSED_SRGB_ALPHA, GL_RGBA, GL_BGRA, GL_UNSIGNED_BYTE}, |
||||
|
||||
{GL_RED, GL_COMPRESSED_RED, GL_RED, GL_COMPRESSED_RED, GL_RED, GL_RED, GL_UNSIGNED_SHORT}, |
||||
{GL_RG, GL_COMPRESSED_RG, GL_RG, GL_COMPRESSED_RG, GL_RG, GL_RG, GL_UNSIGNED_SHORT}, |
||||
{GL_RGB, GL_COMPRESSED_RGB, GL_SRGB8, GL_COMPRESSED_SRGB, GL_RGB, GL_BGR, GL_UNSIGNED_SHORT}, |
||||
{GL_RGBA, GL_COMPRESSED_RGBA, GL_SRGB8_ALPHA8, GL_COMPRESSED_SRGB_ALPHA, GL_RGBA, GL_BGRA, GL_UNSIGNED_SHORT}, |
||||
|
||||
{GL_RED, GL_COMPRESSED_RED, GL_RED, GL_COMPRESSED_RED, GL_RED, GL_RED, GL_UNSIGNED_INT}, |
||||
{GL_RG, GL_COMPRESSED_RG, GL_RG, GL_COMPRESSED_RG, GL_RG, GL_RG, GL_UNSIGNED_INT}, |
||||
{GL_RGB, GL_COMPRESSED_RGB, GL_SRGB8, GL_COMPRESSED_SRGB, GL_RGB, GL_BGR, GL_UNSIGNED_INT}, |
||||
{GL_RGBA, GL_COMPRESSED_RGBA, GL_SRGB8_ALPHA8, GL_COMPRESSED_SRGB_ALPHA, GL_RGBA, GL_BGRA, GL_UNSIGNED_INT}, |
||||
|
||||
// Signed |
||||
{GL_RED, GL_COMPRESSED_RED, GL_RED, GL_COMPRESSED_RED, GL_RED, GL_RED, GL_BYTE}, |
||||
{GL_RG, GL_COMPRESSED_RG, GL_RG, GL_COMPRESSED_RG, GL_RG, GL_RG, GL_BYTE}, |
||||
{GL_RGB, GL_COMPRESSED_RGB, GL_SRGB8, GL_COMPRESSED_SRGB, GL_RGB, GL_BGR, GL_BYTE}, |
||||
{GL_RGBA, GL_COMPRESSED_RGBA, GL_SRGB8_ALPHA8, GL_COMPRESSED_SRGB_ALPHA, GL_RGBA, GL_BGRA, GL_BYTE}, |
||||
|
||||
{GL_RED, GL_COMPRESSED_RED, GL_RED, GL_COMPRESSED_RED, GL_RED, GL_RED, GL_SHORT}, |
||||
{GL_RG, GL_COMPRESSED_RG, GL_RG, GL_COMPRESSED_RG, GL_RG, GL_RG, GL_SHORT}, |
||||
{GL_RGB, GL_COMPRESSED_RGB, GL_SRGB8, GL_COMPRESSED_SRGB, GL_RGB, GL_BGR, GL_SHORT}, |
||||
{GL_RGBA, GL_COMPRESSED_RGBA, GL_SRGB8_ALPHA8, GL_COMPRESSED_SRGB_ALPHA, GL_RGBA, GL_BGRA, GL_SHORT}, |
||||
|
||||
{GL_RED, GL_COMPRESSED_RED, GL_RED, GL_COMPRESSED_RED, GL_RED, GL_RED, GL_INT}, |
||||
{GL_RG, GL_COMPRESSED_RG, GL_RG, GL_COMPRESSED_RG, GL_RG, GL_RG, GL_INT}, |
||||
{GL_RGB, GL_COMPRESSED_RGB, GL_SRGB8, GL_COMPRESSED_SRGB, GL_RGB, GL_BGR, GL_INT}, |
||||
{GL_RGBA, GL_COMPRESSED_RGBA, GL_SRGB8_ALPHA8, GL_COMPRESSED_SRGB_ALPHA, GL_RGBA, GL_BGRA, GL_INT}, |
||||
|
||||
// Float |
||||
{GL_RED, GL_COMPRESSED_RED, GL_RED, GL_COMPRESSED_RED, GL_RED, GL_RED, GL_HALF_FLOAT}, |
||||
{GL_RG, GL_COMPRESSED_RG, GL_RG, GL_COMPRESSED_RG, GL_RG, GL_RG, GL_HALF_FLOAT}, |
||||
{GL_RGB, GL_COMPRESSED_RGB, GL_SRGB8, GL_COMPRESSED_SRGB, GL_RGB, GL_BGR, GL_HALF_FLOAT}, |
||||
{GL_RGBA, GL_COMPRESSED_RGBA, GL_SRGB8_ALPHA8, GL_COMPRESSED_SRGB_ALPHA, GL_RGBA, GL_BGRA, GL_HALF_FLOAT}, |
||||
|
||||
{GL_RED, GL_COMPRESSED_RED, GL_RED, GL_COMPRESSED_RED, GL_RED, GL_RED, GL_FLOAT}, |
||||
{GL_RG, GL_COMPRESSED_RG, GL_RG, GL_COMPRESSED_RG, GL_RG, GL_RG, GL_FLOAT}, |
||||
{GL_RGB, GL_COMPRESSED_RGB, GL_SRGB8, GL_COMPRESSED_SRGB, GL_RGB, GL_BGR, GL_FLOAT}, |
||||
{GL_RGBA, GL_COMPRESSED_RGBA, GL_SRGB8_ALPHA8, GL_COMPRESSED_SRGB_ALPHA, GL_RGBA, GL_BGRA, GL_FLOAT}, |
||||
|
||||
// Packed |
||||
{GL_RED, GL_COMPRESSED_RED, GL_RED, GL_COMPRESSED_RED, GL_RED, GL_RED, GL_HALF_FLOAT}, |
||||
{GL_RGB9_E5, GL_RGB9_E5, GL_RED, GL_COMPRESSED_RED, GL_RED, GL_RED, GL_HALF_FLOAT}, |
||||
{GL_R11F_G11F_B10F, GL_R11F_G11F_B10F, GL_RED, GL_COMPRESSED_RED, GL_RED, GL_RED, GL_HALF_FLOAT}, |
||||
{GL_RED, GL_COMPRESSED_RED, GL_RED, GL_COMPRESSED_RED, GL_RED, GL_RED, GL_HALF_FLOAT}, |
||||
{GL_RGBA4, GL_RGBA4, GL_RED, GL_COMPRESSED_RED, GL_RED, GL_RED, GL_HALF_FLOAT}, |
||||
{GL_RGB10_A2, GL_RGB10_A2, GL_RED, GL_COMPRESSED_RED, GL_RED, GL_RED, GL_HALF_FLOAT}, |
||||
|
||||
// Depth |
||||
{GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT}, |
||||
{GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT}, |
||||
{GL_DEPTH24_STENCIL8, GL_DEPTH24_STENCIL8, GL_DEPTH24_STENCIL8, GL_DEPTH24_STENCIL8, GL_DEPTH_COMPONENT, GL_DEPTH_STENCIL, GL_UNSIGNED_INT}, |
||||
{GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, GL_FLOAT}, |
||||
{GL_DEPTH32F_STENCIL8, GL_DEPTH32F_STENCIL8, GL_DEPTH32F_STENCIL8, GL_DEPTH32F_STENCIL8, GL_DEPTH_COMPONENT, GL_DEPTH_STENCIL, GL_UNSIGNED_INT}, |
||||
|
||||
// Compressed formats |
||||
{GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_NONE, GL_NONE, GL_NONE}, |
||||
{GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_NONE, GL_NONE, GL_NONE}, |
||||
{GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_NONE, GL_NONE, GL_NONE}, |
||||
{GL_COMPRESSED_RED_RGTC1, GL_COMPRESSED_RED_RGTC1, GL_COMPRESSED_RED_RGTC1, GL_COMPRESSED_RED_RGTC1, GL_NONE, GL_NONE, GL_NONE}, |
||||
{GL_COMPRESSED_SIGNED_RED_RGTC1, GL_COMPRESSED_SIGNED_RED_RGTC1, GL_COMPRESSED_SIGNED_RED_RGTC1, GL_COMPRESSED_SIGNED_RED_RGTC1, GL_NONE, GL_NONE, GL_NONE}, |
||||
{GL_COMPRESSED_RG_RGTC2, GL_COMPRESSED_RG_RGTC2, GL_COMPRESSED_RG_RGTC2, GL_COMPRESSED_RG_RGTC2, GL_NONE, GL_NONE, GL_NONE}, |
||||
{GL_COMPRESSED_SIGNED_RG_RGTC2, GL_COMPRESSED_SIGNED_RG_RGTC2, GL_COMPRESSED_SIGNED_RG_RGTC2, GL_COMPRESSED_SIGNED_RG_RGTC2, GL_NONE, GL_NONE, GL_NONE}, |
||||
{GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB, GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB, GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB, GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB, GL_NONE, GL_NONE, GL_NONE}, |
||||
{GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB, GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB, GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB, GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB, GL_NONE, GL_NONE, GL_NONE}, |
||||
{GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB, GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB, GL_NONE, GL_NONE, GL_NONE}, |
||||
}; |
||||
|
||||
return Cast[Format]; |
||||
} |
||||
|
||||
}//namespace detail |
||||
|
||||
inline GLuint createTexture2D(std::string const & Filename) |
||||
{ |
||||
gli::texture2D Texture = gli::load(Filename); |
||||
if(Texture.empty()) |
||||
return 0; |
||||
|
||||
detail::texture_desc TextureDesc = detail::gli2ogl_cast(Texture.format()); |
||||
|
||||
GLint Alignment = 0; |
||||
glGetIntegerv(GL_UNPACK_ALIGNMENT, &Alignment); |
||||
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 1); |
||||
|
||||
GLuint Name = 0; |
||||
glGenTextures(1, &Name); |
||||
glBindTexture(GL_TEXTURE_2D, Name); |
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, Texture.levels() > 1 ? GL_NEAREST_MIPMAP_NEAREST : GL_NEAREST); |
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
||||
|
||||
if(size(Texture, BIT_PER_PIXEL) == size(Texture, BLOCK_SIZE) << 3) |
||||
{ |
||||
for(gli::texture2D::level_type Level = 0; Level < Texture.levels(); ++Level) |
||||
{ |
||||
glTexImage2D( |
||||
GL_TEXTURE_2D, |
||||
GLint(Level), |
||||
TextureDesc.InternalFormat, |
||||
GLsizei(Texture[Level].dimensions().x), |
||||
GLsizei(Texture[Level].dimensions().y), |
||||
0, |
||||
TextureDesc.ExternalFormatRev, |
||||
TextureDesc.Type, |
||||
Texture[Level].data()); |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
for(gli::texture2D::level_type Level = 0; Level < Texture.levels(); ++Level) |
||||
{ |
||||
glCompressedTexImage2D( |
||||
GL_TEXTURE_2D, |
||||
GLint(Level), |
||||
TextureDesc.InternalFormat, |
||||
GLsizei(Texture[Level].dimensions().x), |
||||
GLsizei(Texture[Level].dimensions().y), |
||||
0, |
||||
GLsizei(Texture[Level].capacity()), |
||||
Texture[Level].data()); |
||||
} |
||||
} |
||||
|
||||
glBindTexture(GL_TEXTURE_2D, 0); |
||||
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, Alignment); |
||||
|
||||
return Name; |
||||
} |
||||
|
||||
}//namespace gl_texture_2d |
||||
}//namespace gtx |
||||
}//namespace gli |
||||
@ -0,0 +1,38 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2008-12-19
|
||||
// Updated : 2010-01-09
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/gtx/gradient.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_GTX_GRADIENT_INCLUDED |
||||
#define GLI_GTX_GRADIENT_INCLUDED |
||||
|
||||
#include "../gli.hpp" |
||||
|
||||
namespace gli{ |
||||
namespace gtx{ |
||||
namespace gradient |
||||
{ |
||||
texture2D radial( |
||||
texture2D::dimensions_type const & Size,
|
||||
texture2D::texcoord_type const & Center, |
||||
float const & Radius, |
||||
texture2D::texcoord_type const & Focal); |
||||
|
||||
texture2D linear( |
||||
texture2D::dimensions_type const & Size,
|
||||
texture2D::texcoord_type const & Point0,
|
||||
texture2D::texcoord_type const & Point1); |
||||
|
||||
}//namespace gradient
|
||||
}//namespace gtx
|
||||
}//namespace gli
|
||||
|
||||
namespace gli{using namespace gtx::gradient;} |
||||
|
||||
#include "gradient.inl" |
||||
|
||||
#endif//GLI_GTX_GRADIENT_INCLUDED
|
||||
@ -0,0 +1,74 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2008-12-19 |
||||
// Updated : 2010-01-09 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/gtx/gradient.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace gli{ |
||||
namespace gtx{ |
||||
namespace gradient |
||||
{ |
||||
inline texture2D radial |
||||
( |
||||
texture2D::dimensions_type const & Size, |
||||
texture2D::texcoord_type const & Center, |
||||
float const & Radius, |
||||
texture2D::texcoord_type const & Focal |
||||
) |
||||
{ |
||||
image2D Result(texture2D::dimensions_type(Size), gli::RGB8U); |
||||
glm::u8vec3 * DstData = (glm::u8vec3 *)Result.data(); |
||||
|
||||
for(std::size_t y = 0; y < Result.dimensions().y; ++y) |
||||
for(std::size_t x = 0; x < Result.dimensions().x; ++x) |
||||
{ |
||||
float Value = glm::radialGradient( |
||||
Center * glm::vec2(Size), |
||||
Radius, |
||||
Focal * glm::vec2(Size), |
||||
glm::vec2(x, y)); |
||||
|
||||
std::size_t Index = x + y * Result.dimensions().x; |
||||
|
||||
*(DstData + Index) = glm::u8vec3(glm::u8(glm::clamp(Value * 255.f, 0.f, 255.f))); |
||||
} |
||||
|
||||
gli::texture2D Image(1); |
||||
Image[0] = Result; |
||||
return Image; |
||||
} |
||||
|
||||
inline texture2D linear |
||||
( |
||||
texture2D::dimensions_type const & Size, |
||||
texture2D::texcoord_type const & Point0, |
||||
texture2D::texcoord_type const & Point1 |
||||
) |
||||
{ |
||||
image2D Result(texture2D::dimensions_type(Size), gli::RGB8U); |
||||
glm::u8vec3 * DstData = (glm::u8vec3 *)Result.data(); |
||||
|
||||
for(std::size_t y = 0; y < Result.dimensions().y; ++y) |
||||
for(std::size_t x = 0; x < Result.dimensions().x; ++x) |
||||
{ |
||||
float Value = glm::linearGradient( |
||||
Point0 * glm::vec2(Size), |
||||
Point1 * glm::vec2(Size), |
||||
texture2D::texcoord_type(x, y)); |
||||
|
||||
std::size_t Index = x + y * Result.dimensions().x; |
||||
|
||||
*(DstData + Index) = glm::u8vec3(glm::u8(glm::clamp(Value * 255.f, 0.f, 255.f))); |
||||
} |
||||
|
||||
gli::texture2D Image(1); |
||||
Image[0] = Result; |
||||
return Image; |
||||
} |
||||
|
||||
}//namespace gradient |
||||
}//namespace gtx |
||||
}//namespace gli |
||||
@ -0,0 +1,37 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2010-09-08
|
||||
// Updated : 2010-09-27
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/gtx/loader.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_GTX_LOADER_INCLUDED |
||||
#define GLI_GTX_LOADER_INCLUDED |
||||
|
||||
#include "../gli.hpp" |
||||
#include "../gtx/loader_dds9.hpp" |
||||
#include "../gtx/loader_dds10.hpp" |
||||
#include "../gtx/loader_tga.hpp" |
||||
|
||||
namespace gli{ |
||||
namespace gtx{ |
||||
namespace loader |
||||
{ |
||||
inline texture2D load( |
||||
std::string const & Filename); |
||||
|
||||
inline void save( |
||||
texture2D const & Image,
|
||||
std::string const & Filename); |
||||
|
||||
}//namespace loader
|
||||
}//namespace gtx
|
||||
}//namespace gli
|
||||
|
||||
namespace gli{using namespace gtx::loader;} |
||||
|
||||
#include "loader.inl" |
||||
|
||||
#endif//GLI_GTX_LOADER_INCLUDED
|
||||
@ -0,0 +1,48 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2010-09-08 |
||||
// Updated : 2010-09-27 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/gtx/loader.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace gli{ |
||||
namespace gtx{ |
||||
namespace loader |
||||
{ |
||||
inline texture2D load |
||||
( |
||||
std::string const & Filename |
||||
) |
||||
{ |
||||
if(Filename.find(".dds") != std::string::npos) |
||||
return loadDDS10(Filename); |
||||
else if(Filename.find(".tga") != std::string::npos) |
||||
return loadTGA(Filename); |
||||
else |
||||
{ |
||||
assert(0); // File format not supported |
||||
return texture2D(); |
||||
} |
||||
} |
||||
|
||||
inline void save |
||||
( |
||||
texture2D const & Image, |
||||
std::string const & Filename |
||||
) |
||||
{ |
||||
char const * File = Filename.c_str(); |
||||
|
||||
if(Filename.find(".dds") != std::string::npos) |
||||
saveDDS10(Image, Filename); |
||||
else if(Filename.find(".tga") != std::string::npos) |
||||
saveTGA(Image, Filename); |
||||
else |
||||
assert(0); // File format not supported |
||||
} |
||||
|
||||
}//namespace loader |
||||
}//namespace gtx |
||||
}//namespace gli |
||||
@ -0,0 +1,35 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2010-09-26
|
||||
// Updated : 2010-09-27
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/gtx/loader_dds10.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_GTX_LOADER_DDS10_INCLUDED |
||||
#define GLI_GTX_LOADER_DDS10_INCLUDED |
||||
|
||||
#include "../gli.hpp" |
||||
#include <fstream> |
||||
|
||||
namespace gli{ |
||||
namespace gtx{ |
||||
namespace loader_dds10 |
||||
{ |
||||
texture2D loadDDS10( |
||||
std::string const & Filename); |
||||
|
||||
void saveDDS10( |
||||
texture2D const & Image,
|
||||
std::string const & Filename); |
||||
|
||||
}//namespace loader_dds10
|
||||
}//namespace gtx
|
||||
}//namespace gli
|
||||
|
||||
namespace gli{using namespace gtx::loader_dds10;} |
||||
|
||||
#include "loader_dds10.inl" |
||||
|
||||
#endif//GLI_GTX_LOADER_DDS10_INCLUDED
|
||||
@ -0,0 +1,595 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2010-09-26 |
||||
// Updated : 2010-09-27 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/gtx/loader_dds10.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace gli{ |
||||
namespace gtx{ |
||||
namespace loader_dds10{ |
||||
namespace detail |
||||
{ |
||||
// DDS Documentation |
||||
/* |
||||
http://msdn.microsoft.com/en-us/library/bb943991(VS.85).aspx#File_Layout1 |
||||
http://msdn.microsoft.com/en-us/library/bb943992.aspx |
||||
*/ |
||||
|
||||
#define GLI_MAKEFOURCC(ch0, ch1, ch2, ch3) \ |
||||
(glm::uint32)( \ |
||||
(((glm::uint32)(glm::uint8)(ch3) << 24) & 0xFF000000) | \ |
||||
(((glm::uint32)(glm::uint8)(ch2) << 16) & 0x00FF0000) | \ |
||||
(((glm::uint32)(glm::uint8)(ch1) << 8) & 0x0000FF00) | \ |
||||
((glm::uint32)(glm::uint8)(ch0) & 0x000000FF) ) |
||||
|
||||
enum DXGI_FORMAT |
||||
{ |
||||
DXGI_FORMAT_UNKNOWN = 0, |
||||
DXGI_FORMAT_R32G32B32A32_TYPELESS = 1, |
||||
DXGI_FORMAT_R32G32B32A32_FLOAT = 2, |
||||
DXGI_FORMAT_R32G32B32A32_UINT = 3, |
||||
DXGI_FORMAT_R32G32B32A32_SINT = 4, |
||||
DXGI_FORMAT_R32G32B32_TYPELESS = 5, |
||||
DXGI_FORMAT_R32G32B32_FLOAT = 6, |
||||
DXGI_FORMAT_R32G32B32_UINT = 7, |
||||
DXGI_FORMAT_R32G32B32_SINT = 8, |
||||
DXGI_FORMAT_R16G16B16A16_TYPELESS = 9, |
||||
DXGI_FORMAT_R16G16B16A16_FLOAT = 10, |
||||
DXGI_FORMAT_R16G16B16A16_UNORM = 11, |
||||
DXGI_FORMAT_R16G16B16A16_UINT = 12, |
||||
DXGI_FORMAT_R16G16B16A16_SNORM = 13, |
||||
DXGI_FORMAT_R16G16B16A16_SINT = 14, |
||||
DXGI_FORMAT_R32G32_TYPELESS = 15, |
||||
DXGI_FORMAT_R32G32_FLOAT = 16, |
||||
DXGI_FORMAT_R32G32_UINT = 17, |
||||
DXGI_FORMAT_R32G32_SINT = 18, |
||||
DXGI_FORMAT_R32G8X24_TYPELESS = 19, |
||||
DXGI_FORMAT_D32_FLOAT_S8X24_UINT = 20, |
||||
DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS = 21, |
||||
DXGI_FORMAT_X32_TYPELESS_G8X24_UINT = 22, |
||||
DXGI_FORMAT_R10G10B10A2_TYPELESS = 23, |
||||
DXGI_FORMAT_R10G10B10A2_UNORM = 24, |
||||
DXGI_FORMAT_R10G10B10A2_UINT = 25, |
||||
DXGI_FORMAT_R11G11B10_FLOAT = 26, |
||||
DXGI_FORMAT_R8G8B8A8_TYPELESS = 27, |
||||
DXGI_FORMAT_R8G8B8A8_UNORM = 28, |
||||
DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = 29, |
||||
DXGI_FORMAT_R8G8B8A8_UINT = 30, |
||||
DXGI_FORMAT_R8G8B8A8_SNORM = 31, |
||||
DXGI_FORMAT_R8G8B8A8_SINT = 32, |
||||
DXGI_FORMAT_R16G16_TYPELESS = 33, |
||||
DXGI_FORMAT_R16G16_FLOAT = 34, |
||||
DXGI_FORMAT_R16G16_UNORM = 35, |
||||
DXGI_FORMAT_R16G16_UINT = 36, |
||||
DXGI_FORMAT_R16G16_SNORM = 37, |
||||
DXGI_FORMAT_R16G16_SINT = 38, |
||||
DXGI_FORMAT_R32_TYPELESS = 39, |
||||
DXGI_FORMAT_D32_FLOAT = 40, |
||||
DXGI_FORMAT_R32_FLOAT = 41, |
||||
DXGI_FORMAT_R32_UINT = 42, |
||||
DXGI_FORMAT_R32_SINT = 43, |
||||
DXGI_FORMAT_R24G8_TYPELESS = 44, |
||||
DXGI_FORMAT_D24_UNORM_S8_UINT = 45, |
||||
DXGI_FORMAT_R24_UNORM_X8_TYPELESS = 46, |
||||
DXGI_FORMAT_X24_TYPELESS_G8_UINT = 47, |
||||
DXGI_FORMAT_R8G8_TYPELESS = 48, |
||||
DXGI_FORMAT_R8G8_UNORM = 49, |
||||
DXGI_FORMAT_R8G8_UINT = 50, |
||||
DXGI_FORMAT_R8G8_SNORM = 51, |
||||
DXGI_FORMAT_R8G8_SINT = 52, |
||||
DXGI_FORMAT_R16_TYPELESS = 53, |
||||
DXGI_FORMAT_R16_FLOAT = 54, |
||||
DXGI_FORMAT_D16_UNORM = 55, |
||||
DXGI_FORMAT_R16_UNORM = 56, |
||||
DXGI_FORMAT_R16_UINT = 57, |
||||
DXGI_FORMAT_R16_SNORM = 58, |
||||
DXGI_FORMAT_R16_SINT = 59, |
||||
DXGI_FORMAT_R8_TYPELESS = 60, |
||||
DXGI_FORMAT_R8_UNORM = 61, |
||||
DXGI_FORMAT_R8_UINT = 62, |
||||
DXGI_FORMAT_R8_SNORM = 63, |
||||
DXGI_FORMAT_R8_SINT = 64, |
||||
DXGI_FORMAT_A8_UNORM = 65, |
||||
DXGI_FORMAT_R1_UNORM = 66, |
||||
DXGI_FORMAT_R9G9B9E5_SHAREDEXP = 67, |
||||
DXGI_FORMAT_R8G8_B8G8_UNORM = 68, |
||||
DXGI_FORMAT_G8R8_G8B8_UNORM = 69, |
||||
DXGI_FORMAT_BC1_TYPELESS = 70, |
||||
DXGI_FORMAT_BC1_UNORM = 71, |
||||
DXGI_FORMAT_BC1_UNORM_SRGB = 72, |
||||
DXGI_FORMAT_BC2_TYPELESS = 73, |
||||
DXGI_FORMAT_BC2_UNORM = 74, |
||||
DXGI_FORMAT_BC2_UNORM_SRGB = 75, |
||||
DXGI_FORMAT_BC3_TYPELESS = 76, |
||||
DXGI_FORMAT_BC3_UNORM = 77, |
||||
DXGI_FORMAT_BC3_UNORM_SRGB = 78, |
||||
DXGI_FORMAT_BC4_TYPELESS = 79, |
||||
DXGI_FORMAT_BC4_UNORM = 80, |
||||
DXGI_FORMAT_BC4_SNORM = 81, |
||||
DXGI_FORMAT_BC5_TYPELESS = 82, |
||||
DXGI_FORMAT_BC5_UNORM = 83, |
||||
DXGI_FORMAT_BC5_SNORM = 84, |
||||
DXGI_FORMAT_B5G6R5_UNORM = 85, |
||||
DXGI_FORMAT_B5G5R5A1_UNORM = 86, |
||||
DXGI_FORMAT_B8G8R8A8_UNORM = 87, |
||||
DXGI_FORMAT_B8G8R8X8_UNORM = 88, |
||||
DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM = 89, |
||||
DXGI_FORMAT_B8G8R8A8_TYPELESS = 90, |
||||
DXGI_FORMAT_B8G8R8A8_UNORM_SRGB = 91, |
||||
DXGI_FORMAT_B8G8R8X8_TYPELESS = 92, |
||||
DXGI_FORMAT_B8G8R8X8_UNORM_SRGB = 93, |
||||
DXGI_FORMAT_BC6H_TYPELESS = 94, |
||||
DXGI_FORMAT_BC6H_UF16 = 95, |
||||
DXGI_FORMAT_BC6H_SF16 = 96, |
||||
DXGI_FORMAT_BC7_TYPELESS = 97, |
||||
DXGI_FORMAT_BC7_UNORM = 98, |
||||
DXGI_FORMAT_BC7_UNORM_SRGB = 99, |
||||
DXGI_FORMAT_FORCE_UINT = 0xffffffffUL |
||||
}; |
||||
|
||||
enum D3D10_RESOURCE_DIMENSION |
||||
{ |
||||
D3D10_RESOURCE_DIMENSION_UNKNOWN = 0, |
||||
D3D10_RESOURCE_DIMENSION_BUFFER = 1, |
||||
D3D10_RESOURCE_DIMENSION_TEXTURE1D = 2, |
||||
D3D10_RESOURCE_DIMENSION_TEXTURE2D = 3, |
||||
D3D10_RESOURCE_DIMENSION_TEXTURE3D = 4 |
||||
}; |
||||
|
||||
enum D3D10_RESOURCE_MISC_FLAG |
||||
{ |
||||
D3D10_RESOURCE_MISC_GENERATE_MIPS = 0x1L, |
||||
D3D10_RESOURCE_MISC_SHARED = 0x2L, |
||||
D3D10_RESOURCE_MISC_TEXTURECUBE = 0x4L, |
||||
D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX = 0x10L, |
||||
D3D10_RESOURCE_MISC_GDI_COMPATIBLE = 0x20L |
||||
}; |
||||
|
||||
enum dds_format |
||||
{ |
||||
GLI_D3DFMT_R8G8B8 = 20, |
||||
GLI_D3DFMT_A8R8G8B8 = 21, |
||||
GLI_D3DFMT_X8R8G8B8 = 22, |
||||
GLI_D3DFMT_A8 = 28, |
||||
GLI_D3DFMT_A2B10G10R10 = 31, |
||||
GLI_D3DFMT_A8B8G8R8 = 32, |
||||
GLI_D3DFMT_X8B8G8R8 = 33, |
||||
GLI_D3DFMT_G16R16 = 34, |
||||
GLI_D3DFMT_A2R10G10B10 = 35, |
||||
GLI_D3DFMT_A16B16G16R16 = 36, |
||||
|
||||
GLI_D3DFMT_L8 = 50, |
||||
GLI_D3DFMT_A8L8 = 51, |
||||
|
||||
GLI_D3DFMT_DXT1 = GLI_MAKEFOURCC('D', 'X', 'T', '1'), |
||||
GLI_D3DFMT_DXT2 = GLI_MAKEFOURCC('D', 'X', 'T', '2'), |
||||
GLI_D3DFMT_DXT3 = GLI_MAKEFOURCC('D', 'X', 'T', '3'), |
||||
GLI_D3DFMT_DXT4 = GLI_MAKEFOURCC('D', 'X', 'T', '4'), |
||||
GLI_D3DFMT_DXT5 = GLI_MAKEFOURCC('D', 'X', 'T', '5'), |
||||
GLI_D3DFMT_DX10 = GLI_MAKEFOURCC('D', 'X', '1', '0'), |
||||
|
||||
GLI_D3DFMT_D32 = 71, |
||||
GLI_D3DFMT_D24S8 = 75, |
||||
GLI_D3DFMT_D24X8 = 77, |
||||
GLI_D3DFMT_D16 = 80, |
||||
GLI_D3DFMT_L16 = 81, |
||||
GLI_D3DFMT_D32F_LOCKABLE = 82, |
||||
GLI_D3DFMT_D24FS8 = 83, |
||||
|
||||
GLI_D3DFMT_R16F = 111, |
||||
GLI_D3DFMT_G16R16F = 112, |
||||
GLI_D3DFMT_A16B16G16R16F = 113, |
||||
|
||||
GLI_D3DFMT_R32F = 114, |
||||
GLI_D3DFMT_G32R32F = 115, |
||||
GLI_D3DFMT_A32B32G32R32F = 116 |
||||
}; |
||||
|
||||
struct ddsHeader10 |
||||
{ |
||||
DXGI_FORMAT dxgiFormat; |
||||
D3D10_RESOURCE_DIMENSION resourceDimension; |
||||
glm::uint32 miscFlag; // D3D10_RESOURCE_MISC_GENERATE_MIPS |
||||
glm::uint32 arraySize; |
||||
glm::uint32 reserved; |
||||
}; |
||||
|
||||
|
||||
inline gli::format format_fourcc2gli_cast(glm::uint32 const & FourCC) |
||||
{ |
||||
switch(FourCC) |
||||
{ |
||||
case loader_dds9::detail::GLI_FOURCC_DXT1: |
||||
return DXT1; |
||||
case loader_dds9::detail::GLI_FOURCC_DXT2: |
||||
case loader_dds9::detail::GLI_FOURCC_DXT3: |
||||
return DXT3; |
||||
case loader_dds9::detail::GLI_FOURCC_DXT4: |
||||
case loader_dds9::detail::GLI_FOURCC_DXT5: |
||||
return DXT5; |
||||
case loader_dds9::detail::GLI_FOURCC_R16F: |
||||
return R16F; |
||||
case loader_dds9::detail::GLI_FOURCC_G16R16F: |
||||
return RG16F; |
||||
case loader_dds9::detail::GLI_FOURCC_A16B16G16R16F: |
||||
return RGBA16F; |
||||
case loader_dds9::detail::GLI_FOURCC_R32F: |
||||
return R32F; |
||||
case loader_dds9::detail::GLI_FOURCC_G32R32F: |
||||
return RG32F; |
||||
case loader_dds9::detail::GLI_FOURCC_A32B32G32R32F: |
||||
return RGBA32F; |
||||
|
||||
case loader_dds9::detail::GLI_D3DFMT_R8G8B8: |
||||
return RGB8U; |
||||
case loader_dds9::detail::GLI_D3DFMT_A8R8G8B8: |
||||
case loader_dds9::detail::GLI_D3DFMT_X8R8G8B8: |
||||
case loader_dds9::detail::GLI_D3DFMT_A8B8G8R8: |
||||
case loader_dds9::detail::GLI_D3DFMT_X8B8G8R8: |
||||
return RGBA8U; |
||||
case loader_dds9::detail::GLI_D3DFMT_R5G6B5: |
||||
return R5G6B5; |
||||
case loader_dds9::detail::GLI_D3DFMT_A4R4G4B4: |
||||
case loader_dds9::detail::GLI_D3DFMT_X4R4G4B4: |
||||
return RGBA4; |
||||
case loader_dds9::detail::GLI_D3DFMT_G16R16: |
||||
return RG16U; |
||||
case loader_dds9::detail::GLI_D3DFMT_A16B16G16R16: |
||||
return RGBA16U; |
||||
case loader_dds9::detail::GLI_D3DFMT_A2R10G10B10: |
||||
case loader_dds9::detail::GLI_D3DFMT_A2B10G10R10: |
||||
return RGB10A2; |
||||
default: |
||||
assert(0); |
||||
return FORMAT_NULL; |
||||
} |
||||
} |
||||
|
||||
inline DXGI_FORMAT format_gli2dds_cast(gli::format const & Format) |
||||
{ |
||||
DXGI_FORMAT Cast[] = |
||||
{ |
||||
DXGI_FORMAT_UNKNOWN, //FORMAT_NULL, |
||||
|
||||
// Unsigned integer formats |
||||
DXGI_FORMAT_R8_UINT, //R8U, |
||||
DXGI_FORMAT_R8G8_UINT, //RG8U, |
||||
DXGI_FORMAT_UNKNOWN, //RGB8U, |
||||
DXGI_FORMAT_R8G8B8A8_UINT, //RGBA8U, |
||||
|
||||
DXGI_FORMAT_R16_UINT, //R16U, |
||||
DXGI_FORMAT_R16G16_UINT, //RG16U, |
||||
DXGI_FORMAT_UNKNOWN, //RGB16U, |
||||
DXGI_FORMAT_R16G16B16A16_UINT, //RGBA16U, |
||||
|
||||
DXGI_FORMAT_R32_UINT, //R32U, |
||||
DXGI_FORMAT_R32G32_UINT, //RG32U, |
||||
DXGI_FORMAT_R32G32B32_UINT, //RGB32U, |
||||
DXGI_FORMAT_R32G32B32A32_UINT, //RGBA32U, |
||||
|
||||
// Signed integer formats |
||||
DXGI_FORMAT_R8_SINT, //R8I, |
||||
DXGI_FORMAT_R8G8_SINT, //RG8I, |
||||
DXGI_FORMAT_UNKNOWN, //RGB8I, |
||||
DXGI_FORMAT_R8G8B8A8_SINT, //RGBA8I, |
||||
|
||||
DXGI_FORMAT_R16_SINT, //R16I, |
||||
DXGI_FORMAT_R16G16_SINT, //RG16I, |
||||
DXGI_FORMAT_UNKNOWN, //RGB16I, |
||||
DXGI_FORMAT_R16G16B16A16_SINT, //RGBA16I, |
||||
|
||||
DXGI_FORMAT_R32_SINT, //R32I, |
||||
DXGI_FORMAT_R32G32_SINT, //RG32I, |
||||
DXGI_FORMAT_R32G32B32_SINT, //RGB32I, |
||||
DXGI_FORMAT_R32G32B32A32_SINT, //RGBA32I, |
||||
|
||||
// Floating formats |
||||
DXGI_FORMAT_R16_FLOAT, //R16F, |
||||
DXGI_FORMAT_R16G16_FLOAT, //RG16F, |
||||
DXGI_FORMAT_UNKNOWN, //RGB16F, |
||||
DXGI_FORMAT_R16G16B16A16_FLOAT, //RGBA16F, |
||||
|
||||
DXGI_FORMAT_R32_FLOAT, //R32F, |
||||
DXGI_FORMAT_R32G32_FLOAT, //RG32F, |
||||
DXGI_FORMAT_R32G32B32_FLOAT, //RGB32F, |
||||
DXGI_FORMAT_R32G32B32A32_FLOAT, //RGBA32F, |
||||
|
||||
// Packed formats |
||||
DXGI_FORMAT_UNKNOWN, //RGBE8, |
||||
DXGI_FORMAT_R9G9B9E5_SHAREDEXP, //RGB9E5, |
||||
DXGI_FORMAT_R11G11B10_FLOAT, |
||||
DXGI_FORMAT_B5G6R5_UNORM, //R5G6B5, |
||||
DXGI_FORMAT_UNKNOWN, //RGBA4, |
||||
DXGI_FORMAT_R10G10B10A2_TYPELESS, //RGB10A2, |
||||
|
||||
// Depth formats |
||||
DXGI_FORMAT_D16_UNORM, //D16, |
||||
DXGI_FORMAT_D24_UNORM_S8_UINT, //D24X8, |
||||
DXGI_FORMAT_D24_UNORM_S8_UINT, //D24S8, |
||||
DXGI_FORMAT_D32_FLOAT, //D32F, |
||||
DXGI_FORMAT_D32_FLOAT_S8X24_UINT, //D32FS8X24, |
||||
|
||||
// Compressed formats |
||||
DXGI_FORMAT_BC1_UNORM, //DXT1, |
||||
DXGI_FORMAT_BC2_UNORM, //DXT3, |
||||
DXGI_FORMAT_BC3_UNORM, //DXT5, |
||||
DXGI_FORMAT_BC4_UNORM, //ATI1N_UNORM, |
||||
DXGI_FORMAT_BC4_SNORM, //ATI1N_SNORM, |
||||
DXGI_FORMAT_BC5_UNORM, //ATI2N_UNORM, |
||||
DXGI_FORMAT_BC5_SNORM, //ATI2N_SNORM, |
||||
DXGI_FORMAT_BC6H_UF16, //BP_FLOAT, |
||||
DXGI_FORMAT_BC6H_SF16, //BP_FLOAT, |
||||
DXGI_FORMAT_BC7_UNORM //BP, |
||||
}; |
||||
|
||||
return Cast[Format]; |
||||
} |
||||
|
||||
inline gli::format format_dds2gli_cast(DXGI_FORMAT const & Format) |
||||
{ |
||||
gli::format Cast[] = |
||||
{ |
||||
gli::FORMAT_NULL, //DXGI_FORMAT_UNKNOWN = 0, |
||||
gli::RGBA32U, //DXGI_FORMAT_R32G32B32A32_TYPELESS = 1, |
||||
gli::RGBA32F, //DXGI_FORMAT_R32G32B32A32_FLOAT = 2, |
||||
gli::RGBA32U, //DXGI_FORMAT_R32G32B32A32_UINT = 3, |
||||
gli::RGBA32I, //DXGI_FORMAT_R32G32B32A32_SINT = 4, |
||||
gli::RGB32U, //DXGI_FORMAT_R32G32B32_TYPELESS = 5, |
||||
gli::RGB32F, //DXGI_FORMAT_R32G32B32_FLOAT = 6, |
||||
gli::RGB32U, //DXGI_FORMAT_R32G32B32_UINT = 7, |
||||
gli::RGB32I, //DXGI_FORMAT_R32G32B32_SINT = 8, |
||||
gli::RGBA16U, //DXGI_FORMAT_R16G16B16A16_TYPELESS = 9, |
||||
gli::RGBA16F, //DXGI_FORMAT_R16G16B16A16_FLOAT = 10, |
||||
gli::RGBA16U, //DXGI_FORMAT_R16G16B16A16_UNORM = 11, |
||||
gli::RGBA16I, //DXGI_FORMAT_R16G16B16A16_UINT = 12, |
||||
gli::RGBA16I, //DXGI_FORMAT_R16G16B16A16_SNORM = 13, |
||||
gli::RGBA16I, //DXGI_FORMAT_R16G16B16A16_SINT = 14, |
||||
gli::RG32U, //DXGI_FORMAT_R32G32_TYPELESS = 15, |
||||
gli::RG32F, //DXGI_FORMAT_R32G32_FLOAT = 16, |
||||
gli::RG32U, //DXGI_FORMAT_R32G32_UINT = 17, |
||||
gli::RG32I, //DXGI_FORMAT_R32G32_SINT = 18, |
||||
gli::FORMAT_NULL, //DXGI_FORMAT_R32G8X24_TYPELESS = 19, |
||||
gli::D32FS8X24, //DXGI_FORMAT_D32_FLOAT_S8X24_UINT = 20, |
||||
gli::FORMAT_NULL, //DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS = 21, |
||||
gli::FORMAT_NULL, //DXGI_FORMAT_X32_TYPELESS_G8X24_UINT = 22, |
||||
gli::RGB10A2, //DXGI_FORMAT_R10G10B10A2_TYPELESS = 23, |
||||
gli::RGB10A2, //DXGI_FORMAT_R10G10B10A2_UNORM = 24, |
||||
gli::RGB10A2, //DXGI_FORMAT_R10G10B10A2_UINT = 25, |
||||
gli::RG11B10F, //DXGI_FORMAT_R11G11B10_FLOAT = 26, |
||||
gli::RGBA8U, //DXGI_FORMAT_R8G8B8A8_TYPELESS = 27, |
||||
gli::RGBA8U, //DXGI_FORMAT_R8G8B8A8_UNORM = 28, |
||||
gli::RGBA8U, //DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = 29, |
||||
gli::RGBA8U, //DXGI_FORMAT_R8G8B8A8_UINT = 30, |
||||
gli::RGBA8I, //DXGI_FORMAT_R8G8B8A8_SNORM = 31, |
||||
gli::RGBA8I, //DXGI_FORMAT_R8G8B8A8_SINT = 32, |
||||
gli::RG16U, //DXGI_FORMAT_R16G16_TYPELESS = 33, |
||||
gli::RG16F, //DXGI_FORMAT_R16G16_FLOAT = 34, |
||||
gli::RG16U, //DXGI_FORMAT_R16G16_UNORM = 35, |
||||
gli::RG16U, //DXGI_FORMAT_R16G16_UINT = 36, |
||||
gli::RG16I, //DXGI_FORMAT_R16G16_SNORM = 37, |
||||
gli::RG16I, //DXGI_FORMAT_R16G16_SINT = 38, |
||||
gli::R32F, //DXGI_FORMAT_R32_TYPELESS = 39, |
||||
gli::D32F, //DXGI_FORMAT_D32_FLOAT = 40, |
||||
gli::R32F, //DXGI_FORMAT_R32_FLOAT = 41, |
||||
gli::R32U, //DXGI_FORMAT_R32_UINT = 42, |
||||
gli::R32I, //DXGI_FORMAT_R32_SINT = 43, |
||||
gli::FORMAT_NULL, //DXGI_FORMAT_R24G8_TYPELESS = 44, |
||||
gli::FORMAT_NULL, //DXGI_FORMAT_D24_UNORM_S8_UINT = 45, |
||||
gli::FORMAT_NULL, //DXGI_FORMAT_R24_UNORM_X8_TYPELESS = 46, |
||||
gli::FORMAT_NULL, //DXGI_FORMAT_X24_TYPELESS_G8_UINT = 47, |
||||
gli::RG8U, //DXGI_FORMAT_R8G8_TYPELESS = 48, |
||||
gli::RG8U, //DXGI_FORMAT_R8G8_UNORM = 49, |
||||
gli::RG8U, //DXGI_FORMAT_R8G8_UINT = 50, |
||||
gli::RG8I, //DXGI_FORMAT_R8G8_SNORM = 51, |
||||
gli::RG8I, //DXGI_FORMAT_R8G8_SINT = 52, |
||||
gli::R16U, //DXGI_FORMAT_R16_TYPELESS = 53, |
||||
gli::R16F, //DXGI_FORMAT_R16_FLOAT = 54, |
||||
gli::D16, //DXGI_FORMAT_D16_UNORM = 55, |
||||
gli::R16U, //DXGI_FORMAT_R16_UNORM = 56, |
||||
gli::R16U, //DXGI_FORMAT_R16_UINT = 57, |
||||
gli::R16I, //DXGI_FORMAT_R16_SNORM = 58, |
||||
gli::R16I, //DXGI_FORMAT_R16_SINT = 59, |
||||
gli::R8U, //DXGI_FORMAT_R8_TYPELESS = 60, |
||||
gli::R8U, //DXGI_FORMAT_R8_UNORM = 61, |
||||
gli::R8U, //DXGI_FORMAT_R8_UINT = 62, |
||||
gli::R8I, //DXGI_FORMAT_R8_SNORM = 63, |
||||
gli::R8I, //DXGI_FORMAT_R8_SINT = 64, |
||||
gli::R8U, //DXGI_FORMAT_A8_UNORM = 65, |
||||
gli::FORMAT_NULL, //DXGI_FORMAT_R1_UNORM = 66, |
||||
gli::RGB9E5, //DXGI_FORMAT_R9G9B9E5_SHAREDEXP = 67, |
||||
gli::FORMAT_NULL, //DXGI_FORMAT_R8G8_B8G8_UNORM = 68, |
||||
gli::FORMAT_NULL, //DXGI_FORMAT_G8R8_G8B8_UNORM = 69, |
||||
gli::DXT1, //DXGI_FORMAT_BC1_TYPELESS = 70, |
||||
gli::DXT1, //DXGI_FORMAT_BC1_UNORM = 71, |
||||
gli::DXT1, //DXGI_FORMAT_BC1_UNORM_SRGB = 72, |
||||
gli::DXT3, //DXGI_FORMAT_BC2_TYPELESS = 73, |
||||
gli::DXT3, //DXGI_FORMAT_BC2_UNORM = 74, |
||||
gli::DXT3, //DXGI_FORMAT_BC2_UNORM_SRGB = 75, |
||||
gli::DXT5, //DXGI_FORMAT_BC3_TYPELESS = 76, |
||||
gli::DXT5, //DXGI_FORMAT_BC3_UNORM = 77, |
||||
gli::DXT5, //DXGI_FORMAT_BC3_UNORM_SRGB = 78, |
||||
gli::ATI1N_UNORM, //DXGI_FORMAT_BC4_TYPELESS = 79, |
||||
gli::ATI1N_UNORM, //DXGI_FORMAT_BC4_UNORM = 80, |
||||
gli::ATI1N_SNORM, //DXGI_FORMAT_BC4_SNORM = 81, |
||||
gli::ATI2N_UNORM, //DXGI_FORMAT_BC5_TYPELESS = 82, |
||||
gli::ATI2N_UNORM, //DXGI_FORMAT_BC5_UNORM = 83, |
||||
gli::ATI2N_SNORM, //DXGI_FORMAT_BC5_SNORM = 84, |
||||
gli::FORMAT_NULL, //DXGI_FORMAT_B5G6R5_UNORM = 85, |
||||
gli::FORMAT_NULL, //DXGI_FORMAT_B5G5R5A1_UNORM = 86, |
||||
gli::RGBA8U, //DXGI_FORMAT_B8G8R8A8_UNORM = 87, |
||||
gli::RGBA8U, //DXGI_FORMAT_B8G8R8X8_UNORM = 88, |
||||
gli::FORMAT_NULL, //DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM = 89, |
||||
gli::RGBA8U, //DXGI_FORMAT_B8G8R8A8_TYPELESS = 90, |
||||
gli::RGBA8U, //DXGI_FORMAT_B8G8R8A8_UNORM_SRGB = 91, |
||||
gli::RGBA8U, //DXGI_FORMAT_B8G8R8X8_TYPELESS = 92, |
||||
gli::RGBA8U, //DXGI_FORMAT_B8G8R8X8_UNORM_SRGB = 93, |
||||
gli::BP_UF16, //DXGI_FORMAT_BC6H_TYPELESS = 94, |
||||
gli::BP_UF16, //DXGI_FORMAT_BC6H_UF16 = 95, |
||||
gli::BP_SF16, //DXGI_FORMAT_BC6H_SF16 = 96, |
||||
gli::BP, //DXGI_FORMAT_BC7_TYPELESS = 97, |
||||
gli::BP, //DXGI_FORMAT_BC7_UNORM = 98, |
||||
gli::BP, //DXGI_FORMAT_BC7_UNORM_SRGB = 99, |
||||
gli::R32U //DXGI_FORMAT_FORCE_UINT = 0xffffffffUL |
||||
}; |
||||
|
||||
return Cast[Format]; |
||||
} |
||||
|
||||
}//namespace detail |
||||
|
||||
inline texture2D loadDDS10 |
||||
( |
||||
std::string const & Filename |
||||
) |
||||
{ |
||||
std::ifstream FileIn(Filename.c_str(), std::ios::in | std::ios::binary); |
||||
if(FileIn.fail()) |
||||
return texture2D(); |
||||
|
||||
loader_dds9::detail::ddsHeader HeaderDesc; |
||||
detail::ddsHeader10 HeaderDesc10; |
||||
char Magic[4]; |
||||
|
||||
//* Read magic number and check if valid .dds file |
||||
FileIn.read((char*)&Magic, sizeof(Magic)); |
||||
|
||||
assert(strncmp(Magic, "DDS ", 4) == 0); |
||||
|
||||
// Get the surface descriptor |
||||
FileIn.read((char*)&HeaderDesc, sizeof(HeaderDesc)); |
||||
if(HeaderDesc.format.flags & loader_dds9::detail::GLI_DDPF_FOURCC && HeaderDesc.format.fourCC == loader_dds9::detail::GLI_FOURCC_DX10) |
||||
FileIn.read((char*)&HeaderDesc10, sizeof(HeaderDesc10)); |
||||
|
||||
loader_dds9::detail::DDLoader Loader; |
||||
if(HeaderDesc.format.fourCC == loader_dds9::detail::GLI_FOURCC_DX10) |
||||
Loader.Format = detail::format_dds2gli_cast(HeaderDesc10.dxgiFormat); |
||||
else if(HeaderDesc.format.flags & loader_dds9::detail::GLI_DDPF_FOURCC) |
||||
Loader.Format = detail::format_fourcc2gli_cast(HeaderDesc.format.fourCC); |
||||
else |
||||
{ |
||||
switch(HeaderDesc.format.bpp) |
||||
{ |
||||
case 8: |
||||
Loader.Format = R8U; |
||||
break; |
||||
case 16: |
||||
Loader.Format = RG8U; |
||||
break; |
||||
case 24: |
||||
Loader.Format = RGB8U; |
||||
break; |
||||
case 32: |
||||
Loader.Format = RGBA8U; |
||||
break; |
||||
} |
||||
} |
||||
Loader.BlockSize = size(image2D(texture2D::dimensions_type(0), Loader.Format), BLOCK_SIZE); |
||||
Loader.BPP = size(image2D(image2D::dimensions_type(0), Loader.Format), BIT_PER_PIXEL); |
||||
|
||||
std::size_t Width = HeaderDesc.width; |
||||
std::size_t Height = HeaderDesc.height; |
||||
|
||||
gli::format Format = Loader.Format; |
||||
|
||||
std::streamoff Curr = FileIn.tellg(); |
||||
FileIn.seekg(0, std::ios_base::end); |
||||
std::streamoff End = FileIn.tellg(); |
||||
FileIn.seekg(Curr, std::ios_base::beg); |
||||
|
||||
std::vector<glm::byte> Data(std::size_t(End - Curr), 0); |
||||
std::size_t Offset = 0; |
||||
|
||||
FileIn.read((char*)&Data[0], std::streamsize(Data.size())); |
||||
|
||||
//texture2D Image(glm::min(MipMapCount, Levels));//SurfaceDesc.mipMapLevels); |
||||
std::size_t MipMapCount = (HeaderDesc.flags & loader_dds9::detail::GLI_DDSD_MIPMAPCOUNT) ? HeaderDesc.mipMapLevels : 1; |
||||
//if(Loader.Format == DXT1 || Loader.Format == DXT3 || Loader.Format == DXT5) |
||||
// MipMapCount -= 2; |
||||
texture2D Image(MipMapCount); |
||||
for(std::size_t Level = 0; Level < Image.levels() && (Width || Height); ++Level) |
||||
{ |
||||
Width = glm::max(std::size_t(Width), std::size_t(1)); |
||||
Height = glm::max(std::size_t(Height), std::size_t(1)); |
||||
|
||||
std::size_t MipmapSize = 0; |
||||
if((Loader.BlockSize << 3) > Loader.BPP) |
||||
MipmapSize = ((Width + 3) >> 2) * ((Height + 3) >> 2) * Loader.BlockSize; |
||||
else |
||||
MipmapSize = Width * Height * Loader.BlockSize; |
||||
std::vector<glm::byte> MipmapData(MipmapSize, 0); |
||||
|
||||
memcpy(&MipmapData[0], &Data[0] + Offset, MipmapSize); |
||||
|
||||
image2D::dimensions_type Dimensions(Width, Height); |
||||
Image[Level] = image2D(Dimensions, Format, MipmapData); |
||||
|
||||
Offset += MipmapSize; |
||||
Width >>= 1; |
||||
Height >>= 1; |
||||
} |
||||
|
||||
return Image; |
||||
} |
||||
|
||||
inline void saveDDS10 |
||||
( |
||||
gli::texture2D const & Image, |
||||
std::string const & Filename |
||||
) |
||||
{ |
||||
std::ofstream FileOut(Filename.c_str(), std::ios::out | std::ios::binary); |
||||
if (!FileOut) |
||||
return; |
||||
|
||||
char const * Magic = "DDS "; |
||||
FileOut.write((char*)Magic, sizeof(char) * 4); |
||||
|
||||
glm::uint32 Caps = loader_dds9::detail::GLI_DDSD_CAPS | loader_dds9::detail::GLI_DDSD_HEIGHT | loader_dds9::detail::GLI_DDSD_WIDTH | loader_dds9::detail::GLI_DDSD_PIXELFORMAT; |
||||
|
||||
loader_dds9::detail::ddsHeader HeaderDesc; |
||||
HeaderDesc.size = sizeof(loader_dds9::detail::ddsHeader); |
||||
HeaderDesc.flags = Caps | (loader_dds9::detail::isCompressed(Image) ? loader_dds9::detail::GLI_DDSD_LINEARSIZE : loader_dds9::detail::GLI_DDSD_PITCH) | (Image.levels() > 1 ? loader_dds9::detail::GLI_DDSD_MIPMAPCOUNT : 0); //659463; |
||||
HeaderDesc.width = Image[0].dimensions().x; |
||||
HeaderDesc.height = Image[0].dimensions().y; |
||||
HeaderDesc.pitch = loader_dds9::detail::isCompressed(Image) ? size(Image, LINEAR_SIZE) : 32; |
||||
HeaderDesc.depth = 0; |
||||
HeaderDesc.mipMapLevels = glm::uint32(Image.levels()); |
||||
HeaderDesc.format.size = sizeof(loader_dds9::detail::ddsPixelFormat); |
||||
HeaderDesc.format.flags = loader_dds9::detail::GLI_DDPF_FOURCC; |
||||
HeaderDesc.format.fourCC = loader_dds9::detail::GLI_FOURCC_DX10; |
||||
HeaderDesc.format.bpp = size(Image, BIT_PER_PIXEL); |
||||
HeaderDesc.format.redMask = 0; |
||||
HeaderDesc.format.greenMask = 0; |
||||
HeaderDesc.format.blueMask = 0; |
||||
HeaderDesc.format.alphaMask = 0; |
||||
HeaderDesc.surfaceFlags = loader_dds9::detail::GLI_DDSCAPS_TEXTURE | (Image.levels() > 1 ? loader_dds9::detail::GLI_DDSCAPS_MIPMAP : 0); |
||||
HeaderDesc.cubemapFlags = 0; |
||||
FileOut.write((char*)&HeaderDesc, sizeof(HeaderDesc)); |
||||
|
||||
detail::ddsHeader10 HeaderDesc10; |
||||
HeaderDesc10.arraySize = 1; |
||||
HeaderDesc10.resourceDimension = detail::D3D10_RESOURCE_DIMENSION_TEXTURE2D; |
||||
HeaderDesc10.miscFlag = 0;//Image.levels() > 0 ? detail::D3D10_RESOURCE_MISC_GENERATE_MIPS : 0; |
||||
HeaderDesc10.dxgiFormat = detail::format_gli2dds_cast(Image.format()); |
||||
HeaderDesc10.reserved = 0; |
||||
|
||||
FileOut.write((char*)&HeaderDesc10, sizeof(HeaderDesc10)); |
||||
|
||||
for(gli::texture2D::level_type Level = 0; Level < Image.levels(); ++Level) |
||||
{ |
||||
gli::texture2D::size_type ImageSize = size(Image[Level], gli::LINEAR_SIZE); |
||||
FileOut.write((char*)(Image[Level].data()), ImageSize); |
||||
} |
||||
|
||||
if(FileOut.fail() || FileOut.bad()) |
||||
return; |
||||
|
||||
FileOut.close (); |
||||
} |
||||
|
||||
}//namespace loader_dds10 |
||||
}//namespace gtx |
||||
}//namespace gli |
||||
@ -0,0 +1,39 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2010-09-08
|
||||
// Updated : 2010-09-27
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/gtx/loader_dds9.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_GTX_LOADER_DDS9_INCLUDED |
||||
#define GLI_GTX_LOADER_DDS9_INCLUDED |
||||
|
||||
#include "../gli.hpp" |
||||
#include <fstream> |
||||
|
||||
namespace gli{ |
||||
namespace gtx{ |
||||
namespace loader_dds9 |
||||
{ |
||||
texture2D loadDDS9( |
||||
std::string const & Filename); |
||||
|
||||
void saveDDS9( |
||||
texture2D const & Texture,
|
||||
std::string const & Filename); |
||||
|
||||
void saveTextureCubeDDS9( |
||||
textureCube const & Texture,
|
||||
std::string const & Filename); |
||||
|
||||
}//namespace loader_dds9
|
||||
}//namespace gtx
|
||||
}//namespace gli
|
||||
|
||||
namespace gli{using namespace gtx::loader_dds9;} |
||||
|
||||
#include "loader_dds9.inl" |
||||
|
||||
#endif//GLI_GTX_LOADER_DDS9_INCLUDED
|
||||
@ -0,0 +1,790 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2010-09-08 |
||||
// Updated : 2010-09-27 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/gtx/loader_dds9.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace gli{ |
||||
namespace gtx{ |
||||
namespace loader_dds9{ |
||||
namespace detail |
||||
{ |
||||
// DDS Documentation |
||||
/* |
||||
http://msdn.microsoft.com/en-us/library/bb943991(VS.85).aspx#File_Layout1 |
||||
http://msdn.microsoft.com/en-us/library/bb943992.aspx |
||||
*/ |
||||
|
||||
#define GLI_MAKEFOURCC(ch0, ch1, ch2, ch3) \ |
||||
(glm::uint32)( \ |
||||
(((glm::uint32)(glm::uint8)(ch3) << 24) & 0xFF000000) | \ |
||||
(((glm::uint32)(glm::uint8)(ch2) << 16) & 0x00FF0000) | \ |
||||
(((glm::uint32)(glm::uint8)(ch1) << 8) & 0x0000FF00) | \ |
||||
((glm::uint32)(glm::uint8)(ch0) & 0x000000FF) ) |
||||
|
||||
//enum dds_format |
||||
//{ |
||||
// GLI_D3DFMT_R8G8B8 = 20, |
||||
// GLI_D3DFMT_A8R8G8B8 = 21, |
||||
// GLI_D3DFMT_X8R8G8B8 = 22, |
||||
// GLI_D3DFMT_A8 = 28, |
||||
// GLI_D3DFMT_A2B10G10R10 = 31, |
||||
// GLI_D3DFMT_A8B8G8R8 = 32, |
||||
// GLI_D3DFMT_X8B8G8R8 = 33, |
||||
// GLI_D3DFMT_G16R16 = 34, |
||||
// GLI_D3DFMT_A2R10G10B10 = 35, |
||||
// GLI_D3DFMT_A16B16G16R16 = 36, |
||||
|
||||
// GLI_D3DFMT_L8 = 50, |
||||
// GLI_D3DFMT_A8L8 = 51, |
||||
|
||||
// GLI_D3DFMT_DXT1 = GLI_MAKEFOURCC('D', 'X', 'T', '1'), |
||||
// GLI_D3DFMT_DXT2 = GLI_MAKEFOURCC('D', 'X', 'T', '2'), |
||||
// GLI_D3DFMT_DXT3 = GLI_MAKEFOURCC('D', 'X', 'T', '3'), |
||||
// GLI_D3DFMT_DXT4 = GLI_MAKEFOURCC('D', 'X', 'T', '4'), |
||||
// GLI_D3DFMT_DXT5 = GLI_MAKEFOURCC('D', 'X', 'T', '5'), |
||||
// GLI_D3DFMT_DX10 = GLI_MAKEFOURCC('D', 'X', '1', '0'), |
||||
|
||||
// GLI_D3DFMT_D32 = 71, |
||||
// GLI_D3DFMT_D24S8 = 75, |
||||
// GLI_D3DFMT_D24X8 = 77, |
||||
// GLI_D3DFMT_D16 = 80, |
||||
// GLI_D3DFMT_L16 = 81, |
||||
// GLI_D3DFMT_D32F_LOCKABLE = 82, |
||||
// GLI_D3DFMT_D24FS8 = 83, |
||||
|
||||
// GLI_D3DFMT_R16F = 111, |
||||
// GLI_D3DFMT_G16R16F = 112, |
||||
// GLI_D3DFMT_A16B16G16R16F = 113, |
||||
|
||||
// GLI_D3DFMT_R32F = 114, |
||||
// GLI_D3DFMT_G32R32F = 115, |
||||
// GLI_D3DFMT_A32B32G32R32F = 116 |
||||
//}; |
||||
|
||||
enum ddsCubemapflag |
||||
{ |
||||
GLI_DDSCAPS2_CUBEMAP = 0x00000200, |
||||
GLI_DDSCAPS2_CUBEMAP_POSITIVEX = 0x00000400, |
||||
GLI_DDSCAPS2_CUBEMAP_NEGATIVEX = 0x00000800, |
||||
GLI_DDSCAPS2_CUBEMAP_POSITIVEY = 0x00001000, |
||||
GLI_DDSCAPS2_CUBEMAP_NEGATIVEY = 0x00002000, |
||||
GLI_DDSCAPS2_CUBEMAP_POSITIVEZ = 0x00004000, |
||||
GLI_DDSCAPS2_CUBEMAP_NEGATIVEZ = 0x00008000, |
||||
GLI_DDSCAPS2_VOLUME = 0x00200000 |
||||
}; |
||||
|
||||
enum ddsSurfaceflag |
||||
{ |
||||
GLI_DDSCAPS_COMPLEX = 0x00000008, |
||||
GLI_DDSCAPS_MIPMAP = 0x00400000, |
||||
GLI_DDSCAPS_TEXTURE = 0x00001000 |
||||
}; |
||||
|
||||
struct ddsPixelFormat |
||||
{ |
||||
glm::uint32 size; // 32 |
||||
glm::uint32 flags; |
||||
glm::uint32 fourCC; |
||||
glm::uint32 bpp; |
||||
glm::uint32 redMask; |
||||
glm::uint32 greenMask; |
||||
glm::uint32 blueMask; |
||||
glm::uint32 alphaMask; |
||||
}; |
||||
|
||||
struct ddsHeader |
||||
{ |
||||
glm::uint32 size; |
||||
glm::uint32 flags; |
||||
glm::uint32 height; |
||||
glm::uint32 width; |
||||
glm::uint32 pitch; |
||||
glm::uint32 depth; |
||||
glm::uint32 mipMapLevels; |
||||
glm::uint32 reserved1[11]; |
||||
ddsPixelFormat format; |
||||
glm::uint32 surfaceFlags; |
||||
glm::uint32 cubemapFlags; |
||||
glm::uint32 reserved2[3]; |
||||
}; |
||||
|
||||
glm::uint32 const GLI_D3DFMT_R8G8B8 = 20; |
||||
glm::uint32 const GLI_D3DFMT_A8R8G8B8 = 21; |
||||
glm::uint32 const GLI_D3DFMT_X8R8G8B8 = 22; |
||||
glm::uint32 const GLI_D3DFMT_R5G6B5 = 23; |
||||
glm::uint32 const GLI_D3DFMT_X1R5G5B5 = 24; |
||||
glm::uint32 const GLI_D3DFMT_A1R5G5B5 = 25; |
||||
glm::uint32 const GLI_D3DFMT_A4R4G4B4 = 26; |
||||
glm::uint32 const GLI_D3DFMT_X4R4G4B4 = 30; |
||||
glm::uint32 const GLI_D3DFMT_A2B10G10R10 = 31; |
||||
glm::uint32 const GLI_D3DFMT_A8B8G8R8 = 32; |
||||
glm::uint32 const GLI_D3DFMT_X8B8G8R8 = 33; |
||||
glm::uint32 const GLI_D3DFMT_G16R16 = 34; |
||||
glm::uint32 const GLI_D3DFMT_A2R10G10B10 = 35; |
||||
glm::uint32 const GLI_D3DFMT_A16B16G16R16 = 36; |
||||
|
||||
|
||||
glm::uint32 const GLI_FOURCC_DXT1 = GLI_MAKEFOURCC('D', 'X', 'T', '1'); |
||||
glm::uint32 const GLI_FOURCC_DXT2 = GLI_MAKEFOURCC('D', 'X', 'T', '2'); |
||||
glm::uint32 const GLI_FOURCC_DXT3 = GLI_MAKEFOURCC('D', 'X', 'T', '3'); |
||||
glm::uint32 const GLI_FOURCC_DXT4 = GLI_MAKEFOURCC('D', 'X', 'T', '4'); |
||||
glm::uint32 const GLI_FOURCC_DXT5 = GLI_MAKEFOURCC('D', 'X', 'T', '5'); |
||||
glm::uint32 const GLI_FOURCC_ATI1 = GLI_MAKEFOURCC('A', 'T', 'I', '1'); // ATI1 |
||||
glm::uint32 const GLI_FOURCC_ATI2 = GLI_MAKEFOURCC('A', 'T', 'I', '2'); // ATI2 (AKA 3Dc) |
||||
glm::uint32 const GLI_FOURCC_DX10 = GLI_MAKEFOURCC('D', 'X', '1', '0'); |
||||
glm::uint32 const GLI_FOURCC_BC4U = GLI_MAKEFOURCC('B', 'C', '4', 'U'); |
||||
glm::uint32 const GLI_FOURCC_BC4S = GLI_MAKEFOURCC('B', 'C', '4', 'S'); |
||||
glm::uint32 const GLI_FOURCC_BC5U = GLI_MAKEFOURCC('B', 'C', '5', 'U'); |
||||
glm::uint32 const GLI_FOURCC_BC5S = GLI_MAKEFOURCC('B', 'C', '5', 'S'); |
||||
glm::uint32 const GLI_FOURCC_BC6H = GLI_MAKEFOURCC('B', 'C', '6', 'H'); |
||||
glm::uint32 const GLI_FOURCC_BC7 = GLI_MAKEFOURCC('B', 'C', '7', 'U'); |
||||
|
||||
glm::uint32 const GLI_FOURCC_R16F = 0x0000006f; // 16-bit float Red |
||||
glm::uint32 const GLI_FOURCC_G16R16F = 0x00000070; // 16-bit float Red/Green |
||||
glm::uint32 const GLI_FOURCC_A16B16G16R16F = 0x00000071; // 16-bit float RGBA |
||||
glm::uint32 const GLI_FOURCC_R32F = 0x00000072; // 32-bit float Red |
||||
glm::uint32 const GLI_FOURCC_G32R32F = 0x00000073; // 32-bit float Red/Green |
||||
glm::uint32 const GLI_FOURCC_A32B32G32R32F = 0x00000074; // 32-bit float RGBA |
||||
|
||||
glm::uint32 const GLI_DDPF_ALPHAPIXELS = 0x00000001; // The surface has alpha channel information in the pixel format. |
||||
glm::uint32 const GLI_DDPF_ALPHA = 0x00000002; // The pixel format contains alpha only information |
||||
glm::uint32 const GLI_DDPF_FOURCC = 0x00000004; // The FourCC code is valid. |
||||
glm::uint32 const GLI_DDPF_RGB = 0x00000040; // The RGB data in the pixel format structure is valid. |
||||
//glm::uint32 const GLI_DDPF_COMPRESSED = 0x00000080; // The surface will accept pixel data in the format specified and compress it during the write. |
||||
//glm::uint32 const GLI_DDPF_RGBTOYUV = 0x00000100; // The surface will accept RGB data and translate it during the write to YUV data. |
||||
glm::uint32 const GLI_DDPF_YUV = 0x00000200; // Pixel format is YUV - YUV data in pixel format struct is valid. |
||||
//glm::uint32 const GLI_DDPF_ZBUFFER = 0x00000400; // Pixel format is a z buffer only surface |
||||
//glm::uint32 const GLI_DDPF_ZPIXELS = 0x00002000; // The surface contains Z information in the pixels |
||||
//glm::uint32 const GLI_DDPF_STENCILBUFFER = 0x00004000; // The surface contains stencil information along with Z |
||||
//glm::uint32 const GLI_DDPF_ALPHAPREMULT = 0x00008000; // Premultiplied alpha format -- the color components have been premultiplied by the alpha component. |
||||
glm::uint32 const GLI_DDPF_LUMINANCE = 0x00020000; // Luminance data in the pixel format is valid. |
||||
//glm::uint32 const GLI_DDPF_BUMPLUMINANCE = 0x00040000; // Use this flag for luminance-only or luminance+alpha surfaces, the bit depth is then ddpf.dwLuminanceBitCount. |
||||
//glm::uint32 const GLI_DDPF_BUMPDUDV = 0x00080000; // Bump map dUdV data in the pixel format is valid. |
||||
|
||||
glm::uint32 const GLI_DDSD_CAPS = 0x00000001; |
||||
glm::uint32 const GLI_DDSD_HEIGHT = 0x00000002; |
||||
glm::uint32 const GLI_DDSD_WIDTH = 0x00000004; |
||||
glm::uint32 const GLI_DDSD_PITCH = 0x00000008; |
||||
glm::uint32 const GLI_DDSD_PIXELFORMAT = 0x00001000; |
||||
glm::uint32 const GLI_DDSD_MIPMAPCOUNT = 0x00020000; |
||||
glm::uint32 const GLI_DDSD_LINEARSIZE = 0x00080000; |
||||
glm::uint32 const GLI_DDSD_DEPTH = 0x00800000; |
||||
|
||||
struct DDLoader |
||||
{ |
||||
glm::uint32 BlockSize; |
||||
glm::uint32 BPP; |
||||
gli::format Format; |
||||
}; |
||||
|
||||
enum format_type |
||||
{ |
||||
FORMAT_TYPE_NULL, |
||||
FORMAT_RGBA, |
||||
FORMAT_FOURCC |
||||
}; |
||||
|
||||
inline glm::uint32 getFormatFourCC(gli::texture2D const & Image) |
||||
{ |
||||
switch(Image.format()) |
||||
{ |
||||
default: |
||||
return 0; |
||||
case DXT1: |
||||
return GLI_FOURCC_DXT1; |
||||
case DXT3: |
||||
return GLI_FOURCC_DXT3; |
||||
case DXT5: |
||||
return GLI_FOURCC_DXT5; |
||||
case ATI1N_UNORM: |
||||
case ATI1N_SNORM: |
||||
case ATI2N_UNORM: |
||||
case ATI2N_SNORM: |
||||
case BP_UF16: |
||||
case BP_SF16: |
||||
case BP: |
||||
return GLI_FOURCC_DX10; |
||||
case R16F: |
||||
return GLI_FOURCC_R16F; |
||||
case RG16F: |
||||
return GLI_FOURCC_G16R16F; |
||||
case RGBA16F: |
||||
return GLI_FOURCC_A16B16G16R16F; |
||||
case R32F: |
||||
return GLI_FOURCC_R32F; |
||||
case RG32F: |
||||
return GLI_FOURCC_G32R32F; |
||||
case RGBA32F: |
||||
return GLI_FOURCC_A32B32G32R32F; |
||||
} |
||||
} |
||||
|
||||
inline glm::uint32 getFormatBlockSize(gli::texture2D const & Image) |
||||
{ |
||||
switch(Image.format()) |
||||
{ |
||||
default: |
||||
return 0; |
||||
case DXT1: |
||||
return 8; |
||||
case DXT3: |
||||
return 16; |
||||
case DXT5: |
||||
return 16; |
||||
case ATI1N_UNORM: |
||||
case ATI1N_SNORM: |
||||
return 16; |
||||
case ATI2N_UNORM: |
||||
case ATI2N_SNORM: |
||||
return 32; |
||||
case BP_UF16: |
||||
case BP_SF16: |
||||
return 32; |
||||
case BP: |
||||
return 32; |
||||
case R16F: |
||||
return 2; |
||||
case RG16F: |
||||
return 4; |
||||
case RGBA16F: |
||||
return 8; |
||||
case R32F: |
||||
return 4; |
||||
case RG32F: |
||||
return 8; |
||||
case RGBA32F: |
||||
return 16; |
||||
} |
||||
} |
||||
|
||||
inline glm::uint32 getFormatFlags(gli::texture2D const & Image) |
||||
{ |
||||
glm::uint32 Result = 0; |
||||
|
||||
switch(Image.format()) |
||||
{ |
||||
default: |
||||
break; |
||||
case R8U: |
||||
case RG8U: |
||||
case RGB8U: |
||||
case RGBA8U: |
||||
case R16U: |
||||
case RG16U: |
||||
case RGB16U: |
||||
case RGBA16U: |
||||
case R32U: |
||||
case RG32U: |
||||
case RGB32U: |
||||
case RGBA32U: |
||||
case R8I: |
||||
case RG8I: |
||||
case RGB8I: |
||||
case RGBA8I: |
||||
case R16I: |
||||
case RG16I: |
||||
case RGB16I: |
||||
case RGBA16I: |
||||
case R32I: |
||||
case RG32I: |
||||
case RGB32I: |
||||
case RGBA32I: |
||||
Result |= GLI_DDPF_RGB; |
||||
break; |
||||
case R16F: |
||||
case RG16F: |
||||
case RGB16F: |
||||
case RGBA16F: |
||||
case R32F: |
||||
case RG32F: |
||||
case RGB32F: |
||||
case RGBA32F: |
||||
case RGBE8: |
||||
case RGB9E5: |
||||
case RG11B10F: |
||||
case R5G6B5: |
||||
case RGBA4: |
||||
case RGB10A2: |
||||
case D16: |
||||
case D24X8: |
||||
case D24S8: |
||||
case D32F: |
||||
case D32FS8X24: |
||||
case DXT1: |
||||
case DXT3: |
||||
case DXT5: |
||||
case ATI1N_UNORM: |
||||
case ATI1N_SNORM: |
||||
case ATI2N_UNORM: |
||||
case ATI2N_SNORM: |
||||
case BP_UF16: |
||||
case BP_SF16: |
||||
case BP: |
||||
Result |= GLI_DDPF_FOURCC; |
||||
break; |
||||
}; |
||||
|
||||
return Result; |
||||
} |
||||
|
||||
inline glm::uint32 getFormatBPP(gli::texture2D const & Image) |
||||
{ |
||||
switch(Image.format()) |
||||
{ |
||||
default: |
||||
return 0; |
||||
case R8U: |
||||
case R8I: |
||||
return 8; |
||||
case RG8U: |
||||
case RG8I: |
||||
return 16; |
||||
case RGB8U: |
||||
case RGB8I: |
||||
return 24; |
||||
case RGBA8U: |
||||
case RGBA8I: |
||||
return 32; |
||||
case DXT1: |
||||
return 4; |
||||
case DXT3: |
||||
return 8; |
||||
case DXT5: |
||||
return 8; |
||||
case ATI1N_UNORM: |
||||
case ATI1N_SNORM: |
||||
return 4; |
||||
case ATI2N_UNORM: |
||||
case ATI2N_SNORM: |
||||
return 8; |
||||
case BP_UF16: |
||||
case BP_SF16: |
||||
return 8; |
||||
case BP: |
||||
return 8; |
||||
} |
||||
} |
||||
|
||||
inline bool isCompressed(gli::texture2D const & Image) |
||||
{ |
||||
switch(Image.format()) |
||||
{ |
||||
default: |
||||
return false; |
||||
case DXT1: |
||||
case DXT3: |
||||
case DXT5: |
||||
case ATI1N_UNORM: |
||||
case ATI1N_SNORM: |
||||
case ATI2N_UNORM: |
||||
case ATI2N_SNORM: |
||||
case BP_UF16: |
||||
case BP_SF16: |
||||
case BP: |
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
}//namespace detail |
||||
|
||||
inline texture2D loadDDS9 |
||||
( |
||||
std::string const & Filename |
||||
) |
||||
{ |
||||
std::ifstream FileIn(Filename.c_str(), std::ios::in | std::ios::binary); |
||||
if(FileIn.fail()) |
||||
return texture2D(); |
||||
|
||||
detail::ddsHeader SurfaceDesc; |
||||
char Magic[4]; |
||||
|
||||
//* Read magic number and check if valid .dds file |
||||
FileIn.read((char*)&Magic, sizeof(Magic)); |
||||
|
||||
assert(strncmp(Magic, "DDS ", 4) == 0); |
||||
|
||||
// Get the surface descriptor |
||||
FileIn.read((char*)&SurfaceDesc, sizeof(SurfaceDesc)); |
||||
|
||||
std::size_t Width = SurfaceDesc.width; |
||||
std::size_t Height = SurfaceDesc.height; |
||||
|
||||
//std::size_t Levels = glm::max(glm::highestBit(Width), glm::highestBit(Height)); |
||||
|
||||
detail::DDLoader Loader; |
||||
if(SurfaceDesc.format.flags & detail::GLI_DDPF_FOURCC) |
||||
{ |
||||
switch(SurfaceDesc.format.fourCC) |
||||
{ |
||||
case detail::GLI_FOURCC_DX10: |
||||
assert(0); |
||||
break; |
||||
case detail::GLI_FOURCC_DXT1: |
||||
Loader.BlockSize = 8; |
||||
Loader.Format = DXT1; |
||||
break; |
||||
case detail::GLI_FOURCC_DXT3: |
||||
Loader.BlockSize = 16; |
||||
Loader.Format = DXT3; |
||||
break; |
||||
case detail::GLI_FOURCC_DXT5: |
||||
Loader.BlockSize = 16; |
||||
Loader.Format = DXT5; |
||||
break; |
||||
case detail::GLI_FOURCC_R16F: |
||||
Loader.BlockSize = 2; |
||||
Loader.Format = R16F; |
||||
break; |
||||
case detail::GLI_FOURCC_G16R16F: |
||||
Loader.BlockSize = 4; |
||||
Loader.Format = RG16F; |
||||
break; |
||||
case detail::GLI_FOURCC_A16B16G16R16F: |
||||
Loader.BlockSize = 8; |
||||
Loader.Format = RGBA16F; |
||||
break; |
||||
case detail::GLI_FOURCC_R32F: |
||||
Loader.BlockSize = 4; |
||||
Loader.Format = R32F; |
||||
break; |
||||
case detail::GLI_FOURCC_G32R32F: |
||||
Loader.BlockSize = 8; |
||||
Loader.Format = RG32F; |
||||
break; |
||||
case detail::GLI_FOURCC_A32B32G32R32F: |
||||
Loader.BlockSize = 16; |
||||
Loader.Format = RGBA32F; |
||||
break; |
||||
|
||||
default: |
||||
assert(0); |
||||
return texture2D(); |
||||
} |
||||
} |
||||
else if(SurfaceDesc.format.flags & detail::GLI_DDPF_RGB) |
||||
{ |
||||
switch(SurfaceDesc.format.bpp) |
||||
{ |
||||
case 8: |
||||
Loader.BlockSize = 2; |
||||
Loader.Format = R8U; |
||||
break; |
||||
case 16: |
||||
Loader.BlockSize = 2; |
||||
Loader.Format = RG8U; |
||||
break; |
||||
case 24: |
||||
Loader.BlockSize = 3; |
||||
Loader.Format = RGB8U; |
||||
break; |
||||
case 32: |
||||
Loader.BlockSize = 4; |
||||
Loader.Format = RGBA8U; |
||||
break; |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
|
||||
} |
||||
|
||||
gli::format Format = Loader.Format; |
||||
|
||||
std::streamoff Curr = FileIn.tellg(); |
||||
FileIn.seekg(0, std::ios_base::end); |
||||
std::streamoff End = FileIn.tellg(); |
||||
FileIn.seekg(Curr, std::ios_base::beg); |
||||
|
||||
std::vector<glm::byte> Data(std::size_t(End - Curr), 0); |
||||
std::size_t Offset = 0; |
||||
|
||||
FileIn.read((char*)&Data[0], std::streamsize(Data.size())); |
||||
|
||||
//image Image(glm::min(MipMapCount, Levels));//SurfaceDesc.mipMapLevels); |
||||
std::size_t MipMapCount = (SurfaceDesc.flags & detail::GLI_DDSD_MIPMAPCOUNT) ? SurfaceDesc.mipMapLevels : 1; |
||||
//if(Loader.Format == DXT1 || Loader.Format == DXT3 || Loader.Format == DXT5) |
||||
// MipMapCount -= 2; |
||||
texture2D Image(MipMapCount); |
||||
for(std::size_t Level = 0; Level < Image.levels() && (Width || Height); ++Level) |
||||
{ |
||||
Width = glm::max(std::size_t(Width), std::size_t(1)); |
||||
Height = glm::max(std::size_t(Height), std::size_t(1)); |
||||
|
||||
std::size_t MipmapSize = 0; |
||||
if(Loader.Format == DXT1 || Loader.Format == DXT3 || Loader.Format == DXT5) |
||||
MipmapSize = ((Width + 3) >> 2) * ((Height + 3) >> 2) * Loader.BlockSize; |
||||
else |
||||
MipmapSize = Width * Height * Loader.BlockSize; |
||||
std::vector<glm::byte> MipmapData(MipmapSize, 0); |
||||
|
||||
memcpy(&MipmapData[0], &Data[0] + Offset, MipmapSize); |
||||
|
||||
image2D::dimensions_type Dimensions(Width, Height); |
||||
Image[Level] = image2D(Dimensions, Format, MipmapData); |
||||
|
||||
Offset += MipmapSize; |
||||
Width >>= 1; |
||||
Height >>= 1; |
||||
} |
||||
|
||||
return Image; |
||||
} |
||||
|
||||
inline textureCube loadTextureCubeDDS9 |
||||
( |
||||
std::string const & Filename |
||||
) |
||||
{ |
||||
std::ifstream FileIn(Filename.c_str(), std::ios::in | std::ios::binary); |
||||
if(FileIn.fail()) |
||||
return textureCube(); |
||||
|
||||
detail::ddsHeader SurfaceDesc; |
||||
char Magic[4]; |
||||
|
||||
//* Read magic number and check if valid .dds file |
||||
FileIn.read((char*)&Magic, sizeof(Magic)); |
||||
|
||||
assert(strncmp(Magic, "DDS ", 4) == 0); |
||||
|
||||
// Get the surface descriptor |
||||
FileIn.read((char*)&SurfaceDesc, sizeof(SurfaceDesc)); |
||||
|
||||
std::size_t Width = SurfaceDesc.width; |
||||
std::size_t Height = SurfaceDesc.height; |
||||
|
||||
//std::size_t Levels = glm::max(glm::highestBit(Width), glm::highestBit(Height)); |
||||
|
||||
detail::DDLoader Loader; |
||||
if(SurfaceDesc.format.flags & detail::GLI_DDPF_FOURCC) |
||||
{ |
||||
switch(SurfaceDesc.format.fourCC) |
||||
{ |
||||
case detail::GLI_FOURCC_DX10: |
||||
assert(0); |
||||
break; |
||||
case detail::GLI_FOURCC_DXT1: |
||||
Loader.BlockSize = 8; |
||||
Loader.Format = DXT1; |
||||
break; |
||||
case detail::GLI_FOURCC_DXT3: |
||||
Loader.BlockSize = 16; |
||||
Loader.Format = DXT3; |
||||
break; |
||||
case detail::GLI_FOURCC_DXT5: |
||||
Loader.BlockSize = 16; |
||||
Loader.Format = DXT5; |
||||
break; |
||||
case detail::GLI_FOURCC_R16F: |
||||
Loader.BlockSize = 2; |
||||
Loader.Format = R16F; |
||||
break; |
||||
case detail::GLI_FOURCC_G16R16F: |
||||
Loader.BlockSize = 4; |
||||
Loader.Format = RG16F; |
||||
break; |
||||
case detail::GLI_FOURCC_A16B16G16R16F: |
||||
Loader.BlockSize = 8; |
||||
Loader.Format = RGBA16F; |
||||
break; |
||||
case detail::GLI_FOURCC_R32F: |
||||
Loader.BlockSize = 4; |
||||
Loader.Format = R32F; |
||||
break; |
||||
case detail::GLI_FOURCC_G32R32F: |
||||
Loader.BlockSize = 8; |
||||
Loader.Format = RG32F; |
||||
break; |
||||
case detail::GLI_FOURCC_A32B32G32R32F: |
||||
Loader.BlockSize = 16; |
||||
Loader.Format = RGBA32F; |
||||
break; |
||||
|
||||
default: |
||||
assert(0); |
||||
return textureCube(); |
||||
} |
||||
} |
||||
else if(SurfaceDesc.format.flags & detail::GLI_DDPF_RGB) |
||||
{ |
||||
switch(SurfaceDesc.format.bpp) |
||||
{ |
||||
case 8: |
||||
Loader.BlockSize = 2; |
||||
Loader.Format = R8U; |
||||
break; |
||||
case 16: |
||||
Loader.BlockSize = 2; |
||||
Loader.Format = RG8U; |
||||
break; |
||||
case 24: |
||||
Loader.BlockSize = 3; |
||||
Loader.Format = RGB8U; |
||||
break; |
||||
case 32: |
||||
Loader.BlockSize = 4; |
||||
Loader.Format = RGBA8U; |
||||
break; |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
|
||||
} |
||||
|
||||
gli::format Format = Loader.Format; |
||||
|
||||
std::streamoff Curr = FileIn.tellg(); |
||||
FileIn.seekg(0, std::ios_base::end); |
||||
std::streamoff End = FileIn.tellg(); |
||||
FileIn.seekg(Curr, std::ios_base::beg); |
||||
|
||||
std::vector<glm::byte> Data(std::size_t(End - Curr), 0); |
||||
std::size_t Offset = 0; |
||||
|
||||
FileIn.read((char*)&Data[0], std::streamsize(Data.size())); |
||||
|
||||
//image Image(glm::min(MipMapCount, Levels));//SurfaceDesc.mipMapLevels); |
||||
std::size_t MipMapCount = (SurfaceDesc.flags & detail::GLI_DDSD_MIPMAPCOUNT) ? SurfaceDesc.mipMapLevels : 1; |
||||
//if(Loader.Format == DXT1 || Loader.Format == DXT3 || Loader.Format == DXT5) |
||||
// MipMapCount -= 2; |
||||
textureCube Texture(MipMapCount); |
||||
|
||||
for(textureCube::size_type Face = 0; Face < FACE_MAX; ++Face) |
||||
{ |
||||
Width = SurfaceDesc.width; |
||||
Height = SurfaceDesc.height; |
||||
|
||||
for(textureCube::size_type Level = 0; Level < Texture.levels() && (Width || Height); ++Level) |
||||
{ |
||||
Width = glm::max(std::size_t(Width), std::size_t(1)); |
||||
Height = glm::max(std::size_t(Height), std::size_t(1)); |
||||
|
||||
std::size_t MipmapSize = 0; |
||||
if(Loader.Format == DXT1 || Loader.Format == DXT3 || Loader.Format == DXT5) |
||||
MipmapSize = ((Width + 3) >> 2) * ((Height + 3) >> 2) * Loader.BlockSize; |
||||
else |
||||
MipmapSize = Width * Height * Loader.BlockSize; |
||||
std::vector<glm::byte> MipmapData(MipmapSize, 0); |
||||
|
||||
memcpy(&MipmapData[0], &Data[0] + Offset, MipmapSize); |
||||
|
||||
textureCube::dimensions_type Dimensions(Width, Height); |
||||
Texture[textureCube::face_type(Face)][Level] = image2D(Dimensions, Format, MipmapData); |
||||
|
||||
Offset += MipmapSize; |
||||
Width >>= 1; |
||||
Height >>= 1; |
||||
} |
||||
} |
||||
|
||||
return Texture; |
||||
} |
||||
|
||||
inline void saveDDS9 |
||||
( |
||||
texture2D const & Texture, |
||||
std::string const & Filename |
||||
) |
||||
{ |
||||
std::ofstream FileOut(Filename.c_str(), std::ios::out | std::ios::binary); |
||||
if (!FileOut) |
||||
return; |
||||
|
||||
char const * Magic = "DDS "; |
||||
FileOut.write((char*)Magic, sizeof(char) * 4); |
||||
|
||||
glm::uint32 Caps = detail::GLI_DDSD_CAPS | detail::GLI_DDSD_HEIGHT | detail::GLI_DDSD_WIDTH | detail::GLI_DDSD_PIXELFORMAT; |
||||
|
||||
detail::ddsHeader SurfaceDesc; |
||||
SurfaceDesc.size = sizeof(detail::ddsHeader); |
||||
SurfaceDesc.flags = Caps | (detail::isCompressed(Texture) ? detail::GLI_DDSD_LINEARSIZE : detail::GLI_DDSD_PITCH) | (Texture.levels() > 1 ? detail::GLI_DDSD_MIPMAPCOUNT : 0); //659463; |
||||
SurfaceDesc.width = Texture[0].dimensions().x; |
||||
SurfaceDesc.height = Texture[0].dimensions().y; |
||||
SurfaceDesc.pitch = loader_dds9::detail::isCompressed(Texture) ? size(Texture, LINEAR_SIZE) : 32; |
||||
SurfaceDesc.depth = 0; |
||||
SurfaceDesc.mipMapLevels = glm::uint32(Texture.levels()); |
||||
SurfaceDesc.format.size = sizeof(detail::ddsPixelFormat); |
||||
SurfaceDesc.format.flags = detail::getFormatFlags(Texture); |
||||
SurfaceDesc.format.fourCC = detail::getFormatFourCC(Texture); |
||||
SurfaceDesc.format.bpp = detail::getFormatBPP(Texture); |
||||
SurfaceDesc.format.redMask = 0; |
||||
SurfaceDesc.format.greenMask = 0; |
||||
SurfaceDesc.format.blueMask = 0; |
||||
SurfaceDesc.format.alphaMask = 0; |
||||
SurfaceDesc.surfaceFlags = detail::GLI_DDSCAPS_TEXTURE | (Texture.levels() > 1 ? detail::GLI_DDSCAPS_MIPMAP : 0); |
||||
SurfaceDesc.cubemapFlags = 0; |
||||
|
||||
FileOut.write((char*)&SurfaceDesc, sizeof(SurfaceDesc)); |
||||
|
||||
for(texture2D::level_type Level = 0; Level < Texture.levels(); ++Level) |
||||
{ |
||||
texture2D::size_type ImageSize = size(Texture[Level], gli::LINEAR_SIZE); |
||||
FileOut.write((char*)(Texture[Level].data()), ImageSize); |
||||
} |
||||
|
||||
if(FileOut.fail() || FileOut.bad()) |
||||
return; |
||||
|
||||
FileOut.close (); |
||||
} |
||||
|
||||
inline void saveTextureCubeDDS9 |
||||
( |
||||
textureCube const & Texture, |
||||
std::string const & Filename |
||||
) |
||||
{ |
||||
std::ofstream FileOut(Filename.c_str(), std::ios::out | std::ios::binary); |
||||
if (!FileOut || Texture.empty()) |
||||
return; |
||||
|
||||
char const * Magic = "DDS "; |
||||
FileOut.write((char*)Magic, sizeof(char) * 4); |
||||
|
||||
glm::uint32 Caps = detail::GLI_DDSD_CAPS | detail::GLI_DDSD_HEIGHT | detail::GLI_DDSD_WIDTH | detail::GLI_DDSD_PIXELFORMAT | detail::GLI_DDSCAPS_COMPLEX; |
||||
|
||||
detail::ddsHeader SurfaceDesc; |
||||
SurfaceDesc.size = sizeof(detail::ddsHeader); |
||||
SurfaceDesc.flags = Caps | (detail::isCompressed(Texture[POSITIVE_X]) ? detail::GLI_DDSD_LINEARSIZE : detail::GLI_DDSD_PITCH) | (Texture.levels() > 1 ? detail::GLI_DDSD_MIPMAPCOUNT : 0); //659463; |
||||
SurfaceDesc.width = Texture[POSITIVE_X][0].dimensions().x; |
||||
SurfaceDesc.height = Texture[POSITIVE_X][0].dimensions().y; |
||||
SurfaceDesc.pitch = loader_dds9::detail::isCompressed(Texture[POSITIVE_X]) ? size(Texture[POSITIVE_X], LINEAR_SIZE) : 32; |
||||
SurfaceDesc.depth = 0; |
||||
SurfaceDesc.mipMapLevels = glm::uint32(Texture.levels()); |
||||
SurfaceDesc.format.size = sizeof(detail::ddsPixelFormat); |
||||
SurfaceDesc.format.flags = detail::getFormatFlags(Texture[POSITIVE_X]); |
||||
SurfaceDesc.format.fourCC = detail::getFormatFourCC(Texture[POSITIVE_X]); |
||||
SurfaceDesc.format.bpp = detail::getFormatBPP(Texture[POSITIVE_X]); |
||||
SurfaceDesc.format.redMask = 0; |
||||
SurfaceDesc.format.greenMask = 0; |
||||
SurfaceDesc.format.blueMask = 0; |
||||
SurfaceDesc.format.alphaMask = 0; |
||||
SurfaceDesc.surfaceFlags = detail::GLI_DDSCAPS_TEXTURE | (Texture.levels() > 1 ? detail::GLI_DDSCAPS_MIPMAP : 0); |
||||
SurfaceDesc.cubemapFlags = |
||||
detail::GLI_DDSCAPS2_CUBEMAP | detail::GLI_DDSCAPS2_CUBEMAP_POSITIVEX | detail::GLI_DDSCAPS2_CUBEMAP_NEGATIVEX | detail::GLI_DDSCAPS2_CUBEMAP_POSITIVEY | detail::GLI_DDSCAPS2_CUBEMAP_NEGATIVEY | detail::GLI_DDSCAPS2_CUBEMAP_POSITIVEZ | detail::GLI_DDSCAPS2_CUBEMAP_NEGATIVEZ; |
||||
|
||||
FileOut.write((char*)&SurfaceDesc, sizeof(SurfaceDesc)); |
||||
|
||||
for(textureCube::size_type Face = 0; Face < FACE_MAX; ++Face) |
||||
for(texture2D::level_type Level = 0; Level < Texture.levels(); ++Level) |
||||
{ |
||||
texture2D::size_type ImageSize = size(Texture[textureCube::face_type(Face)][Level], gli::LINEAR_SIZE); |
||||
FileOut.write((char*)(Texture[textureCube::face_type(Face)][Level].data()), ImageSize); |
||||
} |
||||
|
||||
if(FileOut.fail() || FileOut.bad()) |
||||
return; |
||||
|
||||
FileOut.close (); |
||||
} |
||||
|
||||
}//namespace loader_dds9 |
||||
}//namespace gtx |
||||
}//namespace gli |
||||
@ -0,0 +1,36 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2010-09-08
|
||||
// Updated : 2010-09-27
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/gtx/loader_tga.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_GTX_LOADER_TGA_INCLUDED |
||||
#define GLI_GTX_LOADER_TGA_INCLUDED |
||||
|
||||
#include "../gli.hpp" |
||||
#include <string> |
||||
#include <fstream> |
||||
|
||||
namespace gli{ |
||||
namespace gtx{ |
||||
namespace loader_tga |
||||
{ |
||||
texture2D loadTGA( |
||||
std::string const & Filename); |
||||
|
||||
void saveTGA( |
||||
texture2D const & Image,
|
||||
std::string const & Filename); |
||||
|
||||
}//namespace loader_tga
|
||||
}//namespace gtx
|
||||
}//namespace gli
|
||||
|
||||
namespace gli{using namespace gtx::loader_tga;} |
||||
|
||||
#include "loader_tga.inl" |
||||
|
||||
#endif//GLI_GTX_LOADER_TGA_INCLUDED
|
||||
@ -0,0 +1,159 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2010-09-08 |
||||
// Updated : 2010-09-27 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/gtx/loader_tga.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace gli{ |
||||
namespace gtx{ |
||||
namespace loader_tga |
||||
{ |
||||
inline texture2D loadTGA |
||||
( |
||||
std::string const & Filename |
||||
) |
||||
{ |
||||
std::ifstream FileIn(Filename.c_str(), std::ios::in | std::ios::binary); |
||||
if(!FileIn) |
||||
return texture2D(); |
||||
|
||||
unsigned char IdentificationFieldSize; |
||||
unsigned char ColorMapType; |
||||
unsigned char ImageType; |
||||
unsigned short ColorMapOrigin; |
||||
unsigned short ColorMapLength; |
||||
unsigned char ColorMapEntrySize; |
||||
unsigned short OriginX; |
||||
unsigned short OriginY; |
||||
unsigned short Width; |
||||
unsigned short Height; |
||||
unsigned char TexelSize; |
||||
unsigned char Descriptor; |
||||
|
||||
FileIn.read((char*)&IdentificationFieldSize, sizeof(IdentificationFieldSize)); |
||||
FileIn.read((char*)&ColorMapType, sizeof(ColorMapType)); |
||||
FileIn.read((char*)&ImageType, sizeof(ImageType)); |
||||
FileIn.read((char*)&ColorMapOrigin, sizeof(ColorMapOrigin)); |
||||
FileIn.read((char*)&ColorMapLength, sizeof(ColorMapLength)); |
||||
FileIn.read((char*)&ColorMapEntrySize, sizeof(ColorMapEntrySize)); |
||||
FileIn.read((char*)&OriginX, sizeof(OriginX)); |
||||
FileIn.read((char*)&OriginY, sizeof(OriginY)); |
||||
FileIn.read((char*)&Width, sizeof(Width)); |
||||
FileIn.read((char*)&Height, sizeof(Height)); |
||||
FileIn.read((char*)&TexelSize, sizeof(TexelSize)); |
||||
FileIn.read((char*)&Descriptor, sizeof(Descriptor)); |
||||
|
||||
gli::format Format = gli::FORMAT_NULL; |
||||
if(TexelSize == 24) |
||||
Format = gli::RGB8U; |
||||
else if(TexelSize == 32) |
||||
Format = gli::RGBA8U; |
||||
else |
||||
assert(0); |
||||
|
||||
image2D Mipmap(texture2D::dimensions_type(Width, Height), Format); |
||||
|
||||
if (FileIn.fail() || FileIn.bad()) |
||||
{ |
||||
assert(0); |
||||
return texture2D(); |
||||
} |
||||
|
||||
switch(ImageType) |
||||
{ |
||||
default: |
||||
assert(0); |
||||
return texture2D(); |
||||
|
||||
case 2: |
||||
FileIn.seekg(18 + ColorMapLength, std::ios::beg); |
||||
|
||||
char* IdentificationField = new char[IdentificationFieldSize + 1]; |
||||
FileIn.read(IdentificationField, IdentificationFieldSize); |
||||
IdentificationField[IdentificationFieldSize] = '\0'; |
||||
delete[] IdentificationField; |
||||
|
||||
std::size_t DataSize = Width * Height * (TexelSize >> 3); |
||||
FileIn.read((char*)Mipmap.data(), std::streamsize(DataSize)); |
||||
|
||||
if(FileIn.fail() || FileIn.bad()) |
||||
return texture2D(); |
||||
break; |
||||
} |
||||
|
||||
FileIn.close(); |
||||
|
||||
texture2D Image(1); |
||||
Image[0] = Mipmap; |
||||
|
||||
// TGA images are saved in BGR or BGRA format. |
||||
if(TexelSize == 24) |
||||
Image.swizzle<glm::u8vec3>(glm::B, glm::G, glm::R, glm::A); |
||||
if(TexelSize == 32) |
||||
Image.swizzle<glm::u8vec4>(glm::B, glm::G, glm::R, glm::A); |
||||
|
||||
return Image; |
||||
} |
||||
|
||||
inline void saveTGA |
||||
( |
||||
gli::texture2D const & ImageIn, |
||||
std::string const & Filename |
||||
) |
||||
{ |
||||
std::ofstream FileOut(Filename.c_str(), std::ios::out | std::ios::binary); |
||||
if (!FileOut) |
||||
return; |
||||
|
||||
gli::texture2D Image = duplicate(ImageIn); |
||||
|
||||
unsigned char IdentificationFieldSize = 1; |
||||
unsigned char ColorMapType = 0; |
||||
unsigned char ImageType = 2; |
||||
unsigned short ColorMapOrigin = 0; |
||||
unsigned short ColorMapLength = 0; |
||||
unsigned char ColorMapEntrySize = 0; |
||||
unsigned short OriginX = 0; |
||||
unsigned short OriginY = 0; |
||||
unsigned short Width = Image[0].dimensions().x; |
||||
unsigned short Height = Image[0].dimensions().y; |
||||
unsigned char TexelSize = (unsigned char)(Image[0].value_size()); |
||||
unsigned char Descriptor = 0; |
||||
|
||||
if(TexelSize == 24) |
||||
Image.swizzle<glm::u8vec3>(glm::B, glm::G, glm::R, glm::A); |
||||
if(TexelSize == 32) |
||||
Image.swizzle<glm::u8vec4>(glm::B, glm::G, glm::R, glm::A); |
||||
|
||||
FileOut.write((char*)&IdentificationFieldSize, sizeof(IdentificationFieldSize)); |
||||
FileOut.write((char*)&ColorMapType, sizeof(ColorMapType)); |
||||
FileOut.write((char*)&ImageType, sizeof(ImageType)); |
||||
FileOut.write((char*)&ColorMapOrigin, sizeof(ColorMapOrigin)); |
||||
FileOut.write((char*)&ColorMapLength, sizeof(ColorMapLength)); |
||||
FileOut.write((char*)&ColorMapEntrySize, sizeof(ColorMapEntrySize)); |
||||
FileOut.write((char*)&OriginX, sizeof(OriginX)); |
||||
FileOut.write((char*)&OriginY, sizeof(OriginY)); |
||||
FileOut.write((char*)&Width, sizeof(Width)); |
||||
FileOut.write((char*)&Height, sizeof(Height)); |
||||
FileOut.write((char*)&TexelSize, sizeof(TexelSize)); |
||||
FileOut.write((char*)&Descriptor, sizeof(Descriptor)); |
||||
|
||||
if (FileOut.fail () || FileOut.bad ()) |
||||
return; |
||||
|
||||
FileOut.seekp(18 + ColorMapLength, std::ios::beg); |
||||
char* IdentificationField = new char[IdentificationFieldSize + 1]; |
||||
FileOut.write(IdentificationField, std::streamsize(IdentificationFieldSize)); |
||||
delete[] IdentificationField; |
||||
FileOut.write((char*)Image[0].data(), std::streamsize(Image[0].capacity())); |
||||
if(FileOut.fail() || FileOut.bad()) |
||||
return; |
||||
|
||||
FileOut.close (); |
||||
} |
||||
}//namespace loader_tga |
||||
}//namespace gtx |
||||
}//namespace gli |
||||
@ -0,0 +1,27 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2010-01-09
|
||||
// Updated : 2010-01-09
|
||||
// Licence : This source is under MIT License
|
||||
// File : gli/gtx/wavelet.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLI_GTX_WAVELET_INCLUDED |
||||
#define GLI_GTX_WAVELET_INCLUDED |
||||
|
||||
namespace gli{ |
||||
namespace gtx{ |
||||
namespace wavelet |
||||
{ |
||||
|
||||
|
||||
}//namespace wavelet
|
||||
}//namespace gtx
|
||||
}//namespace gli
|
||||
|
||||
namespace gli{using namespace gtx::wavelet;} |
||||
|
||||
#include "wavelet.inl" |
||||
|
||||
#endif//GLI_GTX_WAVELET_INCLUDED
|
||||
@ -0,0 +1,8 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Image Copyright (c) 2008 - 2011 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2010-01-09 |
||||
// Updated : 2010-01-09 |
||||
// Licence : This source is under MIT License |
||||
// File : gli/gtx/wavelet.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
Loading…
Reference in New Issue