drewcassidy/nvidia-texture-tools
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge private branch.

Browse Source
This commit is contained in:
castano
2010-05-27 23:18:39 +00:00
parent e7f2d1e2bc
commit 51a4fe7e2d
15 changed files with 3558 additions and 3549 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/nvimage/BlockDXT.cpp
View File

@ -23,10 +23,10 @@
#include "BlockDXT.h" #include "BlockDXT.h"
#include <nvimage/ColorBlock.h> #include "ColorBlock.h"
#include <nvcore/Stream.h> #include "nvcore/Stream.h"
#include <nvcore/Containers.h> // swap #include "nvcore/Utils.h" // swap
using namespace nv; using namespace nv;

48
src/nvimage/ColorBlock.cpp
View File

@ -1,9 +1,11 @@
// This code is in the public domain -- castanyo@yahoo.es // This code is in the public domain -- castanyo@yahoo.es
#include <nvcore/Containers.h> // swap #include "ColorBlock.h"
#include <nvmath/Box.h> #include "Image.h"
#include <nvimage/ColorBlock.h>
#include <nvimage/Image.h> #include "nvmath/Box.h"
#include "nvcore/Utils.h" // swap
using namespace nv; using namespace nv;
@ -179,28 +181,28 @@ bool ColorBlock::isSingleColor() const
/// Returns true if the block has a single color, ignoring transparent pixels. /// Returns true if the block has a single color, ignoring transparent pixels.
bool ColorBlock::isSingleColorNoAlpha() const bool ColorBlock::isSingleColorNoAlpha() const
{ {
Color32 c; Color32 c;
int i; int i;
for(i = 0; i < 16; i++) for(i = 0; i < 16; i++)
{ {
if (m_color[i].a != 0) { if (m_color[i].a != 0) {
c = m_color[i]; c = m_color[i];
break; break;
} }
} }
Color32 mask(0xFF, 0xFF, 0xFF, 0x00); Color32 mask(0xFF, 0xFF, 0xFF, 0x00);
uint u = c.u & mask.u; uint u = c.u & mask.u;
for(; i < 16; i++) for(; i < 16; i++)
{ {
if (u != (m_color[i].u & mask.u)) if (u != (m_color[i].u & mask.u))
{ {
return false; return false;
} }
} }
return true; return true;
} }
*/ */

3
src/nvimage/ColorBlock.h
View File

@ -1,9 +1,10 @@
// This code is in the public domain -- castanyo@yahoo.es // This code is in the public domain -- castanyo@yahoo.es
#pragma once
#ifndef NV_IMAGE_COLORBLOCK_H #ifndef NV_IMAGE_COLORBLOCK_H
#define NV_IMAGE_COLORBLOCK_H #define NV_IMAGE_COLORBLOCK_H
#include <nvmath/Color.h> #include "nvmath/Color.h"
namespace nv namespace nv
{ {

108
src/nvimage/DirectDrawSurface.cpp
View File

@ -21,15 +21,15 @@
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE. // OTHER DEALINGS IN THE SOFTWARE.
#include <nvimage/DirectDrawSurface.h> #include "DirectDrawSurface.h"
#include <nvimage/ColorBlock.h> #include "ColorBlock.h"
#include <nvimage/Image.h> #include "Image.h"
#include <nvimage/BlockDXT.h> #include "BlockDXT.h"
#include <nvimage/PixelFormat.h> #include "PixelFormat.h"
#include <nvcore/Debug.h> #include "nvcore/Debug.h"
#include <nvcore/Containers.h> // max #include "nvcore/Utils.h" // max
#include <nvcore/StdStream.h> #include "nvcore/StdStream.h"
#include <string.h> // memset #include <string.h> // memset
@ -469,57 +469,57 @@ namespace nv
/* Not used! /* Not used!
namespace namespace
{ {
struct FormatDescriptor struct FormatDescriptor
{ {
uint format; uint format;
uint bitcount; uint bitcount;
uint rmask; uint rmask;
uint gmask; uint gmask;
uint bmask; uint bmask;
uint amask; uint amask;
}; };
static const FormatDescriptor s_d3dFormats[] = static const FormatDescriptor s_d3dFormats[] =
{ {
{ D3DFMT_R8G8B8, 24, 0xFF0000, 0xFF00, 0xFF, 0 }, { D3DFMT_R8G8B8, 24, 0xFF0000, 0xFF00, 0xFF, 0 },
{ D3DFMT_A8R8G8B8, 32, 0xFF0000, 0xFF00, 0xFF, 0xFF000000 }, // DXGI_FORMAT_B8G8R8A8_UNORM { D3DFMT_A8R8G8B8, 32, 0xFF0000, 0xFF00, 0xFF, 0xFF000000 }, // DXGI_FORMAT_B8G8R8A8_UNORM
{ D3DFMT_X8R8G8B8, 32, 0xFF0000, 0xFF00, 0xFF, 0 }, // DXGI_FORMAT_B8G8R8X8_UNORM { D3DFMT_X8R8G8B8, 32, 0xFF0000, 0xFF00, 0xFF, 0 }, // DXGI_FORMAT_B8G8R8X8_UNORM
{ D3DFMT_R5G6B5, 16, 0xF800, 0x7E0, 0x1F, 0 }, // DXGI_FORMAT_B5G6R5_UNORM { D3DFMT_R5G6B5, 16, 0xF800, 0x7E0, 0x1F, 0 }, // DXGI_FORMAT_B5G6R5_UNORM
{ D3DFMT_X1R5G5B5, 16, 0x7C00, 0x3E0, 0x1F, 0 }, { D3DFMT_X1R5G5B5, 16, 0x7C00, 0x3E0, 0x1F, 0 },
{ D3DFMT_A1R5G5B5, 16, 0x7C00, 0x3E0, 0x1F, 0x8000 }, // DXGI_FORMAT_B5G5R5A1_UNORM { D3DFMT_A1R5G5B5, 16, 0x7C00, 0x3E0, 0x1F, 0x8000 }, // DXGI_FORMAT_B5G5R5A1_UNORM
{ D3DFMT_A4R4G4B4, 16, 0xF00, 0xF0, 0xF, 0xF000 }, { D3DFMT_A4R4G4B4, 16, 0xF00, 0xF0, 0xF, 0xF000 },
{ D3DFMT_R3G3B2, 8, 0xE0, 0x1C, 0x3, 0 }, { D3DFMT_R3G3B2, 8, 0xE0, 0x1C, 0x3, 0 },
{ D3DFMT_A8, 8, 0, 0, 0, 8 }, // DXGI_FORMAT_A8_UNORM { D3DFMT_A8, 8, 0, 0, 0, 8 }, // DXGI_FORMAT_A8_UNORM
{ D3DFMT_A8R3G3B2, 16, 0xE0, 0x1C, 0x3, 0xFF00 }, { D3DFMT_A8R3G3B2, 16, 0xE0, 0x1C, 0x3, 0xFF00 },
{ D3DFMT_X4R4G4B4, 16, 0xF00, 0xF0, 0xF, 0 }, { D3DFMT_X4R4G4B4, 16, 0xF00, 0xF0, 0xF, 0 },
{ D3DFMT_A2B10G10R10, 32, 0x3FF, 0xFFC00, 0x3FF00000, 0xC0000000 }, // DXGI_FORMAT_R10G10B10A2 { D3DFMT_A2B10G10R10, 32, 0x3FF, 0xFFC00, 0x3FF00000, 0xC0000000 }, // DXGI_FORMAT_R10G10B10A2
{ D3DFMT_A8B8G8R8, 32, 0xFF, 0xFF00, 0xFF0000, 0xFF000000 }, // DXGI_FORMAT_R8G8B8A8_UNORM { D3DFMT_A8B8G8R8, 32, 0xFF, 0xFF00, 0xFF0000, 0xFF000000 }, // DXGI_FORMAT_R8G8B8A8_UNORM
{ D3DFMT_X8B8G8R8, 32, 0xFF, 0xFF00, 0xFF0000, 0 }, { D3DFMT_X8B8G8R8, 32, 0xFF, 0xFF00, 0xFF0000, 0 },
{ D3DFMT_G16R16, 32, 0xFFFF, 0xFFFF0000, 0, 0 }, // DXGI_FORMAT_R16G16_UNORM { D3DFMT_G16R16, 32, 0xFFFF, 0xFFFF0000, 0, 0 }, // DXGI_FORMAT_R16G16_UNORM
{ D3DFMT_A2R10G10B10, 32, 0x3FF00000, 0xFFC00, 0x3FF, 0xC0000000 }, { D3DFMT_A2R10G10B10, 32, 0x3FF00000, 0xFFC00, 0x3FF, 0xC0000000 },
{ D3DFMT_L8, 8, 8, 0, 0, 0 }, // DXGI_FORMAT_R8_UNORM { D3DFMT_L8, 8, 8, 0, 0, 0 }, // DXGI_FORMAT_R8_UNORM
{ D3DFMT_L16, 16, 16, 0, 0, 0 }, // DXGI_FORMAT_R16_UNORM { D3DFMT_L16, 16, 16, 0, 0, 0 }, // DXGI_FORMAT_R16_UNORM
}; };
static const uint s_d3dFormatCount = sizeof(s_d3dFormats) / sizeof(s_d3dFormats[0]); static const uint s_d3dFormatCount = sizeof(s_d3dFormats) / sizeof(s_d3dFormats[0]);
static uint findD3D9Format(uint bitcount, uint rmask, uint gmask, uint bmask, uint amask) static uint findD3D9Format(uint bitcount, uint rmask, uint gmask, uint bmask, uint amask)
{ {
for (int i = 0; i < s_d3dFormatCount; i++) for (int i = 0; i < s_d3dFormatCount; i++)
{ {
if (s_d3dFormats[i].bitcount == bitcount && if (s_d3dFormats[i].bitcount == bitcount &&
s_d3dFormats[i].rmask == rmask && s_d3dFormats[i].rmask == rmask &&
s_d3dFormats[i].gmask == gmask && s_d3dFormats[i].gmask == gmask &&
s_d3dFormats[i].bmask == bmask && s_d3dFormats[i].bmask == bmask &&
s_d3dFormats[i].amask == amask) s_d3dFormats[i].amask == amask)
{ {
return s_d3dFormats[i].format; return s_d3dFormats[i].format;
} }
} }
return 0; return 0;
} }
} // nv namespace } // nv namespace
*/ */

1
src/nvimage/DirectDrawSurface.h
View File

@ -21,6 +21,7 @@
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE. // OTHER DEALINGS IN THE SOFTWARE.
#pragma once
#ifndef NV_IMAGE_DIRECTDRAWSURFACE_H #ifndef NV_IMAGE_DIRECTDRAWSURFACE_H
#define NV_IMAGE_DIRECTDRAWSURFACE_H #define NV_IMAGE_DIRECTDRAWSURFACE_H

26
src/nvimage/Filter.cpp
View File

@ -35,8 +35,10 @@
#include "Filter.h" #include "Filter.h"
#include <nvmath/Vector.h> // Vector4 #include "nvmath/Vector.h" // Vector4
#include <nvcore/Containers.h> // swap #include "nvcore/Utils.h" // swap
#include <string.h> // memset
using namespace nv; using namespace nv;
@ -360,17 +362,17 @@ void Kernel2::transpose()
void Kernel2::initLaplacian() void Kernel2::initLaplacian()
{ {
nvDebugCheck(m_windowSize == 3); nvDebugCheck(m_windowSize == 3);
// m_data[0] = -1; m_data[1] = -1; m_data[2] = -1; // m_data[0] = -1; m_data[1] = -1; m_data[2] = -1;
// m_data[3] = -1; m_data[4] = +8; m_data[5] = -1; // m_data[3] = -1; m_data[4] = +8; m_data[5] = -1;
// m_data[6] = -1; m_data[7] = -1; m_data[8] = -1; // m_data[6] = -1; m_data[7] = -1; m_data[8] = -1;
m_data[0] = +0; m_data[1] = -1; m_data[2] = +0; m_data[0] = +0; m_data[1] = -1; m_data[2] = +0;
m_data[3] = -1; m_data[4] = +4; m_data[5] = -1; m_data[3] = -1; m_data[4] = +4; m_data[5] = -1;
m_data[6] = +0; m_data[7] = -1; m_data[8] = +0; m_data[6] = +0; m_data[7] = -1; m_data[8] = +0;
// m_data[0] = +1; m_data[1] = -2; m_data[2] = +1; // m_data[0] = +1; m_data[1] = -2; m_data[2] = +1;
// m_data[3] = -2; m_data[4] = +4; m_data[5] = -2; // m_data[3] = -2; m_data[4] = +4; m_data[5] = -2;
// m_data[6] = +1; m_data[7] = -2; m_data[8] = +1; // m_data[6] = +1; m_data[7] = -2; m_data[8] = +1;
} }
@ -487,7 +489,7 @@ void Kernel2::initBlendedSobel(const Vector4 & scale)
}; };
for (int i = 0; i < 9*9; i++) { for (int i = 0; i < 9*9; i++) {
m_data[i] = elements[i] * scale.w(); m_data[i] = elements[i] * scale.w;
} }
} }
{ {
@ -503,7 +505,7 @@ void Kernel2::initBlendedSobel(const Vector4 & scale)
for (int i = 0; i < 7; i++) { for (int i = 0; i < 7; i++) {
for (int e = 0; e < 7; e++) { for (int e = 0; e < 7; e++) {
m_data[(i + 1) * 9 + e + 1] += elements[i * 7 + e] * scale.z(); m_data[(i + 1) * 9 + e + 1] += elements[i * 7 + e] * scale.z;
} }
} }
} }
@ -518,7 +520,7 @@ void Kernel2::initBlendedSobel(const Vector4 & scale)
for (int i = 0; i < 5; i++) { for (int i = 0; i < 5; i++) {
for (int e = 0; e < 5; e++) { for (int e = 0; e < 5; e++) {
m_data[(i + 2) * 9 + e + 2] += elements[i * 5 + e] * scale.y(); m_data[(i + 2) * 9 + e + 2] += elements[i * 5 + e] * scale.y;
} }
} }
} }
@ -531,7 +533,7 @@ void Kernel2::initBlendedSobel(const Vector4 & scale)
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
for (int e = 0; e < 3; e++) { for (int e = 0; e < 3; e++) {
m_data[(i + 3) * 9 + e + 3] += elements[i * 3 + e] * scale.x(); m_data[(i + 3) * 9 + e + 3] += elements[i * 3 + e] * scale.x;
} }
} }
} }

5
src/nvimage/Filter.h
View File

@ -1,10 +1,11 @@
// This code is in the public domain -- castanyo@yahoo.es // This code is in the public domain -- castanyo@yahoo.es
#pragma once
#ifndef NV_IMAGE_FILTER_H #ifndef NV_IMAGE_FILTER_H
#define NV_IMAGE_FILTER_H #define NV_IMAGE_FILTER_H
#include <nvimage/nvimage.h> #include "nvimage.h"
#include <nvcore/Debug.h> #include "nvcore/Debug.h"
namespace nv namespace nv
{ {

54
src/nvimage/FloatImage.cpp
View File

@ -4,11 +4,13 @@
#include "Filter.h" #include "Filter.h"
#include "Image.h" #include "Image.h"
#include <nvmath/Color.h> #include "nvmath/Color.h"
#include <nvmath/Matrix.h> #include "nvmath/Matrix.h"
#include <nvcore/Containers.h> #include "nvcore/Utils.h" // max
#include <nvcore/Ptr.h> #include "nvcore/Ptr.h"
#include "nvcore/Memory.h"
#include "nvcore/Array.h"
#include <math.h> #include <math.h>
@ -150,6 +152,16 @@ void FloatImage::clear(float f/*=0.0f*/)
} }
} }
void FloatImage::clear(uint component, float f/*= 0.0f*/)
{
float * channel = this->channel(component);
const uint size = m_width * m_height;
for(uint i = 0; i < size; i++) {
channel[i] = f;
}
}
void FloatImage::normalize(uint base_component) void FloatImage::normalize(uint base_component)
{ {
nvCheck(base_component + 3 <= m_componentNum); nvCheck(base_component + 3 <= m_componentNum);
@ -164,20 +176,20 @@ void FloatImage::normalize(uint base_component)
Vector3 normal(xChannel[i], yChannel[i], zChannel[i]); Vector3 normal(xChannel[i], yChannel[i], zChannel[i]);
normal = normalizeSafe(normal, Vector3(zero), 0.0f); normal = normalizeSafe(normal, Vector3(zero), 0.0f);
xChannel[i] = normal.x(); xChannel[i] = normal.x;
yChannel[i] = normal.y(); yChannel[i] = normal.y;
zChannel[i] = normal.z(); zChannel[i] = normal.z;
} }
} }
void FloatImage::packNormals(uint base_component) void FloatImage::packNormals(uint base_component)
{ {
scaleBias(base_component, 3, 0.5f, 0.5f); scaleBias(base_component, 3, 0.5f, 1.0f);
} }
void FloatImage::expandNormals(uint base_component) void FloatImage::expandNormals(uint base_component)
{ {
scaleBias(base_component, 3, 2.0f, -1.0f); scaleBias(base_component, 3, 2, -0.5);
} }
void FloatImage::scaleBias(uint base_component, uint num, float scale, float bias) void FloatImage::scaleBias(uint base_component, uint num, float scale, float bias)
@ -188,22 +200,16 @@ void FloatImage::scaleBias(uint base_component, uint num, float scale, float bia
float * ptr = this->channel(base_component + c); float * ptr = this->channel(base_component + c);
for(uint i = 0; i < size; i++) { for(uint i = 0; i < size; i++) {
ptr[i] = scale * ptr[i] + bias; ptr[i] = scale * (ptr[i] + bias);
} }
} }
} }
/// Clamp the elements of the image. /// Clamp the elements of the image.
void FloatImage::clamp(uint base_component, uint num, float low, float high) void FloatImage::clamp(float low, float high)
{ {
const uint size = m_width * m_height; for(uint i = 0; i < m_count; i++) {
m_mem[i] = nv::clamp(m_mem[i], low, high);
for(uint c = 0; c < num; c++) {
float * ptr = this->channel(base_component + c);
for(uint i = 0; i < size; i++) {
ptr[i] = nv::clamp(ptr[i], low, high);
}
} }
} }
@ -249,10 +255,10 @@ void FloatImage::transform(uint base_component, const Matrix & m, Vector4::Arg o
{ {
Vector4 color = nv::transform(m, Vector4(*r, *g, *b, *a)) + offset; Vector4 color = nv::transform(m, Vector4(*r, *g, *b, *a)) + offset;
*r++ = color.x(); *r++ = color.x;
*g++ = color.y(); *g++ = color.y;
*b++ = color.z(); *b++ = color.z;
*a++ = color.w(); *a++ = color.w;
} }
} }
@ -932,7 +938,6 @@ void FloatImage::applyKernelHorizontal(const PolyphaseKernel & k, int y, uint c,
} }
} }
// Vertical flip in place. // Vertical flip in place.
void FloatImage::flip() void FloatImage::flip()
{ {
@ -998,7 +1003,6 @@ void FloatImage::scaleAlphaToCoverage(float desiredCoverage, float alphaRef, int
scaleBias(alphaChannel, 1, alphaScale, 0.0f); scaleBias(alphaChannel, 1, alphaScale, 0.0f);
} }
FloatImage* FloatImage::clone() const FloatImage* FloatImage::clone() const
{ {
FloatImage* copy = new FloatImage(); FloatImage* copy = new FloatImage();

180
src/nvimage/FloatImage.h
View File

@ -3,30 +3,28 @@
#ifndef NV_IMAGE_FLOATIMAGE_H #ifndef NV_IMAGE_FLOATIMAGE_H
#define NV_IMAGE_FLOATIMAGE_H #define NV_IMAGE_FLOATIMAGE_H
#include <nvimage/nvimage.h> #include "nvimage.h"
#include <nvmath/Vector.h> #include "nvcore/Debug.h"
#include "nvcore/Utils.h" // clamp
#include <nvcore/Debug.h>
#include <nvcore/Algorithms.h> // clamp
#include <stdlib.h> // abs #include <stdlib.h> // abs
namespace nv namespace nv
{ {
class Vector4; class Vector4;
class Matrix; class Matrix;
class Image; class Image;
class Filter; class Filter;
class Kernel1; class Kernel1;
class Kernel2; class Kernel2;
class PolyphaseKernel; class PolyphaseKernel;
/// Multicomponent floating point image class. /// Multicomponent floating point image class.
class FloatImage class FloatImage
{ {
public: public:
enum WrapMode { enum WrapMode {
WrapMode_Clamp, WrapMode_Clamp,
@ -53,15 +51,17 @@ public:
/** @name Manipulation. */ /** @name Manipulation. */
//@{ //@{
NVIMAGE_API void clear(float f=0.0f); NVIMAGE_API void clear(float f = 0.0f);
NVIMAGE_API void clear(uint component, float f = 0.0f);
NVIMAGE_API void normalize(uint base_component); NVIMAGE_API void normalize(uint base_component);
NVIMAGE_API void packNormals(uint base_component); NVIMAGE_API void packNormals(uint base_component);
NVIMAGE_API void expandNormals(uint base_component); NVIMAGE_API void expandNormals(uint base_component);
NVIMAGE_API void scaleBias(uint base_component, uint num, float scale, float bias); NVIMAGE_API void scaleBias(uint base_component, uint num, float scale, float add);
NVIMAGE_API void clamp(uint base_component, uint num, float low, float high); //NVIMAGE_API void clamp(uint base_component, uint num);
NVIMAGE_API void clamp(float low, float high);
NVIMAGE_API void toLinear(uint base_component, uint num, float gamma = 2.2f); NVIMAGE_API void toLinear(uint base_component, uint num, float gamma = 2.2f);
NVIMAGE_API void toGamma(uint base_component, uint num, float gamma = 2.2f); NVIMAGE_API void toGamma(uint base_component, uint num, float gamma = 2.2f);
@ -74,9 +74,12 @@ public:
NVIMAGE_API FloatImage * downSample(const Filter & filter, WrapMode wm) const; NVIMAGE_API FloatImage * downSample(const Filter & filter, WrapMode wm) const;
NVIMAGE_API FloatImage * downSample(const Filter & filter, WrapMode wm, uint alpha) const; NVIMAGE_API FloatImage * downSample(const Filter & filter, WrapMode wm, uint alpha) const;
NVIMAGE_API FloatImage * resize(const Filter & filter, uint w, uint h, WrapMode wm) const; NVIMAGE_API FloatImage * resize(const Filter & filter, uint w, uint h, WrapMode wm) const;
NVIMAGE_API FloatImage * resize(const Filter & filter, uint w, uint h, WrapMode wm, uint alpha) const; NVIMAGE_API FloatImage * resize(const Filter & filter, uint w, uint h, WrapMode wm, uint alpha) const;
//NVIMAGE_API FloatImage * downSample(const Kernel1 & filter, WrapMode wm) const;
//NVIMAGE_API FloatImage * downSample(const Kernel1 & filter, uint w, uint h, WrapMode wm) const;
//@}
NVIMAGE_API float applyKernel(const Kernel2 * k, int x, int y, uint c, WrapMode wm) const; NVIMAGE_API float applyKernel(const Kernel2 * k, int x, int y, uint c, WrapMode wm) const;
NVIMAGE_API float applyKernelVertical(const Kernel1 * k, int x, int y, uint c, WrapMode wm) const; NVIMAGE_API float applyKernelVertical(const Kernel1 * k, int x, int y, uint c, WrapMode wm) const;
NVIMAGE_API float applyKernelHorizontal(const Kernel1 * k, int x, int y, uint c, WrapMode wm) const; NVIMAGE_API float applyKernelHorizontal(const Kernel1 * k, int x, int y, uint c, WrapMode wm) const;
@ -89,7 +92,7 @@ public:
NVIMAGE_API float alphaTestCoverage(float alphaRef, int alphaChannel) const; NVIMAGE_API float alphaTestCoverage(float alphaRef, int alphaChannel) const;
NVIMAGE_API void scaleAlphaToCoverage(float coverage, float alphaRef, int alphaChannel); NVIMAGE_API void scaleAlphaToCoverage(float coverage, float alphaRef, int alphaChannel);
//@}
uint width() const { return m_width; } uint width() const { return m_width; }
uint height() const { return m_height; } uint height() const { return m_height; }
@ -105,12 +108,11 @@ public:
const float * scanline(uint y, uint c) const; const float * scanline(uint y, uint c) const;
float * scanline(uint y, uint c); float * scanline(uint y, uint c);
void setPixel(float f, uint x, uint y, uint c);
void addPixel(float f, uint x, uint y, uint c);
float pixel(uint x, uint y, uint c) const; float pixel(uint x, uint y, uint c) const;
float & pixel(uint x, uint y, uint c);
void setPixel(float f, uint idx);
float pixel(uint idx) const; float pixel(uint idx) const;
float & pixel(uint idx);
float sampleNearest(float x, float y, int c, WrapMode wm) const; float sampleNearest(float x, float y, int c, WrapMode wm) const;
float sampleLinear(float x, float y, int c, WrapMode wm) const; float sampleLinear(float x, float y, int c, WrapMode wm) const;
@ -127,7 +129,7 @@ public:
FloatImage* clone() const; FloatImage* clone() const;
public: public:
uint index(uint x, uint y) const; uint index(uint x, uint y) const;
uint indexClamp(int x, int y) const; uint indexClamp(int x, int y) const;
@ -135,7 +137,7 @@ public:
uint indexMirror(int x, int y) const; uint indexMirror(int x, int y) const;
uint index(int x, int y, WrapMode wm) const; uint index(int x, int y, WrapMode wm) const;
public: public:
uint16 m_width; ///< Width of the texture. uint16 m_width; ///< Width of the texture.
uint16 m_height; ///< Height of the texture. uint16 m_height; ///< Height of the texture.
@ -143,107 +145,97 @@ public:
uint32 m_count; ///< Image pixel count. uint32 m_count; ///< Image pixel count.
float * m_mem; float * m_mem;
}; };
/// Get const channel pointer. /// Get const channel pointer.
inline const float * FloatImage::channel(uint c) const inline const float * FloatImage::channel(uint c) const
{ {
nvDebugCheck(m_mem != NULL); nvDebugCheck(m_mem != NULL);
nvDebugCheck(c < m_componentNum); nvDebugCheck(c < m_componentNum);
return m_mem + c * m_width * m_height; return m_mem + c * m_width * m_height;
} }
/// Get channel pointer. /// Get channel pointer.
inline float * FloatImage::channel(uint c) { inline float * FloatImage::channel(uint c) {
nvDebugCheck(m_mem != NULL); nvDebugCheck(m_mem != NULL);
nvDebugCheck(c < m_componentNum); nvDebugCheck(c < m_componentNum);
return m_mem + c * m_width * m_height; return m_mem + c * m_width * m_height;
} }
/// Get const scanline pointer. /// Get const scanline pointer.
inline const float * FloatImage::scanline(uint y, uint c) const inline const float * FloatImage::scanline(uint y, uint c) const
{ {
nvDebugCheck(y < m_height); nvDebugCheck(y < m_height);
return channel(c) + y * m_width; return channel(c) + y * m_width;
} }
/// Get scanline pointer. /// Get scanline pointer.
inline float * FloatImage::scanline(uint y, uint c) inline float * FloatImage::scanline(uint y, uint c)
{ {
nvDebugCheck(y < m_height); nvDebugCheck(y < m_height);
return channel(c) + y * m_width; return channel(c) + y * m_width;
} }
/// Set pixel component. /// Get pixel component.
inline void FloatImage::setPixel(float f, uint x, uint y, uint c) inline float FloatImage::pixel(uint x, uint y, uint c) const
{ {
nvDebugCheck(m_mem != NULL);
nvDebugCheck(x < m_width);
nvDebugCheck(y < m_height);
nvDebugCheck(c < m_componentNum);
m_mem[(c * m_height + y) * m_width + x] = f;
}
/// Add to pixel component.
inline void FloatImage::addPixel(float f, uint x, uint y, uint c)
{
nvDebugCheck(m_mem != NULL);
nvDebugCheck(x < m_width);
nvDebugCheck(y < m_height);
nvDebugCheck(c < m_componentNum);
m_mem[(c * m_height + y) * m_width + x] += f;
}
/// Get pixel component.
inline float FloatImage::pixel(uint x, uint y, uint c) const
{
nvDebugCheck(m_mem != NULL); nvDebugCheck(m_mem != NULL);
nvDebugCheck(x < m_width); nvDebugCheck(x < m_width);
nvDebugCheck(y < m_height); nvDebugCheck(y < m_height);
nvDebugCheck(c < m_componentNum); nvDebugCheck(c < m_componentNum);
return m_mem[(c * m_height + y) * m_width + x]; return m_mem[(c * m_height + y) * m_width + x];
} }
/// Set pixel component. /// Get pixel component.
inline void FloatImage::setPixel(float f, uint idx) inline float & FloatImage::pixel(uint x, uint y, uint c)
{ {
nvDebugCheck(idx < m_count); nvDebugCheck(m_mem != NULL);
m_mem[idx] = f; nvDebugCheck(x < m_width);
} nvDebugCheck(y < m_height);
nvDebugCheck(c < m_componentNum);
return m_mem[(c * m_height + y) * m_width + x];
}
/// Get pixel component. /// Get pixel component.
inline float FloatImage::pixel(uint idx) const inline float FloatImage::pixel(uint idx) const
{ {
nvDebugCheck(idx < m_count); nvDebugCheck(idx < m_count);
return m_mem[idx]; return m_mem[idx];
} }
inline uint FloatImage::index(uint x, uint y) const /// Get pixel component.
{ inline float & FloatImage::pixel(uint idx)
{
nvDebugCheck(idx < m_count);
return m_mem[idx];
}
inline uint FloatImage::index(uint x, uint y) const
{
nvDebugCheck(x < m_width); nvDebugCheck(x < m_width);
nvDebugCheck(y < m_height); nvDebugCheck(y < m_height);
return y * m_width + x; return y * m_width + x;
} }
inline uint FloatImage::indexClamp(int x, int y) const inline uint FloatImage::indexClamp(int x, int y) const
{ {
return nv::clamp(y, int(0), int(m_height-1)) * m_width + nv::clamp(x, int(0), int(m_width-1)); return nv::clamp(y, int(0), int(m_height-1)) * m_width + nv::clamp(x, int(0), int(m_width-1));
} }
inline int repeat_remainder(int a, int b) inline int repeat_remainder(int a, int b)
{ {
if (a >= 0) return a % b; if (a >= 0) return a % b;
else return (a + 1) % b + b - 1; else return (a + 1) % b + b - 1;
} }
inline uint FloatImage::indexRepeat(int x, int y) const inline uint FloatImage::indexRepeat(int x, int y) const
{ {
return repeat_remainder(y, m_height) * m_width + repeat_remainder(x, m_width); return repeat_remainder(y, m_height) * m_width + repeat_remainder(x, m_width);
} }
inline uint FloatImage::indexMirror(int x, int y) const inline uint FloatImage::indexMirror(int x, int y) const
{ {
if (m_width == 1) x = 0; if (m_width == 1) x = 0;
x = abs(x); x = abs(x);
@ -259,14 +251,14 @@ inline uint FloatImage::indexMirror(int x, int y) const
} }
return index(x, y); return index(x, y);
} }
inline uint FloatImage::index(int x, int y, WrapMode wm) const inline uint FloatImage::index(int x, int y, WrapMode wm) const
{ {
if (wm == WrapMode_Clamp) return indexClamp(x, y); if (wm == WrapMode_Clamp) return indexClamp(x, y);
if (wm == WrapMode_Repeat) return indexRepeat(x, y); if (wm == WrapMode_Repeat) return indexRepeat(x, y);
/*if (wm == WrapMode_Mirror)*/ return indexMirror(x, y); /*if (wm == WrapMode_Mirror)*/ return indexMirror(x, y);
} }
} // nv namespace } // nv namespace

12
src/nvimage/Image.cpp
View File

@ -1,13 +1,13 @@
// This code is in the public domain -- castanyo@yahoo.es // This code is in the public domain -- castanyo@yahoo.es
#include <nvimage/Image.h> #include "Image.h"
#include <nvimage/ImageIO.h> #include "ImageIO.h"
#include <nvmath/Color.h> #include "nvmath/Color.h"
#include <nvcore/Debug.h> #include "nvcore/Debug.h"
#include <nvcore/Ptr.h> #include "nvcore/Ptr.h"
#include <nvcore/Containers.h> // swap #include "nvcore/Utils.h" // swap
using namespace nv; using namespace nv;

5
src/nvimage/Image.h
View File

@ -1,10 +1,11 @@
// This code is in the public domain -- castanyo@yahoo.es // This code is in the public domain -- castanyo@yahoo.es
#pragma once
#ifndef NV_IMAGE_IMAGE_H #ifndef NV_IMAGE_IMAGE_H
#define NV_IMAGE_IMAGE_H #define NV_IMAGE_IMAGE_H
#include <nvcore/Debug.h> #include "nvimage.h"
#include <nvimage/nvimage.h> #include "nvcore/Debug.h"
namespace nv namespace nv
{ {

11
src/nvimage/ImageIO.cpp
View File

@ -6,12 +6,13 @@
#include "TgaFile.h" #include "TgaFile.h"
#include "PsdFile.h" #include "PsdFile.h"
#include <nvmath/Color.h> #include "nvmath/Color.h"
#include <nvcore/Ptr.h> #include "nvcore/Ptr.h"
#include <nvcore/Containers.h> #include "nvcore/Utils.h"
#include <nvcore/StrLib.h> #include "nvcore/Array.h"
#include <nvcore/StdStream.h> #include "nvcore/StrLib.h"
#include "nvcore/StdStream.h"
// Extern // Extern
#if defined(HAVE_FREEIMAGE) #if defined(HAVE_FREEIMAGE)

6
src/nvimage/ImageIO.h
View File

@ -1,11 +1,13 @@
// This code is in the public domain -- castanyo@yahoo.es // This code is in the public domain -- castanyo@yahoo.es
#pragma once
#ifndef NV_IMAGE_IMAGEIO_H #ifndef NV_IMAGE_IMAGEIO_H
#define NV_IMAGE_IMAGEIO_H #define NV_IMAGE_IMAGEIO_H
#include <nvimage/nvimage.h> #include "nvimage.h"
#include <nvcore/StrLib.h> #include "nvcore/StrLib.h"
#include "nvcore/HashMap.h"
namespace nv namespace nv

14
src/nvimage/NormalMap.cpp
View File

@ -65,9 +65,9 @@ static FloatImage * createNormalMap(const Image * img, FloatImage::WrapMode wm,
Vector3 n = normalize(Vector3(du, dv, heightScale)); Vector3 n = normalize(Vector3(du, dv, heightScale));
fimage->setPixel(0.5f * n.x() + 0.5f, x, y, 0); fimage->pixel(x, y, 0) = 0.5f * n.x + 0.5f;
fimage->setPixel(0.5f * n.y() + 0.5f, x, y, 1); fimage->pixel(x, y, 1) = 0.5f * n.y + 0.5f;
fimage->setPixel(0.5f * n.z() + 0.5f, x, y, 2); fimage->pixel(x, y, 2) = 0.5f * n.z + 0.5f;
} }
} }
@ -100,9 +100,9 @@ static FloatImage * createNormalMap(const FloatImage * img, FloatImage::WrapMode
Vector3 n = normalize(Vector3(du, dv, heightScale)); Vector3 n = normalize(Vector3(du, dv, heightScale));
img_out->setPixel(n.x(), x, y, 0); img_out->pixel(x, y, 0) = n.x;
img_out->setPixel(n.y(), x, y, 1); img_out->pixel(x, y, 1) = n.y;
img_out->setPixel(n.z(), x, y, 2); img_out->pixel(x, y, 2) = n.z;
} }
} }
@ -111,7 +111,7 @@ static FloatImage * createNormalMap(const FloatImage * img, FloatImage::WrapMode
{ {
for (uint x = 0; x < w; x++) for (uint x = 0; x < w; x++)
{ {
img_out->setPixel(img->pixel(x, y, 3), x, y, 3); img_out->pixel(x, y, 3) = img->pixel(x, y, 3);
} }
} }

20
src/nvimage/Quantize.cpp
View File

@ -12,13 +12,15 @@ http://www.efg2.com/Lab/Library/ImageProcessing/DHALF.TXT
@@ This code needs to be reviewed, I'm not sure it's correct. @@ This code needs to be reviewed, I'm not sure it's correct.
*/ */
#include <nvimage/Quantize.h> #include "Quantize.h"
#include <nvimage/Image.h> #include "Image.h"
#include <nvimage/PixelFormat.h> #include "PixelFormat.h"
#include <nvmath/Color.h> #include "nvmath/Color.h"
#include <nvcore/Containers.h> // swap #include "nvcore/Utils.h" // swap
#include <string.h> // memset
using namespace nv; using namespace nv;
@ -174,10 +176,10 @@ void nv::Quantize::FloydSteinberg(Image * image, uint rsize, uint gsize, uint bs
Color32 pixel = image->pixel(x, y); Color32 pixel = image->pixel(x, y);
// Add error. // Add error.
pixel.r = clamp(int(pixel.r) + int(row0[1+x].x()), 0, 255); pixel.r = clamp(int(pixel.r) + int(row0[1+x].x), 0, 255);
pixel.g = clamp(int(pixel.g) + int(row0[1+x].y()), 0, 255); pixel.g = clamp(int(pixel.g) + int(row0[1+x].y), 0, 255);
pixel.b = clamp(int(pixel.b) + int(row0[1+x].z()), 0, 255); pixel.b = clamp(int(pixel.b) + int(row0[1+x].z), 0, 255);
pixel.a = clamp(int(pixel.a) + int(row0[1+x].w()), 0, 255); pixel.a = clamp(int(pixel.a) + int(row0[1+x].w), 0, 255);
int r = pixel.r; int r = pixel.r;
int g = pixel.g; int g = pixel.g;