Subversion Repositories Games.Chess Giants

Rev

Rev 136 | Rev 164 | 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.llarrow); // "jump to beginning" arrow
  783.    DRAW_BUTTON_IF_NEEDED (scene->gui.larrow); // "previous move" arrow
  784.    DRAW_BUTTON_IF_NEEDED (scene->gui.rarrow); // "next move" arrow
  785.    DRAW_BUTTON_IF_NEEDED (scene->gui.rrarrow); // "jump to end" arrow
  786.    DRAW_TEXT_IF_NEEDED (scene->gui.arrow_text); // arrow text
  787.  
  788.    if (want_framerate)
  789.       Render_wprintf (99.0f, 1.0f, 0.0f, ALIGN_RIGHT, ALIGN_TOP, ALIGN_CENTER, arrow_fontindex, D3DCOLOR_RGBA (255, 255, 255, 255), NULL,
  790.                       L"%d textures\n"
  791.                       L"%d meshes\n"
  792.                       L"%d fonts\n"
  793.                       L"%d sprites\n"
  794.                       L"%d fps", texture_count, mesh_count, font_count, sprite_count, framerate_value);
  795.  
  796.    // draw the other GUI buttons
  797.    DRAW_BUTTON_IF_NEEDED (scene->gui.chatbutton); // chat button
  798.    DRAW_BUTTON_IF_NEEDED (scene->gui.gamesbutton); // games button
  799.    DRAW_BUTTON_IF_NEEDED (scene->gui.peoplebutton); // people button
  800.  
  801.    // does the parts pick line need to be displayed ?
  802.    if (scene->gui.is_partspick_displayed)
  803.    {
  804. #define PARTSIZE_PCT (100.0f / 13.0f)
  805.  
  806.       if (scene->gui.partspick_selectedpart == 'P')      Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  0.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  807.       else if (scene->gui.partspick_selectedpart == 'R') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  1.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  808.       else if (scene->gui.partspick_selectedpart == 'N') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  2.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  809.       else if (scene->gui.partspick_selectedpart == 'B') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  3.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  810.       else if (scene->gui.partspick_selectedpart == 'Q') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  4.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  811.       else if (scene->gui.partspick_selectedpart == 'K') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  5.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  812.       else if (scene->gui.partspick_selectedpart == ' ') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  6.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  813.       else if (scene->gui.partspick_selectedpart == 'k') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  7.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  814.       else if (scene->gui.partspick_selectedpart == 'q') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  8.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  815.       else if (scene->gui.partspick_selectedpart == 'b') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex],  9.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  816.       else if (scene->gui.partspick_selectedpart == 'n') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex], 10.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  817.       else if (scene->gui.partspick_selectedpart == 'r') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex], 11.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  818.       else if (scene->gui.partspick_selectedpart == 'p') Render_DrawSprite (&sprites[theme->lastmovetarget_spriteindex], 12.0f * PARTSIZE_PCT, 0.0f, PARTSIZE_PCT, 11.0f, 0xFF);
  819.  
  820.       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
  821.       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
  822.       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
  823.       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
  824.       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
  825.       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
  826.       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
  827.       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
  828.       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
  829.       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
  830.       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
  831.       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
  832.       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
  833.  
  834. #undef PARTSIZE_PCT
  835.    }
  836.  
  837.    // draw GUI texts
  838.    DRAW_TEXT_IF_NEEDED (scene->gui.comment_text); // move comments
  839.    DRAW_TEXT_IF_NEEDED (scene->gui.history_text); // game history
  840.    DRAW_TEXT_IF_NEEDED (scene->gui.clock_text); // game clock
  841.  
  842.    // draw the chatter channels text
  843.    Render_GetTextBoundaries (-1, chat_fontindex, L"a", &rect);
  844.    combinedheight_percent = (float) (rect.bottom * 100 / initial_height); // get a string's height
  845.  
  846.    // cycle through all the chat strings...
  847.    ccreply = NULL;
  848.    for (cchistory_index = 0; cchistory_index < scene->gui.cchistory_count; cchistory_index++)
  849.    {
  850.       ccreply = &scene->gui.cchistory[cchistory_index]; // quick access to CC reply
  851.       if ((ccreply->text[0] != 0) && (ccreply->arrival_time + 60.0f > current_time))
  852.          break; // break at the first one that we should display
  853.    }
  854.  
  855.    // have we some to display ?
  856.    if (cchistory_index < scene->gui.cchistory_count)
  857.    {
  858.       // first, get the remaining text's combined height
  859.       for (cchistory_index2 = cchistory_index; cchistory_index2 < scene->gui.cchistory_count; cchistory_index2++)
  860.       {
  861.          ccreply = &scene->gui.cchistory[cchistory_index2]; // quick access to CC reply
  862.  
  863.          combinedwidth_percent = 1.0f;
  864.          Render_GetTextBoundaries (100 - combinedwidth_percent, chat_fontindex, L"[] : ", &rect);
  865.          combinedwidth_percent += (float) (rect.right * 100 / initial_width);
  866.          Render_GetTextBoundaries (100 - combinedwidth_percent, chat_fontindex, ccreply->channelname, &rect);
  867.          combinedwidth_percent += (float) (rect.right * 100 / initial_width);
  868.          Render_GetTextBoundaries (100 - combinedwidth_percent, chat_fontindex, ccreply->nickname, &rect);
  869.          combinedwidth_percent += (float) (rect.right * 100 / initial_width);
  870.          Render_GetTextBoundaries (100 - combinedwidth_percent, chat_fontindex, ccreply->text, &rect);
  871.          combinedheight_percent += (float) (rect.bottom * 100 / initial_height); // add this string's height
  872.       }
  873.  
  874.       // now for each string remaining...
  875.       for (; cchistory_index < scene->gui.cchistory_count; cchistory_index++)
  876.       {
  877.          ccreply = &scene->gui.cchistory[cchistory_index]; // quick access to CC reply
  878.          rect.right = 10;
  879.          PRINT_CCREPLY (ccreply); // print CC reply on screen
  880.          combinedheight_percent -= (float) ((rect.bottom - rect.top) * 100 / initial_height); // draw it from top of zone to bottom
  881.       }
  882.    }
  883.  
  884.    // are we online ?
  885.    if (Player_FindByType (PLAYER_INTERNET) != NULL)
  886.    {
  887.       ccreply = &scene->gui.entered_ccreply;
  888.       if (!scene->gui.is_entering_text)
  889.          ccreply->color = RGBACOLOR_SETALPHA (ccreply->color, RGBACOLOR_ALPHA (ccreply->color) / 6); // if there's no text being entered, fade CC reply a lot
  890.  
  891.       rect.right = 10;
  892.       PRINT_CCREPLY (ccreply); // print CC reply on screen
  893.    }
  894.  
  895.    // print GUI texts
  896.    DRAW_TEXT_IF_NEEDED (scene->gui.turn_text); // player turn's text
  897.    DRAW_TEXT_IF_NEEDED (scene->gui.central_text); // central notification zone text
  898.  
  899.    // if needed, print the spinning wheel
  900.    if (scene->gui.want_spinwheel)
  901.       Render_DrawSprite (&sprites[spinner_spriteindex[(int) (10.0f * current_time) % 12]], 47.0f, 46.0f, 6.0f, 8.0f, 255);
  902.  
  903.    // are we in demo mode ? if so, display the program name as a watermark
  904.    if (!is_registered)
  905.       Render_wprintf (50.0f, 60.0f, 0.0f, ALIGN_CENTER, ALIGN_CENTER, ALIGN_CENTER, chat_fontindex,
  906.                       D3DCOLOR_RGBA (255, 255, 255, 255),
  907.                       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);
  908.  
  909.    // end 3D rendering on the back buffer
  910.    //////////////////////////////////////
  911.  
  912.    d3ddev->EndScene (); // ends the 3D scene
  913.    d3ddev->Present (NULL, NULL, NULL, NULL); // displays the created frame on the screen
  914.  
  915.    // update the frame rate
  916.    if (framerate_time < current_time)
  917.    {
  918.       framerate_value = framerate_count;
  919.       framerate_count = 0;
  920.       framerate_time = current_time + 1.0f;
  921.    }
  922.    framerate_count++; // one frame more elapsed
  923.  
  924.    return; // finished
  925. }
  926.  
  927.  
  928. int Render_LoadMesh (const wchar_t *fmt, ...)
  929. {
  930.    // this function appends a new mesh in the global meshes buffer and returns its index
  931.  
  932.    static wchar_t meshfile_pathname[MAX_PATH];
  933.    unsigned long hash;
  934.    mesh_t *mesh;
  935.    int mesh_index;
  936.    va_list argptr;
  937.  
  938.    // concatenate all the arguments in one string
  939.    va_start (argptr, fmt);
  940.    wvsprintf (meshfile_pathname, fmt, argptr);
  941.    va_end (argptr);
  942.  
  943.    // resolve wildcards and get content hash
  944.    ResolveWildcard (meshfile_pathname, L".obj");
  945.    hash = HashFile (meshfile_pathname);
  946.    
  947.    // now cycle through all our loaded meshes and see if it's already loaded
  948.    for (mesh_index = 0; mesh_index < mesh_count; mesh_index++)
  949.       if (meshes[mesh_index].hash == hash)
  950.          return (mesh_index); // if we can find it, return its index so as not to load it twice
  951.  
  952.    // reallocate space to hold one mesh more
  953.    meshes = (mesh_t *) SAFE_realloc (meshes, mesh_count, mesh_count + 1, sizeof (mesh_t), false);
  954.    mesh = &meshes[mesh_count]; // quick access to the mesh we'll be working on
  955.  
  956.    // load the mesh
  957.    if (!Render_LoadMesh_Obj (mesh, meshfile_pathname))
  958.       return (-1); // bomb out on error
  959.  
  960.    mesh->hash = hash; // save the hash
  961.    mesh_count++; // we know now one mesh more
  962.    return (mesh_count - 1); // return its index
  963. }
  964.  
  965.  
  966. int Render_LoadTexture (const wchar_t *fmt, ...)
  967. {
  968.    // this function appends a new texture in the global textures buffer and returns its index
  969.  
  970.    D3DSURFACE_DESC texture_description;
  971.    wchar_t texturefile_pathname[MAX_PATH];
  972.    static wchar_t *filename;
  973.    unsigned long hash;
  974.    int texture_index;
  975.    va_list argptr;
  976.  
  977.    // concatenate all the arguments in one string
  978.    va_start (argptr, fmt);
  979.    wvsprintf (texturefile_pathname, fmt, argptr);
  980.    va_end (argptr);
  981.  
  982.    // resolve wildcards and get content hash
  983.    ResolveWildcard (texturefile_pathname, L".dds|.jpg|.jpeg|.png|.tga|.bmp");
  984.    hash = HashFile (texturefile_pathname);
  985.  
  986.    // now cycle through all our loaded textures and see if it's already loaded
  987.    for (texture_index = 0; texture_index < texture_count; texture_index++)
  988.       if (textures[texture_index].hash == hash)
  989.          return (texture_index); // if we can find it, return its index so as not to load it twice
  990.  
  991.    // reallocate space to hold one texture more
  992.    textures = (texture_t *) SAFE_realloc (textures, texture_count, texture_count + 1, sizeof (texture_t), false);
  993.  
  994.    // ask Direct3D to prepare texture data
  995.    if (FAILED (D3DXCreateTextureFromFile (d3ddev, texturefile_pathname, &textures[texture_count].texture)))
  996.    {
  997.       MessageBox (NULL, LOCALIZE (L"Error_UnableToAddTextureD3DXCreateTextureFromFileFailed"), LOCALIZE (L"FatalError"), MB_ICONERROR | MB_OK);
  998.       terminate_everything = true; // this is a fatal error
  999.       return (-1); // bomb out on error
  1000.    }
  1001.  
  1002.    // get info on the newly loaded texture such as size etc.
  1003.    textures[texture_count].texture->GetLevelDesc (0, &texture_description);
  1004.    textures[texture_count].width = texture_description.Width; // save texture width (as loaded)
  1005.    textures[texture_count].height = texture_description.Height; // save texture height (as loaded)
  1006.    textures[texture_count].hash = hash; // save its hash
  1007.    texture_count++; // we know now one texture more
  1008.    return (texture_count - 1); // return its index
  1009. }
  1010.  
  1011.  
  1012. int Render_LoadFont (const wchar_t *font_name, int font_size, bool is_bold, bool is_italic)
  1013. {
  1014.    // this function appends a new font in the global fonts buffer and returns its index
  1015.  
  1016.    unsigned long pathname_hash;
  1017.    int font_index;
  1018.  
  1019.    // first, get the hash of the requested pathname (include font size and weight parameters)
  1020.    pathname_hash = HashString (font_name);
  1021.    pathname_hash += 3 * (unsigned long) font_size + 2 * (unsigned long) is_bold + (unsigned long) is_italic;
  1022.  
  1023.    // now cycle through all our loaded fonts and see if it's already loaded
  1024.    for (font_index = 0; font_index < font_count; font_index++)
  1025.       if (fonts[font_index].pathname_hash == pathname_hash)
  1026.          return (font_index); // if we can find it, return its index so as not to load it twice
  1027.  
  1028.    // reallocate space to hold one font more
  1029.    fonts = (font_t *) SAFE_realloc (fonts, font_count, font_count + 1, sizeof (font_t), false);
  1030.  
  1031.    // create a Direct3D font object and record font data
  1032.    if (FAILED (D3DXCreateFont (d3ddev, font_size, // font height
  1033.                                2 * font_size / 5, // font width
  1034.                                (is_bold ? FW_BOLD : FW_NORMAL), // font weight (bold, etc)
  1035.                                0, // miplevels
  1036.                                is_italic, // is italic
  1037.                                DEFAULT_CHARSET, // charset
  1038.                                OUT_DEFAULT_PRECIS, // precision
  1039.                                CLEARTYPE_QUALITY, // font quality (antialiased or not)
  1040.                                DEFAULT_PITCH | FF_DONTCARE, // font family
  1041.                                font_name, // font name
  1042.                                &fonts[font_count].font))) // and a pointer that will receive the font
  1043.    {
  1044.       MessageBox (NULL, LOCALIZE (L"Error_UnableToAddFontD3DXCreateFontFailed"), LOCALIZE (L"FatalError"), MB_ICONERROR | MB_OK);
  1045.       terminate_everything = true; // this is a fatal error
  1046.       return (-1); // bomb out on error
  1047.    }
  1048.  
  1049.    fonts[font_count].pathname_hash = pathname_hash; // save its hash
  1050.    font_count++; // we know now one font more
  1051.    return (font_count - 1); // return its index
  1052. }
  1053.  
  1054.  
  1055. int Render_LoadSprite (const wchar_t *fmt, ...)
  1056. {
  1057.    // this function appends a new sprite in the global sprites buffer and returns its index
  1058.  
  1059.    wchar_t spritefile_pathname[MAX_PATH];
  1060.    unsigned long hash;
  1061.    int sprite_index;
  1062.    va_list argptr;
  1063.  
  1064.    // concatenate all the arguments in one string
  1065.    va_start (argptr, fmt);
  1066.    wvsprintf (spritefile_pathname, fmt, argptr);
  1067.    va_end (argptr);
  1068.  
  1069.    // resolve wildcards and get content hash
  1070.    ResolveWildcard (spritefile_pathname, L".dds|.jpg|.jpeg|.png|.tga|.bmp");
  1071.    hash = HashFile (spritefile_pathname);
  1072.  
  1073.    // now cycle through all our loaded sprites and see if it's already loaded
  1074.    for (sprite_index = 0; sprite_index < sprite_count; sprite_index++)
  1075.       if (sprites[sprite_index].hash == hash)
  1076.          return (sprite_index); // if we can find it, return its index so as not to load it twice
  1077.  
  1078.    // reallocate space to hold one sprite more
  1079.    sprites = (sprite_t *) SAFE_realloc (sprites, sprite_count, sprite_count + 1, sizeof (sprite_t), false);
  1080.  
  1081.    // ask Direct3D to prepare texture data
  1082.    if (FAILED (D3DXCreateSprite (d3ddev, &sprites[sprite_count].sprite)))
  1083.    {
  1084.       MessageBox (NULL, LOCALIZE (L"Error_UnableToAddSpriteD3DXCreateSpriteFailed"), LOCALIZE (L"FatalError"), MB_ICONERROR | MB_OK);
  1085.       terminate_everything = true; // this is a fatal error
  1086.       return (-1); // bomb out on error
  1087.    }
  1088.    sprites[sprite_count].texture_index = Render_LoadTexture (spritefile_pathname); // register and save sprite texture
  1089.    sprites[sprite_count].hash = hash; // save its hash
  1090.  
  1091.    sprite_count++; // we know now one sprite more
  1092.    return (sprite_count - 1); // return its index
  1093. }
  1094.  
  1095.  
  1096. int Render_MaterialIndexOf (const wchar_t *material_name)
  1097. {
  1098.    // this function returns the index of the material in the global materials array which has the specified name
  1099.  
  1100.    int material_index;
  1101.  
  1102.    // cycle through all materials and look whether one with the specified name exists
  1103.    for (material_index = 0; material_index < material_count; material_index++)
  1104.       if (_wcsicmp (materials[material_index].name, material_name) == 0)
  1105.          return (material_index); // if we find one, return its index
  1106.  
  1107.    return (material_count - 1); // else return the index of the last material in list, which is the default material
  1108. }
  1109.  
  1110.  
  1111. void Render_MouseToFloor (short mouse_x, short mouse_y, float *floor_x, float *floor_y)
  1112. {
  1113.    // this function converts a mouse coordinates into floor coordinates by doing vector
  1114.    // projection on the floor plane from the eyepoint of the camera
  1115.  
  1116.    static D3DXPLANE floor_plane;
  1117.    static bool is_planefound = false;
  1118.  
  1119.    D3DXMATRIX projection_matrix;
  1120.    D3DXMATRIX view_matrix;
  1121.    D3DXMATRIX invertedview_matrix;
  1122.    float mouse_pitch;
  1123.    float mouse_yaw;
  1124.    vector_t v_lookat;
  1125.    vector_t v_intersection;
  1126.  
  1127.    // find the floor plane (only do it once)
  1128.    if (!is_planefound)
  1129.    {
  1130.       D3DXPlaneFromPointNormal (&floor_plane, (D3DXVECTOR3 *) &scene_lookatpoint, (D3DXVECTOR3 *) &upwards_direction);
  1131.       is_planefound = true; // once and for all, as this plane will never change
  1132.    }
  1133.  
  1134.    // get the current projection and view matrices, and invert the view matrix
  1135.    d3ddev->GetTransform (D3DTS_PROJECTION, &projection_matrix);
  1136.    d3ddev->GetTransform (D3DTS_VIEW, &view_matrix);
  1137.    D3DXMatrixInverse (&invertedview_matrix, NULL, &view_matrix);
  1138.  
  1139.    // convert the mouse coordinates to relative pitch and yaw
  1140.    mouse_pitch =  (((mouse_x * 2.0f) / current_width) - 1) / projection_matrix._11;
  1141.    mouse_yaw = -(((mouse_y * 2.0f) / current_height) - 1) / projection_matrix._22;
  1142.  
  1143.    // now build a matrix that will describe the mouse direction vector, add it to the camera position, and make it 200 times longer
  1144.    v_lookat.x = camera_position.x + (mouse_pitch * invertedview_matrix._11 + mouse_yaw * invertedview_matrix._21 + invertedview_matrix._31) * 200.0f;
  1145.    v_lookat.y = camera_position.y + (mouse_pitch * invertedview_matrix._12 + mouse_yaw * invertedview_matrix._22 + invertedview_matrix._32) * 200.0f;
  1146.    v_lookat.z = camera_position.z + (mouse_pitch * invertedview_matrix._13 + mouse_yaw * invertedview_matrix._23 + invertedview_matrix._33) * 200.0f;
  1147.  
  1148.    // and the intersection point with our ray
  1149.    D3DXPlaneIntersectLine ((D3DXVECTOR3 *) &v_intersection, &floor_plane, (D3DXVECTOR3 *) &camera_position, (D3DXVECTOR3 *) &v_lookat);
  1150.  
  1151.    // now fill the return values
  1152.    *floor_x = v_intersection.x;
  1153.    *floor_y = v_intersection.y;
  1154.  
  1155.    return; // finished
  1156. }
  1157.  
  1158.  
  1159. bool Render_IsMouseInBox (short mouse_x, short mouse_y, float x_percent, float y_percent, float width_percent, float height_percent)
  1160. {
  1161.    // helper function that returns whether the mouse coordinates are inside a given square
  1162.  
  1163.    float mousex_percent;
  1164.    float mousey_percent;
  1165.  
  1166.    // compute mouse coordinates in percents
  1167.    mousex_percent = (float) mouse_x * 100.0f / current_width;
  1168.    mousey_percent = (float) mouse_y * 100.0f / current_height;
  1169.  
  1170.    return ((mousex_percent >= x_percent) && (mousex_percent <= x_percent + width_percent)
  1171.            && (mousey_percent >= y_percent) && (mousey_percent <= y_percent + height_percent));
  1172. }
  1173.  
  1174.  
  1175. static bool Render_LoadMesh_Obj (mesh_t *mesh, const wchar_t *objfile_pathname)
  1176. {
  1177.    // this function loads a mesh from a Wavefront Object file (.obj)
  1178.  
  1179.    #define OBJ_INCREASE_OR_RESIZE(count,maxcount,increment,arrayptr,type,erase) { \
  1180.       (count)++; \
  1181.       if ((count) == (maxcount)) \
  1182.       { \
  1183.          (arrayptr) = (type *) SAFE_realloc ((arrayptr), (maxcount), (maxcount) + (increment), sizeof (type), erase); \
  1184.          (maxcount) += (increment); \
  1185.       } \
  1186.    }
  1187.    #define OBJ_CONVERT_INDEX(element,current_element_count) if ((element) < 0) (element) = (current_element_count) + (element); else (element)--;
  1188.    #define OBJ_GET_EXISTING_INDEX_OR_APPEND_VERTEX(uniquevertex) \
  1189.    { \
  1190.       hash = &hashtable[*((unsigned long *) &obj.vs[(uniquevertex).iv].x) & 0xFF]; \
  1191.       for (vertex_index = 0; vertex_index < hash->count; vertex_index++) \
  1192.          if ((memcmp (&vertices[hash->indices[vertex_index]].position, &obj.vs[(uniquevertex).iv], sizeof (vector_t)) == 0) \
  1193.              && (memcmp (&vertices[hash->indices[vertex_index]].normal, &obj.ns[(uniquevertex).in], sizeof (vector_t)) == 0) \
  1194.              && (memcmp (&vertices[hash->indices[vertex_index]].texcoord, &obj.tcs[(uniquevertex).itc], sizeof (texcoord_t)) == 0)) \
  1195.             break; \
  1196.       if (vertex_index == hash->count) \
  1197.       { \
  1198.          vertex_index = mesh->vertice_count; \
  1199.          current_vertex = &vertices[vertex_index]; \
  1200.          memset (current_vertex, 0, sizeof (vertex_t)); \
  1201.          memcpy (&current_vertex->position, &obj.vs[(uniquevertex).iv], sizeof (vector_t)); \
  1202.          if ((uniquevertex).in > -1) \
  1203.             memcpy (&current_vertex->normal, &obj.ns[(uniquevertex).in], sizeof (vector_t)); \
  1204.          if ((uniquevertex).itc > -1) \
  1205.             memcpy (&current_vertex->texcoord, &obj.tcs[(uniquevertex).itc], sizeof (texcoord_t)); \
  1206.          hash = &hashtable[*((unsigned long *) &current_vertex->normal.x) & 0xFF]; \
  1207.          hash->indices = (long *) SAFE_realloc (hash->indices, hash->count, hash->count + 1, sizeof (long), false); \
  1208.          hash->indices[hash->count] = vertex_index; \
  1209.          hash->count++; \
  1210.          mesh->vertice_count++; \
  1211.       } \
  1212.       else \
  1213.          vertex_index = hash->indices[vertex_index]; \
  1214.    }
  1215.  
  1216.    typedef struct obj_uniquevertex_s { long iv, in, itc; } obj_uniquevertex_t;
  1217.    typedef struct obj_face_s { obj_uniquevertex_t v1, v2, v3; } obj_face_t;
  1218.    typedef struct obj_hashbucket_s { int count; long *indices; /* mallocated */ } obj_hashbucket_t;
  1219.    typedef struct objfile_s
  1220.    {
  1221.       vector_t *vs; long v_count; long v_maxcount; // array mallocated to v_maxcount
  1222.       vector_t *ns; long n_count; long n_maxcount; // array mallocated to n_maxcount
  1223.       texcoord_t *tcs; long tc_count; long tc_maxcount; // array mallocated to tc_maxcount
  1224.       obj_face_t *fs; long f_count; long f_maxcount; // array mallocated to f_maxcount
  1225.    } objfile_t;
  1226.  
  1227.    static obj_hashbucket_t hashtable[256];
  1228.    objfile_t obj;
  1229.    obj_hashbucket_t *hash;
  1230.    obj_face_t *f;
  1231.    vertex_t *vertices; // mallocated
  1232.    unsigned long *indices; // mallocated
  1233.    vertex_t *current_vertex;
  1234.    unsigned long file_size;
  1235.    char *filedata; // mallocated
  1236.    char *fileptr;
  1237.    int vertex_index;
  1238.    int array_index;
  1239.    void *ptr_to;
  1240.    FILE *fp;
  1241.  
  1242.    // open the mesh file and read it as a whole
  1243.    _wfopen_s (&fp, objfile_pathname, L"rb");
  1244.    if (fp == NULL)
  1245.       return (false); // bomb out on error
  1246.    fseek (fp, 0, SEEK_END); // seek at end of file...
  1247.    file_size = ftell (fp); // ...read file length...
  1248.    fseek (fp, 0, SEEK_SET); // and rewind
  1249.    filedata = (char *) SAFE_malloc (file_size, sizeof (char), false); // mallocate space for data
  1250.    fread (filedata, file_size, 1, fp); // read file as a whole
  1251.    fclose (fp); // file is read, close it
  1252.  
  1253.    // allocate space for an arbitrary amount of vertices, texture coordinates, normals and faces
  1254.    memset (&obj, 0, sizeof (obj));
  1255.    obj.v_maxcount = 10000; obj.vs = (vector_t *) SAFE_malloc (obj.v_maxcount, sizeof (vector_t), false);
  1256.    obj.n_maxcount = 10000; obj.ns = (vector_t *) SAFE_malloc (obj.n_maxcount, sizeof (vector_t), false);
  1257.    obj.tc_maxcount = 10000; obj.tcs = (texcoord_t *) SAFE_malloc (obj.tc_maxcount, sizeof (texcoord_t), false);
  1258.    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 !)
  1259.  
  1260.    // read file line per line...
  1261.    fileptr = filedata - 1; // start parsing line after line
  1262.    while (fileptr != NULL)
  1263.    {
  1264.       fileptr++; // skip the line feed (or reach the first character, if it's the first pass)
  1265.  
  1266.       // is it a vertex-related line ?
  1267.       if (fileptr[0] == L'v')
  1268.       {
  1269.          // is it a vertex, a normal or a texture coordinate ?
  1270.          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))
  1271.             OBJ_INCREASE_OR_RESIZE (obj.v_count, obj.v_maxcount, 10000, obj.vs, vector_t, false) // one vertex more has been read
  1272.          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))
  1273.             OBJ_INCREASE_OR_RESIZE (obj.n_count, obj.n_maxcount, 10000, obj.ns, vector_t, false) // one normal more has been read
  1274.          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))
  1275.             OBJ_INCREASE_OR_RESIZE (obj.tc_count, obj.tc_maxcount, 10000, obj.tcs, texcoord_t, false) // one texture coordinate more has been read
  1276.       }
  1277.  
  1278.       // else is it a face-related line ?
  1279.       else if (fileptr[0] == L'f')
  1280.       {
  1281.          // get a quick pointer to current face (note: it's been already blanked out by malloc())
  1282.          f = &obj.fs[obj.f_count];
  1283.  
  1284.          // is it a face with normals, a face without normals or a face without normals and texture coordinates ?
  1285.          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)
  1286.              || (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)
  1287.              || (sscanf_s (&fileptr[2], "%d %d %d", &f->v3.iv, &f->v2.iv, &f->v3.iv) == 6))
  1288.          {
  1289.             OBJ_CONVERT_INDEX (f->v1.iv, obj.v_count);
  1290.             OBJ_CONVERT_INDEX (f->v1.in, obj.n_count); // if no normal could be read, its index will be converted from 0 to -1
  1291.             OBJ_CONVERT_INDEX (f->v1.itc, obj.tc_count); // if no texcoord could be read, its index will be converted from 0 to -1
  1292.             OBJ_CONVERT_INDEX (f->v2.iv, obj.v_count);
  1293.             OBJ_CONVERT_INDEX (f->v2.in, obj.n_count); // if no normal could be read, its index will be converted from 0 to -1
  1294.             OBJ_CONVERT_INDEX (f->v2.itc, obj.tc_count); // if no texcoord could be read, its index will be converted from 0 to -1
  1295.             OBJ_CONVERT_INDEX (f->v3.iv, obj.v_count);
  1296.             OBJ_CONVERT_INDEX (f->v3.in, obj.n_count); // if no normal could be read, its index will be converted from 0 to -1
  1297.             OBJ_CONVERT_INDEX (f->v3.itc, obj.tc_count); // if no texcoord could be read, its index will be converted from 0 to -1
  1298.             OBJ_INCREASE_OR_RESIZE (obj.f_count, obj.f_maxcount, 5000, obj.fs, obj_face_t, true) // one face more has been read
  1299.          }
  1300.       }
  1301.  
  1302.       fileptr = strchr (fileptr, '\n'); // proceed to next line
  1303.    }
  1304.  
  1305.    // now build our final vertex and index list
  1306.    vertices = (vertex_t *) SAFE_malloc (3 * obj.f_count, sizeof (vertex_t), false); // mallocate for the max number of vertices we can have
  1307.    indices = (unsigned long *) SAFE_malloc (3 * obj.f_count, sizeof (unsigned long), false); // mallocate for the right amount of indices
  1308.  
  1309.    // t3h mighty l00p ^^ (builds vertex and index buffers)
  1310.    memset (hashtable, 0, sizeof (hashtable)); // wipe out the hashtable
  1311.    mesh->vertice_count = 0; // start with an unoptimized list
  1312.    for (array_index = 0; array_index < obj.f_count; array_index++)
  1313.    {
  1314.       f = &obj.fs[array_index]; // quick access to current face
  1315.       OBJ_GET_EXISTING_INDEX_OR_APPEND_VERTEX (f->v1);
  1316.       indices[3 * array_index + 0] = vertex_index;
  1317.       OBJ_GET_EXISTING_INDEX_OR_APPEND_VERTEX (f->v2);
  1318.       indices[3 * array_index + 1] = vertex_index;
  1319.       OBJ_GET_EXISTING_INDEX_OR_APPEND_VERTEX (f->v3);
  1320.       indices[3 * array_index + 2] = vertex_index;
  1321.    }
  1322.  
  1323.    // now create a correctly-sized DirectX vertex buffer and populate it
  1324.    mesh->vertex_format = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1;
  1325.    mesh->vertice_size = sizeof (vertex_t);
  1326.    d3ddev->CreateVertexBuffer (mesh->vertice_count * mesh->vertice_size, // length
  1327.                                D3DUSAGE_DYNAMIC, // usage
  1328.                                mesh->vertex_format, // vertex format
  1329.                                D3DPOOL_DEFAULT, // pool type
  1330.                                &mesh->d3dvertices, // pointer to the vertex buffer pointer
  1331.                                NULL); // shared handle
  1332.    mesh->d3dvertices->Lock (0, mesh->vertice_count * mesh->vertice_size, &ptr_to, D3DLOCK_DISCARD);
  1333.    memcpy (ptr_to, vertices, mesh->vertice_count * mesh->vertice_size);
  1334.    mesh->d3dvertices->Unlock ();
  1335.  
  1336.    // create a correctly-sized DirectX index buffer and populate it
  1337.    mesh->is_indexed = true; // remember that we're building an index buffer
  1338.    mesh->indice_count = obj.f_count * 3;
  1339.    mesh->indice_size = (mesh->indice_count <= (int) USHRT_MAX ? 2 : 4);
  1340.    d3ddev->CreateIndexBuffer (mesh->indice_count * mesh->indice_size, // length
  1341.                               D3DUSAGE_DYNAMIC, // usage
  1342.                               (mesh->indice_size == 2 ? D3DFMT_INDEX16 : D3DFMT_INDEX32), // format (here, 16 or 32-bit)
  1343.                               D3DPOOL_DEFAULT, // pool type
  1344.                               &mesh->d3dindices, // pointer to the index buffer pointer
  1345.                               NULL); // shared handle
  1346.    mesh->d3dindices->Lock (0, mesh->indice_count * mesh->indice_size, &ptr_to, D3DLOCK_DISCARD);
  1347.    if (mesh->indice_size == 2)
  1348.       for (array_index = 0; array_index < mesh->indice_count; array_index++)
  1349.          ((unsigned short *) ptr_to)[array_index] = (unsigned short) indices[array_index];
  1350.    else
  1351.       memcpy (ptr_to, indices, mesh->indice_count * mesh->indice_size);
  1352.    mesh->d3dindices->Unlock ();
  1353.  
  1354.    // finished, free the temporary objects
  1355.    for (array_index = 0; array_index < sizeof (hashtable) / sizeof (obj_hashbucket_t); array_index++)
  1356.       SAFE_free ((void **) &hashtable[array_index].indices);
  1357.    SAFE_free ((void **) &indices);
  1358.    SAFE_free ((void **) &vertices);
  1359.    SAFE_free ((void **) &obj.vs);
  1360.    SAFE_free ((void **) &obj.ns);
  1361.    SAFE_free ((void **) &obj.tcs);
  1362.    SAFE_free ((void **) &obj.fs);
  1363.    SAFE_free ((void **) &filedata);
  1364.  
  1365.    return (true); // Wavefront Object successfully loaded, return TRUE
  1366.  
  1367.    #undef OBJ_GET_EXISTING_INDEX_OR_APPEND_VERTEX
  1368.    #undef OBJ_CONVERT_INDEX
  1369.    #undef OBJ_INCREASE_OR_RESIZE
  1370. }
  1371.  
  1372.  
  1373. static void Render_DrawSceneObjectReflection (sceneobject_t *sceneobject)
  1374. {
  1375.    // fast helper to draw a mesh at a specified location with certain pitch and yaw angles
  1376.  
  1377.    D3DXMATRIX rotation_matrix;
  1378.    D3DXMATRIX translation_matrix;
  1379.    D3DXMATRIX reflect_matrix;
  1380.    D3DXMATRIX scaling_matrix;
  1381.    material_t *material;
  1382.    D3DMATERIAL9 d3dmaterial;
  1383.    D3DXPLANE plane;
  1384.    mesh_t *mesh;
  1385.    mesh_t *tile_mesh;
  1386.    float alpha;
  1387.  
  1388.    // draw the reflection below this mesh
  1389.  
  1390.    // quick access to meshes
  1391.    mesh = &meshes[sceneobject->mesh_index];
  1392.    tile_mesh = &meshes[theme->tile_meshindex];
  1393.  
  1394.    // set the world transform at location
  1395.    D3DXPlaneFromPointNormal (&plane, (D3DXVECTOR3 *) &scene_lookatpoint, (D3DXVECTOR3 *) &upwards_direction);
  1396.    D3DXMatrixReflect (&reflect_matrix, &plane);
  1397.    D3DXMatrixRotationYawPitchRoll (&rotation_matrix, -sceneobject->pitch * TO_RADIANS, 0.0f, -sceneobject->yaw * TO_RADIANS);
  1398.    D3DXMatrixTranslation (&translation_matrix, sceneobject->x, sceneobject->y, -sceneobject->z);
  1399.    D3DXMatrixScaling (&scaling_matrix, sceneobject->scale, sceneobject->scale, 1.0f);
  1400.  
  1401.    // tell Direct3D about our matrix
  1402.    d3ddev->SetTransform (D3DTS_WORLD, &(reflect_matrix * scaling_matrix * rotation_matrix * translation_matrix));
  1403.  
  1404.    d3ddev->SetRenderState (D3DRS_STENCILENABLE, true); // enable the stencil buffer
  1405.    d3ddev->SetRenderState (D3DRS_STENCILFUNC, D3DCMP_LESS); // instruct how to fill the stencil buffer
  1406.    d3ddev->SetRenderState (D3DRS_STENCILPASS, D3DSTENCILOP_KEEP); // instruct how to fill the stencil buffer
  1407.  
  1408.    // set the texture for this mesh
  1409.    if (sceneobject->texture_index != -1)
  1410.       d3ddev->SetTexture (0, textures[sceneobject->texture_index].texture);
  1411.    else
  1412.       d3ddev->SetTexture (0, NULL);
  1413.  
  1414.    // adjust the light reflection properties by setting the material
  1415.    if (sceneobject->material_index != -1)
  1416.       material = &materials[sceneobject->material_index]; // use the specified scene object material
  1417.    else
  1418.       material = &materials[material_count - 1]; // scene object material unspecified, use default material
  1419.    alpha = theme->reflection_alpha / 256.0f;
  1420.    d3dmaterial.Ambient = D3DXCOLOR (material->ambient, material->ambient, material->ambient, material->transparency * alpha); // Alpha value not used according to SDK
  1421.    d3dmaterial.Diffuse = D3DXCOLOR (material->diffuse, material->diffuse, material->diffuse, material->transparency * alpha);
  1422.    d3dmaterial.Emissive = D3DXCOLOR (material->emissive, material->emissive, material->emissive, material->transparency * alpha); // Alpha value not used according to SDK
  1423.    d3dmaterial.Specular = D3DXCOLOR (material->specular, material->specular, material->specular, material->transparency * alpha); // Alpha value not used according to SDK
  1424.    d3dmaterial.Power = material->shininess;
  1425.    d3ddev->SetMaterial (&d3dmaterial);
  1426.  
  1427.    // draw the mesh subset
  1428.    d3ddev->SetStreamSource (0, mesh->d3dvertices, 0, sizeof (vertex_t));
  1429.    d3ddev->SetFVF (mesh->vertex_format);
  1430.    d3ddev->SetRenderState (D3DRS_CULLMODE, D3DCULL_CW); // draw the faces backwards
  1431.    if (mesh->is_indexed)
  1432.    {
  1433.       d3ddev->SetIndices (mesh->d3dindices);
  1434.       d3ddev->DrawIndexedPrimitive (D3DPT_TRIANGLELIST, 0, 0, mesh->vertice_count, 0, mesh->indice_count / 3);
  1435.    }
  1436.    else
  1437.       d3ddev->DrawPrimitive (D3DPT_TRIANGLELIST, 0, mesh->vertice_count / 3);
  1438.  
  1439.    d3ddev->SetRenderState (D3DRS_STENCILENABLE, false); // and disable the stencil buffer
  1440.  
  1441.    // now draw the simple shadow below this mesh
  1442.  
  1443.    // grab the tools we need in hand
  1444.    d3ddev->SetRenderState (D3DRS_ZENABLE, false); // disable the Z buffer
  1445.    d3ddev->SetRenderState (D3DRS_AMBIENT, D3DCOLOR_XRGB (255, 255, 255)); // raise ambient light
  1446.  
  1447.    // position the simple shadow sprite
  1448.    D3DXMatrixScaling (&scaling_matrix, max (sceneobject->simpleshadow_size, sceneobject->z / 5.0f), max (sceneobject->simpleshadow_size, sceneobject->z / 5.0f), 0.0f);
  1449.    D3DXMatrixTranslation (&translation_matrix, sceneobject->x, sceneobject->y, 0.0f);
  1450.    d3ddev->SetTransform (D3DTS_WORLD, &(scaling_matrix * translation_matrix));
  1451.  
  1452.    // adjust the light reflection properties by setting the material
  1453.    material = &materials[material_count - 1]; // use the default material
  1454.    d3dmaterial.Ambient = D3DXCOLOR (material->ambient, material->ambient, material->ambient, material->transparency);
  1455.    d3dmaterial.Diffuse = D3DXCOLOR (material->diffuse, material->diffuse, material->diffuse, material->transparency);
  1456.    d3dmaterial.Emissive = D3DXCOLOR (material->emissive, material->emissive, material->emissive, material->transparency);
  1457.    d3dmaterial.Specular = D3DXCOLOR (material->specular, material->specular, material->specular, material->transparency);
  1458.    d3dmaterial.Power = material->shininess;
  1459.    d3ddev->SetMaterial (&d3dmaterial);
  1460.  
  1461.    d3ddev->SetTexture (0, textures[theme->shadow_textureindex].texture); // select the texture we want
  1462.  
  1463.    // and then draw it
  1464.    d3ddev->SetStreamSource (0, tile_mesh->d3dvertices, 0, sizeof (vertex_t)); // set stream source
  1465.    d3ddev->SetFVF (tile_mesh->vertex_format); // select which vertex format we are using
  1466.    d3ddev->SetRenderState (D3DRS_CULLMODE, D3DCULL_CW); // draw the faces backwards
  1467.    if (tile_mesh->is_indexed)
  1468.    {
  1469.       d3ddev->SetIndices (tile_mesh->d3dindices);
  1470.       d3ddev->DrawIndexedPrimitive (D3DPT_TRIANGLELIST, 0, 0, tile_mesh->vertice_count, 0, tile_mesh->indice_count / 3);
  1471.    }
  1472.    else
  1473.       d3ddev->DrawPrimitive (D3DPT_TRIANGLELIST, 0, tile_mesh->vertice_count / 3);
  1474.  
  1475.    // finished, reset ambient light to its previous value and enable the Z buffer back
  1476.    d3ddev->SetRenderState (D3DRS_AMBIENT, ambient_light);
  1477.    d3ddev->SetRenderState (D3DRS_ZENABLE, true);
  1478.  
  1479.    return; // finished
  1480. }
  1481.  
  1482.  
  1483. static void Render_DrawSceneObject (sceneobject_t *sceneobject)
  1484. {
  1485.    // fast helper to draw a mesh at a specified location with certain pitch and yaw angles
  1486.  
  1487.    D3DXMATRIX rotation_matrix;
  1488.    D3DXMATRIX translation_matrix;
  1489.    D3DXMATRIX scaling_matrix;
  1490.    material_t *material;
  1491.    D3DMATERIAL9 d3dmaterial;
  1492.    mesh_t *mesh;
  1493.  
  1494.    // is this object a tile (i.e, it has no mesh) ?
  1495.    if (sceneobject->mesh_index == -1)
  1496.    {
  1497.       Render_DrawSceneTile (sceneobject); // then draw it as a tile instead
  1498.       return; // and return
  1499.    }
  1500.  
  1501.    // quick access to mesh
  1502.    mesh = &meshes[sceneobject->mesh_index];
  1503.  
  1504.    // set the world transform at location
  1505.    D3DXMatrixRotationYawPitchRoll (&rotation_matrix, sceneobject->pitch * TO_RADIANS, 0.0f, sceneobject->yaw * TO_RADIANS);
  1506.    D3DXMatrixTranslation (&translation_matrix, sceneobject->x, sceneobject->y, sceneobject->z);
  1507.    D3DXMatrixScaling (&scaling_matrix, sceneobject->scale, sceneobject->scale, 1.0f);
  1508.  
  1509.    // tell Direct3D about our matrix
  1510.    d3ddev->SetTransform (D3DTS_WORLD, &(scaling_matrix * rotation_matrix * translation_matrix));
  1511.  
  1512.    // set the texture for this mesh
  1513.    if (sceneobject->texture_index != -1)
  1514.       d3ddev->SetTexture (0, textures[sceneobject->texture_index].texture);
  1515.    else
  1516.       d3ddev->SetTexture (0, NULL);
  1517.  
  1518.    // adjust the light reflection properties by setting the material
  1519.    if (sceneobject->material_index != -1)
  1520.       material = &materials[sceneobject->material_index];
  1521.    else
  1522.       material = &materials[material_count - 1];
  1523.    d3dmaterial.Ambient = D3DXCOLOR (material->ambient, material->ambient, material->ambient, material->transparency);
  1524.    d3dmaterial.Diffuse = D3DXCOLOR (material->diffuse, material->diffuse, material->diffuse, material->transparency);
  1525.    d3dmaterial.Emissive = D3DXCOLOR (material->emissive, material->emissive, material->emissive, material->transparency);
  1526.    d3dmaterial.Specular = D3DXCOLOR (material->specular, material->specular, material->specular, material->transparency);
  1527.    d3dmaterial.Power = material->shininess;
  1528.    d3ddev->SetMaterial (&d3dmaterial);
  1529.  
  1530.    // draw the mesh subset
  1531.    d3ddev->SetStreamSource (0, mesh->d3dvertices, 0, sizeof (vertex_t));
  1532.    d3ddev->SetFVF (mesh->vertex_format);
  1533.  
  1534.    // is there transparency on this mesh ?
  1535.    if (material->transparency < 1)
  1536.    {
  1537.       d3ddev->SetRenderState (D3DRS_CULLMODE, D3DCULL_CW); // draw the back faces
  1538.       if (mesh->is_indexed)
  1539.       {
  1540.          d3ddev->SetIndices (mesh->d3dindices);
  1541.          d3ddev->DrawIndexedPrimitive (D3DPT_TRIANGLELIST, 0, 0, mesh->vertice_count, 0, mesh->indice_count / 3);
  1542.       }
  1543.       else
  1544.          d3ddev->DrawPrimitive (D3DPT_TRIANGLELIST, 0, mesh->vertice_count / 3);
  1545.    }
  1546.  
  1547.    // now draw the front faces
  1548.    d3ddev->SetRenderState (D3DRS_CULLMODE, D3DCULL_CCW); // draw the front faces
  1549.    if (mesh->is_indexed)
  1550.    {
  1551.       d3ddev->SetIndices (mesh->d3dindices);
  1552.       d3ddev->DrawIndexedPrimitive (D3DPT_TRIANGLELIST, 0, 0, mesh->vertice_count, 0, mesh->indice_count / 3);
  1553.    }
  1554.    else
  1555.       d3ddev->DrawPrimitive (D3DPT_TRIANGLELIST, 0, mesh->vertice_count / 3);
  1556.  
  1557.    return; // finished
  1558. }
  1559.  
  1560.  
  1561. static void Render_DrawSceneTile (sceneobject_t *sceneobject)
  1562. {
  1563.    // fast helper to draw a tile (i.e, an object that doesn't have a mesh) at a specified location
  1564.  
  1565.    D3DXMATRIX rotation_matrix;
  1566.    D3DXMATRIX translation_matrix;
  1567.    D3DXMATRIX scaling_matrix;
  1568.    material_t *material;
  1569.    D3DMATERIAL9 d3dmaterial;
  1570.    mesh_t *tile_mesh;
  1571.  
  1572.    tile_mesh = &meshes[theme->tile_meshindex]; // quick access to tile mesh
  1573.  
  1574.    // grab the tools we need in hand
  1575.    d3ddev->SetRenderState (D3DRS_AMBIENT, D3DCOLOR_RGBA (0xFF, 0xFF, 0xFF, 0xFF)); // raise light
  1576.  
  1577.    // set the world transform at location
  1578.    D3DXMatrixRotationYawPitchRoll (&rotation_matrix, sceneobject->pitch * TO_RADIANS, 0.0f, sceneobject->yaw * TO_RADIANS);
  1579.    D3DXMatrixTranslation (&translation_matrix, sceneobject->x, sceneobject->y, sceneobject->z);
  1580.    D3DXMatrixScaling (&scaling_matrix, sceneobject->scale, sceneobject->scale, 1.0f);
  1581.  
  1582.    // tell Direct3D about our matrix
  1583.    d3ddev->SetTransform (D3DTS_WORLD, &(scaling_matrix * rotation_matrix * translation_matrix));
  1584.  
  1585.    // adjust the light reflection properties by setting the material
  1586.    material = &materials[material_count - 1]; // use the default material for tiles
  1587.    d3dmaterial.Ambient = D3DXCOLOR (material->ambient, material->ambient, material->ambient, material->ambient);
  1588.    d3dmaterial.Diffuse = D3DXCOLOR (material->diffuse, material->diffuse, material->diffuse, material->diffuse);
  1589.    d3dmaterial.Emissive = D3DXCOLOR (material->emissive, material->emissive, material->emissive, material->emissive);
  1590.    d3dmaterial.Specular = D3DXCOLOR (material->specular, material->specular, material->specular, material->specular);
  1591.    d3dmaterial.Power = material->shininess;
  1592.    d3ddev->SetMaterial (&d3dmaterial);
  1593.  
  1594.    // select the texture we want
  1595.    d3ddev->SetTexture (0, textures[sceneobject->texture_index].texture);
  1596.  
  1597.    // and then draw it
  1598.    d3ddev->SetStreamSource (0, tile_mesh->d3dvertices, 0, sizeof (vertex_t)); // set stream source
  1599.    d3ddev->SetFVF (tile_mesh->vertex_format); // select which vertex format we are using
  1600.    d3ddev->SetRenderState (D3DRS_CULLMODE, D3DCULL_CW); // draw the back faces
  1601.    if (tile_mesh->is_indexed)
  1602.    {
  1603.       d3ddev->SetIndices (tile_mesh->d3dindices);
  1604.       d3ddev->DrawIndexedPrimitive (D3DPT_TRIANGLELIST, 0, 0, tile_mesh->vertice_count, 0, tile_mesh->indice_count / 3);
  1605.    }
  1606.    else
  1607.       d3ddev->DrawPrimitive (D3DPT_TRIANGLELIST, 0, tile_mesh->vertice_count / 3);
  1608.  
  1609.    // finished, reset ambient light to its previous value
  1610.    d3ddev->SetRenderState (D3DRS_AMBIENT, ambient_light);
  1611.  
  1612.    return; // finished
  1613. }
  1614.  
  1615.  
  1616. static void Render_DrawSprite (sprite_t *sprite, float x_percent, float y_percent, float width_percent, float height_percent, int alpha)
  1617. {
  1618.    // fast helper to draw a sprite at a specified location with certain parameters
  1619.  
  1620.    D3DXMATRIX scaling_matrix;
  1621.    texture_t *texture;
  1622.    float scale_x;
  1623.    float scale_y;
  1624.  
  1625.    texture = &textures[sprite->texture_index]; // quick access to sprite's texture
  1626.  
  1627.    scale_x = (width_percent * (float) initial_width) / (float) (100 * texture->width);
  1628.    scale_y = (height_percent * (float) initial_height) / (float) (100 * texture->height);
  1629.  
  1630.    // start rendering the sprite (an optimized version would draw all sprites in a row...)
  1631.    sprite->sprite->Begin (D3DXSPRITE_ALPHABLEND);
  1632.  
  1633.    // scale and position the sprite
  1634.    D3DXMatrixTransformation2D (&scaling_matrix, // output matrix
  1635.                                NULL, // scaling center
  1636.                                0.0f, // scaling rotation
  1637.                                &D3DXVECTOR2 (scale_x, scale_y), // scaling ratio
  1638.                                &D3DXVECTOR2 (0, 0), // rotation center
  1639.                                0.0f, // rotation
  1640.                                &D3DXVECTOR2 (x_percent * (float) initial_width / 100.0f, y_percent * (float) initial_height / 100.0f)); // translation
  1641.    sprite->sprite->SetTransform (&scaling_matrix); // tell the sprite about the scaling and position transform
  1642.  
  1643.    // now draw the sprite with the specified alpha and finish rendering
  1644.    sprite->sprite->Draw (texture->texture, NULL, NULL, NULL, D3DCOLOR_ARGB (alpha, 255, 255, 255));
  1645.    sprite->sprite->End ();
  1646.  
  1647.    return; // finished
  1648. }
  1649.  
  1650.  
  1651. static void Render_GetTextBoundaries (float maxwidth_percent, int font_id, wchar_t *text, RECT *rect)
  1652. {
  1653.    // this function computes and returns the size of the rectangle the specified text will fit into. Note that text may be modified
  1654.    // to insert new lines if it doesn't fit in a single line.
  1655.  
  1656.    int char_index;
  1657.    int length;
  1658.    int optimal_length;
  1659.    bool have_split;
  1660.    int max_width;
  1661.  
  1662.    // blank out the output rectangle
  1663.    memset (rect, 0, sizeof (RECT));
  1664.  
  1665.    // ask direct3D to compute the text size a first time
  1666.    fonts[font_id].font->DrawText (NULL, text, -1, rect, DT_CALCRECT, D3DCOLOR (0));
  1667.  
  1668.    // if max width is not set, set it to viewport width
  1669.    if (maxwidth_percent <= 0)
  1670.       max_width = initial_width; // then use it to compute the real max width
  1671.    else
  1672.       max_width = (int) ((maxwidth_percent * (float) initial_width) / 100.0f); // else if specified, convert this percentage to an absolute pixel width
  1673.  
  1674.    // do we need more than one line ?
  1675.    if (rect->right > max_width)
  1676.    {
  1677.       // see how many lines we need and compute the optimal length of one line
  1678.       length = wcslen (text);
  1679.       optimal_length = length / (1 + rect->right / (int) max_width);
  1680.       have_split = false;
  1681.       for (char_index = optimal_length; char_index < length; char_index++)
  1682.          if (iswspace (text[char_index]))
  1683.          {
  1684.             text[char_index] = L'\n'; // interpolate linefeeds into string
  1685.             have_split = true; // remember string has been split
  1686.             char_index += optimal_length;
  1687.          }
  1688.  
  1689.       // and ask direct3D to compute the text size again
  1690.       fonts[font_id].font->DrawText (NULL, text, -1, rect, DT_CALCRECT, D3DCOLOR (0));
  1691.    }
  1692.  
  1693.    return; // finished
  1694. }
  1695.  
  1696.  
  1697. 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, ...)
  1698. {
  1699.    // this function displays text on the Direct3D interface according to the given parameters. X and Y are the base coordinates of
  1700.    // the text's bounding rectangle. Max_width is the maximum allowed width of this rectangle before wrapping words on a new line.
  1701.    // Horiz_align and vert_align are the alignment parameters of the RECTANGLE relatively to X and Y. Text_align is the alignment of
  1702.    // the TEXT inside this rectangle (meaning, you can have right-aligned text in a rectangle that is centered on a point). Font_id
  1703.    // 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
  1704.    // bounding rectangle, after any word wrapping corrections have been made. Fmt is a format string containing the text itself,
  1705.    // printf-style.
  1706.  
  1707.    va_list argptr;
  1708.    RECT rect;
  1709.    int left;
  1710.    int top;
  1711.    int x;
  1712.    int y;
  1713.  
  1714.    // concatenate all the arguments in one string
  1715.    va_start (argptr, fmt);
  1716.    wvsprintf (printf_buffer, fmt, argptr);
  1717.    va_end (argptr);
  1718.  
  1719.    // translate percent coordinates into absolute coordinates
  1720.    x = (int) ((x_percent * (float) initial_width) / 100.0f);
  1721.    y = (int) ((y_percent * (float) initial_height) / 100.0f);
  1722.  
  1723.    // get the text boundaries
  1724.    Render_GetTextBoundaries (maxwidth_percent, font_id, printf_buffer, &rect);
  1725.  
  1726.    // horizontal alignment
  1727.    if (horiz_align == ALIGN_LEFT)
  1728.       left = x;
  1729.    else if (horiz_align == ALIGN_RIGHT)
  1730.       left = x - rect.right;
  1731.    else
  1732.       left = x - rect.right / 2;
  1733.  
  1734.    // vertical alignment
  1735.    if (vert_align == ALIGN_TOP)
  1736.       top = y;
  1737.    else if (vert_align == ALIGN_BOTTOM)
  1738.       top = y - rect.bottom;
  1739.    else
  1740.       top = y - rect.bottom / 2;
  1741.  
  1742.    // now reposition our rectangle correctly acording to alignment
  1743.    OffsetRect (&rect, left, top);
  1744.  
  1745.    // and draw the text
  1746.    if (text_align == ALIGN_LEFT)
  1747.       fonts[font_id].font->DrawText (NULL, printf_buffer, -1, &rect, DT_LEFT, RGBACOLOR_TO_ARGBCOLOR (color_rgba));
  1748.    else if (horiz_align == ALIGN_RIGHT)
  1749.       fonts[font_id].font->DrawText (NULL, printf_buffer, -1, &rect, DT_RIGHT, RGBACOLOR_TO_ARGBCOLOR (color_rgba));
  1750.    else
  1751.       fonts[font_id].font->DrawText (NULL, printf_buffer, -1, &rect, DT_CENTER, RGBACOLOR_TO_ARGBCOLOR (color_rgba));
  1752.  
  1753.    // do we want the output rectangle ?
  1754.    if (out_rect != NULL)
  1755.       memcpy (out_rect, &rect, sizeof (rect)); // if so, copy it in the given variable
  1756.  
  1757.    return; // finished
  1758. }
  1759.  
  1760.  
  1761. static float DistanceToCamera (float x, float y, float z)
  1762. {
  1763.    // this function computes the distance of the point at coordinates x,y,z to the camera
  1764.  
  1765.    vector_t displacement;
  1766.  
  1767.    // compute displacement...
  1768.    displacement.x = x - camera_position.x;
  1769.    displacement.y = y - camera_position.y;
  1770.    displacement.z = z - camera_position.z;
  1771.  
  1772.    // ...and then Pythagores in 3D
  1773.    return (sqrtf (displacement.x * displacement.x + displacement.y * displacement.y + displacement.z * displacement.z));
  1774. }
  1775.  
  1776.  
  1777. static float FadeFloat (float from, float to, float start_time, float end_time)
  1778. {
  1779.    // helper function to return a progressive variation between from and to based on time
  1780.  
  1781.    if (end_time < current_time)
  1782.       return (to);
  1783.  
  1784.    //      base + (variation) * (               fraction of completion               )
  1785.    return (from + (to - from) * (current_time - start_time) / (end_time - start_time));
  1786. }
  1787.  
  1788.  
  1789. static unsigned long HashString (const wchar_t *string_buffer)
  1790. {
  1791.    // super fast string hash function, code courtesy of
  1792.    // http://www.azillionmonkeys.com/qed/hash.html
  1793.  
  1794.    unsigned long length;
  1795.    unsigned long hash;
  1796.    unsigned long tmp;
  1797.    int remaining;
  1798.  
  1799.    // first, get the string length and start with this as a hash value
  1800.    length = wcslen (string_buffer) * sizeof (wchar_t);
  1801.    hash = length;
  1802.  
  1803.    // figure out how many bytes there will remain after 32-bit processing
  1804.    remaining = length & 3;
  1805.    length >>= 2;
  1806.  
  1807.    // main loop, process 32-bit blocks
  1808.    for ( ; length > 0; length--)
  1809.    {
  1810.       hash += *((const unsigned short *) string_buffer);
  1811.       tmp = ((*((const unsigned short *) (string_buffer + 2))) << 11) ^ hash;
  1812.       hash = (hash << 16) ^ tmp;
  1813.       string_buffer += 2 * sizeof (unsigned short);
  1814.       hash += hash >> 11;
  1815.    }
  1816.  
  1817.    // handle the remaining bytes
  1818.    if (remaining == 3)
  1819.    {
  1820.       hash += *((const unsigned short *) string_buffer);
  1821.       hash ^= hash << 16;
  1822.       hash ^= string_buffer[sizeof (unsigned short)] << 18;
  1823.       hash += hash >> 11;
  1824.    }
  1825.    else if (remaining == 2)
  1826.    {
  1827.       hash += *((const unsigned short *) string_buffer);
  1828.       hash ^= hash << 11;
  1829.       hash += hash >> 17;
  1830.    }
  1831.    else if (remaining == 1)
  1832.    {
  1833.       hash += *string_buffer;
  1834.       hash ^= hash << 10;
  1835.       hash += hash >> 1;
  1836.    }
  1837.  
  1838.    // force "avalanching" of final 127 bits
  1839.    hash ^= hash << 3;
  1840.    hash += hash >> 5;
  1841.    hash ^= hash << 4;
  1842.    hash += hash >> 17;
  1843.    hash ^= hash << 25;
  1844.    hash += hash >> 6;
  1845.  
  1846.    return (hash); // finished, return the hash value
  1847. }
  1848.  
  1849.  
  1850. static unsigned long HashFile (const wchar_t *file_pathname)
  1851. {
  1852.    // super fast file content pseudo-hash function
  1853.  
  1854.    unsigned short value;
  1855.    unsigned long file_size;
  1856.    FILE *fp;
  1857.  
  1858.    // open the file
  1859.    _wfopen_s (&fp, file_pathname, L"rb");
  1860.    if (fp == NULL)
  1861.       return ((unsigned long) time (NULL)); // if file can't be open, return a random number
  1862.  
  1863.    // seek at end of file, read file size, and rewind
  1864.    fseek (fp, 0, SEEK_END);
  1865.    file_size = ftell (fp);
  1866.    fseek (fp, 0, SEEK_SET);
  1867.  
  1868.    // seek at 2/3 of file size (if file is small enough, return only its content)
  1869.    if (file_size >= 4)
  1870.    {
  1871.       fseek (fp, file_size * 2 / 3, SEEK_SET); // seek at 2/3 of file
  1872.       fread (&value, 2, 1, fp); // and read a word here
  1873.    }
  1874.    else if (file_size >= 2)
  1875.       fread (&value, 2, 1, fp);
  1876.    else if (file_size == 1)
  1877.       value = fgetc (fp);
  1878.    else
  1879.       value = 0;
  1880.  
  1881.    // finished, close the file
  1882.    fclose (fp);
  1883.  
  1884.    // and return a hash composed of the 16 lower bits of the file size and the value we read
  1885.    return ((unsigned long) (file_size << 16) | (unsigned long) value);
  1886. }
  1887.  
  1888.  
  1889. static void ResolveWildcard (wchar_t *file_pathname, wchar_t *extensions_separated_by_bars)
  1890. {
  1891.    // this function resolves a pathname ending with .* by testing with various possible
  1892.    // file extensions until one of the files formed that way is found to exist.
  1893.  
  1894.    static wchar_t extension_list[256]; // needs to be modifiable for strtok()
  1895.    wchar_t *current_extension;
  1896.    wchar_t *wcstok_context;
  1897.    int length;
  1898.  
  1899.    wcscpy_s (extension_list, WCHAR_SIZEOF (extension_list), extensions_separated_by_bars);
  1900.    length = wcslen (file_pathname); // get pathname length
  1901.  
  1902.    // does the pathname we want NOT end with a wildcard ?
  1903.    if ((length < 2) || (wcscmp (&file_pathname[length - 2], L".*") != 0))
  1904.       return; // no need to resolve anything
  1905.  
  1906.    // test each extension and see if a corresponding file exists
  1907.    current_extension = wcstok_s (extension_list, L"|", &wcstok_context);
  1908.    while (current_extension != NULL)
  1909.    {
  1910.       if (*current_extension == L'.')
  1911.          current_extension++; // if current extension starts with a dot, skip it
  1912.  
  1913.       wcscpy_s (&file_pathname[length - 1], wcslen (current_extension) + 1, current_extension);
  1914.       if (_waccess (file_pathname, 0) == 0)
  1915.          return; // found a file with this extension
  1916.       current_extension = wcstok_s (NULL, L"|", &wcstok_context);
  1917.    }
  1918.  
  1919.    wcscpy_s (&file_pathname[length - 1], 2, L"*");
  1920.    return; // if none of these extensions match, put the wildcard back and return
  1921. }
  1922.  
  1923.  
  1924. static int SortReflectedObjects (const void *object1, const void *object2)
  1925. {
  1926.    // callback function used by qsort() when sorting the reflected objects according to their distance to the viewer
  1927.  
  1928.    return ((int) (1000.0f * (((reflectedobject_t *) object2)->distance - ((reflectedobject_t *) object1)->distance)));
  1929. }
  1930.