REM *******************************************************************
      REM
      REM Introduction :
      REM
      REM *******************************************************************
      REM
      REM These tutorials are based on http://www.directxtutorial.com/ which
      REM is an excellent site to learn about DirectX programming. These are
      REM very in depth tutorials and I won't repeat what is said there,
      REM rather I will show you the 'minimal' BB4W program which will
      REM achieve the same effect as the tutorial. You can then go on to
      REM modify them at your hearts desire!
      REM
      REM We will use DirectX9. Why? Well, DirectX8 is now officially
      REM 'unsupported' although DirectX9 and 10 still maintain backward
      REM compatibility. There is no BB4W library for DirectX9 and so it will
      REM be useful to learn to create the functions we need from the ground
      REM up. You will find that a lot of your programs are based around
      REM the same shell.
      REM
      REM DirectX uses COM (Component Object Model), if you are not familiar
      REM with COM then a quick read of :
      REM
      REM http://bb4w.wikispaces.com/Component+Object+Model+programming
      REM
      REM which will help with the basics. I will not try to explain it here.
      REM
      REM I have decided to use structures to call the different methods in
      REM each interface see :
      REM
      REM http://bb4w.wikispaces.com/Calling+object+methods+using+structures
      REM
      REM Although it can seem tedious to type out the structures first time,
      REM it does lead to more readable code than the more obfuscating
      REM indirection method. This is especially useful when you come back to
      REM the code after a long time.
      REM
      REM For instance reading :
      REM
      REM             SYS IDirect3DDevice9.BeginScene%, IDirect3DDevice9%
      REM
      REM is a lot easier to reference than
      REM
      REM             SYS !(!D%+164), D%
      REM
      REM There are some caveats to using structures. The first is that the
      REM original memory allocated for the structure is wasted but this is
      REM not really a big problem. Second, we have to use a tricky line of
      REM code to redirect the structure to point to the interfaces despatch
      REM table (we *must* remember to do this!) and third we could argue
      REM that they are slightly slower to call than using indirection. All
      REM in all, I think it is worthwhile doing for the readability of the
      REM code.
      REM
      REM The only other thing to mention is the FNf() function. DirectX uses
      REM 4 byte floating point values rather than BB4W's 5 or 8 byte float
      REM (*FLOAT 40 and *FLOAT 64 respectively). Whenever you see a value
      REM such as 1.0f or 0.5f mentioned in the tutorials we need to use
      REM FNf(1.0) or FNf(0.5) instead, otherwise we will get some very funny
      REM results. See :
      REM
      REM http://bb4w.wikispaces.com/Passing+floating-point+values+to+DLLs
      REM
      REM For further information.

      REM *******************************************************************
      REM
      REM  Programming DirectX9
      REM  Lesson 1
      REM
      REM *******************************************************************

      REM Remember, this lesson shows you a lot of code which will later
      REM be moved into a library. You could skip to lesson three which
      REM shows you exactly the same program but with all the reusable
      REM code put in a library.

      REM Well, we should choose a screen mode.
      REM MODE 8 is a good start. 640 x 512 pixels.
      REM we'll also turn the cursor off.
      REM Notice initialisation of the window is done for you by BB4W!

      MODE 8
      OFF


      REM We should always make sure that we have a cleanup procedure.
      REM This enables us to free up all the resources we create with DirectX
      REM Remember, any object 'created' by you will stay there until you
      REM free it. To prevent all your memory eventually being used up you
      REM must free it.
      ON ERROR PROC_Error   : PROC_Cleanup : END
      ON CLOSE PROC_Cleanup : QUIT

      REM First we need to load in the D3D9.DLL. This 'Dynamic Linked
      REM Library' contains all the goods to use DirectX. If you haven't,
      REM install the latest DirectX SDK it would be a good reference
      REM Otherwise, make sure you have DirectX9 installed.
      SYS "LoadLibrary", "D3D9.DLL" TO D3D9DLL%


      REM It is good practice to check the result of any Windows API call we
      REM make just in case things rely on them later, but we won't always
      REM do this.
      IF D3D9DLL% = FALSE THEN
        m$ = "Failed to load D3D9.DLL. " +CHR$13
        m$+= "Please ensure you have DirectX9 installed."
        ERROR 100, m$
      ENDIF

      REM The first function we need is 'Direct3DCreate9' so we will query
      REM our dll loaded into memory and get its address.
      SYS"GetProcAddress", D3D9DLL%, "Direct3DCreate9" TO Direct3DCreate9%

      REM Again, check to see if we have found the address
      IF Direct3DCreate9% = FALSE THEN
        ERROR 100, "Could not locate Direct3DCreate9 function."
      ENDIF



      REM Now we will 'create' the DirectX9 'device'. This is an 'object'
      REM which contains 'interfaces' and/or 'methods'. We can call these
      REM methods to control DirectX.
      REM
      REM At first we will define constants etc as we need them, but later
      REM we can move all definitions to a separate initialisation routine,
      REM and later still, to a separate library.



      REM First get the Direct3D9 interface pointer :
      D3D_SDK_VERSION = 32 : REM DirectX 9c
      SYS Direct3DCreate9%, D3D_SDK_VERSION TO IDirect3D9%
      IF IDirect3D9% = FALSE THEN
        ERROR 100, "Failed to Create Direct3D9 interface."
      ENDIF


      REM Now we need to define our first interface. We do this by defining
      REM the following structure and then redirecting it to point to the
      REM interface's methods.
      DIM IDirect3D9{                        \
      \QueryInterface%,                      \
      \AddRef%,                              \
      \Release%,                             \
      \RegisterSoftwareDevice%,              \
      \GetAdapterCount%,                     \
      \GetAdapterIdentifier%,                \
      \GetAdapterModeCount%,                 \
      \EnumAdapterModes%,                    \
      \GetAdapterDisplayMode%,               \
      \CheckDeviceType%,                     \
      \CheckDeviceFormat%,                   \
      \CheckDeviceMultiSampleType%,          \
      \CheckDepthStencilMatch%,              \
      \CheckDeviceFormatConversion%,         \
      \GetDeviceCaps%,                       \
      \GetAdapterMonitor%,                   \
      \CreateDevice%                        }

      REM We have created the structure, but unfortunately if we were to call
      REM any of the methods with it we would fail dramatically. With the
      REM next line we redirect our structure to point to the IDirect3D9
      REM despatch table.
      !(^IDirect3D9{}+4) = !IDirect3D9%

      REM Sorry about that, but it is essential we do this if we want to use
      REM structure members as methods/functions!

      REM Next we define the PRESENT_PARAMETERS{} which we need to 'create
      REM the device' and set some of its members.
      DIM D3DPRESENT_PARAMETERS{              \
      \BackBufferWidth%,                      \
      \BackBufferHeight%,                     \
      \BackBufferFormat%,                     \
      \BackBufferCount%,                      \
      \MultiSampleType%,                      \
      \MultiSampleQuality%,                   \
      \SwapEffect%,                           \
      \hDeviceWindow%,                        \
      \Windowed%,                             \
      \EnableAutoDepthStencil%,               \
      \AutoDepthStencilFormat%,               \
      \Flags%,                                \
      \FullScreen_RefreshRateInHz%,           \
      \PresentationInterval%                 }

      REM Define some constants
      REM Take note this is NOT BB4W's TRUE which is -1!
      _TRUE                                 = 1
      D3DSWAPEFFECT_DISCARD                 = 1

      REM Set some D3DPRESENT_PARAMETERS{} members
      D3DPRESENT_PARAMETERS.Windowed%       = _TRUE
      D3DPRESENT_PARAMETERS.SwapEffect%     = D3DSWAPEFFECT_DISCARD
      D3DPRESENT_PARAMETERS.hDeviceWindow%  = @hwnd%

      REM And now we Create the Device
      D3DADAPTER_DEFAULT                    = 0
      D3DDEVTYPE_HAL                        = 1
      D3DCREATE_SOFTWARE_VERTEXPROCESSING   = &20

      SYS IDirect3D9.CreateDevice%, IDirect3D9%, D3DADAPTER_DEFAULT, \
      \ D3DDEVTYPE_HAL, @hwnd%, D3DCREATE_SOFTWARE_VERTEXPROCESSING, \
      \ D3DPRESENT_PARAMETERS{}, ^IDirect3DDevice9% TO R%
      IF R%<>0 OR IDirect3DDevice9% = FALSE THEN
        ERROR 100, "Failed to Create IDirect3DDevice9."
      ENDIF

      REM Notice the ^ (address of) symbol with ^IDirect3DDevice9%. We will
      REM come across this a lot when we want to receive a value back from
      REM the SYS call which is not returned in the result.

      REM A note of the SYS call format:
      REM You may have noticed the slightly different SYS call format when
      REM calling an method via an object's interface compared to a simple
      REM Windows API function. You must put the interface pointer as the
      REM second parameter ie after calling the method :
      REM
      REM SYS IDirect3D9.CreateDevice%
      REM
      REM We add the interface pointer
      REM
      REM SYS IDirect3D9.CreateDevice%, IDirect3D9%
      REM