326 lines
11 KiB
Plaintext
326 lines
11 KiB
Plaintext
(*
|
|
* CDDL HEADER START
|
|
*
|
|
* The contents of this file are subject to the terms of the
|
|
* Common Development and Distribution License, Version 1.0 only
|
|
* (the "License"). You may not use this file except in compliance
|
|
* with the License.
|
|
*
|
|
* You can obtain a copy of the license at
|
|
* http://www.opensource.org/licenses/cddl1.php.
|
|
* See the License for the specific language governing permissions
|
|
* and limitations under the License.
|
|
*
|
|
* When distributing Covered Code, include this CDDL HEADER in each
|
|
* file and include the License file at
|
|
* http://www.opensource.org/licenses/cddl1.php. If applicable,
|
|
* add the following below this CDDL HEADER, with the fields enclosed
|
|
* by brackets "[]" replaced with your own identifying * information:
|
|
* Portions Copyright [yyyy] [name of copyright owner]
|
|
*
|
|
* CDDL HEADER END
|
|
*
|
|
*
|
|
* Portions Copyright 2009 Andreas Schneider
|
|
*)
|
|
unit UArt;
|
|
|
|
{$mode objfpc}{$H+}
|
|
|
|
interface
|
|
|
|
uses
|
|
Classes, Imaging, ImagingTypes, ImagingCanvases, ImagingClasses,
|
|
UMulBlock, UGenericIndex, UHue;
|
|
|
|
type
|
|
TArtType = (atLand, atStatic, atLandFlat);
|
|
TArt = class(TMulBlock)
|
|
constructor Create(AData: TStream; AIndex: TGenericIndex; AArtType: TArtType); overload;
|
|
constructor Create(AData: TStream; AIndex: TGenericIndex; AArtType: TArtType; AHue: THue; APartialHue: Boolean); overload;
|
|
constructor Create(AData: TStream; AIndex: TGenericIndex; AArtType: TArtType; AArtColor: Word; AHue: THue; APartialHue: Boolean); overload;
|
|
destructor Destroy; override;
|
|
function Clone: TArt; override;
|
|
function GetSize: Integer; override;
|
|
procedure Write(AData: TStream); override;
|
|
procedure RefreshBuffer;
|
|
protected
|
|
FArtType: TArtType;
|
|
FHeader: LongInt;
|
|
FGraphic: TSingleImage;
|
|
FBuffer: TStream;
|
|
public
|
|
property ArtType: TArtType read FArtType write FArtType;
|
|
property Header: LongInt read FHeader write FHeader;
|
|
property Graphic: TSingleImage read FGraphic;
|
|
property Buffer: TStream read FBuffer;
|
|
end;
|
|
|
|
implementation
|
|
|
|
type
|
|
PWordArray = ^TWordArray;
|
|
TWordArray = array[0..(MaxInt div SizeOf(Word) - 1)] of Word;
|
|
|
|
constructor TArt.Create(AData: TStream; AIndex: TGenericIndex; AArtType: TArtType);
|
|
begin
|
|
Create(AData, AIndex, AArtType, 0, nil, False);
|
|
end;
|
|
|
|
constructor TArt.Create(AData: TStream; AIndex: TGenericIndex; AArtType: TArtType; AHue: THue; APartialHue: Boolean);
|
|
begin
|
|
Create(AData, AIndex, AArtType, 0, AHue, APartialHue);
|
|
end;
|
|
|
|
constructor TArt.Create(AData: TStream; AIndex: TGenericIndex; AArtType: TArtType; AArtColor: Word; AHue: THue; APartialHue: Boolean);
|
|
var
|
|
i, x, y, start: Integer;
|
|
iCurrentHeight, iCurrentWidth: Integer;
|
|
width, height: SmallInt;
|
|
lookup: array of integer;
|
|
color, run, offset: Word;
|
|
block: TMemoryStream;
|
|
P: PWordArray;
|
|
r, g, b: Byte;
|
|
|
|
begin
|
|
FBuffer := TMemoryStream.Create;
|
|
FArtType := AArtType;
|
|
AArtColor := AArtColor or $8000; //set alpha bit on background
|
|
if Assigned(AData) and (AIndex.Lookup > -1) then
|
|
begin
|
|
AData.Position := AIndex.Lookup;
|
|
block := TMemoryStream.Create;
|
|
block.CopyFrom(AData, AIndex.Size);
|
|
block.Position := 0;
|
|
|
|
if AArtType = atLand then
|
|
begin
|
|
FGraphic:= TSingleImage.CreateFromParams(44, 44, ifA1R5G5B5);
|
|
FillWord(FGraphic.Bits^, 44 * 44, AArtColor);
|
|
for y := 0 to 21 do
|
|
begin
|
|
P := FGraphic.Bits + y * 44 * 2;
|
|
block.Read(P^[22 - (y + 1)], (y + 1) * 4);
|
|
end;
|
|
for y := 0 to 21 do
|
|
begin
|
|
P := FGraphic.Bits + (22 + y) * 44 * 2;
|
|
block.Read(P^[y], (22 - y) * 4);
|
|
end;
|
|
for i := 0 to 44 * 44 - 1 do
|
|
PWordArray(FGraphic.Bits)^[i] := PWordArray(FGraphic.Bits)^[i] xor $8000; //invert alpha bit
|
|
end else if AArtType = atLandFlat then
|
|
begin
|
|
FGraphic:= TSingleImage.CreateFromParams(44, 44, ifA1R5G5B5);
|
|
for i := 1 to 22 do
|
|
begin
|
|
for x := 0 to i * 2 - 1 do
|
|
begin
|
|
y := i * 2 - x - 1;
|
|
block.Read(color, SizeOf(Word));
|
|
PWordArray(FGraphic.Bits + y * 44 * 2)^[x] := color;
|
|
if y > 0 then
|
|
PWordArray(FGraphic.Bits + (y - 1) * 44 * 2)^[x] := color;
|
|
end;
|
|
end;
|
|
for i := 22 to 43 do
|
|
begin
|
|
for y := 0 to (44 - i) * 2 - 1 do
|
|
begin
|
|
x := 42 - (43 - i) * 2 + y;
|
|
block.Read(color, SizeOf(Word));
|
|
PWordArray(FGraphic.Bits + (43 - y) * 44 * 2)^[x] := color;
|
|
if y > 0 then
|
|
PWordArray(FGraphic.Bits + (44 - y) * 44 * 2)^[x] := color;
|
|
end;
|
|
end;
|
|
for i := 0 to 44 * 44 - 1 do
|
|
PWordArray(FGraphic.Bits)^[i] := PWordArray(FGraphic.Bits)^[i] xor $8000; //invert alpha bit
|
|
end else if AArtType = atStatic then
|
|
begin
|
|
block.Read(FHeader, SizeOf(LongInt));
|
|
block.Read(width, SizeOf(SmallInt));
|
|
block.Read(height, SizeOf(SmallInt));
|
|
FGraphic:= TSingleImage.CreateFromParams(width, height, ifA1R5G5B5);
|
|
FillWord(FGraphic.Bits^, width * height, AArtColor);
|
|
SetLength(lookup, height);
|
|
start := block.Position + (height * 2);
|
|
for i := 0 to height - 1 do
|
|
begin
|
|
block.Read(offset, SizeOf(Word));
|
|
lookup[i] := start + (offset * 2);
|
|
end;
|
|
for iCurrentHeight := 0 to height - 1 do
|
|
begin
|
|
block.Position := lookup[iCurrentHeight];
|
|
iCurrentWidth := 0;
|
|
P := FGraphic.Bits + iCurrentHeight * width * 2;
|
|
while (block.Read(offset, SizeOf(Word)) = SizeOf(Word)) and
|
|
(block.Read(run, SizeOf(Word)) = SizeOf(Word)) and
|
|
(offset + run <> 0) do
|
|
begin
|
|
inc(iCurrentWidth, offset);
|
|
for i := 0 to run - 1 do
|
|
begin
|
|
block.Read(color, SizeOf(Word));
|
|
P^[iCurrentWidth + i] := color;
|
|
end;
|
|
inc(iCurrentWidth, run);
|
|
end;
|
|
end;
|
|
|
|
if AHue <> nil then
|
|
begin
|
|
for i := 0 to width * height - 1 do
|
|
begin
|
|
color := PWordArray(FGraphic.Bits)^[i];
|
|
if color <> AArtColor then
|
|
begin
|
|
r := (color and $7C00) shr 10;
|
|
if APartialHue then
|
|
begin
|
|
g := (color and $3E0) shr 5;
|
|
b := color and $1F;
|
|
if (r = g) and (g = b) then
|
|
color := AHue.ColorTable[r];
|
|
end else
|
|
color := AHue.ColorTable[r];
|
|
end;
|
|
PWordArray(FGraphic.Bits)^[i] := color;
|
|
end;
|
|
end;
|
|
|
|
for i := 0 to width * height - 1 do
|
|
PWordArray(FGraphic.Bits)^[i] := PWordArray(FGraphic.Bits)^[i] xor $8000; //invert alpha bit
|
|
end else
|
|
FGraphic:= TSingleImage.Create;
|
|
if Assigned(block) then block.Free;
|
|
end else
|
|
begin
|
|
FHeader := 1;
|
|
FGraphic := TSingleImage.Create;
|
|
end;
|
|
FGraphic.Format := ifA8R8G8B8;
|
|
end;
|
|
|
|
destructor TArt.Destroy;
|
|
begin
|
|
if assigned(FGraphic) then FGraphic.Free;
|
|
if assigned(FBuffer) then FBuffer.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TArt.Clone: TArt;
|
|
begin
|
|
Result := TArt.Create(nil, nil, FArtType);
|
|
Result.FHeader := FHeader;
|
|
Result.FGraphic.Assign(FGraphic);
|
|
end;
|
|
|
|
procedure TArt.Write(AData: TStream);
|
|
begin
|
|
FBuffer.Position := 0;
|
|
AData.CopyFrom(FBuffer, FBuffer.Size);
|
|
end;
|
|
|
|
function TArt.GetSize: Integer;
|
|
begin
|
|
RefreshBuffer;
|
|
Result := FBuffer.Size
|
|
end;
|
|
|
|
procedure TArt.RefreshBuffer;
|
|
var
|
|
argbGraphic: TSingleImage;
|
|
i, x, y, lineWidth, start: Integer;
|
|
iCurrentHeight, iCurrentWidth: Integer;
|
|
width, height: SmallInt;
|
|
color, run, offset: Word;
|
|
lookup: array of SmallInt;
|
|
begin
|
|
argbGraphic := TSingleImage.CreateFromImage(FGraphic);
|
|
argbGraphic.Format := ifA1R5G5B5;
|
|
for i := 0 to argbGraphic.Width * argbGraphic.Height - 1 do
|
|
PWordArray(argbGraphic.Bits)^[i] := PWordArray(argbGraphic.Bits)^[i] xor $8000; //invert alpha bit
|
|
FBuffer.Size := 0;
|
|
if FArtType = atLand then
|
|
begin
|
|
if (argbGraphic.Height <> 44) or (argbGraphic.Width <> 44) then Exit;
|
|
x := 21;
|
|
y := 0;
|
|
lineWidth := 2;
|
|
for i := 1 to 22 do
|
|
begin
|
|
Dec(x);
|
|
FBuffer.Write(PWordArray(argbGraphic.Bits + y * 44 * 2)^[x + i], lineWidth);
|
|
Inc(y);
|
|
Inc(lineWidth, 2);
|
|
end;
|
|
for i := 1 to 22 do
|
|
begin
|
|
Dec(lineWidth, 2);
|
|
FBuffer.Write(PWordArray(argbGraphic.Bits + y * 44 * 2)^[x + i], lineWidth);
|
|
Inc(x);
|
|
Inc(y);
|
|
end;
|
|
end else if FArtType = atStatic then
|
|
begin
|
|
if (argbGraphic.Height = 0) or (argbGraphic.Width = 0) then Exit;
|
|
width := argbGraphic.Width;
|
|
height := argbGraphic.Height;
|
|
FBuffer.Write(FHeader, SizeOf(LongInt));
|
|
FBuffer.Write(width, SizeOf(SmallInt));
|
|
FBuffer.Write(height, SizeOf(SmallInt));
|
|
SetLength(lookup, height);
|
|
for i := 0 to height - 1 do
|
|
FBuffer.Write(lookup[i], SizeOf(SmallInt)); //placeholders for the lookup table
|
|
start := FBuffer.Position;
|
|
for iCurrentHeight := 0 to height - 1 do
|
|
begin
|
|
lookup[iCurrentHeight] := SmallInt((FBuffer.Position - start) div 2); //remember the lookup offset for the current line
|
|
offset := 0;
|
|
run := 0;
|
|
for iCurrentWidth := 0 to width - 1 do //process every pixel on the current line
|
|
begin
|
|
color := PWordArray(FGraphic.Bits + iCurrentHeight * width * 2)^[iCurrentWidth];
|
|
if (color and $8000 = 0) and (run = 0) then //new visible pixel found
|
|
begin
|
|
FBuffer.Write(offset, SizeOf(Word));
|
|
FBuffer.Write(offset, SizeOf(Word)); //just a placeholder for the "run length"
|
|
run := 1;
|
|
FBuffer.Write(color, SizeOf(Word));
|
|
end else if (color and $8000 = 0) and (run > 0) then //another visible pixel found
|
|
begin
|
|
inc(run);
|
|
FBuffer.Write(color, SizeOf(Word));
|
|
end else if (color and $8000 = $8000) and (run > 0) then //after some visible pixels this one is invisible, so stop the current run
|
|
begin
|
|
FBuffer.Seek(Integer(-((run + 1) * 2)), soFromCurrent); //jump back ...
|
|
FBuffer.Write(run, SizeOf(Word)); //... to write the actual "run length" ...
|
|
FBuffer.Seek(Integer(run * 2), soFromCurrent); //... and jump forth again to proceed
|
|
run := 0;
|
|
offset := 1;
|
|
end else
|
|
inc(offset);
|
|
end;
|
|
if run > 0 then //no more pixels but the "run" didn't end yet ;-)
|
|
begin
|
|
FBuffer.Seek(Integer(-((run + 1) * 2)), soFromCurrent);
|
|
FBuffer.Write(run, SizeOf(Word));
|
|
FBuffer.Seek(Integer(run * 2), soFromCurrent);
|
|
run := 0;
|
|
end;
|
|
FBuffer.Write(run, SizeOf(Word)); //just write "0"
|
|
FBuffer.Write(run, SizeOf(Word)); //... two times, to indicate the end of that line
|
|
end;
|
|
FBuffer.Position := start - (height * 2); //now update the lookup table with our new values
|
|
for i := 0 to height - 1 do
|
|
FBuffer.Write(lookup[i], SizeOf(SmallInt));
|
|
end;
|
|
argbGraphic.Free;
|
|
end;
|
|
|
|
end.
|
|
|