This document is organized into the following topics:

	Getting started
	What's New in this Release
	Loading the DirectX 8 project
	Testing out DirectX 8
	Debugging
	Modifying a running application
	Workspaces
	Summary
	Appendix Installation Problems Driver Issues Image Settings

 

This version of the library is based on DirectX 8.1.

New Samples

Lighting

New Demos

Particles

Changes

	Particle parameters are completely encapsulated in a structure, making it much easier to work with presets. The new Particle demo displays a UI that allows you to interactively control the parameters. The number of particles is now defined as the number of particles per second.
	When a DirectX frame window looses focus, it automatically inserts wait states to yield to other windows and processes.

In the Project Browser, select the project Triangle in the left hand pane. Next select the class DX::Triangle in the middle pane. Click right and select Test

	To see the class, click right onto DX::Triangle and select Browse Class. A Class Hierarchy Browser will open on the DX::Triangle class.
	Again this window can be sized and saved using Tools Menu -> Save Preferences.
	To test this application from the Class Hierarchy Browser, right click on the DX::Triangle class and choose Test. The application will open a window and display a rotating yellow triangle (rotating around the Y axis).

It is important to note that unlike Visual Studio, the application is running in the same process as the development environment. To further demonstrate this, let us change the running program. 

Select the method (right hand pane) frameMove.

On the third line from the bottom you will see a line:

matspin rotationY: m_fTime.

which calculates the Y rotation from the time the application has been running. Change this line to:

matspin rotationY: m_fTime/2.

Save the new method by right clicking in the text pane and choosing Accept.

The triangle will now immediately begin to rotate at half the previous speed. Try m_fTime*3 to speed up rotation.

We have just modified a running program which is one of the greatest strengths of Smalltalk.

Now let’s debug this application.

After the line above (and before the line containing SetTransform) insert the following line (don’t forget the period at the end of the line):

self halt.

When you save the new method this time, a debugger window will display. First choose Window Menu -> Arrange windows and then save this with Options Menu -> Save Preferences.

The debugger window displays the call stack (top left), the locals (top right) and the current position (bottom).

In the locals window, you can expand out matSpin to see all of its values and by pressing the Resume toolbar button (far left), you can see the matspin matrix changing. Thus the debugger gives you ways of tracking complex changes.

To dismiss the debugger while leaving the application running, remove the self halt line in the debugger text and right click to accept. Choose resume to continue the application and close the debugger window. You will see the application continue to run.

Exit the application by closing the window.

Another example might be to test out different materials. To do this:

Go to the method renderScene and insert as the first line:

self createMaterial.

Now go to the method createMaterial and change the first float (currently 1.0) to 0.0 after the initMaterial:.

The triangle immediately goes green.

Syntax
Just before we go into workspaces, we need to briefly review the Smalltalk syntax. All Smalltalk statements are of the form “receiver message” or “receiver message: param1” or “receiver message: param1 with: param2”. There are no exceptions to this rule. In addition, the Smalltalk standard does not define operator precedence.

1*3 + 3*4 will execute as (((1*3)+3)*4)

1*4<3*6 will execute as (((1*4)<3)*6)

unless of course you provide parenthesis yourself.

Note: Optionally, Smalltalk MT supports operator precedence. To enable operator precedence, open the Image Properties (in the Transcript, Tools Menu -> Image Properties), click on the Compiler Tab, and check the box labeled “Enable Operator Precedence”. Doing this makes your code incompatible with other Smalltalks.

From the Class Hierarchy Browser choose Tools Menu -> New Workspace. Let’s call a DLL entry point by typing in:

WINAPI MessageBeep: -1

Execute this line by choosing Smalltalk Menu -> Execute (Note: The cursor must be somewhere on the line you typed). The system bell will ring. You have just executed a DLL call (statically called) by executing this line as though it was a script!

Smalltalk code can be executed anywhere in a text pane which provides the ability to easily prototype and test. Workspaces also have the ability to create variables to hold onto values. For example, let us test out the PerformanceTimer. 

In a workspace enter:

a := PerformanceTimer new.

If you execute this line, you will be prompted that “a” is not defined. Do you wish to declare it as a workspace variable. Select Yes. 

Now enter the line:

a tick

This time instead of executing this line, display this line using Smalltalk Menu -> Display. A float will be displayed showing the current tick value. Execute:

a resetTimer

To set the timer back to zero and then display the tick value again.

As you can see, it is simple to test out classes in a workspace for use in your code.

Exit Smalltalk MT
Exit Smalltalk by closing the Transcript. Choose Exit (not Save & Exit) to maintain a ‘clean’ image (choosing Save & Exit will save the image in its current state with all projects loaded).