Subversion Repositories Games.Chess Giants

Rev

Rev 131 | Rev 140 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. // render.cpp
  2.  
  3. // thanks ChaotikMind for optimizing the engine a bit :)
  4.  
  5. #include "common.h"
  6.  
  7.  
  8. // note: DirectX requires a C++ compiler.
  9. #include "DirectX9/Include/d3d9.h"
  10. #include "DirectX9/Include/d3dx9.h"
  11.  
  12. // include the Direct3D library files
  13. #pragma comment (lib, "DirectX9/Lib/x86/d3d9.lib")
  14. #pragma comment (lib, "DirectX9/Lib/x86/d3dx9.lib")
  15.  
  16.  
  17. // handy macro to print a chatter channel reply
  18. #define PRINT_CCREPLY(ccreply) \
  19. { \
  20.    Render_wprintf (rect.right * 100.0f / initial_width, 100 - combinedheight_percent, (initial_width - rect.right) * 100.0f / initial_width, ALIGN_LEFT, ALIGN_TOP, ALIGN_LEFT, \
  21.                    chat_fontindex, (ccreply)->color, &rect, \
  22.                    L"["); \
  23.    Render_wprintf (rect.right * 100.0f / initial_width, 100 - combinedheight_percent, (initial_width - rect.right) * 100.0f / initial_width, ALIGN_LEFT, ALIGN_TOP, ALIGN_LEFT, \
  24.                    chat_fontindex, RGBA_TO_RGBACOLOR (159, 159, 159, RGBACOLOR_ALPHA ((ccreply)->color)), &rect, \
  25.                    (ccreply)->channelname); \
  26.    Render_wprintf (rect.right * 100.0f / initial_width, 100 - combinedheight_percent, (initial_width - rect.right) * 100.0f / initial_width, ALIGN_LEFT, ALIGN_TOP, ALIGN_LEFT, \
  27.                    chat_fontindex, (ccreply)->color, &rect, \
  28.                    L"] "); /* closing bracket + non-breakable space */ \
  29.    Render_wprintf (rect.right * 100.0f / initial_width, 100 - combinedheight_percent, (initial_width - rect.right) * 100.0f / initial_width, ALIGN_LEFT, ALIGN_TOP, ALIGN_LEFT, \
  30.                    chat_fontindex, RGBA_TO_RGBACOLOR (159, 159, 159, RGBACOLOR_ALPHA ((ccreply)->color)), &rect, \
  31.                    (ccreply)->nickname); \
  32.    Render_wprintf (rect.right * 100.0f / initial_width, 100 - combinedheight_percent, (initial_width - rect.right) * 100.0f / initial_width, ALIGN_LEFT, ALIGN_TOP, ALIGN_LEFT, \
  33.                    chat_fontindex, (ccreply)->color, &rect, \
  34.                    L": "); /* colon + non-breakable space */ \
  35.    if ((ccreply)->text != NULL) \
  36.       Render_wprintf (rect.right * 100.0f / initial_width, 100 - combinedheight_percent, (initial_width - rect.right) * 100.0f / initial_width, ALIGN_LEFT, ALIGN_TOP, ALIGN_LEFT, \
  37.                       chat_fontindex, (ccreply)->color, &rect, \
  38.                       (ccreply)->text); \
  39. }
  40.  
  41.  
  42. // handy macro to draw a GUI button
  43. #define DRAW_BUTTON_IF_NEEDED(button) \
  44. { \
  45.    if ((button).state != 0) \
  46.    { \
  47.       Render_DrawSprite (&sprites[(button).sprite_index], (button).left, (button).top, (button).width, (button).height, ((button).state == 2 ? 0xFF : 0x7F)); \
  48.       if ((button).text[0] != 0) \
  49.          Render_wprintf ((button).left + (button).width / 2.0f, (button).top + (button).height / 2.0f, (button).width, ALIGN_CENTER, ALIGN_CENTER, ALIGN_CENTER, chat_fontindex, D3DCOLOR_ARGB (255, 255, 255, /*alpha*/ ((button).state == 2 ? 0xFF : 0x7F)), NULL, (button).text); \
  50.    } \
  51. }
  52.  
  53.  
  54. // handy macro to draw a GUI text
  55. #define DRAW_TEXT_IF_NEEDED(text) \
  56. { \
  57.    if ((text).is_displayed) \
  58.    { \
  59.       Render_wprintf ((text).xpos_percent, (text).ypos_percent, \
  60.                       (text).maxwidth_percent, (text).horizontal_align, (text).vertical_align, (text).text_align, (text).font_index, \
  61.                       ((text).want_fade ? \
  62.                        RGBACOLOR_SETALPHA ((text).color, \
  63.                                            (((text).appear_time + (text).disappear_time) * 0.5f > current_time ? \
  64.                                            /* fading in  */ (int) FadeFloat (0, RGBACOLOR_ALPHA ((text).color), (text).appear_time, (text).appear_time + 0.5f) : \
  65.                                            /* fading out */ (int) FadeFloat (RGBACOLOR_ALPHA ((text).color), 0, (text).disappear_time - 3.0f, (text).disappear_time))) : \
  66.                        (text).color), \
  67.                       NULL, (text).buffer); \
  68.       if ((text).disappear_time < current_time) \
  69.          (text).is_displayed = false; \
  70.    } \
  71. }
  72.  
  73.  
  74. #pragma pack(push,1)
  75.  
  76. // definition for a vector
  77. typedef struct vector_s
  78. {
  79.    float x; // X component
  80.    float y; // Y component
  81.    float z; // Z component
  82. } vector_t;
  83.  
  84.  
  85. // definition for a texture coordinates pair
  86. typedef struct texcoord_s
  87. {
  88.    float u; // X coordinate of the texture point this vertex corresponds to
  89.    float v; // Y coordinate of the texture point this vertex corresponds to
  90. } texcoord_t;
  91.  
  92.  
  93. // definition for a vertex (must be in that order for Direct3D)
  94. typedef struct vertex_s
  95. {
  96.    vector_t position; // position in space
  97.    vector_t normal; // coordinates of the unary normal vector of the plane this vertex is on (for illumination)
  98.    texcoord_t texcoord; // coordinates of the texture point this vertex corresponds to
  99. } vertex_t;
  100.  
  101. #pragma pack(pop)
  102.  
  103.  
  104. // definition for a reflected object (qsort array element to sort reflections by distance)
  105. typedef struct reflectedobject_s
  106. {
  107.    sceneobject_t *object; // pointer to the scene object
  108.    float distance; // distance to viewer camera
  109. } reflectedobject_t;
  110.  
  111.  
  112. // definition for a material (light reflection type)
  113. typedef struct material_s
  114. {
  115.    wchar_t name[32]; // material name
  116.    float ambient; // ambient reflection value ranging from 0 to 1
  117.    float diffuse; // diffuse reflection value ranging from 0 to 1
  118.    float emissive; // emissive reflection value ranging from 0 to 1
  119.    float specular; // specular reflection value ranging from 0 to 1
  120.    float shininess; // shininess (specular factor)
  121.    float transparency; // transparency value ranging from 0 (fully transparent) to 1 (opaque)
  122. } material_t;
  123.  
  124.  
  125. // definition for a mesh
  126. typedef struct mesh_s
  127. {
  128.    unsigned long hash; // basic content hash, to avoid duplicates
  129.    unsigned long vertex_format;
  130.    IDirect3DVertexBuffer9 *d3dvertices; // handled opaquely by Direct3D
  131.    int vertice_size;
  132.    int vertice_count;
  133.    bool is_indexed; // set to TRUE if this mesh has an index buffer
  134.    IDirect3DIndexBuffer9 *d3dindices; // handled opaquely by Direct3D
  135.    int indice_size;
  136.    int indice_count;
  137. } mesh_t;
  138.  
  139.  
  140. // definition for a texture
  141. typedef struct texture_s
  142. {
  143.    unsigned long hash; // basic content hash, to avoid duplicates
  144.    int width;
  145.    int height;
  146.    IDirect3DTexture9 *texture;
  147. } texture_t;
  148.  
  149.  
  150. // definition for a font
  151. typedef struct font_s
  152. {
  153.    unsigned long pathname_hash;
  154.    ID3DXFont *font;
  155. } font_t;
  156.  
  157.  
  158. // definition for a sprite
  159. typedef struct sprite_s
  160. {
  161.    unsigned long hash; // basic content hash, to avoid duplicates
  162.    ID3DXSprite *sprite;
  163.    int texture_index;
  164. } sprite_t;
  165.  
  166.  
  167. // global variables used in this module only
  168. static IDirect3D9 *d3d = NULL; // our Direct3D interface
  169. static IDirect3DDevice9 *d3ddev = NULL; // the device class
  170.  
  171. static material_t *materials = NULL;
  172. static int material_count = 0;
  173. static texture_t *textures = NULL;
  174. static int texture_count = 0;
  175. static mesh_t *meshes = NULL;
  176. static int mesh_count = 0;
  177. static font_t *fonts = NULL;
  178. static int font_count = 0;
  179. static sprite_t *sprites = NULL;
  180. static int sprite_count = 0;
  181. static const float fov_value = 45.0f; // field of view width, in degrees
  182. static const float viewdist_near = 1.0f; // nearest view plane distance
  183. static const float viewdist_far = 200.0f; // farthest view plane distance
  184. static int initial_width = 0; // initial width of the render surface, in pixels (typically equal to the max displayable size)
  185. static int initial_height = 0; // initial height of the render surface, in pixels (typically equal to the max displayable size)
  186. static float current_width = 0.0f; // current width of the client area on which the render surface is rendered, in pixels
  187. static float current_height = 0.0f; // current height of the client area on which the render surface is rendered, in pixels
  188. static D3DCOLOR ambient_light;
  189. static vector_t camera_position;
  190. static vector_t scene_lookatpoint = { 0.0f, 0.0f, 0.0f };
  191. static const vector_t upwards_direction = { 0.0f, 0.0f, 1.0f };
  192. static int best_supported_filter;
  193. static bool is_fsaa_supported = false;
  194.  
  195. static wchar_t printf_buffer[0xffff];
  196.  
  197.  
  198. // prototypes of functions used in this module only
  199. static bool Render_LoadMesh_X (mesh_t *mesh, const wchar_t *xfile_pathname);
  200. static bool Render_LoadMesh_Obj (mesh_t *mesh, const wchar_t *objfile_pathname);
  201. static void Render_DrawSceneObjectReflection (sceneobject_t *sceneobject);
  202. static void Render_DrawSceneObject (sceneobject_t *sceneobject);
  203. static void Render_DrawSceneTile (sceneobject_t *sceneobject);
  204. static void Render_DrawSprite (sprite_t *sprite, float x_percent, float y_percent, float width_percent, float height_percent, int alpha);
  205. static void Render_GetTextBoundaries (float maxwidth_percent, int font_id, wchar_t *text, RECT *rect);
  206. static void Render_wprintf (float x_percent, float y_percent, float maxwidth_percent, int horiz_align, int vert_align, int text_align, int font_id, unsigned long color_rgba, RECT *out_rect, const wchar_t *fmt, ...);
  207. static float DistanceToCamera (float x, float y, float z);
  208. static float FadeFloat (float from, float to, float start_time, float end_time);
  209. static unsigned long HashString (const wchar_t *string_buffer);
  210. static unsigned long HashFile (const wchar_t *file_pathname);
  211. static void ResolveWildcard (wchar_t *file_pathname, wchar_t *extensions_separated_by_bars);
  212. static int SortReflectedObjects (const void *object1, const void *object2);
  213.  
  214.  
  215. bool Render_Init (const wchar_t *fmt, ...)
  216. {
  217.    // this function sets up and initializes Direct3D
  218.  
  219.    static wchar_t splashscreen_pathname[MAX_PATH];
  220.    static wchar_t *default_materialname = L"default";
  221.    va_list argptr;
  222.  
  223.    D3DCAPS9 device_capabilities;
  224.    unsigned long behaviour_flags;
  225.    unsigned long multisample_quality_count;
  226.    D3DPRESENT_PARAMETERS d3dpp;
  227.    wchar_t errorfile_path[MAX_PATH];
  228.    wchar_t line_buffer[256];
  229.    material_t material;
  230.    HRESULT ret;
  231.    RECT rect;
  232.    RECT viewport_rect;
  233.    FILE *fp;
  234.  
  235.    // concatenate all the arguments in one string
  236.    va_start (argptr, fmt);
  237.    wvsprintf (splashscreen_pathname, fmt, argptr);
  238.    va_end (argptr);
  239.  
  240.    // create the Direct3D interface
  241.    d3d = Direct3DCreate9 (D3D_SDK_VERSION);
  242.  
  243.    // get hardware capabilities
  244.    if (FAILED (d3d->GetDeviceCaps (D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &device_capabilities)))
  245.    {
  246.       MessageBox (NULL, LOCALIZE (L"Error_CouldNotCreateD3DDevGetDeviceCapsFailed"), LOCALIZE (L"FatalError"), MB_ICONERROR | MB_OK);
  247.       terminate_everything = true; // this is a fatal error
  248.       return (false);
  249.    }
  250.  
  251.    // grab info from that and adjust our D3D settings
  252.    best_supported_filter = (device_capabilities.RasterCaps & D3DPRASTERCAPS_ANISOTROPY ? D3DTEXF_ANISOTROPIC : D3DTEXF_LINEAR);
  253.    behaviour_flags = (device_capabilities.VertexProcessingCaps != 0 ? D3DCREATE_HARDWARE_VERTEXPROCESSING : D3DCREATE_SOFTWARE_VERTEXPROCESSING);
  254.  
  255.    // see if simple (non-maskable) full-scene antialiasing is supported and in how many quality flavors
  256.    if (SUCCEEDED (d3d->CheckDeviceMultiSampleType (D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, false, D3DMULTISAMPLE_NONMASKABLE, &multisample_quality_count)))
  257.       is_fsaa_supported = true; // remember FSAA is supported
  258.  
  259.    memset (&d3dpp, 0, sizeof (d3dpp)); // clear out the struct for use
  260.    d3dpp.Windowed = true; // always windowed (because we can't display dialog boxes in fullscreen mode)
  261.    d3dpp.BackBufferCount = 1;
  262.    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; // discard old frames
  263.    d3dpp.hDeviceWindow = hMainWnd; // set the window to be used by Direct3D
  264.    d3dpp.EnableAutoDepthStencil = true; // enable Z-buffer and stencil buffer
  265.    d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8; // D3DFMT_D15S1 15 bits should be enough to store each pixel's Z depth
  266.    if (is_fsaa_supported)
  267.    {
  268.       d3dpp.MultiSampleType = D3DMULTISAMPLE_NONMASKABLE; // use multisampling (full scene antialiasing) if supported
  269.       d3dpp.MultiSampleQuality = multisample_quality_count - 1; // use the best available multisample quality
  270.    }
  271.    else
  272.    {
  273.       d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE; // do not use multisampling (full scene antialiasing)
  274.       d3dpp.MultiSampleQuality = 0;
  275.    }
  276.  
  277.    // get main window's current rectangle and full screen size
  278.    GetWindowRect (hMainWnd, &rect);
  279.  
  280.    // create a device class using this information and the info from the d3dpp stuct. Resize the window to the max displayable
  281.    // size before creating the DirectX device, so as to guarantee the viewport will never be upscaled in case of window resize.
  282.    MoveWindow (hMainWnd, rect.left, rect.top, GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN), false);
  283.    if (FAILED (ret = d3d->CreateDevice (D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hMainWnd, behaviour_flags, &d3dpp, &d3ddev)))
  284.    {
  285.       MessageBox (NULL, LOCALIZE (L"Error_CouldNotCreateD3DDevCreateDeviceFailed"), LOCALIZE (L"FatalError"), MB_ICONERROR | MB_OK);
  286.  
  287.       // on error, write a log file on the user's desktop
  288.       errorfile_path[0] = 0;
  289.       SHGetSpecialFolderPath (NULL, errorfile_path, CSIDL_DESKTOP, true);
  290.       wcscat_s (errorfile_path, WCHAR_SIZEOF (errorfile_path), L"\\Chess Giants error.log");
  291.       _wfopen_s (&fp, errorfile_path, L"w, ccs=UNICODE");
  292.       if (fp != NULL)
  293.       {
  294.          fwprintf (fp, L"device_capabilities.DeviceType = %d\n", device_capabilities.DeviceType);
  295.          fwprintf (fp, L"device_capabilities.AdapterOrdinal = %ul\n", device_capabilities.AdapterOrdinal);
  296.          fwprintf (fp, L"device_capabilities.Caps = %ul\n", device_capabilities.Caps);
  297.          fwprintf (fp, L"device_capabilities.Caps2 = %ul\n", device_capabilities.Caps2);
  298.          fwprintf (fp, L"device_capabilities.Caps3 = %ul\n", device_capabilities.Caps3);
  299.          fwprintf (fp, L"device_capabilities.PresentationIntervals = %ul\n", device_capabilities.PresentationIntervals);
  300.          fwprintf (fp, L"device_capabilities.CursorCaps = %ul\n", device_capabilities.CursorCaps);
  301.          fwprintf (fp, L"device_capabilities.DevCaps = %ul\n", device_capabilities.DevCaps);
  302.          fwprintf (fp, L"device_capabilities.PrimitiveMiscCaps = %ul\n", device_capabilities.PrimitiveMiscCaps);
  303.          fwprintf (fp, L"device_capabilities.RasterCaps = %ul\n", device_capabilities.RasterCaps);
  304.          fwprintf (fp, L"device_capabilities.ZCmpCaps = %ul\n", device_capabilities.ZCmpCaps);
  305.          fwprintf (fp, L"device_capabilities.SrcBlendCaps = %ul\n", device_capabilities.SrcBlendCaps);
  306.          fwprintf (fp, L"device_capabilities.DestBlendCaps = %ul\n", device_capabilities.DestBlendCaps);
  307.          fwprintf (fp, L"device_capabilities.AlphaCmpCaps = %ul\n", device_capabilities.AlphaCmpCaps);
  308.          fwprintf (fp, L"device_capabilities.ShadeCaps = %ul\n", device_capabilities.ShadeCaps);
  309.          fwprintf (fp, L"device_capabilities.TextureCaps = %ul\n", device_capabilities.TextureCaps);
  310.          fwprintf (fp, L"device_capabilities.TextureFilterCaps = %ul\n", device_capabilities.TextureFilterCaps);
  311.          fwprintf (fp, L"device_capabilities.CubeTextureFilterCaps = %ul\n", device_capabilities.CubeTextureFilterCaps);
  312.          fwprintf (fp, L"device_capabilities.VolumeTextureFilterCaps = %ul\n", device_capabilities.VolumeTextureFilterCaps);
  313.          fwprintf (fp, L"device_capabilities.TextureAddressCaps = %ul\n", device_capabilities.TextureAddressCaps);
  314.          fwprintf (fp, L"device_capabilities.VolumeTextureAddressCaps = %ul\n", device_capabilities.VolumeTextureAddressCaps);
  315.          fwprintf (fp, L"device_capabilities.LineCaps = %ul\n", device_capabilities.LineCaps);
  316.          fwprintf (fp, L"device_capabilities.MaxTextureWidth = %ul\n", device_capabilities.MaxTextureWidth);
  317.          fwprintf (fp, L"device_capabilities.MaxTextureHeight = %ul\n", device_capabilities.MaxTextureHeight);
  318.          fwprintf (fp, L"device_capabilities.MaxVolumeExtent = %ul\n", device_capabilities.MaxVolumeExtent);
  319.          fwprintf (fp, L"device_capabilities.MaxTextureRepeat = %ul\n", device_capabilities.MaxTextureRepeat);
  320.          fwprintf (fp, L"device_capabilities.MaxTextureAspectRatio = %ul\n", device_capabilities.MaxTextureAspectRatio);
  321.          fwprintf (fp, L"device_capabilities.MaxAnisotropy = %ul\n", device_capabilities.MaxAnisotropy);
  322.          fwprintf (fp, L"device_capabilities.MaxVertexW = %f\n", device_capabilities.MaxVertexW);
  323.          fwprintf (fp, L"device_capabilities.GuardBandLeft = %f\n", device_capabilities.GuardBandLeft);
  324.          fwprintf (fp, L"device_capabilities.GuardBandTop = %f\n", device_capabilities.GuardBandTop);
  325.          fwprintf (fp, L"device_capabilities.GuardBandRight = %f\n", device_capabilities.GuardBandRight);
  326.          fwprintf (fp, L"device_capabilities.GuardBandBottom = %f\n", device_capabilities.GuardBandBottom);
  327.          fwprintf (fp, L"device_capabilities.ExtentsAdjust = %f\n", device_capabilities.ExtentsAdjust);
  328.          fwprintf (fp, L"device_capabilities.StencilCaps = %ul\n", device_capabilities.StencilCaps);
  329.          fwprintf (fp, L"device_capabilities.FVFCaps = %ul\n", device_capabilities.FVFCaps);
  330.          fwprintf (fp, L"device_capabilities.TextureOpCaps = %ul\n", device_capabilities.TextureOpCaps);
  331.          fwprintf (fp, L"device_capabilities.MaxTextureBlendStages = %ul\n", device_capabilities.MaxTextureBlendStages);
  332.          fwprintf (fp, L"device_capabilities.MaxSimultaneousTextures = %ul\n", device_capabilities.MaxSimultaneousTextures);
  333.          fwprintf (fp, L"device_capabilities.VertexProcessingCaps = %ul\n", device_capabilities.VertexProcessingCaps);
  334.          fwprintf (fp, L"device_capabilities.MaxActiveLights = %ul\n", device_capabilities.MaxActiveLights);
  335.          fwprintf (fp, L"device_capabilities.MaxUserClipPlanes = %ul\n", device_capabilities.MaxUserClipPlanes);
  336.          fwprintf (fp, L"device_capabilities.MaxVertexBlendMatrices = %ul\n", device_capabilities.MaxVertexBlendMatrices);
  337.          fwprintf (fp, L"device_capabilities.MaxVertexBlendMatrixIndex = %ul\n", device_capabilities.MaxVertexBlendMatrixIndex);
  338.          fwprintf (fp, L"device_capabilities.MaxPointSize = %f\n", device_capabilities.MaxPointSize);
  339.          fwprintf (fp, L"device_capabilities.MaxPrimitiveCount = %ul\n", device_capabilities.MaxPrimitiveCount);
  340.          fwprintf (fp, L"device_capabilities.MaxVertexIndex = %ul\n", device_capabilities.MaxVertexIndex);
  341.          fwprintf (fp, L"device_capabilities.MaxStreams = %ul\n", device_capabilities.MaxStreams);
  342.          fwprintf (fp, L"device_capabilities.MaxStreamStride = %ul\n", device_capabilities.MaxStreamStride);
  343.          fwprintf (fp, L"device_capabilities.VertexShaderVersion = %ul\n", device_capabilities.VertexShaderVersion);
  344.          fwprintf (fp, L"device_capabilities.MaxVertexShaderConst = %ul\n", device_capabilities.MaxVertexShaderConst);
  345.          fwprintf (fp, L"device_capabilities.PixelShaderVersion = %ul\n", device_capabilities.PixelShaderVersion);
  346.          fwprintf (fp, L"device_capabilities.PixelShader1xMaxValue = %f\n", device_capabilities.PixelShader1xMaxValue);
  347.          fwprintf (fp, L"device_capabilities.DevCaps2 = %ul\n", device_capabilities.DevCaps2);
  348.          fwprintf (fp, L"device_capabilities.MaxNpatchTessellationLevel = %f\n", device_capabilities.MaxNpatchTessellationLevel);
  349.          fwprintf (fp, L"device_capabilities.Reserved5 = %ul\n", device_capabilities.Reserved5);
  350.          fwprintf (fp, L"device_capabilities.MasterAdapterOrdinal = %ul\n", device_capabilities.MasterAdapterOrdinal);
  351.          fwprintf (fp, L"device_capabilities.AdapterOrdinalInGroup = %ul\n", device_capabilities.AdapterOrdinalInGroup);
  352.          fwprintf (fp, L"device_capabilities.NumberOfAdaptersInGroup = %ul\n", device_capabilities.NumberOfAdaptersInGroup);
  353.          fwprintf (fp, L"device_capabilities.DeclTypes = %ul\n", device_capabilities.DeclTypes);
  354.          fwprintf (fp, L"device_capabilities.NumSimultaneousRTs = %ul\n", device_capabilities.NumSimultaneousRTs);
  355.          fwprintf (fp, L"device_capabilities.StretchRectFilterCaps = %ul\n", device_capabilities.StretchRectFilterCaps);
  356.          fwprintf (fp, L"device_capabilities.VS20Caps.Caps = %ul\n", device_capabilities.VS20Caps.Caps);
  357.          fwprintf (fp, L"device_capabilities.VS20Caps.DynamicFlowControlDepth = %d\n", device_capabilities.VS20Caps.DynamicFlowControlDepth);
  358.          fwprintf (fp, L"device_capabilities.VS20Caps.NumTemps = %d\n", device_capabilities.VS20Caps.NumTemps);
  359.          fwprintf (fp, L"device_capabilities.VS20Caps.StaticFlowControlDepth = %d\n", device_capabilities.VS20Caps.StaticFlowControlDepth);
  360.          fwprintf (fp, L"device_capabilities.PS20Caps.Caps = %ul\n", device_capabilities.PS20Caps.Caps);
  361.          fwprintf (fp, L"device_capabilities.PS20Caps.DynamicFlowControlDepth = %d\n", device_capabilities.PS20Caps.DynamicFlowControlDepth);
  362.          fwprintf (fp, L"device_capabilities.PS20Caps.NumTemps = %d\n", device_capabilities.PS20Caps.NumTemps);
  363.          fwprintf (fp, L"device_capabilities.PS20Caps.StaticFlowControlDepth = %d\n", device_capabilities.PS20Caps.StaticFlowControlDepth);
  364.          fwprintf (fp, L"device_capabilities.PS20Caps.NumInstructionSlots = %d\n", device_capabilities.PS20Caps.NumInstructionSlots);
  365.          fwprintf (fp, L"device_capabilities.VertexTextureFilterCaps = %ul\n", device_capabilities.VertexTextureFilterCaps);
  366.          fwprintf (fp, L"device_capabilities.MaxVShaderInstructionsExecuted = %ul\n", device_capabilities.MaxVShaderInstructionsExecuted);
  367.          fwprintf (fp, L"device_capabilities.MaxPShaderInstructionsExecuted = %ul\n", device_capabilities.MaxPShaderInstructionsExecuted);
  368.          fwprintf (fp, L"device_capabilities.MaxVertexShader30InstructionSlots = %ul\n", device_capabilities.MaxVertexShader30InstructionSlots);
  369.          fwprintf (fp, L"device_capabilities.MaxPixelShader30InstructionSlots = %ul\n", device_capabilities.MaxPixelShader30InstructionSlots);
  370.          fwprintf (fp, L"========\n");
  371.          fwprintf (fp, L"(guessed) behaviour_flags = %ul\n", behaviour_flags);
  372.          fwprintf (fp, L"========\n");
  373.          fwprintf (fp, L"d3dpp.MultiSampleType = %d\n", d3dpp.MultiSampleType);
  374.          fwprintf (fp, L"d3dpp.MultiSampleQuality = %d\n", d3dpp.MultiSampleQuality);
  375.          fwprintf (fp, L"========\n");
  376.          fwprintf (fp, L"d3d->CreateDevice() returned %d\n", (int) ret);
  377.          fclose (fp);
  378.  
  379.          MessageBox (NULL, LOCALIZE (L"Error_GameCouldNotStartPleaseSendLogToAuthor"), LOCALIZE (L"Information"), MB_ICONINFORMATION | MB_OK);
  380.       }
  381.       else
  382.          MessageBox (NULL, LOCALIZE (L"Error_CouldNotWriteToLogFile"), LOCALIZE (L"FatalError"), MB_ICONERROR | MB_OK);
  383.  
  384.       terminate_everything = true; // this is a fatal error
  385.       return (false);
  386.    }
  387.  
  388.    // save the viewport's width and height
  389.    GetClientRect (hMainWnd, &viewport_rect);
  390.    initial_width = viewport_rect.right;
  391.    initial_height = viewport_rect.bottom;
  392.  
  393.    // now resize the window to its original size
  394.    MoveWindow (hMainWnd, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, false);
  395.  
  396.    // set the texture parameters
  397.    d3ddev->SetSamplerState (0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP); // wrap textures around their edges
  398.    d3ddev->SetSamplerState (0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
  399.    d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE); // and modulate their alpha with the material's alpha
  400.    d3ddev->SetTextureStageState (0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
  401.    d3ddev->SetTextureStageState (0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
  402.  
  403.    // enable the Z buffer
  404.    d3ddev->SetRenderState (D3DRS_ZENABLE, true);
  405.  
  406.    // disable the stencil buffer
  407.    d3ddev->SetRenderState (D3DRS_STENCILENABLE, false);
  408.  
  409.    // normalize the face normals (if we don't, scaling will cause problems with lighting computations)
  410.    d3ddev->SetRenderState (D3DRS_NORMALIZENORMALS, true);
  411.  
  412.    // turn on alpha blending
  413.    d3ddev->SetRenderState (D3DRS_ALPHABLENDENABLE, true);
  414.    d3ddev->SetRenderState (D3DRS_BLENDOP, D3DBLENDOP_ADD);
  415.    d3ddev->SetRenderState (D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
  416.    d3ddev->SetRenderState (D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
  417.  
  418.    // use all of the materials' light reflection properties
  419.    d3ddev->SetRenderState (D3DRS_AMBIENTMATERIALSOURCE, D3DMCS_MATERIAL);
  420.    d3ddev->SetRenderState (D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_MATERIAL);
  421.    d3ddev->SetRenderState (D3DRS_SPECULARMATERIALSOURCE, D3DMCS_MATERIAL);
  422.    d3ddev->SetRenderState (D3DRS_EMISSIVEMATERIALSOURCE, D3DMCS_MATERIAL);
  423.    d3ddev->SetRenderState (D3DRS_COLORVERTEX, false);
  424.  
  425.    // enable 3D lighting
  426.    d3ddev->SetRenderState (D3DRS_LIGHTING, true);
  427.  
  428.    // load the splash screen sprite and display it
  429.    int bgsprite_index = Render_LoadSprite (splashscreen_pathname);
  430.    d3ddev->Clear (0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL, D3DCOLOR_XRGB (0, 0, 0), 1.0f, 0);
  431.    d3ddev->BeginScene (); // begins the 3D scene
  432.    Render_DrawSprite (&sprites[bgsprite_index], 0.0f, 0.0f, 100.0f, 100.0f, 0xFF); // draw the background sprite
  433.    d3ddev->EndScene (); // ends the 3D scene
  434.    d3ddev->Present (NULL, NULL, NULL, NULL); // displays the created frame on the screen
  435.  
  436.    // open and parse the materials file and build the materials list
  437.    materials = NULL;
  438.    material_count = 0;
  439.    _wfopen_s (&fp, L"materials.cfg", L"r, ccs=UNICODE");
  440.    if (fp != NULL)
  441.    {
  442.       // read line per line...
  443.       while (fgetws (line_buffer, WCHAR_SIZEOF (line_buffer), fp) != NULL)
  444.       {
  445.          // can we read a complete material line ?
  446.          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)
  447.          {
  448.             materials = (material_t *) SAFE_realloc (materials, material_count, material_count + 1, sizeof (material_t), false);
  449.             memcpy (&materials[material_count], &material, sizeof (material_t));
  450.             material_count++; // if so, append this new material to the materials array
  451.          }
  452.       }
  453.       fclose (fp); // finished, close the file
  454.    }
  455.    materials = (material_t *) SAFE_realloc (materials, material_count, material_count + 1, sizeof (material_t), false);
  456.    wcscpy_s (materials[material_count].name, WCHAR_SIZEOF (materials[material_count].name), default_materialname);
  457.    materials[material_count].ambient = 1.0f;
  458.    materials[material_count].diffuse = 1.0f;
  459.    materials[material_count].emissive = 0.0f;
  460.    materials[material_count].specular = 0.0f;
  461.    materials[material_count].shininess = 0.0f;
  462.    materials[material_count].transparency = 1.0f;
  463.    material_count++; // append a default material at the end of the array and we're all set
  464.  
  465.    return (true); // finished
  466. }
  467.  
  468.  
  469. void Render_Shutdown (void)
  470. {
  471.    // this function shuts down the Direct3D interfaces and releases the Direct3D COM objects
  472.  
  473.    int array_index;
  474.  
  475.    // close and release font data
  476.    SAFE_free ((void **) &fonts);
  477.    font_count = 0;
  478.  
  479.    // close and release sprite data
  480.    SAFE_free ((void **) &sprites);
  481.    sprite_count = 0;
  482.  
  483.    // close and release meshes data
  484.    if (meshes != NULL)
  485.    {
  486.       for (array_index = 0; array_index < mesh_count; array_index++)
  487.       {
  488.          if (meshes[array_index].d3dindices != NULL)
  489.             meshes[array_index].d3dindices->Release ();
  490.          meshes[array_index].d3dindices = NULL;
  491.  
  492.          if (meshes[array_index].d3dvertices != NULL)
  493.             meshes[array_index].d3dvertices->Release ();
  494.          meshes[array_index].d3dvertices = NULL;
  495.       }
  496.    }
  497.    meshes = NULL;
  498.    mesh_count = 0;
  499.  
  500.    // close and release texture data
  501.    if (textures != NULL)
  502.    {
  503.       for (array_index = 0; array_index < texture_count; array_index++)
  504.          if (textures[array_index].texture != NULL)
  505.             textures[array_index].texture->Release ();
  506.       SAFE_free ((void **) &textures);
  507.    }
  508.    texture_count = 0;
  509.  
  510.    // close and release materials data
  511.    SAFE_free ((void **) &materials);
  512.    material_count = 0;
  513.  
  514.    // close and release the 3D device
  515.    if (d3ddev != NULL)
  516.       d3ddev->Release ();
  517.    d3ddev = NULL;
  518.  
  519.    // close and release Direct3D
  520.    if (d3d != NULL)
  521.       d3d->Release ();
  522.    d3d = NULL;
  523.  
  524.    return; // finished
  525. }
  526.  
  527.  
  528. void Render_RenderFrame (scene_t *scene)
  529. {
  530.    // this is the function used to render a single frame
  531.  
  532.    static int framerate_value = 0;
  533.    static int framerate_count = 0;
  534.    static float framerate_time = 0;
  535.  
  536.    D3DXMATRIX scaling_matrix;
  537.    D3DXMATRIX translation_matrix;
  538.    D3DXMATRIX view_matrix; // the view transform matrix
  539.    D3DXMATRIX projection_matrix; // the projection transform matrix
  540.    D3DLIGHT9 dxlight;
  541.    RECT rect;
  542.    float angle;
  543.    float sin_pitch;
  544.    float sin_yaw;
  545.    float cos_pitch;
  546.    float cos_yaw;
  547.    int light_index;
  548.    int object_index;
  549.    int cchistory_index;
  550.    int cchistory_index2;
  551.    float combinedwidth_percent;
  552.    float combinedheight_percent;
  553.    light_t *light;
  554.    ccreply_t *ccreply;
  555.    sceneobject_t *sceneobject;
  556.    reflectedobject_t *reflectedobjects; // mallocated
  557.    int reflectedobject_count;
  558.    reflectedobject_t *otherobjects; // mallocated
  559.    int otherobject_count;
  560.  
  561.    if (terminate_everything)
  562.       return; // consistency check
  563.  
  564.    // get the device view port and save the actual width and height
  565.    GetClientRect (hMainWnd, &rect);
  566.    current_width = (float) rect.right; // they may differ from window width and window height
  567.    current_height = (float) rect.bottom; // because of title bars, menus, borders, etc.
  568.  
  569.    // clear the back buffer, the Z buffer and the stencil buffer
  570.    d3ddev->Clear (0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL, D3DCOLOR_XRGB (0, 0, 0), 1.0f, 0);
  571.    d3ddev->BeginScene (); // begins the 3D scene
  572.  
  573.    ////////////////////////////////////////
  574.    // Setup scene lights
  575.  
  576.    // There are three types of light : ambient, diffuse and specular.
  577.    // Diffuse lights can be of type directional (sun), point (bulb) or spot (flashlight).
  578.  
  579.    // The attenuation formula for point lights is :
  580.    // Atten = 1 / (att0 + (att1 * d) + (att2 * d²))
  581.  
  582.    // In spot lights, Phi is the outer cone angle. Theta is the inner cone angle.
  583.  
  584.    // set the default lighting color
  585.    ambient_light = RGBACOLOR_TO_ARGBCOLOR (RGBACOLOR_FULLALPHA (theme->illum.ambient_light));
  586.    d3ddev->SetRenderState (D3DRS_AMBIENT, ambient_light);
  587.  
  588.    // for each light...
  589.    for (light_index = 0; light_index < theme->illum.light_count; light_index++)
  590.    {
  591.       light = &theme->illum.lights[light_index]; // quick access to light
  592.  
  593.       memset (&dxlight, 0, sizeof (dxlight)); // clear out the dxlight struct for use
  594.  
  595.       // set its type
  596.       if (light->type == LIGHT_DIRECTIONAL)
  597.          dxlight.Type = D3DLIGHT_DIRECTIONAL; // directional light (e.g, sun)
  598.       else if (light->type == LIGHT_POINT)
  599.          dxlight.Type = D3DLIGHT_POINT; // point light (e.g, light bulb)
  600.       else if (light->type == LIGHT_SPOT)
  601.          dxlight.Type = D3DLIGHT_SPOT; // spot light (e.g, flash light)
  602.       else
  603.       {
  604.          d3ddev->LightEnable (light_index, false); // unknown light ; turn off light #index
  605.          continue; // and proceed to the next one
  606.       }
  607.  
  608.       // set its parameters
  609.       dxlight.Diffuse = D3DXCOLOR (RGBACOLOR_TO_ARGBCOLOR (RGBACOLOR_FULLALPHA (light->color)));
  610.       dxlight.Specular = D3DXCOLOR (0xffffffff);
  611.       dxlight.Position.x = light->pos_x;
  612.       dxlight.Position.y = light->pos_y;
  613.       dxlight.Position.z = light->pos_z;
  614.       dxlight.Direction.x = light->direction_x;
  615.       dxlight.Direction.y = light->direction_y;
  616.       dxlight.Direction.z = light->direction_z;
  617.       dxlight.Range = light->range; // light won't be computed after this distance
  618.       dxlight.Attenuation0 = light->attenuation_constant; // constant attenuation, see formula
  619.       dxlight.Attenuation1 = light->attenuation_proportional; // proportional attenuation, see formula
  620.       dxlight.Attenuation2 = light->attenuation_square; // square attenuation, see formula
  621.       dxlight.Phi = light->cone_outer * TO_RADIANS; // outer spot cone
  622.       dxlight.Theta = light->cone_inner * TO_RADIANS; // inner spot cone
  623.  
  624.       d3ddev->SetLight (light_index, &dxlight); // send the light struct properties to light #index
  625.       d3ddev->LightEnable (light_index, true); // turn on light #index
  626.    }
  627.  
  628.    ////////////////////////////////
  629.    // View transform
  630.  
  631.    // update the point looked at
  632.    scene_lookatpoint.x = lookatpoint_x;
  633.    scene_lookatpoint.y = lookatpoint_y;
  634.  
  635.    // compute the sine and cosine of the pitch component
  636.    angle = current_pitch * TO_RADIANS;
  637.    sin_pitch = sinf (angle);
  638.    cos_pitch = cosf (angle);
  639.  
  640.    // compute the sine and cosine of the yaw component
  641.    angle = current_yaw * TO_RADIANS;
  642.    sin_yaw = sinf (angle);
  643.    cos_yaw = cosf (angle);
  644.  
  645.    // build the camera position
  646.    camera_position.x = scene_lookatpoint.x + (float) -(cos_pitch * cos_yaw) * current_distance;
  647.    camera_position.y = scene_lookatpoint.y + (float) -(cos_pitch * sin_yaw) * current_distance;
  648.    camera_position.z = (float) sin_pitch * current_distance;
  649.  
  650.    // set up a view matrix
  651.    D3DXMatrixLookAtLH (&view_matrix,
  652.                        (D3DXVECTOR3 *) &camera_position, // camera position
  653.                        (D3DXVECTOR3 *) &scene_lookatpoint, // look-at position
  654.                        (D3DXVECTOR3 *) &upwards_direction); // up direction
  655.  
  656.    // tell Direct3D about our matrix
  657.    d3ddev->SetTransform (D3DTS_VIEW, &view_matrix);
  658.  
  659.    /////////////////////////////////////
  660.    // Projection transform
  661.  
  662.    // set up a projection matrix
  663.    D3DXMatrixPerspectiveFovLH (&projection_matrix,
  664.                                fov_value * TO_RADIANS, // field of view width
  665.                                current_width / current_height, // aspect ratio
  666.                                viewdist_near, viewdist_far); // view plane distances
  667.  
  668.    // tell Direct3D about our matrix
  669.    d3ddev->SetTransform (D3DTS_PROJECTION, &projection_matrix);
  670.  
  671.    /////////////////////////////////////
  672.    // End of the transforms
  673.  
  674.    // if we want it, enable specular lighting
  675.    d3ddev->SetRenderState (D3DRS_SPECULARENABLE, options.want_specularlighting);
  676.  
  677.    // turn on texture filtering if needed
  678.    if (options.want_filtering)
  679.    {
  680.       d3ddev->SetSamplerState (0, D3DSAMP_MINFILTER, best_supported_filter);
  681.       d3ddev->SetSamplerState (0, D3DSAMP_MAGFILTER, best_supported_filter);
  682.       d3ddev->SetSamplerState (0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
  683.  
  684.       // turn on fullscene antialiasing only if capable
  685.       d3ddev->SetRenderState (D3DRS_MULTISAMPLEANTIALIAS, is_fsaa_supported);
  686.    }
  687.    else
  688.    {
  689.       d3ddev->SetSamplerState (0, D3DSAMP_MINFILTER, D3DTEXF_NONE);
  690.       d3ddev->SetSamplerState (0, D3DSAMP_MAGFILTER, D3DTEXF_NONE);
  691.       d3ddev->SetSamplerState (0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
  692.  
  693.       // turn off fullscene antialiasing
  694.       d3ddev->SetRenderState (D3DRS_MULTISAMPLEANTIALIAS, false);
  695.    }
  696.  
  697.    /////////////////////////////////////////////////////////////
  698.    // draw the background elements. No need for a Z buffer here.
  699.  
  700.    d3ddev->SetRenderState (D3DRS_ZENABLE, false); // disable depth testing
  701.  
  702.    // draw the background sprite, if any
  703.    if (scene->background_spriteindex >= 0)
  704.       Render_DrawSprite (&sprites[scene->background_spriteindex], 0.0f, 0.0f, 100.0f, 100.0f, 0xFF);
  705.  
  706.    // draw the table border
  707.    Render_DrawSceneObject (&scene->objects[0]);
  708.    Render_DrawSceneObject (&scene->objects[1]);
  709.  
  710.    // draw the table and build the stencil buffer at the same time
  711.    d3ddev->SetRenderState (D3DRS_STENCILENABLE, true); // enable the stencil buffer (i.e. the "frame" for drawing table reflections)
  712.    d3ddev->SetRenderState (D3DRS_STENCILFUNC, D3DCMP_ALWAYS); // instruct how to fill it
  713.    d3ddev->SetRenderState (D3DRS_STENCILPASS, D3DSTENCILOP_INCRSAT); // instruct how to fill it
  714.    Render_DrawSceneObject (&scene->objects[2]); // draw the table squares in the stencil buffer
  715.    d3ddev->SetRenderState (D3DRS_STENCILENABLE, false); // finished drawing the stencil buffer
  716.  
  717.    d3ddev->SetRenderState (D3DRS_ZENABLE, true); // re-enable depth testing
  718.  
  719.    ////////////////////////////////////////////////////////////
  720.    // draw the scene objects and their reflections on the table
  721.  
  722.    // start with the reflections if we want them, and if the table does it
  723.    if (options.want_reflections && (theme->reflection_alpha > 0))
  724.    {
  725.       // build an array of reflected objects with their distances
  726.       reflectedobjects = NULL;
  727.       reflectedobject_count = 0;
  728.       otherobjects = NULL;
  729.       otherobject_count = 0;
  730.  
  731.       // cycle through all parts and see which ones need to be reflected
  732.       for (object_index = 3; object_index < scene->object_count; object_index++)
  733.       {
  734.          sceneobject = &scene->objects[object_index]; // quick access to scene object
  735.  
  736.          // is this object a mesh AND it's above the ground ?
  737.          if ((sceneobject->mesh_index != -1) && (sceneobject->z > 0))
  738.          {
  739.             // yes it is. It thus needs to be reflected, so add it to the list
  740.             reflectedobjects = (reflectedobject_t *) SAFE_realloc (reflectedobjects, reflectedobject_count, reflectedobject_count + 1, sizeof (reflectedobject_t), false);
  741.             reflectedobjects[reflectedobject_count].object = sceneobject; // save scene object
  742.             reflectedobjects[reflectedobject_count].distance = DistanceToCamera (sceneobject->x, sceneobject->y, sceneobject->z);
  743.             reflectedobject_count++; // we have now one object more to reflect
  744.          }
  745.          else
  746.          {
  747.             // no it's not. It doesn't need to be reflected, so add it to the other list
  748.             otherobjects = (reflectedobject_t *) SAFE_realloc (otherobjects, otherobject_count, otherobject_count + 1, sizeof (reflectedobject_t), false);
  749.             otherobjects[otherobject_count].object = sceneobject; // save scene object
  750.             otherobjects[otherobject_count].distance = 0;
  751.             otherobject_count++; // we have now one object more to reflect
  752.          }
  753.       }
  754.  
  755.       // now sort them from farthest to closest and draw them in this order
  756.       qsort (reflectedobjects, reflectedobject_count, sizeof (reflectedobject_t), SortReflectedObjects);
  757.       for (object_index = 0; object_index < reflectedobject_count; object_index++)
  758.          Render_DrawSceneObjectReflection (reflectedobjects[object_index].object); // draw the reflection
  759.       for (object_index = 0; object_index < reflectedobject_count; object_index++)
  760.          Render_DrawSceneObject (reflectedobjects[object_index].object); // and draw the objects afterwards
  761.       for (object_index = 0; object_index < otherobject_count; object_index++)
  762.          Render_DrawSceneObject (otherobjects[object_index].object); // finally, draw the non-reflected objects
  763.  
  764.       SAFE_free ((void **) &reflectedobjects); // and free the reflected objects array
  765.       SAFE_free ((void **) &otherobjects); // and the non-reflected objects array
  766.    }
  767.    else
  768.       for (object_index = 3; object_index < scene->object_count; object_index++)
  769.          Render_DrawSceneObject (&scene->objects[object_index]); // else if no reflections, draw the objects, the Z-buffer will sort them
  770.  
  771.    // draw the overlay texture if required
  772.    if (scene->overlay_spriteindex >= 0)
  773.       Render_DrawSprite (&sprites[scene->overlay_spriteindex], 0.0f, 0.0f, 100.0f, 100.0f, 0x4F);
  774.  
  775.    ///////////////
  776.    // draw the GUI
  777.  
  778.    DRAW_BUTTON_IF_NEEDED (scene->gui.newgamebutton); // new game
  779.    DRAW_BUTTON_IF_NEEDED (scene->gui.opengamebutton); // open game
  780.  
  781.    // draw the arrows
  782.    DRAW_BUTTON_IF_NEEDED (scene->gui.larrow); // left arrow
  783.    DRAW_BUTTON_IF_NEEDED (scene->gui.rarrow); // right arrow
  784.    DRAW_TEXT_IF_NEEDED (scene->gui.arrow_text); // arrow text
  785.  
  786.    if (want_framerate)
  787.       Render_wprintf (99.0f, 1.0f, 0.0f, ALIGN_RIGHT, ALIGN_TOP, ALIGN_CENTER, arrow_fontindex, D3DCOLOR_RGBA (255, 255, 255, 255), NULL,
  788.                       L"%d textures\n"
  789.                       L"%d meshes\n"
  790.                       L"%d fonts\n"
  791.                       L"%d sprites\n"
  792.                       L"%d fps", texture_count, mesh_count, font_count, sprite_count, framerate_value);
  793.  
  794.    // draw the other GUI buttons
  795.    DRAW_BUTTON_IF_NEEDED (scene->gui.chatbutton); // chat button
  796.    DRAW_BUTTON_IF_NEEDED (scene->gui.gamesbutton); // games button
  797.    DRAW_BUTTON_IF_NEEDED (scene->gui.peoplebutton); // people button
  798.  
  799.    // does the parts pick line need to be displayed ?
  800.    if (scene->gui.is_partspick_displayed)
  801.    {
  802. #define PARTSIZE_PCT (100.0f / 13.0f)
  803.  
  804.       if (scene->gui.partspick_selectedpart == 'P')      Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  0.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  805.       else if (scene->gui.partspick_selectedpart == 'R') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  1.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  806.       else if (scene->gui.partspick_selectedpart == 'N') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  2.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  807.       else if (scene->gui.partspick_selectedpart == 'B') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  3.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  808.       else if (scene->gui.partspick_selectedpart == 'Q') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  4.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  809.       else if (scene->gui.partspick_selectedpart == 'K') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  5.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  810.       else if (scene->gui.partspick_selectedpart == ' ') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  6.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  811.       else if (scene->gui.partspick_selectedpart == 'k') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  7.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  812.       else if (scene->gui.partspick_selectedpart == 'q') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  8.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  813.       else if (scene->gui.partspick_selectedpart == 'b') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  9.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  814.       else if (scene->gui.partspick_selectedpart == 'n') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex], 10.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  815.       else if (scene->gui.partspick_selectedpart == 'r') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex], 11.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  816.       else if (scene->gui.partspick_selectedpart == 'p') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex], 12.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  817.  
  818.       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
  819.       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
  820.       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
  821.       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
  822.       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
  823.       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
  824.       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
  825.       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
  826.       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
  827.       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
  828.       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
  829.       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
  830.       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
  831.  
  832. #undef PARTSIZE_PCT
  833.    }
  834.  
  835.    // draw GUI texts
  836.    DRAW_TEXT_IF_NEEDED (scene->gui.comment_text); // move comments
  837.    DRAW_TEXT_IF_NEEDED (scene->gui.history_text); // game history
  838.    DRAW_TEXT_IF_NEEDED (scene->gui.clock_text); // game clock
  839.  
  840.    // draw the chatter channels text
  841.    Render_GetTextBoundaries (-1, chat_fontindex, L"a", &rect);
  842.    combinedheight_percent = (float) (rect.bottom * 100 / initial_height); // get a string's height
  843.  
  844.    // cycle through all the chat strings...
  845.    ccreply = NULL;
  846.    for (cchistory_index = 0; cchistory_index < scene->gui.cchistory_count; cchistory_index++)
  847.    {
  848.       ccreply = &scene->gui.cchistory[cchistory_index]; // quick access to CC reply
  849.       if ((ccreply->text[0] != 0) && (ccreply->arrival_time + 60.0f > current_time))
  850.          break; // break at the first one that we should display
  851.    }
  852.  
  853.    // have we some to display ?
  854.    if (cchistory_index < scene->gui.cchistory_count)
  855.    {
  856.       // first, get the remaining text's combined height
  857.       for (cchistory_index2 = cchistory_index; cchistory_index2 < scene->gui.cchistory_count; cchistory_index2++)
  858.       {
  859.          ccreply = &scene->gui.cchistory[cchistory_index2]; // quick access to CC reply
  860.  
  861.          combinedwidth_percent = 1.0f;
  862.          Render_GetTextBoundaries (100 - combinedwidth_percent, chat_fontindex, L"[] : ", &rect);
  863.          combinedwidth_percent += (float) (rect.right * 100 / initial_width);
  864.          Render_GetTextBoundaries (100 - combinedwidth_percent, chat_fontindex, ccreply->channelname, &rect);
  865.          combinedwidth_percent += (float) (rect.right * 100 / initial_width);
  866.          Render_GetTextBoundaries (100 - combinedwidth_percent, chat_fontindex, ccreply->nickname, &rect);
  867.          combinedwidth_percent += (float) (rect.right * 100 / initial_width);
  868.          Render_GetTextBoundaries (100 - combinedwidth_percent, chat_fontindex, ccreply->text, &rect);
  869.          combinedheight_percent += (float) (rect.bottom * 100 / initial_height); // add this string's height
  870.       }
  871.  
  872.       // now for each string remaining...
  873.       for (; cchistory_index < scene->gui.cchistory_count; cchistory_index++)
  874.       {
  875.          ccreply = &scene->gui.cchistory[cchistory_index]; // quick access to CC reply
  876.          rect.right = 10;
  877.          PRINT_CCREPLY (ccreply); // print CC reply on screen
  878.          combinedheight_percent -= (float) ((rect.bottom - rect.top) * 100 / initial_height); // draw it from top of zone to bottom
  879.       }
  880.    }
  881.  
  882.    // are we online ?
  883.    if (Player_FindByType (PLAYER_INTERNET) != NULL)
  884.    {
  885.       ccreply = &scene->gui.entered_ccreply;
  886.       if (!scene->gui.is_entering_text)
  887.          ccreply->color = RGBACOLOR_SETALPHA (ccreply->color, RGBACOLOR_ALPHA (ccreply->color) / 6); // if there's no text being entered, fade CC reply a lot
  888.  
  889.       rect.right = 10;
  890.       PRINT_CCREPLY (ccreply); // print CC reply on screen
  891.    }
  892.  
  893.    // print GUI texts
  894.    DRAW_TEXT_IF_NEEDED (scene->gui.turn_text); // player turn's text
  895.    DRAW_TEXT_IF_NEEDED (scene->gui.central_text); // central notification zone text
  896.  
  897.    // if needed, print the spinning wheel
  898.    if (scene->gui.want_spinwheel)
  899.       Render_DrawSprite (&sprites[spinner_spriteindex[(int) (10.0f * current_time) % 12]], 47.0f, 46.0f, 6.0f, 8.0f, 255);
  900.  
  901.    // are we in demo mode ? if so, display the program name as a watermark
  902.    if (!is_registered)
  903.       Render_wprintf (50.0f, 60.0f, 0.0f, ALIGN_CENTER, ALIGN_CENTER, ALIGN_CENTER, chat_fontindex,
  904.                       D3DCOLOR_RGBA (255, 255, 255, 255),
  905.                       NULL, PROGRAM_NAME L"%s - " PROGRAM_URL L"\n- %d:%02d -", LOCALIZE (L"EvaluationMode"), (int) (DEMO_TIMEOUT - current_time) / 60, (int) (DEMO_TIMEOUT - current_time) % 60);
  906.  
  907.    // end 3D rendering on the back buffer
  908.    //////////////////////////////////////
  909.  
  910.    d3ddev->EndScene (); // ends the 3D scene
  911.    d3ddev->Present (NULL, NULL, NULL, NULL); // displays the created frame on the screen
  912.  
  913.    // update the frame rate
  914.    if (framerate_time < current_time)
  915.    {
  916.       framerate_value = framerate_count;
  917.       framerate_count = 0;
  918.       framerate_time = current_time + 1.0f;
  919.    }
  920.    framerate_count++; // one frame more elapsed
  921.  
  922.    return; // finished
  923. }
  924.  
  925.  
  926. int Render_LoadMesh (const wchar_t *fmt, ...)
  927. {
  928.    // this function appends a new mesh in the global meshes buffer and returns its index
  929.  
  930.    static wchar_t meshfile_pathname[MAX_PATH];
  931.    unsigned long hash;
  932.    mesh_t *mesh;
  933.    int mesh_index;
  934.    va_list argptr;
  935.  
  936.    // concatenate all the arguments in one string
  937.    va_start (argptr, fmt);
  938.    wvsprintf (meshfile_pathname, fmt, argptr);
  939.    va_end (argptr);
  940.  
  941.    // resolve wildcards and get content hash
  942.    ResolveWildcard (meshfile_pathname, L".obj");
  943.    hash = HashFile (meshfile_pathname);
  944.    
  945.    // now cycle through all our loaded meshes and see if it's already loaded
  946.    for (mesh_index = 0; mesh_index < mesh_count; mesh_index++)
  947.       if (meshes[mesh_index].hash == hash)
  948.          return (mesh_index); // if we can find it, return its index so as not to load it twice
  949.  
  950.    // reallocate space to hold one mesh more
  951.    meshes = (mesh_t *) SAFE_realloc (meshes, mesh_count, mesh_count + 1, sizeof (mesh_t), false);
  952.    mesh = &meshes[mesh_count]; // quick access to the mesh we'll be working on
  953.  
  954.    // load the mesh
  955.    if (!Render_LoadMesh_Obj (mesh, meshfile_pathname))
  956.       return (-1); // bomb out on error
  957.  
  958.    mesh->hash = hash; // save the hash
  959.    mesh_count++; // we know now one mesh more
  960.    return (mesh_count - 1); // return its index
  961. }
  962.  
  963.  
  964. int Render_LoadTexture (const wchar_t *fmt, ...)
  965. {
  966.    // this function appends a new texture in the global textures buffer and returns its index
  967.  
  968.    D3DSURFACE_DESC texture_description;
  969.    wchar_t texturefile_pathname[MAX_PATH];
  970.    static wchar_t *filename;
  971.    unsigned long hash;
  972.    int texture_index;
  973.    va_list argptr;
  974.  
  975.    // concatenate all the arguments in one string
  976.    va_start (argptr, fmt);
  977.    wvsprintf (texturefile_pathname, fmt, argptr);
  978.    va_end (argptr);
  979.  
  980.    // resolve wildcards and get content hash
  981.    ResolveWildcard (texturefile_pathname, L".dds|.jpg|.jpeg|.png|.tga|.bmp");
  982.    hash = HashFile (texturefile_pathname);
  983.  
  984.    // now cycle through all our loaded textures and see if it's already loaded
  985.    for (texture_index = 0; texture_index < texture_count; texture_index++)
  986.       if (textures[texture_index].hash == hash)
  987.          return (texture_index); // if we can find it, return its index so as not to load it twice
  988.  
  989.    // reallocate space to hold one texture more
  990.    textures = (texture_t *) SAFE_realloc (textures, texture_count, texture_count + 1, sizeof (texture_t), false);
  991.  
  992.    // ask Direct3D to prepare texture data
  993.    if (FAILED (D3DXCreateTextureFromFile (d3ddev, texturefile_pathname, &textures[texture_count].texture)))
  994.    {
  995.       MessageBox (NULL, LOCALIZE (L"Error_UnableToAddTextureD3DXCreateTextureFromFileFailed"), LOCALIZE (L"FatalError"), MB_ICONERROR | MB_OK);
  996.       terminate_everything = true; // this is a fatal error
  997.       return (-1); // bomb out on error
  998.    }
  999.  
  1000.    // get info on the newly loaded texture such as size etc.
  1001.    textures[texture_count].texture->GetLevelDesc (0, &texture_description);
  1002.    textures[texture_count].width = texture_description.Width; // save texture width (as loaded)
  1003.    textures[texture_count].height = texture_description.Height; // save texture height (as loaded)
  1004.    textures[texture_count].hash = hash; // save its hash
  1005.    texture_count++; // we know now one texture more
  1006.    return (texture_count - 1); // return its index
  1007. }
  1008.  
  1009.  
  1010. int Render_LoadFont (const wchar_t *font_name, int font_size, bool is_bold, bool is_italic)
  1011. {
  1012.    // this function appends a new font in the global fonts buffer and returns its index
  1013.  
  1014.    unsigned long pathname_hash;
  1015.    int font_index;
  1016.  
  1017.    // first, get the hash of the requested pathname (include font size and weight parameters)
  1018.    pathname_hash = HashString (font_name);
  1019.    pathname_hash += 3 * (unsigned long) font_size + 2 * (unsigned long) is_bold + (unsigned long) is_italic;
  1020.  
  1021.    // now cycle through all our loaded fonts and see if it's already loaded
  1022.    for (font_index = 0; font_index < font_count; font_index++)
  1023.       if (fonts[font_index].pathname_hash == pathname_hash)
  1024.          return (font_index); // if we can find it, return its index so as not to load it twice
  1025.  
  1026.    // reallocate space to hold one font more
  1027.    fonts = (font_t *) SAFE_realloc (fonts, font_count, font_count + 1, sizeof (font_t), false);
  1028.  
  1029.    // create a Direct3D font object and record font data
  1030.    if (FAILED (D3DXCreateFont (d3ddev, font_size, // font height
  1031.                                2 * font_size / 5, // font width
  1032.                                (is_bold ? FW_BOLD : FW_NORMAL), // font weight (bold, etc)
  1033.                                0, // miplevels
  1034.                                is_italic, // is italic
  1035.                                DEFAULT_CHARSET, // charset
  1036.                                OUT_DEFAULT_PRECIS, // precision
  1037.                                CLEARTYPE_QUALITY, // font quality (antialiased or not)
  1038.                                DEFAULT_PITCH | FF_DONTCARE, // font family
  1039.                                font_name, // font name
  1040.                                &fonts[font_count].font))) // and a pointer that will receive the font
  1041.    {
  1042.       MessageBox (NULL, LOCALIZE (L"Error_UnableToAddFontD3DXCreateFontFailed"), LOCALIZE (L"FatalError"), MB_ICONERROR | MB_OK);
  1043.       terminate_everything = true; // this is a fatal error
  1044.       return (-1); // bomb out on error
  1045.    }
  1046.  
  1047.    fonts[font_count].pathname_hash = pathname_hash; // save its hash
  1048.    font_count++; // we know now one font more
  1049.    return (font_count - 1); // return its index
  1050. }
  1051.  
  1052.  
  1053. int Render_LoadSprite (const wchar_t *fmt, ...)
  1054. {
  1055.    // this function appends a new sprite in the global sprites buffer and returns its index
  1056.  
  1057.    wchar_t spritefile_pathname[MAX_PATH];
  1058.    unsigned long hash;
  1059.    int sprite_index;
  1060.    va_list argptr;
  1061.  
  1062.    // concatenate all the arguments in one string
  1063.    va_start (argptr, fmt);
  1064.    wvsprintf (spritefile_pathname, fmt, argptr);
  1065.    va_end (argptr);
  1066.  
  1067.    // resolve wildcards and get content hash
  1068.    ResolveWildcard (spritefile_pathname, L".dds|.jpg|.jpeg|.png|.tga|.bmp");
  1069.    hash = HashFile (spritefile_pathname);
  1070.  
  1071.    // now cycle through all our loaded sprites and see if it's already loaded
  1072.    for (sprite_index = 0; sprite_index < sprite_count; sprite_index++)
  1073.       if (sprites[sprite_index].hash == hash)
  1074.          return (sprite_index); // if we can find it, return its index so as not to load it twice
  1075.  
  1076.    // reallocate space to hold one sprite more
  1077.    sprites = (sprite_t *) SAFE_realloc (sprites, sprite_count, sprite_count + 1, sizeof (sprite_t), false);
  1078.  
  1079.    // ask Direct3D to prepare texture data
  1080.    if (FAILED (D3DXCreateSprite (d3ddev, &sprites[sprite_count].sprite)))
  1081.    {
  1082.       MessageBox (NULL, LOCALIZE (L"Error_UnableToAddSpriteD3DXCreateSpriteFailed"), LOCALIZE (L"FatalError"), MB_ICONERROR | MB_OK);
  1083.       terminate_everything = true; // this is a fatal error
  1084.       return (-1); // bomb out on error
  1085.    }
  1086.    sprites[sprite_count].texture_index = Render_LoadTexture (spritefile_pathname); // register and save sprite texture
  1087.    sprites[sprite_count].hash = hash; // save its hash
  1088.  
  1089.    sprite_count++; // we know now one sprite more
  1090.    return (sprite_count - 1); // return its index
  1091. }
  1092.  
  1093.  
  1094. int Render_MaterialIndexOf (const wchar_t *material_name)
  1095. {
  1096.    // this function returns the index of the material in the global materials array which has the specified name
  1097.  
  1098.    int material_index;
  1099.  
  1100.    // cycle through all materials and look whether one with the specified name exists
  1101.    for (material_index = 0; material_index < material_count; material_index++)
  1102.       if (_wcsicmp (materials[material_index].name, material_name) == 0)
  1103.          return (material_index); // if we find one, return its index
  1104.  
  1105.    return (material_count - 1); // else return the index of the last material in list, which is the default material
  1106. }
  1107.  
  1108.  
  1109. void Render_MouseToFloor (short mouse_x, short mouse_y, float *floor_x, float *floor_y)
  1110. {
  1111.    // this function converts a mouse coordinates into floor coordinates by doing vector
  1112.    // projection on the floor plane from the eyepoint of the camera
  1113.  
  1114.    static D3DXPLANE floor_plane;
  1115.    static bool is_planefound = false;
  1116.  
  1117.    D3DXMATRIX projection_matrix;
  1118.    D3DXMATRIX view_matrix;
  1119.    D3DXMATRIX invertedview_matrix;
  1120.    float mouse_pitch;
  1121.    float mouse_yaw;
  1122.    vector_t v_lookat;
  1123.    vector_t v_intersection;
  1124.  
  1125.    // find the floor plane (only do it once)
  1126.    if (!is_planefound)
  1127.    {
  1128.       D3DXPlaneFromPointNormal (&floor_plane, (D3DXVECTOR3 *) &scene_lookatpoint, (D3DXVECTOR3 *) &upwards_direction);
  1129.       is_planefound = true; // once and for all, as this plane will never change
  1130.    }
  1131.  
  1132.    // get the current projection and view matrices, and invert the view matrix
  1133.    d3ddev->GetTransform (D3DTS_PROJECTION, &projection_matrix);
  1134.    d3ddev->GetTransform (D3DTS_VIEW, &view_matrix);
  1135.    D3DXMatrixInverse (&invertedview_matrix, NULL, &view_matrix);
  1136.  
  1137.    // convert the mouse coordinates to relative pitch and yaw
  1138.    mouse_pitch =  (((mouse_x * 2.0f) / current_width) - 1) / projection_matrix._11;
  1139.    mouse_yaw = -(((mouse_y * 2.0f) / current_height) - 1) / projection_matrix._22;
  1140.  
  1141.    // now build a matrix that will describe the mouse direction vector, add it to the camera position, and make it 200 times longer
  1142.    v_lookat.x = camera_position.x + (mouse_pitch * invertedview_matrix._11 + mouse_yaw * invertedview_matrix._21 + invertedview_matrix._31) * 200.0f;
  1143.    v_lookat.y = camera_position.y + (mouse_pitch * invertedview_matrix._12 + mouse_yaw * invertedview_matrix._22 + invertedview_matrix._32) * 200.0f;
  1144.    v_lookat.z = camera_position.z + (mouse_pitch * invertedview_matrix._13 + mouse_yaw * invertedview_matrix._23 + invertedview_matrix._33) * 200.0f;
  1145.  
  1146.    // and the intersection point with our ray
  1147.    D3DXPlaneIntersectLine ((D3DXVECTOR3 *) &v_intersection, &floor_plane, (D3DXVECTOR3 *) &camera_position, (D3DXVECTOR3 *) &v_lookat);
  1148.  
  1149.    // now fill the return values
  1150.    *floor_x = v_intersection.x;
  1151.    *floor_y = v_intersection.y;
  1152.  
  1153.    return; // finished
  1154. }
  1155.  
  1156.  
  1157. bool Render_IsMouseInBox (short mouse_x, short mouse_y, float x_percent, float y_percent, float width_percent, float height_percent)
  1158. {
  1159.    // helper function that returns whether the mouse coordinates are inside a given square
  1160.  
  1161.    float mousex_percent;
  1162.    float mousey_percent;
  1163.  
  1164.    // compute mouse coordinates in percents
  1165.    mousex_percent = (float) mouse_x * 100.0f / current_width;
  1166.    mousey_percent = (float) mouse_y * 100.0f / current_height;
  1167.  
  1168.    return ((mousex_percent >= x_percent) && (mousex_percent <= x_percent + width_percent)
  1169.            && (mousey_percent >= y_percent) && (mousey_percent <= y_percent + height_percent));
  1170. }
  1171.  
  1172.  
  1173. static bool Render_LoadMesh_Obj (mesh_t *mesh, const wchar_t *objfile_pathname)
  1174. {
  1175.    // this function loads a mesh from a Wavefront Object file (.obj)
  1176.  
  1177.    #define OBJ_INCREASE_OR_RESIZE(count,maxcount,increment,arrayptr,type,erase) { \
  1178.       (count)++; \
  1179.       if ((count) == (maxcount)) \
  1180.       { \
  1181.          (arrayptr) = (type *) SAFE_realloc ((arrayptr), (maxcount), (maxcount) + (increment), sizeof (type), erase); \
  1182.          (maxcount) += (increment); \
  1183.       } \
  1184.    }
  1185.    #define OBJ_CONVERT_INDEX(element,current_element_count) if ((element) < 0) (element) = (current_element_count) + (element); else (element)--;
  1186.    #define OBJ_GET_EXISTING_INDEX_OR_APPEND_VERTEX(uniquevertex) \
  1187.    { \
  1188.       hash = &hashtable[*((unsigned long *) &obj.vs[(uniquevertex).iv].x) & 0xFF]; \
  1189.       for (vertex_index = 0; vertex_index < hash->count; vertex_index++) \
  1190.          if ((memcmp (&vertices[hash->indices[vertex_index]].position, &obj.vs[(uniquevertex).iv], sizeof (vector_t)) == 0) \
  1191.              && (memcmp (&vertices[hash->indices[vertex_index]].normal, &obj.ns[(uniquevertex).in], sizeof (vector_t)) == 0) \
  1192.              && (memcmp (&vertices[hash->indices[vertex_index]].texcoord, &obj.tcs[(uniquevertex).itc], sizeof (texcoord_t)) == 0)) \
  1193.             break; \
  1194.       if (vertex_index == hash->count) \
  1195.       { \
  1196.          vertex_index = mesh->vertice_count; \
  1197.          current_vertex = &vertices[vertex_index]; \
  1198.          memset (current_vertex, 0, sizeof (vertex_t)); \
  1199.          memcpy (&current_vertex->position, &obj.vs[(uniquevertex).iv], sizeof (vector_t)); \
  1200.          if ((uniquevertex).in > -1) \
  1201.             memcpy (&current_vertex->normal, &obj.ns[(uniquevertex).in], sizeof (vector_t)); \
  1202.          if ((uniquevertex).itc > -1) \
  1203.             memcpy (&current_vertex->texcoord, &obj.tcs[(uniquevertex).itc], sizeof (texcoord_t)); \
  1204.          hash = &hashtable[*((unsigned long *) &current_vertex->normal.x) & 0xFF]; \
  1205.          hash->indices = (long *) SAFE_realloc (hash->indices, hash->count, hash->count + 1, sizeof (long), false); \
  1206.          hash->indices[hash->count] = vertex_index; \
  1207.          hash->count++; \
  1208.          mesh->vertice_count++; \
  1209.       } \
  1210.       else \
  1211.          vertex_index = hash->indices[vertex_index]; \
  1212.    }
  1213.  
  1214.    typedef struct obj_uniquevertex_s { long iv, in, itc; } obj_uniquevertex_t;
  1215.    typedef struct obj_face_s { obj_uniquevertex_t v1, v2, v3; } obj_face_t;
  1216.    typedef struct obj_hashbucket_s { int count; long *indices; /* mallocated */ } obj_hashbucket_t;
  1217.    typedef struct objfile_s
  1218.    {
  1219.       vector_t *vs; long v_count; long v_maxcount; // array mallocated to v_maxcount
  1220.       vector_t *ns; long n_count; long n_maxcount; // array mallocated to n_maxcount
  1221.       texcoord_t *tcs; long tc_count; long tc_maxcount; // array mallocated to tc_maxcount
  1222.       obj_face_t *fs; long f_count; long f_maxcount; // array mallocated to f_maxcount
  1223.    } objfile_t;
  1224.  
  1225.    static obj_hashbucket_t hashtable[256];
  1226.    objfile_t obj;
  1227.    obj_hashbucket_t *hash;
  1228.    obj_face_t *f;
  1229.    vertex_t *vertices; // mallocated
  1230.    unsigned long *indices; // mallocated
  1231.    vertex_t *current_vertex;
  1232.    unsigned long file_size;
  1233.    char *filedata; // mallocated
  1234.    char *fileptr;
  1235.    int vertex_index;
  1236.    int array_index;
  1237.    void *ptr_to;
  1238.    FILE *fp;
  1239.  
  1240.    // open the mesh file and read it as a whole
  1241.    _wfopen_s (&fp, objfile_pathname, L"rb");
  1242.    if (fp == NULL)
  1243.       return (false); // bomb out on error
  1244.    fseek (fp, 0, SEEK_END); // seek at end of file...
  1245.    file_size = ftell (fp); // ...read file length...
  1246.    fseek (fp, 0, SEEK_SET); // and rewind
  1247.    filedata = (char *) SAFE_malloc (file_size, sizeof (char), false); // mallocate space for data
  1248.    fread (filedata, file_size, 1, fp); // read file as a whole
  1249.    fclose (fp); // file is read, close it
  1250.  
  1251.    // allocate space for an arbitrary amount of vertices, texture coordinates, normals and faces
  1252.    memset (&obj, 0, sizeof (obj));
  1253.    obj.v_maxcount = 10000; obj.vs = (vector_t *) SAFE_malloc (obj.v_maxcount, sizeof (vector_t), false);
  1254.    obj.n_maxcount = 10000; obj.ns = (vector_t *) SAFE_malloc (obj.n_maxcount, sizeof (vector_t), false);
  1255.    obj.tc_maxcount = 10000; obj.tcs = (texcoord_t *) SAFE_malloc (obj.tc_maxcount, sizeof (texcoord_t), false);
  1256.    obj.f_maxcount = 5000; obj.fs = (obj_face_t *) SAFE_malloc (obj.f_maxcount, sizeof (obj_face_t), true); // zero out the faces array (IMPORTANT !)
  1257.  
  1258.    // read file line per line...
  1259.    fileptr = filedata - 1; // start parsing line after line
  1260.    while (fileptr != NULL)
  1261.    {
  1262.       fileptr++; // skip the line feed (or reach the first character, if it's the first pass)
  1263.  
  1264.       // is it a vertex-related line ?
  1265.       if (fileptr[0] == L'v')
  1266.       {
  1267.          // is it a vertex, a normal or a texture coordinate ?
  1268.          if ((fileptr[1] == L' ') && (sscanf_s (&fileptr[2], "%f %f %f", &obj.vs[obj.v_count].x, &obj.vs[obj.v_count].y, &obj.vs[obj.v_count].z) == 3))
  1269.             OBJ_INCREASE_OR_RESIZE (obj.v_count, obj.v_maxcount, 10000, obj.vs, vector_t, false) // one vertex more has been read
  1270.          else if ((fileptr[1] == L'n') && (sscanf_s (&fileptr[3], "%f %f %f", &obj.ns[obj.n_count].x, &obj.ns[obj.n_count].y, &obj.ns[obj.n_count].z) == 3))
  1271.             OBJ_INCREASE_OR_RESIZE (obj.n_count, obj.n_maxcount, 10000, obj.ns, vector_t, false) // one normal more has been read
  1272.          else if ((fileptr[1] == L't') && (sscanf_s (&fileptr[3], "%f %f", &obj.tcs[obj.tc_count].u, &obj.tcs[obj.tc_count].v) == 2))
  1273.             OBJ_INCREASE_OR_RESIZE (obj.tc_count, obj.tc_maxcount, 10000, obj.tcs, texcoord_t, false) // one texture coordinate more has been read
  1274.       }
  1275.  
  1276.       // else is it a face-related line ?
  1277.       else if (fileptr[0] == L'f')
  1278.       {
  1279.          // get a quick pointer to current face (note: it's been already blanked out by malloc())
  1280.          f = &obj.fs[obj.f_count];
  1281.  
  1282.          // is it a face with normals, a face without normals or a face without normals and texture coordinates ?
  1283.          if ((sscanf_s (&fileptr[2], "%d/%d/%d %d/%d/%d %d/%d/%d", &f->v1.iv, &f->v1.itc, &f->v1.in, &f->v2.iv, &f->v2.itc, &f->v2.in, &f->v3.iv, &f->v3.itc, &f->v3.in) == 9)
  1284.              || (sscanf_s (&fileptr[2], "%d/%d %d/%d %d/%d", &f->v3.iv, &f->v3.itc, &f->v2.iv, &f->v2.itc, &f->v3.iv, &f->v3.itc) == 6)
  1285.              || (sscanf_s (&fileptr[2], "%d %d %d", &f->v3.iv, &f->v2.iv, &f->v3.iv) == 6))
  1286.          {
  1287.             OBJ_CONVERT_INDEX (f->v1.iv, obj.v_count);
  1288.             OBJ_CONVERT_INDEX (f->v1.in, obj.n_count); // if no normal could be read, its index will be converted from 0 to -1
  1289.             OBJ_CONVERT_INDEX (f->v1.itc, obj.tc_count); // if no texcoord could be read, its index will be converted from 0 to -1
  1290.             OBJ_CONVERT_INDEX (f->v2.iv, obj.v_count);
  1291.             OBJ_CONVERT_INDEX (f->v2.in, obj.n_count); // if no normal could be read, its index will be converted from 0 to -1
  1292.             OBJ_CONVERT_INDEX (f->v2.itc, obj.tc_count); // if no texcoord could be read, its index will be converted from 0 to -1
  1293.             OBJ_CONVERT_INDEX (f->v3.iv, obj.v_count);
  1294.             OBJ_CONVERT_INDEX (f->v3.in, obj.n_count); // if no normal could be read, its index will be converted from 0 to -1
  1295.             OBJ_CONVERT_INDEX (f->v3.itc, obj.tc_count); // if no texcoord could be read, its index will be converted from 0 to -1
  1296.             OBJ_INCREASE_OR_RESIZE (obj.f_count, obj.f_maxcount, 5000, obj.fs, obj_face_t, true) // one face more has been read
  1297.          }
  1298.       }
  1299.  
  1300.       fileptr = strchr (fileptr, '\n'); // proceed to next line
  1301.    }
  1302.  
  1303.    // now build our final vertex and index list
  1304.    vertices = (vertex_t *) SAFE_malloc (3 * obj.f_count, sizeof (vertex_t), false); // mallocate for the max number of vertices we can have
  1305.    indices = (unsigned long *) SAFE_malloc (3 * obj.f_count, sizeof (unsigned long), false); // mallocate for the right amount of indices
  1306.  
  1307.    // t3h mighty l00p ^^ (builds vertex and index buffers)
  1308.    memset (hashtable, 0, sizeof (hashtable)); // wipe out the hashtable
  1309.    mesh->vertice_count = 0; // start with an unoptimized list
  1310.    for (array_index = 0; array_index < obj.f_count; array_index++)
  1311.    {
  1312.       f = &obj.fs[array_index]; // quick access to current face
  1313.       OBJ_GET_EXISTING_INDEX_OR_APPEND_VERTEX (f->v1);
  1314.       indices[3 * array_index + 0] = vertex_index;
  1315.       OBJ_GET_EXISTING_INDEX_OR_APPEND_VERTEX (f->v2);
  1316.       indices[3 * array_index + 1] = vertex_index;
  1317.       OBJ_GET_EXISTING_INDEX_OR_APPEND_VERTEX (f->v3);
  1318.       indices[3 * array_index + 2] = vertex_index;
  1319.    }
  1320.  
  1321.    // now create a correctly-sized DirectX vertex buffer and populate it
  1322.    mesh->vertex_format = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1;
  1323.    mesh->vertice_size = sizeof (vertex_t);
  1324.    d3ddev->CreateVertexBuffer (mesh->vertice_count * mesh->vertice_size, // length
  1325.                                D3DUSAGE_DYNAMIC, // usage
  1326.                                mesh->vertex_format, // vertex format
  1327.                                D3DPOOL_DEFAULT, // pool type
  1328.                                &mesh->d3dvertices, // pointer to the vertex buffer pointer
  1329.                                NULL); // shared handle
  1330.    mesh->d3dvertices->Lock (0, mesh->vertice_count * mesh->vertice_size, &ptr_to, D3DLOCK_DISCARD);
  1331.    memcpy (ptr_to, vertices, mesh->vertice_count * mesh->vertice_size);
  1332.    mesh->d3dvertices->Unlock ();
  1333.  
  1334.    // create a correctly-sized DirectX index buffer and populate it
  1335.    mesh->is_indexed = true; // remember that we're building an index buffer
  1336.    mesh->indice_count = obj.f_count * 3;
  1337.    mesh->indice_size = (mesh->indice_count <= (int) USHRT_MAX ? 2 : 4);
  1338.    d3ddev->CreateIndexBuffer (mesh->indice_count * mesh->indice_size, // length
  1339.                               D3DUSAGE_DYNAMIC, // usage
  1340.                               (mesh->indice_size == 2 ? D3DFMT_INDEX16 : D3DFMT_INDEX32), // format (here, 16 or 32-bit)
  1341.                               D3DPOOL_DEFAULT, // pool type
  1342.                               &mesh->d3dindices, // pointer to the index buffer pointer
  1343.                               NULL); // shared handle
  1344.    mesh->d3dindices->Lock (0, mesh->indice_count * mesh->indice_size, &ptr_to, D3DLOCK_DISCARD);
  1345.    if (mesh->indice_size == 2)
  1346.       for (array_index = 0; array_index < mesh->indice_count; array_index++)
  1347.          ((unsigned short *) ptr_to)[array_index] = (unsigned short) indices[array_index];
  1348.    else
  1349.       memcpy (ptr_to, indices, mesh->indice_count * mesh->indice_size);
  1350.    mesh->d3dindices->Unlock ();
  1351.  
  1352.    // finished, free the temporary objects
  1353.    for (array_index = 0; array_index < sizeof (hashtable) / sizeof (obj_hashbucket_t); array_index++)
  1354.       SAFE_free ((void **) &hashtable[array_index].indices);
  1355.    SAFE_free ((void **) &indices);
  1356.    SAFE_free ((void **) &vertices);
  1357.    SAFE_free ((void **) &obj.vs);
  1358.    SAFE_free ((void **) &obj.ns);
  1359.    SAFE_free ((void **) &obj.tcs);
  1360.    SAFE_free ((void **) &obj.fs);
  1361.    SAFE_free ((void **) &filedata);
  1362.  
  1363.    return (true); // Wavefront Object successfully loaded, return TRUE
  1364.  
  1365.    #undef OBJ_GET_EXISTING_INDEX_OR_APPEND_VERTEX
  1366.    #undef OBJ_CONVERT_INDEX
  1367.    #undef OBJ_INCREASE_OR_RESIZE
  1368. }
  1369.  
  1370.  
  1371. static void Render_DrawSceneObjectReflection (sceneobject_t *sceneobject)
  1372. {
  1373.    // fast helper to draw a mesh at a specified location with certain pitch and yaw angles
  1374.  
  1375.    D3DXMATRIX rotation_matrix;
  1376.    D3DXMATRIX translation_matrix;
  1377.    D3DXMATRIX reflect_matrix;
  1378.    D3DXMATRIX scaling_matrix;
  1379.    material_t *material;
  1380.    D3DMATERIAL9 d3dmaterial;
  1381.    D3DXPLANE plane;
  1382.    mesh_t *mesh;
  1383.    mesh_t *tile_mesh;
  1384.    float alpha;
  1385.  
  1386.    // draw the reflection below this mesh
  1387.  
  1388.    // quick access to meshes
  1389.    mesh = &meshes[sceneobject->mesh_index];
  1390.    tile_mesh = &meshes[theme->tile_meshindex];
  1391.  
  1392.    // set the world transform at location
  1393.    D3DXPlaneFromPointNormal (&plane, (D3DXVECTOR3 *) &scene_lookatpoint, (D3DXVECTOR3 *) &upwards_direction);
  1394.    D3DXMatrixReflect (&reflect_matrix, &plane);
  1395.    D3DXMatrixRotationYawPitchRoll (&rotation_matrix, -sceneobject->pitch * TO_RADIANS, 0.0f, -sceneobject->yaw * TO_RADIANS);
  1396.    D3DXMatrixTranslation (&translation_matrix, sceneobject->x, sceneobject->y, -sceneobject->z);
  1397.    D3DXMatrixScaling (&scaling_matrix, sceneobject->scale, sceneobject->scale, 1.0f);
  1398.  
  1399.    // tell Direct3D about our matrix
  1400.    d3ddev->SetTransform (D3DTS_WORLD, &(reflect_matrix * scaling_matrix * rotation_matrix * translation_matrix));
  1401.  
  1402.    d3ddev->SetRenderState (D3DRS_STENCILENABLE, true); // enable the stencil buffer
  1403.    d3ddev->SetRenderState (D3DRS_STENCILFUNC, D3DCMP_LESS); // instruct how to fill the stencil buffer
  1404.    d3ddev->SetRenderState (D3DRS_STENCILPASS, D3DSTENCILOP_KEEP); // instruct how to fill the stencil buffer
  1405.  
  1406.    // set the texture for this mesh
  1407.    if (sceneobject->texture_index != -1)
  1408.       d3ddev->SetTexture (0, textures[sceneobject->texture_index].texture);
  1409.    else
  1410.       d3ddev->SetTexture (0, NULL);
  1411.  
  1412.    // adjust the light reflection properties by setting the material
  1413.    if (sceneobject->material_index != -1)
  1414.       material = &materials[sceneobject->material_index]; // use the specified scene object material
  1415.    else
  1416.       material = &materials[material_count - 1]; // scene object material unspecified, use default material
  1417.    alpha = theme->reflection_alpha / 256.0f;
  1418.    d3dmaterial.Ambient = D3DXCOLOR (material->ambient, material->ambient, material->ambient, material->transparency * alpha); // Alpha value not used according to SDK
  1419.    d3dmaterial.Diffuse = D3DXCOLOR (material->diffuse, material->diffuse, material->diffuse, material->transparency * alpha);
  1420.    d3dmaterial.Emissive = D3DXCOLOR (material->emissive, material->emissive, material->emissive, material->transparency * alpha); // Alpha value not used according to SDK
  1421.    d3dmaterial.Specular = D3DXCOLOR (material->specular, material->specular, material->specular, material->transparency * alpha); // Alpha value not used according to SDK
  1422.    d3dmaterial.Power = material->shininess;
  1423.    d3ddev->SetMaterial (&d3dmaterial);
  1424.  
  1425.    // draw the mesh subset
  1426.    d3ddev->SetStreamSource (0, mesh->d3dvertices, 0, sizeof (vertex_t));
  1427.    d3ddev->SetFVF (mesh->vertex_format);
  1428.    d3ddev->SetRenderState (D3DRS_CULLMODE, D3DCULL_CW); // draw the faces backwards
  1429.    if (mesh->is_indexed)
  1430.    {
  1431.       d3ddev->SetIndices (mesh->d3dindices);
  1432.       d3ddev->DrawIndexedPrimitive (D3DPT_TRIANGLELIST, 0, 0, mesh->vertice_count, 0, mesh->indice_count / 3);
  1433.    }
  1434.    else
  1435.       d3ddev->DrawPrimitive (D3DPT_TRIANGLELIST, 0, mesh->vertice_count / 3);
  1436.  
  1437.    d3ddev->SetRenderState (D3DRS_STENCILENABLE, false); // and disable the stencil buffer
  1438.  
  1439.    // now draw the simple shadow below this mesh
  1440.  
  1441.    // grab the tools we need in hand
  1442.    d3ddev->SetRenderState (D3DRS_ZENABLE, false); // disable the Z buffer
  1443.    d3ddev->SetRenderState (D3DRS_AMBIENT, D3DCOLOR_XRGB (255, 255, 255)); // raise ambient light
  1444.  
  1445.    // position the simple shadow sprite
  1446.    D3DXMatrixScaling (&scaling_matrix, max (sceneobject->simpleshadow_size, sceneobject->z / 5.0f), max (sceneobject->simpleshadow_size, sceneobject->z / 5.0f), 0.0f);
  1447.    D3DXMatrixTranslation (&translation_matrix, sceneobject->x, sceneobject->y, 0.0f);
  1448.    d3ddev->SetTransform (D3DTS_WORLD, &(scaling_matrix * translation_matrix));
  1449.  
  1450.    // adjust the light reflection properties by setting the material
  1451.    material = &materials[material_count - 1]; // use the default material
  1452.    d3dmaterial.Ambient = D3DXCOLOR (material->ambient, material->ambient, material->ambient, material->transparency);
  1453.    d3dmaterial.Diffuse = D3DXCOLOR (material->diffuse, material->diffuse, material->diffuse, material->transparency);
  1454.    d3dmaterial.Emissive = D3DXCOLOR (material->emissive, material->emissive, material->emissive, material->transparency);
  1455.    d3dmaterial.Specular = D3DXCOLOR (material->specular, material->specular, material->specular, material->transparency);
  1456.    d3dmaterial.Power = material->shininess;
  1457.    d3ddev->SetMaterial (&d3dmaterial);
  1458.  
  1459.    d3ddev->SetTexture (0, textures[theme->shadow_textureindex].texture); // select the texture we want
  1460.  
  1461.    // and then draw it
  1462.    d3ddev->SetStreamSource (0, tile_mesh->d3dvertices, 0, sizeof (vertex_t)); // set stream source
  1463.    d3ddev->SetFVF (tile_mesh->vertex_format); // select which vertex format we are using
  1464.    d3ddev->SetRenderState (D3DRS_CULLMODE, D3DCULL_CW); // draw the faces backwards
  1465.    if (tile_mesh->is_indexed)
  1466.    {
  1467.       d3ddev->SetIndices (tile_mesh->d3dindices);
  1468.       d3ddev->DrawIndexedPrimitive (D3DPT_TRIANGLELIST, 0, 0, tile_mesh->vertice_count, 0, tile_mesh->indice_count / 3);
  1469.    }
  1470.    else
  1471.       d3ddev->DrawPrimitive (D3DPT_TRIANGLELIST, 0, tile_mesh->vertice_count / 3);
  1472.  
  1473.    // finished, reset ambient light to its previous value and enable the Z buffer back
  1474.    d3ddev->SetRenderState (D3DRS_AMBIENT, ambient_light);
  1475.    d3ddev->SetRenderState (D3DRS_ZENABLE, true);
  1476.  
  1477.    return; // finished
  1478. }
  1479.  
  1480.  
  1481. static void Render_DrawSceneObject (sceneobject_t *sceneobject)
  1482. {
  1483.    // fast helper to draw a mesh at a specified location with certain pitch and yaw angles
  1484.  
  1485.    D3DXMATRIX rotation_matrix;
  1486.    D3DXMATRIX translation_matrix;
  1487.    D3DXMATRIX scaling_matrix;
  1488.    material_t *material;
  1489.    D3DMATERIAL9 d3dmaterial;
  1490.    mesh_t *mesh;
  1491.  
  1492.    // is this object a tile (i.e, it has no mesh) ?
  1493.    if (sceneobject->mesh_index == -1)
  1494.    {
  1495.       Render_DrawSceneTile (sceneobject); // then draw it as a tile instead
  1496.       return; // and return
  1497.    }
  1498.  
  1499.    // quick access to mesh
  1500.    mesh = &meshes[sceneobject->mesh_index];
  1501.  
  1502.    // set the world transform at location
  1503.    D3DXMatrixRotationYawPitchRoll (&rotation_matrix, sceneobject->pitch * TO_RADIANS, 0.0f, sceneobject->yaw * TO_RADIANS);
  1504.    D3DXMatrixTranslation (&translation_matrix, sceneobject->x, sceneobject->y, sceneobject->z);
  1505.    D3DXMatrixScaling (&scaling_matrix, sceneobject->scale, sceneobject->scale, 1.0f);
  1506.  
  1507.    // tell Direct3D about our matrix
  1508.    d3ddev->SetTransform (D3DTS_WORLD, &(scaling_matrix * rotation_matrix * translation_matrix));
  1509.  
  1510.    // set the texture for this mesh
  1511.    if (sceneobject->texture_index != -1)
  1512.       d3ddev->SetTexture (0, textures[sceneobject->texture_index].texture);
  1513.    else
  1514.       d3ddev->SetTexture (0, NULL);
  1515.  
  1516.    // adjust the light reflection properties by setting the material
  1517.    if (sceneobject->material_index != -1)
  1518.       material = &materials[sceneobject->material_index];
  1519.    else
  1520.       material = &materials[material_count - 1];
  1521.    d3dmaterial.Ambient = D3DXCOLOR (material->ambient, material->ambient, material->ambient, material->transparency);
  1522.    d3dmaterial.Diffuse = D3DXCOLOR (material->diffuse, material->diffuse, material->diffuse, material->transparency);
  1523.    d3dmaterial.Emissive = D3DXCOLOR (material->emissive, material->emissive, material->emissive, material->transparency);
  1524.    d3dmaterial.Specular = D3DXCOLOR (material->specular, material->specular, material->specular, material->transparency);
  1525.    d3dmaterial.Power = material->shininess;
  1526.    d3ddev->SetMaterial (&d3dmaterial);
  1527.  
  1528.    // draw the mesh subset
  1529.    d3ddev->SetStreamSource (0, mesh->d3dvertices, 0, sizeof (vertex_t));
  1530.    d3ddev->SetFVF (mesh->vertex_format);
  1531.  
  1532.    // is there transparency on this mesh ?
  1533.    if (material->transparency < 1)
  1534.    {
  1535.       d3ddev->SetRenderState (D3DRS_CULLMODE, D3DCULL_CW); // draw the back faces
  1536.       if (mesh->is_indexed)
  1537.       {
  1538.          d3ddev->SetIndices (mesh->d3dindices);
  1539.          d3ddev->DrawIndexedPrimitive (D3DPT_TRIANGLELIST, 0, 0, mesh->vertice_count, 0, mesh->indice_count / 3);
  1540.       }
  1541.       else
  1542.          d3ddev->DrawPrimitive (D3DPT_TRIANGLELIST, 0, mesh->vertice_count / 3);
  1543.    }
  1544.  
  1545.    // now draw the front faces
  1546.    d3ddev->SetRenderState (D3DRS_CULLMODE, D3DCULL_CCW); // draw the front faces
  1547.    if (mesh->is_indexed)
  1548.    {
  1549.       d3ddev->SetIndices (mesh->d3dindices);
  1550.       d3ddev->DrawIndexedPrimitive (D3DPT_TRIANGLELIST, 0, 0, mesh->vertice_count, 0, mesh->indice_count / 3);
  1551.    }
  1552.    else
  1553.       d3ddev->DrawPrimitive (D3DPT_TRIANGLELIST, 0, mesh->vertice_count / 3);
  1554.  
  1555.    return; // finished
  1556. }
  1557.  
  1558.  
  1559. static void Render_DrawSceneTile (sceneobject_t *sceneobject)
  1560. {
  1561.    // fast helper to draw a tile (i.e, an object that doesn't have a mesh) at a specified location
  1562.  
  1563.    D3DXMATRIX rotation_matrix;
  1564.    D3DXMATRIX translation_matrix;
  1565.    D3DXMATRIX scaling_matrix;
  1566.    material_t *material;
  1567.    D3DMATERIAL9 d3dmaterial;
  1568.    mesh_t *tile_mesh;
  1569.  
  1570.    tile_mesh = &meshes[theme->tile_meshindex]; // quick access to tile mesh
  1571.  
  1572.    // grab the tools we need in hand
  1573.    d3ddev->SetRenderState (D3DRS_AMBIENT, D3DCOLOR_RGBA (0xFF, 0xFF, 0xFF, 0xFF)); // raise light
  1574.  
  1575.    // set the world transform at location
  1576.    D3DXMatrixRotationYawPitchRoll (&rotation_matrix, sceneobject->pitch * TO_RADIANS, 0.0f, sceneobject->yaw * TO_RADIANS);
  1577.    D3DXMatrixTranslation (&translation_matrix, sceneobject->x, sceneobject->y, sceneobject->z);
  1578.    D3DXMatrixScaling (&scaling_matrix, sceneobject->scale, sceneobject->scale, 1.0f);
  1579.  
  1580.    // tell Direct3D about our matrix
  1581.    d3ddev->SetTransform (D3DTS_WORLD, &(scaling_matrix * rotation_matrix * translation_matrix));
  1582.  
  1583.    // adjust the light reflection properties by setting the material
  1584.    material = &materials[material_count - 1]; // use the default material for tiles
  1585.    d3dmaterial.Ambient = D3DXCOLOR (material->ambient, material->ambient, material->ambient, material->ambient);
  1586.    d3dmaterial.Diffuse = D3DXCOLOR (material->diffuse, material->diffuse, material->diffuse, material->diffuse);
  1587.    d3dmaterial.Emissive = D3DXCOLOR (material->emissive, material->emissive, material->emissive, material->emissive);
  1588.    d3dmaterial.Specular = D3DXCOLOR (material->specular, material->specular, material->specular, material->specular);
  1589.    d3dmaterial.Power = material->shininess;
  1590.    d3ddev->SetMaterial (&d3dmaterial);
  1591.  
  1592.    // select the texture we want
  1593.    d3ddev->SetTexture (0, textures[sceneobject->texture_index].texture);
  1594.  
  1595.    // and then draw it
  1596.    d3ddev->SetStreamSource (0, tile_mesh->d3dvertices, 0, sizeof (vertex_t)); // set stream source
  1597.    d3ddev->SetFVF (tile_mesh->vertex_format); // select which vertex format we are using
  1598.    d3ddev->SetRenderState (D3DRS_CULLMODE, D3DCULL_CW); // draw the back faces
  1599.    if (tile_mesh->is_indexed)
  1600.    {
  1601.       d3ddev->SetIndices (tile_mesh->d3dindices);
  1602.       d3ddev->DrawIndexedPrimitive (D3DPT_TRIANGLELIST, 0, 0, tile_mesh->vertice_count, 0, tile_mesh->indice_count / 3);
  1603.    }
  1604.    else
  1605.       d3ddev->DrawPrimitive (D3DPT_TRIANGLELIST, 0, tile_mesh->vertice_count / 3);
  1606.  
  1607.    // finished, reset ambient light to its previous value
  1608.    d3ddev->SetRenderState (D3DRS_AMBIENT, ambient_light);
  1609.  
  1610.    return; // finished
  1611. }
  1612.  
  1613.  
  1614. static void Render_DrawSprite (sprite_t *sprite, float x_percent, float y_percent, float width_percent, float height_percent, int alpha)
  1615. {
  1616.    // fast helper to draw a sprite at a specified location with certain parameters
  1617.  
  1618.    D3DXMATRIX scaling_matrix;
  1619.    texture_t *texture;
  1620.    float scale_x;
  1621.    float scale_y;
  1622.  
  1623.    texture = &textures[sprite->texture_index]; // quick access to sprite's texture
  1624.  
  1625.    scale_x = (width_percent * (float) initial_width) / (float) (100 * texture->width);
  1626.    scale_y = (height_percent * (float) initial_height) / (float) (100 * texture->height);
  1627.  
  1628.    // start rendering the sprite (an optimized version would draw all sprites in a row...)
  1629.    sprite->sprite->Begin (D3DXSPRITE_ALPHABLEND);
  1630.  
  1631.    // scale and position the sprite
  1632.    D3DXMatrixTransformation2D (&scaling_matrix, // output matrix
  1633.                                NULL, // scaling center
  1634.                                0.0f, // scaling rotation
  1635.                                &D3DXVECTOR2 (scale_x, scale_y), // scaling ratio
  1636.                                &D3DXVECTOR2 (0, 0), // rotation center
  1637.                                0.0f, // rotation
  1638.                                &D3DXVECTOR2 (x_percent * (float) initial_width / 100.0f, y_percent * (float) initial_height / 100.0f)); // translation
  1639.    sprite->sprite->SetTransform (&scaling_matrix); // tell the sprite about the scaling and position transform
  1640.  
  1641.    // now draw the sprite with the specified alpha and finish rendering
  1642.    sprite->sprite->Draw (texture->texture, NULL, NULL, NULL, D3DCOLOR_ARGB (alpha, 255, 255, 255));
  1643.    sprite->sprite->End ();
  1644.  
  1645.    return; // finished
  1646. }
  1647.  
  1648.  
  1649. static void Render_GetTextBoundaries (float maxwidth_percent, int font_id, wchar_t *text, RECT *rect)
  1650. {
  1651.    // this function computes and returns the size of the rectangle the specified text will fit into. Note that text may be modified
  1652.    // to insert new lines if it doesn't fit in a single line.
  1653.  
  1654.    int char_index;
  1655.    int length;
  1656.    int optimal_length;
  1657.    bool have_split;
  1658.    int max_width;
  1659.  
  1660.    // blank out the output rectangle
  1661.    memset (rect, 0, sizeof (RECT));
  1662.  
  1663.    // ask direct3D to compute the text size a first time
  1664.    fonts[font_id].font->DrawText (NULL, text, -1, rect, DT_CALCRECT, D3DCOLOR (0));
  1665.  
  1666.    // if max width is not set, set it to viewport width
  1667.    if (maxwidth_percent <= 0)
  1668.       max_width = initial_width; // then use it to compute the real max width
  1669.    else
  1670.       max_width = (int) ((maxwidth_percent * (float) initial_width) / 100.0f); // else if specified, convert this percentage to an absolute pixel width
  1671.  
  1672.    // do we need more than one line ?
  1673.    if (rect->right > max_width)
  1674.    {
  1675.       // see how many lines we need and compute the optimal length of one line
  1676.       length = wcslen (text);
  1677.       optimal_length = length / (1 + rect->right / (int) max_width);
  1678.       have_split = false;
  1679.       for (char_index = optimal_length; char_index < length; char_index++)
  1680.          if (iswspace (text[char_index]))
  1681.          {
  1682.             text[char_index] = L'\n'; // interpolate linefeeds into string
  1683.             have_split = true; // remember string has been split
  1684.             char_index += optimal_length;
  1685.          }
  1686.  
  1687.       // and ask direct3D to compute the text size again
  1688.       fonts[font_id].font->DrawText (NULL, text, -1, rect, DT_CALCRECT, D3DCOLOR (0));
  1689.    }
  1690.  
  1691.    return; // finished
  1692. }
  1693.  
  1694.  
  1695. static void Render_wprintf (float x_percent, float y_percent, float maxwidth_percent, int horiz_align, int vert_align, int text_align, int font_id, unsigned long color_rgba, RECT *out_rect, const wchar_t *fmt, ...)
  1696. {
  1697.    // this function displays text on the Direct3D interface according to the given parameters. X and Y are the base coordinates of
  1698.    // the text's bounding rectangle. Max_width is the maximum allowed width of this rectangle before wrapping words on a new line.
  1699.    // Horiz_align and vert_align are the alignment parameters of the RECTANGLE relatively to X and Y. Text_align is the alignment of
  1700.    // the TEXT inside this rectangle (meaning, you can have right-aligned text in a rectangle that is centered on a point). Font_id
  1701.    // and color.alphargb define the font and color of the text. Out_rect, if filled, will point to a RECT structure describing the text's
  1702.    // bounding rectangle, after any word wrapping corrections have been made. Fmt is a format string containing the text itself,
  1703.    // printf-style.
  1704.  
  1705.    va_list argptr;
  1706.    RECT rect;
  1707.    int left;
  1708.    int top;
  1709.    int x;
  1710.    int y;
  1711.  
  1712.    // concatenate all the arguments in one string
  1713.    va_start (argptr, fmt);
  1714.    wvsprintf (printf_buffer, fmt, argptr);
  1715.    va_end (argptr);
  1716.  
  1717.    // translate percent coordinates into absolute coordinates
  1718.    x = (int) ((x_percent * (float) initial_width) / 100.0f);
  1719.    y = (int) ((y_percent * (float) initial_height) / 100.0f);
  1720.  
  1721.    // get the text boundaries
  1722.    Render_GetTextBoundaries (maxwidth_percent, font_id, printf_buffer, &rect);
  1723.  
  1724.    // horizontal alignment
  1725.    if (horiz_align == ALIGN_LEFT)
  1726.       left = x;
  1727.    else if (horiz_align == ALIGN_RIGHT)
  1728.       left = x - rect.right;
  1729.    else
  1730.       left = x - rect.right / 2;
  1731.  
  1732.    // vertical alignment
  1733.    if (vert_align == ALIGN_TOP)
  1734.       top = y;
  1735.    else if (vert_align == ALIGN_BOTTOM)
  1736.       top = y - rect.bottom;
  1737.    else
  1738.       top = y - rect.bottom / 2;
  1739.  
  1740.    // now reposition our rectangle correctly acording to alignment
  1741.    OffsetRect (&rect, left, top);
  1742.  
  1743.    // and draw the text
  1744.    if (text_align == ALIGN_LEFT)
  1745.       fonts[font_id].font->DrawText (NULL, printf_buffer, -1, &rect, DT_LEFT, RGBACOLOR_TO_ARGBCOLOR (color_rgba));
  1746.    else if (horiz_align == ALIGN_RIGHT)
  1747.       fonts[font_id].font->DrawText (NULL, printf_buffer, -1, &rect, DT_RIGHT, RGBACOLOR_TO_ARGBCOLOR (color_rgba));
  1748.    else
  1749.       fonts[font_id].font->DrawText (NULL, printf_buffer, -1, &rect, DT_CENTER, RGBACOLOR_TO_ARGBCOLOR (color_rgba));
  1750.  
  1751.    // do we want the output rectangle ?
  1752.    if (out_rect != NULL)
  1753.       memcpy (out_rect, &rect, sizeof (rect)); // if so, copy it in the given variable
  1754.  
  1755.    return; // finished
  1756. }
  1757.  
  1758.  
  1759. static float DistanceToCamera (float x, float y, float z)
  1760. {
  1761.    // this function computes the distance of the point at coordinates x,y,z to the camera
  1762.  
  1763.    vector_t displacement;
  1764.  
  1765.    // compute displacement...
  1766.    displacement.x = x - camera_position.x;
  1767.    displacement.y = y - camera_position.y;
  1768.    displacement.z = z - camera_position.z;
  1769.  
  1770.    // ...and then Pythagores in 3D
  1771.    return (sqrtf (displacement.x * displacement.x + displacement.y * displacement.y + displacement.z * displacement.z));
  1772. }
  1773.  
  1774.  
  1775. static float FadeFloat (float from, float to, float start_time, float end_time)
  1776. {
  1777.    // helper function to return a progressive variation between from and to based on time
  1778.  
  1779.    if (end_time < current_time)
  1780.       return (to);
  1781.  
  1782.    //      base + (variation) * (               fraction of completion               )
  1783.    return (from + (to - from) * (current_time - start_time) / (end_time - start_time));
  1784. }
  1785.  
  1786.  
  1787. static unsigned long HashString (const wchar_t *string_buffer)
  1788. {
  1789.    // super fast string hash function, code courtesy of
  1790.    // http://www.azillionmonkeys.com/qed/hash.html
  1791.  
  1792.    unsigned long length;
  1793.    unsigned long hash;
  1794.    unsigned long tmp;
  1795.    int remaining;
  1796.  
  1797.    // first, get the string length and start with this as a hash value
  1798.    length = wcslen (string_buffer) * sizeof (wchar_t);
  1799.    hash = length;
  1800.  
  1801.    // figure out how many bytes there will remain after 32-bit processing
  1802.    remaining = length & 3;
  1803.    length >>= 2;
  1804.  
  1805.    // main loop, process 32-bit blocks
  1806.    for ( ; length > 0; length--)
  1807.    {
  1808.       hash += *((const unsigned short *) string_buffer);
  1809.       tmp = ((*((const unsigned short *) (string_buffer + 2))) << 11) ^ hash;
  1810.       hash = (hash << 16) ^ tmp;
  1811.       string_buffer += 2 * sizeof (unsigned short);
  1812.       hash += hash >> 11;
  1813.    }
  1814.  
  1815.    // handle the remaining bytes
  1816.    if (remaining == 3)
  1817.    {
  1818.       hash += *((const unsigned short *) string_buffer);
  1819.       hash ^= hash << 16;
  1820.       hash ^= string_buffer[sizeof (unsigned short)] << 18;
  1821.       hash += hash >> 11;
  1822.    }
  1823.    else if (remaining == 2)
  1824.    {
  1825.       hash += *((const unsigned short *) string_buffer);
  1826.       hash ^= hash << 11;
  1827.       hash += hash >> 17;
  1828.    }
  1829.    else if (remaining == 1)
  1830.    {
  1831.       hash += *string_buffer;
  1832.       hash ^= hash << 10;
  1833.       hash += hash >> 1;
  1834.    }
  1835.  
  1836.    // force "avalanching" of final 127 bits
  1837.    hash ^= hash << 3;
  1838.    hash += hash >> 5;
  1839.    hash ^= hash << 4;
  1840.    hash += hash >> 17;
  1841.    hash ^= hash << 25;
  1842.    hash += hash >> 6;
  1843.  
  1844.    return (hash); // finished, return the hash value
  1845. }
  1846.  
  1847.  
  1848. static unsigned long HashFile (const wchar_t *file_pathname)
  1849. {
  1850.    // super fast file content pseudo-hash function
  1851.  
  1852.    unsigned short value;
  1853.    unsigned long file_size;
  1854.    FILE *fp;
  1855.  
  1856.    // open the file
  1857.    _wfopen_s (&fp, file_pathname, L"rb");
  1858.    if (fp == NULL)
  1859.       return ((unsigned long) time (NULL)); // if file can't be open, return a random number
  1860.  
  1861.    // seek at end of file, read file size, and rewind
  1862.    fseek (fp, 0, SEEK_END);
  1863.    file_size = ftell (fp);
  1864.    fseek (fp, 0, SEEK_SET);
  1865.  
  1866.    // seek at 2/3 of file size (if file is small enough, return only its content)
  1867.    if (file_size >= 4)
  1868.    {
  1869.       fseek (fp, file_size * 2 / 3, SEEK_SET); // seek at 2/3 of file
  1870.       fread (&value, 2, 1, fp); // and read a word here
  1871.    }
  1872.    else if (file_size >= 2)
  1873.       fread (&value, 2, 1, fp);
  1874.    else if (file_size == 1)
  1875.       value = fgetc (fp);
  1876.    else
  1877.       value = 0;
  1878.  
  1879.    // finished, close the file
  1880.    fclose (fp);
  1881.  
  1882.    // and return a hash composed of the 16 lower bits of the file size and the value we read
  1883.    return ((unsigned long) (file_size << 16) | (unsigned long) value);
  1884. }
  1885.  
  1886.  
  1887. static void ResolveWildcard (wchar_t *file_pathname, wchar_t *extensions_separated_by_bars)
  1888. {
  1889.    // this function resolves a pathname ending with .* by testing with various possible
  1890.    // file extensions until one of the files formed that way is found to exist.
  1891.  
  1892.    static wchar_t extension_list[256]; // needs to be modifiable for strtok()
  1893.    wchar_t *current_extension;
  1894.    wchar_t *wcstok_context;
  1895.    int length;
  1896.  
  1897.    wcscpy_s (extension_list, WCHAR_SIZEOF (extension_list), extensions_separated_by_bars);
  1898.    length = wcslen (file_pathname); // get pathname length
  1899.  
  1900.    // does the pathname we want NOT end with a wildcard ?
  1901.    if ((length < 2) || (wcscmp (&file_pathname[length - 2], L".*") != 0))
  1902.       return; // no need to resolve anything
  1903.  
  1904.    // test each extension and see if a corresponding file exists
  1905.    current_extension = wcstok_s (extension_list, L"|", &wcstok_context);
  1906.    while (current_extension != NULL)
  1907.    {
  1908.       if (*current_extension == L'.')
  1909.          current_extension++; // if current extension starts with a dot, skip it
  1910.  
  1911.       wcscpy_s (&file_pathname[length - 1], wcslen (current_extension) + 1, current_extension);
  1912.       if (_waccess (file_pathname, 0) == 0)
  1913.          return; // found a file with this extension
  1914.       current_extension = wcstok_s (NULL, L"|", &wcstok_context);
  1915.    }
  1916.  
  1917.    wcscpy_s (&file_pathname[length - 1], 2, L"*");
  1918.    return; // if none of these extensions match, put the wildcard back and return
  1919. }
  1920.  
  1921.  
  1922. static int SortReflectedObjects (const void *object1, const void *object2)
  1923. {
  1924.    // callback function used by qsort() when sorting the reflected objects according to their distance to the viewer
  1925.  
  1926.    return ((int) (1000.0f * (((reflectedobject_t *) object2)->distance - ((reflectedobject_t *) object1)->distance)));
  1927. }
  1928.