{
Ported to FPC by Nikolay Nikolov (nickysn@users.sourceforge.net)
}
{
Lights demo for OpenPTC 1.0 C++ API
Copyright (c) Glenn Fiedler (ptc@gaffer.org)
This source code is licensed under the GNU GPL
}
program Lights;
{$MODE objfpc}
{$INLINE on}
uses
ptc;
var
{ distance lookup table }
distance_table: array [0..299, 0..511] of DWord; { note: 16.16 fixed }
{ intensity calculation }
function CalcIntensity(dx, dy: Integer; i: DWord): DWord; Inline;
begin
{ lookup intensity at [dx,dy] }
Result := i * distance_table[dy, dx];
end;
var
console: IPTCConsole;
surface: IPTCSurface;
format: IPTCFormat;
palette: IPTCPalette;
dx, dy: Integer;
divisor: Single;
data: PUint32;
pixels, line: PUint8;
width: Integer;
i: Integer;
x, y, x1, y1, x2, y2, x3, y3, x4, y4: Integer;
cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4: Single;
dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4: Single;
_dx1, _dx2, _dx3, _dx4: Integer;
_dy1, _dy2, _dy3, _dy4: Integer;
ix1, ix2, ix3, ix4: Integer;
i1, i2, i3, i4: DWord;
length: Integer;
move_t, move_dt, move_ddt: Single;
flash_t, flash_dt, flash_ddt: Single;
intensity: DWord;
max_intensity, max_intensity_inc: Single;
begin
try
try
{ create console }
console := TPTCConsoleFactory.CreateNew;
format := TPTCFormatFactory.CreateNew(8);
{ open console }
console.open('Lights demo', 320, 200, format);
{ create surface }
surface := TPTCSurfaceFactory.CreateNew(320, 200, format);
{ setup intensity table }
for dy := 0 to 199 do
for dx := 0 to 511 do
begin
divisor := sqrt((dx * dx) + (dy * dy));
if divisor < 0.3 then
divisor := 0.3;
distance_table[dy, dx] := Trunc(65535 / divisor);
end;
{ create palette }
palette := TPTCPaletteFactory.CreateNew;
{ generate greyscale palette }
data := palette.Lock;
try
for i := 0 to 255 do
data[i] := (i shl 16) or (i shl 8) or i;
finally
palette.Unlock;
end;
{ set console palette }
console.palette(palette);
{ set surface palette }
surface.palette(palette);
{ data }
cx1 := 60;
cy1 := 110;
cx2 := 100;
cy2 := 80;
cx3 := 250;
cy3 := 110;
cx4 := 200;
cy4 := 90;
dx1 := 0;
dy1 := 0;
dx2 := 0;
dy2 := 0;
dx3 := 0;
dy3 := 0;
dx4 := 0;
dy4 := 0;
i1 := 0;
i2 := 0;
i3 := 0;
i4 := 0;
{ time data }
move_t := 0.3;
move_dt := 0.1;
move_ddt := 0.0006;
flash_t := 0.1;
flash_dt := 0.0;
flash_ddt := 0.0004;
{ control data }
max_intensity := 30;
max_intensity_inc := 0.2;
{ main loop }
while not console.KeyPressed do
begin
{ source positions }
x1 := Trunc(cx1 + dx1);
y1 := Trunc(cy1 + dy1);
x2 := Trunc(cx2 + dx2);
y2 := Trunc(cy2 + dy2);
x3 := Trunc(cx3 + dx3);
y3 := Trunc(cy3 + dy3);
x4 := Trunc(cx4 + dx4);
y4 := Trunc(cy4 + dy4);
{ lock surface }
pixels := surface.lock;
try
{ get surface dimensions }
width := surface.width;
{ line loop }
for y := 0 to 199 do
begin
{ calcalate pointer to start of line }
line := pixels + y * width;
{ get y deltas }
_dy1 := abs(y - y1);
_dy2 := abs(y - y2);
_dy3 := abs(y - y3);
_dy4 := abs(y - y4);
{ setup x }
x := 0;
{ line loop }
while x < width do
begin
{ get x deltas }
_dx1 := abs(x1 - x);
_dx2 := abs(x2 - x);
_dx3 := abs(x3 - x);
_dx4 := abs(x4 - x);
{ get increments }
ix1 := 1;
ix2 := 1;
ix3 := 1;
ix4 := 1;
if x1 > x then
ix1 := -1;
if x2 > x then
ix2 := -1;
if x3 > x then
ix3 := -1;
if x4 > x then
ix4 := -1;
{ set span length to min delta }
length := width - x;
if (x1 > x) and (_dx1 < length) then
length := _dx1;
if (x2 > x) and (_dx2 < length) then
length := _dx2;
if (x3 > x) and (_dx3 < length) then
length := _dx3;
if (x4 > x) and (_dx4 < length) then
length := _dx4;
{ pixel loop }
while length > 0 do
begin
Dec(length);
{ calc intensities }
intensity := CalcIntensity(_dx1, _dy1, i1);
Inc(intensity, CalcIntensity(_dx2, _dy2, i2));
Inc(intensity, CalcIntensity(_dx3, _dy3, i3));
Inc(intensity, CalcIntensity(_dx4, _dy4, i4));
intensity := intensity shr 16;
if intensity > 255 then
intensity := 255;
{ update deltas }
Inc(_dx1, ix1);
Inc(_dx2, ix2);
Inc(_dx3, ix3);
Inc(_dx4, ix4);
{ store the pixel }
line[x] := intensity;
Inc(x);
end;
end;
end;
finally
{ unlock surface }
surface.unlock;
end;
{ move the lights around }
dx1 := 50 * sin((move_t + 0.0) * 0.10);
dy1 := 80 * sin((move_t + 0.6) * 0.14);
dx2 := 100 * sin((move_t + 0.1) * 0.10);
dy2 := 30 * sin((move_t - 0.4) * 0.30);
dx3 := 39 * sin((move_t + 9.9) * 0.20);
dy3 := 50 * sin((move_t + 0.4) * 0.30);
dx4 := 70 * sin((move_t - 0.3) * 0.25);
dy4 := 40 * sin((move_t - 0.1) * 0.31);
{ flash intensity }
i1 := Trunc(max_intensity * (sin((flash_t + 0.000) * 1.000) + 1));
i2 := Trunc(max_intensity * (sin((flash_t + 2.199) * 0.781) + 1));
i3 := Trunc(max_intensity * (sin((flash_t - 1.450) * 1.123) + 1));
i4 := Trunc(max_intensity * (sin((flash_t + 0.000) * 0.500) + 1));
{ update time }
move_t := move_t + move_dt;
move_dt := move_dt + move_ddt;
flash_t := flash_t + flash_dt;
flash_dt := flash_dt + flash_ddt;
{ reset on big flash... }
if (move_t > 600) and (i1 > 10000) and (i2 > 10000) and
(i3 > 10000) and (i4 > 10000) then
begin
move_t := 0.3;
move_dt := 0.1;
move_ddt := 0.0006;
flash_t := 0.1;
flash_dt := 0.0;
flash_ddt := 0.0004;
max_intensity := 0.0;
max_intensity_inc := 0.2;
end;
{ update intensity }
max_intensity := max_intensity + max_intensity_inc;
max_intensity_inc := max_intensity_inc + 0.008;
{ copy surface to console }
surface.copy(console);
{ update console }
console.update;
end;
finally
if Assigned(console) then
console.close;
end;
except
on error: TPTCError do
{ report error }
error.report;
end;
end.
