dll/directx/wine/d3d8/d3d8_main.c

   1 /*
   2  * Direct3D 8
   3  *
   4  * Copyright 2005 Oliver Stieber
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  */
  21
  22 #include "d3d8_private.h"
  23
  24 HRESULT WINAPI D3D8GetSWInfo(void) {
  25     FIXME("(void): stub\n");
  26     return 0;
  27 }
  28
  29 void WINAPI DebugSetMute(void) {
  30     /* nothing to do */
  31 }
  32
  33 IDirect3D8 * WINAPI DECLSPEC_HOTPATCH Direct3DCreate8(UINT sdk_version)
  34 {
  35     struct d3d8 *object;
  36
  37     TRACE("sdk_version %#x.\n", sdk_version);
  38
  39     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
  40         return NULL;
  41
  42     if (!d3d8_init(object))
  43     {
  44         WARN("Failed to initialize d3d8.\n");
  45         HeapFree(GetProcessHeap(), 0, object);
  46         return NULL;
  47     }
  48
  49     TRACE("Created d3d8 object %p.\n", object);
  50
  51     return &object->IDirect3D8_iface;
  52 }
  53
  54 /* At process attach */
  55 BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, void *reserved)
  56 {
  57     if (reason == DLL_PROCESS_ATTACH)
  58         DisableThreadLibraryCalls(inst);
  59
  60     return TRUE;
  61 }
  62
  63 /***********************************************************************
  64  *              ValidateVertexShader (D3D8.@)
  65  *
  66  * I've seen reserved1 and reserved2 always passed as 0's
  67  * bool seems always passed as 0 or 1, but other values work as well...
  68  * toto       result?
  69  */
  70 HRESULT WINAPI ValidateVertexShader(DWORD* vertexshader, DWORD* reserved1, DWORD* reserved2, BOOL bool, DWORD* toto)
  71 {
  72   HRESULT ret;
  73   static BOOL warned;
  74
  75   if (TRACE_ON(d3d8) || !warned) {
  76       FIXME("(%p %p %p %d %p): stub\n", vertexshader, reserved1, reserved2, bool, toto);
  77       warned = TRUE;
  78   }
  79
  80   if (!vertexshader)
  81       return E_FAIL;
  82
  83   if (reserved1 || reserved2)
  84       return E_FAIL;
  85
  86   switch(*vertexshader) {
  87         case 0xFFFE0101:
  88         case 0xFFFE0100:
  89             ret=S_OK;
  90             break;
  91         default:
  92             WARN("Invalid shader version token %#x.\n", *vertexshader);
  93             ret=E_FAIL;
  94         }
  95
  96   return ret;
  97 }
  98
  99 /***********************************************************************
 100  *              ValidatePixelShader (D3D8.@)
 101  *
 102  * PARAMS
 103  * toto       result?
 104  */
 105 HRESULT WINAPI ValidatePixelShader(DWORD* pixelshader, DWORD* reserved1, BOOL bool, DWORD* toto)
 106 {
 107   HRESULT ret;
 108   static BOOL warned;
 109
 110   if (TRACE_ON(d3d8) || !warned) {
 111       FIXME("(%p %p %d %p): stub\n", pixelshader, reserved1, bool, toto);
 112       warned = TRUE;
 113   }
 114
 115   if (!pixelshader)
 116       return E_FAIL;
 117
 118   if (reserved1)
 119       return E_FAIL;
 120
 121   switch(*pixelshader) {
 122         case 0xFFFF0100:
 123         case 0xFFFF0101:
 124         case 0xFFFF0102:
 125         case 0xFFFF0103:
 126         case 0xFFFF0104:
 127             ret=S_OK;
 128             break;
 129         default:
 130             WARN("Invalid shader version token %#x.\n", *pixelshader);
 131             ret=E_FAIL;
 132         }
 133   return ret;
 134 }
 135
 136 void d3d8_resource_cleanup(struct d3d8_resource *resource)
 137 {
 138     wined3d_private_store_cleanup(&resource->private_store);
 139 }
 140
 141 HRESULT d3d8_resource_free_private_data(struct d3d8_resource *resource, const GUID *guid)
 142 {
 143     struct wined3d_private_data *entry;
 144
 145     wined3d_mutex_lock();
 146     entry = wined3d_private_store_get_private_data(&resource->private_store, guid);
 147     if (!entry)
 148     {
 149         wined3d_mutex_unlock();
 150         return D3DERR_NOTFOUND;
 151     }
 152
 153     wined3d_private_store_free_private_data(&resource->private_store, entry);
 154     wined3d_mutex_unlock();
 155
 156     return D3D_OK;
 157 }
 158
 159 HRESULT d3d8_resource_get_private_data(struct d3d8_resource *resource, const GUID *guid,
 160         void *data, DWORD *data_size)
 161 {
 162     const struct wined3d_private_data *stored_data;
 163     DWORD size_in;
 164     HRESULT hr;
 165
 166     wined3d_mutex_lock();
 167     stored_data = wined3d_private_store_get_private_data(&resource->private_store, guid);
 168     if (!stored_data)
 169     {
 170         hr = D3DERR_NOTFOUND;
 171         goto done;
 172     }
 173
 174     size_in = *data_size;
 175     *data_size = stored_data->size;
 176     if (!data)
 177     {
 178         hr = D3D_OK;
 179         goto done;
 180     }
 181     if (size_in < stored_data->size)
 182     {
 183         hr = D3DERR_MOREDATA;
 184         goto done;
 185     }
 186
 187     if (stored_data->flags & WINED3DSPD_IUNKNOWN)
 188         IUnknown_AddRef(stored_data->content.object);
 189     memcpy(data, stored_data->content.data, stored_data->size);
 190     hr = D3D_OK;
 191
 192 done:
 193     wined3d_mutex_unlock();
 194     return hr;
 195 }
 196
 197 void d3d8_resource_init(struct d3d8_resource *resource)
 198 {
 199     resource->refcount = 1;
 200     wined3d_private_store_init(&resource->private_store);
 201 }
 202
 203 HRESULT d3d8_resource_set_private_data(struct d3d8_resource *resource, const GUID *guid,
 204         const void *data, DWORD data_size, DWORD flags)
 205 {
 206     HRESULT hr;
 207
 208     wined3d_mutex_lock();
 209     hr = wined3d_private_store_set_private_data(&resource->private_store, guid, data, data_size, flags);
 210     wined3d_mutex_unlock();
 211     return hr;
 212 }