2D Бампмэппинг (Bumpmapping)

Чтобы сделать правильный 2d бампмэппинг надо посчитать нормаль для каждого пиксела в bumpmap (карте высот) и для вычисления цвета каждого пиксела использовать угол между источником света и данной нормалью.

Для бампмэппинга в нашем случае используется источник света, бесконечно близкий к освещаемой плоскости: координаты нормали nx и ny просто разность высот между соседними пикселaми в bumpmap по осям X и Y.

Так как нормаль - просто вектор направления, и ее длина равна единице, то nz=1-sqrt(nx2 + ny2).

1. Заранее вычисляем интенсивность света (light map) по вышеприведенной формуле. (Световое пятно с максимальной интенсивностью в центре). Полагаем как обычно, что интенсивность зависит от n_z. Пусть размер таблички будет для удобства 256x256.

2. Подбирая из lightmap интенсивность по формуле: outvalue = lightmap[n_x+128][n_y+128] (если использовать нормали в диапазоне -128...+127) мы получим корректную картину освещения для бесконечно близкого источника.

 
n_x = bumpmap[x+1][y] - bumpmap[x-1][y]
n_y = bumpmap[x][y+1] - bumpmap[x][y-1]
 
Конечный цвет определяется так:
outvalue:=lightmap[(n_x-(lightx-currentx))][(n_y-(lighty-currenty))].
Также нужно проверить, находимся ли мы внутри диапазона lightmap.
 
Вот пример:

Program Bumpy_Surface;
 
{Hичего не USES}
 
type Tscr=array[0..199,0..319] of byte;
 
     SegmentT = Array[0..65534] of byte;
 
     Virseg = ^SegmentT;
 
var
 
scr:Tscr absolute $A000:0000;
 
buf:Tscr;
 
  ilx,ily:integer;
 
  i,j,k,nx,ny,nz,rx,ry,x,y,lx,ly,x1,y1:integer;
 
  tx,ty,tz:real;
 
var segm,offs:integer;
 
 Segment : Virseg;
 
 litemap : word;
 
Procedure SetUpSegment(VAR segname:virseg;VAR add : word);
 
begin GetMem (Segname,65534); add := seg (Segname^); end;
 
Procedure wait; assembler;
 
asm mov dx,3DAh;
 
@l1:in al,dx;and al,08h;jnz @l1;
 
@l2:in al,dx;and al,08h;jz @l2;end;
 
Procedure SetMode (Mode:word);assembler; asm mov ax,Mode; int 10h end;
 
Procedure FillBox(x,y,w,h:integer; color:byte);
 
var i,j,k:integer;
 
begin for i:=y to y+h-1 do for j:=x to x+w-1 do buf[i,j]:=color; end;
 
Procedure Print(x,y:integer; s:string; xs,ys:integer; color:byte);
 
var i,j,k,c,px,py:integer; b:byte;
 
begin px:=x;py:=y; for k:=1 to length(s) do begin c:=ord(s[k]);
 
for i:=0 to 7
 do begin b:=mem[segm:offs+c*8+i]; for j:=0 to 7 do begin
 
if b shl j and 128<>0 
     then FillBox(x,y,xs,ys,color); x:=x+xs; end;
 
x:=px; y:=y+ys; end; y:=py; px:=px+xs*8; x:=px; end;
 
end;
 
Procedure SetGradientPalette; var k,r,g,b:byte;
 
begin asm mov  dx,03c8h; xor  al,al;out  dx,al;end;
 
r:=0; g:=0; for k:=0 to 255 do begin b:=(k*63 div 255);
 
{r:=b; g:=b;{} if k>200 then begin r:=r+1;g:=g+1;end;
 
asm mov dx,03c9h; mov al,r;out dx,al;
 
mov al,g;out dx,al; mov al,b;out dx,al end;
 
end;end;
 
Procedure Blur;
 
var i,j,k:integer;
 
begin for i:=0 to 199 do for j:=0 to 319 do
 
buf[i,j]:=(buf[i-1,j]+buf[i+1,j]+buf[i,j-1]+buf[i,j+1]) div 4;
 
end;
 
Procedure ASMBumpmapping;assembler;
 
asm
 
{few times faster ;) }
 
    mov ax, seg buf
 
    mov es,ax
 
    mov ax, offset buf
 
    mov bx,320*3
 
    add ax,bx
 
    mov di,ax
 
    mov si,bx
 
    mov dx,199
 
    sub dx,5
 
@1: mov cx,320
 
@2: xor bh,bh; xor ah,ah;
 
    mov al, es:[di+1]
 
    mov bl, es:[di-1]
 
    sub ax,bx
 
    sub ax,320; add ax,cx; add ax,lx; add ax,128;
 
    cmp ax,255; jc @ok1; mov ax,255; @ok1:
 
    push ax
 
    xor ah,ah;
 
    mov al, es:[di+320]
 
    mov bl, es:[di-320]
 
    sub ax,bx
 
    sub ax,197; add ax,dx; add ax,ly; add ax,128;
 
    cmp ax,255; jc @ok2; mov ax,255; @ok2:
 
    pop bx
 
    mov bh,bl; mov bl,al
 
    push es
 
    mov ax, litemap
 
    mov es,ax
 
    and bx,0FFFEh
 
    mov bx,[es:bx]
 
    mov ax, 0A000h
 
    mov es,ax
 
    mov [es:si],bx
 
    pop es
 
    inc di
 
    inc si
 
    loop @2
 
    dec dx;
 
    jnz @1
 
    mov ax,$0a000
 
    mov es,ax
 
    xor ax,ax
 
    mov [es:si-1],ax
 
end;{asm Bumpmaping}
 
Procedure Bumpmapping;
 
begin
 
{Bumpmapping}
 
for y:=0+3 to 199-3 do begin
 
for x:=0 to 319 do begin
 
nx:=buf[y+1,x]-buf[y-1,x];
 
ny:=buf[y,x+1]-buf[y,x-1];
 
nx:=nx-x+lx;
 
ny:=ny-y+ly;
 
nx:=nx+128;
 
ny:=ny+128;
 
if (nx<0) or (nx>255) then nx:=0;
 
if (ny<0) or (ny>255) then ny:=0;
 
scr[y,x]:=mem[litemap:nX+nY*256]; end;
 
end;{ Bumpmapping }
 
end;
 
BEGIN
 
{Достанем адрес знакогенератора}
 
asm 
mov ax,$1130;
mov bh,03h;
int 10h;
mov segm,es;
mov offs,bp;
end;
 
{установим режим и палитру}
 
setmode($13); setgradientpalette;
 
{Cгенерируем световое пятно}
 
SetUpSegment(Segment,litemap);
 
for y:=0 to 255 do for x:=0 to 255 do begin
 
tX:=(x-128)/128.0;
 
tY:=(y-128)/128.0;
 
tZ:=1-sqrt(tX*tX+tY*tY);
 
if (tZ<0) then tZ:=0; mem[litemap:x+y*256]:=round(tz*254); end;
 
{ Очистим буфер }
 
fillchar(buf,64000,0);
 
{набросаем точек}
 
  for i:=0 to 10000 do fillbox(random(320),random(200),1,1,255);
 
{...и размоем их}
 
blur;
 
{Hапишем текст}
 
  print(60,65,'BUMPY',5,5,255);
 
  print(47,115,'SURFACE',4,4,255);
 
{...и опять размоем}
 
blur;blur;blur;
 
ilx:=5;ily:=5;
 
ly:=100;lx:=80;
 
REPEAT
 
{move(buf,scr,64000);}
 
 wait;
 
{Bumpmapping;}
 
ASMBumpmapping;
 
 lx:=lx+ilx;if (lx>320) or (lx<0) then ilx:=-ilx;
 
 ly:=ly+ily;if (ly>200) or (ly<0) then ily:=-ily;
 
UNTIL port[$60]=1;{ESC}
 
{сбросим буфер клавиатуры}
 
memw[$000:$041a]:=memw[$000:$041c];
 
setmode($3);
END.