(Ebook - Pdf) Kick Ass Delphi Programming

To access the contents, click the chapter and section titles.

Kick Ass Delphi Programming

Go!

Keyword

(Publisher: The Coriolis Group)

Author(s): Don Taylor, Jim Mischel, John Penman, Terence Goggin

ISBN: 1576100448

Publication Date: 09/01/96

Search this book:

Go!

-----------

To keep Shopper’s methods direct and simple, I’ve chosen not to use buttons for downloading and uploading files. To download a file, for example, simply click on the desired file. The key to making this technique work is to create a new event. When you add the RemFilesList listbox to the main form, define a new OnDblClick event using the Events page in the Object Inspector. This event is handled by the TMainForm.Rem FilesListDblClick procedure. The code fragment shows that in response to the event, Shopper1.Get is assigned a file name.

procedure TMainForm.RemFilesListDblClick(Sender: TObject); begin

if RemFilesList.ItemIndex = -1 then Exit; Shopper1.Get :=

RemFilesList.Items.Strings[RemFilesList.ItemIndex];

end;

Inside the Shopper component, the Get property passes the file name as Name to Retrieve. To ensure that the file is sent and stored correctly, SetUpFileTransfer checks the file’s extension. For a binary file (such as .EXE, .DLL, and ZIP), SetUpFileTransfer tells FTPCommand to send the TYPE IMAGE command, instructing the server to send the file as a stream of contiguous bytes. For non-binary files, SetUpFileTransfer employs the TYPE A command. After the FTP server acknowledges the TYPE command, SetUpFileTransfer sends the RETR file name command through FTPCommand.

When you double click on a directory name such as ‘\DELPHI’, no download occurs. Instead, SetUpFileTransfer calls ChangeDir to handle a directory change. ChangeDir then calls FTPCommand, sending the CWD command, followed by the ‘\DELPHI’ string to the FTP server. If the server accepts the command, it returns a reply code of 250. ChangeDir next sends the LIST command, via FTPCommand, to update the remote files directory listbox. Finally, Decode creates a new directory listing for the changed directory.

Internally, the process of uploading a file is similar to downloading, and the Shopper1.Put property accomplishes this task using its PutFile method. On the main form, to facilitate uploading a file from the client to the server, I derived the following listboxes: LocalDrive from TDriveComboBox, LocalDirList from TDirectoryListBox, and LocalFileList from TFileListBox. Each of these listboxes are synchronized. When you select a different drive in LocalDrive, the contents of

LocalDirList and LocalFileList are updated transparently. As with the RemFilesList listbox, I used the Events page in the Object Inspector to create a new OnDblClick event handler, TMainForm.LocalFileListDblClick, to handle a double click on a file in the LocalFileList listbox. A double click on the file you wish to upload tells

TMainForm.LocalFileListDblClick to call the Shopper1.Put method.

As written, FTPCLI uploads or downloads only a single file at a time. However, you can remedy this shortcoming by enabling the listboxes to handle multiple selections in the Object Inspector, and modifying the TShopper.SetUpFileTransfer and

TShopper.PutFile methods.

Odds and Ends

Shopper is an FTP client and a non-visual component, and has no provision for storing and retrieving host names, user names, passwords, and account information. Handling these is best left to the programmer, who can design these visible features to meet the needs of a specific application. Shopper’s use of published events makes it easy to use within a wrapper application.

Shopper has one additional published property, LogOn, that you can use to tell Shopper to track FTP calls during a session. To use this feature, set LogOn to True and go to the Events page of the Object Inspector. Double click on the

OnUpDateProgInfo event to derive a Shopper1UpDateLogInfo event handler. Then add the following code to this handler:

Writeln(LogFile, LogInfo);

The file variable, LogFile, is a text file which you would need to declare in MAIN.PAS. Note that using this option somewhat slows the interaction between the client and server, a result due to the increased overhead of writing every transaction to the file.

Products | Contact Us | About Us | Privacy | Ad Info | Home

Use of this site is subject to certain Terms & Conditions, Copyright © 1996-2000 EarthWeb Inc.

All rights reserved. Reproduction whole or in part in any form or medium without express written permission of EarthWeb is prohibited. Read EarthWeb's privacy statement.

To access the contents, click the chapter and section titles.

Kick Ass Delphi Programming

Go!

Keyword

(Publisher: The Coriolis Group)

Author(s): Don Taylor, Jim Mischel, John Penman, Terence Goggin

ISBN: 1576100448

Publication Date: 09/01/96

Search this book:

Go!

-----------

CHAPTER 6

3D Fractal Landscapes

JON SHEMITZ

•The Nature Of Fractals

•Efficient Arrays To Store Fractal Vertices

•Fractal Randomness

•Fractal Generation

•Fractal Display

Big Sur too expensive for you? Create your own Virtual Sur, and make it as big as you like, using fractal techniques and that old Delphi magic.

The first time I heard the word “fractal” was a little over thirteen years ago,

when I was still a mainframe programmer. A coworker and I were talking about our spiffy new IBM PC’s, and he asked me if I had any fractal software.

“No,” I said. “what are fractals?”

He explained that you made a fractal by applying some geometric operation to a simple figure, and then repeatedly applying the same operation to the result. While this explanation doesn’t even begin to touch on the sort of mathematical properties of fractals that interest mathematicians, it remains a good summary of how most fractals are generated.

It certainly describes 3D fractal landscape generation.

Bending and Dividing

To generate a landscape, simply assign random heights to the three vertices of an equilateral triangle, then ‘bend’ each of the edges by raising or lowering the midpoint by some random amount. If you draw lines between each of the three midpoints, you have carved the initial triangle into four triangles. If you apply this bending and dividing operation to each new triangle as you create it, before long you will end up with something that looks surprisingly like a real landscape. (See Figures 6.1, 6.2, and 6.3.)

FIGURE 6.1 An outline fractal landscape.

FIGURE 6.2 A filled fractal landscape.

FIGURE 6.3 A rendered fractal landscape.

The Shared Edges Problem

Now, of course, fractal landscape generation’s not quite as simple as “bend, divide, repeat”—you have to make sure that you only bend a given line once, and of course, you do generally want to display the landscape—but those are the details.

The first and most important detail is that you have to keep track of what you’re doing. If you straightforwardly write the FractureTriangle() routine to bend each edge, you will end up with something like that shown in Figure 6.4. Your triangles won’t form a smooth mesh; each group of four triangles will “float” with each vertex at a different height than its neighbors’.

FIGURE 6.4 When edges don’t meet.

A look at Figure 6.5 may help make it clear what’s going on. Interior edges are shared by two triangles, which do not necessarily agree on where to set shared edges. Vertex I is the midpoint of the line DF, which is shared by triangles

CDF and DEF. If both triangles try to set the height of I, triangles 1, 2, and 3 will be given a different height for I than triangles 4, 5, and 6!

FIGURE 6.5 How triangles “fight” over edges.

Clearly, we need to maintain a database of vertices, so that we can set vertex I when we fracture triangle CDF—and use the same value for vertex I when we fracture triangle DEF. We might try to say that triangle DEF is an “inside” triangle, and that therefore we will fracture it last and use the “outer” triangles’ values for vertices G, H, and I—but look at triangles GEH and LMN. Lines GE and EH are shared with “outside” triangles, so we should use the outside triangles’ values for vertices L and M, but line GH is “all inside”, so we need to bend it. We could undoubtedly elaborate the scheme of inside and outside triangles to handle these “outside-inside subtriangles” properly, but we’d end up with code that was hard to read and liable to break whenever it was changed.

It’s far simpler to define a special value that only uninitialized vertices will have and make FractureTriangle() look to see if any given midpoint has already been set. If a midpoint has been set, FractureTriangle() uses that height; if no midpoint has been set, FractureTriangle() gives it a new height. It may be a bit slower to calculate and lookup the midpoints of inside triangles than to simply pass in the right arguments, but the code is smaller and clearer—and displaying a landscape certainly takes much longer than generating it.

Products | Contact Us | About Us | Privacy | Ad Info | Home

Use of this site is subject to certain Terms & Conditions, Copyright © 1996-2000 EarthWeb Inc.

All rights reserved. Reproduction whole or in part in any form or medium without express written permission of EarthWeb is prohibited. Read EarthWeb's privacy statement.

Go!

Keyword

To access the contents, click the chapter and section titles.

Kick Ass Delphi Programming

(Publisher: The Coriolis Group)

Author(s): Don Taylor, Jim Mischel, John Penman, Terence Goggin

ISBN: 1576100448

Publication Date: 09/01/96

Search this book:

Go!

-----------

A Triangular Array

Now, when we bend a line, we are only changing the midpoint’s z value, so in principle, we could somehow use the [x, y] coordinate pair as an index into a table of z values. However, this would turn out to be a very sparse array, and the code will run a lot faster if we can use a normal, contiguous array than if we have to keep walking a sparse array’s lists. This is why Listing 6.1 defines a system of 2D logical addresses—the TVertex data type—which “name” the actual 3D coordinates in the TTriple data type.

Listing 6.1 GLOBAL.PAS

unit Global; {Fractal Landscapes 3.0 -- Copyright _ 1987..1996, Jon Shemitz}

interface

uses WinTypes;

type

Int16 = {$ifdef Ver80} integer {$else} SmallInt {$endif} ;

const
MaxPlys	= 8;
MaxEdgeLength	= 1 shl (MaxPlys - 1);
UnitLength: LongInt = 5000;
ShadesOfGray	= 64;
type
TCoordinate = -30000..30000;
TTriple = record
X,	{ Width:	0 (left) to UnitLength (right)	}
Y,	{ Depth:	0 (front) to VanishingPoint.Y (back)}
Z: TCoordinate; { Height:		0 (bottom) to UnitLength (top)	}
end;

function Triple(X, Y, Z: TCoordinate): TTriple;

type

TPixel = TPoint;

type

GridCoordinate = 0..MaxEdgeLength; { Triangular grid space }

TVertex = record

AB, BC, CA: GridCoordinate; end;

function Vertex(AB, BC, CA: GridCoordinate): TVertex;

type

DrawModes = (dmOutline, dmFill, dmRender); DrawRates = (drLow, drMedium, drHigh);

const

Envelope = 3000;

SeaLevel: word = 100; { 0 (bottom) to UnitLength (top) } VanishingPoint: TTriple = ( X: 1500 ;

Y:25000 ; { Apparent depth of vanishing point }

Z:15000 );

LightSource: TTriple = ( X: 2500;

		Y:	+7500;
		Z:	25000	);
DrawMode: DrawModes	=	dmOutline;
DrawRate: DrawRates	=	drHigh;

const

Uninitialized = -30000;

var

A, B, C: TVertex; Plys: 1..MaxPlys; EdgeLength: Int16;

DisplayHeight,

DisplayWidth: Int16;

implementation

function Triple(X, Y, Z: TCoordinate): TTriple; begin

Result.X := X;

Result.Y := Y;

Result.Z := Z; end;

function Vertex(AB, BC, CA: GridCoordinate): TVertex; begin

Result.AB := AB;

Result.BC := BC;

Result.CA := CA; end;

end.

Perhaps the simplest naming scheme is to simply number each vertex along the outermost triangle’s three edges, as in the left half of Figure 6.6, and use all three coordinates to refer to each edge. While we really only need two coordinates and the third is redundant, I find it a bit clearer to be able to refer to the three outermost vertices as [1, 0, 0], [0, 1, 0], and [0, 0, 1] rather than as [1, 0], [0, 1], and [0, 0]. That’s why a TVertex is defined as a coordinate triple, even though the third coordinate is not really necessary and does slow things down somewhat.

FIGURE 6.6 Storing vertices in a “square” array.

When it comes to the database of vertices, though, the third coordinate is ignored. As you can see from the right half of Figure 6.6, each vertex has the same coordinates if we make the equilateral triangle into an isosceles triangle. This lets us use the AB and BC coordinates much as if they were the normal row and column coordinates of a square array.

However, if we did store our triangular array in a square array, we would be wasting nearly half the space. This wouldn’t be such a big deal, except that in 16-bit segmented environments we run smack into the 64K segment size barrier. Each TTriple consists of three 16-bit fixed-point numbers, so a square array for an eight-ply database (Figure 6.7) would take (28-1+1)2 vertices, or 99,846 bytes. If we store only the cells on and below the diagonal, we can pare this to 50,310 bytes. This lets us use simple array indexing instead of arrays of arrays or huge pointers. Similarly, at least in this demo program, the database will fit in the data segment, which does make for faster access than if we had to use heap blocks and pointers.

FIGURE 6.7 Plies versus number of triangles.

Products | Contact Us | About Us | Privacy | Ad Info | Home

Use of this site is subject to certain Terms & Conditions, Copyright © 1996-2000 EarthWeb Inc.

All rights reserved. Reproduction whole or in part in any form or medium without express written permission of EarthWeb is prohibited. Read EarthWeb's privacy statement.

Go!

Keyword

To access the contents, click the chapter and section titles.

Kick Ass Delphi Programming

(Publisher: The Coriolis Group)

Author(s): Don Taylor, Jim Mischel, John Penman, Terence Goggin

ISBN: 1576100448

Publication Date: 09/01/96

Search this book:

Go!

-----------

Since eight plies is hardly too fine a resolution for, say, a 1280 by 1024 screen, the demo program for this chapter, Fractal Landscapes 3.0, (a.k.a. FL3, a Delphi port of a Windows port of a DOS program, which was originally written as a “cute hack” in Turbo Pascal 4.0) uses the triangular database code in Listing 6.2. The basic idea is that each row of vertices follows right after the previous row. Since there is only one vertex on the first row, the second row starts in DB’s second “cell.” Since the second row has two vertices, the third row starts in DB’s fourth cell, and so on.

Listing 6.2 DATABASE.PAS

unit Database; {Fractal Landscapes 3.0 -- Copyright _ 1987..1996, Jon Shemitz}

{Database and landscape generation}

interface

uses SysUtils, Global;

{ Misc math fns and such }

function IDIV(Numerator: LongInt; Denominator: Int16): Int16; {$ifdef Ver80} {Delphi 1.0 still supported InLine fns} InLine(

$5B	/	{ POP	BX ; Denominator	}
$58	/	{ POP	AX ; Lo word of Num }
$5A	/	{ POP	DX ; Hi word of Num }
$F7	/ $FB	{ IDIV	BX ; Mixed DIV	}

); {$endif}

function IMUL(A, B: Int16): LongInt;

{$ifdef Ver80} {Delphi 1.0 still supported InLine fns} InLine(

$5B	/	{ POP	BX }
$58	/	{ POP	AX }
$F7	/ $EB	{ IMUL	BX }

); {$endif}

function Rand(Envelope: integer): integer;

{database}

procedure ResetDB;

function GetTriple(const V: TVertex): TTriple; { DB[V] }

procedure SwapTriples(var A, B: TTriple);

function Midpoint(A, B: TVertex): TVertex;

function LoadLandscape(const FileName: TFileName): boolean;

function SaveLandscape(const FileName: TFileName): boolean;

{calculation}

procedure FractureTriangle(const A, B, C: TVertex; Plys: word);

function Unscale(ScaledCoordinate: LongInt): TCoordinate; {$ifdef Ver80} {Delphi 1.0 still supported InLine fns} InLine(

$58	/	{	POP	AX	; Lo word of SC	}
$5A	/	{	POP	DX	; Hi word of SC	}
$8B	/ $1E	/ UnitLength / {	MOV	BX,[UnitLength]	; Lo word of scale}
$F7	/ $FB	{	IDIV	BX	; Unscale	}

); {$endif}

implementation

{ Misc math fns and such }

{$ifNdef Ver80} {Delphi 2.0 doesn't support InLine fns} function IDIV(Numerator: LongInt; Denominator: Int16): Int16; begin

Result := Numerator div Denominator; end;

{$endif}

{$ifNdef Ver80} {Delphi 2.0 doesn't support InLine fns} function IMUL(A, B: Int16): LongInt;

begin

Result := Longint(A) * B; end;

{$endif}

function Rand(Envelope: integer): integer;

{ Pseudonormal distribution, in range _Envelope } begin

Rand := integer(Random(Envelope)) + integer(Random(Envelope)) - Envelope; end;

{$ifNdef Ver80} {Delphi 1.0 doesn't support InLine fns} function Unscale(ScaledCoordinate: LongInt): TCoordinate; begin

Result := ScaledCoordinate div UnitLength; end;

{$endif}

{ Database }