// 直線描画
#include <stdio.h>
#include <windows.h>
#include "resource_07.h"
#include "gt_img_parts.h"
// ======== GT_IMG ==================================
class GT_IMG {
public :
GT_COL_TABLE m_col_table;
unsigned long *m_col_mask;
char *m_alpha;
int m_width, m_height, m_byte_width, m_bit_count;
BYTE *m_pbits;
GT_IMG();
virtual ~GT_IMG();
// 作成と破棄
virtual destroy();
virtual create(int cx, int cy, int a_bit_count, int a_color_size=0);
// ピクセル描画
set_pixel(int x, int y, DWORD col);
DWORD get_pixel(int x, int y);
// 直線描画
draw_line(int sx, int sy, int ex, int ey, BYTE r, BYTE g, BYTE b, int rate);
template <int d_bit> void draw_line_pixput(int sx, int sy, int ex, int ey, BYTE r, BYTE g, BYTE b, int rate);
adjust_lining_limit(int *p_start, int *p_end, int sx, int sy, int ex, int ey, int *p_cx, int *p_cy);
// アルファ値
is_alpha(){ return (m_alpha!=NULL); }
// カラー
set_col_mask(UINT r, UINT g, UINT b);
set_pal_col(BYTE index, BYTE r, BYTE g, BYTE b);
// 読込
load_dib(char *filename);
load_dib_rle4(HANDLE hfile); // 4bit ランレングス圧縮
load_dib_rle8(HANDLE hfile); // 8bit ランレングス圧縮
// 書込み
save_dib(char *filename, int rle_compress_flag=0);
save_dib_rle4(HANDLE hfile); // 4bit ランレングス圧縮
save_dib_rle8(HANDLE hfile); // 8bit ランレングス圧縮
};
// 直線描画
GT_IMG::draw_line(int sx, int sy, int ex, int ey, BYTE r, BYTE g, BYTE b, int rate){
if (!m_pbits) return -1;
if (sx==ex && sy==ey) return -1;
// 描画
switch(m_bit_count){
case 1 : draw_line_pixput<1> (sx, sy, ex, ey, r, g, b, rate); break;
case 4 : draw_line_pixput<4> (sx, sy, ex, ey, r, g, b, rate); break;
case 8 : draw_line_pixput<8> (sx, sy, ex, ey, r, g, b, rate); break;
case 16: draw_line_pixput<16>(sx, sy, ex, ey, r, g, b, rate); break;
case 24: draw_line_pixput<24>(sx, sy, ex, ey, r, g, b, rate); break;
case 32: draw_line_pixput<32>(sx, sy, ex, ey, r, g, b, rate); break;
}
return 0;
}
// 直線描画のインライン・テンプレート（ＲＧＢ版）
template <int d_bit> void
GT_IMG::draw_line_pixput(int sx, int sy, int ex, int ey, BYTE r, BYTE g, BYTE b, int rate){
int cx, cy, pos_x, pos_y, i, lim, start, end;
PIXEL_ITR<d_bit,0> d_pix;
if (rate<0) rate=0;
if (rate>=255) rate=255;
d_pix.init(m_pbits, m_alpha, m_byte_width, m_width, m_height, &m_col_table);
int col_index;
double e;
int *p_co1, *p_co2, ddis1, ddis2, dn1, dn2;
if (adjust_lining_limit(&start, &end, sx, sy, ex, ey, &cx, &cy)<0) return;
int base_axis = (abs(cx)>abs(cy))? 'x' : 'y';
p_co1 = (base_axis=='x')? &pos_x : &pos_y;
p_co2 = (base_axis=='x')? &pos_y : &pos_x;
ddis1 = (base_axis=='x')? 2*cx : 2*cy;
ddis2 = (base_axis=='x')? 2*cy : 2*cx;
dn1 = dn2 = 1;
if (ddis1<0) { dn1=-1; ddis1 = -ddis1; }
if (ddis2<0) { dn2=-1; ddis2 = -ddis2; }
pos_x = sx;
pos_y = sy;
*p_co1 += dn1* start;
*p_co2 += dn2* (start*ddis2+ddis1/2) /ddis1;
e = (ddis1/2 + start*ddis2)%ddis1;
if (d_bit<8){ // （パレット版）
col_index = m_col_table.get_col_index<d_bit>(r*rate/255, g*rate/255, b*rate/255);
for(i=start;i<=end;i++){
d_pix.set_pos(pos_x, pos_y);
d_pix.set_col(col_index);
(*p_co1)+=dn1;
e += ddis2;
if (e>=ddis1){
e -= ddis1;
(*p_co2)+=dn2;
}
}
}
else { // （ＲＧＢ版）
for(i=start;i<=end;i++){
d_pix.set_pos(pos_x, pos_y);
d_pix.set_col(r, g, b, rate);
(*p_co1)+=dn1;
e += ddis2;
if (e>=ddis1){
e -= ddis1;
(*p_co2)+=dn2;
}
}
}
return ;
};
// 直線描画 補正
GT_IMG::adjust_lining_limit(int *p_start, int *p_end, int sx, int sy, int ex, int ey, int *p_cx, int *p_cy){
int img_lim, img_lim_other, base_lim, other_lim;
int *p_res, base_co, other_co, tmp, cx, cy;
cx=*p_cx=ex-sx;
cy=*p_cy=ey-sy;
int base_axis = (abs(cx)>abs(cy))? 'x' : 'y';
*p_start = *p_end = 0;
if (!cx && !cy) return -1;
// x,yの長いほうの座標軸をベースにする
if (base_axis=='x'){ // x 座標ベース
img_lim = m_width;
img_lim_other = m_height;
base_lim = cx;
other_lim = cy;
}
else{ // y 座標ベース
img_lim = m_height;
img_lim_other = m_width;
base_lim = cy;
other_lim = cx;
}
for(int i=0;i<2;i++){
if (i==0) {
p_res = p_start;
base_co = (base_axis=='x')? sx : sy;
other_co = (base_axis=='x')? sy : sx;
}
else if (i==1) {
p_res = p_end;
base_co = (base_axis=='x')? ex : ey;
other_co = (base_axis=='x')? ey : ex;
other_lim = -other_lim;
}
// x,yの長いほうの座標軸で判定
if (base_co<0) *p_res=-base_co;
if (base_co>=img_lim) *p_res= base_co-img_lim+1;
// x,yの短いほうの座標軸で判定
if (!other_lim) continue;
tmp = other_co + ((*p_res) * (2*other_lim) + abs(base_lim))/(2*base_lim);
int aim_co;
if (tmp<0) { aim_co = -other_co; }
else if (tmp>=img_lim_other) { aim_co = other_co-img_lim_other+1; }
else continue; // 範囲内
tmp = aim_co*2*abs(base_lim)-abs(base_lim);
*p_res = tmp/abs(2*other_lim);
if (i==0 && tmp%abs(2*other_lim)) (*p_res)++;
if (i==1) (*p_res)++;
}
*p_end = abs(base_lim) - *p_end;
return 0;
}
// コンストラクタ
GT_IMG::GT_IMG(){
m_col_mask =NULL;
m_alpha =NULL;
m_width = m_height = m_byte_width = m_bit_count =0;
m_pbits =NULL;
}
// デストラクタ
GT_IMG::~GT_IMG(){
destroy();
}
// GIMG 破棄
GT_IMG::destroy(){
m_width=0;
m_height=0;
m_byte_width=0;
m_bit_count=0;
if (m_pbits) delete[] m_pbits;
m_pbits = NULL;
if (m_col_mask) delete[] m_col_mask;
m_col_mask = NULL;
m_col_table.destroy();
return 0;
};
// GIMG 作成
GT_IMG::create(int cx, int cy, int a_bit_count, int a_color_size){
int i, palette_len, info_size;
destroy(); // ファイルが開けたら既存データ破棄
if (cx<=0 || cy<=0) return -1;
if (a_bit_count!=1 && a_bit_count!=4 && a_bit_count!=8
&& a_bit_count!=16 && a_bit_count!=24 && a_bit_count!=32) return -1;
if (a_bit_count<=8 && a_color_size==0) palette_len=1<<a_bit_count; // 8bit以下でパレット色数指定無しなら
else palette_len=a_color_size;
// パレット・メモリ確保
m_col_table.make(palette_len);
/* バッファの１ラインの長さを計算 */
m_byte_width=4*((cx*a_bit_count+31)/32);
m_pbits = new BYTE[m_byte_width*cy];
ZeroMemory(m_pbits, m_byte_width*cy);
if (!m_pbits) return -1;
m_width= cx;
m_height=cy;
m_bit_count=a_bit_count;
// パレット自動配色
// 適当な基本色
RGBTRIPLE rgb[8]={
{0,0,0},{255, 255, 255}, {0,0,255}, {255,0,0}, {0,255,0}, {255, 255,0}, {255,0,255},{0,255,255}
};
for(i=0;i<min(palette_len, 8);i++){
m_col_table.add_col(rgb[i].rgbtRed, rgb[i].rgbtGreen, rgb[i].rgbtBlue);
}
return 0;
}
// パレットに色設定
inline GT_IMG::set_pal_col(BYTE index, BYTE r, BYTE g, BYTE b){
if (m_col_table.m_cols_len<=index) return 0;
m_col_table.set_col(index, r, g, b);
return 0;
}
// カラーマスク設定
GT_IMG::set_col_mask(UINT r, UINT g, UINT b){
if (!m_col_mask) m_col_mask = new unsigned long[3];
m_col_mask[0] = r;
m_col_mask[1] = g;
m_col_mask[2] = b;
}
// １点ピクセル取得
DWORD GT_IMG::get_pixel(int x, int y){
if (!m_pbits) return 0;
if (x<0 || x>=m_width || y<0 || y>=m_height) return 0;
BYTE *ppix;
ppix=m_pbits+(m_height-y-1)*m_byte_width + (x*m_bit_count>>3);
switch(m_bit_count){
case 1: return 0x01 & (*ppix >> (7-(x&7)));
case 4: return 0x0f & (*ppix >> ((x&1)?0:4));
case 8: return *ppix ;
case 16: return *(WORD*)ppix;
case 24: return 0x00FFffFF & *(DWORD*)ppix;
case 32: return *(DWORD*)ppix ;
}
return 0;
}
// １点ピクセル書きこみ
GT_IMG::set_pixel(int x, int y, DWORD col){
if (!m_pbits) return 0;
if (x<0 || x>=m_width || y<0 || y>=m_height) return 0;
BYTE *ppix;
ppix=m_pbits+(m_height-y-1)*m_byte_width + (x*m_bit_count>>3);
switch(m_bit_count){
case 1: *ppix &= ~(1 <<(7-(x&7)));
*ppix |= ((bool)col) <<(7-(x&7));
break;
case 4: *ppix &= 0x0f << ((x&1)?4:0);
*ppix |= (0x0f & col) << ((x&1)?0:4);
break;
case 8: *ppix = (BYTE)col; break;
case 16: *(WORD*)ppix = (WORD)col; break;
case 24: *(RGBTRIPLE*)ppix = *(RGBTRIPLE*)&col; break;
case 32: *(DWORD*)ppix = *(DWORD*)&col; break;
}
return 0;
}
// ======== GT_DIB ==================================
class GT_DIB : public GT_IMG{
public :
HDC m_hdc;
HBITMAP m_hbmp;
GT_DIB();
~GT_DIB();
// DC 適用
apply_dc(HDC hdc);
apply_dc(HWND hwnd);
// 作成と破棄
create(int cx, int cy, int a_bit_count, int a_color_size=0);
virtual destroy();
// カラー
apply_palette_all();
set_pal_col(BYTE index, BYTE r, BYTE g, BYTE b);
};
// コンストラクタ
GT_DIB::GT_DIB(){
m_hdc = NULL;
m_hbmp = NULL;
}
// デストラクタ
GT_DIB::~GT_DIB(){
destroy();
}
// HDCパレット設定(全て）
GT_DIB::apply_palette_all(){
return m_col_table.apply_palette_all(m_hdc);
}
// パレットに色設定
inline GT_DIB::set_pal_col(BYTE index, BYTE r, BYTE g, BYTE b){
return m_col_table.set_pal_col(m_hdc, index, r, g, b);
}
// ＤＣ有効化
GT_DIB::apply_dc(HDC hdc){
if (m_hdc) { DeleteDC(m_hdc); m_hdc=NULL; }
m_hdc = CreateCompatibleDC(hdc);
SelectObject(m_hdc, m_hbmp);
return 0;
}
// ＤＣ有効化(HWND hwnd)
GT_DIB::apply_dc(HWND hwnd){
if (m_hdc) { DeleteDC(m_hdc); m_hdc=NULL; }
HDC hwnd_hdc = GetDC(hwnd);
m_hdc = CreateCompatibleDC(hwnd_hdc);
SelectObject(m_hdc, m_hbmp);
ReleaseDC(hwnd, hwnd_hdc);
return 0;
}
// 破棄
GT_DIB::destroy(){
if (m_hdc) { DeleteDC(m_hdc); m_hdc=NULL; }
if (m_hbmp) { DeleteObject(m_hbmp); m_hbmp=NULL; }
// if (m_pbits) delete[] m_pbits;
m_pbits = NULL;
m_width=0;
m_height=0;
m_byte_width=0;
m_bit_count=0;
if (m_col_mask) delete[] m_col_mask;
m_col_mask = NULL;
m_col_table.destroy();
return 0;
}
// 作成
GT_DIB::create(int cx, int cy, int a_bit_count, int a_color_size){
BITMAPINFO *bmp_info;
int i, palette_entry, info_size;
destroy(); // 作成済みメモリを破棄する
if (cx<=0 || cy<=0) return -1;
if (a_bit_count!=1 && a_bit_count!=4 && a_bit_count!=8
&& a_bit_count!=16 && a_bit_count!=24 && a_bit_count!=32) return -1;
palette_entry=1;
if (a_color_size!=0) palette_entry=a_color_size;
else if (a_bit_count<=8) palette_entry=1<<a_bit_count; // 8bit以下でパレット色数指定無しなら
info_size=sizeof(BITMAPINFOHEADER) + (palette_entry-1)*sizeof(RGBQUAD)+1;
bmp_info = (BITMAPINFO*)malloc(info_size);
if (!bmp_info) return -1;
ZeroMemory(bmp_info, info_size);
// 適当な基本色
RGBTRIPLE rgb[8]={
{0,0,0},{255, 255, 255}, {0,0,255}, {255,0,0}, {0,255,0}, {255, 255,0}, {255,0,255},{0,255,255}
};
m_col_table.make(palette_entry);
for(i=0;i<min(palette_entry, 8);i++){
bmp_info->bmiColors[i].rgbBlue = rgb[i].rgbtBlue;
bmp_info->bmiColors[i].rgbGreen = rgb[i].rgbtGreen;
bmp_info->bmiColors[i].rgbRed = rgb[i].rgbtRed;
bmp_info->bmiColors[i].rgbReserved = 0;
m_col_table.add_col(rgb[i].rgbtRed, rgb[i].rgbtGreen, rgb[i].rgbtBlue);
}
/* BITMAPINFO構造体設定 */
bmp_info->bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
bmp_info->bmiHeader.biWidth=cx;
bmp_info->bmiHeader.biHeight=cy;
bmp_info->bmiHeader.biPlanes=1;
bmp_info->bmiHeader.biBitCount=a_bit_count;
bmp_info->bmiHeader.biCompression=BI_RGB;
bmp_info->bmiHeader.biSizeImage=0;
bmp_info->bmiHeader.biXPelsPerMeter=0;
bmp_info->bmiHeader.biYPelsPerMeter=0;
bmp_info->bmiHeader.biClrUsed=palette_entry;
bmp_info->bmiHeader.biClrImportant=0;
m_hbmp = CreateDIBSection(NULL, bmp_info, DIB_RGB_COLORS, (VOID**)&m_pbits, NULL, 0);
if (!m_hbmp) {
free(bmp_info);
return -1;
}
m_width= cx;
m_height=cy;
m_bit_count=a_bit_count;
/* バッファの１ラインの長さを計算 */
m_byte_width=4*((m_width*m_bit_count+31)/32);
ZeroMemory(m_pbits, m_byte_width*m_height);
free(bmp_info);
return 0;
}
|
それぞれ整数値での
