一个简单的能处理MIP-MAP的类

最新推荐文章于 2025-08-23 12:59:31 发布

weixin_30830327

最新推荐文章于 2025-08-23 12:59:31 发布

阅读量63

点赞数

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/len3d/archive/2005/07/08/188838.html

本文展示了一个能处理MIP - MAP的简单类eiTexture。该类包含构造、析构函数，有加载纹理、归一化、生成MIP - MAP等方法，还实现了获取颜色、双线性插值等功能，通过一系列代码逻辑完成对纹理数据的处理。

一个简单的能处理MIP-MAP的类

// -------------------------------------------------------------------------

eiTexture::eiTexture(eiBool instance_type, eiBool mip_map_filter)

{

format = NONE;

type = SRC;

m_width = 0;

m_height = 0;

instance = instance_type;

use_mip_map = mip_map_filter;

bits = NULL;

}

// -------------------------------------------------------------------------

eiTexture:: ~ eiTexture()

{

}

// -------------------------------------------------------------------------

eiBool eiTexture::load(eiChar * file_name)

{

CFile file;

if( !file.Open( file_name, CFile::modeRead | CFile::shareDenyWrite ) )

{

msger.print("Load texture failed.");

return false;

}

BITMAPFILEHEADER bfhHeader;

file.Read( &bfhHeader, sizeof(BITMAPFILEHEADER) );

if( bfhHeader.bfType != 0x4d42 )

{

msger.print("Load texture failed.");

return false;

}

eiUInt uBmpInfoLen = (eiUInt) bfhHeader.bfOffBits - sizeof(BITMAPFILEHEADER);

LPBITMAPINFOHEADER m_lpBMPHdr = (LPBITMAPINFOHEADER) new eiByte [ uBmpInfoLen ];

eiUInt counts = file.Read(m_lpBMPHdr, uBmpInfoLen);

if(m_lpBMPHdr->biSize != sizeof(BITMAPINFOHEADER))

{

msger.print("Texture format error.");

return false;

}

DWORD m_dwImageSize = m_lpBMPHdr->biSizeImage;

if(m_dwImageSize == 0)

{

DWORD dwBytes = ((DWORD) m_lpBMPHdr->biWidth * m_lpBMPHdr->biBitCount) / 32;

if(((DWORD) m_lpBMPHdr->biWidth * m_lpBMPHdr->biBitCount) % 32)

{

dwBytes++;

}

dwBytes *= 4;

m_dwImageSize = dwBytes * m_lpBMPHdr->biHeight;

}

bits = (eiByte*) new eiByte [ m_dwImageSize ];

counts = file.Read(bits, m_dwImageSize);

file.Close();

m_width = m_lpBMPHdr->biWidth;

m_height = m_lpBMPHdr->biHeight;

delete []m_lpBMPHdr;

format = BMP;

normalize();

inv_width = 1.0 / m_width;

inv_height = 1.0 / m_height;

if(use_mip_map)

{

make_mip_map();

}

return true;

}

// -------------------------------------------------------------------------

eiVoid eiTexture::normalize()

{

eiByte *pbits;

eiInt n_width,n_height;

eiFloat dx,dy;

eiColor color;

pbits = bits;

n_width = (eiInt) powf( 2, (eiInt) log2f( m_width ) + 1 );

n_height = (eiInt) powf( 2, (eiInt) log2f( m_height ) + 1 );

dx = (eiFloat) m_width / (eiFloat) n_width;

dy = (eiFloat) m_height / (eiFloat) n_height;

src.resize( n_width * n_height * 3 );

std::vector<eiByte>::iterator pbyPtr = src.begin();

for(eiInt j = 0 ; j < n_height ; j++)

{

for(eiInt i = 0 ; i < n_width ; i++)

{

color = get_bilinear_color( pbits, i * dx, j * dy );

pbyPtr[0] = (eiByte) ( color.b * 255 );

pbyPtr[1] = (eiByte) ( color.g * 255 );

pbyPtr[2] = (eiByte) ( color.r * 255 );

pbyPtr += 3;

}

delete []pbits;

bits = NULL;

m_width = n_width;

m_height = n_height;

}

// -------------------------------------------------------------------------

eiInt eiTexture::get_width()

{

return m_width;

}

// -------------------------------------------------------------------------

eiInt eiTexture::get_height()

{

return m_height;

}

// -------------------------------------------------------------------------

eiColorB eiTexture::get_color(eiByte * dibbits, eiInt x, eiInt y)

{

eiColorB color;

color.r = color.g = color.b = 0;

if(dibbits == NULL)

return color;

if(x < 0)

x = 0;

if(x >= m_width)

x = m_width - 1;

if(y < 0)

y = 0;

if(y >= m_height)

y = m_height - 1;

eiByte *pbyPtr;

pbyPtr = dibbits + (y * m_width + x) * 3;

color.b = pbyPtr[0];

color.g = pbyPtr[1];

color.r = pbyPtr[2];

return color;

}

// -------------------------------------------------------------------------

eiColor eiTexture::get_bilinear_color(eiByte * dibbits, eiFloat x, eiFloat y)

{

eiInt u,v;

u = (eiInt) x;

v = (eiInt) y;

if( (eiFloat) u == x && (eiFloat) v == y )

{

eiColorB clr = get_color(dibbits,u,v);

return newclr( clr.r * EI_BYTE_2_FLOAT,

clr.g * EI_BYTE_2_FLOAT,

clr.b * EI_BYTE_2_FLOAT );

}

eiFloat du,dv,r1,g1,b1,r2,g2,b2;

eiColorB c1,c2,c3,c4;

du = curve( x - u );

dv = curve( y - v );

c1 = get_color(dibbits,u,v);

c2 = get_color(dibbits,u+1,v);

c3 = get_color(dibbits,u+1,v+1);

c4 = get_color(dibbits,u,v+1);

r1 = c1.r + (c2.r - c1.r) * du;

g1 = c1.g + (c2.g - c1.g) * du;

b1 = c1.b + (c2.b - c1.b) * du;

r2 = c4.r + (c3.r - c4.r) * du;

g2 = c4.g + (c3.g - c4.g) * du;

b2 = c4.b + (c3.b - c4.b) * du;

r1 = r1 + (r2 - r1) * dv;

g1 = g1 + (g2 - g1) * dv;

b1 = b1 + (b2 - b1) * dv;

r1 *= EI_BYTE_2_FLOAT;

g1 *= EI_BYTE_2_FLOAT;

b1 *= EI_BYTE_2_FLOAT;

return newclr(r1,g1,b1);

}

// -------------------------------------------------------------------------

eiColorB eiTexture::get_src_color(eiInt x, eiInt y)

{

eiColorB color;

color.r = color.g = color.b = 0;

if(src.empty())

return color;

if(x < 0)

x = 0;

if(x >= m_width)

x = m_width - 1;

if(y < 0)

y = 0;

if(y >= m_height)

y = m_height - 1;

std::vector<eiByte>::iterator pbyPtr;

pbyPtr = src.begin() + (y * m_width + x) * 3;

color.b = pbyPtr[0];

color.g = pbyPtr[1];

color.r = pbyPtr[2];

return color;

}

// -------------------------------------------------------------------------

eiColor eiTexture::get_src_bilinear_color(eiFloat x, eiFloat y)

{

eiInt u,v;

u = (eiInt) x;

v = (eiInt) y;

if( (eiFloat) u == x && (eiFloat) v == y )

{

eiColorB clr = get_src_color(u,v);

return newclr( clr.r * EI_BYTE_2_FLOAT,

clr.g * EI_BYTE_2_FLOAT,

clr.b * EI_BYTE_2_FLOAT );

}

eiFloat du,dv,r1,g1,b1,r2,g2,b2;

eiColorB c1,c2,c3,c4;

du = curve( x - u );

dv = curve( y - v );

c1 = get_src_color(u,v);

c2 = get_src_color(u+1,v);

c3 = get_src_color(u+1,v+1);

c4 = get_src_color(u,v+1);

r1 = c1.r + (c2.r - c1.r) * du;

g1 = c1.g + (c2.g - c1.g) * du;

b1 = c1.b + (c2.b - c1.b) * du;

r2 = c4.r + (c3.r - c4.r) * du;

g2 = c4.g + (c3.g - c4.g) * du;

b2 = c4.b + (c3.b - c4.b) * du;

r1 = r1 + (r2 - r1) * dv;

g1 = g1 + (g2 - g1) * dv;

b1 = b1 + (b2 - b1) * dv;

r1 *= EI_BYTE_2_FLOAT;

g1 *= EI_BYTE_2_FLOAT;

b1 *= EI_BYTE_2_FLOAT;

return newclr(r1,g1,b1);

}

// -------------------------------------------------------------------------

eiVoid eiTexture::blt(eiInt x1,eiInt y1,eiInt x2,eiInt y2,

eiInt width,eiInt height)

{

eiInt c1,c2,c3,c4;

std::vector<eiByte>::iterator pbyPtr;

for( eiInt j = y1, mj = y2 ; j < (y1 + height) ; j += 2, mj++ )

{

for( eiInt i = x1, mi = x2 ; i < (x1 + width) ; i += 2, mi++ )

{

pbyPtr = mip_map.begin() + j * m_width + i;

c1 = pbyPtr[0];

c2 = pbyPtr[1];

pbyPtr += m_width;

c3 = pbyPtr[0];

c4 = pbyPtr[1];

pbyPtr = mip_map.begin() + mj * m_width + mi;

pbyPtr[0] = (eiByte) ( (eiFloat) ( c1 + c2 + c3 + c4 ) * 0.25 );

}

// -------------------------------------------------------------------------

eiVoid eiTexture::bltB(eiInt x1,eiInt y1,eiInt x2,eiInt y2,

eiInt width,eiInt height)

{

if(width == 0 || height == 0)

return;

eiInt width2,height2;

width2 = width / 2;

height2 = height / 2;

blt( x1, y1, x2, y2, width, height);

bltB( x2, y2, x2 / 2, y2 / 2, width2, height2 );

}

// -------------------------------------------------------------------------

eiVoid eiTexture::bltG(eiInt x1,eiInt y1,eiInt x2,eiInt y2,

eiInt width,eiInt height)

{

if(width == 0 || height == 0)

return;

eiInt width2,height2;

width2 = width / 2;

height2 = height / 2;

blt( x1, y1, x2, y2, width, height);

bltG( x2, y2, x2 / 2, y2, width2, height2 );

}

// -------------------------------------------------------------------------

eiVoid eiTexture::bltR(eiInt x1,eiInt y1,eiInt x2,eiInt y2,

eiInt width,eiInt height)

{

if(width == 0 || height == 0)

return;

eiInt width2,height2;

width2 = width / 2;

height2 = height / 2;

blt( x1, y1, x2, y2, width, height);

bltR( x2, y2, x2, y2 / 2, width2, height2 );

}

// -------------------------------------------------------------------------

eiBool eiTexture::make_mip_map()

{

if(format == NONE || type == MIP_MAP)

return false;

mip_map.resize( m_width * m_height );

eiColorB c1,c2,c3,c4;

eiFloat r,g,b;

std::vector<eiByte>::iterator pbyPtr;

eiInt width2,height2;

width2 = m_width / 2;

height2 = m_height / 2;

for( eiInt j = 0, mj = 0 ; j < m_height ; j += 2, mj++ )

{

for( eiInt i = 0, mi = 0 ; i < m_width ; i += 2, mi++ )

{

c1 = get_src_color( i , j );

c2 = get_src_color( i + 1 , j );

c3 = get_src_color( i + 1 , j + 1 );

c4 = get_src_color( i , j + 1 );

b = (eiFloat) ( (eiInt) c1.b + (eiInt) c2.b + (eiInt) c3.b + (eiInt) c4.b ) * 0.25;

g = (eiFloat) ( (eiInt) c1.g + (eiInt) c2.g + (eiInt) c3.g + (eiInt) c4.g ) * 0.25;

r = (eiFloat) ( (eiInt) c1.r + (eiInt) c2.r + (eiInt) c3.r + (eiInt) c4.r ) * 0.25;

// i have not considered efficiency problem in precomputing progress

/**//* mip-map is built as follow :

NEXT GREEN

RED BLUE */

pbyPtr = mip_map.begin() + ( mj + height2 ) * m_width + mi + width2;

pbyPtr[0] = (eiByte) b;

pbyPtr = mip_map.begin() + mj * m_width + mi + width2;

pbyPtr[0] = (eiByte) g;

pbyPtr = mip_map.begin() + ( mj + height2 ) * m_width + mi;

pbyPtr[0] = (eiByte) r;

}

bltB( width2, height2, m_width / 4, m_height / 4, width2, height2 );

bltG( width2, 0, m_width / 4, 0, width2, height2 );

bltR( 0, height2, 0, m_height / 4, width2, height2 );

type = MIP_MAP;

return true;

}

// -------------------------------------------------------------------------

eiFloat eiTexture::get_bilinear(eiFloat x, eiFloat y)

{

eiInt u,v;

std::vector<eiByte>::iterator pbyPtr;

u = (eiInt) x;

v = (eiInt) y;

if( (eiFloat) u == x && (eiFloat) v == y )

{

pbyPtr = mip_map.begin() + m_width * v + u;

return pbyPtr[0] * EI_BYTE_2_FLOAT;

}

eiFloat du,dv,r1,r2;

eiByte f1,f2,f3,f4;

du = curve( x - u );

dv = curve( y - v );

pbyPtr = mip_map.begin() + m_width * v + u;

f1 = pbyPtr[0];

f2 = pbyPtr[1];

pbyPtr += m_width;

f3 = pbyPtr[1];

f4 = pbyPtr[0];

r1 = f1 + (f2 - f1) * du;

r2 = f4 + (f3 - f4) * du;

r1 = r1 + (r2 - r1) * dv;

return r1 * EI_BYTE_2_FLOAT;

}

// -------------------------------------------------------------------------

eiColor eiTexture::get_pixel(eiFloat x, eiFloat y, eiInt d)

{

if(src.empty() || ( type == MIP_MAP && mip_map.empty() ) )

return newclr();

if(d == 0)

{

return get_src_bilinear_color( x, y );

}

eiFloat b,g,r,scale;

scale = 1 / powf( 2 , d );

eiFloat mx,my,width2,height2;

width2 = m_width * scale;

height2 = m_height * scale;

mx = x * scale;

my = y * scale;

b = get_bilinear( width2 + mx , height2 + my );

g = get_bilinear( width2 + mx , my );

r = get_bilinear( mx , height2 + my );

return newclr(r,g,b);

}

// -------------------------------------------------------------------------

eiColor eiTexture::lookup( const eiPlane & uv)

{

return get_pixel(uv.x, uv.y, uv.z, uv.w);

}

// -------------------------------------------------------------------------

eiColor eiTexture::get_pixel(eiFloat x, eiFloat y, eiFloat dx, eiFloat dy)

{

x *= m_width;

y *= m_height;

if( type == SRC || ( dx == 0.0 && dy == 0.0 ) )

{

//maybe shading for raytracing, do not use mip-map

return get_src_bilinear_color( x, y );

}

dx *= m_width;

dy *= m_height;

eiFloat d;

eiInt di;

eiColor c1,c2;

d = max(dx,dy);

d = log2f(d);

di = (eiInt) d;

d = d - (eiFloat) di;

c1 = get_pixel( x, y, di );

c2 = get_pixel( x, y, di + 1 );

return mixclr( c1, c2, d );

}

// -------------------------------------------------------------------------

posted on 2005-07-08 18:56 Len3d 阅读( ...) 评论( ...) 编辑收藏

转载于:https://www.cnblogs.com/len3d/archive/2005/07/08/188838.html