Subversion Repositories Games.Chess Giants

// render.cpp

// thanks ChaotikMind for optimizing the engine a bit :)

#include "common.h"

// note: DirectX requires a C++ compiler.

#include "DirectX9/Include/d3d9.h"

#include "DirectX9/Include/d3dx9.h"

// include the Direct3D library files

#pragma comment (lib, "DirectX9/Lib/x86/d3d9.lib")

#pragma comment (lib, "DirectX9/Lib/x86/d3dx9.lib")

// define this to display framerate

#define WANT_FRAMERATE

// handy macro to print a chatter channel reply

#define PRINT_CCREPLY(ccreply) \

{ \

   Render_wprintf (rect.right, initial_height - combined_height, initial_width - rect.right, ALIGN_LEFT, ALIGN_TOP, ALIGN_LEFT, \

                   chat_fontindex, (ccreply)->color, &rect, \

                   L"["); \

   Render_wprintf (rect.right, initial_height - combined_height, initial_width - rect.right, ALIGN_LEFT, ALIGN_TOP, ALIGN_LEFT, \

                   chat_fontindex, RGBA_TO_RGBACOLOR (159, 159, 159, RGBACOLOR_ALPHA ((ccreply)->color)), &rect, \

                   (ccreply)->channelname); \

   Render_wprintf (rect.right, initial_height - combined_height, initial_width - rect.right, ALIGN_LEFT, ALIGN_TOP, ALIGN_LEFT, \

                   chat_fontindex, (ccreply)->color, &rect, \

                   L"] "); /* closing bracket + non-breakable space */ \

   Render_wprintf (rect.right, initial_height - combined_height, initial_width - rect.right, ALIGN_LEFT, ALIGN_TOP, ALIGN_LEFT, \

                   chat_fontindex, RGBA_TO_RGBACOLOR (159, 159, 159, RGBACOLOR_ALPHA ((ccreply)->color)), &rect, \

                   (ccreply)->nickname); \

   Render_wprintf (rect.right, initial_height - combined_height, initial_width - rect.right, ALIGN_LEFT, ALIGN_TOP, ALIGN_LEFT, \

                   chat_fontindex, (ccreply)->color, &rect, \

                   L": "); /* colon + non-breakable space */ \

   if ((ccreply)->text != NULL) \

      Render_wprintf (rect.right, initial_height - combined_height, initial_width - rect.right, ALIGN_LEFT, ALIGN_TOP, ALIGN_LEFT, \

                      chat_fontindex, (ccreply)->color, &rect, \

                      (ccreply)->text); \

}

// handy macro to draw a GUI button

#define DRAW_BUTTON_IF_NEEDED(button) \

{ \

   if ((button).state != 0) \

      Render_DrawSprite (&sprites[(button).sprite_index], (button).left, (button).top, (button).width, (button).height, ((button).state == 2 ? 0xFF : 0x7F)); \

}

// handy macro to draw a GUI text

#define DRAW_TEXT_IF_NEEDED(text) \

{ \

   if ((text).is_displayed) \

   { \

      Render_wprintf ((int) ((text).xpos_percent * (float) initial_width) / 100, (int) ((text).ypos_percent * (float) initial_height) / 100, \

                      (int) ((text).maxwidth_percent * (float) initial_width) / 100, (text).horizontal_align, (text).vertical_align, (text).text_align, (text).font_index, \

                      ((text).want_fade ? \

                       RGBACOLOR_SETALPHA ((text).color, \

                                           (((text).appear_time + (text).disappear_time) * 0.5f > current_time ? \

                                           /* fading in  */ (int) FadeFloat (0, RGBACOLOR_ALPHA ((text).color), (text).appear_time, (text).appear_time + 0.5f) : \

                                           /* fading out */ (int) FadeFloat (RGBACOLOR_ALPHA ((text).color), 0, (text).disappear_time - 3.0f, (text).disappear_time))) : \

                       (text).color), \

                      NULL, (text).buffer); \

      if ((text).disappear_time < current_time) \

         (text).is_displayed = false; \

   } \

}

#pragma pack(push,1)

// definition for a vector

typedef struct vector_s

{

   float x; // X component

   float y; // Y component

   float z; // Z component

} vector_t;

// definition for a texture coordinates pair

typedef struct texcoord_s

{

   float u; // X coordinate of the texture point this vertex corresponds to

   float v; // Y coordinate of the texture point this vertex corresponds to

} texcoord_t;

// definition for a vertex (must be in that order for Direct3D)

typedef struct vertex_s

{

   vector_t position; // position in space

   vector_t normal; // coordinates of the unary normal vector of the plane this vertex is on (for illumination)

   texcoord_t texcoord; // coordinates of the texture point this vertex corresponds to

} vertex_t;

#pragma pack(pop)

// definition for a reflected object (qsort array element to sort reflections by distance)

typedef struct reflectedobject_s

{

   sceneobject_t *object; // pointer to the scene object

   float distance; // distance to viewer camera

} reflectedobject_t;

// definition for a material (light reflection type)

typedef struct material_s

{

   wchar_t name[32]; // material name

   float ambient; // ambient reflection value ranging from 0 to 1

   float diffuse; // diffuse reflection value ranging from 0 to 1

   float emissive; // emissive reflection value ranging from 0 to 1

   float specular; // specular reflection value ranging from 0 to 1

   float shininess; // shininess (specular factor)

   float transparency; // transparency value ranging from 0 (fully transparent) to 1 (opaque)

} material_t;

// definition for a mesh

typedef struct mesh_s

{

   unsigned long hash; // basic content hash, to avoid duplicates

   unsigned long vertex_format;

   IDirect3DVertexBuffer9 *d3dvertices; // handled opaquely by Direct3D

   int vertice_size;

   int vertice_count;

   bool is_indexed; // set to TRUE if this mesh has an index buffer

   IDirect3DIndexBuffer9 *d3dindices; // handled opaquely by Direct3D

   int indice_size;

   int indice_count;

} mesh_t;

// definition for a texture

typedef struct texture_s

{

   unsigned long hash; // basic content hash, to avoid duplicates

   int width;

   int height;

   IDirect3DTexture9 *texture;

} texture_t;

// definition for a font

typedef struct font_s

{

   unsigned long pathname_hash;

   ID3DXFont *font;

} font_t;

// definition for a sprite

typedef struct sprite_s

{

   unsigned long hash; // basic content hash, to avoid duplicates

   ID3DXSprite *sprite;

   int texture_index;

} sprite_t;

// global variables used in this module only

static IDirect3D9 *d3d = NULL; // our Direct3D interface

static IDirect3DDevice9 *d3ddev = NULL; // the device class

static material_t *materials = NULL;

static int material_count = 0;

static texture_t *textures = NULL;

static int texture_count = 0;

static mesh_t *meshes = NULL;

static int mesh_count = 0;

static font_t *fonts = NULL;

static int font_count = 0;

static sprite_t *sprites = NULL;

static int sprite_count = 0;

static const float fov_value = 45.0f; // field of view width, in degrees

static const float viewdist_near = 1.0f; // nearest view plane distance

static const float viewdist_far = 200.0f; // farthest view plane distance

static int initial_width = 0; // initial width of the render surface, in pixels

static int initial_height = 0; // initial height of the render surface, in pixels

static float current_width = 0.0f; // current width of the client area on which the render surface is rendered, in pixels

static float current_height = 0.0f; // current height of the client area on which the render surface is rendered, in pixels

static D3DCOLOR ambient_light;

static vector_t camera_position;

static const vector_t scene_center = { 0.0f, 0.0f, 0.0f };

static const vector_t upwards_direction = { 0.0f, 0.0f, 1.0f };

static int best_supported_filter;

static unsigned long multisample_quality = 0;

static wchar_t printf_buffer[0xffff];

// prototypes of functions used in this module only

static bool Render_LoadMesh_X (mesh_t *mesh, const wchar_t *xfile_pathname);

static bool Render_LoadMesh_Obj (mesh_t *mesh, const wchar_t *objfile_pathname);

static void Render_DrawSceneObjectReflection (sceneobject_t *sceneobject);

static void Render_DrawSceneObject (sceneobject_t *sceneobject);

static void Render_DrawSceneTile (sceneobject_t *sceneobject);

static void Render_DrawSprite (sprite_t *sprite, float x_percent, float y_percent, float width_percent, float height_percent, int alpha);

static void Render_GetTextBoundaries (int max_width, int font_id, wchar_t *text, RECT *rect);

static void Render_wprintf (int x, int y, int max_width, int horiz_align, int vert_align, int text_align, int font_id, unsigned long color_rgba, RECT *out_rect, const wchar_t *fmt, ...);

static float DistanceToCamera (float x, float y, float z);

static float FadeFloat (float from, float to, float start_time, float end_time);

static unsigned long HashString (const wchar_t *string_buffer);

static unsigned long HashFile (const wchar_t *file_pathname);

static void ResolveWildcard (wchar_t *file_pathname, wchar_t *extensions_separated_by_bars);

static int SortReflectedObjects (const void *object1, const void *object2);

bool Render_Init (void)

{

   // this function sets up and initializes Direct3D

   static wchar_t *default_materialname = L"default";

   D3DCAPS9 device_capabilities;

   unsigned long behaviour_flags;

   unsigned long best_multisample_type;

   D3DPRESENT_PARAMETERS d3dpp;

   wchar_t line_buffer[256];

   material_t material;

   RECT rect;

   FILE *fp;

   // create the Direct3D interface

MessageBox (NULL, L"about to call Direct3dCreate9()", L"info", MB_OK);

   d3d = Direct3DCreate9 (D3D_SDK_VERSION);

MessageBox (NULL, L"Direct3dCreate9() call returned", L"info", MB_OK);

   // get hardware capabilities

   if (FAILED (d3d->GetDeviceCaps (D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &device_capabilities)))

   {

      MessageBox (NULL, LOCALIZE (L"Error_CouldNotCreateD3DDevGetDeviceCapsFailed"), LOCALIZE (L"FatalError"), MB_ICONERROR | MB_OK);

      return (false);

   }

MessageBox (NULL, L"GetDeviceCaps() call returned", L"info", MB_OK);

   // grab info from that and adjust our D3D settings

   best_supported_filter = (device_capabilities.RasterCaps & D3DPRASTERCAPS_ANISOTROPY ? D3DTEXF_ANISOTROPIC : D3DTEXF_LINEAR);

   behaviour_flags = (device_capabilities.VertexProcessingCaps != 0 ? D3DCREATE_HARDWARE_VERTEXPROCESSING : D3DCREATE_SOFTWARE_VERTEXPROCESSING);

   // see if full-scene antialiasing is supported and pick the best available multisample type

   best_multisample_type = D3DMULTISAMPLE_NONE;

   while (SUCCEEDED (d3d->CheckDeviceMultiSampleType (D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, false, (D3DMULTISAMPLE_TYPE) (best_multisample_type + 1), &multisample_quality)))

   {

      best_multisample_type++; // increase multisample type as long as the next one is supported

      if ((best_multisample_type == D3DMULTISAMPLE_2_SAMPLES) && !options.want_hiquality)

         break; // stop searching for the best one if we don't want the highest possible quality

   }

MessageBox (NULL, L"CheckDeviceMultiSampleType() call returned", L"info", MB_OK);

   memset (&d3dpp, 0, sizeof (d3dpp)); // clear out the struct for use

   d3dpp.Windowed = true; // always windowed (because we can't display dialog boxes in fullscreen mode)

   d3dpp.BackBufferCount = 1;

   d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; // discard old frames

   d3dpp.hDeviceWindow = hMainWnd; // set the window to be used by Direct3D

   d3dpp.EnableAutoDepthStencil = true; // enable Z-buffer and stencil buffer

   d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8; // D3DFMT_D15S1 15 bits should be enough to store each pixel's Z depth

   d3dpp.MultiSampleType = (D3DMULTISAMPLE_TYPE) best_multisample_type; // use multisampling (full scene antialiasing) if supported

   d3dpp.MultiSampleQuality = (multisample_quality > 0 ? multisample_quality - 1 : 0);

   // create a device class using this information and the info from the d3dpp stuct

   if (FAILED (d3d->CreateDevice (D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hMainWnd, behaviour_flags, &d3dpp, &d3ddev)))

   {

      MessageBox (NULL, LOCALIZE (L"Error_CouldNotCreateD3DDevCreateDeviceFailed"), LOCALIZE (L"FatalError"), MB_ICONERROR | MB_OK);

      return (false);

   }

MessageBox (NULL, L"CreateDevice() call returned", L"info", MB_OK);

   // get the device view port and save the initial width and height

   GetClientRect (hMainWnd, &rect);

   initial_width = rect.right; // they may differ from window width and window height

   initial_height = rect.bottom; // because of title bars, menus, borders, etc.

   // set the texture parameters

   d3ddev->SetSamplerState (0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP); // wrap textures around their edges

   d3ddev->SetSamplerState (0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);

   d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE); // and modulate their alpha with the material's alpha

   d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);

   d3ddev->SetTextureStageState (0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);

   // enable the Z buffer

   d3ddev->SetRenderState (D3DRS_ZENABLE, true);

   // disable the stencil buffer

   d3ddev->SetRenderState (D3DRS_STENCILENABLE, false);

   // normalize the face normals (if we don't, scaling will cause problems with lighting computations)

   d3ddev->SetRenderState (D3DRS_NORMALIZENORMALS, true);

   // turn on alpha blending

   d3ddev->SetRenderState (D3DRS_ALPHABLENDENABLE, true);

   d3ddev->SetRenderState (D3DRS_BLENDOP, D3DBLENDOP_ADD);

   d3ddev->SetRenderState (D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);

   d3ddev->SetRenderState (D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);

   // use all of the materials' light reflection properties

   d3ddev->SetRenderState (D3DRS_AMBIENTMATERIALSOURCE, D3DMCS_MATERIAL);

   d3ddev->SetRenderState (D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_MATERIAL);

   d3ddev->SetRenderState (D3DRS_SPECULARMATERIALSOURCE, D3DMCS_MATERIAL);

   d3ddev->SetRenderState (D3DRS_EMISSIVEMATERIALSOURCE, D3DMCS_MATERIAL);

   d3ddev->SetRenderState (D3DRS_COLORVERTEX, false);

   // enable 3D lighting

   d3ddev->SetRenderState (D3DRS_LIGHTING, true);

MessageBox (NULL, L"SetRenderState() calls returned", L"info", MB_OK);

   // open and parse the materials file and build the materials list

   materials = NULL;

   material_count = 0;

   _wfopen_s (&fp, L"materials.cfg", L"r, ccs=UNICODE");

   if (fp != NULL)

   {

      // read line per line...

      while (fgetws (line_buffer, WCHAR_SIZEOF (line_buffer), fp) != NULL)

      {

         // can we read a complete material line ?

         if (swscanf_s (line_buffer, L"\"%[^\"]\" %f %f %f %f %f %f", material.name, WCHAR_SIZEOF (material.name), &material.ambient, &material.diffuse, &material.emissive, &material.specular, &material.shininess, &material.transparency) == 7)

         {

            materials = (material_t *) SAFE_realloc (materials, material_count, material_count + 1, sizeof (material_t), false);

            memcpy (&materials[material_count], &material, sizeof (material_t));

            material_count++; // if so, append this new material to the materials array

         }

      }

      fclose (fp); // finished, close the file

   }

   materials = (material_t *) SAFE_realloc (materials, material_count, material_count + 1, sizeof (material_t), false);

   wcscpy_s (materials[material_count].name, WCHAR_SIZEOF (materials[material_count].name), default_materialname);

   materials[material_count].ambient = 1.0f;

   materials[material_count].diffuse = 1.0f;

   materials[material_count].emissive = 0.0f;

   materials[material_count].specular = 0.0f;

   materials[material_count].shininess = 0.0f;

   materials[material_count].transparency = 1.0f;

   material_count++; // append a default material at the end of the array and we're all set

   return (true); // finished

}

void Render_Shutdown (void)

{

   // this function shuts down the Direct3D interfaces and releases the Direct3D COM objects

   int array_index;

   // close and release font data

   SAFE_free ((void **) &fonts);

   font_count = 0;

   // close and release sprite data

   SAFE_free ((void **) &sprites);

   sprite_count = 0;

   // close and release meshes data

   if (meshes != NULL)

   {

      for (array_index = 0; array_index < mesh_count; array_index++)

      {

         if (meshes[array_index].d3dindices != NULL)

            meshes[array_index].d3dindices->Release ();

         meshes[array_index].d3dindices = NULL;

         if (meshes[array_index].d3dvertices != NULL)

            meshes[array_index].d3dvertices->Release ();

         meshes[array_index].d3dvertices = NULL;

      }

   }

   meshes = NULL;

   mesh_count = 0;

   // close and release texture data

   if (textures != NULL)

   {

      for (array_index = 0; array_index < texture_count; array_index++)

         if (textures[array_index].texture != NULL)

            textures[array_index].texture->Release ();

      SAFE_free ((void **) &textures);

   }

   texture_count = 0;

   // close and release materials data

   SAFE_free ((void **) &materials);

   material_count = 0;

   // close and release the 3D device

   if (d3ddev != NULL)

      d3ddev->Release ();

   d3ddev = NULL;

   // close and release Direct3D

   if (d3d != NULL)

      d3d->Release ();

   d3d = NULL;

   return; // finished

}

void Render_RenderFrame (scene_t *scene)

{

   // this is the function used to render a single frame

   static int framerate_value = 0;

   static int framerate_count = 0;

   static float framerate_time = 0;

   D3DXMATRIX scaling_matrix;

   D3DXMATRIX translation_matrix;

   D3DXMATRIX view_matrix; // the view transform matrix

   D3DXMATRIX projection_matrix; // the projection transform matrix

   D3DLIGHT9 dxlight;

   RECT rect;

   float angle;

   float sin_pitch;

   float sin_yaw;

   float cos_pitch;

   float cos_yaw;

   int light_index;

   int object_index;

   int cchistory_index;

   int cchistory_index2;

   int combined_width;

   int combined_height;

   light_t *light;

   ccreply_t *ccreply;

   sceneobject_t *sceneobject;

   reflectedobject_t *reflectedobjects; // mallocated

   int reflectedobject_count;

   reflectedobject_t *otherobjects; // mallocated

   int otherobject_count;

   // get the device view port and save the actual width and height

   GetClientRect (hMainWnd, &rect);

   current_width = (float) rect.right; // they may differ from window width and window height

   current_height = (float) rect.bottom; // because of title bars, menus, borders, etc.

   // clear the back buffer, the Z buffer and the stencil buffer

   d3ddev->Clear (0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL, D3DCOLOR_XRGB (0, 0, 0), 1.0f, 0);

   d3ddev->BeginScene (); // begins the 3D scene

   ////////////////////////////////////////

   // Setup scene lights

   // There are three types of light : ambient, diffuse and specular.

   // Diffuse lights can be of type directional (sun), point (bulb) or spot (flashlight).

   // The attenuation formula for point lights is :

   // Atten = 1 / (att0 + (att1 * d) + (att2 * d²))

   // In spot lights, Phi is the outer cone angle. Theta is the inner cone angle.

   // set the default lighting color

   ambient_light = RGBACOLOR_TO_ARGBCOLOR (RGBACOLOR_FULLALPHA (theme->illum.ambient_light));

   d3ddev->SetRenderState (D3DRS_AMBIENT, ambient_light);

   // for each light...

   for (light_index = 0; light_index < theme->illum.light_count; light_index++)

   {

      light = &theme->illum.lights[light_index]; // quick access to light

      memset (&dxlight, 0, sizeof (dxlight)); // clear out the dxlight struct for use

      // set its type

      if (light->type == LIGHT_DIRECTIONAL)

         dxlight.Type = D3DLIGHT_DIRECTIONAL; // directional light (e.g, sun)

      else if (light->type == LIGHT_POINT)

         dxlight.Type = D3DLIGHT_POINT; // point light (e.g, light bulb)

      else if (light->type == LIGHT_SPOT)

         dxlight.Type = D3DLIGHT_SPOT; // spot light (e.g, flash light)

      else

      {

         d3ddev->LightEnable (light_index, false); // unknown light ; turn off light #index

         continue; // and proceed to the next one

      }

      // set its parameters

      dxlight.Diffuse = D3DXCOLOR (RGBACOLOR_TO_ARGBCOLOR (RGBACOLOR_FULLALPHA (light->color)));

      dxlight.Specular = D3DXCOLOR (0xffffffff);

      dxlight.Position.x = light->pos_x;

      dxlight.Position.y = light->pos_y;

      dxlight.Position.z = light->pos_z;

      dxlight.Direction.x = light->direction_x;

      dxlight.Direction.y = light->direction_y;

      dxlight.Direction.z = light->direction_z;

      dxlight.Range = light->range; // light won't be computed after this distance

      dxlight.Attenuation0 = light->attenuation_constant; // constant attenuation, see formula

      dxlight.Attenuation1 = light->attenuation_proportional; // proportional attenuation, see formula

      dxlight.Attenuation2 = light->attenuation_square; // square attenuation, see formula

      dxlight.Phi = light->cone_outer * TO_RADIANS; // outer spot cone

      dxlight.Theta = light->cone_inner * TO_RADIANS; // inner spot cone

      d3ddev->SetLight (light_index, &dxlight); // send the light struct properties to light #index

      d3ddev->LightEnable (light_index, true); // turn on light #index

   }

   ////////////////////////////////

   // View transform

   // compute the sine and cosine of the pitch component

   angle = current_pitch * TO_RADIANS;

   sin_pitch = sinf (angle);

   cos_pitch = cosf (angle);

   // compute the sine and cosine of the yaw component

   angle = current_yaw * TO_RADIANS;

   sin_yaw = sinf (angle);

   cos_yaw = cosf (angle);

   // build the camera position

   camera_position.x = (float) -(cos_pitch * cos_yaw) * current_distance;

   camera_position.y = (float) -(cos_pitch * sin_yaw) * current_distance;

   camera_position.z = (float) sin_pitch * current_distance;

   // set up a view matrix

   D3DXMatrixLookAtLH (&view_matrix,

                       (D3DXVECTOR3 *) &camera_position, // camera position

                       (D3DXVECTOR3 *) &scene_center, // look-at position

                       (D3DXVECTOR3 *) &upwards_direction); // up direction

   // tell Direct3D about our matrix

   d3ddev->SetTransform (D3DTS_VIEW, &view_matrix);

   /////////////////////////////////////

   // Projection transform

   // set up a projection matrix

   D3DXMatrixPerspectiveFovLH (&projection_matrix,

                               fov_value * TO_RADIANS, // field of view width

                               current_width / current_height, // aspect ratio

                               viewdist_near, viewdist_far); // view plane distances

   // tell Direct3D about our matrix

   d3ddev->SetTransform (D3DTS_PROJECTION, &projection_matrix);

   /////////////////////////////////////

   // End of the transforms

   // if we want it, enable specular lighting

   d3ddev->SetRenderState (D3DRS_SPECULARENABLE, options.want_specularlighting);

   // turn on texture filtering if needed

   if (options.want_filtering)

   {

      d3ddev->SetSamplerState (0, D3DSAMP_MINFILTER, best_supported_filter);

      d3ddev->SetSamplerState (0, D3DSAMP_MAGFILTER, best_supported_filter);

      d3ddev->SetSamplerState (0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);

      // turn on fullscene antialiasing only if capable

      d3ddev->SetRenderState (D3DRS_MULTISAMPLEANTIALIAS, (multisample_quality > 0));

   }

   else

   {

      d3ddev->SetSamplerState (0, D3DSAMP_MINFILTER, D3DTEXF_NONE);

      d3ddev->SetSamplerState (0, D3DSAMP_MAGFILTER, D3DTEXF_NONE);

      d3ddev->SetSamplerState (0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);

      // turn off fullscene antialiasing

      d3ddev->SetRenderState (D3DRS_MULTISAMPLEANTIALIAS, false);

   }

   /////////////////////////////////////////////////////////////

   // draw the background elements. No need for a Z buffer here.

   d3ddev->SetRenderState (D3DRS_ZENABLE, false); // disable depth testing

   // draw the background sprite, if any

   if (scene->background_spriteindex >= 0)

      Render_DrawSprite (&sprites[scene->background_spriteindex], 0.0f, 0.0f, 100.0f, 100.0f, 0xFF);

   // draw the table border

   Render_DrawSceneObject (&scene->objects[0]);

   Render_DrawSceneObject (&scene->objects[1]);

   // draw the table and build the stencil buffer at the same time

   d3ddev->SetRenderState (D3DRS_STENCILENABLE, true); // enable the stencil buffer (i.e. the "frame" for drawing table reflections)

   d3ddev->SetRenderState (D3DRS_STENCILFUNC, D3DCMP_ALWAYS); // instruct how to fill it

   d3ddev->SetRenderState (D3DRS_STENCILPASS, D3DSTENCILOP_INCRSAT); // instruct how to fill it

   Render_DrawSceneObject (&scene->objects[2]); // draw the table squares in the stencil buffer

   d3ddev->SetRenderState (D3DRS_STENCILENABLE, false); // finished drawing the stencil buffer

   d3ddev->SetRenderState (D3DRS_ZENABLE, true); // re-enable depth testing

   ////////////////////////////////////////////////////////////

   // draw the scene objects and their reflections on the table

   // start with the reflections if we want them, and if the table does it

   if (options.want_reflections && (theme->reflection_alpha > 0))

   {

      // build an array of reflected objects with their distances

      reflectedobjects = NULL;

      reflectedobject_count = 0;

      otherobjects = NULL;

      otherobject_count = 0;

      // cycle through all parts and see which ones need to be reflected

      for (object_index = 3; object_index < scene->object_count; object_index++)

      {

         sceneobject = &scene->objects[object_index]; // quick access to scene object

         // is this object a mesh AND it's above the ground ?

         if ((sceneobject->mesh_index != -1) && (sceneobject->z > 0))

         {

            // yes it is. It thus needs to be reflected, so add it to the list

            reflectedobjects = (reflectedobject_t *) SAFE_realloc (reflectedobjects, reflectedobject_count, reflectedobject_count + 1, sizeof (reflectedobject_t), false);

            reflectedobjects[reflectedobject_count].object = sceneobject; // save scene object

            reflectedobjects[reflectedobject_count].distance = DistanceToCamera (sceneobject->x, sceneobject->y, sceneobject->z);

            reflectedobject_count++; // we have now one object more to reflect

         }

         else

         {

            // no it's not. It doesn't need to be reflected, so add it to the other list

            otherobjects = (reflectedobject_t *) SAFE_realloc (otherobjects, otherobject_count, otherobject_count + 1, sizeof (reflectedobject_t), false);

            otherobjects[otherobject_count].object = sceneobject; // save scene object

            otherobjects[otherobject_count].distance = 0;

            otherobject_count++; // we have now one object more to reflect

         }

      }

      // now sort them from farthest to closest and draw them in this order

      qsort (reflectedobjects, reflectedobject_count, sizeof (reflectedobject_t), SortReflectedObjects);

      for (object_index = 0; object_index < reflectedobject_count; object_index++)

         Render_DrawSceneObjectReflection (reflectedobjects[object_index].object); // draw the reflection

      for (object_index = 0; object_index < reflectedobject_count; object_index++)

         Render_DrawSceneObject (reflectedobjects[object_index].object); // and draw the objects afterwards

      for (object_index = 0; object_index < otherobject_count; object_index++)

         Render_DrawSceneObject (otherobjects[object_index].object); // finally, draw the non-reflected objects

      SAFE_free ((void **) &reflectedobjects); // and free the reflected objects array

      SAFE_free ((void **) &otherobjects); // and the non-reflected objects array

   }

   else

      for (object_index = 3; object_index < scene->object_count; object_index++)

         Render_DrawSceneObject (&scene->objects[object_index]); // else if no reflections, draw the objects, the Z-buffer will sort them

   // draw the overlay texture if required

   if (scene->overlay_spriteindex >= 0)

      Render_DrawSprite (&sprites[scene->overlay_spriteindex], 0.0f, 0.0f, 100.0f, 100.0f, 0x4F);

   ///////////////

   // draw the GUI

   // draw the arrows

   DRAW_BUTTON_IF_NEEDED (scene->gui.larrow); // left arrow

   DRAW_BUTTON_IF_NEEDED (scene->gui.rarrow); // right arrow

   DRAW_TEXT_IF_NEEDED (scene->gui.arrow_text); // arrow text

   if (want_framerate)

      Render_wprintf (initial_width - 10, 10, 62, ALIGN_RIGHT, ALIGN_TOP, ALIGN_CENTER, arrow_fontindex, D3DCOLOR_RGBA (255, 255, 255, 255), NULL,

                      L"%d textures\n"

                      L"%d meshes\n"

                      L"%d fonts\n"

                      L"%d sprites\n"

                      L"%d fps", texture_count, mesh_count, font_count, sprite_count, framerate_value);

   // draw the other GUI buttons

   DRAW_BUTTON_IF_NEEDED (scene->gui.chatbutton); // chat button

   DRAW_BUTTON_IF_NEEDED (scene->gui.gamesbutton); // games button

   DRAW_BUTTON_IF_NEEDED (scene->gui.peoplebutton); // people button

   // does the parts pick line need to be displayed ?

   if (scene->gui.is_partspick_displayed)

   {

#define PARTSIZE_PCT (100.0f / 13.0f)

      if (scene->gui.partspick_selectedpart == 'P')      Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  0.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);

      else if (scene->gui.partspick_selectedpart == 'R') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  1.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);

      else if (scene->gui.partspick_selectedpart == 'N') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  2.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);

      else if (scene->gui.partspick_selectedpart == 'B') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  3.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);

      else if (scene->gui.partspick_selectedpart == 'Q') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  4.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);

      else if (scene->gui.partspick_selectedpart == 'K') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  5.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);

      else if (scene->gui.partspick_selectedpart == ' ') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  6.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);

      else if (scene->gui.partspick_selectedpart == 'k') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  7.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);

      else if (scene->gui.partspick_selectedpart == 'q') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  8.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);

      else if (scene->gui.partspick_selectedpart == 'b') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  9.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);

      else if (scene->gui.partspick_selectedpart == 'n') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex], 10.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);

      else if (scene->gui.partspick_selectedpart == 'r') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex], 11.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);

      else if (scene->gui.partspick_selectedpart == 'p') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex], 12.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);

      Render_DrawSprite (&sprites[theme->flatsprites[COLOR_WHITE][PART_PAWN]],       0.0f * PARTSIZE_PCT, 0, PARTSIZE_PCT, 11.0f, (((scene->gui.partspick_hoveredpart == 'P') || (scene->gui.partspick_selectedpart == 'P')) ? 0xFF : 0x7F)); // white pawn

      Render_DrawSprite (&sprites[theme->flatsprites[COLOR_WHITE][PART_ROOK]],       1.0f * PARTSIZE_PCT, 0, PARTSIZE_PCT, 11.0f, (((scene->gui.partspick_hoveredpart == 'R') || (scene->gui.partspick_selectedpart == 'R')) ? 0xFF : 0x7F)); // white rook

      Render_DrawSprite (&sprites[theme->flatsprites[COLOR_WHITE][PART_KNIGHT]],     2.0f * PARTSIZE_PCT, 0, PARTSIZE_PCT, 11.0f, (((scene->gui.partspick_hoveredpart == 'N') || (scene->gui.partspick_selectedpart == 'N')) ? 0xFF : 0x7F)); // white knight

      Render_DrawSprite (&sprites[theme->flatsprites[COLOR_WHITE][PART_BISHOP]],     3.0f * PARTSIZE_PCT, 0, PARTSIZE_PCT, 11.0f, (((scene->gui.partspick_hoveredpart == 'B') || (scene->gui.partspick_selectedpart == 'B')) ? 0xFF : 0x7F)); // white bishop

      Render_DrawSprite (&sprites[theme->flatsprites[COLOR_WHITE][PART_QUEEN]],      4.0f * PARTSIZE_PCT, 0, PARTSIZE_PCT, 11.0f, (((scene->gui.partspick_hoveredpart == 'Q') || (scene->gui.partspick_selectedpart == 'Q')) ? 0xFF : 0x7F)); // white queen

      Render_DrawSprite (&sprites[theme->flatsprites[COLOR_WHITE][PART_KING]],       5.0f * PARTSIZE_PCT, 0, PARTSIZE_PCT, 11.0f, (((scene->gui.partspick_hoveredpart == 'K') || (scene->gui.partspick_selectedpart == 'K')) ? 0xFF : 0x7F)); // white king

      Render_DrawSprite (&sprites[theme->lastmovesource_spriteindex],         6.0f * PARTSIZE_PCT, 0, PARTSIZE_PCT, 11.0f, (((scene->gui.partspick_hoveredpart == ' ') || (scene->gui.partspick_selectedpart == ' ')) ? 0xFF : 0x7F)); // erase mark

      Render_DrawSprite (&sprites[theme->flatsprites[COLOR_BLACK][PART_KING]],       7.0f * PARTSIZE_PCT, 0, PARTSIZE_PCT, 11.0f, (((scene->gui.partspick_hoveredpart == 'k') || (scene->gui.partspick_selectedpart == 'k')) ? 0xFF : 0x7F)); // black king

      Render_DrawSprite (&sprites[theme->flatsprites[COLOR_BLACK][PART_QUEEN]],      8.0f * PARTSIZE_PCT, 0, PARTSIZE_PCT, 11.0f, (((scene->gui.partspick_hoveredpart == 'q') || (scene->gui.partspick_selectedpart == 'q')) ? 0xFF : 0x7F)); // black queen

      Render_DrawSprite (&sprites[theme->flatsprites[COLOR_BLACK][PART_BISHOP]],     9.0f * PARTSIZE_PCT, 0, PARTSIZE_PCT, 11.0f, (((scene->gui.partspick_hoveredpart == 'b') || (scene->gui.partspick_selectedpart == 'b')) ? 0xFF : 0x7F)); // black bishop

      Render_DrawSprite (&sprites[theme->flatsprites[COLOR_BLACK][PART_KNIGHT]],    10.0f * PARTSIZE_PCT, 0, PARTSIZE_PCT, 11.0f, (((scene->gui.partspick_hoveredpart == 'n') || (scene->gui.partspick_selectedpart == 'n')) ? 0xFF : 0x7F)); // black knight

      Render_DrawSprite (&sprites[theme->flatsprites[COLOR_BLACK][PART_ROOK]],      11.0f * PARTSIZE_PCT, 0, PARTSIZE_PCT, 11.0f, (((scene->gui.partspick_hoveredpart == 'r') || (scene->gui.partspick_selectedpart == 'r')) ? 0xFF : 0x7F)); // black rook

      Render_DrawSprite (&sprites[theme->flatsprites[COLOR_BLACK][PART_PAWN]],      12.0f * PARTSIZE_PCT, 0, PARTSIZE_PCT, 11.0f, (((scene->gui.partspick_hoveredpart == 'p') || (scene->gui.partspick_selectedpart == 'p')) ? 0xFF : 0x7F)); // black pawn

#undef PARTSIZE_PCT

   }

   // draw GUI texts

   DRAW_TEXT_IF_NEEDED (scene->gui.comment_text); // move comments

   DRAW_TEXT_IF_NEEDED (scene->gui.history_text); // game history

   DRAW_TEXT_IF_NEEDED (scene->gui.clock_text); // game clock