?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Improve detection of device palette change.
[wine.git] / dlls / wined3d / device.c
blob76ab604a0d702bfcfd357bff13d60a64c900b0a3
1 /*
2 * IWineD3DDevice implementation
3 *
4 * Copyright 2002 Lionel Ulmer
5 * Copyright 2002-2005 Jason Edmeades
6 * Copyright 2003-2004 Raphael Junqueira
7 * Copyright 2004 Christian Costa
8 * Copyright 2005 Oliver Stieber
9 * Copyright 2006-2008 Stefan Dösinger for CodeWeavers
10 * Copyright 2006-2007 Henri Verbeet
11 * Copyright 2007 Andrew Riedi
12 *
13 * This library is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU Lesser General Public
15 * License as published by the Free Software Foundation; either
16 * version 2.1 of the License, or (at your option) any later version.
17 *
18 * This library is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * Lesser General Public License for more details.
22 *
23 * You should have received a copy of the GNU Lesser General Public
24 * License along with this library; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 */
27
28 #include "config.h"
29 #include <stdio.h>
30 #ifdef HAVE_FLOAT_H
31 # include <float.h>
32 #endif
33 #include "wined3d_private.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
36 #define GLINFO_LOCATION This->adapter->gl_info
37
38 /* Define the default light parameters as specified by MSDN */
39 const WINED3DLIGHT WINED3D_default_light = {
40
41 WINED3DLIGHT_DIRECTIONAL, /* Type */
42 { 1.0, 1.0, 1.0, 0.0 }, /* Diffuse r,g,b,a */
43 { 0.0, 0.0, 0.0, 0.0 }, /* Specular r,g,b,a */
44 { 0.0, 0.0, 0.0, 0.0 }, /* Ambient r,g,b,a, */
45 { 0.0, 0.0, 0.0 }, /* Position x,y,z */
46 { 0.0, 0.0, 1.0 }, /* Direction x,y,z */
47 0.0, /* Range */
48 0.0, /* Falloff */
49 0.0, 0.0, 0.0, /* Attenuation 0,1,2 */
50 0.0, /* Theta */
51 0.0 /* Phi */
52 };
53
54 /* static function declarations */
55 static void WINAPI IWineD3DDeviceImpl_AddResource(IWineD3DDevice *iface, IWineD3DResource *resource);
56
57 /* helper macros */
58 #define D3DMEMCHECK(object, ppResult) if(NULL == object) { *ppResult = NULL; WARN("Out of memory\n"); return WINED3DERR_OUTOFVIDEOMEMORY;}
59
60 #define D3DCREATEOBJECTINSTANCE(object, type) { \
61 object=HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3D##type##Impl)); \
62 D3DMEMCHECK(object, pp##type); \
63 object->lpVtbl = &IWineD3D##type##_Vtbl; \
64 object->wineD3DDevice = This; \
65 object->parent = parent; \
66 object->ref = 1; \
67 *pp##type = (IWineD3D##type *) object; \
68 }
69
70 #define D3DCREATESHADEROBJECTINSTANCE(object, type) { \
71 object=HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3D##type##Impl)); \
72 D3DMEMCHECK(object, pp##type); \
73 object->lpVtbl = &IWineD3D##type##_Vtbl; \
74 object->parent = parent; \
75 object->baseShader.ref = 1; \
76 object->baseShader.device = (IWineD3DDevice*) This; \
77 list_init(&object->baseShader.linked_programs); \
78 *pp##type = (IWineD3D##type *) object; \
79 }
80
81 #define D3DCREATERESOURCEOBJECTINSTANCE(object, type, d3dtype, _size){ \
82 object=HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3D##type##Impl)); \
83 D3DMEMCHECK(object, pp##type); \
84 object->lpVtbl = &IWineD3D##type##_Vtbl; \
85 object->resource.wineD3DDevice = This; \
86 object->resource.parent = parent; \
87 object->resource.resourceType = d3dtype; \
88 object->resource.ref = 1; \
89 object->resource.pool = Pool; \
90 object->resource.format = Format; \
91 object->resource.usage = Usage; \
92 object->resource.size = _size; \
93 list_init(&object->resource.privateData); \
94 /* Check that we have enough video ram left */ \
95 if (Pool == WINED3DPOOL_DEFAULT) { \
96 if (IWineD3DDevice_GetAvailableTextureMem(iface) <= _size) { \
97 WARN("Out of 'bogus' video memory\n"); \
98 HeapFree(GetProcessHeap(), 0, object); \
99 *pp##type = NULL; \
100 return WINED3DERR_OUTOFVIDEOMEMORY; \
101 } \
102 WineD3DAdapterChangeGLRam(This, _size); \
103 } \
104 object->resource.heapMemory = (0 == _size ? NULL : HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, _size + RESOURCE_ALIGNMENT)); \
105 if (object->resource.heapMemory == NULL && _size != 0) { \
106 FIXME("Out of memory!\n"); \
107 HeapFree(GetProcessHeap(), 0, object); \
108 *pp##type = NULL; \
109 return WINED3DERR_OUTOFVIDEOMEMORY; \
110 } \
111 object->resource.allocatedMemory = (BYTE *)(((ULONG_PTR) object->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1)); \
112 *pp##type = (IWineD3D##type *) object; \
113 IWineD3DDeviceImpl_AddResource(iface, (IWineD3DResource *)object) ;\
114 TRACE("(%p) : Created resource %p\n", This, object); \
115 }
116
117 #define D3DINITIALIZEBASETEXTURE(_basetexture) { \
118 _basetexture.levels = Levels; \
119 _basetexture.filterType = (Usage & WINED3DUSAGE_AUTOGENMIPMAP) ? WINED3DTEXF_LINEAR : WINED3DTEXF_NONE; \
120 _basetexture.LOD = 0; \
121 _basetexture.dirty = TRUE; \
122 _basetexture.is_srgb = FALSE; \
123 _basetexture.srgb_mode_change_count = 0; \
124 }
125
126 /**********************************************************
127 * Global variable / Constants follow
128 **********************************************************/
129 const float identity[16] = {1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1}; /* When needed for comparisons */
130
131 /**********************************************************
132 * IUnknown parts follows
133 **********************************************************/
134
135 static HRESULT WINAPI IWineD3DDeviceImpl_QueryInterface(IWineD3DDevice *iface,REFIID riid,LPVOID *ppobj)
136 {
137 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
138
139 TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
140 if (IsEqualGUID(riid, &IID_IUnknown)
141 || IsEqualGUID(riid, &IID_IWineD3DBase)
142 || IsEqualGUID(riid, &IID_IWineD3DDevice)) {
143 IUnknown_AddRef(iface);
144 *ppobj = This;
145 return S_OK;
146 }
147 *ppobj = NULL;
148 return E_NOINTERFACE;
149 }
150
151 static ULONG WINAPI IWineD3DDeviceImpl_AddRef(IWineD3DDevice *iface) {
152 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
153 ULONG refCount = InterlockedIncrement(&This->ref);
154
155 TRACE("(%p) : AddRef increasing from %d\n", This, refCount - 1);
156 return refCount;
157 }
158
159 static ULONG WINAPI IWineD3DDeviceImpl_Release(IWineD3DDevice *iface) {
160 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
161 ULONG refCount = InterlockedDecrement(&This->ref);
162
163 TRACE("(%p) : Releasing from %d\n", This, refCount + 1);
164
165 if (!refCount) {
166 if (This->fbo) {
167 GL_EXTCALL(glDeleteFramebuffersEXT(1, &This->fbo));
168 }
169 if (This->src_fbo) {
170 GL_EXTCALL(glDeleteFramebuffersEXT(1, &This->src_fbo));
171 }
172 if (This->dst_fbo) {
173 GL_EXTCALL(glDeleteFramebuffersEXT(1, &This->dst_fbo));
174 }
175
176 if (This->glsl_program_lookup) hash_table_destroy(This->glsl_program_lookup);
177
178 /* TODO: Clean up all the surfaces and textures! */
179 /* NOTE: You must release the parent if the object was created via a callback
180 ** ***************************/
181
182 if (!list_empty(&This->resources)) {
183 FIXME("(%p) Device released with resources still bound, acceptable but unexpected\n", This);
184 dumpResources(&This->resources);
185 }
186
187 if(This->contexts) ERR("Context array not freed!\n");
188 if (This->hardwareCursor) DestroyCursor(This->hardwareCursor);
189 This->haveHardwareCursor = FALSE;
190
191 IWineD3D_Release(This->wineD3D);
192 This->wineD3D = NULL;
193 HeapFree(GetProcessHeap(), 0, This);
194 TRACE("Freed device %p\n", This);
195 This = NULL;
196 }
197 return refCount;
198 }
199
200 /**********************************************************
201 * IWineD3DDevice implementation follows
202 **********************************************************/
203 static HRESULT WINAPI IWineD3DDeviceImpl_GetParent(IWineD3DDevice *iface, IUnknown **pParent) {
204 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
205 *pParent = This->parent;
206 IUnknown_AddRef(This->parent);
207 return WINED3D_OK;
208 }
209
210 static HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexBuffer(IWineD3DDevice *iface, UINT Size, DWORD Usage,
211 DWORD FVF, WINED3DPOOL Pool, IWineD3DVertexBuffer** ppVertexBuffer, HANDLE *sharedHandle,
212 IUnknown *parent) {
213 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
214 IWineD3DVertexBufferImpl *object;
215 WINED3DFORMAT Format = WINED3DFMT_VERTEXDATA; /* Dummy format for now */
216 int dxVersion = ( (IWineD3DImpl *) This->wineD3D)->dxVersion;
217 BOOL conv;
218
219 if(Size == 0) {
220 WARN("Size 0 requested, returning WINED3DERR_INVALIDCALL\n");
221 *ppVertexBuffer = NULL;
222 return WINED3DERR_INVALIDCALL;
223 } else if(Pool == WINED3DPOOL_SCRATCH) {
224 /* The d3d9 testsuit shows that this is not allowed. It doesn't make much sense
225 * anyway, SCRATCH vertex buffers aren't useable anywhere
226 */
227 WARN("Vertex buffer in D3DPOOL_SCRATCH requested, returning WINED3DERR_INVALIDCALL\n");
228 *ppVertexBuffer = NULL;
229 return WINED3DERR_INVALIDCALL;
230 }
231
232 D3DCREATERESOURCEOBJECTINSTANCE(object, VertexBuffer, WINED3DRTYPE_VERTEXBUFFER, Size)
233
234 TRACE("(%p) : Size=%d, Usage=0x%08x, FVF=%x, Pool=%d - Memory@%p, Iface@%p\n", This, Size, Usage, FVF, Pool, object->resource.allocatedMemory, object);
235 *ppVertexBuffer = (IWineD3DVertexBuffer *)object;
236
237 object->fvf = FVF;
238
239 /* Observations show that drawStridedSlow is faster on dynamic VBs than converting +
240 * drawStridedFast (half-life 2).
241 *
242 * Basically converting the vertices in the buffer is quite expensive, and observations
243 * show that drawStridedSlow is faster than converting + uploading + drawStridedFast.
244 * Therefore do not create a VBO for WINED3DUSAGE_DYNAMIC buffers.
245 *
246 * Direct3D7 has another problem: Its vertexbuffer api doesn't offer a way to specify
247 * the range of vertices being locked, so each lock will require the whole buffer to be transformed.
248 * Moreover geometry data in dx7 is quite simple, so drawStridedSlow isn't a big hit. A plus
249 * is that the vertex buffers fvf can be trusted in dx7. So only create non-converted vbos for
250 * dx7 apps.
251 * There is a IDirect3DVertexBuffer7::Optimize call after which the buffer can't be locked any
252 * more. In this call we can convert dx7 buffers too.
253 */
254 conv = ((FVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW ) || (FVF & (WINED3DFVF_DIFFUSE | WINED3DFVF_SPECULAR));
255 if(!GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT)) {
256 TRACE("Not creating a vbo because GL_ARB_vertex_buffer is not supported\n");
257 } else if(Pool == WINED3DPOOL_SYSTEMMEM) {
258 TRACE("Not creating a vbo because the vertex buffer is in system memory\n");
259 } else if(Usage & WINED3DUSAGE_DYNAMIC) {
260 TRACE("Not creating a vbo because the buffer has dynamic usage\n");
261 } else if(dxVersion <= 7 && conv) {
262 TRACE("Not creating a vbo because dxVersion is 7 and the fvf needs conversion\n");
263 } else {
264 object->Flags |= VBFLAG_CREATEVBO;
265 }
266 return WINED3D_OK;
267 }
268
269 static void CreateIndexBufferVBO(IWineD3DDeviceImpl *This, IWineD3DIndexBufferImpl *object) {
270 GLenum error, glUsage;
271 TRACE("Creating VBO for Index Buffer %p\n", object);
272
273 /* The following code will modify the ELEMENT_ARRAY_BUFFER binding, make sure it is
274 * restored on the next draw
275 */
276 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
277
278 /* Make sure that a context is there. Needed in a multithreaded environment. Otherwise this call is a nop */
279 ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
280 ENTER_GL();
281
282 while(glGetError());
283
284 GL_EXTCALL(glGenBuffersARB(1, &object->vbo));
285 error = glGetError();
286 if(error != GL_NO_ERROR || object->vbo == 0) {
287 ERR("Creating a vbo failed with error %s (%#x), continuing without vbo for this buffer\n", debug_glerror(error), error);
288 goto out;
289 }
290
291 GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, object->vbo));
292 error = glGetError();
293 if(error != GL_NO_ERROR) {
294 ERR("Failed to bind index buffer with error %s (%#x), continuing without vbo for this buffer\n", debug_glerror(error), error);
295 goto out;
296 }
297
298 /* Use static write only usage for now. Dynamic index buffers stay in sysmem, and due to the sysmem
299 * copy no readback will be needed
300 */
301 glUsage = GL_STATIC_DRAW_ARB;
302 GL_EXTCALL(glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, object->resource.size, NULL, glUsage));
303 error = glGetError();
304 if(error != GL_NO_ERROR) {
305 ERR("Failed to initialize the index buffer with error %s (%#x)\n", debug_glerror(error), error);
306 goto out;
307 }
308 LEAVE_GL();
309 TRACE("Successfully created vbo %d for index buffer %p\n", object->vbo, object);
310 return;
311
312 out:
313 GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0));
314 GL_EXTCALL(glDeleteBuffersARB(1, &object->vbo));
315 LEAVE_GL();
316 object->vbo = 0;
317 }
318
319 static HRESULT WINAPI IWineD3DDeviceImpl_CreateIndexBuffer(IWineD3DDevice *iface, UINT Length, DWORD Usage,
320 WINED3DFORMAT Format, WINED3DPOOL Pool, IWineD3DIndexBuffer** ppIndexBuffer,
321 HANDLE *sharedHandle, IUnknown *parent) {
322 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
323 IWineD3DIndexBufferImpl *object;
324 TRACE("(%p) Creating index buffer\n", This);
325
326 /* Allocate the storage for the device */
327 D3DCREATERESOURCEOBJECTINSTANCE(object,IndexBuffer,WINED3DRTYPE_INDEXBUFFER, Length)
328
329 if(Pool != WINED3DPOOL_SYSTEMMEM && !(Usage & WINED3DUSAGE_DYNAMIC) && GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT)) {
330 CreateIndexBufferVBO(This, object);
331 }
332
333 TRACE("(%p) : Len=%d, Use=%x, Format=(%u,%s), Pool=%d - Memory@%p, Iface@%p\n", This, Length, Usage, Format,
334 debug_d3dformat(Format), Pool, object, object->resource.allocatedMemory);
335 *ppIndexBuffer = (IWineD3DIndexBuffer *) object;
336
337 return WINED3D_OK;
338 }
339
340 static HRESULT WINAPI IWineD3DDeviceImpl_CreateStateBlock(IWineD3DDevice* iface, WINED3DSTATEBLOCKTYPE Type, IWineD3DStateBlock** ppStateBlock, IUnknown *parent) {
341
342 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
343 IWineD3DStateBlockImpl *object;
344 int i, j;
345 HRESULT temp_result;
346
347 D3DCREATEOBJECTINSTANCE(object, StateBlock)
348 object->blockType = Type;
349
350 for(i = 0; i < LIGHTMAP_SIZE; i++) {
351 list_init(&object->lightMap[i]);
352 }
353
354 /* Special case - Used during initialization to produce a placeholder stateblock
355 so other functions called can update a state block */
356 if (Type == WINED3DSBT_INIT) {
357 /* Don't bother increasing the reference count otherwise a device will never
358 be freed due to circular dependencies */
359 return WINED3D_OK;
360 }
361
362 temp_result = allocate_shader_constants(object);
363 if (WINED3D_OK != temp_result)
364 return temp_result;
365
366 /* Otherwise, might as well set the whole state block to the appropriate values */
367 if (This->stateBlock != NULL)
368 stateblock_copy((IWineD3DStateBlock*) object, (IWineD3DStateBlock*) This->stateBlock);
369 else
370 memset(object->streamFreq, 1, sizeof(object->streamFreq));
371
372 /* Reset the ref and type after kludging it */
373 object->wineD3DDevice = This;
374 object->ref = 1;
375 object->blockType = Type;
376
377 TRACE("Updating changed flags appropriate for type %d\n", Type);
378
379 if (Type == WINED3DSBT_ALL) {
380
381 TRACE("ALL => Pretend everything has changed\n");
382 stateblock_savedstates_set((IWineD3DStateBlock*) object, &object->changed, TRUE);
383
384 /* Lights are not part of the changed / set structure */
385 for(j = 0; j < LIGHTMAP_SIZE; j++) {
386 struct list *e;
387 LIST_FOR_EACH(e, &object->lightMap[j]) {
388 PLIGHTINFOEL *light = LIST_ENTRY(e, PLIGHTINFOEL, entry);
389 light->changed = TRUE;
390 light->enabledChanged = TRUE;
391 }
392 }
393 for(j = 1; j <= WINEHIGHEST_RENDER_STATE; j++) {
394 object->contained_render_states[j - 1] = j;
395 }
396 object->num_contained_render_states = WINEHIGHEST_RENDER_STATE;
397 /* TODO: Filter unused transforms between TEXTURE8 and WORLD0? */
398 for(j = 1; j <= HIGHEST_TRANSFORMSTATE; j++) {
399 object->contained_transform_states[j - 1] = j;
400 }
401 object->num_contained_transform_states = HIGHEST_TRANSFORMSTATE;
402 for(j = 0; j < GL_LIMITS(vshader_constantsF); j++) {
403 object->contained_vs_consts_f[j] = j;
404 }
405 object->num_contained_vs_consts_f = GL_LIMITS(vshader_constantsF);
406 for(j = 0; j < MAX_CONST_I; j++) {
407 object->contained_vs_consts_i[j] = j;
408 }
409 object->num_contained_vs_consts_i = MAX_CONST_I;
410 for(j = 0; j < MAX_CONST_B; j++) {
411 object->contained_vs_consts_b[j] = j;
412 }
413 object->num_contained_vs_consts_b = MAX_CONST_B;
414 for(j = 0; j < GL_LIMITS(pshader_constantsF); j++) {
415 object->contained_ps_consts_f[j] = j;
416 }
417 object->num_contained_ps_consts_f = GL_LIMITS(pshader_constantsF);
418 for(j = 0; j < MAX_CONST_I; j++) {
419 object->contained_ps_consts_i[j] = j;
420 }
421 object->num_contained_ps_consts_i = MAX_CONST_I;
422 for(j = 0; j < MAX_CONST_B; j++) {
423 object->contained_ps_consts_b[j] = j;
424 }
425 object->num_contained_ps_consts_b = MAX_CONST_B;
426 for(i = 0; i < MAX_TEXTURES; i++) {
427 for(j = 1; j <= WINED3D_HIGHEST_TEXTURE_STATE; j++) {
428 object->contained_tss_states[object->num_contained_tss_states].stage = i;
429 object->contained_tss_states[object->num_contained_tss_states].state = j;
430 object->num_contained_tss_states++;
431 }
432 }
433 for(i = 0; i < MAX_COMBINED_SAMPLERS; i++) {
434 for(j = 1; j <= WINED3D_HIGHEST_SAMPLER_STATE; j++) {
435 object->contained_sampler_states[object->num_contained_sampler_states].stage = i;
436 object->contained_sampler_states[object->num_contained_sampler_states].state = j;
437 object->num_contained_sampler_states++;
438 }
439 }
440
441 for(i = 0; i < MAX_STREAMS; i++) {
442 if(object->streamSource[i]) {
443 IWineD3DVertexBuffer_AddRef(object->streamSource[i]);
444 }
445 }
446 if(object->pIndexData) {
447 IWineD3DIndexBuffer_AddRef(object->pIndexData);
448 }
449 if(object->vertexShader) {
450 IWineD3DVertexShader_AddRef(object->vertexShader);
451 }
452 if(object->pixelShader) {
453 IWineD3DPixelShader_AddRef(object->pixelShader);
454 }
455
456 } else if (Type == WINED3DSBT_PIXELSTATE) {
457
458 TRACE("PIXELSTATE => Pretend all pixel shates have changed\n");
459 stateblock_savedstates_set((IWineD3DStateBlock*) object, &object->changed, FALSE);
460
461 object->changed.pixelShader = TRUE;
462
463 /* Pixel Shader Constants */
464 for (i = 0; i < GL_LIMITS(vshader_constantsF); ++i) {
465 object->contained_ps_consts_f[i] = i;
466 object->changed.pixelShaderConstantsF[i] = TRUE;
467 }
468 object->num_contained_ps_consts_f = GL_LIMITS(vshader_constantsF);
469 for (i = 0; i < MAX_CONST_B; ++i) {
470 object->contained_ps_consts_b[i] = i;
471 object->changed.pixelShaderConstantsB[i] = TRUE;
472 }
473 object->num_contained_ps_consts_b = MAX_CONST_B;
474 for (i = 0; i < MAX_CONST_I; ++i) {
475 object->contained_ps_consts_i[i] = i;
476 object->changed.pixelShaderConstantsI[i] = TRUE;
477 }
478 object->num_contained_ps_consts_i = MAX_CONST_I;
479
480 for (i = 0; i < NUM_SAVEDPIXELSTATES_R; i++) {
481 object->changed.renderState[SavedPixelStates_R[i]] = TRUE;
482 object->contained_render_states[i] = SavedPixelStates_R[i];
483 }
484 object->num_contained_render_states = NUM_SAVEDPIXELSTATES_R;
485 for (j = 0; j < MAX_TEXTURES; j++) {
486 for (i = 0; i < NUM_SAVEDPIXELSTATES_T; i++) {
487 object->changed.textureState[j][SavedPixelStates_T[i]] = TRUE;
488 object->contained_tss_states[object->num_contained_tss_states].stage = j;
489 object->contained_tss_states[object->num_contained_tss_states].state = SavedPixelStates_T[i];
490 object->num_contained_tss_states++;
491 }
492 }
493 for (j = 0 ; j < MAX_COMBINED_SAMPLERS; j++) {
494 for (i =0; i < NUM_SAVEDPIXELSTATES_S;i++) {
495 object->changed.samplerState[j][SavedPixelStates_S[i]] = TRUE;
496 object->contained_sampler_states[object->num_contained_sampler_states].stage = j;
497 object->contained_sampler_states[object->num_contained_sampler_states].state = SavedPixelStates_S[i];
498 object->num_contained_sampler_states++;
499 }
500 }
501 if(object->pixelShader) {
502 IWineD3DPixelShader_AddRef(object->pixelShader);
503 }
504
505 /* Pixel state blocks do not contain vertex buffers. Set them to NULL to avoid wrong refcounting
506 * on them. This makes releasing the buffer easier
507 */
508 for(i = 0; i < MAX_STREAMS; i++) {
509 object->streamSource[i] = NULL;
510 }
511 object->pIndexData = NULL;
512 object->vertexShader = NULL;
513
514 } else if (Type == WINED3DSBT_VERTEXSTATE) {
515
516 TRACE("VERTEXSTATE => Pretend all vertex shates have changed\n");
517 stateblock_savedstates_set((IWineD3DStateBlock*) object, &object->changed, FALSE);
518
519 object->changed.vertexShader = TRUE;
520
521 /* Vertex Shader Constants */
522 for (i = 0; i < GL_LIMITS(vshader_constantsF); ++i) {
523 object->changed.vertexShaderConstantsF[i] = TRUE;
524 object->contained_vs_consts_f[i] = i;
525 }
526 object->num_contained_vs_consts_f = GL_LIMITS(vshader_constantsF);
527 for (i = 0; i < MAX_CONST_B; ++i) {
528 object->changed.vertexShaderConstantsB[i] = TRUE;
529 object->contained_vs_consts_b[i] = i;
530 }
531 object->num_contained_vs_consts_b = MAX_CONST_B;
532 for (i = 0; i < MAX_CONST_I; ++i) {
533 object->changed.vertexShaderConstantsI[i] = TRUE;
534 object->contained_vs_consts_i[i] = i;
535 }
536 object->num_contained_vs_consts_i = MAX_CONST_I;
537 for (i = 0; i < NUM_SAVEDVERTEXSTATES_R; i++) {
538 object->changed.renderState[SavedVertexStates_R[i]] = TRUE;
539 object->contained_render_states[i] = SavedVertexStates_R[i];
540 }
541 object->num_contained_render_states = NUM_SAVEDVERTEXSTATES_R;
542 for (j = 0; j < MAX_TEXTURES; j++) {
543 for (i = 0; i < NUM_SAVEDVERTEXSTATES_T; i++) {
544 object->changed.textureState[j][SavedVertexStates_T[i]] = TRUE;
545 object->contained_tss_states[object->num_contained_tss_states].stage = j;
546 object->contained_tss_states[object->num_contained_tss_states].state = SavedVertexStates_T[i];
547 object->num_contained_tss_states++;
548 }
549 }
550 for (j = 0 ; j < MAX_COMBINED_SAMPLERS; j++){
551 for (i =0; i < NUM_SAVEDVERTEXSTATES_S;i++) {
552 object->changed.samplerState[j][SavedVertexStates_S[i]] = TRUE;
553 object->contained_sampler_states[object->num_contained_sampler_states].stage = j;
554 object->contained_sampler_states[object->num_contained_sampler_states].state = SavedVertexStates_S[i];
555 object->num_contained_sampler_states++;
556 }
557 }
558
559 for(j = 0; j < LIGHTMAP_SIZE; j++) {
560 struct list *e;
561 LIST_FOR_EACH(e, &object->lightMap[j]) {
562 PLIGHTINFOEL *light = LIST_ENTRY(e, PLIGHTINFOEL, entry);
563 light->changed = TRUE;
564 light->enabledChanged = TRUE;
565 }
566 }
567
568 for(i = 0; i < MAX_STREAMS; i++) {
569 if(object->streamSource[i]) {
570 IWineD3DVertexBuffer_AddRef(object->streamSource[i]);
571 }
572 }
573 if(object->vertexShader) {
574 IWineD3DVertexShader_AddRef(object->vertexShader);
575 }
576 object->pIndexData = NULL;
577 object->pixelShader = NULL;
578 } else {
579 FIXME("Unrecognized state block type %d\n", Type);
580 }
581
582 TRACE("(%p) returning token (ptr to stateblock) of %p\n", This, object);
583 return WINED3D_OK;
584 }
585
586 /* ************************************
587 MSDN:
588 [in] Render targets are not lockable unless the application specifies TRUE for Lockable. Note that lockable render targets reduce performance on some graphics hardware.
589
590 Discard
591 [in] Set this flag to TRUE to enable z-buffer discarding, and FALSE otherwise.
592
593 If this flag is set, the contents of the depth stencil buffer will be invalid after calling either IDirect3DDevice9::Present or IDirect3DDevice9::SetDepthStencilSurface with a different depth surface.
594
595 ******************************** */
596
597 static HRESULT WINAPI IWineD3DDeviceImpl_CreateSurface(IWineD3DDevice *iface, UINT Width, UINT Height, WINED3DFORMAT Format, BOOL Lockable, BOOL Discard, UINT Level, IWineD3DSurface **ppSurface,WINED3DRESOURCETYPE Type, DWORD Usage, WINED3DPOOL Pool, WINED3DMULTISAMPLE_TYPE MultiSample ,DWORD MultisampleQuality, HANDLE* pSharedHandle, WINED3DSURFTYPE Impl, IUnknown *parent) {
598 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
599 IWineD3DSurfaceImpl *object; /*NOTE: impl ref allowed since this is a create function */
600 unsigned int Size = 1;
601 const StaticPixelFormatDesc *tableEntry = getFormatDescEntry(Format, NULL, NULL);
602 TRACE("(%p) Create surface\n",This);
603
604 /** FIXME: Check ranges on the inputs are valid
605 * MSDN
606 * MultisampleQuality
607 * [in] Quality level. The valid range is between zero and one less than the level
608 * returned by pQualityLevels used by IDirect3D9::CheckDeviceMultiSampleType.
609 * Passing a larger value returns the error WINED3DERR_INVALIDCALL. The MultisampleQuality
610 * values of paired render targets, depth stencil surfaces, and the MultiSample type
611 * must all match.
612 *******************************/
613
614
615 /**
616 * TODO: Discard MSDN
617 * [in] Set this flag to TRUE to enable z-buffer discarding, and FALSE otherwise.
618 *
619 * If this flag is set, the contents of the depth stencil buffer will be
620 * invalid after calling either IDirect3DDevice9::Present or * IDirect3DDevice9::SetDepthStencilSurface
621 * with a different depth surface.
622 *
623 *This flag has the same behavior as the constant, D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL, in D3DPRESENTFLAG.
624 ***************************/
625
626 if(MultisampleQuality > 0) {
627 FIXME("MultisampleQuality set to %d, substituting 0\n", MultisampleQuality);
628 MultisampleQuality=0;
629 }
630
631 /** FIXME: Check that the format is supported
632 * by the device.
633 *******************************/
634
635 /** DXTn mipmaps use the same number of 'levels' down to eg. 8x1, but since
636 * it is based around 4x4 pixel blocks it requires padding, so allocate enough
637 * space!
638 *********************************/
639 if (WINED3DFMT_UNKNOWN == Format) {
640 Size = 0;
641 } else if (Format == WINED3DFMT_DXT1) {
642 /* DXT1 is half byte per pixel */
643 Size = ((max(Width,4) * tableEntry->bpp) * max(Height,4)) >> 1;
644
645 } else if (Format == WINED3DFMT_DXT2 || Format == WINED3DFMT_DXT3 ||
646 Format == WINED3DFMT_DXT4 || Format == WINED3DFMT_DXT5) {
647 Size = ((max(Width,4) * tableEntry->bpp) * max(Height,4));
648 } else {
649 /* The pitch is a multiple of 4 bytes */
650 Size = ((Width * tableEntry->bpp) + This->surface_alignment - 1) & ~(This->surface_alignment - 1);
651 Size *= Height;
652 }
653
654 /** Create and initialise the surface resource **/
655 D3DCREATERESOURCEOBJECTINSTANCE(object,Surface,WINED3DRTYPE_SURFACE, Size)
656 /* "Standalone" surface */
657 IWineD3DSurface_SetContainer((IWineD3DSurface *)object, NULL);
658
659 object->currentDesc.Width = Width;
660 object->currentDesc.Height = Height;
661 object->currentDesc.MultiSampleType = MultiSample;
662 object->currentDesc.MultiSampleQuality = MultisampleQuality;
663 object->glDescription.level = Level;
664
665 /* Flags */
666 object->Flags = 0;
667 object->Flags |= Discard ? SFLAG_DISCARD : 0;
668 object->Flags |= (WINED3DFMT_D16_LOCKABLE == Format) ? SFLAG_LOCKABLE : 0;
669 object->Flags |= Lockable ? SFLAG_LOCKABLE : 0;
670
671
672 if (WINED3DFMT_UNKNOWN != Format) {
673 object->bytesPerPixel = tableEntry->bpp;
674 } else {
675 object->bytesPerPixel = 0;
676 }
677
678 /** TODO: change this into a texture transform matrix so that it's processed in hardware **/
679
680 TRACE("Pool %d %d %d %d\n",Pool, WINED3DPOOL_DEFAULT, WINED3DPOOL_MANAGED, WINED3DPOOL_SYSTEMMEM);
681
682 /** Quick lockable sanity check TODO: remove this after surfaces, usage and lockability have been debugged properly
683 * this function is too deep to need to care about things like this.
684 * Levels need to be checked too, and possibly Type since they all affect what can be done.
685 * ****************************************/
686 switch(Pool) {
687 case WINED3DPOOL_SCRATCH:
688 if(!Lockable)
689 FIXME("Create surface called with a pool of SCRATCH and a Lockable of FALSE "
690 "which are mutually exclusive, setting lockable to TRUE\n");
691 Lockable = TRUE;
692 break;
693 case WINED3DPOOL_SYSTEMMEM:
694 if(!Lockable) FIXME("Create surface called with a pool of SYSTEMMEM and a Lockable of FALSE, "
695 "this is acceptable but unexpected (I can't know how the surface can be usable!)\n");
696 case WINED3DPOOL_MANAGED:
697 if(Usage == WINED3DUSAGE_DYNAMIC) FIXME("Create surface called with a pool of MANAGED and a "
698 "Usage of DYNAMIC which are mutually exclusive, not doing "
699 "anything just telling you.\n");
700 break;
701 case WINED3DPOOL_DEFAULT: /*TODO: Create offscreen plain can cause this check to fail..., find out if it should */
702 if(!(Usage & WINED3DUSAGE_DYNAMIC) && !(Usage & WINED3DUSAGE_RENDERTARGET)
703 && !(Usage && WINED3DUSAGE_DEPTHSTENCIL ) && Lockable)
704 WARN("Creating a surface with a POOL of DEFAULT with Lockable true, that doesn't specify DYNAMIC usage.\n");
705 break;
706 default:
707 FIXME("(%p) Unknown pool %d\n", This, Pool);
708 break;
709 };
710
711 if (Usage & WINED3DUSAGE_RENDERTARGET && Pool != WINED3DPOOL_DEFAULT) {
712 FIXME("Trying to create a render target that isn't in the default pool\n");
713 }
714
715 /* mark the texture as dirty so that it gets loaded first time around*/
716 IWineD3DSurface_AddDirtyRect(*ppSurface, NULL);
717 TRACE("(%p) : w(%d) h(%d) fmt(%d,%s) lockable(%d) surf@%p, surfmem@%p, %d bytes\n",
718 This, Width, Height, Format, debug_d3dformat(Format),
719 (WINED3DFMT_D16_LOCKABLE == Format), *ppSurface, object->resource.allocatedMemory, object->resource.size);
720
721 /* Store the DirectDraw primary surface. This is the first rendertarget surface created */
722 if( (Usage & WINED3DUSAGE_RENDERTARGET) && (!This->ddraw_primary) )
723 This->ddraw_primary = (IWineD3DSurface *) object;
724
725 /* Look at the implementation and set the correct Vtable */
726 switch(Impl) {
727 case SURFACE_OPENGL:
728 /* Check if a 3D adapter is available when creating gl surfaces */
729 if(!This->adapter) {
730 ERR("OpenGL surfaces are not available without opengl\n");
731 HeapFree(GetProcessHeap(), 0, object->resource.allocatedMemory);
732 HeapFree(GetProcessHeap(), 0, object);
733 return WINED3DERR_NOTAVAILABLE;
734 }
735 break;
736
737 case SURFACE_GDI:
738 object->lpVtbl = &IWineGDISurface_Vtbl;
739 break;
740
741 default:
742 /* To be sure to catch this */
743 ERR("Unknown requested surface implementation %d!\n", Impl);
744 IWineD3DSurface_Release((IWineD3DSurface *) object);
745 return WINED3DERR_INVALIDCALL;
746 }
747
748 list_init(&object->renderbuffers);
749
750 /* Call the private setup routine */
751 return IWineD3DSurface_PrivateSetup( (IWineD3DSurface *) object );
752
753 }
754
755 static HRESULT WINAPI IWineD3DDeviceImpl_CreateTexture(IWineD3DDevice *iface, UINT Width, UINT Height, UINT Levels,
756 DWORD Usage, WINED3DFORMAT Format, WINED3DPOOL Pool,
757 IWineD3DTexture** ppTexture, HANDLE* pSharedHandle, IUnknown *parent,
758 D3DCB_CREATESURFACEFN D3DCB_CreateSurface) {
759
760 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
761 IWineD3DTextureImpl *object;
762 unsigned int i;
763 UINT tmpW;
764 UINT tmpH;
765 HRESULT hr;
766 unsigned int pow2Width;
767 unsigned int pow2Height;
768 const GlPixelFormatDesc *glDesc;
769 getFormatDescEntry(Format, &GLINFO_LOCATION, &glDesc);
770
771 TRACE("(%p) : Width %d, Height %d, Levels %d, Usage %#x\n", This, Width, Height, Levels, Usage);
772 TRACE("Format %#x (%s), Pool %#x, ppTexture %p, pSharedHandle %p, parent %p\n",
773 Format, debug_d3dformat(Format), Pool, ppTexture, pSharedHandle, parent);
774
775 if((Usage & (WINED3DUSAGE_AUTOGENMIPMAP | WINED3DUSAGE_RENDERTARGET)) ==
776 (WINED3DUSAGE_AUTOGENMIPMAP | WINED3DUSAGE_RENDERTARGET)) {
777 WARN("Application requests both D3DUSAGE_AUTOGENMIPMAP and D3DUSAGE_RENDERTARGET, which are mutually exclusive\n");
778 return WINED3DERR_INVALIDCALL;
779 }
780
781 /* TODO: It should only be possible to create textures for formats
782 that are reported as supported */
783 if (WINED3DFMT_UNKNOWN >= Format) {
784 WARN("(%p) : Texture cannot be created with a format of WINED3DFMT_UNKNOWN\n", This);
785 return WINED3DERR_INVALIDCALL;
786 }
787
788 D3DCREATERESOURCEOBJECTINSTANCE(object, Texture, WINED3DRTYPE_TEXTURE, 0);
789 D3DINITIALIZEBASETEXTURE(object->baseTexture);
790 object->width = Width;
791 object->height = Height;
792
793 /** Non-power2 support **/
794 if (GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO)) {
795 pow2Width = Width;
796 pow2Height = Height;
797 } else {
798 /* Find the nearest pow2 match */
799 pow2Width = pow2Height = 1;
800 while (pow2Width < Width) pow2Width <<= 1;
801 while (pow2Height < Height) pow2Height <<= 1;
802
803 if(pow2Width != Width || pow2Height != Height) {
804 if(Levels > 1) {
805 WARN("Attempted to create a mipmapped np2 texture without unconditional np2 support\n");
806 HeapFree(GetProcessHeap(), 0, object);
807 *ppTexture = NULL;
808 return WINED3DERR_INVALIDCALL;
809 } else {
810 Levels = 1;
811 }
812 }
813 }
814
815 /** FIXME: add support for real non-power-two if it's provided by the video card **/
816 /* Precalculated scaling for 'faked' non power of two texture coords.
817 Second also don't use ARB_TEXTURE_RECTANGLE in case the surface format is P8 and EXT_PALETTED_TEXTURE
818 is used in combination with texture uploads (RTL_READTEX/RTL_TEXTEX). The reason is that EXT_PALETTED_TEXTURE
819 doesn't work in combination with ARB_TEXTURE_RECTANGLE.
820 */
821 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE) &&
822 (Width != pow2Width || Height != pow2Height) &&
823 !((Format == WINED3DFMT_P8) && GL_SUPPORT(EXT_PALETTED_TEXTURE) && (wined3d_settings.rendertargetlock_mode == RTL_READTEX || wined3d_settings.rendertargetlock_mode == RTL_TEXTEX)))
824 {
825 object->baseTexture.pow2Matrix[0] = (float)Width;
826 object->baseTexture.pow2Matrix[5] = (float)Height;
827 object->baseTexture.pow2Matrix[10] = 1.0;
828 object->baseTexture.pow2Matrix[15] = 1.0;
829 object->target = GL_TEXTURE_RECTANGLE_ARB;
830 } else {
831 object->baseTexture.pow2Matrix[0] = (((float)Width) / ((float)pow2Width));
832 object->baseTexture.pow2Matrix[5] = (((float)Height) / ((float)pow2Height));
833 object->baseTexture.pow2Matrix[10] = 1.0;
834 object->baseTexture.pow2Matrix[15] = 1.0;
835 object->target = GL_TEXTURE_2D;
836 }
837 TRACE(" xf(%f) yf(%f)\n", object->baseTexture.pow2Matrix[0], object->baseTexture.pow2Matrix[5]);
838
839 /* Calculate levels for mip mapping */
840 if (Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
841 if(!GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
842 WARN("No mipmap generation support, returning D3DERR_INVALIDCALL\n");
843 return WINED3DERR_INVALIDCALL;
844 }
845 if(Levels > 1) {
846 WARN("D3DUSAGE_AUTOGENMIPMAP is set, and level count > 1, returning D3DERR_INVALIDCALL\n");
847 return WINED3DERR_INVALIDCALL;
848 }
849 object->baseTexture.levels = 1;
850 } else if (Levels == 0) {
851 TRACE("calculating levels %d\n", object->baseTexture.levels);
852 object->baseTexture.levels++;
853 tmpW = Width;
854 tmpH = Height;
855 while (tmpW > 1 || tmpH > 1) {
856 tmpW = max(1, tmpW >> 1);
857 tmpH = max(1, tmpH >> 1);
858 object->baseTexture.levels++;
859 }
860 TRACE("Calculated levels = %d\n", object->baseTexture.levels);
861 }
862
863 /* Generate all the surfaces */
864 tmpW = Width;
865 tmpH = Height;
866 for (i = 0; i < object->baseTexture.levels; i++)
867 {
868 /* use the callback to create the texture surface */
869 hr = D3DCB_CreateSurface(This->parent, parent, tmpW, tmpH, Format, Usage, Pool, i, WINED3DCUBEMAP_FACE_POSITIVE_X, &object->surfaces[i],NULL);
870 if (hr!= WINED3D_OK || ( (IWineD3DSurfaceImpl *) object->surfaces[i])->Flags & SFLAG_OVERSIZE) {
871 FIXME("Failed to create surface %p\n", object);
872 /* clean up */
873 object->surfaces[i] = NULL;
874 IWineD3DTexture_Release((IWineD3DTexture *)object);
875
876 *ppTexture = NULL;
877 return hr;
878 }
879
880 IWineD3DSurface_SetContainer(object->surfaces[i], (IWineD3DBase *)object);
881 TRACE("Created surface level %d @ %p\n", i, object->surfaces[i]);
882 /* calculate the next mipmap level */
883 tmpW = max(1, tmpW >> 1);
884 tmpH = max(1, tmpH >> 1);
885 }
886 object->baseTexture.shader_conversion_group = glDesc->conversion_group;
887
888 TRACE("(%p) : Created texture %p\n", This, object);
889 return WINED3D_OK;
890 }
891
892 static HRESULT WINAPI IWineD3DDeviceImpl_CreateVolumeTexture(IWineD3DDevice *iface,
893 UINT Width, UINT Height, UINT Depth,
894 UINT Levels, DWORD Usage,
895 WINED3DFORMAT Format, WINED3DPOOL Pool,
896 IWineD3DVolumeTexture **ppVolumeTexture,
897 HANDLE *pSharedHandle, IUnknown *parent,
898 D3DCB_CREATEVOLUMEFN D3DCB_CreateVolume) {
899
900 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
901 IWineD3DVolumeTextureImpl *object;
902 unsigned int i;
903 UINT tmpW;
904 UINT tmpH;
905 UINT tmpD;
906 const GlPixelFormatDesc *glDesc;
907
908 getFormatDescEntry(Format, &GLINFO_LOCATION, &glDesc);
909
910 /* TODO: It should only be possible to create textures for formats
911 that are reported as supported */
912 if (WINED3DFMT_UNKNOWN >= Format) {
913 WARN("(%p) : Texture cannot be created with a format of WINED3DFMT_UNKNOWN\n", This);
914 return WINED3DERR_INVALIDCALL;
915 }
916 if(!GL_SUPPORT(EXT_TEXTURE3D)) {
917 WARN("(%p) : Texture cannot be created - no volume texture support\n", This);
918 return WINED3DERR_INVALIDCALL;
919 }
920
921 D3DCREATERESOURCEOBJECTINSTANCE(object, VolumeTexture, WINED3DRTYPE_VOLUMETEXTURE, 0);
922 D3DINITIALIZEBASETEXTURE(object->baseTexture);
923
924 TRACE("(%p) : W(%d) H(%d) D(%d), Lvl(%d) Usage(%d), Fmt(%u,%s), Pool(%s)\n", This, Width, Height,
925 Depth, Levels, Usage, Format, debug_d3dformat(Format), debug_d3dpool(Pool));
926
927 object->width = Width;
928 object->height = Height;
929 object->depth = Depth;
930
931 /* Is NP2 support for volumes needed? */
932 object->baseTexture.pow2Matrix[ 0] = 1.0;
933 object->baseTexture.pow2Matrix[ 5] = 1.0;
934 object->baseTexture.pow2Matrix[10] = 1.0;
935 object->baseTexture.pow2Matrix[15] = 1.0;
936
937 /* Calculate levels for mip mapping */
938 if (Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
939 if(!GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
940 WARN("No mipmap generation support, returning D3DERR_INVALIDCALL\n");
941 return WINED3DERR_INVALIDCALL;
942 }
943 if(Levels > 1) {
944 WARN("D3DUSAGE_AUTOGENMIPMAP is set, and level count > 1, returning D3DERR_INVALIDCALL\n");
945 return WINED3DERR_INVALIDCALL;
946 }
947 Levels = 1;
948 } else if (Levels == 0) {
949 object->baseTexture.levels++;
950 tmpW = Width;
951 tmpH = Height;
952 tmpD = Depth;
953 while (tmpW > 1 || tmpH > 1 || tmpD > 1) {
954 tmpW = max(1, tmpW >> 1);
955 tmpH = max(1, tmpH >> 1);
956 tmpD = max(1, tmpD >> 1);
957 object->baseTexture.levels++;
958 }
959 TRACE("Calculated levels = %d\n", object->baseTexture.levels);
960 }
961
962 /* Generate all the surfaces */
963 tmpW = Width;
964 tmpH = Height;
965 tmpD = Depth;
966
967 for (i = 0; i < object->baseTexture.levels; i++)
968 {
969 HRESULT hr;
970 /* Create the volume */
971 hr = D3DCB_CreateVolume(This->parent, parent, tmpW, tmpH, tmpD, Format, Pool, Usage,
972 &object->volumes[i], pSharedHandle);
973
974 if(FAILED(hr)) {
975 ERR("Creating a volume for the volume texture failed(%08x)\n", hr);
976 IWineD3DVolumeTexture_Release((IWineD3DVolumeTexture *) object);
977 *ppVolumeTexture = NULL;
978 return hr;
979 }
980
981 /* Set its container to this object */
982 IWineD3DVolume_SetContainer(object->volumes[i], (IWineD3DBase *)object);
983
984 /* calculate the next mipmap level */
985 tmpW = max(1, tmpW >> 1);
986 tmpH = max(1, tmpH >> 1);
987 tmpD = max(1, tmpD >> 1);
988 }
989 object->baseTexture.shader_conversion_group = glDesc->conversion_group;
990
991 *ppVolumeTexture = (IWineD3DVolumeTexture *) object;
992 TRACE("(%p) : Created volume texture %p\n", This, object);
993 return WINED3D_OK;
994 }
995
996 static HRESULT WINAPI IWineD3DDeviceImpl_CreateVolume(IWineD3DDevice *iface,
997 UINT Width, UINT Height, UINT Depth,
998 DWORD Usage,
999 WINED3DFORMAT Format, WINED3DPOOL Pool,
1000 IWineD3DVolume** ppVolume,
1001 HANDLE* pSharedHandle, IUnknown *parent) {
1002
1003 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1004 IWineD3DVolumeImpl *object; /** NOTE: impl ref allowed since this is a create function **/
1005 const StaticPixelFormatDesc *formatDesc = getFormatDescEntry(Format, NULL, NULL);
1006
1007 if(!GL_SUPPORT(EXT_TEXTURE3D)) {
1008 WARN("(%p) : Volume cannot be created - no volume texture support\n", This);
1009 return WINED3DERR_INVALIDCALL;
1010 }
1011
1012 D3DCREATERESOURCEOBJECTINSTANCE(object, Volume, WINED3DRTYPE_VOLUME, ((Width * formatDesc->bpp) * Height * Depth))
1013
1014 TRACE("(%p) : W(%d) H(%d) D(%d), Usage(%d), Fmt(%u,%s), Pool(%s)\n", This, Width, Height,
1015 Depth, Usage, Format, debug_d3dformat(Format), debug_d3dpool(Pool));
1016
1017 object->currentDesc.Width = Width;
1018 object->currentDesc.Height = Height;
1019 object->currentDesc.Depth = Depth;
1020 object->bytesPerPixel = formatDesc->bpp;
1021
1022 /** Note: Volume textures cannot be dxtn, hence no need to check here **/
1023 object->lockable = TRUE;
1024 object->locked = FALSE;
1025 memset(&object->lockedBox, 0, sizeof(WINED3DBOX));
1026 object->dirty = TRUE;
1027
1028 return IWineD3DVolume_AddDirtyBox((IWineD3DVolume *) object, NULL);
1029 }
1030
1031 static HRESULT WINAPI IWineD3DDeviceImpl_CreateCubeTexture(IWineD3DDevice *iface, UINT EdgeLength,
1032 UINT Levels, DWORD Usage,
1033 WINED3DFORMAT Format, WINED3DPOOL Pool,
1034 IWineD3DCubeTexture **ppCubeTexture,
1035 HANDLE *pSharedHandle, IUnknown *parent,
1036 D3DCB_CREATESURFACEFN D3DCB_CreateSurface) {
1037
1038 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1039 IWineD3DCubeTextureImpl *object; /** NOTE: impl ref allowed since this is a create function **/
1040 unsigned int i, j;
1041 UINT tmpW;
1042 HRESULT hr;
1043 unsigned int pow2EdgeLength = EdgeLength;
1044 const GlPixelFormatDesc *glDesc;
1045 getFormatDescEntry(Format, &GLINFO_LOCATION, &glDesc);
1046
1047 if((Usage & (WINED3DUSAGE_AUTOGENMIPMAP | WINED3DUSAGE_RENDERTARGET)) ==
1048 (WINED3DUSAGE_AUTOGENMIPMAP | WINED3DUSAGE_RENDERTARGET)) {
1049 WARN("Application requests both D3DUSAGE_AUTOGENMIPMAP and D3DUSAGE_RENDERTARGET, which are mutually exclusive\n");
1050 return WINED3DERR_INVALIDCALL;
1051 }
1052
1053 /* TODO: It should only be possible to create textures for formats
1054 that are reported as supported */
1055 if (WINED3DFMT_UNKNOWN >= Format) {
1056 WARN("(%p) : Texture cannot be created with a format of WINED3DFMT_UNKNOWN\n", This);
1057 return WINED3DERR_INVALIDCALL;
1058 }
1059
1060 if (!GL_SUPPORT(ARB_TEXTURE_CUBE_MAP) && Pool != WINED3DPOOL_SCRATCH) {
1061 WARN("(%p) : Tried to create not supported cube texture\n", This);
1062 return WINED3DERR_INVALIDCALL;
1063 }
1064
1065 D3DCREATERESOURCEOBJECTINSTANCE(object, CubeTexture, WINED3DRTYPE_CUBETEXTURE, 0);
1066 D3DINITIALIZEBASETEXTURE(object->baseTexture);
1067
1068 TRACE("(%p) Create Cube Texture\n", This);
1069
1070 /** Non-power2 support **/
1071
1072 /* Find the nearest pow2 match */
1073 pow2EdgeLength = 1;
1074 while (pow2EdgeLength < EdgeLength) pow2EdgeLength <<= 1;
1075
1076 object->edgeLength = EdgeLength;
1077 /* TODO: support for native non-power 2 */
1078 /* Precalculated scaling for 'faked' non power of two texture coords */
1079 object->baseTexture.pow2Matrix[ 0] = ((float)EdgeLength) / ((float)pow2EdgeLength);
1080 object->baseTexture.pow2Matrix[ 5] = ((float)EdgeLength) / ((float)pow2EdgeLength);
1081 object->baseTexture.pow2Matrix[10] = ((float)EdgeLength) / ((float)pow2EdgeLength);
1082 object->baseTexture.pow2Matrix[15] = 1.0;
1083
1084 /* Calculate levels for mip mapping */
1085 if (Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
1086 if(!GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
1087 WARN("No mipmap generation support, returning D3DERR_INVALIDCALL\n");
1088 HeapFree(GetProcessHeap(), 0, object);
1089 *ppCubeTexture = NULL;
1090
1091 return WINED3DERR_INVALIDCALL;
1092 }
1093 if(Levels > 1) {
1094 WARN("D3DUSAGE_AUTOGENMIPMAP is set, and level count > 1, returning D3DERR_INVALIDCALL\n");
1095 HeapFree(GetProcessHeap(), 0, object);
1096 *ppCubeTexture = NULL;
1097
1098 return WINED3DERR_INVALIDCALL;
1099 }
1100 Levels = 1;
1101 } else if (Levels == 0) {
1102 object->baseTexture.levels++;
1103 tmpW = EdgeLength;
1104 while (tmpW > 1) {
1105 tmpW = max(1, tmpW >> 1);
1106 object->baseTexture.levels++;
1107 }
1108 TRACE("Calculated levels = %d\n", object->baseTexture.levels);
1109 }
1110
1111 /* Generate all the surfaces */
1112 tmpW = EdgeLength;
1113 for (i = 0; i < object->baseTexture.levels; i++) {
1114
1115 /* Create the 6 faces */
1116 for (j = 0; j < 6; j++) {
1117
1118 hr=D3DCB_CreateSurface(This->parent, parent, tmpW, tmpW, Format, Usage, Pool,
1119 i /* Level */, j, &object->surfaces[j][i],pSharedHandle);
1120
1121 if(hr!= WINED3D_OK) {
1122 /* clean up */
1123 int k;
1124 int l;
1125 for (l = 0; l < j; l++) {
1126 IWineD3DSurface_Release(object->surfaces[l][i]);
1127 }
1128 for (k = 0; k < i; k++) {
1129 for (l = 0; l < 6; l++) {
1130 IWineD3DSurface_Release(object->surfaces[l][k]);
1131 }
1132 }
1133
1134 FIXME("(%p) Failed to create surface\n",object);
1135 HeapFree(GetProcessHeap(),0,object);
1136 *ppCubeTexture = NULL;
1137 return hr;
1138 }
1139 IWineD3DSurface_SetContainer(object->surfaces[j][i], (IWineD3DBase *)object);
1140 TRACE("Created surface level %d @ %p,\n", i, object->surfaces[j][i]);
1141 }
1142 tmpW = max(1, tmpW >> 1);
1143 }
1144 object->baseTexture.shader_conversion_group = glDesc->conversion_group;
1145
1146 TRACE("(%p) : Created Cube Texture %p\n", This, object);
1147 *ppCubeTexture = (IWineD3DCubeTexture *) object;
1148 return WINED3D_OK;
1149 }
1150
1151 static HRESULT WINAPI IWineD3DDeviceImpl_CreateQuery(IWineD3DDevice *iface, WINED3DQUERYTYPE Type, IWineD3DQuery **ppQuery, IUnknown* parent) {
1152 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1153 IWineD3DQueryImpl *object; /*NOTE: impl ref allowed since this is a create function */
1154 HRESULT hr = WINED3DERR_NOTAVAILABLE;
1155 const IWineD3DQueryVtbl *vtable;
1156
1157 /* Just a check to see if we support this type of query */
1158 switch(Type) {
1159 case WINED3DQUERYTYPE_OCCLUSION:
1160 TRACE("(%p) occlusion query\n", This);
1161 if (GL_SUPPORT(ARB_OCCLUSION_QUERY))
1162 hr = WINED3D_OK;
1163 else
1164 WARN("Unsupported in local OpenGL implementation: ARB_OCCLUSION_QUERY/NV_OCCLUSION_QUERY\n");
1165
1166 vtable = &IWineD3DOcclusionQuery_Vtbl;
1167 break;
1168
1169 case WINED3DQUERYTYPE_EVENT:
1170 if(!(GL_SUPPORT(NV_FENCE) || GL_SUPPORT(APPLE_FENCE) )) {
1171 /* Half-Life 2 needs this query. It does not render the main menu correctly otherwise
1172 * Pretend to support it, faking this query does not do much harm except potentially lowering performance
1173 */
1174 FIXME("(%p) Event query: Unimplemented, but pretending to be supported\n", This);
1175 }
1176 vtable = &IWineD3DEventQuery_Vtbl;
1177 hr = WINED3D_OK;
1178 break;
1179
1180 case WINED3DQUERYTYPE_VCACHE:
1181 case WINED3DQUERYTYPE_RESOURCEMANAGER:
1182 case WINED3DQUERYTYPE_VERTEXSTATS:
1183 case WINED3DQUERYTYPE_TIMESTAMP:
1184 case WINED3DQUERYTYPE_TIMESTAMPDISJOINT:
1185 case WINED3DQUERYTYPE_TIMESTAMPFREQ:
1186 case WINED3DQUERYTYPE_PIPELINETIMINGS:
1187 case WINED3DQUERYTYPE_INTERFACETIMINGS:
1188 case WINED3DQUERYTYPE_VERTEXTIMINGS:
1189 case WINED3DQUERYTYPE_PIXELTIMINGS:
1190 case WINED3DQUERYTYPE_BANDWIDTHTIMINGS:
1191 case WINED3DQUERYTYPE_CACHEUTILIZATION:
1192 default:
1193 /* Use the base Query vtable until we have a special one for each query */
1194 vtable = &IWineD3DQuery_Vtbl;
1195 FIXME("(%p) Unhandled query type %d\n", This, Type);
1196 }
1197 if(NULL == ppQuery || hr != WINED3D_OK) {
1198 return hr;
1199 }
1200
1201 D3DCREATEOBJECTINSTANCE(object, Query)
1202 object->lpVtbl = vtable;
1203 object->type = Type;
1204 object->state = QUERY_CREATED;
1205 /* allocated the 'extended' data based on the type of query requested */
1206 switch(Type){
1207 case WINED3DQUERYTYPE_OCCLUSION:
1208 object->extendedData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WineQueryOcclusionData));
1209 ((WineQueryOcclusionData *)(object->extendedData))->ctx = This->activeContext;
1210
1211 if(GL_SUPPORT(ARB_OCCLUSION_QUERY)) {
1212 TRACE("(%p) Allocating data for an occlusion query\n", This);
1213 GL_EXTCALL(glGenQueriesARB(1, &((WineQueryOcclusionData *)(object->extendedData))->queryId));
1214 break;
1215 }
1216 case WINED3DQUERYTYPE_EVENT:
1217 object->extendedData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WineQueryEventData));
1218 ((WineQueryEventData *)(object->extendedData))->ctx = This->activeContext;
1219
1220 if(GL_SUPPORT(APPLE_FENCE)) {
1221 GL_EXTCALL(glGenFencesAPPLE(1, &((WineQueryEventData *)(object->extendedData))->fenceId));
1222 checkGLcall("glGenFencesAPPLE");
1223 } else if(GL_SUPPORT(NV_FENCE)) {
1224 GL_EXTCALL(glGenFencesNV(1, &((WineQueryEventData *)(object->extendedData))->fenceId));
1225 checkGLcall("glGenFencesNV");
1226 }
1227 break;
1228
1229 case WINED3DQUERYTYPE_VCACHE:
1230 case WINED3DQUERYTYPE_RESOURCEMANAGER:
1231 case WINED3DQUERYTYPE_VERTEXSTATS:
1232 case WINED3DQUERYTYPE_TIMESTAMP:
1233 case WINED3DQUERYTYPE_TIMESTAMPDISJOINT:
1234 case WINED3DQUERYTYPE_TIMESTAMPFREQ:
1235 case WINED3DQUERYTYPE_PIPELINETIMINGS:
1236 case WINED3DQUERYTYPE_INTERFACETIMINGS:
1237 case WINED3DQUERYTYPE_VERTEXTIMINGS:
1238 case WINED3DQUERYTYPE_PIXELTIMINGS:
1239 case WINED3DQUERYTYPE_BANDWIDTHTIMINGS:
1240 case WINED3DQUERYTYPE_CACHEUTILIZATION:
1241 default:
1242 object->extendedData = 0;
1243 FIXME("(%p) Unhandled query type %d\n",This , Type);
1244 }
1245 TRACE("(%p) : Created Query %p\n", This, object);
1246 return WINED3D_OK;
1247 }
1248
1249 /*****************************************************************************
1250 * IWineD3DDeviceImpl_SetupFullscreenWindow
1251 *
1252 * Helper function that modifies a HWND's Style and ExStyle for proper
1253 * fullscreen use.
1254 *
1255 * Params:
1256 * iface: Pointer to the IWineD3DDevice interface
1257 * window: Window to setup
1258 *
1259 *****************************************************************************/
1260 static LONG fullscreen_style(LONG orig_style) {
1261 LONG style = orig_style;
1262 style &= ~WS_CAPTION;
1263 style &= ~WS_THICKFRAME;
1264
1265 /* Make sure the window is managed, otherwise we won't get keyboard input */
1266 style |= WS_POPUP | WS_SYSMENU;
1267
1268 return style;
1269 }
1270
1271 static LONG fullscreen_exStyle(LONG orig_exStyle) {
1272 LONG exStyle = orig_exStyle;
1273
1274 /* Filter out window decorations */
1275 exStyle &= ~WS_EX_WINDOWEDGE;
1276 exStyle &= ~WS_EX_CLIENTEDGE;
1277
1278 return exStyle;
1279 }
1280
1281 static void WINAPI IWineD3DDeviceImpl_SetupFullscreenWindow(IWineD3DDevice *iface, HWND window) {
1282 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1283
1284 LONG style, exStyle;
1285 /* Don't do anything if an original style is stored.
1286 * That shouldn't happen
1287 */
1288 TRACE("(%p): Setting up window %p for exclusive mode\n", This, window);
1289 if (This->style || This->exStyle) {
1290 ERR("(%p): Want to change the window parameters of HWND %p, but "
1291 "another style is stored for restoration afterwards\n", This, window);
1292 }
1293
1294 /* Get the parameters and save them */
1295 style = GetWindowLongW(window, GWL_STYLE);
1296 exStyle = GetWindowLongW(window, GWL_EXSTYLE);
1297 This->style = style;
1298 This->exStyle = exStyle;
1299
1300 style = fullscreen_style(style);
1301 exStyle = fullscreen_exStyle(exStyle);
1302
1303 TRACE("Old style was %08x,%08x, setting to %08x,%08x\n",
1304 This->style, This->exStyle, style, exStyle);
1305
1306 SetWindowLongW(window, GWL_STYLE, style);
1307 SetWindowLongW(window, GWL_EXSTYLE, exStyle);
1308
1309 /* Inform the window about the update. */
1310 SetWindowPos(window, HWND_TOP, 0, 0,
1311 This->ddraw_width, This->ddraw_height, SWP_FRAMECHANGED);
1312 ShowWindow(window, SW_NORMAL);
1313 }
1314
1315 /*****************************************************************************
1316 * IWineD3DDeviceImpl_RestoreWindow
1317 *
1318 * Helper function that restores a windows' properties when taking it out
1319 * of fullscreen mode
1320 *
1321 * Params:
1322 * iface: Pointer to the IWineD3DDevice interface
1323 * window: Window to setup
1324 *
1325 *****************************************************************************/
1326 static void WINAPI IWineD3DDeviceImpl_RestoreWindow(IWineD3DDevice *iface, HWND window) {
1327 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1328 LONG style, exStyle;
1329
1330 /* This could be a DDSCL_NORMAL -> DDSCL_NORMAL
1331 * switch, do nothing
1332 */
1333 if (!This->style && !This->exStyle) return;
1334
1335 TRACE("(%p): Restoring window settings of window %p to %08x, %08x\n",
1336 This, window, This->style, This->exStyle);
1337
1338 style = GetWindowLongW(window, GWL_STYLE);
1339 exStyle = GetWindowLongW(window, GWL_EXSTYLE);
1340
1341 /* Only restore the style if the application didn't modify it during the fullscreen phase.
1342 * Some applications change it before calling Reset() when switching between windowed and
1343 * fullscreen modes(HL2), some depend on the original style(Eve Online)
1344 */
1345 if(style == fullscreen_style(This->style) &&
1346 exStyle == fullscreen_style(This->exStyle)) {
1347 SetWindowLongW(window, GWL_STYLE, This->style);
1348 SetWindowLongW(window, GWL_EXSTYLE, This->exStyle);
1349 }
1350
1351 /* Delete the old values */
1352 This->style = 0;
1353 This->exStyle = 0;
1354
1355 /* Inform the window about the update */
1356 SetWindowPos(window, 0 /* InsertAfter, ignored */,
1357 0, 0, 0, 0, /* Pos, Size, ignored */
1358 SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
1359 }
1360
1361 /* example at http://www.fairyengine.com/articles/dxmultiviews.htm */
1362 static HRESULT WINAPI IWineD3DDeviceImpl_CreateAdditionalSwapChain(IWineD3DDevice* iface, WINED3DPRESENT_PARAMETERS* pPresentationParameters, IWineD3DSwapChain** ppSwapChain,
1363 IUnknown* parent,
1364 D3DCB_CREATERENDERTARGETFN D3DCB_CreateRenderTarget,
1365 D3DCB_CREATEDEPTHSTENCILSURFACEFN D3DCB_CreateDepthStencil) {
1366 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1367
1368 HDC hDc;
1369 IWineD3DSwapChainImpl *object; /** NOTE: impl ref allowed since this is a create function **/
1370 HRESULT hr = WINED3D_OK;
1371 IUnknown *bufferParent;
1372 BOOL displaymode_set = FALSE;
1373 WINED3DDISPLAYMODE Mode;
1374 const StaticPixelFormatDesc *formatDesc;
1375
1376 TRACE("(%p) : Created Additional Swap Chain\n", This);
1377
1378 /** FIXME: Test under windows to find out what the life cycle of a swap chain is,
1379 * does a device hold a reference to a swap chain giving them a lifetime of the device
1380 * or does the swap chain notify the device of its destruction.
1381 *******************************/
1382
1383 /* Check the params */
1384 if(pPresentationParameters->BackBufferCount > WINED3DPRESENT_BACK_BUFFER_MAX) {
1385 ERR("App requested %d back buffers, this is not supported for now\n", pPresentationParameters->BackBufferCount);
1386 return WINED3DERR_INVALIDCALL;
1387 } else if (pPresentationParameters->BackBufferCount > 1) {
1388 FIXME("The app requests more than one back buffer, this can't be supported properly. Please configure the application to use double buffering(=1 back buffer) if possible\n");
1389 }
1390
1391 D3DCREATEOBJECTINSTANCE(object, SwapChain)
1392
1393 /*********************
1394 * Lookup the window Handle and the relating X window handle
1395 ********************/
1396
1397 /* Setup hwnd we are using, plus which display this equates to */
1398 object->win_handle = pPresentationParameters->hDeviceWindow;
1399 if (!object->win_handle) {
1400 object->win_handle = This->createParms.hFocusWindow;
1401 }
1402 if(!This->ddraw_window) IWineD3DDevice_SetHWND(iface, object->win_handle);
1403
1404 hDc = GetDC(object->win_handle);
1405 TRACE("Using hDc %p\n", hDc);
1406
1407 if (NULL == hDc) {
1408 WARN("Failed to get a HDc for Window %p\n", object->win_handle);
1409 return WINED3DERR_NOTAVAILABLE;
1410 }
1411
1412 /* Get info on the current display setup */
1413 IWineD3D_GetAdapterDisplayMode(This->wineD3D, This->adapter->num, &Mode);
1414 object->orig_width = Mode.Width;
1415 object->orig_height = Mode.Height;
1416 object->orig_fmt = Mode.Format;
1417 formatDesc = getFormatDescEntry(Mode.Format, NULL, NULL);
1418
1419 /** MSDN: If Windowed is TRUE and either of the BackBufferWidth/Height values is zero,
1420 * then the corresponding dimension of the client area of the hDeviceWindow
1421 * (or the focus window, if hDeviceWindow is NULL) is taken.
1422 **********************/
1423
1424 if (pPresentationParameters->Windowed &&
1425 ((pPresentationParameters->BackBufferWidth == 0) ||
1426 (pPresentationParameters->BackBufferHeight == 0) ||
1427 (pPresentationParameters->BackBufferFormat == WINED3DFMT_UNKNOWN))) {
1428
1429 RECT Rect;
1430 GetClientRect(object->win_handle, &Rect);
1431
1432 if (pPresentationParameters->BackBufferWidth == 0) {
1433 pPresentationParameters->BackBufferWidth = Rect.right;
1434 TRACE("Updating width to %d\n", pPresentationParameters->BackBufferWidth);
1435 }
1436 if (pPresentationParameters->BackBufferHeight == 0) {
1437 pPresentationParameters->BackBufferHeight = Rect.bottom;
1438 TRACE("Updating height to %d\n", pPresentationParameters->BackBufferHeight);
1439 }
1440 if (pPresentationParameters->BackBufferFormat == WINED3DFMT_UNKNOWN) {
1441 pPresentationParameters->BackBufferFormat = object->orig_fmt;
1442 TRACE("Updating format to %s\n", debug_d3dformat(object->orig_fmt));
1443 }
1444 }
1445
1446 /* Put the correct figures in the presentation parameters */
1447 TRACE("Copying across presentation parameters\n");
1448 object->presentParms = *pPresentationParameters;
1449
1450 TRACE("calling rendertarget CB\n");
1451 hr = D3DCB_CreateRenderTarget(This->parent,
1452 parent,
1453 object->presentParms.BackBufferWidth,
1454 object->presentParms.BackBufferHeight,
1455 object->presentParms.BackBufferFormat,
1456 object->presentParms.MultiSampleType,
1457 object->presentParms.MultiSampleQuality,
1458 TRUE /* Lockable */,
1459 &object->frontBuffer,
1460 NULL /* pShared (always null)*/);
1461 if (object->frontBuffer != NULL) {
1462 IWineD3DSurface_SetContainer(object->frontBuffer, (IWineD3DBase *)object);
1463 IWineD3DSurface_ModifyLocation(object->frontBuffer, SFLAG_INDRAWABLE, TRUE);
1464 } else {
1465 ERR("Failed to create the front buffer\n");
1466 goto error;
1467 }
1468
1469 /*********************
1470 * Windowed / Fullscreen
1471 *******************/
1472
1473 /**
1474 * TODO: MSDN says that we are only allowed one fullscreen swapchain per device,
1475 * so we should really check to see if there is a fullscreen swapchain already
1476 * I think Windows and X have different ideas about fullscreen, does a single head count as full screen?
1477 **************************************/
1478
1479 if (!pPresentationParameters->Windowed) {
1480 WINED3DDISPLAYMODE mode;
1481
1482
1483 /* Change the display settings */
1484 mode.Width = pPresentationParameters->BackBufferWidth;
1485 mode.Height = pPresentationParameters->BackBufferHeight;
1486 mode.Format = pPresentationParameters->BackBufferFormat;
1487 mode.RefreshRate = pPresentationParameters->FullScreen_RefreshRateInHz;
1488
1489 IWineD3DDevice_SetDisplayMode(iface, 0, &mode);
1490 displaymode_set = TRUE;
1491 IWineD3DDevice_SetFullscreen(iface, TRUE);
1492 }
1493
1494 /**
1495 * Create an opengl context for the display visual
1496 * NOTE: the visual is chosen as the window is created and the glcontext cannot
1497 * use different properties after that point in time. FIXME: How to handle when requested format
1498 * doesn't match actual visual? Cannot choose one here - code removed as it ONLY works if the one
1499 * it chooses is identical to the one already being used!
1500 **********************************/
1501 /** FIXME: Handle stencil appropriately via EnableAutoDepthStencil / AutoDepthStencilFormat **/
1502
1503 object->context = HeapAlloc(GetProcessHeap(), 0, sizeof(object->context));
1504 if(!object->context)
1505 return E_OUTOFMEMORY;
1506 object->num_contexts = 1;
1507
1508 object->context[0] = CreateContext(This, (IWineD3DSurfaceImpl *) object->frontBuffer, object->win_handle, FALSE /* pbuffer */, pPresentationParameters);
1509 if (!object->context[0]) {
1510 ERR("Failed to create a new context\n");
1511 hr = WINED3DERR_NOTAVAILABLE;
1512 goto error;
1513 } else {
1514 TRACE("Context created (HWND=%p, glContext=%p)\n",
1515 object->win_handle, object->context[0]->glCtx);
1516 }
1517
1518 /*********************
1519 * Create the back, front and stencil buffers
1520 *******************/
1521 if(object->presentParms.BackBufferCount > 0) {
1522 int i;
1523
1524 object->backBuffer = HeapAlloc(GetProcessHeap(), 0, sizeof(IWineD3DSurface *) * object->presentParms.BackBufferCount);
1525 if(!object->backBuffer) {
1526 ERR("Out of memory\n");
1527 hr = E_OUTOFMEMORY;
1528 goto error;
1529 }
1530
1531 for(i = 0; i < object->presentParms.BackBufferCount; i++) {
1532 TRACE("calling rendertarget CB\n");
1533 hr = D3DCB_CreateRenderTarget(This->parent,
1534 parent,
1535 object->presentParms.BackBufferWidth,
1536 object->presentParms.BackBufferHeight,
1537 object->presentParms.BackBufferFormat,
1538 object->presentParms.MultiSampleType,
1539 object->presentParms.MultiSampleQuality,
1540 TRUE /* Lockable */,
1541 &object->backBuffer[i],
1542 NULL /* pShared (always null)*/);
1543 if(hr == WINED3D_OK && object->backBuffer[i]) {
1544 IWineD3DSurface_SetContainer(object->backBuffer[i], (IWineD3DBase *)object);
1545 } else {
1546 ERR("Cannot create new back buffer\n");
1547 goto error;
1548 }
1549 ENTER_GL();
1550 glDrawBuffer(GL_BACK);
1551 checkGLcall("glDrawBuffer(GL_BACK)");
1552 LEAVE_GL();
1553 }
1554 } else {
1555 object->backBuffer = NULL;
1556
1557 /* Single buffering - draw to front buffer */
1558 ENTER_GL();
1559 glDrawBuffer(GL_FRONT);
1560 checkGLcall("glDrawBuffer(GL_FRONT)");
1561 LEAVE_GL();
1562 }
1563
1564 /* Under directX swapchains share the depth stencil, so only create one depth-stencil */
1565 if (pPresentationParameters->EnableAutoDepthStencil && hr == WINED3D_OK) {
1566 TRACE("Creating depth stencil buffer\n");
1567 if (This->auto_depth_stencil_buffer == NULL ) {
1568 hr = D3DCB_CreateDepthStencil(This->parent,
1569 parent,
1570 object->presentParms.BackBufferWidth,
1571 object->presentParms.BackBufferHeight,
1572 object->presentParms.AutoDepthStencilFormat,
1573 object->presentParms.MultiSampleType,
1574 object->presentParms.MultiSampleQuality,
1575 FALSE /* FIXME: Discard */,
1576 &This->auto_depth_stencil_buffer,
1577 NULL /* pShared (always null)*/ );
1578 if (This->auto_depth_stencil_buffer != NULL)
1579 IWineD3DSurface_SetContainer(This->auto_depth_stencil_buffer, 0);
1580 }
1581
1582 /** TODO: A check on width, height and multisample types
1583 *(since the zbuffer must be at least as large as the render target and have the same multisample parameters)
1584 ****************************/
1585 object->wantsDepthStencilBuffer = TRUE;
1586 } else {
1587 object->wantsDepthStencilBuffer = FALSE;
1588 }
1589
1590 TRACE("Created swapchain %p\n", object);
1591 TRACE("FrontBuf @ %p, BackBuf @ %p, DepthStencil %d\n",object->frontBuffer, object->backBuffer ? object->backBuffer[0] : NULL, object->wantsDepthStencilBuffer);
1592 return WINED3D_OK;
1593
1594 error:
1595 if (displaymode_set) {
1596 DEVMODEW devmode;
1597 RECT clip_rc;
1598
1599 SetRect(&clip_rc, 0, 0, object->orig_width, object->orig_height);
1600 ClipCursor(NULL);
1601
1602 /* Change the display settings */
1603 memset(&devmode, 0, sizeof(devmode));
1604 devmode.dmSize = sizeof(devmode);
1605 devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
1606 devmode.dmBitsPerPel = formatDesc->bpp * 8;
1607 devmode.dmPelsWidth = object->orig_width;
1608 devmode.dmPelsHeight = object->orig_height;
1609 ChangeDisplaySettingsExW(This->adapter->DeviceName, &devmode, NULL, CDS_FULLSCREEN, NULL);
1610 }
1611
1612 if (object->backBuffer) {
1613 int i;
1614 for(i = 0; i < object->presentParms.BackBufferCount; i++) {
1615 if(object->backBuffer[i]) {
1616 IWineD3DSurface_GetParent(object->backBuffer[i], &bufferParent);
1617 IUnknown_Release(bufferParent); /* once for the get parent */
1618 if (IUnknown_Release(bufferParent) > 0) {
1619 FIXME("(%p) Something's still holding the back buffer\n",This);
1620 }
1621 }
1622 }
1623 HeapFree(GetProcessHeap(), 0, object->backBuffer);
1624 object->backBuffer = NULL;
1625 }
1626 if(object->context[0])
1627 DestroyContext(This, object->context[0]);
1628 if(object->frontBuffer) {
1629 IWineD3DSurface_GetParent(object->frontBuffer, &bufferParent);
1630 IUnknown_Release(bufferParent); /* once for the get parent */
1631 if (IUnknown_Release(bufferParent) > 0) {
1632 FIXME("(%p) Something's still holding the front buffer\n",This);
1633 }
1634 }
1635 HeapFree(GetProcessHeap(), 0, object);
1636 return hr;
1637 }
1638
1639 /** NOTE: These are ahead of the other getters and setters to save using a forward declaration **/
1640 static UINT WINAPI IWineD3DDeviceImpl_GetNumberOfSwapChains(IWineD3DDevice *iface) {
1641 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1642 TRACE("(%p)\n", This);
1643
1644 return This->NumberOfSwapChains;
1645 }
1646
1647 static HRESULT WINAPI IWineD3DDeviceImpl_GetSwapChain(IWineD3DDevice *iface, UINT iSwapChain, IWineD3DSwapChain **pSwapChain) {
1648 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1649 TRACE("(%p) : swapchain %d\n", This, iSwapChain);
1650
1651 if(iSwapChain < This->NumberOfSwapChains) {
1652 *pSwapChain = This->swapchains[iSwapChain];
1653 IWineD3DSwapChain_AddRef(*pSwapChain);
1654 TRACE("(%p) returning %p\n", This, *pSwapChain);
1655 return WINED3D_OK;
1656 } else {
1657 TRACE("Swapchain out of range\n");
1658 *pSwapChain = NULL;
1659 return WINED3DERR_INVALIDCALL;
1660 }
1661 }
1662
1663 /*****
1664 * Vertex Declaration
1665 *****/
1666 static HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexDeclaration(IWineD3DDevice* iface, IWineD3DVertexDeclaration** ppVertexDeclaration,
1667 IUnknown *parent, const WINED3DVERTEXELEMENT *elements, UINT element_count) {
1668 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1669 IWineD3DVertexDeclarationImpl *object = NULL;
1670 HRESULT hr = WINED3D_OK;
1671
1672 TRACE("(%p) : directXVersion %u, elements %p, element_count %d, ppDecl=%p\n",
1673 This, ((IWineD3DImpl *)This->wineD3D)->dxVersion, elements, element_count, ppVertexDeclaration);
1674
1675 D3DCREATEOBJECTINSTANCE(object, VertexDeclaration)
1676
1677 hr = IWineD3DVertexDeclaration_SetDeclaration((IWineD3DVertexDeclaration *)object, elements, element_count);
1678 if(FAILED(hr)) {
1679 *ppVertexDeclaration = NULL;
1680 HeapFree(GetProcessHeap(), 0, object);
1681 }
1682
1683 return hr;
1684 }
1685
1686 static unsigned int ConvertFvfToDeclaration(IWineD3DDeviceImpl *This, /* For the GL info, which has the type table */
1687 DWORD fvf, WINED3DVERTEXELEMENT** ppVertexElements) {
1688
1689 unsigned int idx, idx2;
1690 unsigned int offset;
1691 BOOL has_pos = (fvf & WINED3DFVF_POSITION_MASK) != 0;
1692 BOOL has_blend = (fvf & WINED3DFVF_XYZB5) > WINED3DFVF_XYZRHW;
1693 BOOL has_blend_idx = has_blend &&
1694 (((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB5) ||
1695 (fvf & WINED3DFVF_LASTBETA_D3DCOLOR) ||
1696 (fvf & WINED3DFVF_LASTBETA_UBYTE4));
1697 BOOL has_normal = (fvf & WINED3DFVF_NORMAL) != 0;
1698 BOOL has_psize = (fvf & WINED3DFVF_PSIZE) != 0;
1699 BOOL has_diffuse = (fvf & WINED3DFVF_DIFFUSE) != 0;
1700 BOOL has_specular = (fvf & WINED3DFVF_SPECULAR) !=0;
1701
1702 DWORD num_textures = (fvf & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
1703 DWORD texcoords = (fvf & 0x00FF0000) >> 16;
1704
1705 WINED3DVERTEXELEMENT end_element = WINED3DDECL_END();
1706 WINED3DVERTEXELEMENT *elements = NULL;
1707
1708 unsigned int size;
1709 DWORD num_blends = 1 + (((fvf & WINED3DFVF_XYZB5) - WINED3DFVF_XYZB1) >> 1);
1710 if (has_blend_idx) num_blends--;
1711
1712 /* Compute declaration size */
1713 size = has_pos + (has_blend && num_blends > 0) + has_blend_idx + has_normal +
1714 has_psize + has_diffuse + has_specular + num_textures + 1;
1715
1716 /* convert the declaration */
1717 elements = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WINED3DVERTEXELEMENT));
1718 if (!elements)
1719 return 0;
1720
1721 elements[size-1] = end_element;
1722 idx = 0;
1723 if (has_pos) {
1724 if (!has_blend && (fvf & WINED3DFVF_XYZRHW)) {
1725 elements[idx].Type = WINED3DDECLTYPE_FLOAT4;
1726 elements[idx].Usage = WINED3DDECLUSAGE_POSITIONT;
1727 }
1728 else {
1729 elements[idx].Type = WINED3DDECLTYPE_FLOAT3;
1730 elements[idx].Usage = WINED3DDECLUSAGE_POSITION;
1731 }
1732 elements[idx].UsageIndex = 0;
1733 idx++;
1734 }
1735 if (has_blend && (num_blends > 0)) {
1736 if (((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB2) && (fvf & WINED3DFVF_LASTBETA_D3DCOLOR))
1737 elements[idx].Type = WINED3DDECLTYPE_D3DCOLOR;
1738 else
1739 elements[idx].Type = WINED3DDECLTYPE_FLOAT1 + num_blends - 1;
1740 elements[idx].Usage = WINED3DDECLUSAGE_BLENDWEIGHT;
1741 elements[idx].UsageIndex = 0;
1742 idx++;
1743 }
1744 if (has_blend_idx) {
1745 if (fvf & WINED3DFVF_LASTBETA_UBYTE4 ||
1746 (((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB2) && (fvf & WINED3DFVF_LASTBETA_D3DCOLOR)))
1747 elements[idx].Type = WINED3DDECLTYPE_UBYTE4;
1748 else if (fvf & WINED3DFVF_LASTBETA_D3DCOLOR)
1749 elements[idx].Type = WINED3DDECLTYPE_D3DCOLOR;
1750 else
1751 elements[idx].Type = WINED3DDECLTYPE_FLOAT1;
1752 elements[idx].Usage = WINED3DDECLUSAGE_BLENDINDICES;
1753 elements[idx].UsageIndex = 0;
1754 idx++;
1755 }
1756 if (has_normal) {
1757 elements[idx].Type = WINED3DDECLTYPE_FLOAT3;
1758 elements[idx].Usage = WINED3DDECLUSAGE_NORMAL;
1759 elements[idx].UsageIndex = 0;
1760 idx++;
1761 }
1762 if (has_psize) {
1763 elements[idx].Type = WINED3DDECLTYPE_FLOAT1;
1764 elements[idx].Usage = WINED3DDECLUSAGE_PSIZE;
1765 elements[idx].UsageIndex = 0;
1766 idx++;
1767 }
1768 if (has_diffuse) {
1769 elements[idx].Type = WINED3DDECLTYPE_D3DCOLOR;
1770 elements[idx].Usage = WINED3DDECLUSAGE_COLOR;
1771 elements[idx].UsageIndex = 0;
1772 idx++;
1773 }
1774 if (has_specular) {
1775 elements[idx].Type = WINED3DDECLTYPE_D3DCOLOR;
1776 elements[idx].Usage = WINED3DDECLUSAGE_COLOR;
1777 elements[idx].UsageIndex = 1;
1778 idx++;
1779 }
1780 for (idx2 = 0; idx2 < num_textures; idx2++) {
1781 unsigned int numcoords = (texcoords >> (idx2*2)) & 0x03;
1782 switch (numcoords) {
1783 case WINED3DFVF_TEXTUREFORMAT1:
1784 elements[idx].Type = WINED3DDECLTYPE_FLOAT1;
1785 break;
1786 case WINED3DFVF_TEXTUREFORMAT2:
1787 elements[idx].Type = WINED3DDECLTYPE_FLOAT2;
1788 break;
1789 case WINED3DFVF_TEXTUREFORMAT3:
1790 elements[idx].Type = WINED3DDECLTYPE_FLOAT3;
1791 break;
1792 case WINED3DFVF_TEXTUREFORMAT4:
1793 elements[idx].Type = WINED3DDECLTYPE_FLOAT4;
1794 break;
1795 }
1796 elements[idx].Usage = WINED3DDECLUSAGE_TEXCOORD;
1797 elements[idx].UsageIndex = idx2;
1798 idx++;
1799 }
1800
1801 /* Now compute offsets, and initialize the rest of the fields */
1802 for (idx = 0, offset = 0; idx < size-1; idx++) {
1803 elements[idx].Stream = 0;
1804 elements[idx].Method = WINED3DDECLMETHOD_DEFAULT;
1805 elements[idx].Offset = offset;
1806 offset += WINED3D_ATR_SIZE(elements[idx].Type) * WINED3D_ATR_TYPESIZE(elements[idx].Type);
1807 }
1808
1809 *ppVertexElements = elements;
1810 return size;
1811 }
1812
1813 static HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexDeclarationFromFVF(IWineD3DDevice* iface, IWineD3DVertexDeclaration** ppVertexDeclaration, IUnknown *Parent, DWORD Fvf) {
1814 WINED3DVERTEXELEMENT* elements = NULL;
1815 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
1816 unsigned int size;
1817 DWORD hr;
1818
1819 size = ConvertFvfToDeclaration(This, Fvf, &elements);
1820 if (size == 0) return WINED3DERR_OUTOFVIDEOMEMORY;
1821
1822 hr = IWineD3DDevice_CreateVertexDeclaration(iface, ppVertexDeclaration, Parent, elements, size);
1823 HeapFree(GetProcessHeap(), 0, elements);
1824 if (hr != S_OK) return hr;
1825
1826 return WINED3D_OK;
1827 }
1828
1829 static HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexShader(IWineD3DDevice *iface, IWineD3DVertexDeclaration *vertex_declaration, CONST DWORD *pFunction, IWineD3DVertexShader **ppVertexShader, IUnknown *parent) {
1830 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1831 IWineD3DVertexShaderImpl *object; /* NOTE: impl usage is ok, this is a create */
1832 HRESULT hr = WINED3D_OK;
1833 D3DCREATESHADEROBJECTINSTANCE(object, VertexShader)
1834 object->baseShader.shader_ins = IWineD3DVertexShaderImpl_shader_ins;
1835
1836 TRACE("(%p) : Created Vertex shader %p\n", This, *ppVertexShader);
1837
1838 if (vertex_declaration) {
1839 IWineD3DVertexShader_FakeSemantics(*ppVertexShader, vertex_declaration);
1840 }
1841
1842 hr = IWineD3DVertexShader_SetFunction(*ppVertexShader, pFunction);
1843
1844 if (WINED3D_OK != hr) {
1845 FIXME("(%p) : Failed to set the function, returning WINED3DERR_INVALIDCALL\n", iface);
1846 IWineD3DVertexShader_Release(*ppVertexShader);
1847 return WINED3DERR_INVALIDCALL;
1848 }
1849 list_add_head(&This->shaders, &object->baseShader.shader_list_entry);
1850
1851 return WINED3D_OK;
1852 }
1853
1854 static HRESULT WINAPI IWineD3DDeviceImpl_CreatePixelShader(IWineD3DDevice *iface, CONST DWORD *pFunction, IWineD3DPixelShader **ppPixelShader, IUnknown *parent) {
1855 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1856 IWineD3DPixelShaderImpl *object; /* NOTE: impl allowed, this is a create */
1857 HRESULT hr = WINED3D_OK;
1858
1859 D3DCREATESHADEROBJECTINSTANCE(object, PixelShader)
1860 object->baseShader.shader_ins = IWineD3DPixelShaderImpl_shader_ins;
1861 hr = IWineD3DPixelShader_SetFunction(*ppPixelShader, pFunction);
1862 if (WINED3D_OK == hr) {
1863 TRACE("(%p) : Created Pixel shader %p\n", This, *ppPixelShader);
1864 list_add_head(&This->shaders, &object->baseShader.shader_list_entry);
1865 } else {
1866 WARN("(%p) : Failed to create pixel shader\n", This);
1867 }
1868
1869 return hr;
1870 }
1871
1872 static HRESULT WINAPI IWineD3DDeviceImpl_CreatePalette(IWineD3DDevice *iface, DWORD Flags, PALETTEENTRY *PalEnt, IWineD3DPalette **Palette, IUnknown *Parent) {
1873 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
1874 IWineD3DPaletteImpl *object;
1875 HRESULT hr;
1876 TRACE("(%p)->(%x, %p, %p, %p)\n", This, Flags, PalEnt, Palette, Parent);
1877
1878 /* Create the new object */
1879 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DPaletteImpl));
1880 if(!object) {
1881 ERR("Out of memory when allocating memory for a IWineD3DPalette implementation\n");
1882 return E_OUTOFMEMORY;
1883 }
1884
1885 object->lpVtbl = &IWineD3DPalette_Vtbl;
1886 object->ref = 1;
1887 object->Flags = Flags;
1888 object->parent = Parent;
1889 object->wineD3DDevice = This;
1890 object->palNumEntries = IWineD3DPaletteImpl_Size(Flags);
1891
1892 object->hpal = CreatePalette((const LOGPALETTE*)&(object->palVersion));
1893
1894 if(!object->hpal) {
1895 HeapFree( GetProcessHeap(), 0, object);
1896 return E_OUTOFMEMORY;
1897 }
1898
1899 hr = IWineD3DPalette_SetEntries((IWineD3DPalette *) object, 0, 0, IWineD3DPaletteImpl_Size(Flags), PalEnt);
1900 if(FAILED(hr)) {
1901 IWineD3DPalette_Release((IWineD3DPalette *) object);
1902 return hr;
1903 }
1904
1905 *Palette = (IWineD3DPalette *) object;
1906
1907 return WINED3D_OK;
1908 }
1909
1910 static void IWineD3DDeviceImpl_LoadLogo(IWineD3DDeviceImpl *This, const char *filename) {
1911 HBITMAP hbm;
1912 BITMAP bm;
1913 HRESULT hr;
1914 HDC dcb = NULL, dcs = NULL;
1915 WINEDDCOLORKEY colorkey;
1916
1917 hbm = (HBITMAP) LoadImageA(NULL, filename, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
1918 if(hbm)
1919 {
1920 GetObjectA(hbm, sizeof(BITMAP), &bm);
1921 dcb = CreateCompatibleDC(NULL);
1922 if(!dcb) goto out;
1923 SelectObject(dcb, hbm);
1924 }
1925 else
1926 {
1927 /* Create a 32x32 white surface to indicate that wined3d is used, but the specified image
1928 * couldn't be loaded
1929 */
1930 memset(&bm, 0, sizeof(bm));
1931 bm.bmWidth = 32;
1932 bm.bmHeight = 32;
1933 }
1934
1935 hr = IWineD3DDevice_CreateSurface((IWineD3DDevice *) This, bm.bmWidth, bm.bmHeight, WINED3DFMT_R5G6B5,
1936 TRUE, FALSE, 0, &This->logo_surface, WINED3DRTYPE_SURFACE, 0,
1937 WINED3DPOOL_DEFAULT, WINED3DMULTISAMPLE_NONE, 0, NULL, SURFACE_OPENGL, NULL);
1938 if(FAILED(hr)) {
1939 ERR("Wine logo requested, but failed to create surface\n");
1940 goto out;
1941 }
1942
1943 if(dcb) {
1944 hr = IWineD3DSurface_GetDC(This->logo_surface, &dcs);
1945 if(FAILED(hr)) goto out;
1946 BitBlt(dcs, 0, 0, bm.bmWidth, bm.bmHeight, dcb, 0, 0, SRCCOPY);
1947 IWineD3DSurface_ReleaseDC(This->logo_surface, dcs);
1948
1949 colorkey.dwColorSpaceLowValue = 0;
1950 colorkey.dwColorSpaceHighValue = 0;
1951 IWineD3DSurface_SetColorKey(This->logo_surface, WINEDDCKEY_SRCBLT, &colorkey);
1952 } else {
1953 /* Fill the surface with a white color to show that wined3d is there */
1954 IWineD3DDevice_ColorFill((IWineD3DDevice *) This, This->logo_surface, NULL, 0xffffffff);
1955 }
1956
1957 out:
1958 if(dcb) {
1959 DeleteDC(dcb);
1960 }
1961 if(hbm) {
1962 DeleteObject(hbm);
1963 }
1964 return;
1965 }
1966
1967 static void create_dummy_textures(IWineD3DDeviceImpl *This) {
1968 unsigned int i;
1969 /* Under DirectX you can have texture stage operations even if no texture is
1970 bound, whereas opengl will only do texture operations when a valid texture is
1971 bound. We emulate this by creating dummy textures and binding them to each
1972 texture stage, but disable all stages by default. Hence if a stage is enabled
1973 then the default texture will kick in until replaced by a SetTexture call */
1974 ENTER_GL();
1975
1976 if(GL_SUPPORT(APPLE_CLIENT_STORAGE)) {
1977 /* The dummy texture does not have client storage backing */
1978 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
1979 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
1980 }
1981 for (i = 0; i < GL_LIMITS(textures); i++) {
1982 GLubyte white = 255;
1983
1984 /* Make appropriate texture active */
1985 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1986 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
1987 checkGLcall("glActiveTextureARB");
1988 } else if (i > 0) {
1989 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1990 }
1991
1992 /* Generate an opengl texture name */
1993 glGenTextures(1, &This->dummyTextureName[i]);
1994 checkGLcall("glGenTextures");
1995 TRACE("Dummy Texture %d given name %d\n", i, This->dummyTextureName[i]);
1996
1997 /* Generate a dummy 2d texture (not using 1d because they cause many
1998 * DRI drivers fall back to sw) */
1999 This->stateBlock->textureDimensions[i] = GL_TEXTURE_2D;
2000 glBindTexture(GL_TEXTURE_2D, This->dummyTextureName[i]);
2001 checkGLcall("glBindTexture");
2002
2003 glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 1, 1, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, &white);
2004 checkGLcall("glTexImage2D");
2005 }
2006 if(GL_SUPPORT(APPLE_CLIENT_STORAGE)) {
2007 /* Reenable because if supported it is enabled by default */
2008 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
2009 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
2010 }
2011
2012 LEAVE_GL();
2013 }
2014
2015 static HRESULT WINAPI IWineD3DDeviceImpl_Init3D(IWineD3DDevice *iface, WINED3DPRESENT_PARAMETERS* pPresentationParameters, D3DCB_CREATEADDITIONALSWAPCHAIN D3DCB_CreateAdditionalSwapChain) {
2016 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
2017 IWineD3DSwapChainImpl *swapchain = NULL;
2018 HRESULT hr;
2019 DWORD state;
2020 unsigned int i;
2021
2022 TRACE("(%p)->(%p,%p)\n", This, pPresentationParameters, D3DCB_CreateAdditionalSwapChain);
2023 if(This->d3d_initialized) return WINED3DERR_INVALIDCALL;
2024 if(!This->adapter->opengl) return WINED3DERR_INVALIDCALL;
2025
2026 /* TODO: Test if OpenGL is compiled in and loaded */
2027
2028 TRACE("(%p) : Creating stateblock\n", This);
2029 /* Creating the startup stateBlock - Note Special Case: 0 => Don't fill in yet! */
2030 hr = IWineD3DDevice_CreateStateBlock(iface,
2031 WINED3DSBT_INIT,
2032 (IWineD3DStateBlock **)&This->stateBlock,
2033 NULL);
2034 if (WINED3D_OK != hr) { /* Note: No parent needed for initial internal stateblock */
2035 WARN("Failed to create stateblock\n");
2036 goto err_out;
2037 }
2038 TRACE("(%p) : Created stateblock (%p)\n", This, This->stateBlock);
2039 This->updateStateBlock = This->stateBlock;
2040 IWineD3DStateBlock_AddRef((IWineD3DStateBlock*)This->updateStateBlock);
2041
2042 hr = allocate_shader_constants(This->updateStateBlock);
2043 if (WINED3D_OK != hr) {
2044 goto err_out;
2045 }
2046
2047 This->render_targets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DSurface *) * GL_LIMITS(buffers));
2048 This->fbo_color_attachments = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DSurface *) * GL_LIMITS(buffers));
2049 This->draw_buffers = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(GLenum) * GL_LIMITS(buffers));
2050
2051 This->NumberOfPalettes = 1;
2052 This->palettes = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PALETTEENTRY*));
2053 if(!This->palettes || !This->render_targets || !This->fbo_color_attachments || !This->draw_buffers) {
2054 ERR("Out of memory!\n");
2055 goto err_out;
2056 }
2057 This->palettes[0] = HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY) * 256);
2058 if(!This->palettes[0]) {
2059 ERR("Out of memory!\n");
2060 goto err_out;
2061 }
2062 for (i = 0; i < 256; ++i) {
2063 This->palettes[0][i].peRed = 0xFF;
2064 This->palettes[0][i].peGreen = 0xFF;
2065 This->palettes[0][i].peBlue = 0xFF;
2066 This->palettes[0][i].peFlags = 0xFF;
2067 }
2068 This->currentPalette = 0;
2069
2070 /* Initialize the texture unit mapping to a 1:1 mapping */
2071 for (state = 0; state < MAX_COMBINED_SAMPLERS; ++state) {
2072 if (state < GL_LIMITS(fragment_samplers)) {
2073 This->texUnitMap[state] = state;
2074 This->rev_tex_unit_map[state] = state;
2075 } else {
2076 This->texUnitMap[state] = -1;
2077 This->rev_tex_unit_map[state] = -1;
2078 }
2079 }
2080
2081 /* Setup the implicit swapchain */
2082 TRACE("Creating implicit swapchain\n");
2083 hr=D3DCB_CreateAdditionalSwapChain(This->parent, pPresentationParameters, (IWineD3DSwapChain **)&swapchain);
2084 if (FAILED(hr) || !swapchain) {
2085 WARN("Failed to create implicit swapchain\n");
2086 goto err_out;
2087 }
2088
2089 This->NumberOfSwapChains = 1;
2090 This->swapchains = HeapAlloc(GetProcessHeap(), 0, This->NumberOfSwapChains * sizeof(IWineD3DSwapChain *));
2091 if(!This->swapchains) {
2092 ERR("Out of memory!\n");
2093 goto err_out;
2094 }
2095 This->swapchains[0] = (IWineD3DSwapChain *) swapchain;
2096
2097 if(swapchain->backBuffer && swapchain->backBuffer[0]) {
2098 TRACE("Setting rendertarget to %p\n", swapchain->backBuffer);
2099 This->render_targets[0] = swapchain->backBuffer[0];
2100 This->lastActiveRenderTarget = swapchain->backBuffer[0];
2101 }
2102 else {
2103 TRACE("Setting rendertarget to %p\n", swapchain->frontBuffer);
2104 This->render_targets[0] = swapchain->frontBuffer;
2105 This->lastActiveRenderTarget = swapchain->frontBuffer;
2106 }
2107 IWineD3DSurface_AddRef(This->render_targets[0]);
2108 This->activeContext = swapchain->context[0];
2109 This->lastThread = GetCurrentThreadId();
2110
2111 /* Depth Stencil support */
2112 This->stencilBufferTarget = This->auto_depth_stencil_buffer;
2113 if (NULL != This->stencilBufferTarget) {
2114 IWineD3DSurface_AddRef(This->stencilBufferTarget);
2115 }
2116
2117 hr = This->shader_backend->shader_alloc_private(iface);
2118 if(FAILED(hr)) {
2119 TRACE("Shader private data couldn't be allocated\n");
2120 goto err_out;
2121 }
2122
2123 /* Set up some starting GL setup */
2124 ENTER_GL();
2125
2126 /* Setup all the devices defaults */
2127 IWineD3DStateBlock_InitStartupStateBlock((IWineD3DStateBlock *)This->stateBlock);
2128 create_dummy_textures(This);
2129 #if 0
2130 IWineD3DImpl_CheckGraphicsMemory();
2131 #endif
2132
2133 { /* Set a default viewport */
2134 WINED3DVIEWPORT vp;
2135 vp.X = 0;
2136 vp.Y = 0;
2137 vp.Width = pPresentationParameters->BackBufferWidth;
2138 vp.Height = pPresentationParameters->BackBufferHeight;
2139 vp.MinZ = 0.0f;
2140 vp.MaxZ = 1.0f;
2141 IWineD3DDevice_SetViewport((IWineD3DDevice *)This, &vp);
2142 }
2143
2144 /* Initialize the current view state */
2145 This->view_ident = 1;
2146 This->contexts[0]->last_was_rhw = 0;
2147 glGetIntegerv(GL_MAX_LIGHTS, &This->maxConcurrentLights);
2148 checkGLcall("glGetIntegerv(GL_MAX_LIGHTS, &This->maxConcurrentLights)");
2149
2150 switch(wined3d_settings.offscreen_rendering_mode) {
2151 case ORM_FBO:
2152 case ORM_PBUFFER:
2153 This->offscreenBuffer = GL_BACK;
2154 break;
2155
2156 case ORM_BACKBUFFER:
2157 {
2158 if(GL_LIMITS(aux_buffers) > 0) {
2159 TRACE("Using auxilliary buffer for offscreen rendering\n");
2160 This->offscreenBuffer = GL_AUX0;
2161 } else {
2162 TRACE("Using back buffer for offscreen rendering\n");
2163 This->offscreenBuffer = GL_BACK;
2164 }
2165 }
2166 }
2167
2168 TRACE("(%p) All defaults now set up, leaving Init3D with %p\n", This, This);
2169 LEAVE_GL();
2170
2171 /* Clear the screen */
2172 IWineD3DDevice_Clear((IWineD3DDevice *) This, 0, NULL,
2173 WINED3DCLEAR_TARGET | pPresentationParameters->EnableAutoDepthStencil ? WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL : 0,
2174 0x00, 1.0, 0);
2175
2176 This->d3d_initialized = TRUE;
2177
2178 if(wined3d_settings.logo) {
2179 IWineD3DDeviceImpl_LoadLogo(This, wined3d_settings.logo);
2180 }
2181 This->highest_dirty_ps_const = 0;
2182 This->highest_dirty_vs_const = 0;
2183 return WINED3D_OK;
2184
2185 err_out:
2186 This->shader_backend->shader_free_private(iface);
2187 HeapFree(GetProcessHeap(), 0, This->render_targets);
2188 HeapFree(GetProcessHeap(), 0, This->fbo_color_attachments);
2189 HeapFree(GetProcessHeap(), 0, This->draw_buffers);
2190 HeapFree(GetProcessHeap(), 0, This->swapchains);
2191 This->NumberOfSwapChains = 0;
2192 if(This->palettes) {
2193 HeapFree(GetProcessHeap(), 0, This->palettes[0]);
2194 HeapFree(GetProcessHeap(), 0, This->palettes);
2195 }
2196 This->NumberOfPalettes = 0;
2197 if(swapchain) {
2198 IWineD3DSwapChain_Release( (IWineD3DSwapChain *) swapchain);
2199 }
2200 This->draw_buffers = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(GLenum) * GL_LIMITS(buffers));
2201 if(This->stateBlock) {
2202 IWineD3DStateBlock_Release((IWineD3DStateBlock *) This->stateBlock);
2203 This->stateBlock = NULL;
2204 }
2205 return hr;
2206 }
2207
2208 static HRESULT WINAPI IWineD3DDeviceImpl_Uninit3D(IWineD3DDevice *iface, D3DCB_DESTROYSURFACEFN D3DCB_DestroyDepthStencilSurface, D3DCB_DESTROYSWAPCHAINFN D3DCB_DestroySwapChain) {
2209 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
2210 int sampler;
2211 UINT i;
2212 TRACE("(%p)\n", This);
2213
2214 if(!This->d3d_initialized) return WINED3DERR_INVALIDCALL;
2215
2216 /* I don't think that the interface guarantees that the device is destroyed from the same thread
2217 * it was created. Thus make sure a context is active for the glDelete* calls
2218 */
2219 ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
2220
2221 if(This->logo_surface) IWineD3DSurface_Release(This->logo_surface);
2222
2223 TRACE("Deleting high order patches\n");
2224 for(i = 0; i < PATCHMAP_SIZE; i++) {
2225 struct list *e1, *e2;
2226 struct WineD3DRectPatch *patch;
2227 LIST_FOR_EACH_SAFE(e1, e2, &This->patches[i]) {
2228 patch = LIST_ENTRY(e1, struct WineD3DRectPatch, entry);
2229 IWineD3DDevice_DeletePatch(iface, patch->Handle);
2230 }
2231 }
2232
2233 /* Delete the palette conversion shader if it is around */
2234 if(This->paletteConversionShader) {
2235 GL_EXTCALL(glDeleteProgramsARB(1, &This->paletteConversionShader));
2236 This->paletteConversionShader = 0;
2237 }
2238
2239 /* Delete the pbuffer context if there is any */
2240 if(This->pbufferContext) DestroyContext(This, This->pbufferContext);
2241
2242 /* Delete the mouse cursor texture */
2243 if(This->cursorTexture) {
2244 ENTER_GL();
2245 glDeleteTextures(1, &This->cursorTexture);
2246 LEAVE_GL();
2247 This->cursorTexture = 0;
2248 }
2249
2250 for (sampler = 0; sampler < MAX_FRAGMENT_SAMPLERS; ++sampler) {
2251 IWineD3DDevice_SetTexture(iface, sampler, NULL);
2252 }
2253 for (sampler = 0; sampler < MAX_VERTEX_SAMPLERS; ++sampler) {
2254 IWineD3DDevice_SetTexture(iface, WINED3DVERTEXTEXTURESAMPLER0 + sampler, NULL);
2255 }
2256
2257 /* Destroy the depth blt resources, they will be invalid after the reset. Also free shader
2258 * private data, it might contain opengl pointers
2259 */
2260 This->shader_backend->shader_destroy_depth_blt(iface);
2261 This->shader_backend->shader_free_private(iface);
2262
2263 /* Release the update stateblock */
2264 if(IWineD3DStateBlock_Release((IWineD3DStateBlock *)This->updateStateBlock) > 0){
2265 if(This->updateStateBlock != This->stateBlock)
2266 FIXME("(%p) Something's still holding the Update stateblock\n",This);
2267 }
2268 This->updateStateBlock = NULL;
2269
2270 { /* because were not doing proper internal refcounts releasing the primary state block
2271 causes recursion with the extra checks in ResourceReleased, to avoid this we have
2272 to set this->stateBlock = NULL; first */
2273 IWineD3DStateBlock *stateBlock = (IWineD3DStateBlock *)This->stateBlock;
2274 This->stateBlock = NULL;
2275
2276 /* Release the stateblock */
2277 if(IWineD3DStateBlock_Release(stateBlock) > 0){
2278 FIXME("(%p) Something's still holding the Update stateblock\n",This);
2279 }
2280 }
2281
2282 /* Release the buffers (with sanity checks)*/
2283 TRACE("Releasing the depth stencil buffer at %p\n", This->stencilBufferTarget);
2284 if(This->stencilBufferTarget != NULL && (IWineD3DSurface_Release(This->stencilBufferTarget) >0)){
2285 if(This->auto_depth_stencil_buffer != This->stencilBufferTarget)
2286 FIXME("(%p) Something's still holding the stencilBufferTarget\n",This);
2287 }
2288 This->stencilBufferTarget = NULL;
2289
2290 TRACE("Releasing the render target at %p\n", This->render_targets[0]);
2291 if(IWineD3DSurface_Release(This->render_targets[0]) >0){
2292 /* This check is a bit silly, it should be in swapchain_release FIXME("(%p) Something's still holding the renderTarget\n",This); */
2293 }
2294 TRACE("Setting rendertarget to NULL\n");
2295 This->render_targets[0] = NULL;
2296
2297 if (This->auto_depth_stencil_buffer) {
2298 if(D3DCB_DestroyDepthStencilSurface(This->auto_depth_stencil_buffer) > 0) {
2299 FIXME("(%p) Something's still holding the auto depth stencil buffer\n", This);
2300 }
2301 This->auto_depth_stencil_buffer = NULL;
2302 }
2303
2304 for(i=0; i < This->NumberOfSwapChains; i++) {
2305 TRACE("Releasing the implicit swapchain %d\n", i);
2306 if (D3DCB_DestroySwapChain(This->swapchains[i]) > 0) {
2307 FIXME("(%p) Something's still holding the implicit swapchain\n", This);
2308 }
2309 }
2310
2311 HeapFree(GetProcessHeap(), 0, This->swapchains);
2312 This->swapchains = NULL;
2313 This->NumberOfSwapChains = 0;
2314
2315 for (i = 0; i < This->NumberOfPalettes; i++) HeapFree(GetProcessHeap(), 0, This->palettes[i]);
2316 HeapFree(GetProcessHeap(), 0, This->palettes);
2317 This->palettes = NULL;
2318 This->NumberOfPalettes = 0;
2319
2320 HeapFree(GetProcessHeap(), 0, This->render_targets);
2321 HeapFree(GetProcessHeap(), 0, This->fbo_color_attachments);
2322 HeapFree(GetProcessHeap(), 0, This->draw_buffers);
2323 This->render_targets = NULL;
2324 This->fbo_color_attachments = NULL;
2325 This->draw_buffers = NULL;
2326
2327 This->d3d_initialized = FALSE;
2328 return WINED3D_OK;
2329 }
2330
2331 static void WINAPI IWineD3DDeviceImpl_SetFullscreen(IWineD3DDevice *iface, BOOL fullscreen) {
2332 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
2333 TRACE("(%p) Setting DDraw fullscreen mode to %s\n", This, fullscreen ? "true" : "false");
2334
2335 /* Setup the window for fullscreen mode */
2336 if(fullscreen && !This->ddraw_fullscreen) {
2337 IWineD3DDeviceImpl_SetupFullscreenWindow(iface, This->ddraw_window);
2338 } else if(!fullscreen && This->ddraw_fullscreen) {
2339 IWineD3DDeviceImpl_RestoreWindow(iface, This->ddraw_window);
2340 }
2341
2342 /* DirectDraw apps can change between fullscreen and windowed mode after device creation with
2343 * IDirectDraw7::SetCooperativeLevel. The GDI surface implementation needs to know this.
2344 * DDraw doesn't necessarily have a swapchain, so we have to store the fullscreen flag
2345 * separately.
2346 */
2347 This->ddraw_fullscreen = fullscreen;
2348 }
2349
2350 /* Enables thread safety in the wined3d device and its resources. Called by DirectDraw
2351 * from SetCooperativeLevel if DDSCL_MULTITHREADED is specified, and by d3d8/9 from
2352 * CreateDevice if D3DCREATE_MULTITHREADED is passed.
2353 *
2354 * There is no way to deactivate thread safety once it is enabled.
2355 */
2356 static void WINAPI IWineD3DDeviceImpl_SetMultithreaded(IWineD3DDevice *iface) {
2357 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
2358
2359 /*For now just store the flag(needed in case of ddraw) */
2360 This->createParms.BehaviorFlags |= WINED3DCREATE_MULTITHREADED;
2361
2362 return;
2363 }
2364
2365 static HRESULT WINAPI IWineD3DDeviceImpl_SetDisplayMode(IWineD3DDevice *iface, UINT iSwapChain, WINED3DDISPLAYMODE* pMode) {
2366 DEVMODEW devmode;
2367 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2368 LONG ret;
2369 const StaticPixelFormatDesc *formatDesc = getFormatDescEntry(pMode->Format, NULL, NULL);
2370 RECT clip_rc;
2371
2372 TRACE("(%p)->(%d,%p) Mode=%dx%dx@%d, %s\n", This, iSwapChain, pMode, pMode->Width, pMode->Height, pMode->RefreshRate, debug_d3dformat(pMode->Format));
2373
2374 /* Resize the screen even without a window:
2375 * The app could have unset it with SetCooperativeLevel, but not called
2376 * RestoreDisplayMode first. Then the release will call RestoreDisplayMode,
2377 * but we don't have any hwnd
2378 */
2379
2380 memset(&devmode, 0, sizeof(devmode));
2381 devmode.dmSize = sizeof(devmode);
2382 devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
2383 devmode.dmBitsPerPel = formatDesc->bpp * 8;
2384 devmode.dmPelsWidth = pMode->Width;
2385 devmode.dmPelsHeight = pMode->Height;
2386
2387 devmode.dmDisplayFrequency = pMode->RefreshRate;
2388 if (pMode->RefreshRate != 0) {
2389 devmode.dmFields |= DM_DISPLAYFREQUENCY;
2390 }
2391
2392 /* Only change the mode if necessary */
2393 if( (This->ddraw_width == pMode->Width) &&
2394 (This->ddraw_height == pMode->Height) &&
2395 (This->ddraw_format == pMode->Format) &&
2396 (pMode->RefreshRate == 0) ) {
2397 return WINED3D_OK;
2398 }
2399
2400 ret = ChangeDisplaySettingsExW(NULL, &devmode, NULL, CDS_FULLSCREEN, NULL);
2401 if (ret != DISP_CHANGE_SUCCESSFUL) {
2402 if(devmode.dmDisplayFrequency != 0) {
2403 WARN("ChangeDisplaySettingsExW failed, trying without the refresh rate\n");
2404 devmode.dmFields &= ~DM_DISPLAYFREQUENCY;
2405 devmode.dmDisplayFrequency = 0;
2406 ret = ChangeDisplaySettingsExW(NULL, &devmode, NULL, CDS_FULLSCREEN, NULL) != DISP_CHANGE_SUCCESSFUL;
2407 }
2408 if(ret != DISP_CHANGE_SUCCESSFUL) {
2409 return WINED3DERR_NOTAVAILABLE;
2410 }
2411 }
2412
2413 /* Store the new values */
2414 This->ddraw_width = pMode->Width;
2415 This->ddraw_height = pMode->Height;
2416 This->ddraw_format = pMode->Format;
2417
2418 /* Only do this with a window of course, and only if we're fullscreened */
2419 if(This->ddraw_window && This->ddraw_fullscreen)
2420 MoveWindow(This->ddraw_window, 0, 0, pMode->Width, pMode->Height, TRUE);
2421
2422 /* And finally clip mouse to our screen */
2423 SetRect(&clip_rc, 0, 0, pMode->Width, pMode->Height);
2424 ClipCursor(&clip_rc);
2425
2426 return WINED3D_OK;
2427 }
2428
2429 static HRESULT WINAPI IWineD3DDeviceImpl_GetDirect3D(IWineD3DDevice *iface, IWineD3D **ppD3D) {
2430 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2431 *ppD3D= This->wineD3D;
2432 TRACE("(%p) : wineD3D returning %p\n", This, *ppD3D);
2433 IWineD3D_AddRef(*ppD3D);
2434 return WINED3D_OK;
2435 }
2436
2437 static UINT WINAPI IWineD3DDeviceImpl_GetAvailableTextureMem(IWineD3DDevice *iface) {
2438 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2439
2440 TRACE("(%p) : simulating %dMB, returning %dMB left\n", This,
2441 (This->adapter->TextureRam/(1024*1024)),
2442 ((This->adapter->TextureRam - This->adapter->UsedTextureRam) / (1024*1024)));
2443 /* return simulated texture memory left */
2444 return (This->adapter->TextureRam - This->adapter->UsedTextureRam);
2445 }
2446
2447
2448
2449 /*****
2450 * Get / Set FVF
2451 *****/
2452 static HRESULT WINAPI IWineD3DDeviceImpl_SetFVF(IWineD3DDevice *iface, DWORD fvf) {
2453 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2454
2455 /* Update the current state block */
2456 This->updateStateBlock->changed.fvf = TRUE;
2457
2458 if(This->updateStateBlock->fvf == fvf) {
2459 TRACE("Application is setting the old fvf over, nothing to do\n");
2460 return WINED3D_OK;
2461 }
2462
2463 This->updateStateBlock->fvf = fvf;
2464 TRACE("(%p) : FVF Shader FVF set to %x\n", This, fvf);
2465 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VDECL);
2466 return WINED3D_OK;
2467 }
2468
2469
2470 static HRESULT WINAPI IWineD3DDeviceImpl_GetFVF(IWineD3DDevice *iface, DWORD *pfvf) {
2471 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2472 TRACE("(%p) : GetFVF returning %x\n", This, This->stateBlock->fvf);
2473 *pfvf = This->stateBlock->fvf;
2474 return WINED3D_OK;
2475 }
2476
2477 /*****
2478 * Get / Set Stream Source
2479 *****/
2480 static HRESULT WINAPI IWineD3DDeviceImpl_SetStreamSource(IWineD3DDevice *iface, UINT StreamNumber,IWineD3DVertexBuffer* pStreamData, UINT OffsetInBytes, UINT Stride) {
2481 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2482 IWineD3DVertexBuffer *oldSrc;
2483
2484 if (StreamNumber >= MAX_STREAMS) {
2485 WARN("Stream out of range %d\n", StreamNumber);
2486 return WINED3DERR_INVALIDCALL;
2487 } else if(OffsetInBytes & 0x3) {
2488 WARN("OffsetInBytes is not 4 byte aligned: %d\n", OffsetInBytes);
2489 return WINED3DERR_INVALIDCALL;
2490 }
2491
2492 oldSrc = This->updateStateBlock->streamSource[StreamNumber];
2493 TRACE("(%p) : StreamNo: %u, OldStream (%p), NewStream (%p), OffsetInBytes %u, NewStride %u\n", This, StreamNumber, oldSrc, pStreamData, OffsetInBytes, Stride);
2494
2495 This->updateStateBlock->changed.streamSource[StreamNumber] = TRUE;
2496
2497 if(oldSrc == pStreamData &&
2498 This->updateStateBlock->streamStride[StreamNumber] == Stride &&
2499 This->updateStateBlock->streamOffset[StreamNumber] == OffsetInBytes) {
2500 TRACE("Application is setting the old values over, nothing to do\n");
2501 return WINED3D_OK;
2502 }
2503
2504 This->updateStateBlock->streamSource[StreamNumber] = pStreamData;
2505 if (pStreamData) {
2506 This->updateStateBlock->streamStride[StreamNumber] = Stride;
2507 This->updateStateBlock->streamOffset[StreamNumber] = OffsetInBytes;
2508 }
2509
2510 /* Handle recording of state blocks */
2511 if (This->isRecordingState) {
2512 TRACE("Recording... not performing anything\n");
2513 if(pStreamData) IWineD3DVertexBuffer_AddRef(pStreamData);
2514 if(oldSrc) IWineD3DVertexBuffer_Release(oldSrc);
2515 return WINED3D_OK;
2516 }
2517
2518 /* Need to do a getParent and pass the references up */
2519 /* MSDN says ..... When an application no longer holds a reference to this interface, the interface will automatically be freed.
2520 which suggests that we shouldn't be ref counting? and do need a _release on the stream source to reset the stream source
2521 so for now, just count internally */
2522 if (pStreamData != NULL) {
2523 IWineD3DVertexBufferImpl *vbImpl = (IWineD3DVertexBufferImpl *) pStreamData;
2524 InterlockedIncrement(&vbImpl->bindCount);
2525 IWineD3DVertexBuffer_AddRef(pStreamData);
2526 }
2527 if (oldSrc != NULL) {
2528 InterlockedDecrement(&((IWineD3DVertexBufferImpl *) oldSrc)->bindCount);
2529 IWineD3DVertexBuffer_Release(oldSrc);
2530 }
2531
2532 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
2533
2534 return WINED3D_OK;
2535 }
2536
2537 static HRESULT WINAPI IWineD3DDeviceImpl_GetStreamSource(IWineD3DDevice *iface, UINT StreamNumber,IWineD3DVertexBuffer** pStream, UINT *pOffset, UINT* pStride) {
2538 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2539
2540 TRACE("(%p) : StreamNo: %u, Stream (%p), Offset %u, Stride %u\n", This, StreamNumber,
2541 This->stateBlock->streamSource[StreamNumber],
2542 This->stateBlock->streamOffset[StreamNumber],
2543 This->stateBlock->streamStride[StreamNumber]);
2544
2545 if (StreamNumber >= MAX_STREAMS) {
2546 WARN("Stream out of range %d\n", StreamNumber);
2547 return WINED3DERR_INVALIDCALL;
2548 }
2549 *pStream = This->stateBlock->streamSource[StreamNumber];
2550 *pStride = This->stateBlock->streamStride[StreamNumber];
2551 if (pOffset) {
2552 *pOffset = This->stateBlock->streamOffset[StreamNumber];
2553 }
2554
2555 if (*pStream != NULL) {
2556 IWineD3DVertexBuffer_AddRef(*pStream); /* We have created a new reference to the VB */
2557 }
2558 return WINED3D_OK;
2559 }
2560
2561 static HRESULT WINAPI IWineD3DDeviceImpl_SetStreamSourceFreq(IWineD3DDevice *iface, UINT StreamNumber, UINT Divider) {
2562 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2563 UINT oldFlags = This->updateStateBlock->streamFlags[StreamNumber];
2564 UINT oldFreq = This->updateStateBlock->streamFreq[StreamNumber];
2565
2566 TRACE("(%p) StreamNumber(%d), Divider(%d)\n", This, StreamNumber, Divider);
2567 This->updateStateBlock->streamFlags[StreamNumber] = Divider & (WINED3DSTREAMSOURCE_INSTANCEDATA | WINED3DSTREAMSOURCE_INDEXEDDATA );
2568
2569 This->updateStateBlock->changed.streamFreq[StreamNumber] = TRUE;
2570 This->updateStateBlock->streamFreq[StreamNumber] = Divider & 0x7FFFFF;
2571
2572 if(This->updateStateBlock->streamFreq[StreamNumber] != oldFreq ||
2573 This->updateStateBlock->streamFlags[StreamNumber] != oldFlags) {
2574 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
2575 }
2576
2577 return WINED3D_OK;
2578 }
2579
2580 static HRESULT WINAPI IWineD3DDeviceImpl_GetStreamSourceFreq(IWineD3DDevice *iface, UINT StreamNumber, UINT* Divider) {
2581 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2582
2583 TRACE("(%p) StreamNumber(%d), Divider(%p)\n", This, StreamNumber, Divider);
2584 *Divider = This->updateStateBlock->streamFreq[StreamNumber] | This->updateStateBlock->streamFlags[StreamNumber];
2585
2586 TRACE("(%p) : returning %d\n", This, *Divider);
2587
2588 return WINED3D_OK;
2589 }
2590
2591 /*****
2592 * Get / Set & Multiply Transform
2593 *****/
2594 static HRESULT WINAPI IWineD3DDeviceImpl_SetTransform(IWineD3DDevice *iface, WINED3DTRANSFORMSTATETYPE d3dts, CONST WINED3DMATRIX* lpmatrix) {
2595 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2596
2597 /* Most of this routine, comments included copied from ddraw tree initially: */
2598 TRACE("(%p) : Transform State=%s\n", This, debug_d3dtstype(d3dts));
2599
2600 /* Handle recording of state blocks */
2601 if (This->isRecordingState) {
2602 TRACE("Recording... not performing anything\n");
2603 This->updateStateBlock->changed.transform[d3dts] = TRUE;
2604 This->updateStateBlock->transforms[d3dts] = *lpmatrix;
2605 return WINED3D_OK;
2606 }
2607
2608 /*
2609 * If the new matrix is the same as the current one,
2610 * we cut off any further processing. this seems to be a reasonable
2611 * optimization because as was noticed, some apps (warcraft3 for example)
2612 * tend towards setting the same matrix repeatedly for some reason.
2613 *
2614 * From here on we assume that the new matrix is different, wherever it matters.
2615 */
2616 if (!memcmp(&This->stateBlock->transforms[d3dts].u.m[0][0], lpmatrix, sizeof(WINED3DMATRIX))) {
2617 TRACE("The app is setting the same matrix over again\n");
2618 return WINED3D_OK;
2619 } else {
2620 conv_mat(lpmatrix, &This->stateBlock->transforms[d3dts].u.m[0][0]);
2621 }
2622
2623 /*
2624 ScreenCoord = ProjectionMat * ViewMat * WorldMat * ObjectCoord
2625 where ViewMat = Camera space, WorldMat = world space.
2626
2627 In OpenGL, camera and world space is combined into GL_MODELVIEW
2628 matrix. The Projection matrix stay projection matrix.
2629 */
2630
2631 /* Capture the times we can just ignore the change for now */
2632 if (d3dts == WINED3DTS_VIEW) { /* handle the VIEW matrix */
2633 This->view_ident = !memcmp(lpmatrix, identity, 16 * sizeof(float));
2634 /* Handled by the state manager */
2635 }
2636
2637 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TRANSFORM(d3dts));
2638 return WINED3D_OK;
2639
2640 }
2641 static HRESULT WINAPI IWineD3DDeviceImpl_GetTransform(IWineD3DDevice *iface, WINED3DTRANSFORMSTATETYPE State, WINED3DMATRIX* pMatrix) {
2642 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2643 TRACE("(%p) : for Transform State %s\n", This, debug_d3dtstype(State));
2644 *pMatrix = This->stateBlock->transforms[State];
2645 return WINED3D_OK;
2646 }
2647
2648 static HRESULT WINAPI IWineD3DDeviceImpl_MultiplyTransform(IWineD3DDevice *iface, WINED3DTRANSFORMSTATETYPE State, CONST WINED3DMATRIX* pMatrix) {
2649 WINED3DMATRIX *mat = NULL;
2650 WINED3DMATRIX temp;
2651
2652 /* Note: Using 'updateStateBlock' rather than 'stateblock' in the code
2653 * below means it will be recorded in a state block change, but it
2654 * works regardless where it is recorded.
2655 * If this is found to be wrong, change to StateBlock.
2656 */
2657 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2658 TRACE("(%p) : For state %s\n", This, debug_d3dtstype(State));
2659
2660 if (State < HIGHEST_TRANSFORMSTATE)
2661 {
2662 mat = &This->updateStateBlock->transforms[State];
2663 } else {
2664 FIXME("Unhandled transform state!!\n");
2665 }
2666
2667 multiply_matrix(&temp, mat, pMatrix);
2668
2669 /* Apply change via set transform - will reapply to eg. lights this way */
2670 return IWineD3DDeviceImpl_SetTransform(iface, State, &temp);
2671 }
2672
2673 /*****
2674 * Get / Set Light
2675 *****/
2676 /* Note lights are real special cases. Although the device caps state only eg. 8 are supported,
2677 you can reference any indexes you want as long as that number max are enabled at any
2678 one point in time! Therefore since the indexes can be anything, we need a hashmap of them.
2679 However, this causes stateblock problems. When capturing the state block, I duplicate the hashmap,
2680 but when recording, just build a chain pretty much of commands to be replayed. */
2681
2682 static HRESULT WINAPI IWineD3DDeviceImpl_SetLight(IWineD3DDevice *iface, DWORD Index, CONST WINED3DLIGHT* pLight) {
2683 float rho;
2684 PLIGHTINFOEL *object = NULL;
2685 UINT Hi = LIGHTMAP_HASHFUNC(Index);
2686 struct list *e;
2687
2688 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2689 TRACE("(%p) : Idx(%d), pLight(%p). Hash index is %d\n", This, Index, pLight, Hi);
2690
2691 /* Check the parameter range. Need for speed most wanted sets junk lights which confuse
2692 * the gl driver.
2693 */
2694 if(!pLight) {
2695 WARN("Light pointer = NULL, returning WINED3DERR_INVALIDCALL\n");
2696 return WINED3DERR_INVALIDCALL;
2697 }
2698
2699 switch(pLight->Type) {
2700 case WINED3DLIGHT_POINT:
2701 case WINED3DLIGHT_SPOT:
2702 case WINED3DLIGHT_PARALLELPOINT:
2703 case WINED3DLIGHT_GLSPOT:
2704 /* Incorrect attenuation values can cause the gl driver to crash. Happens with Need for speed
2705 * most wanted
2706 */
2707 if(pLight->Attenuation0 < 0.0 || pLight->Attenuation1 < 0.0 || pLight->Attenuation2 < 0.0) {
2708 WARN("Attenuation is negative, returning WINED3DERR_INVALIDCALL\n");
2709 return WINED3DERR_INVALIDCALL;
2710 }
2711 break;
2712
2713 case WINED3DLIGHT_DIRECTIONAL:
2714 /* Ignores attenuation */
2715 break;
2716
2717 default:
2718 WARN("Light type out of range, returning WINED3DERR_INVALIDCALL\n");
2719 return WINED3DERR_INVALIDCALL;
2720 }
2721
2722 LIST_FOR_EACH(e, &This->updateStateBlock->lightMap[Hi]) {
2723 object = LIST_ENTRY(e, PLIGHTINFOEL, entry);
2724 if(object->OriginalIndex == Index) break;
2725 object = NULL;
2726 }
2727
2728 if(!object) {
2729 TRACE("Adding new light\n");
2730 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2731 if(!object) {
2732 ERR("Out of memory error when allocating a light\n");
2733 return E_OUTOFMEMORY;
2734 }
2735 list_add_head(&This->updateStateBlock->lightMap[Hi], &object->entry);
2736 object->glIndex = -1;
2737 object->OriginalIndex = Index;
2738 object->changed = TRUE;
2739 }
2740
2741 /* Initialize the object */
2742 TRACE("Light %d setting to type %d, Diffuse(%f,%f,%f,%f), Specular(%f,%f,%f,%f), Ambient(%f,%f,%f,%f)\n", Index, pLight->Type,
2743 pLight->Diffuse.r, pLight->Diffuse.g, pLight->Diffuse.b, pLight->Diffuse.a,
2744 pLight->Specular.r, pLight->Specular.g, pLight->Specular.b, pLight->Specular.a,
2745 pLight->Ambient.r, pLight->Ambient.g, pLight->Ambient.b, pLight->Ambient.a);
2746 TRACE("... Pos(%f,%f,%f), Dirn(%f,%f,%f)\n", pLight->Position.x, pLight->Position.y, pLight->Position.z,
2747 pLight->Direction.x, pLight->Direction.y, pLight->Direction.z);
2748 TRACE("... Range(%f), Falloff(%f), Theta(%f), Phi(%f)\n", pLight->Range, pLight->Falloff, pLight->Theta, pLight->Phi);
2749
2750 /* Save away the information */
2751 object->OriginalParms = *pLight;
2752
2753 switch (pLight->Type) {
2754 case WINED3DLIGHT_POINT:
2755 /* Position */
2756 object->lightPosn[0] = pLight->Position.x;
2757 object->lightPosn[1] = pLight->Position.y;
2758 object->lightPosn[2] = pLight->Position.z;
2759 object->lightPosn[3] = 1.0f;
2760 object->cutoff = 180.0f;
2761 /* FIXME: Range */
2762 break;
2763
2764 case WINED3DLIGHT_DIRECTIONAL:
2765 /* Direction */
2766 object->lightPosn[0] = -pLight->Direction.x;
2767 object->lightPosn[1] = -pLight->Direction.y;
2768 object->lightPosn[2] = -pLight->Direction.z;
2769 object->lightPosn[3] = 0.0;
2770 object->exponent = 0.0f;
2771 object->cutoff = 180.0f;
2772 break;
2773
2774 case WINED3DLIGHT_SPOT:
2775 /* Position */
2776 object->lightPosn[0] = pLight->Position.x;
2777 object->lightPosn[1] = pLight->Position.y;
2778 object->lightPosn[2] = pLight->Position.z;
2779 object->lightPosn[3] = 1.0;
2780
2781 /* Direction */
2782 object->lightDirn[0] = pLight->Direction.x;
2783 object->lightDirn[1] = pLight->Direction.y;
2784 object->lightDirn[2] = pLight->Direction.z;
2785 object->lightDirn[3] = 1.0;
2786
2787 /*
2788 * opengl-ish and d3d-ish spot lights use too different models for the
2789 * light "intensity" as a function of the angle towards the main light direction,
2790 * so we only can approximate very roughly.
2791 * however spot lights are rather rarely used in games (if ever used at all).
2792 * furthermore if still used, probably nobody pays attention to such details.
2793 */
2794 if (pLight->Falloff == 0) {
2795 /* Falloff = 0 is easy, because d3d's and opengl's spot light equations have the
2796 * falloff resp. exponent parameter as an exponent, so the spot light lighting
2797 * will always be 1.0 for both of them, and we don't have to care for the
2798 * rest of the rather complex calculation
2799 */
2800 object->exponent = 0;
2801 } else {
2802 rho = pLight->Theta + (pLight->Phi - pLight->Theta)/(2*pLight->Falloff);
2803 if (rho < 0.0001) rho = 0.0001f;
2804 object->exponent = -0.3/log(cos(rho/2));
2805 }
2806 if (object->exponent > 128.0) {
2807 object->exponent = 128.0;
2808 }
2809 object->cutoff = pLight->Phi*90/M_PI;
2810
2811 /* FIXME: Range */
2812 break;
2813
2814 default:
2815 FIXME("Unrecognized light type %d\n", pLight->Type);
2816 }
2817
2818 /* Update the live definitions if the light is currently assigned a glIndex */
2819 if (object->glIndex != -1 && !This->isRecordingState) {
2820 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(object->glIndex));
2821 }
2822 return WINED3D_OK;
2823 }
2824
2825 static HRESULT WINAPI IWineD3DDeviceImpl_GetLight(IWineD3DDevice *iface, DWORD Index, WINED3DLIGHT* pLight) {
2826 PLIGHTINFOEL *lightInfo = NULL;
2827 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2828 DWORD Hi = LIGHTMAP_HASHFUNC(Index);
2829 struct list *e;
2830 TRACE("(%p) : Idx(%d), pLight(%p)\n", This, Index, pLight);
2831
2832 LIST_FOR_EACH(e, &This->stateBlock->lightMap[Hi]) {
2833 lightInfo = LIST_ENTRY(e, PLIGHTINFOEL, entry);
2834 if(lightInfo->OriginalIndex == Index) break;
2835 lightInfo = NULL;
2836 }
2837
2838 if (lightInfo == NULL) {
2839 TRACE("Light information requested but light not defined\n");
2840 return WINED3DERR_INVALIDCALL;
2841 }
2842
2843 *pLight = lightInfo->OriginalParms;
2844 return WINED3D_OK;
2845 }
2846
2847 /*****
2848 * Get / Set Light Enable
2849 * (Note for consistency, renamed d3dx function by adding the 'set' prefix)
2850 *****/
2851 static HRESULT WINAPI IWineD3DDeviceImpl_SetLightEnable(IWineD3DDevice *iface, DWORD Index, BOOL Enable) {
2852 PLIGHTINFOEL *lightInfo = NULL;
2853 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2854 UINT Hi = LIGHTMAP_HASHFUNC(Index);
2855 struct list *e;
2856 TRACE("(%p) : Idx(%d), enable? %d\n", This, Index, Enable);
2857
2858 /* Tests show true = 128...not clear why */
2859 Enable = Enable? 128: 0;
2860
2861 LIST_FOR_EACH(e, &This->updateStateBlock->lightMap[Hi]) {
2862 lightInfo = LIST_ENTRY(e, PLIGHTINFOEL, entry);
2863 if(lightInfo->OriginalIndex == Index) break;
2864 lightInfo = NULL;
2865 }
2866 TRACE("Found light: %p\n", lightInfo);
2867
2868 /* Special case - enabling an undefined light creates one with a strict set of parms! */
2869 if (lightInfo == NULL) {
2870
2871 TRACE("Light enabled requested but light not defined, so defining one!\n");
2872 IWineD3DDeviceImpl_SetLight(iface, Index, &WINED3D_default_light);
2873
2874 /* Search for it again! Should be fairly quick as near head of list */
2875 LIST_FOR_EACH(e, &This->updateStateBlock->lightMap[Hi]) {
2876 lightInfo = LIST_ENTRY(e, PLIGHTINFOEL, entry);
2877 if(lightInfo->OriginalIndex == Index) break;
2878 lightInfo = NULL;
2879 }
2880 if (lightInfo == NULL) {
2881 FIXME("Adding default lights has failed dismally\n");
2882 return WINED3DERR_INVALIDCALL;
2883 }
2884 }
2885
2886 lightInfo->enabledChanged = TRUE;
2887 if(!Enable) {
2888 if(lightInfo->glIndex != -1) {
2889 if(!This->isRecordingState) {
2890 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(lightInfo->glIndex));
2891 }
2892
2893 This->stateBlock->activeLights[lightInfo->glIndex] = NULL;
2894 lightInfo->glIndex = -1;
2895 } else {
2896 TRACE("Light already disabled, nothing to do\n");
2897 }
2898 lightInfo->enabled = FALSE;
2899 } else {
2900 lightInfo->enabled = TRUE;
2901 if (lightInfo->glIndex != -1) {
2902 /* nop */
2903 TRACE("Nothing to do as light was enabled\n");
2904 } else {
2905 int i;
2906 /* Find a free gl light */
2907 for(i = 0; i < This->maxConcurrentLights; i++) {
2908 if(This->stateBlock->activeLights[i] == NULL) {
2909 This->stateBlock->activeLights[i] = lightInfo;
2910 lightInfo->glIndex = i;
2911 break;
2912 }
2913 }
2914 if(lightInfo->glIndex == -1) {
2915 /* Our tests show that Windows returns D3D_OK in this situation, even with
2916 * D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE devices. This
2917 * is consistent among ddraw, d3d8 and d3d9. GetLightEnable returns TRUE
2918 * as well for those lights.
2919 *
2920 * TODO: Test how this affects rendering
2921 */
2922 FIXME("Too many concurrently active lights\n");
2923 return WINED3D_OK;
2924 }
2925
2926 /* i == lightInfo->glIndex */
2927 if(!This->isRecordingState) {
2928 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(i));
2929 }
2930 }
2931 }
2932
2933 return WINED3D_OK;
2934 }
2935
2936 static HRESULT WINAPI IWineD3DDeviceImpl_GetLightEnable(IWineD3DDevice *iface, DWORD Index,BOOL* pEnable) {
2937
2938 PLIGHTINFOEL *lightInfo = NULL;
2939 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2940 struct list *e;
2941 UINT Hi = LIGHTMAP_HASHFUNC(Index);
2942 TRACE("(%p) : for idx(%d)\n", This, Index);
2943
2944 LIST_FOR_EACH(e, &This->stateBlock->lightMap[Hi]) {
2945 lightInfo = LIST_ENTRY(e, PLIGHTINFOEL, entry);
2946 if(lightInfo->OriginalIndex == Index) break;
2947 lightInfo = NULL;
2948 }
2949
2950 if (lightInfo == NULL) {
2951 TRACE("Light enabled state requested but light not defined\n");
2952 return WINED3DERR_INVALIDCALL;
2953 }
2954 /* true is 128 according to SetLightEnable */
2955 *pEnable = lightInfo->enabled ? 128 : 0;
2956 return WINED3D_OK;
2957 }
2958
2959 /*****
2960 * Get / Set Clip Planes
2961 *****/
2962 static HRESULT WINAPI IWineD3DDeviceImpl_SetClipPlane(IWineD3DDevice *iface, DWORD Index, CONST float *pPlane) {
2963 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2964 TRACE("(%p) : for idx %d, %p\n", This, Index, pPlane);
2965
2966 /* Validate Index */
2967 if (Index >= GL_LIMITS(clipplanes)) {
2968 TRACE("Application has requested clipplane this device doesn't support\n");
2969 return WINED3DERR_INVALIDCALL;
2970 }
2971
2972 This->updateStateBlock->changed.clipplane[Index] = TRUE;
2973
2974 if(This->updateStateBlock->clipplane[Index][0] == pPlane[0] &&
2975 This->updateStateBlock->clipplane[Index][1] == pPlane[1] &&
2976 This->updateStateBlock->clipplane[Index][2] == pPlane[2] &&
2977 This->updateStateBlock->clipplane[Index][3] == pPlane[3]) {
2978 TRACE("Application is setting old values over, nothing to do\n");
2979 return WINED3D_OK;
2980 }
2981
2982 This->updateStateBlock->clipplane[Index][0] = pPlane[0];
2983 This->updateStateBlock->clipplane[Index][1] = pPlane[1];
2984 This->updateStateBlock->clipplane[Index][2] = pPlane[2];
2985 This->updateStateBlock->clipplane[Index][3] = pPlane[3];
2986
2987 /* Handle recording of state blocks */
2988 if (This->isRecordingState) {
2989 TRACE("Recording... not performing anything\n");
2990 return WINED3D_OK;
2991 }
2992
2993 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_CLIPPLANE(Index));
2994
2995 return WINED3D_OK;
2996 }
2997
2998 static HRESULT WINAPI IWineD3DDeviceImpl_GetClipPlane(IWineD3DDevice *iface, DWORD Index, float *pPlane) {
2999 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3000 TRACE("(%p) : for idx %d\n", This, Index);
3001
3002 /* Validate Index */
3003 if (Index >= GL_LIMITS(clipplanes)) {
3004 TRACE("Application has requested clipplane this device doesn't support\n");
3005 return WINED3DERR_INVALIDCALL;
3006 }
3007
3008 pPlane[0] = This->stateBlock->clipplane[Index][0];
3009 pPlane[1] = This->stateBlock->clipplane[Index][1];
3010 pPlane[2] = This->stateBlock->clipplane[Index][2];
3011 pPlane[3] = This->stateBlock->clipplane[Index][3];
3012 return WINED3D_OK;
3013 }
3014
3015 /*****
3016 * Get / Set Clip Plane Status
3017 * WARNING: This code relies on the fact that D3DCLIPSTATUS8 == D3DCLIPSTATUS9
3018 *****/
3019 static HRESULT WINAPI IWineD3DDeviceImpl_SetClipStatus(IWineD3DDevice *iface, CONST WINED3DCLIPSTATUS* pClipStatus) {
3020 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3021 FIXME("(%p) : stub\n", This);
3022 if (NULL == pClipStatus) {
3023 return WINED3DERR_INVALIDCALL;
3024 }
3025 This->updateStateBlock->clip_status.ClipUnion = pClipStatus->ClipUnion;
3026 This->updateStateBlock->clip_status.ClipIntersection = pClipStatus->ClipIntersection;
3027 return WINED3D_OK;
3028 }
3029
3030 static HRESULT WINAPI IWineD3DDeviceImpl_GetClipStatus(IWineD3DDevice *iface, WINED3DCLIPSTATUS* pClipStatus) {
3031 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3032 FIXME("(%p) : stub\n", This);
3033 if (NULL == pClipStatus) {
3034 return WINED3DERR_INVALIDCALL;
3035 }
3036 pClipStatus->ClipUnion = This->updateStateBlock->clip_status.ClipUnion;
3037 pClipStatus->ClipIntersection = This->updateStateBlock->clip_status.ClipIntersection;
3038 return WINED3D_OK;
3039 }
3040
3041 /*****
3042 * Get / Set Material
3043 *****/
3044 static HRESULT WINAPI IWineD3DDeviceImpl_SetMaterial(IWineD3DDevice *iface, CONST WINED3DMATERIAL* pMaterial) {
3045 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3046
3047 This->updateStateBlock->changed.material = TRUE;
3048 This->updateStateBlock->material = *pMaterial;
3049
3050 /* Handle recording of state blocks */
3051 if (This->isRecordingState) {
3052 TRACE("Recording... not performing anything\n");
3053 return WINED3D_OK;
3054 }
3055
3056 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_MATERIAL);
3057 return WINED3D_OK;
3058 }
3059
3060 static HRESULT WINAPI IWineD3DDeviceImpl_GetMaterial(IWineD3DDevice *iface, WINED3DMATERIAL* pMaterial) {
3061 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3062 *pMaterial = This->updateStateBlock->material;
3063 TRACE("(%p) : Diffuse (%f,%f,%f,%f)\n", This, pMaterial->Diffuse.r, pMaterial->Diffuse.g,
3064 pMaterial->Diffuse.b, pMaterial->Diffuse.a);
3065 TRACE("(%p) : Ambient (%f,%f,%f,%f)\n", This, pMaterial->Ambient.r, pMaterial->Ambient.g,
3066 pMaterial->Ambient.b, pMaterial->Ambient.a);
3067 TRACE("(%p) : Specular (%f,%f,%f,%f)\n", This, pMaterial->Specular.r, pMaterial->Specular.g,
3068 pMaterial->Specular.b, pMaterial->Specular.a);
3069 TRACE("(%p) : Emissive (%f,%f,%f,%f)\n", This, pMaterial->Emissive.r, pMaterial->Emissive.g,
3070 pMaterial->Emissive.b, pMaterial->Emissive.a);
3071 TRACE("(%p) : Power (%f)\n", This, pMaterial->Power);
3072
3073 return WINED3D_OK;
3074 }
3075
3076 /*****
3077 * Get / Set Indices
3078 *****/
3079 static HRESULT WINAPI IWineD3DDeviceImpl_SetIndices(IWineD3DDevice *iface, IWineD3DIndexBuffer* pIndexData) {
3080 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3081 IWineD3DIndexBuffer *oldIdxs;
3082
3083 TRACE("(%p) : Setting to %p\n", This, pIndexData);
3084 oldIdxs = This->updateStateBlock->pIndexData;
3085
3086 This->updateStateBlock->changed.indices = TRUE;
3087 This->updateStateBlock->pIndexData = pIndexData;
3088
3089 /* Handle recording of state blocks */
3090 if (This->isRecordingState) {
3091 TRACE("Recording... not performing anything\n");
3092 if(pIndexData) IWineD3DIndexBuffer_AddRef(pIndexData);
3093 if(oldIdxs) IWineD3DIndexBuffer_Release(oldIdxs);
3094 return WINED3D_OK;
3095 }
3096
3097 if(oldIdxs != pIndexData) {
3098 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
3099 if(pIndexData) IWineD3DIndexBuffer_AddRef(pIndexData);
3100 if(oldIdxs) IWineD3DIndexBuffer_Release(oldIdxs);
3101 }
3102 return WINED3D_OK;
3103 }
3104
3105 static HRESULT WINAPI IWineD3DDeviceImpl_GetIndices(IWineD3DDevice *iface, IWineD3DIndexBuffer** ppIndexData) {
3106 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3107
3108 *ppIndexData = This->stateBlock->pIndexData;
3109
3110 /* up ref count on ppindexdata */
3111 if (*ppIndexData) {
3112 IWineD3DIndexBuffer_AddRef(*ppIndexData);
3113 TRACE("(%p) index data set to %p\n", This, ppIndexData);
3114 }else{
3115 TRACE("(%p) No index data set\n", This);
3116 }
3117 TRACE("Returning %p\n", *ppIndexData);
3118
3119 return WINED3D_OK;
3120 }
3121
3122 /* Method to offer d3d9 a simple way to set the base vertex index without messing with the index buffer */
3123 static HRESULT WINAPI IWineD3DDeviceImpl_SetBaseVertexIndex(IWineD3DDevice *iface, INT BaseIndex) {
3124 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3125 TRACE("(%p)->(%d)\n", This, BaseIndex);
3126
3127 if(This->updateStateBlock->baseVertexIndex == BaseIndex) {
3128 TRACE("Application is setting the old value over, nothing to do\n");
3129 return WINED3D_OK;
3130 }
3131
3132 This->updateStateBlock->baseVertexIndex = BaseIndex;
3133
3134 if (This->isRecordingState) {
3135 TRACE("Recording... not performing anything\n");
3136 return WINED3D_OK;
3137 }
3138 /* The base vertex index affects the stream sources */
3139 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
3140 return WINED3D_OK;
3141 }
3142
3143 static HRESULT WINAPI IWineD3DDeviceImpl_GetBaseVertexIndex(IWineD3DDevice *iface, INT* base_index) {
3144 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3145 TRACE("(%p) : base_index %p\n", This, base_index);
3146
3147 *base_index = This->stateBlock->baseVertexIndex;
3148
3149 TRACE("Returning %u\n", *base_index);
3150
3151 return WINED3D_OK;
3152 }
3153
3154 /*****
3155 * Get / Set Viewports
3156 *****/
3157 static HRESULT WINAPI IWineD3DDeviceImpl_SetViewport(IWineD3DDevice *iface, CONST WINED3DVIEWPORT* pViewport) {
3158 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3159
3160 TRACE("(%p)\n", This);
3161 This->updateStateBlock->changed.viewport = TRUE;
3162 This->updateStateBlock->viewport = *pViewport;
3163
3164 /* Handle recording of state blocks */
3165 if (This->isRecordingState) {
3166 TRACE("Recording... not performing anything\n");
3167 return WINED3D_OK;
3168 }
3169
3170 TRACE("(%p) : x=%d, y=%d, wid=%d, hei=%d, minz=%f, maxz=%f\n", This,
3171 pViewport->X, pViewport->Y, pViewport->Width, pViewport->Height, pViewport->MinZ, pViewport->MaxZ);
3172
3173 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VIEWPORT);
3174 return WINED3D_OK;
3175
3176 }
3177
3178 static HRESULT WINAPI IWineD3DDeviceImpl_GetViewport(IWineD3DDevice *iface, WINED3DVIEWPORT* pViewport) {
3179 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3180 TRACE("(%p)\n", This);
3181 *pViewport = This->stateBlock->viewport;
3182 return WINED3D_OK;
3183 }
3184
3185 /*****
3186 * Get / Set Render States
3187 * TODO: Verify against dx9 definitions
3188 *****/
3189 static HRESULT WINAPI IWineD3DDeviceImpl_SetRenderState(IWineD3DDevice *iface, WINED3DRENDERSTATETYPE State, DWORD Value) {
3190
3191 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3192 DWORD oldValue = This->stateBlock->renderState[State];
3193
3194 TRACE("(%p)->state = %s(%d), value = %d\n", This, debug_d3drenderstate(State), State, Value);
3195
3196 This->updateStateBlock->changed.renderState[State] = TRUE;
3197 This->updateStateBlock->renderState[State] = Value;
3198
3199 /* Handle recording of state blocks */
3200 if (This->isRecordingState) {
3201 TRACE("Recording... not performing anything\n");
3202 return WINED3D_OK;
3203 }
3204
3205 /* Compared here and not before the assignment to allow proper stateblock recording */
3206 if(Value == oldValue) {
3207 TRACE("Application is setting the old value over, nothing to do\n");
3208 } else {
3209 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(State));
3210 }
3211
3212 return WINED3D_OK;
3213 }
3214
3215 static HRESULT WINAPI IWineD3DDeviceImpl_GetRenderState(IWineD3DDevice *iface, WINED3DRENDERSTATETYPE State, DWORD *pValue) {
3216 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3217 TRACE("(%p) for State %d = %d\n", This, State, This->stateBlock->renderState[State]);
3218 *pValue = This->stateBlock->renderState[State];
3219 return WINED3D_OK;
3220 }
3221
3222 /*****
3223 * Get / Set Sampler States
3224 * TODO: Verify against dx9 definitions
3225 *****/
3226
3227 static HRESULT WINAPI IWineD3DDeviceImpl_SetSamplerState(IWineD3DDevice *iface, DWORD Sampler, WINED3DSAMPLERSTATETYPE Type, DWORD Value) {
3228 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3229 DWORD oldValue;
3230
3231 TRACE("(%p) : Sampler %#x, Type %s (%#x), Value %#x\n",
3232 This, Sampler, debug_d3dsamplerstate(Type), Type, Value);
3233
3234 if (Sampler >= WINED3DVERTEXTEXTURESAMPLER0 && Sampler <= WINED3DVERTEXTEXTURESAMPLER3) {
3235 Sampler -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
3236 }
3237
3238 if (Sampler >= sizeof(This->stateBlock->samplerState)/sizeof(This->stateBlock->samplerState[0])) {
3239 ERR("Current Sampler overflows sampleState0 array (sampler %d)\n", Sampler);
3240 return WINED3D_OK; /* Windows accepts overflowing this array ... we do not. */
3241 }
3242 /**
3243 * SetSampler is designed to allow for more than the standard up to 8 textures
3244 * and Geforce has stopped supporting more than 6 standard textures in openGL.
3245 * So I have to use ARB for Gforce. (maybe if the sampler > 4 then use ARB?)
3246 *
3247 * http://developer.nvidia.com/object/General_FAQ.html#t6
3248 *
3249 * There are two new settings for GForce
3250 * the sampler one:
3251 * GL_MAX_TEXTURE_IMAGE_UNITS_ARB
3252 * and the texture one:
3253 * GL_MAX_TEXTURE_COORDS_ARB.
3254 * Ok GForce say it's ok to use glTexParameter/glGetTexParameter(...).
3255 ******************/
3256
3257 oldValue = This->stateBlock->samplerState[Sampler][Type];
3258 This->updateStateBlock->samplerState[Sampler][Type] = Value;
3259 This->updateStateBlock->changed.samplerState[Sampler][Type] = Value;
3260
3261 /* Handle recording of state blocks */
3262 if (This->isRecordingState) {
3263 TRACE("Recording... not performing anything\n");
3264 return WINED3D_OK;
3265 }
3266
3267 if(oldValue == Value) {
3268 TRACE("Application is setting the old value over, nothing to do\n");
3269 return WINED3D_OK;
3270 }
3271
3272 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(Sampler));
3273
3274 return WINED3D_OK;
3275 }
3276
3277 static HRESULT WINAPI IWineD3DDeviceImpl_GetSamplerState(IWineD3DDevice *iface, DWORD Sampler, WINED3DSAMPLERSTATETYPE Type, DWORD* Value) {
3278 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3279
3280 TRACE("(%p) : Sampler %#x, Type %s (%#x)\n",
3281 This, Sampler, debug_d3dsamplerstate(Type), Type);
3282
3283 if (Sampler >= WINED3DVERTEXTEXTURESAMPLER0 && Sampler <= WINED3DVERTEXTEXTURESAMPLER3) {
3284 Sampler -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
3285 }
3286
3287 if (Sampler >= sizeof(This->stateBlock->samplerState)/sizeof(This->stateBlock->samplerState[0])) {
3288 ERR("Current Sampler overflows sampleState0 array (sampler %d)\n", Sampler);
3289 return WINED3D_OK; /* Windows accepts overflowing this array ... we do not. */
3290 }
3291 *Value = This->stateBlock->samplerState[Sampler][Type];
3292 TRACE("(%p) : Returning %#x\n", This, *Value);
3293
3294 return WINED3D_OK;
3295 }
3296
3297 static HRESULT WINAPI IWineD3DDeviceImpl_SetScissorRect(IWineD3DDevice *iface, CONST RECT* pRect) {
3298 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3299
3300 This->updateStateBlock->changed.scissorRect = TRUE;
3301 if(EqualRect(&This->updateStateBlock->scissorRect, pRect)) {
3302 TRACE("App is setting the old scissor rectangle over, nothing to do\n");
3303 return WINED3D_OK;
3304 }
3305 CopyRect(&This->updateStateBlock->scissorRect, pRect);
3306
3307 if(This->isRecordingState) {
3308 TRACE("Recording... not performing anything\n");
3309 return WINED3D_OK;
3310 }
3311
3312 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SCISSORRECT);
3313
3314 return WINED3D_OK;
3315 }
3316
3317 static HRESULT WINAPI IWineD3DDeviceImpl_GetScissorRect(IWineD3DDevice *iface, RECT* pRect) {
3318 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3319
3320 *pRect = This->updateStateBlock->scissorRect;
3321 TRACE("(%p)Returning a Scissor Rect of %d:%d-%d:%d\n", This, pRect->left, pRect->top, pRect->right, pRect->bottom);
3322 return WINED3D_OK;
3323 }
3324
3325 static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexDeclaration(IWineD3DDevice* iface, IWineD3DVertexDeclaration* pDecl) {
3326 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
3327 IWineD3DVertexDeclaration *oldDecl = This->updateStateBlock->vertexDecl;
3328
3329 TRACE("(%p) : pDecl=%p\n", This, pDecl);
3330
3331 This->updateStateBlock->vertexDecl = pDecl;
3332 This->updateStateBlock->changed.vertexDecl = TRUE;
3333
3334 if (This->isRecordingState) {
3335 TRACE("Recording... not performing anything\n");
3336 return WINED3D_OK;
3337 } else if(pDecl == oldDecl) {
3338 /* Checked after the assignment to allow proper stateblock recording */
3339 TRACE("Application is setting the old declaration over, nothing to do\n");
3340 return WINED3D_OK;
3341 }
3342
3343 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VDECL);
3344 return WINED3D_OK;
3345 }
3346
3347 static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexDeclaration(IWineD3DDevice* iface, IWineD3DVertexDeclaration** ppDecl) {
3348 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3349
3350 TRACE("(%p) : ppDecl=%p\n", This, ppDecl);
3351
3352 *ppDecl = This->stateBlock->vertexDecl;
3353 if (NULL != *ppDecl) IWineD3DVertexDeclaration_AddRef(*ppDecl);
3354 return WINED3D_OK;
3355 }
3356
3357 static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShader(IWineD3DDevice *iface, IWineD3DVertexShader* pShader) {
3358 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3359 IWineD3DVertexShader* oldShader = This->updateStateBlock->vertexShader;
3360
3361 This->updateStateBlock->vertexShader = pShader;
3362 This->updateStateBlock->changed.vertexShader = TRUE;
3363
3364 if (This->isRecordingState) {
3365 if(pShader) IWineD3DVertexShader_AddRef(pShader);
3366 if(oldShader) IWineD3DVertexShader_Release(oldShader);
3367 TRACE("Recording... not performing anything\n");
3368 return WINED3D_OK;
3369 } else if(oldShader == pShader) {
3370 /* Checked here to allow proper stateblock recording */
3371 TRACE("App is setting the old shader over, nothing to do\n");
3372 return WINED3D_OK;
3373 }
3374
3375 TRACE("(%p) : setting pShader(%p)\n", This, pShader);
3376 if(pShader) IWineD3DVertexShader_AddRef(pShader);
3377 if(oldShader) IWineD3DVertexShader_Release(oldShader);
3378
3379 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VSHADER);
3380
3381 return WINED3D_OK;
3382 }
3383
3384 static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShader(IWineD3DDevice *iface, IWineD3DVertexShader** ppShader) {
3385 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3386
3387 if (NULL == ppShader) {
3388 return WINED3DERR_INVALIDCALL;
3389 }
3390 *ppShader = This->stateBlock->vertexShader;
3391 if( NULL != *ppShader)
3392 IWineD3DVertexShader_AddRef(*ppShader);
3393
3394 TRACE("(%p) : returning %p\n", This, *ppShader);
3395 return WINED3D_OK;
3396 }
3397
3398 static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantB(
3399 IWineD3DDevice *iface,
3400 UINT start,
3401 CONST BOOL *srcData,
3402 UINT count) {
3403
3404 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3405 int i, cnt = min(count, MAX_CONST_B - start);
3406
3407 TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3408 iface, srcData, start, count);
3409
3410 if (srcData == NULL || cnt < 0)
3411 return WINED3DERR_INVALIDCALL;
3412
3413 memcpy(&This->updateStateBlock->vertexShaderConstantB[start], srcData, cnt * sizeof(BOOL));
3414 for (i = 0; i < cnt; i++)
3415 TRACE("Set BOOL constant %u to %s\n", start + i, srcData[i]? "true":"false");
3416
3417 for (i = start; i < cnt + start; ++i) {
3418 This->updateStateBlock->changed.vertexShaderConstantsB[i] = TRUE;
3419 }
3420
3421 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VERTEXSHADERCONSTANT);
3422
3423 return WINED3D_OK;
3424 }
3425
3426 static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantB(
3427 IWineD3DDevice *iface,
3428 UINT start,
3429 BOOL *dstData,
3430 UINT count) {
3431
3432 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3433 int cnt = min(count, MAX_CONST_B - start);
3434
3435 TRACE("(iface %p, dstData %p, start %d, count %d)\n",
3436 iface, dstData, start, count);
3437
3438 if (dstData == NULL || cnt < 0)
3439 return WINED3DERR_INVALIDCALL;
3440
3441 memcpy(dstData, &This->stateBlock->vertexShaderConstantB[start], cnt * sizeof(BOOL));
3442 return WINED3D_OK;
3443 }
3444
3445 static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantI(
3446 IWineD3DDevice *iface,
3447 UINT start,
3448 CONST int *srcData,
3449 UINT count) {
3450
3451 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3452 int i, cnt = min(count, MAX_CONST_I - start);
3453
3454 TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3455 iface, srcData, start, count);
3456
3457 if (srcData == NULL || cnt < 0)
3458 return WINED3DERR_INVALIDCALL;
3459
3460 memcpy(&This->updateStateBlock->vertexShaderConstantI[start * 4], srcData, cnt * sizeof(int) * 4);
3461 for (i = 0; i < cnt; i++)
3462 TRACE("Set INT constant %u to { %d, %d, %d, %d }\n", start + i,
3463 srcData[i*4], srcData[i*4+1], srcData[i*4+2], srcData[i*4+3]);
3464
3465 for (i = start; i < cnt + start; ++i) {
3466 This->updateStateBlock->changed.vertexShaderConstantsI[i] = TRUE;
3467 }
3468
3469 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VERTEXSHADERCONSTANT);
3470
3471 return WINED3D_OK;
3472 }
3473
3474 static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantI(
3475 IWineD3DDevice *iface,
3476 UINT start,
3477 int *dstData,
3478 UINT count) {
3479
3480 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3481 int cnt = min(count, MAX_CONST_I - start);
3482
3483 TRACE("(iface %p, dstData %p, start %d, count %d)\n",
3484 iface, dstData, start, count);
3485
3486 if (dstData == NULL || ((signed int) MAX_CONST_I - (signed int) start) <= (signed int) 0)
3487 return WINED3DERR_INVALIDCALL;
3488
3489 memcpy(dstData, &This->stateBlock->vertexShaderConstantI[start * 4], cnt * sizeof(int) * 4);
3490 return WINED3D_OK;
3491 }
3492
3493 static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantF(
3494 IWineD3DDevice *iface,
3495 UINT start,
3496 CONST float *srcData,
3497 UINT count) {
3498
3499 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3500 int i;
3501
3502 TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3503 iface, srcData, start, count);
3504
3505 /* Specifically test start > limit to catch MAX_UINT overflows when adding start + count */
3506 if (srcData == NULL || start + count > GL_LIMITS(vshader_constantsF) || start > GL_LIMITS(vshader_constantsF))
3507 return WINED3DERR_INVALIDCALL;
3508
3509 memcpy(&This->updateStateBlock->vertexShaderConstantF[start * 4], srcData, count * sizeof(float) * 4);
3510 if(TRACE_ON(d3d)) {
3511 for (i = 0; i < count; i++)
3512 TRACE("Set FLOAT constant %u to { %f, %f, %f, %f }\n", start + i,
3513 srcData[i*4], srcData[i*4+1], srcData[i*4+2], srcData[i*4+3]);
3514 }
3515
3516 for (i = start; i < count + start; ++i) {
3517 if (!This->updateStateBlock->changed.vertexShaderConstantsF[i]) {
3518 constants_entry *ptr = LIST_ENTRY(list_head(&This->updateStateBlock->set_vconstantsF), constants_entry, entry);
3519 if (!ptr || ptr->count >= sizeof(ptr->idx) / sizeof(*ptr->idx)) {
3520 ptr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(constants_entry));
3521 list_add_head(&This->updateStateBlock->set_vconstantsF, &ptr->entry);
3522 }
3523 ptr->idx[ptr->count++] = i;
3524 This->updateStateBlock->changed.vertexShaderConstantsF[i] = TRUE;
3525 }
3526 }
3527
3528 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VERTEXSHADERCONSTANT);
3529
3530 return WINED3D_OK;
3531 }
3532
3533 static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantF_DirtyConst(
3534 IWineD3DDevice *iface,
3535 UINT start,
3536 CONST float *srcData,
3537 UINT count) {
3538
3539 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3540 int i;
3541
3542 TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3543 iface, srcData, start, count);
3544
3545 /* Specifically test start > limit to catch MAX_UINT overflows when adding start + count */
3546 if (srcData == NULL || start + count > GL_LIMITS(vshader_constantsF) || start > GL_LIMITS(vshader_constantsF))
3547 return WINED3DERR_INVALIDCALL;
3548
3549 memcpy(&This->updateStateBlock->vertexShaderConstantF[start * 4], srcData, count * sizeof(float) * 4);
3550 if(TRACE_ON(d3d)) {
3551 for (i = 0; i < count; i++)
3552 TRACE("Set FLOAT constant %u to { %f, %f, %f, %f }\n", start + i,
3553 srcData[i*4], srcData[i*4+1], srcData[i*4+2], srcData[i*4+3]);
3554 }
3555
3556 /* We don't want shader constant dirtification to be an O(contexts), so just dirtify the active
3557 * context. On a context switch the old context will be fully dirtified
3558 */
3559 memset(This->activeContext->vshader_const_dirty + start, 1,
3560 sizeof(*This->activeContext->vshader_const_dirty) * count);
3561 This->highest_dirty_vs_const = max(This->highest_dirty_vs_const, start+count);
3562
3563 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VERTEXSHADERCONSTANT);
3564
3565 return WINED3D_OK;
3566 }
3567
3568 static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantF(
3569 IWineD3DDevice *iface,
3570 UINT start,
3571 float *dstData,
3572 UINT count) {
3573
3574 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3575 int cnt = min(count, GL_LIMITS(vshader_constantsF) - start);
3576
3577 TRACE("(iface %p, dstData %p, start %d, count %d)\n",
3578 iface, dstData, start, count);
3579
3580 if (dstData == NULL || cnt < 0)
3581 return WINED3DERR_INVALIDCALL;
3582
3583 memcpy(dstData, &This->stateBlock->vertexShaderConstantF[start * 4], cnt * sizeof(float) * 4);
3584 return WINED3D_OK;
3585 }
3586
3587 static inline void markTextureStagesDirty(IWineD3DDeviceImpl *This, DWORD stage) {
3588 DWORD i;
3589 for(i = 0; i < WINED3D_HIGHEST_TEXTURE_STATE; i++) {
3590 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(stage, i));
3591 }
3592 }
3593
3594 static void device_map_stage(IWineD3DDeviceImpl *This, int stage, int unit) {
3595 int i = This->rev_tex_unit_map[unit];
3596 int j = This->texUnitMap[stage];
3597
3598 This->texUnitMap[stage] = unit;
3599 if (i != -1 && i != stage) {
3600 This->texUnitMap[i] = -1;
3601 }
3602
3603 This->rev_tex_unit_map[unit] = stage;
3604 if (j != -1 && j != unit) {
3605 This->rev_tex_unit_map[j] = -1;
3606 }
3607 }
3608
3609 static void device_update_fixed_function_usage_map(IWineD3DDeviceImpl *This) {
3610 int i;
3611
3612 for (i = 0; i < MAX_TEXTURES; ++i) {
3613 WINED3DTEXTUREOP color_op = This->stateBlock->textureState[i][WINED3DTSS_COLOROP];
3614 WINED3DTEXTUREOP alpha_op = This->stateBlock->textureState[i][WINED3DTSS_ALPHAOP];
3615 DWORD color_arg1 = This->stateBlock->textureState[i][WINED3DTSS_COLORARG1] & WINED3DTA_SELECTMASK;
3616 DWORD color_arg2 = This->stateBlock->textureState[i][WINED3DTSS_COLORARG2] & WINED3DTA_SELECTMASK;
3617 DWORD color_arg3 = This->stateBlock->textureState[i][WINED3DTSS_COLORARG0] & WINED3DTA_SELECTMASK;
3618 DWORD alpha_arg1 = This->stateBlock->textureState[i][WINED3DTSS_ALPHAARG1] & WINED3DTA_SELECTMASK;
3619 DWORD alpha_arg2 = This->stateBlock->textureState[i][WINED3DTSS_ALPHAARG2] & WINED3DTA_SELECTMASK;
3620 DWORD alpha_arg3 = This->stateBlock->textureState[i][WINED3DTSS_ALPHAARG0] & WINED3DTA_SELECTMASK;
3621
3622 if (color_op == WINED3DTOP_DISABLE) {
3623 /* Not used, and disable higher stages */
3624 while (i < MAX_TEXTURES) {
3625 This->fixed_function_usage_map[i] = FALSE;
3626 ++i;
3627 }
3628 break;
3629 }
3630
3631 if (((color_arg1 == WINED3DTA_TEXTURE) && color_op != WINED3DTOP_SELECTARG2)
3632 || ((color_arg2 == WINED3DTA_TEXTURE) && color_op != WINED3DTOP_SELECTARG1)
3633 || ((color_arg3 == WINED3DTA_TEXTURE) && (color_op == WINED3DTOP_MULTIPLYADD || color_op == WINED3DTOP_LERP))
3634 || ((alpha_arg1 == WINED3DTA_TEXTURE) && alpha_op != WINED3DTOP_SELECTARG2)
3635 || ((alpha_arg2 == WINED3DTA_TEXTURE) && alpha_op != WINED3DTOP_SELECTARG1)
3636 || ((alpha_arg3 == WINED3DTA_TEXTURE) && (alpha_op == WINED3DTOP_MULTIPLYADD || alpha_op == WINED3DTOP_LERP))) {
3637 This->fixed_function_usage_map[i] = TRUE;
3638 } else {
3639 This->fixed_function_usage_map[i] = FALSE;
3640 }
3641
3642 if ((color_op == WINED3DTOP_BUMPENVMAP || color_op == WINED3DTOP_BUMPENVMAPLUMINANCE) && i < MAX_TEXTURES - 1) {
3643 This->fixed_function_usage_map[i+1] = TRUE;
3644 }
3645 }
3646 }
3647
3648 static void device_map_fixed_function_samplers(IWineD3DDeviceImpl *This) {
3649 int i, tex;
3650
3651 device_update_fixed_function_usage_map(This);
3652
3653 if (!GL_SUPPORT(NV_REGISTER_COMBINERS) || This->stateBlock->lowest_disabled_stage <= GL_LIMITS(textures)) {
3654 for (i = 0; i < This->stateBlock->lowest_disabled_stage; ++i) {
3655 if (!This->fixed_function_usage_map[i]) continue;
3656
3657 if (This->texUnitMap[i] != i) {
3658 device_map_stage(This, i, i);
3659 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(i));
3660 markTextureStagesDirty(This, i);
3661 }
3662 }
3663 return;
3664 }
3665
3666 /* Now work out the mapping */
3667 tex = 0;
3668 for (i = 0; i < This->stateBlock->lowest_disabled_stage; ++i) {
3669 if (!This->fixed_function_usage_map[i]) continue;
3670
3671 if (This->texUnitMap[i] != tex) {
3672 device_map_stage(This, i, tex);
3673 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(i));
3674 markTextureStagesDirty(This, i);
3675 }
3676
3677 ++tex;
3678 }
3679 }
3680
3681 static void device_map_psamplers(IWineD3DDeviceImpl *This) {
3682 DWORD *sampler_tokens = ((IWineD3DPixelShaderImpl *)This->stateBlock->pixelShader)->baseShader.reg_maps.samplers;
3683 int i;
3684
3685 for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i) {
3686 if (sampler_tokens[i] && This->texUnitMap[i] != i) {
3687 device_map_stage(This, i, i);
3688 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(i));
3689 if (i < MAX_TEXTURES) {
3690 markTextureStagesDirty(This, i);
3691 }
3692 }
3693 }
3694 }
3695
3696 static BOOL device_unit_free_for_vs(IWineD3DDeviceImpl *This, DWORD *pshader_sampler_tokens, DWORD *vshader_sampler_tokens, int unit) {
3697 int current_mapping = This->rev_tex_unit_map[unit];
3698
3699 if (current_mapping == -1) {
3700 /* Not currently used */
3701 return TRUE;
3702 }
3703
3704 if (current_mapping < MAX_FRAGMENT_SAMPLERS) {
3705 /* Used by a fragment sampler */
3706
3707 if (!pshader_sampler_tokens) {
3708 /* No pixel shader, check fixed function */
3709 return current_mapping >= MAX_TEXTURES || !This->fixed_function_usage_map[current_mapping];
3710 }
3711
3712 /* Pixel shader, check the shader's sampler map */
3713 return !pshader_sampler_tokens[current_mapping];
3714 }
3715
3716 /* Used by a vertex sampler */
3717 return !vshader_sampler_tokens[current_mapping];
3718 }
3719
3720 static void device_map_vsamplers(IWineD3DDeviceImpl *This, BOOL ps) {
3721 DWORD *vshader_sampler_tokens = ((IWineD3DVertexShaderImpl *)This->stateBlock->vertexShader)->baseShader.reg_maps.samplers;
3722 DWORD *pshader_sampler_tokens = NULL;
3723 int start = GL_LIMITS(combined_samplers) - 1;
3724 int i;
3725
3726 if (ps) {
3727 IWineD3DPixelShaderImpl *pshader = (IWineD3DPixelShaderImpl *)This->stateBlock->pixelShader;
3728
3729 /* Make sure the shader's reg_maps are up to date. This is only relevant for 1.x pixelshaders. */
3730 IWineD3DPixelShader_CompileShader((IWineD3DPixelShader *)pshader);
3731 pshader_sampler_tokens = pshader->baseShader.reg_maps.samplers;
3732 }
3733
3734 for (i = 0; i < MAX_VERTEX_SAMPLERS; ++i) {
3735 int vsampler_idx = i + MAX_FRAGMENT_SAMPLERS;
3736 if (vshader_sampler_tokens[i]) {
3737 if (This->texUnitMap[vsampler_idx] != -1) {
3738 /* Already mapped somewhere */
3739 continue;
3740 }
3741
3742 while (start >= 0) {
3743 if (device_unit_free_for_vs(This, pshader_sampler_tokens, vshader_sampler_tokens, start)) {
3744 device_map_stage(This, vsampler_idx, start);
3745 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(vsampler_idx));
3746
3747 --start;
3748 break;
3749 }
3750
3751 --start;
3752 }
3753 }
3754 }
3755 }
3756
3757 void IWineD3DDeviceImpl_FindTexUnitMap(IWineD3DDeviceImpl *This) {
3758 BOOL vs = use_vs(This);
3759 BOOL ps = use_ps(This);
3760 /*
3761 * Rules are:
3762 * -> Pixel shaders need a 1:1 map. In theory the shader input could be mapped too, but
3763 * that would be really messy and require shader recompilation
3764 * -> When the mapping of a stage is changed, sampler and ALL texture stage states have
3765 * to be reset. Because of that try to work with a 1:1 mapping as much as possible
3766 */
3767 if (ps) {
3768 device_map_psamplers(This);
3769 } else {
3770 device_map_fixed_function_samplers(This);
3771 }
3772
3773 if (vs) {
3774 device_map_vsamplers(This, ps);
3775 }
3776 }
3777
3778 static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShader(IWineD3DDevice *iface, IWineD3DPixelShader *pShader) {
3779 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3780 IWineD3DPixelShader *oldShader = This->updateStateBlock->pixelShader;
3781 This->updateStateBlock->pixelShader = pShader;
3782 This->updateStateBlock->changed.pixelShader = TRUE;
3783
3784 /* Handle recording of state blocks */
3785 if (This->isRecordingState) {
3786 TRACE("Recording... not performing anything\n");
3787 }
3788
3789 if (This->isRecordingState) {
3790 TRACE("Recording... not performing anything\n");
3791 if(pShader) IWineD3DPixelShader_AddRef(pShader);
3792 if(oldShader) IWineD3DPixelShader_Release(oldShader);
3793 return WINED3D_OK;
3794 }
3795
3796 if(pShader == oldShader) {
3797 TRACE("App is setting the old pixel shader over, nothing to do\n");
3798 return WINED3D_OK;
3799 }
3800
3801 if(pShader) IWineD3DPixelShader_AddRef(pShader);
3802 if(oldShader) IWineD3DPixelShader_Release(oldShader);
3803
3804 TRACE("(%p) : setting pShader(%p)\n", This, pShader);
3805 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_PIXELSHADER);
3806
3807 return WINED3D_OK;
3808 }
3809
3810 static HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShader(IWineD3DDevice *iface, IWineD3DPixelShader **ppShader) {
3811 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3812
3813 if (NULL == ppShader) {
3814 WARN("(%p) : PShader is NULL, returning INVALIDCALL\n", This);
3815 return WINED3DERR_INVALIDCALL;
3816 }
3817
3818 *ppShader = This->stateBlock->pixelShader;
3819 if (NULL != *ppShader) {
3820 IWineD3DPixelShader_AddRef(*ppShader);
3821 }
3822 TRACE("(%p) : returning %p\n", This, *ppShader);
3823 return WINED3D_OK;
3824 }
3825
3826 static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantB(
3827 IWineD3DDevice *iface,
3828 UINT start,
3829 CONST BOOL *srcData,
3830 UINT count) {
3831
3832 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3833 int i, cnt = min(count, MAX_CONST_B - start);
3834
3835 TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3836 iface, srcData, start, count);
3837
3838 if (srcData == NULL || cnt < 0)
3839 return WINED3DERR_INVALIDCALL;
3840
3841 memcpy(&This->updateStateBlock->pixelShaderConstantB[start], srcData, cnt * sizeof(BOOL));
3842 for (i = 0; i < cnt; i++)
3843 TRACE("Set BOOL constant %u to %s\n", start + i, srcData[i]? "true":"false");
3844
3845 for (i = start; i < cnt + start; ++i) {
3846 This->updateStateBlock->changed.pixelShaderConstantsB[i] = TRUE;
3847 }
3848
3849 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_PIXELSHADERCONSTANT);
3850
3851 return WINED3D_OK;
3852 }
3853
3854 static HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantB(
3855 IWineD3DDevice *iface,
3856 UINT start,
3857 BOOL *dstData,
3858 UINT count) {
3859
3860 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3861 int cnt = min(count, MAX_CONST_B - start);
3862
3863 TRACE("(iface %p, dstData %p, start %d, count %d)\n",
3864 iface, dstData, start, count);
3865
3866 if (dstData == NULL || cnt < 0)
3867 return WINED3DERR_INVALIDCALL;
3868
3869 memcpy(dstData, &This->stateBlock->pixelShaderConstantB[start], cnt * sizeof(BOOL));
3870 return WINED3D_OK;
3871 }
3872
3873 static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantI(
3874 IWineD3DDevice *iface,
3875 UINT start,
3876 CONST int *srcData,
3877 UINT count) {
3878
3879 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3880 int i, cnt = min(count, MAX_CONST_I - start);
3881
3882 TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3883 iface, srcData, start, count);
3884
3885 if (srcData == NULL || cnt < 0)
3886 return WINED3DERR_INVALIDCALL;
3887
3888 memcpy(&This->updateStateBlock->pixelShaderConstantI[start * 4], srcData, cnt * sizeof(int) * 4);
3889 for (i = 0; i < cnt; i++)
3890 TRACE("Set INT constant %u to { %d, %d, %d, %d }\n", start + i,
3891 srcData[i*4], srcData[i*4+1], srcData[i*4+2], srcData[i*4+3]);
3892
3893 for (i = start; i < cnt + start; ++i) {
3894 This->updateStateBlock->changed.pixelShaderConstantsI[i] = TRUE;
3895 }
3896
3897 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_PIXELSHADERCONSTANT);
3898
3899 return WINED3D_OK;
3900 }
3901
3902 static HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantI(
3903 IWineD3DDevice *iface,
3904 UINT start,
3905 int *dstData,
3906 UINT count) {
3907
3908 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3909 int cnt = min(count, MAX_CONST_I - start);
3910
3911 TRACE("(iface %p, dstData %p, start %d, count %d)\n",
3912 iface, dstData, start, count);
3913
3914 if (dstData == NULL || cnt < 0)
3915 return WINED3DERR_INVALIDCALL;
3916
3917 memcpy(dstData, &This->stateBlock->pixelShaderConstantI[start * 4], cnt * sizeof(int) * 4);
3918 return WINED3D_OK;
3919 }
3920
3921 static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantF(
3922 IWineD3DDevice *iface,
3923 UINT start,
3924 CONST float *srcData,
3925 UINT count) {
3926
3927 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3928 int i;
3929
3930 TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3931 iface, srcData, start, count);
3932
3933 /* Specifically test start > limit to catch MAX_UINT overflows when adding start + count */
3934 if (srcData == NULL || start + count > GL_LIMITS(pshader_constantsF) || start > GL_LIMITS(pshader_constantsF))
3935 return WINED3DERR_INVALIDCALL;
3936
3937 memcpy(&This->updateStateBlock->pixelShaderConstantF[start * 4], srcData, count * sizeof(float) * 4);
3938 if(TRACE_ON(d3d)) {
3939 for (i = 0; i < count; i++)
3940 TRACE("Set FLOAT constant %u to { %f, %f, %f, %f }\n", start + i,
3941 srcData[i*4], srcData[i*4+1], srcData[i*4+2], srcData[i*4+3]);
3942 }
3943
3944 for (i = start; i < count + start; ++i) {
3945 if (!This->updateStateBlock->changed.pixelShaderConstantsF[i]) {
3946 constants_entry *ptr = LIST_ENTRY(list_head(&This->updateStateBlock->set_pconstantsF), constants_entry, entry);
3947 if (!ptr || ptr->count >= sizeof(ptr->idx) / sizeof(*ptr->idx)) {
3948 ptr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(constants_entry));
3949 list_add_head(&This->updateStateBlock->set_pconstantsF, &ptr->entry);
3950 }
3951 ptr->idx[ptr->count++] = i;
3952 This->updateStateBlock->changed.pixelShaderConstantsF[i] = TRUE;
3953 }
3954 }
3955
3956 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_PIXELSHADERCONSTANT);
3957
3958 return WINED3D_OK;
3959 }
3960
3961 static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantF_DirtyConst(
3962 IWineD3DDevice *iface,
3963 UINT start,
3964 CONST float *srcData,
3965 UINT count) {
3966
3967 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3968 int i;
3969
3970 TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3971 iface, srcData, start, count);
3972
3973 /* Specifically test start > limit to catch MAX_UINT overflows when adding start + count */
3974 if (srcData == NULL || start + count > GL_LIMITS(pshader_constantsF) || start > GL_LIMITS(pshader_constantsF))
3975 return WINED3DERR_INVALIDCALL;
3976
3977 memcpy(&This->updateStateBlock->pixelShaderConstantF[start * 4], srcData, count * sizeof(float) * 4);
3978 if(TRACE_ON(d3d)) {
3979 for (i = 0; i < count; i++)
3980 TRACE("Set FLOAT constant %u to { %f, %f, %f, %f }\n", start + i,
3981 srcData[i*4], srcData[i*4+1], srcData[i*4+2], srcData[i*4+3]);
3982 }
3983
3984 /* We don't want shader constant dirtification to be an O(contexts), so just dirtify the active
3985 * context. On a context switch the old context will be fully dirtified
3986 */
3987 memset(This->activeContext->pshader_const_dirty + start, 1,
3988 sizeof(*This->activeContext->pshader_const_dirty) * count);
3989 This->highest_dirty_ps_const = max(This->highest_dirty_ps_const, start+count);
3990
3991 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_PIXELSHADERCONSTANT);
3992
3993 return WINED3D_OK;
3994 }
3995
3996 static HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantF(
3997 IWineD3DDevice *iface,
3998 UINT start,
3999 float *dstData,
4000 UINT count) {
4001
4002 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4003 int cnt = min(count, GL_LIMITS(pshader_constantsF) - start);
4004
4005 TRACE("(iface %p, dstData %p, start %d, count %d)\n",
4006 iface, dstData, start, count);
4007
4008 if (dstData == NULL || cnt < 0)
4009 return WINED3DERR_INVALIDCALL;
4010
4011 memcpy(dstData, &This->stateBlock->pixelShaderConstantF[start * 4], cnt * sizeof(float) * 4);
4012 return WINED3D_OK;
4013 }
4014
4015 #define copy_and_next(dest, src, size) memcpy(dest, src, size); dest += (size)
4016 static HRESULT
4017 process_vertices_strided(IWineD3DDeviceImpl *This, DWORD dwDestIndex, DWORD dwCount, WineDirect3DVertexStridedData *lpStrideData, IWineD3DVertexBufferImpl *dest, DWORD dwFlags) {
4018 char *dest_ptr, *dest_conv = NULL, *dest_conv_addr = NULL;
4019 unsigned int i;
4020 DWORD DestFVF = dest->fvf;
4021 WINED3DVIEWPORT vp;
4022 WINED3DMATRIX mat, proj_mat, view_mat, world_mat;
4023 BOOL doClip;
4024 int numTextures;
4025
4026 if (lpStrideData->u.s.normal.lpData) {
4027 WARN(" lighting state not saved yet... Some strange stuff may happen !\n");
4028 }
4029
4030 if (lpStrideData->u.s.position.lpData == NULL) {
4031 ERR("Source has no position mask\n");
4032 return WINED3DERR_INVALIDCALL;
4033 }
4034
4035 /* We might access VBOs from this code, so hold the lock */
4036 ENTER_GL();
4037
4038 if (dest->resource.allocatedMemory == NULL) {
4039 /* This may happen if we do direct locking into a vbo. Unlikely,
4040 * but theoretically possible(ddraw processvertices test)
4041 */
4042 dest->resource.allocatedMemory = HeapAlloc(GetProcessHeap(), 0, dest->resource.size);
4043 if(!dest->resource.allocatedMemory) {
4044 LEAVE_GL();
4045 ERR("Out of memory\n");
4046 return E_OUTOFMEMORY;
4047 }
4048 if(dest->vbo) {
4049 void *src;
4050 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, dest->vbo));
4051 checkGLcall("glBindBufferARB");
4052 src = GL_EXTCALL(glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_READ_ONLY_ARB));
4053 if(src) {
4054 memcpy(dest->resource.allocatedMemory, src, dest->resource.size);
4055 }
4056 GL_EXTCALL(glUnmapBufferARB(GL_ARRAY_BUFFER_ARB));
4057 checkGLcall("glUnmapBufferARB");
4058 }
4059 }
4060
4061 /* Get a pointer into the destination vbo(create one if none exists) and
4062 * write correct opengl data into it. It's cheap and allows us to run drawStridedFast
4063 */
4064 if(!dest->vbo && GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT)) {
4065 dest->Flags |= VBFLAG_CREATEVBO;
4066 IWineD3DVertexBuffer_PreLoad((IWineD3DVertexBuffer *) dest);
4067 }
4068
4069 if(dest->vbo) {
4070 unsigned char extrabytes = 0;
4071 /* If the destination vertex buffer has D3DFVF_XYZ position(non-rhw), native d3d writes RHW position, where the RHW
4072 * gets written into the 4 bytes after the Z position. In the case of a dest buffer that only has D3DFVF_XYZ data,
4073 * this may write 4 extra bytes beyond the area that should be written
4074 */
4075 if(DestFVF == WINED3DFVF_XYZ) extrabytes = 4;
4076 dest_conv_addr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwCount * get_flexible_vertex_size(DestFVF) + extrabytes);
4077 if(!dest_conv_addr) {
4078 ERR("Out of memory\n");
4079 /* Continue without storing converted vertices */
4080 }
4081 dest_conv = dest_conv_addr;
4082 }
4083
4084 /* Should I clip?
4085 * a) WINED3DRS_CLIPPING is enabled
4086 * b) WINED3DVOP_CLIP is passed
4087 */
4088 if(This->stateBlock->renderState[WINED3DRS_CLIPPING]) {
4089 static BOOL warned = FALSE;
4090 /*
4091 * The clipping code is not quite correct. Some things need
4092 * to be checked against IDirect3DDevice3 (!), d3d8 and d3d9,
4093 * so disable clipping for now.
4094 * (The graphics in Half-Life are broken, and my processvertices
4095 * test crashes with IDirect3DDevice3)
4096 doClip = TRUE;
4097 */
4098 doClip = FALSE;
4099 if(!warned) {
4100 warned = TRUE;
4101 FIXME("Clipping is broken and disabled for now\n");
4102 }
4103 } else doClip = FALSE;
4104 dest_ptr = ((char *) dest->resource.allocatedMemory) + dwDestIndex * get_flexible_vertex_size(DestFVF);
4105
4106 IWineD3DDevice_GetTransform( (IWineD3DDevice *) This,
4107 WINED3DTS_VIEW,
4108 &view_mat);
4109 IWineD3DDevice_GetTransform( (IWineD3DDevice *) This,
4110 WINED3DTS_PROJECTION,
4111 &proj_mat);
4112 IWineD3DDevice_GetTransform( (IWineD3DDevice *) This,
4113 WINED3DTS_WORLDMATRIX(0),
4114 &world_mat);
4115
4116 TRACE("View mat:\n");
4117 TRACE("%f %f %f %f\n", view_mat.u.s._11, view_mat.u.s._12, view_mat.u.s._13, view_mat.u.s._14);
4118 TRACE("%f %f %f %f\n", view_mat.u.s._21, view_mat.u.s._22, view_mat.u.s._23, view_mat.u.s._24);
4119 TRACE("%f %f %f %f\n", view_mat.u.s._31, view_mat.u.s._32, view_mat.u.s._33, view_mat.u.s._34);
4120 TRACE("%f %f %f %f\n", view_mat.u.s._41, view_mat.u.s._42, view_mat.u.s._43, view_mat.u.s._44);
4121
4122 TRACE("Proj mat:\n");
4123 TRACE("%f %f %f %f\n", proj_mat.u.s._11, proj_mat.u.s._12, proj_mat.u.s._13, proj_mat.u.s._14);
4124 TRACE("%f %f %f %f\n", proj_mat.u.s._21, proj_mat.u.s._22, proj_mat.u.s._23, proj_mat.u.s._24);
4125 TRACE("%f %f %f %f\n", proj_mat.u.s._31, proj_mat.u.s._32, proj_mat.u.s._33, proj_mat.u.s._34);
4126 TRACE("%f %f %f %f\n", proj_mat.u.s._41, proj_mat.u.s._42, proj_mat.u.s._43, proj_mat.u.s._44);
4127
4128 TRACE("World mat:\n");
4129 TRACE("%f %f %f %f\n", world_mat.u.s._11, world_mat.u.s._12, world_mat.u.s._13, world_mat.u.s._14);
4130 TRACE("%f %f %f %f\n", world_mat.u.s._21, world_mat.u.s._22, world_mat.u.s._23, world_mat.u.s._24);
4131 TRACE("%f %f %f %f\n", world_mat.u.s._31, world_mat.u.s._32, world_mat.u.s._33, world_mat.u.s._34);
4132 TRACE("%f %f %f %f\n", world_mat.u.s._41, world_mat.u.s._42, world_mat.u.s._43, world_mat.u.s._44);
4133
4134 /* Get the viewport */
4135 IWineD3DDevice_GetViewport( (IWineD3DDevice *) This, &vp);
4136 TRACE("Viewport: X=%d, Y=%d, Width=%d, Height=%d, MinZ=%f, MaxZ=%f\n",
4137 vp.X, vp.Y, vp.Width, vp.Height, vp.MinZ, vp.MaxZ);
4138
4139 multiply_matrix(&mat,&view_mat,&world_mat);
4140 multiply_matrix(&mat,&proj_mat,&mat);
4141
4142 numTextures = (DestFVF & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
4143
4144 for (i = 0; i < dwCount; i+= 1) {
4145 unsigned int tex_index;
4146
4147 if ( ((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZ ) ||
4148 ((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW ) ) {
4149 /* The position first */
4150 float *p =
4151 (float *) (((char *) lpStrideData->u.s.position.lpData) + i * lpStrideData->u.s.position.dwStride);
4152 float x, y, z, rhw;
4153 TRACE("In: ( %06.2f %06.2f %06.2f )\n", p[0], p[1], p[2]);
4154
4155 /* Multiplication with world, view and projection matrix */
4156 x = (p[0] * mat.u.s._11) + (p[1] * mat.u.s._21) + (p[2] * mat.u.s._31) + (1.0 * mat.u.s._41);
4157 y = (p[0] * mat.u.s._12) + (p[1] * mat.u.s._22) + (p[2] * mat.u.s._32) + (1.0 * mat.u.s._42);
4158 z = (p[0] * mat.u.s._13) + (p[1] * mat.u.s._23) + (p[2] * mat.u.s._33) + (1.0 * mat.u.s._43);
4159 rhw = (p[0] * mat.u.s._14) + (p[1] * mat.u.s._24) + (p[2] * mat.u.s._34) + (1.0 * mat.u.s._44);
4160
4161 TRACE("x=%f y=%f z=%f rhw=%f\n", x, y, z, rhw);
4162
4163 /* WARNING: The following things are taken from d3d7 and were not yet checked
4164 * against d3d8 or d3d9!
4165 */
4166
4167 /* Clipping conditions: From msdn
4168 *
4169 * A vertex is clipped if it does not match the following requirements
4170 * -rhw < x <= rhw
4171 * -rhw < y <= rhw
4172 * 0 < z <= rhw
4173 * 0 < rhw ( Not in d3d7, but tested in d3d7)
4174 *
4175 * If clipping is on is determined by the D3DVOP_CLIP flag in D3D7, and
4176 * by the D3DRS_CLIPPING in D3D9(according to the msdn, not checked)
4177 *
4178 */
4179
4180 if( !doClip ||
4181 ( (-rhw -eps < x) && (-rhw -eps < y) && ( -eps < z) &&
4182 (x <= rhw + eps) && (y <= rhw + eps ) && (z <= rhw + eps) &&
4183 ( rhw > eps ) ) ) {
4184
4185 /* "Normal" viewport transformation (not clipped)
4186 * 1) The values are divided by rhw
4187 * 2) The y axis is negative, so multiply it with -1
4188 * 3) Screen coordinates go from -(Width/2) to +(Width/2) and
4189 * -(Height/2) to +(Height/2). The z range is MinZ to MaxZ
4190 * 4) Multiply x with Width/2 and add Width/2
4191 * 5) The same for the height
4192 * 6) Add the viewpoint X and Y to the 2D coordinates and
4193 * The minimum Z value to z
4194 * 7) rhw = 1 / rhw Reciprocal of Homogeneous W....
4195 *
4196 * Well, basically it's simply a linear transformation into viewport
4197 * coordinates
4198 */
4199
4200 x /= rhw;
4201 y /= rhw;
4202 z /= rhw;
4203
4204 y *= -1;
4205
4206 x *= vp.Width / 2;
4207 y *= vp.Height / 2;
4208 z *= vp.MaxZ - vp.MinZ;
4209
4210 x += vp.Width / 2 + vp.X;
4211 y += vp.Height / 2 + vp.Y;
4212 z += vp.MinZ;
4213
4214 rhw = 1 / rhw;
4215 } else {
4216 /* That vertex got clipped
4217 * Contrary to OpenGL it is not dropped completely, it just
4218 * undergoes a different calculation.
4219 */
4220 TRACE("Vertex got clipped\n");
4221 x += rhw;
4222 y += rhw;
4223
4224 x /= 2;
4225 y /= 2;
4226
4227 /* Msdn mentions that Direct3D9 keeps a list of clipped vertices
4228 * outside of the main vertex buffer memory. That needs some more
4229 * investigation...
4230 */
4231 }
4232
4233 TRACE("Writing (%f %f %f) %f\n", x, y, z, rhw);
4234
4235
4236 ( (float *) dest_ptr)[0] = x;
4237 ( (float *) dest_ptr)[1] = y;
4238 ( (float *) dest_ptr)[2] = z;
4239 ( (float *) dest_ptr)[3] = rhw; /* SIC, see ddraw test! */
4240
4241 dest_ptr += 3 * sizeof(float);
4242
4243 if((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW) {
4244 dest_ptr += sizeof(float);
4245 }
4246
4247 if(dest_conv) {
4248 float w = 1 / rhw;
4249 ( (float *) dest_conv)[0] = x * w;
4250 ( (float *) dest_conv)[1] = y * w;
4251 ( (float *) dest_conv)[2] = z * w;
4252 ( (float *) dest_conv)[3] = w;
4253
4254 dest_conv += 3 * sizeof(float);
4255
4256 if((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW) {
4257 dest_conv += sizeof(float);
4258 }
4259 }
4260 }
4261 if (DestFVF & WINED3DFVF_PSIZE) {
4262 dest_ptr += sizeof(DWORD);
4263 if(dest_conv) dest_conv += sizeof(DWORD);
4264 }
4265 if (DestFVF & WINED3DFVF_NORMAL) {
4266 float *normal =
4267 (float *) (((float *) lpStrideData->u.s.normal.lpData) + i * lpStrideData->u.s.normal.dwStride);
4268 /* AFAIK this should go into the lighting information */
4269 FIXME("Didn't expect the destination to have a normal\n");
4270 copy_and_next(dest_ptr, normal, 3 * sizeof(float));
4271 if(dest_conv) {
4272 copy_and_next(dest_conv, normal, 3 * sizeof(float));
4273 }
4274 }
4275
4276 if (DestFVF & WINED3DFVF_DIFFUSE) {
4277 DWORD *color_d =
4278 (DWORD *) (((char *) lpStrideData->u.s.diffuse.lpData) + i * lpStrideData->u.s.diffuse.dwStride);
4279 if(!color_d) {
4280 static BOOL warned = FALSE;
4281
4282 if(!warned) {
4283 ERR("No diffuse color in source, but destination has one\n");
4284 warned = TRUE;
4285 }
4286
4287 *( (DWORD *) dest_ptr) = 0xffffffff;
4288 dest_ptr += sizeof(DWORD);
4289
4290 if(dest_conv) {
4291 *( (DWORD *) dest_conv) = 0xffffffff;
4292 dest_conv += sizeof(DWORD);
4293 }
4294 }
4295 else {
4296 copy_and_next(dest_ptr, color_d, sizeof(DWORD));
4297 if(dest_conv) {
4298 *( (DWORD *) dest_conv) = (*color_d & 0xff00ff00) ; /* Alpha + green */
4299 *( (DWORD *) dest_conv) |= (*color_d & 0x00ff0000) >> 16; /* Red */
4300 *( (DWORD *) dest_conv) |= (*color_d & 0xff0000ff) << 16; /* Blue */
4301 dest_conv += sizeof(DWORD);
4302 }
4303 }
4304 }
4305
4306 if (DestFVF & WINED3DFVF_SPECULAR) {
4307 /* What's the color value in the feedback buffer? */
4308 DWORD *color_s =
4309 (DWORD *) (((char *) lpStrideData->u.s.specular.lpData) + i * lpStrideData->u.s.specular.dwStride);
4310 if(!color_s) {
4311 static BOOL warned = FALSE;
4312
4313 if(!warned) {
4314 ERR("No specular color in source, but destination has one\n");
4315 warned = TRUE;
4316 }
4317
4318 *( (DWORD *) dest_ptr) = 0xFF000000;
4319 dest_ptr += sizeof(DWORD);
4320
4321 if(dest_conv) {
4322 *( (DWORD *) dest_conv) = 0xFF000000;
4323 dest_conv += sizeof(DWORD);
4324 }
4325 }
4326 else {
4327 copy_and_next(dest_ptr, color_s, sizeof(DWORD));
4328 if(dest_conv) {
4329 *( (DWORD *) dest_conv) = (*color_s & 0xff00ff00) ; /* Alpha + green */
4330 *( (DWORD *) dest_conv) |= (*color_s & 0x00ff0000) >> 16; /* Red */
4331 *( (DWORD *) dest_conv) |= (*color_s & 0xff0000ff) << 16; /* Blue */
4332 dest_conv += sizeof(DWORD);
4333 }
4334 }
4335 }
4336
4337 for (tex_index = 0; tex_index < numTextures; tex_index++) {
4338 float *tex_coord =
4339 (float *) (((char *) lpStrideData->u.s.texCoords[tex_index].lpData) +
4340 i * lpStrideData->u.s.texCoords[tex_index].dwStride);
4341 if(!tex_coord) {
4342 ERR("No source texture, but destination requests one\n");
4343 dest_ptr+=GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float);
4344 if(dest_conv) dest_conv += GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float);
4345 }
4346 else {
4347 copy_and_next(dest_ptr, tex_coord, GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float));
4348 if(dest_conv) {
4349 copy_and_next(dest_conv, tex_coord, GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float));
4350 }
4351 }
4352 }
4353 }
4354
4355 if(dest_conv) {
4356 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, dest->vbo));
4357 checkGLcall("glBindBufferARB(GL_ARRAY_BUFFER_ARB)");
4358 GL_EXTCALL(glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, dwDestIndex * get_flexible_vertex_size(DestFVF),
4359 dwCount * get_flexible_vertex_size(DestFVF),
4360 dest_conv_addr));
4361 checkGLcall("glBufferSubDataARB(GL_ARRAY_BUFFER_ARB)");
4362 HeapFree(GetProcessHeap(), 0, dest_conv_addr);
4363 }
4364
4365 LEAVE_GL();
4366
4367 return WINED3D_OK;
4368 }
4369 #undef copy_and_next
4370
4371 static HRESULT WINAPI IWineD3DDeviceImpl_ProcessVertices(IWineD3DDevice *iface, UINT SrcStartIndex, UINT DestIndex, UINT VertexCount, IWineD3DVertexBuffer* pDestBuffer, IWineD3DVertexDeclaration* pVertexDecl, DWORD Flags) {
4372 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4373 WineDirect3DVertexStridedData strided;
4374 BOOL vbo = FALSE, streamWasUP = This->stateBlock->streamIsUP;
4375 TRACE("(%p)->(%d,%d,%d,%p,%p,%d\n", This, SrcStartIndex, DestIndex, VertexCount, pDestBuffer, pVertexDecl, Flags);
4376
4377 if(pVertexDecl) {
4378 ERR("Output vertex declaration not implemented yet\n");
4379 }
4380
4381 /* Need any context to write to the vbo. */
4382 ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
4383
4384 /* ProcessVertices reads from vertex buffers, which have to be assigned. DrawPrimitive and DrawPrimitiveUP
4385 * control the streamIsUP flag, thus restore it afterwards.
4386 */
4387 This->stateBlock->streamIsUP = FALSE;
4388 memset(&strided, 0, sizeof(strided));
4389 primitiveDeclarationConvertToStridedData(iface, FALSE, &strided, &vbo);
4390 This->stateBlock->streamIsUP = streamWasUP;
4391
4392 if(vbo || SrcStartIndex) {
4393 unsigned int i;
4394 /* ProcessVertices can't convert FROM a vbo, and vertex buffers used to source into ProcessVertices are
4395 * unlikely to ever be used for drawing. Release vbos in those buffers and fix up the strided structure
4396 *
4397 * Also get the start index in, but only loop over all elements if there's something to add at all.
4398 */
4399 #define FIXSRC(type) \
4400 if(strided.u.s.type.VBO) { \
4401 IWineD3DVertexBufferImpl *vb = (IWineD3DVertexBufferImpl *) This->stateBlock->streamSource[strided.u.s.type.streamNo]; \
4402 strided.u.s.type.VBO = 0; \
4403 strided.u.s.type.lpData = (BYTE *) ((unsigned long) strided.u.s.type.lpData + (unsigned long) vb->resource.allocatedMemory); \
4404 ENTER_GL(); \
4405 GL_EXTCALL(glDeleteBuffersARB(1, &vb->vbo)); \
4406 vb->vbo = 0; \
4407 LEAVE_GL(); \
4408 } \
4409 if(strided.u.s.type.lpData) { \
4410 strided.u.s.type.lpData += strided.u.s.type.dwStride * SrcStartIndex; \
4411 }
4412 FIXSRC(position);
4413 FIXSRC(blendWeights);
4414 FIXSRC(blendMatrixIndices);
4415 FIXSRC(normal);
4416 FIXSRC(pSize);
4417 FIXSRC(diffuse);
4418 FIXSRC(specular);
4419 for(i = 0; i < WINED3DDP_MAXTEXCOORD; i++) {
4420 FIXSRC(texCoords[i]);
4421 }
4422 FIXSRC(position2);
4423 FIXSRC(normal2);
4424 FIXSRC(tangent);
4425 FIXSRC(binormal);
4426 FIXSRC(tessFactor);
4427 FIXSRC(fog);
4428 FIXSRC(depth);
4429 FIXSRC(sample);
4430 #undef FIXSRC
4431 }
4432
4433 return process_vertices_strided(This, DestIndex, VertexCount, &strided, (IWineD3DVertexBufferImpl *) pDestBuffer, Flags);
4434 }
4435
4436 /*****
4437 * Get / Set Texture Stage States
4438 * TODO: Verify against dx9 definitions
4439 *****/
4440 static HRESULT WINAPI IWineD3DDeviceImpl_SetTextureStageState(IWineD3DDevice *iface, DWORD Stage, WINED3DTEXTURESTAGESTATETYPE Type, DWORD Value) {
4441 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4442 DWORD oldValue = This->updateStateBlock->textureState[Stage][Type];
4443
4444 TRACE("(%p) : Stage=%d, Type=%s(%d), Value=%d\n", This, Stage, debug_d3dtexturestate(Type), Type, Value);
4445
4446 if (Stage >= MAX_TEXTURES) {
4447 WARN("Attempting to set stage %u which is higher than the max stage %u, ignoring\n", Stage, MAX_TEXTURES - 1);
4448 return WINED3D_OK;
4449 }
4450
4451 This->updateStateBlock->changed.textureState[Stage][Type] = TRUE;
4452 This->updateStateBlock->textureState[Stage][Type] = Value;
4453
4454 if (This->isRecordingState) {
4455 TRACE("Recording... not performing anything\n");
4456 return WINED3D_OK;
4457 }
4458
4459 /* Checked after the assignments to allow proper stateblock recording */
4460 if(oldValue == Value) {
4461 TRACE("App is setting the old value over, nothing to do\n");
4462 return WINED3D_OK;
4463 }
4464
4465 if(Stage > This->stateBlock->lowest_disabled_stage &&
4466 This->shader_backend->StateTable[STATE_TEXTURESTAGE(0, Type)].representative == STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP)) {
4467 /* Colorop change above lowest disabled stage? That won't change anything in the gl setup
4468 * Changes in other states are important on disabled stages too
4469 */
4470 return WINED3D_OK;
4471 }
4472
4473 if(Type == WINED3DTSS_COLOROP) {
4474 int i;
4475
4476 if(Value == WINED3DTOP_DISABLE && oldValue != WINED3DTOP_DISABLE) {
4477 /* Previously enabled stage disabled now. Make sure to dirtify all enabled stages above Stage,
4478 * they have to be disabled
4479 *
4480 * The current stage is dirtified below.
4481 */
4482 for(i = Stage + 1; i < This->stateBlock->lowest_disabled_stage; i++) {
4483 TRACE("Additionally dirtifying stage %d\n", i);
4484 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP));
4485 }
4486 This->stateBlock->lowest_disabled_stage = Stage;
4487 TRACE("New lowest disabled: %d\n", Stage);
4488 } else if(Value != WINED3DTOP_DISABLE && oldValue == WINED3DTOP_DISABLE) {
4489 /* Previously disabled stage enabled. Stages above it may need enabling
4490 * stage must be lowest_disabled_stage here, if it's bigger success is returned above,
4491 * and stages below the lowest disabled stage can't be enabled(because they are enabled already).
4492 *
4493 * Again stage Stage doesn't need to be dirtified here, it is handled below.
4494 */
4495
4496 for(i = Stage + 1; i < GL_LIMITS(texture_stages); i++) {
4497 if(This->updateStateBlock->textureState[i][WINED3DTSS_COLOROP] == WINED3DTOP_DISABLE) {
4498 break;
4499 }
4500 TRACE("Additionally dirtifying stage %d due to enable\n", i);
4501 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP));
4502 }
4503 This->stateBlock->lowest_disabled_stage = i;
4504 TRACE("New lowest disabled: %d\n", i);
4505 }
4506 if(GL_SUPPORT(NV_REGISTER_COMBINERS) && !This->stateBlock->pixelShader) {
4507 /* TODO: Built a stage -> texture unit mapping for register combiners */
4508 }
4509 }
4510
4511 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(Stage, Type));
4512
4513 return WINED3D_OK;
4514 }
4515
4516 static HRESULT WINAPI IWineD3DDeviceImpl_GetTextureStageState(IWineD3DDevice *iface, DWORD Stage, WINED3DTEXTURESTAGESTATETYPE Type, DWORD* pValue) {
4517 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4518 TRACE("(%p) : requesting Stage %d, Type %d getting %d\n", This, Stage, Type, This->updateStateBlock->textureState[Stage][Type]);
4519 *pValue = This->updateStateBlock->textureState[Stage][Type];
4520 return WINED3D_OK;
4521 }
4522
4523 /*****
4524 * Get / Set Texture
4525 *****/
4526 static HRESULT WINAPI IWineD3DDeviceImpl_SetTexture(IWineD3DDevice *iface, DWORD Stage, IWineD3DBaseTexture* pTexture) {
4527 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4528 IWineD3DBaseTexture *oldTexture;
4529
4530 TRACE("(%p) : Stage %#x, Texture %p\n", This, Stage, pTexture);
4531
4532 if (Stage >= WINED3DVERTEXTEXTURESAMPLER0 && Stage <= WINED3DVERTEXTEXTURESAMPLER3) {
4533 Stage -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
4534 }
4535
4536 if (Stage >= sizeof(This->stateBlock->textures)/sizeof(This->stateBlock->textures[0])) {
4537 ERR("Current stage overflows textures array (stage %d)\n", Stage);
4538 return WINED3D_OK; /* Windows accepts overflowing this array ... we do not. */
4539 }
4540
4541 oldTexture = This->updateStateBlock->textures[Stage];
4542
4543 if(pTexture != NULL) {
4544 /* SetTexture isn't allowed on textures in WINED3DPOOL_SCRATCH;
4545 */
4546 if(((IWineD3DTextureImpl*)pTexture)->resource.pool == WINED3DPOOL_SCRATCH) {
4547 WARN("(%p) Attempt to set scratch texture rejected\n", pTexture);
4548 return WINED3DERR_INVALIDCALL;
4549 }
4550 This->stateBlock->textureDimensions[Stage] = IWineD3DBaseTexture_GetTextureDimensions(pTexture);
4551 }
4552
4553 TRACE("GL_LIMITS %d\n",GL_LIMITS(sampler_stages));
4554 TRACE("(%p) : oldtexture(%p)\n", This,oldTexture);
4555
4556 This->updateStateBlock->changed.textures[Stage] = TRUE;
4557 TRACE("(%p) : setting new texture to %p\n", This, pTexture);
4558 This->updateStateBlock->textures[Stage] = pTexture;
4559
4560 /* Handle recording of state blocks */
4561 if (This->isRecordingState) {
4562 TRACE("Recording... not performing anything\n");
4563 return WINED3D_OK;
4564 }
4565
4566 if(oldTexture == pTexture) {
4567 TRACE("App is setting the same texture again, nothing to do\n");
4568 return WINED3D_OK;
4569 }
4570
4571 /** NOTE: MSDN says that setTexture increases the reference count,
4572 * and that the application must set the texture back to null (or have a leaky application),
4573 * This means we should pass the refcount up to the parent
4574 *******************************/
4575 if (NULL != This->updateStateBlock->textures[Stage]) {
4576 IWineD3DBaseTextureImpl *new = (IWineD3DBaseTextureImpl *) This->updateStateBlock->textures[Stage];
4577 ULONG bindCount = InterlockedIncrement(&new->baseTexture.bindCount);
4578
4579 IWineD3DBaseTexture_AddRef(This->updateStateBlock->textures[Stage]);
4580 if(oldTexture == NULL && Stage < MAX_TEXTURES) {
4581 /* The source arguments for color and alpha ops have different meanings when a NULL texture is bound,
4582 * so the COLOROP and ALPHAOP have to be dirtified.
4583 */
4584 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(Stage, WINED3DTSS_COLOROP));
4585 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(Stage, WINED3DTSS_ALPHAOP));
4586 }
4587 if(bindCount == 1) {
4588 new->baseTexture.sampler = Stage;
4589 }
4590 /* More than one assignment? Doesn't matter, we only need one gl texture unit to use for uploading */
4591
4592 }
4593
4594 if (NULL != oldTexture) {
4595 IWineD3DBaseTextureImpl *old = (IWineD3DBaseTextureImpl *) oldTexture;
4596 LONG bindCount = InterlockedDecrement(&old->baseTexture.bindCount);
4597
4598 IWineD3DBaseTexture_Release(oldTexture);
4599 if(pTexture == NULL && Stage < MAX_TEXTURES) {
4600 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(Stage, WINED3DTSS_COLOROP));
4601 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(Stage, WINED3DTSS_ALPHAOP));
4602 }
4603
4604 if(bindCount && old->baseTexture.sampler == Stage) {
4605 int i;
4606 /* Have to do a search for the other sampler(s) where the texture is bound to
4607 * Shouldn't happen as long as apps bind a texture only to one stage
4608 */
4609 TRACE("Searcing for other sampler / stage id where the texture is bound to\n");
4610 for(i = 0; i < MAX_COMBINED_SAMPLERS; i++) {
4611 if(This->updateStateBlock->textures[i] == oldTexture) {
4612 old->baseTexture.sampler = i;
4613 break;
4614 }
4615 }
4616 }
4617 }
4618
4619 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(Stage));
4620
4621 return WINED3D_OK;
4622 }
4623
4624 static HRESULT WINAPI IWineD3DDeviceImpl_GetTexture(IWineD3DDevice *iface, DWORD Stage, IWineD3DBaseTexture** ppTexture) {
4625 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4626
4627 TRACE("(%p) : Stage %#x, ppTexture %p\n", This, Stage, ppTexture);
4628
4629 if (Stage >= WINED3DVERTEXTEXTURESAMPLER0 && Stage <= WINED3DVERTEXTEXTURESAMPLER3) {
4630 Stage -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
4631 }
4632
4633 if (Stage >= sizeof(This->stateBlock->textures)/sizeof(This->stateBlock->textures[0])) {
4634 ERR("Current stage overflows textures array (stage %d)\n", Stage);
4635 return WINED3D_OK; /* Windows accepts overflowing this array ... we do not. */
4636 }
4637
4638 *ppTexture=This->stateBlock->textures[Stage];
4639 if (*ppTexture)
4640 IWineD3DBaseTexture_AddRef(*ppTexture);
4641
4642 TRACE("(%p) : Returning %p\n", This, *ppTexture);
4643
4644 return WINED3D_OK;
4645 }
4646
4647 /*****
4648 * Get Back Buffer
4649 *****/
4650 static HRESULT WINAPI IWineD3DDeviceImpl_GetBackBuffer(IWineD3DDevice *iface, UINT iSwapChain, UINT BackBuffer, WINED3DBACKBUFFER_TYPE Type,
4651 IWineD3DSurface **ppBackBuffer) {
4652 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4653 IWineD3DSwapChain *swapChain;
4654 HRESULT hr;
4655
4656 TRACE("(%p) : BackBuf %d Type %d SwapChain %d returning %p\n", This, BackBuffer, Type, iSwapChain, *ppBackBuffer);
4657
4658 hr = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapChain);
4659 if (hr == WINED3D_OK) {
4660 hr = IWineD3DSwapChain_GetBackBuffer(swapChain, BackBuffer, Type, ppBackBuffer);
4661 IWineD3DSwapChain_Release(swapChain);
4662 } else {
4663 *ppBackBuffer = NULL;
4664 }
4665 return hr;
4666 }
4667
4668 static HRESULT WINAPI IWineD3DDeviceImpl_GetDeviceCaps(IWineD3DDevice *iface, WINED3DCAPS* pCaps) {
4669 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4670 WARN("(%p) : stub, calling idirect3d for now\n", This);
4671 return IWineD3D_GetDeviceCaps(This->wineD3D, This->adapterNo, This->devType, pCaps);
4672 }
4673
4674 static HRESULT WINAPI IWineD3DDeviceImpl_GetDisplayMode(IWineD3DDevice *iface, UINT iSwapChain, WINED3DDISPLAYMODE* pMode) {
4675 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4676 IWineD3DSwapChain *swapChain;
4677 HRESULT hr;
4678
4679 if(iSwapChain > 0) {
4680 hr = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapChain);
4681 if (hr == WINED3D_OK) {
4682 hr = IWineD3DSwapChain_GetDisplayMode(swapChain, pMode);
4683 IWineD3DSwapChain_Release(swapChain);
4684 } else {
4685 FIXME("(%p) Error getting display mode\n", This);
4686 }
4687 } else {
4688 /* Don't read the real display mode,
4689 but return the stored mode instead. X11 can't change the color
4690 depth, and some apps are pretty angry if they SetDisplayMode from
4691 24 to 16 bpp and find out that GetDisplayMode still returns 24 bpp
4692
4693 Also don't relay to the swapchain because with ddraw it's possible
4694 that there isn't a swapchain at all */
4695 pMode->Width = This->ddraw_width;
4696 pMode->Height = This->ddraw_height;
4697 pMode->Format = This->ddraw_format;
4698 pMode->RefreshRate = 0;
4699 hr = WINED3D_OK;
4700 }
4701
4702 return hr;
4703 }
4704
4705 static HRESULT WINAPI IWineD3DDeviceImpl_SetHWND(IWineD3DDevice *iface, HWND hWnd) {
4706 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4707 TRACE("(%p)->(%p)\n", This, hWnd);
4708
4709 if(This->ddraw_fullscreen) {
4710 if(This->ddraw_window && This->ddraw_window != hWnd) {
4711 IWineD3DDeviceImpl_RestoreWindow(iface, This->ddraw_window);
4712 }
4713 if(hWnd && This->ddraw_window != hWnd) {
4714 IWineD3DDeviceImpl_SetupFullscreenWindow(iface, hWnd);
4715 }
4716 }
4717
4718 This->ddraw_window = hWnd;
4719 return WINED3D_OK;
4720 }
4721
4722 static HRESULT WINAPI IWineD3DDeviceImpl_GetHWND(IWineD3DDevice *iface, HWND *hWnd) {
4723 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4724 TRACE("(%p)->(%p)\n", This, hWnd);
4725
4726 *hWnd = This->ddraw_window;
4727 return WINED3D_OK;
4728 }
4729
4730 /*****
4731 * Stateblock related functions
4732 *****/
4733
4734 static HRESULT WINAPI IWineD3DDeviceImpl_BeginStateBlock(IWineD3DDevice *iface) {
4735 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4736 IWineD3DStateBlockImpl *object;
4737 HRESULT temp_result;
4738 int i;
4739
4740 TRACE("(%p)\n", This);
4741
4742 if (This->isRecordingState) {
4743 return WINED3DERR_INVALIDCALL;
4744 }
4745
4746 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DStateBlockImpl));
4747 if (NULL == object ) {
4748 FIXME("(%p)Error allocating memory for stateblock\n", This);
4749 return E_OUTOFMEMORY;
4750 }
4751 TRACE("(%p) created object %p\n", This, object);
4752 object->wineD3DDevice= This;
4753 /** FIXME: object->parent = parent; **/
4754 object->parent = NULL;
4755 object->blockType = WINED3DSBT_RECORDED;
4756 object->ref = 1;
4757 object->lpVtbl = &IWineD3DStateBlock_Vtbl;
4758
4759 for(i = 0; i < LIGHTMAP_SIZE; i++) {
4760 list_init(&object->lightMap[i]);
4761 }
4762
4763 temp_result = allocate_shader_constants(object);
4764 if (WINED3D_OK != temp_result)
4765 return temp_result;
4766
4767 IWineD3DStateBlock_Release((IWineD3DStateBlock*)This->updateStateBlock);
4768 This->updateStateBlock = object;
4769 This->isRecordingState = TRUE;
4770
4771 TRACE("(%p) recording stateblock %p\n",This , object);
4772 return WINED3D_OK;
4773 }
4774
4775 static HRESULT WINAPI IWineD3DDeviceImpl_EndStateBlock(IWineD3DDevice *iface, IWineD3DStateBlock** ppStateBlock) {
4776 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4777 unsigned int i, j;
4778 IWineD3DStateBlockImpl *object = This->updateStateBlock;
4779
4780 if (!This->isRecordingState) {
4781 FIXME("(%p) not recording! returning error\n", This);
4782 *ppStateBlock = NULL;
4783 return WINED3DERR_INVALIDCALL;
4784 }
4785
4786 for(i = 1; i <= WINEHIGHEST_RENDER_STATE; i++) {
4787 if(object->changed.renderState[i]) {
4788 object->contained_render_states[object->num_contained_render_states] = i;
4789 object->num_contained_render_states++;
4790 }
4791 }
4792 for(i = 1; i <= HIGHEST_TRANSFORMSTATE; i++) {
4793 if(object->changed.transform[i]) {
4794 object->contained_transform_states[object->num_contained_transform_states] = i;
4795 object->num_contained_transform_states++;
4796 }
4797 }
4798 for(i = 0; i < GL_LIMITS(vshader_constantsF); i++) {
4799 if(object->changed.vertexShaderConstantsF[i]) {
4800 object->contained_vs_consts_f[object->num_contained_vs_consts_f] = i;
4801 object->num_contained_vs_consts_f++;
4802 }
4803 }
4804 for(i = 0; i < MAX_CONST_I; i++) {
4805 if(object->changed.vertexShaderConstantsI[i]) {
4806 object->contained_vs_consts_i[object->num_contained_vs_consts_i] = i;
4807 object->num_contained_vs_consts_i++;
4808 }
4809 }
4810 for(i = 0; i < MAX_CONST_B; i++) {
4811 if(object->changed.vertexShaderConstantsB[i]) {
4812 object->contained_vs_consts_b[object->num_contained_vs_consts_b] = i;
4813 object->num_contained_vs_consts_b++;
4814 }
4815 }
4816 for(i = 0; i < MAX_CONST_I; i++) {
4817 if(object->changed.pixelShaderConstantsI[i]) {
4818 object->contained_ps_consts_i[object->num_contained_ps_consts_i] = i;
4819 object->num_contained_ps_consts_i++;
4820 }
4821 }
4822 for(i = 0; i < MAX_CONST_B; i++) {
4823 if(object->changed.pixelShaderConstantsB[i]) {
4824 object->contained_ps_consts_b[object->num_contained_ps_consts_b] = i;
4825 object->num_contained_ps_consts_b++;
4826 }
4827 }
4828 for(i = 0; i < MAX_TEXTURES; i++) {
4829 for(j = 1; j <= WINED3D_HIGHEST_TEXTURE_STATE; j++) {
4830 if(object->changed.textureState[i][j]) {
4831 object->contained_tss_states[object->num_contained_tss_states].stage = i;
4832 object->contained_tss_states[object->num_contained_tss_states].state = j;
4833 object->num_contained_tss_states++;
4834 }
4835 }
4836 }
4837 for(i = 0; i < MAX_COMBINED_SAMPLERS; i++){
4838 for (j = 1; j < WINED3D_HIGHEST_SAMPLER_STATE; j++) {
4839 if(object->changed.samplerState[i][j]) {
4840 object->contained_sampler_states[object->num_contained_sampler_states].stage = i;
4841 object->contained_sampler_states[object->num_contained_sampler_states].state = j;
4842 object->num_contained_sampler_states++;
4843 }
4844 }
4845 }
4846
4847 *ppStateBlock = (IWineD3DStateBlock*) object;
4848 This->isRecordingState = FALSE;
4849 This->updateStateBlock = This->stateBlock;
4850 IWineD3DStateBlock_AddRef((IWineD3DStateBlock*)This->updateStateBlock);
4851 /* IWineD3DStateBlock_AddRef(*ppStateBlock); don't need to do this, since we should really just release UpdateStateBlock first */
4852 TRACE("(%p) returning token (ptr to stateblock) of %p\n", This, *ppStateBlock);
4853 return WINED3D_OK;
4854 }
4855
4856 /*****
4857 * Scene related functions
4858 *****/
4859 static HRESULT WINAPI IWineD3DDeviceImpl_BeginScene(IWineD3DDevice *iface) {
4860 /* At the moment we have no need for any functionality at the beginning
4861 of a scene */
4862 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4863 TRACE("(%p)\n", This);
4864
4865 if(This->inScene) {
4866 TRACE("Already in Scene, returning WINED3DERR_INVALIDCALL\n");
4867 return WINED3DERR_INVALIDCALL;
4868 }
4869 This->inScene = TRUE;
4870 return WINED3D_OK;
4871 }
4872
4873 static HRESULT WINAPI IWineD3DDeviceImpl_EndScene(IWineD3DDevice *iface) {
4874 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4875 TRACE("(%p)\n", This);
4876
4877 if(!This->inScene) {
4878 TRACE("Not in scene, returning WINED3DERR_INVALIDCALL\n");
4879 return WINED3DERR_INVALIDCALL;
4880 }
4881
4882 ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
4883 /* We only have to do this if we need to read the, swapbuffers performs a flush for us */
4884 ENTER_GL();
4885 glFlush();
4886 checkGLcall("glFlush");
4887 LEAVE_GL();
4888
4889 This->inScene = FALSE;
4890 return WINED3D_OK;
4891 }
4892
4893 static HRESULT WINAPI IWineD3DDeviceImpl_Present(IWineD3DDevice *iface,
4894 CONST RECT* pSourceRect, CONST RECT* pDestRect,
4895 HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion) {
4896 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4897 IWineD3DSwapChain *swapChain = NULL;
4898 int i;
4899 int swapchains = IWineD3DDeviceImpl_GetNumberOfSwapChains(iface);
4900
4901 TRACE("(%p) Presenting the frame\n", This);
4902
4903 for(i = 0 ; i < swapchains ; i ++) {
4904
4905 IWineD3DDeviceImpl_GetSwapChain(iface, i, &swapChain);
4906 TRACE("presentinng chain %d, %p\n", i, swapChain);
4907 IWineD3DSwapChain_Present(swapChain, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion, 0);
4908 IWineD3DSwapChain_Release(swapChain);
4909 }
4910
4911 return WINED3D_OK;
4912 }
4913
4914 /* Not called from the VTable (internal subroutine) */
4915 HRESULT IWineD3DDeviceImpl_ClearSurface(IWineD3DDeviceImpl *This, IWineD3DSurfaceImpl *target, DWORD Count,
4916 CONST WINED3DRECT* pRects, DWORD Flags, WINED3DCOLOR Color,
4917 float Z, DWORD Stencil) {
4918 GLbitfield glMask = 0;
4919 unsigned int i;
4920 WINED3DRECT curRect;
4921 RECT vp_rect;
4922 WINED3DVIEWPORT *vp = &This->stateBlock->viewport;
4923 UINT drawable_width, drawable_height;
4924 IWineD3DSurfaceImpl *depth_stencil = (IWineD3DSurfaceImpl *) This->stencilBufferTarget;
4925
4926 /* When we're clearing parts of the drawable, make sure that the target surface is well up to date in the
4927 * drawable. After the clear we'll mark the drawable up to date, so we have to make sure that this is true
4928 * for the cleared parts, and the untouched parts.
4929 *
4930 * If we're clearing the whole target there is no need to copy it into the drawable, it will be overwritten
4931 * anyway. If we're not clearing the color buffer we don't have to copy either since we're not going to set
4932 * the drawable up to date. We have to check all settings that limit the clear area though. Do not bother
4933 * checking all this if the dest surface is in the drawable anyway.
4934 */
4935 if((Flags & WINED3DCLEAR_TARGET) && !(target->Flags & SFLAG_INDRAWABLE)) {
4936 while(1) {
4937 if(vp->X != 0 || vp->Y != 0 ||
4938 vp->Width < target->currentDesc.Width || vp->Height < target->currentDesc.Height) {
4939 IWineD3DSurface_LoadLocation((IWineD3DSurface *) target, SFLAG_INDRAWABLE, NULL);
4940 break;
4941 }
4942 if(This->stateBlock->renderState[WINED3DRS_SCISSORTESTENABLE] && (
4943 This->stateBlock->scissorRect.left > 0 || This->stateBlock->scissorRect.top > 0 ||
4944 This->stateBlock->scissorRect.right < target->currentDesc.Width ||
4945 This->stateBlock->scissorRect.bottom < target->currentDesc.Height)) {
4946 IWineD3DSurface_LoadLocation((IWineD3DSurface *) target, SFLAG_INDRAWABLE, NULL);
4947 break;
4948 }
4949 if(Count > 0 && pRects && (
4950 pRects[0].x1 > 0 || pRects[0].y1 > 0 ||
4951 pRects[0].x2 < target->currentDesc.Width ||
4952 pRects[0].y2 < target->currentDesc.Height)) {
4953 IWineD3DSurface_LoadLocation((IWineD3DSurface *) target, SFLAG_INDRAWABLE, NULL);
4954 break;
4955 }
4956 break;
4957 }
4958 }
4959
4960 target->get_drawable_size(target, &drawable_width, &drawable_height);
4961
4962 ActivateContext(This, (IWineD3DSurface *) target, CTXUSAGE_CLEAR);
4963 ENTER_GL();
4964
4965 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) {
4966 apply_fbo_state((IWineD3DDevice *) This);
4967 }
4968
4969 /* Only set the values up once, as they are not changing */
4970 if (Flags & WINED3DCLEAR_STENCIL) {
4971 glClearStencil(Stencil);
4972 checkGLcall("glClearStencil");
4973 glMask = glMask | GL_STENCIL_BUFFER_BIT;
4974 glStencilMask(0xFFFFFFFF);
4975 }
4976
4977 if (Flags & WINED3DCLEAR_ZBUFFER) {
4978 glDepthMask(GL_TRUE);
4979 glClearDepth(Z);
4980 checkGLcall("glClearDepth");
4981 glMask = glMask | GL_DEPTH_BUFFER_BIT;
4982 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_ZWRITEENABLE));
4983
4984 if(This->depth_copy_state == WINED3D_DCS_COPY) {
4985 if(vp->X != 0 || vp->Y != 0 ||
4986 vp->Width < depth_stencil->currentDesc.Width || vp->Height < depth_stencil->currentDesc.Height) {
4987 depth_copy((IWineD3DDevice *) This);
4988 }
4989 else if(This->stateBlock->renderState[WINED3DRS_SCISSORTESTENABLE] && (
4990 This->stateBlock->scissorRect.left > 0 || This->stateBlock->scissorRect.top > 0 ||
4991 This->stateBlock->scissorRect.right < depth_stencil->currentDesc.Width ||
4992 This->stateBlock->scissorRect.bottom < depth_stencil->currentDesc.Height)) {
4993 depth_copy((IWineD3DDevice *) This);
4994 }
4995 else if(Count > 0 && pRects && (
4996 pRects[0].x1 > 0 || pRects[0].y1 > 0 ||
4997 pRects[0].x2 < depth_stencil->currentDesc.Width ||
4998 pRects[0].y2 < depth_stencil->currentDesc.Height)) {
4999 depth_copy((IWineD3DDevice *) This);
5000 }
5001 }
5002 This->depth_copy_state = WINED3D_DCS_INITIAL;
5003 }
5004
5005 if (Flags & WINED3DCLEAR_TARGET) {
5006 TRACE("Clearing screen with glClear to color %x\n", Color);
5007 glClearColor(D3DCOLOR_R(Color),
5008 D3DCOLOR_G(Color),
5009 D3DCOLOR_B(Color),
5010 D3DCOLOR_A(Color));
5011 checkGLcall("glClearColor");
5012
5013 /* Clear ALL colors! */
5014 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
5015 glMask = glMask | GL_COLOR_BUFFER_BIT;
5016 }
5017
5018 vp_rect.left = vp->X;
5019 vp_rect.top = vp->Y;
5020 vp_rect.right = vp->X + vp->Width;
5021 vp_rect.bottom = vp->Y + vp->Height;
5022 if (!(Count > 0 && pRects)) {
5023 if(This->stateBlock->renderState[WINED3DRS_SCISSORTESTENABLE]) {
5024 IntersectRect(&vp_rect, &vp_rect, &This->stateBlock->scissorRect);
5025 }
5026 if(This->render_offscreen) {
5027 glScissor(vp_rect.left, vp_rect.top,
5028 vp_rect.right - vp_rect.left, vp_rect.bottom - vp_rect.top);
5029 } else {
5030 glScissor(vp_rect.left, drawable_height - vp_rect.bottom,
5031 vp_rect.right - vp_rect.left, vp_rect.bottom - vp_rect.top);
5032 }
5033 checkGLcall("glScissor");
5034 glClear(glMask);
5035 checkGLcall("glClear");
5036 } else {
5037 /* Now process each rect in turn */
5038 for (i = 0; i < Count; i++) {
5039 /* Note gl uses lower left, width/height */
5040 IntersectRect((RECT *) &curRect, &vp_rect, (RECT *) &pRects[i]);
5041 if(This->stateBlock->renderState[WINED3DRS_SCISSORTESTENABLE]) {
5042 IntersectRect((RECT *) &curRect, (RECT *) &curRect, &This->stateBlock->scissorRect);
5043 }
5044 TRACE("(%p) Rect=(%d,%d)->(%d,%d) glRect=(%d,%d), len=%d, hei=%d\n", This,
5045 pRects[i].x1, pRects[i].y1, pRects[i].x2, pRects[i].y2,
5046 curRect.x1, (target->currentDesc.Height - curRect.y2),
5047 curRect.x2 - curRect.x1, curRect.y2 - curRect.y1);
5048
5049 /* Tests show that rectangles where x1 > x2 or y1 > y2 are ignored silently.
5050 * The rectangle is not cleared, no error is returned, but further rectanlges are
5051 * still cleared if they are valid
5052 */
5053 if(curRect.x1 > curRect.x2 || curRect.y1 > curRect.y2) {
5054 TRACE("Rectangle with negative dimensions, ignoring\n");
5055 continue;
5056 }
5057
5058 if(This->render_offscreen) {
5059 glScissor(curRect.x1, curRect.y1,
5060 curRect.x2 - curRect.x1, curRect.y2 - curRect.y1);
5061 } else {
5062 glScissor(curRect.x1, drawable_height - curRect.y2,
5063 curRect.x2 - curRect.x1, curRect.y2 - curRect.y1);
5064 }
5065 checkGLcall("glScissor");
5066
5067 glClear(glMask);
5068 checkGLcall("glClear");
5069 }
5070 }
5071
5072 /* Restore the old values (why..?) */
5073 if (Flags & WINED3DCLEAR_STENCIL) {
5074 glStencilMask(This->stateBlock->renderState[WINED3DRS_STENCILWRITEMASK]);
5075 }
5076 if (Flags & WINED3DCLEAR_TARGET) {
5077 DWORD mask = This->stateBlock->renderState[WINED3DRS_COLORWRITEENABLE];
5078 glColorMask(mask & WINED3DCOLORWRITEENABLE_RED ? GL_TRUE : GL_FALSE,
5079 mask & WINED3DCOLORWRITEENABLE_GREEN ? GL_TRUE : GL_FALSE,
5080 mask & WINED3DCOLORWRITEENABLE_BLUE ? GL_TRUE : GL_FALSE,
5081 mask & WINED3DCOLORWRITEENABLE_ALPHA ? GL_TRUE : GL_FALSE);
5082
5083 /* Dirtify the target surface for now. If the surface is locked regularly, and an up to date sysmem copy exists,
5084 * it is most likely more efficient to perform a clear on the sysmem copy too instead of downloading it
5085 */
5086 IWineD3DSurface_ModifyLocation(This->lastActiveRenderTarget, SFLAG_INDRAWABLE, TRUE);
5087 /* TODO: Move the fbo logic into ModifyLocation() */
5088 if(This->render_offscreen && wined3d_settings.offscreen_rendering_mode == ORM_FBO) {
5089 target->Flags |= SFLAG_INTEXTURE;
5090 }
5091 }
5092 LEAVE_GL();
5093
5094 return WINED3D_OK;
5095 }
5096
5097 static HRESULT WINAPI IWineD3DDeviceImpl_Clear(IWineD3DDevice *iface, DWORD Count, CONST WINED3DRECT* pRects,
5098 DWORD Flags, WINED3DCOLOR Color, float Z, DWORD Stencil) {
5099 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5100 IWineD3DSurfaceImpl *target = (IWineD3DSurfaceImpl *)This->render_targets[0];
5101
5102 TRACE("(%p) Count (%d), pRects (%p), Flags (%x), Color (0x%08x), Z (%f), Stencil (%d)\n", This,
5103 Count, pRects, Flags, Color, Z, Stencil);
5104
5105 if(Flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL) && This->stencilBufferTarget == NULL) {
5106 WARN("Clearing depth and/or stencil without a depth stencil buffer attached, returning WINED3DERR_INVALIDCALL\n");
5107 /* TODO: What about depth stencil buffers without stencil bits? */
5108 return WINED3DERR_INVALIDCALL;
5109 }
5110
5111 return IWineD3DDeviceImpl_ClearSurface(This, target, Count, pRects, Flags, Color, Z, Stencil);
5112 }
5113
5114 /*****
5115 * Drawing functions
5116 *****/
5117 static HRESULT WINAPI IWineD3DDeviceImpl_DrawPrimitive(IWineD3DDevice *iface, WINED3DPRIMITIVETYPE PrimitiveType, UINT StartVertex,
5118 UINT PrimitiveCount) {
5119
5120 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5121
5122 TRACE("(%p) : Type=(%d,%s), Start=%d, Count=%d\n", This, PrimitiveType,
5123 debug_d3dprimitivetype(PrimitiveType),
5124 StartVertex, PrimitiveCount);
5125
5126 /* The index buffer is not needed here, but restore it, otherwise it is hell to keep track of */
5127 if(This->stateBlock->streamIsUP) {
5128 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
5129 This->stateBlock->streamIsUP = FALSE;
5130 }
5131
5132 if(This->stateBlock->loadBaseVertexIndex != 0) {
5133 This->stateBlock->loadBaseVertexIndex = 0;
5134 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
5135 }
5136 /* Account for the loading offset due to index buffers. Instead of reloading all sources correct it with the startvertex parameter */
5137 drawPrimitive(iface, PrimitiveType, PrimitiveCount, StartVertex, 0/* NumVertices */, -1 /* indxStart */,
5138 0 /* indxSize */, NULL /* indxData */, 0 /* minIndex */);
5139 return WINED3D_OK;
5140 }
5141
5142 /* TODO: baseVIndex needs to be provided from This->stateBlock->baseVertexIndex when called from d3d8 */
5143 static HRESULT WINAPI IWineD3DDeviceImpl_DrawIndexedPrimitive(IWineD3DDevice *iface,
5144 WINED3DPRIMITIVETYPE PrimitiveType,
5145 UINT minIndex, UINT NumVertices, UINT startIndex, UINT primCount) {
5146
5147 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5148 UINT idxStride = 2;
5149 IWineD3DIndexBuffer *pIB;
5150 WINED3DINDEXBUFFER_DESC IdxBufDsc;
5151 GLuint vbo;
5152
5153 pIB = This->stateBlock->pIndexData;
5154 if (!pIB) {
5155 /* D3D9 returns D3DERR_INVALIDCALL when DrawIndexedPrimitive is called
5156 * without an index buffer set. (The first time at least...)
5157 * D3D8 simply dies, but I doubt it can do much harm to return
5158 * D3DERR_INVALIDCALL there as well. */
5159 ERR("(%p) : Called without a valid index buffer set, returning WINED3DERR_INVALIDCALL\n", This);
5160 return WINED3DERR_INVALIDCALL;
5161 }
5162
5163 if(This->stateBlock->streamIsUP) {
5164 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
5165 This->stateBlock->streamIsUP = FALSE;
5166 }
5167 vbo = ((IWineD3DIndexBufferImpl *) pIB)->vbo;
5168
5169 TRACE("(%p) : Type=(%d,%s), min=%d, CountV=%d, startIdx=%d, countP=%d\n", This,
5170 PrimitiveType, debug_d3dprimitivetype(PrimitiveType),
5171 minIndex, NumVertices, startIndex, primCount);
5172
5173 IWineD3DIndexBuffer_GetDesc(pIB, &IdxBufDsc);
5174 if (IdxBufDsc.Format == WINED3DFMT_INDEX16) {
5175 idxStride = 2;
5176 } else {
5177 idxStride = 4;
5178 }
5179
5180 if(This->stateBlock->loadBaseVertexIndex != This->stateBlock->baseVertexIndex) {
5181 This->stateBlock->loadBaseVertexIndex = This->stateBlock->baseVertexIndex;
5182 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
5183 }
5184
5185 drawPrimitive(iface, PrimitiveType, primCount, 0, NumVertices, startIndex,
5186 idxStride, vbo ? NULL : ((IWineD3DIndexBufferImpl *) pIB)->resource.allocatedMemory, minIndex);
5187
5188 return WINED3D_OK;
5189 }
5190
5191 static HRESULT WINAPI IWineD3DDeviceImpl_DrawPrimitiveUP(IWineD3DDevice *iface, WINED3DPRIMITIVETYPE PrimitiveType,
5192 UINT PrimitiveCount, CONST void* pVertexStreamZeroData,
5193 UINT VertexStreamZeroStride) {
5194 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5195 IWineD3DVertexBuffer *vb;
5196
5197 TRACE("(%p) : Type=(%d,%s), pCount=%d, pVtxData=%p, Stride=%d\n", This, PrimitiveType,
5198 debug_d3dprimitivetype(PrimitiveType),
5199 PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride);
5200
5201 /* Note in the following, it's not this type, but that's the purpose of streamIsUP */
5202 vb = This->stateBlock->streamSource[0];
5203 This->stateBlock->streamSource[0] = (IWineD3DVertexBuffer *)pVertexStreamZeroData;
5204 if(vb) IWineD3DVertexBuffer_Release(vb);
5205 This->stateBlock->streamOffset[0] = 0;
5206 This->stateBlock->streamStride[0] = VertexStreamZeroStride;
5207 This->stateBlock->streamIsUP = TRUE;
5208 This->stateBlock->loadBaseVertexIndex = 0;
5209
5210 /* TODO: Only mark dirty if drawing from a different UP address */
5211 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
5212
5213 drawPrimitive(iface, PrimitiveType, PrimitiveCount, 0 /* start vertex */, 0 /* NumVertices */,
5214 0 /* indxStart*/, 0 /* indxSize*/, NULL /* indxData */, 0 /* indxMin */);
5215
5216 /* MSDN specifies stream zero settings must be set to NULL */
5217 This->stateBlock->streamStride[0] = 0;
5218 This->stateBlock->streamSource[0] = NULL;
5219
5220 /* stream zero settings set to null at end, as per the msdn. No need to mark dirty here, the app has to set
5221 * the new stream sources or use UP drawing again
5222 */
5223 return WINED3D_OK;
5224 }
5225
5226 static HRESULT WINAPI IWineD3DDeviceImpl_DrawIndexedPrimitiveUP(IWineD3DDevice *iface, WINED3DPRIMITIVETYPE PrimitiveType,
5227 UINT MinVertexIndex, UINT NumVertices,
5228 UINT PrimitiveCount, CONST void* pIndexData,
5229 WINED3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,
5230 UINT VertexStreamZeroStride) {
5231 int idxStride;
5232 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5233 IWineD3DVertexBuffer *vb;
5234 IWineD3DIndexBuffer *ib;
5235
5236 TRACE("(%p) : Type=(%d,%s), MinVtxIdx=%d, NumVIdx=%d, PCount=%d, pidxdata=%p, IdxFmt=%d, pVtxdata=%p, stride=%d\n",
5237 This, PrimitiveType, debug_d3dprimitivetype(PrimitiveType),
5238 MinVertexIndex, NumVertices, PrimitiveCount, pIndexData,
5239 IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride);
5240
5241 if (IndexDataFormat == WINED3DFMT_INDEX16) {
5242 idxStride = 2;
5243 } else {
5244 idxStride = 4;
5245 }
5246
5247 /* Note in the following, it's not this type, but that's the purpose of streamIsUP */
5248 vb = This->stateBlock->streamSource[0];
5249 This->stateBlock->streamSource[0] = (IWineD3DVertexBuffer *)pVertexStreamZeroData;
5250 if(vb) IWineD3DVertexBuffer_Release(vb);
5251 This->stateBlock->streamIsUP = TRUE;
5252 This->stateBlock->streamOffset[0] = 0;
5253 This->stateBlock->streamStride[0] = VertexStreamZeroStride;
5254
5255 /* Set to 0 as per msdn. Do it now due to the stream source loading during drawPrimitive */
5256 This->stateBlock->baseVertexIndex = 0;
5257 This->stateBlock->loadBaseVertexIndex = 0;
5258 /* Mark the state dirty until we have nicer tracking of the stream source pointers */
5259 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VDECL);
5260 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
5261
5262 drawPrimitive(iface, PrimitiveType, PrimitiveCount, 0 /* vertexStart */, NumVertices, 0 /* indxStart */, idxStride, pIndexData, MinVertexIndex);
5263
5264 /* MSDN specifies stream zero settings and index buffer must be set to NULL */
5265 This->stateBlock->streamSource[0] = NULL;
5266 This->stateBlock->streamStride[0] = 0;
5267 ib = This->stateBlock->pIndexData;
5268 if(ib) {
5269 IWineD3DIndexBuffer_Release(ib);
5270 This->stateBlock->pIndexData = NULL;
5271 }
5272 /* No need to mark the stream source state dirty here. Either the app calls UP drawing again, or it has to call
5273 * SetStreamSource to specify a vertex buffer
5274 */
5275
5276 return WINED3D_OK;
5277 }
5278
5279 static HRESULT WINAPI IWineD3DDeviceImpl_DrawPrimitiveStrided (IWineD3DDevice *iface, WINED3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, WineDirect3DVertexStridedData *DrawPrimStrideData) {
5280 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
5281
5282 /* Mark the state dirty until we have nicer tracking
5283 * its fine to change baseVertexIndex because that call is only called by ddraw which does not need
5284 * that value.
5285 */
5286 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VDECL);
5287 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
5288 This->stateBlock->baseVertexIndex = 0;
5289 This->up_strided = DrawPrimStrideData;
5290 drawPrimitive(iface, PrimitiveType, PrimitiveCount, 0, 0, 0, 0, NULL, 0);
5291 This->up_strided = NULL;
5292 return WINED3D_OK;
5293 }
5294
5295 static HRESULT WINAPI IWineD3DDeviceImpl_DrawIndexedPrimitiveStrided(IWineD3DDevice *iface, WINED3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, WineDirect3DVertexStridedData *DrawPrimStrideData, UINT NumVertices, CONST void *pIndexData, WINED3DFORMAT IndexDataFormat) {
5296 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
5297 DWORD idxSize = (IndexDataFormat == WINED3DFMT_INDEX32 ? 4 : 2);
5298
5299 /* Mark the state dirty until we have nicer tracking
5300 * its fine to change baseVertexIndex because that call is only called by ddraw which does not need
5301 * that value.
5302 */
5303 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VDECL);
5304 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
5305 This->stateBlock->streamIsUP = TRUE;
5306 This->stateBlock->baseVertexIndex = 0;
5307 This->up_strided = DrawPrimStrideData;
5308 drawPrimitive(iface, PrimitiveType, PrimitiveCount, 0 /* startvertexidx */, 0 /* numindices */, 0 /* startidx */, idxSize, pIndexData, 0 /* minindex */);
5309 This->up_strided = NULL;
5310 return WINED3D_OK;
5311 }
5312
5313 static HRESULT IWineD3DDeviceImpl_UpdateVolume(IWineD3DDevice *iface, IWineD3DVolume *pSourceVolume, IWineD3DVolume *pDestinationVolume) {
5314 /* This is a helper function for UpdateTexture, there is no public UpdateVolume method in d3d. Since it's
5315 * not callable by the app directly no parameter validation checks are needed here.
5316 */
5317 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
5318 WINED3DLOCKED_BOX src;
5319 WINED3DLOCKED_BOX dst;
5320 HRESULT hr;
5321 TRACE("(%p)->(%p, %p)\n", This, pSourceVolume, pDestinationVolume);
5322
5323 /* TODO: Implement direct loading into the gl volume instead of using memcpy and
5324 * dirtification to improve loading performance.
5325 */
5326 hr = IWineD3DVolume_LockBox(pSourceVolume, &src, NULL, WINED3DLOCK_READONLY);
5327 if(FAILED(hr)) return hr;
5328 hr = IWineD3DVolume_LockBox(pDestinationVolume, &dst, NULL, WINED3DLOCK_DISCARD);
5329 if(FAILED(hr)) {
5330 IWineD3DVolume_UnlockBox(pSourceVolume);
5331 return hr;
5332 }
5333
5334 memcpy(dst.pBits, src.pBits, ((IWineD3DVolumeImpl *) pDestinationVolume)->resource.size);
5335
5336 hr = IWineD3DVolume_UnlockBox(pDestinationVolume);
5337 if(FAILED(hr)) {
5338 IWineD3DVolume_UnlockBox(pSourceVolume);
5339 } else {
5340 hr = IWineD3DVolume_UnlockBox(pSourceVolume);
5341 }
5342 return hr;
5343 }
5344
5345 /* Yet another way to update a texture, some apps use this to load default textures instead of using surface/texture lock/unlock */
5346 static HRESULT WINAPI IWineD3DDeviceImpl_UpdateTexture (IWineD3DDevice *iface, IWineD3DBaseTexture *pSourceTexture, IWineD3DBaseTexture *pDestinationTexture){
5347 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5348 HRESULT hr = WINED3D_OK;
5349 WINED3DRESOURCETYPE sourceType;
5350 WINED3DRESOURCETYPE destinationType;
5351 int i ,levels;
5352
5353 /* TODO: think about moving the code into IWineD3DBaseTexture */
5354
5355 TRACE("(%p) Source %p Destination %p\n", This, pSourceTexture, pDestinationTexture);
5356
5357 /* verify that the source and destination textures aren't NULL */
5358 if (NULL == pSourceTexture || NULL == pDestinationTexture) {
5359 WARN("(%p) : source (%p) and destination (%p) textures must not be NULL, returning WINED3DERR_INVALIDCALL\n",
5360 This, pSourceTexture, pDestinationTexture);
5361 hr = WINED3DERR_INVALIDCALL;
5362 }
5363
5364 if (pSourceTexture == pDestinationTexture) {
5365 WARN("(%p) : source (%p) and destination (%p) textures must be different, returning WINED3DERR_INVALIDCALL\n",
5366 This, pSourceTexture, pDestinationTexture);
5367 hr = WINED3DERR_INVALIDCALL;
5368 }
5369 /* Verify that the source and destination textures are the same type */
5370 sourceType = IWineD3DBaseTexture_GetType(pSourceTexture);
5371 destinationType = IWineD3DBaseTexture_GetType(pDestinationTexture);
5372
5373 if (sourceType != destinationType) {
5374 WARN("(%p) Sorce and destination types must match, returning WINED3DERR_INVALIDCALL\n",
5375 This);
5376 hr = WINED3DERR_INVALIDCALL;
5377 }
5378
5379 /* check that both textures have the identical numbers of levels */
5380 if (IWineD3DBaseTexture_GetLevelCount(pDestinationTexture) != IWineD3DBaseTexture_GetLevelCount(pSourceTexture)) {
5381 WARN("(%p) : source (%p) and destination (%p) textures must have identical numbers of levels, returning WINED3DERR_INVALIDCALL\n", This, pSourceTexture, pDestinationTexture);
5382 hr = WINED3DERR_INVALIDCALL;
5383 }
5384
5385 if (WINED3D_OK == hr) {
5386
5387 /* Make sure that the destination texture is loaded */
5388 IWineD3DBaseTexture_PreLoad(pDestinationTexture);
5389
5390 /* Update every surface level of the texture */
5391 levels = IWineD3DBaseTexture_GetLevelCount(pDestinationTexture);
5392
5393 switch (sourceType) {
5394 case WINED3DRTYPE_TEXTURE:
5395 {
5396 IWineD3DSurface *srcSurface;
5397 IWineD3DSurface *destSurface;
5398
5399 for (i = 0 ; i < levels ; ++i) {
5400 IWineD3DTexture_GetSurfaceLevel((IWineD3DTexture *)pSourceTexture, i, &srcSurface);
5401 IWineD3DTexture_GetSurfaceLevel((IWineD3DTexture *)pDestinationTexture, i, &destSurface);
5402 hr = IWineD3DDevice_UpdateSurface(iface, srcSurface, NULL, destSurface, NULL);
5403 IWineD3DSurface_Release(srcSurface);
5404 IWineD3DSurface_Release(destSurface);
5405 if (WINED3D_OK != hr) {
5406 WARN("(%p) : Call to update surface failed\n", This);
5407 return hr;
5408 }
5409 }
5410 }
5411 break;
5412 case WINED3DRTYPE_CUBETEXTURE:
5413 {
5414 IWineD3DSurface *srcSurface;
5415 IWineD3DSurface *destSurface;
5416 WINED3DCUBEMAP_FACES faceType;
5417
5418 for (i = 0 ; i < levels ; ++i) {
5419 /* Update each cube face */
5420 for (faceType = WINED3DCUBEMAP_FACE_POSITIVE_X; faceType <= WINED3DCUBEMAP_FACE_NEGATIVE_Z; ++faceType){
5421 hr = IWineD3DCubeTexture_GetCubeMapSurface((IWineD3DCubeTexture *)pSourceTexture, faceType, i, &srcSurface);
5422 if (WINED3D_OK != hr) {
5423 FIXME("(%p) : Failed to get src cube surface facetype %d, level %d\n", This, faceType, i);
5424 } else {
5425 TRACE("Got srcSurface %p\n", srcSurface);
5426 }
5427 hr = IWineD3DCubeTexture_GetCubeMapSurface((IWineD3DCubeTexture *)pDestinationTexture, faceType, i, &destSurface);
5428 if (WINED3D_OK != hr) {
5429 FIXME("(%p) : Failed to get src cube surface facetype %d, level %d\n", This, faceType, i);
5430 } else {
5431 TRACE("Got desrSurface %p\n", destSurface);
5432 }
5433 hr = IWineD3DDevice_UpdateSurface(iface, srcSurface, NULL, destSurface, NULL);
5434 IWineD3DSurface_Release(srcSurface);
5435 IWineD3DSurface_Release(destSurface);
5436 if (WINED3D_OK != hr) {
5437 WARN("(%p) : Call to update surface failed\n", This);
5438 return hr;
5439 }
5440 }
5441 }
5442 }
5443 break;
5444
5445 case WINED3DRTYPE_VOLUMETEXTURE:
5446 {
5447 IWineD3DVolume *srcVolume = NULL;
5448 IWineD3DVolume *destVolume = NULL;
5449
5450 for (i = 0 ; i < levels ; ++i) {
5451 IWineD3DVolumeTexture_GetVolumeLevel((IWineD3DVolumeTexture *)pSourceTexture, i, &srcVolume);
5452 IWineD3DVolumeTexture_GetVolumeLevel((IWineD3DVolumeTexture *)pDestinationTexture, i, &destVolume);
5453 hr = IWineD3DDeviceImpl_UpdateVolume(iface, srcVolume, destVolume);
5454 IWineD3DVolume_Release(srcVolume);
5455 IWineD3DVolume_Release(destVolume);
5456 if (WINED3D_OK != hr) {
5457 WARN("(%p) : Call to update volume failed\n", This);
5458 return hr;
5459 }
5460 }
5461 }
5462 break;
5463
5464 default:
5465 FIXME("(%p) : Unsupported source and destination type\n", This);
5466 hr = WINED3DERR_INVALIDCALL;
5467 }
5468 }
5469
5470 return hr;
5471 }
5472
5473 static HRESULT WINAPI IWineD3DDeviceImpl_GetFrontBufferData(IWineD3DDevice *iface,UINT iSwapChain, IWineD3DSurface *pDestSurface) {
5474 IWineD3DSwapChain *swapChain;
5475 HRESULT hr;
5476 hr = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapChain);
5477 if(hr == WINED3D_OK) {
5478 hr = IWineD3DSwapChain_GetFrontBufferData(swapChain, pDestSurface);
5479 IWineD3DSwapChain_Release(swapChain);
5480 }
5481 return hr;
5482 }
5483
5484 static HRESULT WINAPI IWineD3DDeviceImpl_ValidateDevice(IWineD3DDevice *iface, DWORD* pNumPasses) {
5485 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5486 /* return a sensible default */
5487 *pNumPasses = 1;
5488 /* TODO: If the window is minimized then validate device should return something other than WINED3D_OK */
5489 FIXME("(%p) : stub\n", This);
5490 return WINED3D_OK;
5491 }
5492
5493 static void dirtify_p8_texture_samplers(IWineD3DDeviceImpl *device)
5494 {
5495 int i;
5496
5497 for (i = 0; i < MAX_COMBINED_SAMPLERS; i++) {
5498 IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl*)device->stateBlock->textures[i];
5499 if (texture && (texture->resource.format == WINED3DFMT_P8 || texture->resource.format == WINED3DFMT_A8P8)) {
5500 IWineD3DDeviceImpl_MarkStateDirty(device, STATE_SAMPLER(i));
5501 }
5502 }
5503 }
5504
5505 static HRESULT WINAPI IWineD3DDeviceImpl_SetPaletteEntries(IWineD3DDevice *iface, UINT PaletteNumber, CONST PALETTEENTRY* pEntries) {
5506 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5507 int j;
5508 UINT NewSize;
5509 PALETTEENTRY **palettes;
5510
5511 TRACE("(%p) : PaletteNumber %u\n", This, PaletteNumber);
5512
5513 if (PaletteNumber >= MAX_PALETTES) {
5514 ERR("(%p) : (%u) Out of range 0-%u, returning Invalid Call\n", This, PaletteNumber, MAX_PALETTES);
5515 return WINED3DERR_INVALIDCALL;
5516 }
5517
5518 if (PaletteNumber >= This->NumberOfPalettes) {
5519 NewSize = This->NumberOfPalettes;
5520 do {
5521 NewSize *= 2;
5522 } while(PaletteNumber >= NewSize);
5523 palettes = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->palettes, sizeof(PALETTEENTRY*) * NewSize);
5524 if (!palettes) {
5525 ERR("Out of memory!\n");
5526 return E_OUTOFMEMORY;
5527 }
5528 This->palettes = palettes;
5529 This->NumberOfPalettes = NewSize;
5530 }
5531
5532 if (!This->palettes[PaletteNumber]) {
5533 This->palettes[PaletteNumber] = HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY) * 256);
5534 if (!This->palettes[PaletteNumber]) {
5535 ERR("Out of memory!\n");
5536 return E_OUTOFMEMORY;
5537 }
5538 }
5539
5540 for (j = 0; j < 256; ++j) {
5541 This->palettes[PaletteNumber][j].peRed = pEntries[j].peRed;
5542 This->palettes[PaletteNumber][j].peGreen = pEntries[j].peGreen;
5543 This->palettes[PaletteNumber][j].peBlue = pEntries[j].peBlue;
5544 This->palettes[PaletteNumber][j].peFlags = pEntries[j].peFlags;
5545 }
5546 if (PaletteNumber == This->currentPalette) dirtify_p8_texture_samplers(This);
5547 TRACE("(%p) : returning\n", This);
5548 return WINED3D_OK;
5549 }
5550
5551 static HRESULT WINAPI IWineD3DDeviceImpl_GetPaletteEntries(IWineD3DDevice *iface, UINT PaletteNumber, PALETTEENTRY* pEntries) {
5552 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5553 int j;
5554 TRACE("(%p) : PaletteNumber %u\n", This, PaletteNumber);
5555 if (PaletteNumber >= This->NumberOfPalettes || !This->palettes[PaletteNumber]) {
5556 /* What happens in such situation isn't documented; Native seems to silently abort
5557 on such conditions. Return Invalid Call. */
5558 ERR("(%p) : (%u) Non-existent palette. NumberOfPalettes %u\n", This, PaletteNumber, This->NumberOfPalettes);
5559 return WINED3DERR_INVALIDCALL;
5560 }
5561 for (j = 0; j < 256; ++j) {
5562 pEntries[j].peRed = This->palettes[PaletteNumber][j].peRed;
5563 pEntries[j].peGreen = This->palettes[PaletteNumber][j].peGreen;
5564 pEntries[j].peBlue = This->palettes[PaletteNumber][j].peBlue;
5565 pEntries[j].peFlags = This->palettes[PaletteNumber][j].peFlags;
5566 }
5567 TRACE("(%p) : returning\n", This);
5568 return WINED3D_OK;
5569 }
5570
5571 static HRESULT WINAPI IWineD3DDeviceImpl_SetCurrentTexturePalette(IWineD3DDevice *iface, UINT PaletteNumber) {
5572 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5573 TRACE("(%p) : PaletteNumber %u\n", This, PaletteNumber);
5574 /* Native appears to silently abort on attempt to make an uninitialized palette current and render.
5575 (tested with reference rasterizer). Return Invalid Call. */
5576 if (PaletteNumber >= This->NumberOfPalettes || !This->palettes[PaletteNumber]) {
5577 ERR("(%p) : (%u) Non-existent palette. NumberOfPalettes %u\n", This, PaletteNumber, This->NumberOfPalettes);
5578 return WINED3DERR_INVALIDCALL;
5579 }
5580 /*TODO: stateblocks */
5581 if (This->currentPalette != PaletteNumber) {
5582 This->currentPalette = PaletteNumber;
5583 dirtify_p8_texture_samplers(This);
5584 }
5585 TRACE("(%p) : returning\n", This);
5586 return WINED3D_OK;
5587 }
5588
5589 static HRESULT WINAPI IWineD3DDeviceImpl_GetCurrentTexturePalette(IWineD3DDevice *iface, UINT* PaletteNumber) {
5590 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5591 if (PaletteNumber == NULL) {
5592 WARN("(%p) : returning Invalid Call\n", This);
5593 return WINED3DERR_INVALIDCALL;
5594 }
5595 /*TODO: stateblocks */
5596 *PaletteNumber = This->currentPalette;
5597 TRACE("(%p) : returning %u\n", This, *PaletteNumber);
5598 return WINED3D_OK;
5599 }
5600
5601 static HRESULT WINAPI IWineD3DDeviceImpl_SetSoftwareVertexProcessing(IWineD3DDevice *iface, BOOL bSoftware) {
5602 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5603 static BOOL showFixmes = TRUE;
5604 if (showFixmes) {
5605 FIXME("(%p) : stub\n", This);
5606 showFixmes = FALSE;
5607 }
5608
5609 This->softwareVertexProcessing = bSoftware;
5610 return WINED3D_OK;
5611 }
5612
5613
5614 static BOOL WINAPI IWineD3DDeviceImpl_GetSoftwareVertexProcessing(IWineD3DDevice *iface) {
5615 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5616 static BOOL showFixmes = TRUE;
5617 if (showFixmes) {
5618 FIXME("(%p) : stub\n", This);
5619 showFixmes = FALSE;
5620 }
5621 return This->softwareVertexProcessing;
5622 }
5623
5624
5625 static HRESULT WINAPI IWineD3DDeviceImpl_GetRasterStatus(IWineD3DDevice *iface, UINT iSwapChain, WINED3DRASTER_STATUS* pRasterStatus) {
5626 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5627 IWineD3DSwapChain *swapChain;
5628 HRESULT hr;
5629
5630 TRACE("(%p) : SwapChain %d returning %p\n", This, iSwapChain, pRasterStatus);
5631
5632 hr = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapChain);
5633 if(hr == WINED3D_OK){
5634 hr = IWineD3DSwapChain_GetRasterStatus(swapChain, pRasterStatus);
5635 IWineD3DSwapChain_Release(swapChain);
5636 }else{
5637 FIXME("(%p) IWineD3DSwapChain_GetRasterStatus returned in error\n", This);
5638 }
5639 return hr;
5640 }
5641
5642
5643 static HRESULT WINAPI IWineD3DDeviceImpl_SetNPatchMode(IWineD3DDevice *iface, float nSegments) {
5644 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5645 static BOOL showfixmes = TRUE;
5646 if(nSegments != 0.0f) {
5647 if( showfixmes) {
5648 FIXME("(%p) : stub nSegments(%f)\n", This, nSegments);
5649 showfixmes = FALSE;
5650 }
5651 }
5652 return WINED3D_OK;
5653 }
5654
5655 static float WINAPI IWineD3DDeviceImpl_GetNPatchMode(IWineD3DDevice *iface) {
5656 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5657 static BOOL showfixmes = TRUE;
5658 if( showfixmes) {
5659 FIXME("(%p) : stub returning(%f)\n", This, 0.0f);
5660 showfixmes = FALSE;
5661 }
5662 return 0.0f;
5663 }
5664
5665 static HRESULT WINAPI IWineD3DDeviceImpl_UpdateSurface(IWineD3DDevice *iface, IWineD3DSurface *pSourceSurface, CONST RECT* pSourceRect, IWineD3DSurface *pDestinationSurface, CONST POINT* pDestPoint) {
5666 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
5667 /** TODO: remove casts to IWineD3DSurfaceImpl
5668 * NOTE: move code to surface to accomplish this
5669 ****************************************/
5670 IWineD3DSurfaceImpl *pSrcSurface = (IWineD3DSurfaceImpl *)pSourceSurface;
5671 int srcWidth, srcHeight;
5672 unsigned int srcSurfaceWidth, srcSurfaceHeight, destSurfaceWidth, destSurfaceHeight;
5673 WINED3DFORMAT destFormat, srcFormat;
5674 UINT destSize;
5675 int srcLeft, destLeft, destTop;
5676 WINED3DPOOL srcPool, destPool;
5677 int offset = 0;
5678 int rowoffset = 0; /* how many bytes to add onto the end of a row to wraparound to the beginning of the next */
5679 glDescriptor *glDescription = NULL;
5680 GLenum dummy;
5681 int bpp;
5682 CONVERT_TYPES convert = NO_CONVERSION;
5683
5684 WINED3DSURFACE_DESC winedesc;
5685
5686 TRACE("(%p) : Source (%p) Rect (%p) Destination (%p) Point(%p)\n", This, pSourceSurface, pSourceRect, pDestinationSurface, pDestPoint);
5687 memset(&winedesc, 0, sizeof(winedesc));
5688 winedesc.Width = &srcSurfaceWidth;
5689 winedesc.Height = &srcSurfaceHeight;
5690 winedesc.Pool = &srcPool;
5691 winedesc.Format = &srcFormat;
5692
5693 IWineD3DSurface_GetDesc(pSourceSurface, &winedesc);
5694
5695 winedesc.Width = &destSurfaceWidth;
5696 winedesc.Height = &destSurfaceHeight;
5697 winedesc.Pool = &destPool;
5698 winedesc.Format = &destFormat;
5699 winedesc.Size = &destSize;
5700
5701 IWineD3DSurface_GetDesc(pDestinationSurface, &winedesc);
5702
5703 if(srcPool != WINED3DPOOL_SYSTEMMEM || destPool != WINED3DPOOL_DEFAULT){
5704 WARN("source %p must be SYSTEMMEM and dest %p must be DEFAULT, returning WINED3DERR_INVALIDCALL\n", pSourceSurface, pDestinationSurface);
5705 return WINED3DERR_INVALIDCALL;
5706 }
5707
5708 /* This call loads the opengl surface directly, instead of copying the surface to the
5709 * destination's sysmem copy. If surface conversion is needed, use BltFast instead to
5710 * copy in sysmem and use regular surface loading.
5711 */
5712 d3dfmt_get_conv((IWineD3DSurfaceImpl *) pDestinationSurface, FALSE, TRUE,
5713 &dummy, &dummy, &dummy, &convert, &bpp, FALSE);
5714 if(convert != NO_CONVERSION) {
5715 return IWineD3DSurface_BltFast(pDestinationSurface,
5716 pDestPoint ? pDestPoint->x : 0,
5717 pDestPoint ? pDestPoint->y : 0,
5718 pSourceSurface, (RECT *) pSourceRect, 0);
5719 }
5720
5721 if (destFormat == WINED3DFMT_UNKNOWN) {
5722 TRACE("(%p) : Converting destination surface from WINED3DFMT_UNKNOWN to the source format\n", This);
5723 IWineD3DSurface_SetFormat(pDestinationSurface, srcFormat);
5724
5725 /* Get the update surface description */
5726 IWineD3DSurface_GetDesc(pDestinationSurface, &winedesc);
5727 }
5728
5729 ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
5730
5731 ENTER_GL();
5732
5733 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
5734 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB));
5735 checkGLcall("glActiveTextureARB");
5736 }
5737
5738 /* Make sure the surface is loaded and up to date */
5739 IWineD3DSurface_PreLoad(pDestinationSurface);
5740
5741 IWineD3DSurface_GetGlDesc(pDestinationSurface, &glDescription);
5742
5743 /* this needs to be done in lines if the sourceRect != the sourceWidth */
5744 srcWidth = pSourceRect ? pSourceRect->right - pSourceRect->left : srcSurfaceWidth;
5745 srcHeight = pSourceRect ? pSourceRect->bottom - pSourceRect->top : srcSurfaceHeight;
5746 srcLeft = pSourceRect ? pSourceRect->left : 0;
5747 destLeft = pDestPoint ? pDestPoint->x : 0;
5748 destTop = pDestPoint ? pDestPoint->y : 0;
5749
5750
5751 /* This function doesn't support compressed textures
5752 the pitch is just bytesPerPixel * width */
5753 if(srcWidth != srcSurfaceWidth || srcLeft ){
5754 rowoffset = srcSurfaceWidth * pSrcSurface->bytesPerPixel;
5755 offset += srcLeft * pSrcSurface->bytesPerPixel;
5756 /* TODO: do we ever get 3bpp?, would a shift and an add be quicker than a mul (well maybe a cycle or two) */
5757 }
5758 /* TODO DXT formats */
5759
5760 if(pSourceRect != NULL && pSourceRect->top != 0){
5761 offset += pSourceRect->top * srcSurfaceWidth * pSrcSurface->bytesPerPixel;
5762 }
5763 TRACE("(%p) glTexSubImage2D, Level %d, left %d, top %d, width %d, height %d , ftm %d, type %d, memory %p\n"
5764 ,This
5765 ,glDescription->level
5766 ,destLeft
5767 ,destTop
5768 ,srcWidth
5769 ,srcHeight
5770 ,glDescription->glFormat
5771 ,glDescription->glType
5772 ,IWineD3DSurface_GetData(pSourceSurface)
5773 );
5774
5775 /* Sanity check */
5776 if (IWineD3DSurface_GetData(pSourceSurface) == NULL) {
5777
5778 /* need to lock the surface to get the data */
5779 FIXME("Surfaces has no allocated memory, but should be an in memory only surface\n");
5780 }
5781
5782 /* TODO: Cube and volume support */
5783 if(rowoffset != 0){
5784 /* not a whole row so we have to do it a line at a time */
5785 int j;
5786
5787 /* hopefully using pointer addition will be quicker than using a point + j * rowoffset */
5788 const unsigned char* data =((const unsigned char *)IWineD3DSurface_GetData(pSourceSurface)) + offset;
5789
5790 for(j = destTop ; j < (srcHeight + destTop) ; j++){
5791
5792 glTexSubImage2D(glDescription->target
5793 ,glDescription->level
5794 ,destLeft
5795 ,j
5796 ,srcWidth
5797 ,1
5798 ,glDescription->glFormat
5799 ,glDescription->glType
5800 ,data /* could be quicker using */
5801 );
5802 data += rowoffset;
5803 }
5804
5805 } else { /* Full width, so just write out the whole texture */
5806
5807 if (WINED3DFMT_DXT1 == destFormat ||
5808 WINED3DFMT_DXT2 == destFormat ||
5809 WINED3DFMT_DXT3 == destFormat ||
5810 WINED3DFMT_DXT4 == destFormat ||
5811 WINED3DFMT_DXT5 == destFormat) {
5812 if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) {
5813 if (destSurfaceHeight != srcHeight || destSurfaceWidth != srcWidth) {
5814 /* FIXME: The easy way to do this is to lock the destination, and copy the bits across */
5815 FIXME("Updating part of a compressed texture is not supported at the moment\n");
5816 } if (destFormat != srcFormat) {
5817 FIXME("Updating mixed format compressed texture is not curretly support\n");
5818 } else {
5819 GL_EXTCALL(glCompressedTexImage2DARB)(glDescription->target,
5820 glDescription->level,
5821 glDescription->glFormatInternal,
5822 srcWidth,
5823 srcHeight,
5824 0,
5825 destSize,
5826 IWineD3DSurface_GetData(pSourceSurface));
5827 }
5828 } else {
5829 FIXME("Attempting to update a DXT compressed texture without hardware support\n");
5830 }
5831
5832
5833 } else {
5834 glTexSubImage2D(glDescription->target
5835 ,glDescription->level
5836 ,destLeft
5837 ,destTop
5838 ,srcWidth
5839 ,srcHeight
5840 ,glDescription->glFormat
5841 ,glDescription->glType
5842 ,IWineD3DSurface_GetData(pSourceSurface)
5843 );
5844 }
5845 }
5846 checkGLcall("glTexSubImage2D");
5847
5848 LEAVE_GL();
5849
5850 IWineD3DSurface_ModifyLocation(pDestinationSurface, SFLAG_INTEXTURE, TRUE);
5851 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(0));
5852
5853 return WINED3D_OK;
5854 }
5855
5856 static HRESULT WINAPI IWineD3DDeviceImpl_DrawRectPatch(IWineD3DDevice *iface, UINT Handle, CONST float* pNumSegs, CONST WINED3DRECTPATCH_INFO* pRectPatchInfo) {
5857 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5858 struct WineD3DRectPatch *patch;
5859 unsigned int i;
5860 struct list *e;
5861 BOOL found;
5862 TRACE("(%p) Handle(%d) noSegs(%p) rectpatch(%p)\n", This, Handle, pNumSegs, pRectPatchInfo);
5863
5864 if(!(Handle || pRectPatchInfo)) {
5865 /* TODO: Write a test for the return value, thus the FIXME */
5866 FIXME("Both Handle and pRectPatchInfo are NULL\n");
5867 return WINED3DERR_INVALIDCALL;
5868 }
5869
5870 if(Handle) {
5871 i = PATCHMAP_HASHFUNC(Handle);
5872 found = FALSE;
5873 LIST_FOR_EACH(e, &This->patches[i]) {
5874 patch = LIST_ENTRY(e, struct WineD3DRectPatch, entry);
5875 if(patch->Handle == Handle) {
5876 found = TRUE;
5877 break;
5878 }
5879 }
5880
5881 if(!found) {
5882 TRACE("Patch does not exist. Creating a new one\n");
5883 patch = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*patch));
5884 patch->Handle = Handle;
5885 list_add_head(&This->patches[i], &patch->entry);
5886 } else {
5887 TRACE("Found existing patch %p\n", patch);
5888 }
5889 } else {
5890 /* Since opengl does not load tesselated vertex attributes into numbered vertex
5891 * attributes we have to tesselate, read back, and draw. This needs a patch
5892 * management structure instance. Create one.
5893 *
5894 * A possible improvement is to check if a vertex shader is used, and if not directly
5895 * draw the patch.
5896 */
5897 FIXME("Drawing an uncached patch. This is slow\n");
5898 patch = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*patch));
5899 }
5900
5901 if(pNumSegs[0] != patch->numSegs[0] || pNumSegs[1] != patch->numSegs[1] ||
5902 pNumSegs[2] != patch->numSegs[2] || pNumSegs[3] != patch->numSegs[3] ||
5903 (pRectPatchInfo && memcmp(pRectPatchInfo, &patch->RectPatchInfo, sizeof(*pRectPatchInfo)) != 0) ) {
5904 HRESULT hr;
5905 TRACE("Tesselation density or patch info changed, retesselating\n");
5906
5907 if(pRectPatchInfo) {
5908 patch->RectPatchInfo = *pRectPatchInfo;
5909 }
5910 patch->numSegs[0] = pNumSegs[0];
5911 patch->numSegs[1] = pNumSegs[1];
5912 patch->numSegs[2] = pNumSegs[2];
5913 patch->numSegs[3] = pNumSegs[3];
5914
5915 hr = tesselate_rectpatch(This, patch);
5916 if(FAILED(hr)) {
5917 WARN("Patch tesselation failed\n");
5918
5919 /* Do not release the handle to store the params of the patch */
5920 if(!Handle) {
5921 HeapFree(GetProcessHeap(), 0, patch);
5922 }
5923 return hr;
5924 }
5925 }
5926
5927 This->currentPatch = patch;
5928 IWineD3DDevice_DrawPrimitiveStrided(iface, WINED3DPT_TRIANGLELIST, patch->numSegs[0] * patch->numSegs[1] * 2, &patch->strided);
5929 This->currentPatch = NULL;
5930
5931 /* Destroy uncached patches */
5932 if(!Handle) {
5933 HeapFree(GetProcessHeap(), 0, patch->mem);
5934 HeapFree(GetProcessHeap(), 0, patch);
5935 }
5936 return WINED3D_OK;
5937 }
5938
5939 static HRESULT WINAPI IWineD3DDeviceImpl_DrawTriPatch(IWineD3DDevice *iface, UINT Handle, CONST float* pNumSegs, CONST WINED3DTRIPATCH_INFO* pTriPatchInfo) {
5940 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5941 TRACE("(%p) Handle(%d) noSegs(%p) tripatch(%p)\n", This, Handle, pNumSegs, pTriPatchInfo);
5942 FIXME("(%p) : Stub\n", This);
5943 return WINED3D_OK;
5944 }
5945
5946 static HRESULT WINAPI IWineD3DDeviceImpl_DeletePatch(IWineD3DDevice *iface, UINT Handle) {
5947 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5948 int i;
5949 struct WineD3DRectPatch *patch;
5950 struct list *e;
5951 TRACE("(%p) Handle(%d)\n", This, Handle);
5952
5953 i = PATCHMAP_HASHFUNC(Handle);
5954 LIST_FOR_EACH(e, &This->patches[i]) {
5955 patch = LIST_ENTRY(e, struct WineD3DRectPatch, entry);
5956 if(patch->Handle == Handle) {
5957 TRACE("Deleting patch %p\n", patch);
5958 list_remove(&patch->entry);
5959 HeapFree(GetProcessHeap(), 0, patch->mem);
5960 HeapFree(GetProcessHeap(), 0, patch);
5961 return WINED3D_OK;
5962 }
5963 }
5964
5965 /* TODO: Write a test for the return value */
5966 FIXME("Attempt to destroy nonexistent patch\n");
5967 return WINED3DERR_INVALIDCALL;
5968 }
5969
5970 static IWineD3DSwapChain *get_swapchain(IWineD3DSurface *target) {
5971 HRESULT hr;
5972 IWineD3DSwapChain *swapchain;
5973
5974 hr = IWineD3DSurface_GetContainer(target, &IID_IWineD3DSwapChain, (void **)&swapchain);
5975 if (SUCCEEDED(hr)) {
5976 IWineD3DSwapChain_Release((IUnknown *)swapchain);
5977 return swapchain;
5978 }
5979
5980 return NULL;
5981 }
5982
5983 static void bind_fbo(IWineD3DDevice *iface, GLenum target, GLuint *fbo) {
5984 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5985
5986 if (!*fbo) {
5987 GL_EXTCALL(glGenFramebuffersEXT(1, fbo));
5988 checkGLcall("glGenFramebuffersEXT()");
5989 }
5990 GL_EXTCALL(glBindFramebufferEXT(target, *fbo));
5991 checkGLcall("glBindFramebuffer()");
5992 }
5993
5994 static void attach_surface_fbo(IWineD3DDeviceImpl *This, GLenum fbo_target, DWORD idx, IWineD3DSurface *surface) {
5995 const IWineD3DSurfaceImpl *surface_impl = (IWineD3DSurfaceImpl *)surface;
5996 IWineD3DBaseTextureImpl *texture_impl;
5997 GLenum texttarget, target;
5998 GLint old_binding;
5999
6000 texttarget = surface_impl->glDescription.target;
6001 if(texttarget == GL_TEXTURE_2D) {
6002 target = GL_TEXTURE_2D;
6003 glGetIntegerv(GL_TEXTURE_BINDING_2D, &old_binding);
6004 } else if(texttarget == GL_TEXTURE_RECTANGLE_ARB) {
6005 target = GL_TEXTURE_RECTANGLE_ARB;
6006 glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB, &old_binding);
6007 } else {
6008 target = GL_TEXTURE_CUBE_MAP_ARB;
6009 glGetIntegerv(GL_TEXTURE_BINDING_CUBE_MAP_ARB, &old_binding);
6010 }
6011
6012 IWineD3DSurface_PreLoad(surface);
6013
6014 glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
6015 glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
6016 glBindTexture(target, old_binding);
6017
6018 /* Update base texture states array */
6019 if (SUCCEEDED(IWineD3DSurface_GetContainer(surface, &IID_IWineD3DBaseTexture, (void **)&texture_impl))) {
6020 texture_impl->baseTexture.states[WINED3DTEXSTA_MINFILTER] = WINED3DTEXF_POINT;
6021 texture_impl->baseTexture.states[WINED3DTEXSTA_MAGFILTER] = WINED3DTEXF_POINT;
6022 if (texture_impl->baseTexture.bindCount) {
6023 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(texture_impl->baseTexture.sampler));
6024 }
6025
6026 IWineD3DBaseTexture_Release((IWineD3DBaseTexture *)texture_impl);
6027 }
6028
6029 GL_EXTCALL(glFramebufferTexture2DEXT(fbo_target, GL_COLOR_ATTACHMENT0_EXT + idx, texttarget,
6030 surface_impl->glDescription.textureName, surface_impl->glDescription.level));
6031
6032 checkGLcall("attach_surface_fbo");
6033 }
6034
6035 static void color_fill_fbo(IWineD3DDevice *iface, IWineD3DSurface *surface, CONST WINED3DRECT *rect, WINED3DCOLOR color) {
6036 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6037 IWineD3DSwapChain *swapchain;
6038
6039 swapchain = get_swapchain(surface);
6040 if (swapchain) {
6041 GLenum buffer;
6042
6043 TRACE("Surface %p is onscreen\n", surface);
6044
6045 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
6046 buffer = surface_get_gl_buffer(surface, swapchain);
6047 glDrawBuffer(buffer);
6048 checkGLcall("glDrawBuffer()");
6049 } else {
6050 TRACE("Surface %p is offscreen\n", surface);
6051 bind_fbo(iface, GL_FRAMEBUFFER_EXT, &This->dst_fbo);
6052 attach_surface_fbo(This, GL_FRAMEBUFFER_EXT, 0, surface);
6053 }
6054
6055 if (rect) {
6056 glEnable(GL_SCISSOR_TEST);
6057 if(!swapchain) {
6058 glScissor(rect->x1, rect->y1, rect->x2 - rect->x1, rect->y2 - rect->y1);
6059 } else {
6060 glScissor(rect->x1, ((IWineD3DSurfaceImpl *)surface)->currentDesc.Height - rect->y2,
6061 rect->x2 - rect->x1, rect->y2 - rect->y1);
6062 }
6063 checkGLcall("glScissor");
6064 } else {
6065 glDisable(GL_SCISSOR_TEST);
6066 }
6067 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE));
6068
6069 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
6070 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE));
6071
6072 glClearColor(D3DCOLOR_R(color), D3DCOLOR_G(color), D3DCOLOR_B(color), D3DCOLOR_A(color));
6073 glClear(GL_COLOR_BUFFER_BIT);
6074 checkGLcall("glClear");
6075
6076 if (This->render_offscreen) {
6077 bind_fbo(iface, GL_FRAMEBUFFER_EXT, &This->fbo);
6078 } else {
6079 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
6080 checkGLcall("glBindFramebuffer()");
6081 }
6082
6083 if (swapchain && surface == ((IWineD3DSwapChainImpl *)swapchain)->frontBuffer
6084 && ((IWineD3DSwapChainImpl *)swapchain)->backBuffer) {
6085 glDrawBuffer(GL_BACK);
6086 checkGLcall("glDrawBuffer()");
6087 }
6088 }
6089
6090 static inline DWORD argb_to_fmt(DWORD color, WINED3DFORMAT destfmt) {
6091 unsigned int r, g, b, a;
6092 DWORD ret;
6093
6094 if(destfmt == WINED3DFMT_A8R8G8B8 || destfmt == WINED3DFMT_X8R8G8B8 ||
6095 destfmt == WINED3DFMT_R8G8B8)
6096 return color;
6097
6098 TRACE("Converting color %08x to format %s\n", color, debug_d3dformat(destfmt));
6099
6100 a = (color & 0xff000000) >> 24;
6101 r = (color & 0x00ff0000) >> 16;
6102 g = (color & 0x0000ff00) >> 8;
6103 b = (color & 0x000000ff) >> 0;
6104
6105 switch(destfmt)
6106 {
6107 case WINED3DFMT_R5G6B5:
6108 if(r == 0xff && g == 0xff && b == 0xff) return 0xffff;
6109 r = (r * 32) / 256;
6110 g = (g * 64) / 256;
6111 b = (b * 32) / 256;
6112 ret = r << 11;
6113 ret |= g << 5;
6114 ret |= b;
6115 TRACE("Returning %08x\n", ret);
6116 return ret;
6117
6118 case WINED3DFMT_X1R5G5B5:
6119 case WINED3DFMT_A1R5G5B5:
6120 a = (a * 2) / 256;
6121 r = (r * 32) / 256;
6122 g = (g * 32) / 256;
6123 b = (b * 32) / 256;
6124 ret = a << 15;
6125 ret |= r << 10;
6126 ret |= g << 5;
6127 ret |= b << 0;
6128 TRACE("Returning %08x\n", ret);
6129 return ret;
6130
6131 case WINED3DFMT_A8:
6132 TRACE("Returning %08x\n", a);
6133 return a;
6134
6135 case WINED3DFMT_X4R4G4B4:
6136 case WINED3DFMT_A4R4G4B4:
6137 a = (a * 16) / 256;
6138 r = (r * 16) / 256;
6139 g = (g * 16) / 256;
6140 b = (b * 16) / 256;
6141 ret = a << 12;
6142 ret |= r << 8;
6143 ret |= g << 4;
6144 ret |= b << 0;
6145 TRACE("Returning %08x\n", ret);
6146 return ret;
6147
6148 case WINED3DFMT_R3G3B2:
6149 r = (r * 8) / 256;
6150 g = (g * 8) / 256;
6151 b = (b * 4) / 256;
6152 ret = r << 5;
6153 ret |= g << 2;
6154 ret |= b << 0;
6155 TRACE("Returning %08x\n", ret);
6156 return ret;
6157
6158 case WINED3DFMT_X8B8G8R8:
6159 case WINED3DFMT_A8B8G8R8:
6160 ret = a << 24;
6161 ret |= b << 16;
6162 ret |= g << 8;
6163 ret |= r << 0;
6164 TRACE("Returning %08x\n", ret);
6165 return ret;
6166
6167 case WINED3DFMT_A2R10G10B10:
6168 a = (a * 4) / 256;
6169 r = (r * 1024) / 256;
6170 g = (g * 1024) / 256;
6171 b = (b * 1024) / 256;
6172 ret = a << 30;
6173 ret |= r << 20;
6174 ret |= g << 10;
6175 ret |= b << 0;
6176 TRACE("Returning %08x\n", ret);
6177 return ret;
6178
6179 case WINED3DFMT_A2B10G10R10:
6180 a = (a * 4) / 256;
6181 r = (r * 1024) / 256;
6182 g = (g * 1024) / 256;
6183 b = (b * 1024) / 256;
6184 ret = a << 30;
6185 ret |= b << 20;
6186 ret |= g << 10;
6187 ret |= r << 0;
6188 TRACE("Returning %08x\n", ret);
6189 return ret;
6190
6191 default:
6192 FIXME("Add a COLORFILL conversion for format %s\n", debug_d3dformat(destfmt));
6193 return 0;
6194 }
6195 }
6196
6197 static HRESULT WINAPI IWineD3DDeviceImpl_ColorFill(IWineD3DDevice *iface, IWineD3DSurface *pSurface, CONST WINED3DRECT* pRect, WINED3DCOLOR color) {
6198 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6199 IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *) pSurface;
6200 WINEDDBLTFX BltFx;
6201 TRACE("(%p) Colour fill Surface: %p rect: %p color: 0x%08x\n", This, pSurface, pRect, color);
6202
6203 if (surface->resource.pool != WINED3DPOOL_DEFAULT && surface->resource.pool != WINED3DPOOL_SYSTEMMEM) {
6204 FIXME("call to colorfill with non WINED3DPOOL_DEFAULT or WINED3DPOOL_SYSTEMMEM surface\n");
6205 return WINED3DERR_INVALIDCALL;
6206 }
6207
6208 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) {
6209 color_fill_fbo(iface, pSurface, pRect, color);
6210 return WINED3D_OK;
6211 } else {
6212 /* Just forward this to the DirectDraw blitting engine */
6213 memset(&BltFx, 0, sizeof(BltFx));
6214 BltFx.dwSize = sizeof(BltFx);
6215 BltFx.u5.dwFillColor = argb_to_fmt(color, surface->resource.format);
6216 return IWineD3DSurface_Blt(pSurface, (RECT *) pRect, NULL, NULL, WINEDDBLT_COLORFILL, &BltFx, WINED3DTEXF_NONE);
6217 }
6218 }
6219
6220 /* rendertarget and depth stencil functions */
6221 static HRESULT WINAPI IWineD3DDeviceImpl_GetRenderTarget(IWineD3DDevice* iface,DWORD RenderTargetIndex, IWineD3DSurface **ppRenderTarget) {
6222 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6223
6224 if (RenderTargetIndex >= GL_LIMITS(buffers)) {
6225 ERR("(%p) : Only %d render targets are supported.\n", This, GL_LIMITS(buffers));
6226 return WINED3DERR_INVALIDCALL;
6227 }
6228
6229 *ppRenderTarget = This->render_targets[RenderTargetIndex];
6230 TRACE("(%p) : RenderTarget %d Index returning %p\n", This, RenderTargetIndex, *ppRenderTarget);
6231 /* Note inc ref on returned surface */
6232 if(*ppRenderTarget != NULL)
6233 IWineD3DSurface_AddRef(*ppRenderTarget);
6234 return WINED3D_OK;
6235 }
6236
6237 static HRESULT WINAPI IWineD3DDeviceImpl_SetFrontBackBuffers(IWineD3DDevice *iface, IWineD3DSurface *Front, IWineD3DSurface *Back) {
6238 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6239 IWineD3DSurfaceImpl *FrontImpl = (IWineD3DSurfaceImpl *) Front;
6240 IWineD3DSurfaceImpl *BackImpl = (IWineD3DSurfaceImpl *) Back;
6241 IWineD3DSwapChainImpl *Swapchain;
6242 HRESULT hr;
6243
6244 TRACE("(%p)->(%p,%p)\n", This, FrontImpl, BackImpl);
6245
6246 hr = IWineD3DDevice_GetSwapChain(iface, 0, (IWineD3DSwapChain **) &Swapchain);
6247 if(hr != WINED3D_OK) {
6248 ERR("Can't get the swapchain\n");
6249 return hr;
6250 }
6251
6252 /* Make sure to release the swapchain */
6253 IWineD3DSwapChain_Release((IWineD3DSwapChain *) Swapchain);
6254
6255 if(FrontImpl && !(FrontImpl->resource.usage & WINED3DUSAGE_RENDERTARGET) ) {
6256 ERR("Trying to set a front buffer which doesn't have WINED3DUSAGE_RENDERTARGET usage\n");
6257 return WINED3DERR_INVALIDCALL;
6258 }
6259 else if(BackImpl && !(BackImpl->resource.usage & WINED3DUSAGE_RENDERTARGET)) {
6260 ERR("Trying to set a back buffer which doesn't have WINED3DUSAGE_RENDERTARGET usage\n");
6261 return WINED3DERR_INVALIDCALL;
6262 }
6263
6264 if(Swapchain->frontBuffer != Front) {
6265 TRACE("Changing the front buffer from %p to %p\n", Swapchain->frontBuffer, Front);
6266
6267 if(Swapchain->frontBuffer)
6268 IWineD3DSurface_SetContainer(Swapchain->frontBuffer, NULL);
6269 Swapchain->frontBuffer = Front;
6270
6271 if(Swapchain->frontBuffer) {
6272 IWineD3DSurface_SetContainer(Swapchain->frontBuffer, (IWineD3DBase *) Swapchain);
6273 }
6274 }
6275
6276 if(Back && !Swapchain->backBuffer) {
6277 /* We need memory for the back buffer array - only one back buffer this way */
6278 Swapchain->backBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DSurface *));
6279 if(!Swapchain->backBuffer) {
6280 ERR("Out of memory\n");
6281 return E_OUTOFMEMORY;
6282 }
6283 }
6284
6285 if(Swapchain->backBuffer[0] != Back) {
6286 TRACE("Changing the back buffer from %p to %p\n", Swapchain->backBuffer, Back);
6287
6288 /* What to do about the context here in the case of multithreading? Not sure.
6289 * This function is called by IDirect3D7::CreateDevice so in theory its initialization code
6290 */
6291 ENTER_GL();
6292 if(!Swapchain->backBuffer[0]) {
6293 /* GL was told to draw to the front buffer at creation,
6294 * undo that
6295 */
6296 glDrawBuffer(GL_BACK);
6297 checkGLcall("glDrawBuffer(GL_BACK)");
6298 /* Set the backbuffer count to 1 because other code uses it to fing the back buffers */
6299 Swapchain->presentParms.BackBufferCount = 1;
6300 } else if (!Back) {
6301 /* That makes problems - disable for now */
6302 /* glDrawBuffer(GL_FRONT); */
6303 checkGLcall("glDrawBuffer(GL_FRONT)");
6304 /* We have lost our back buffer, set this to 0 to avoid confusing other code */
6305 Swapchain->presentParms.BackBufferCount = 0;
6306 }
6307 LEAVE_GL();
6308
6309 if(Swapchain->backBuffer[0])
6310 IWineD3DSurface_SetContainer(Swapchain->backBuffer[0], NULL);
6311 Swapchain->backBuffer[0] = Back;
6312
6313 if(Swapchain->backBuffer[0]) {
6314 IWineD3DSurface_SetContainer(Swapchain->backBuffer[0], (IWineD3DBase *) Swapchain);
6315 } else {
6316 HeapFree(GetProcessHeap(), 0, Swapchain->backBuffer);
6317 Swapchain->backBuffer = NULL;
6318 }
6319
6320 }
6321
6322 return WINED3D_OK;
6323 }
6324
6325 static HRESULT WINAPI IWineD3DDeviceImpl_GetDepthStencilSurface(IWineD3DDevice* iface, IWineD3DSurface **ppZStencilSurface) {
6326 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6327 *ppZStencilSurface = This->stencilBufferTarget;
6328 TRACE("(%p) : zStencilSurface returning %p\n", This, *ppZStencilSurface);
6329
6330 if(*ppZStencilSurface != NULL) {
6331 /* Note inc ref on returned surface */
6332 IWineD3DSurface_AddRef(*ppZStencilSurface);
6333 return WINED3D_OK;
6334 } else {
6335 return WINED3DERR_NOTFOUND;
6336 }
6337 }
6338
6339 /* TODO: Handle stencil attachments */
6340 static void set_depth_stencil_fbo(IWineD3DDevice *iface, IWineD3DSurface *depth_stencil) {
6341 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6342 IWineD3DSurfaceImpl *depth_stencil_impl = (IWineD3DSurfaceImpl *)depth_stencil;
6343
6344 TRACE("Set depth stencil to %p\n", depth_stencil);
6345
6346 if (depth_stencil_impl) {
6347 if (depth_stencil_impl->current_renderbuffer) {
6348 GL_EXTCALL(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_stencil_impl->current_renderbuffer->id));
6349 checkGLcall("glFramebufferRenderbufferEXT()");
6350 } else {
6351 IWineD3DBaseTextureImpl *texture_impl;
6352 GLenum texttarget, target;
6353 GLint old_binding = 0;
6354
6355 texttarget = depth_stencil_impl->glDescription.target;
6356 if(texttarget == GL_TEXTURE_2D) {
6357 target = GL_TEXTURE_2D;
6358 glGetIntegerv(GL_TEXTURE_BINDING_2D, &old_binding);
6359 } else if(texttarget == GL_TEXTURE_RECTANGLE_ARB) {
6360 target = GL_TEXTURE_RECTANGLE_ARB;
6361 glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB, &old_binding);
6362 } else {
6363 target = GL_TEXTURE_CUBE_MAP_ARB;
6364 glGetIntegerv(GL_TEXTURE_BINDING_CUBE_MAP_ARB, &old_binding);
6365 }
6366
6367 IWineD3DSurface_PreLoad(depth_stencil);
6368
6369 glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
6370 glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
6371 glTexParameteri(target, GL_DEPTH_TEXTURE_MODE_ARB, GL_LUMINANCE);
6372 glBindTexture(target, old_binding);
6373
6374 /* Update base texture states array */
6375 if (SUCCEEDED(IWineD3DSurface_GetContainer(depth_stencil, &IID_IWineD3DBaseTexture, (void **)&texture_impl))) {
6376 texture_impl->baseTexture.states[WINED3DTEXSTA_MINFILTER] = WINED3DTEXF_POINT;
6377 texture_impl->baseTexture.states[WINED3DTEXSTA_MAGFILTER] = WINED3DTEXF_POINT;
6378 if (texture_impl->baseTexture.bindCount) {
6379 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(texture_impl->baseTexture.sampler));
6380 }
6381
6382 IWineD3DBaseTexture_Release((IWineD3DBaseTexture *)texture_impl);
6383 }
6384
6385 GL_EXTCALL(glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, texttarget,
6386 depth_stencil_impl->glDescription.textureName, depth_stencil_impl->glDescription.level));
6387 checkGLcall("glFramebufferTexture2DEXT()");
6388 }
6389 } else {
6390 GL_EXTCALL(glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, 0, 0));
6391 checkGLcall("glFramebufferTexture2DEXT()");
6392 }
6393 }
6394
6395 static void set_render_target_fbo(IWineD3DDevice *iface, DWORD idx, IWineD3DSurface *render_target) {
6396 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6397 IWineD3DSurfaceImpl *rtimpl = (IWineD3DSurfaceImpl *)render_target;
6398
6399 TRACE("Set render target %u to %p\n", idx, render_target);
6400
6401 if (rtimpl) {
6402 attach_surface_fbo(This, GL_FRAMEBUFFER_EXT, idx, render_target);
6403 This->draw_buffers[idx] = GL_COLOR_ATTACHMENT0_EXT + idx;
6404 } else {
6405 GL_EXTCALL(glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT + idx, GL_TEXTURE_2D, 0, 0));
6406 checkGLcall("glFramebufferTexture2DEXT()");
6407
6408 This->draw_buffers[idx] = GL_NONE;
6409 }
6410 }
6411
6412 static void check_fbo_status(IWineD3DDevice *iface) {
6413 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6414 GLenum status;
6415
6416 status = GL_EXTCALL(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT));
6417 if (status == GL_FRAMEBUFFER_COMPLETE_EXT) {
6418 TRACE("FBO complete\n");
6419 } else {
6420 IWineD3DSurfaceImpl *attachment;
6421 int i;
6422 FIXME("FBO status %s (%#x)\n", debug_fbostatus(status), status);
6423
6424 /* Dump the FBO attachments */
6425 for (i = 0; i < GL_LIMITS(buffers); ++i) {
6426 attachment = (IWineD3DSurfaceImpl *)This->fbo_color_attachments[i];
6427 if (attachment) {
6428 FIXME("\tColor attachment %d: (%p) %s %ux%u\n", i, attachment, debug_d3dformat(attachment->resource.format),
6429 attachment->pow2Width, attachment->pow2Height);
6430 }
6431 }
6432 attachment = (IWineD3DSurfaceImpl *)This->fbo_depth_attachment;
6433 if (attachment) {
6434 FIXME("\tDepth attachment: (%p) %s %ux%u\n", attachment, debug_d3dformat(attachment->resource.format),
6435 attachment->pow2Width, attachment->pow2Height);
6436 }
6437 }
6438 }
6439
6440 static BOOL depth_mismatch_fbo(IWineD3DDevice *iface) {
6441 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6442 IWineD3DSurfaceImpl *rt_impl = (IWineD3DSurfaceImpl *)This->render_targets[0];
6443 IWineD3DSurfaceImpl *ds_impl = (IWineD3DSurfaceImpl *)This->stencilBufferTarget;
6444
6445 if (!ds_impl) return FALSE;
6446
6447 if (ds_impl->current_renderbuffer) {
6448 return (rt_impl->pow2Width != ds_impl->current_renderbuffer->width ||
6449 rt_impl->pow2Height != ds_impl->current_renderbuffer->height);
6450 }
6451
6452 return (rt_impl->pow2Width != ds_impl->pow2Width ||
6453 rt_impl->pow2Height != ds_impl->pow2Height);
6454 }
6455
6456 void apply_fbo_state(IWineD3DDevice *iface) {
6457 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6458 unsigned int i;
6459
6460 if (This->render_offscreen) {
6461 bind_fbo(iface, GL_FRAMEBUFFER_EXT, &This->fbo);
6462
6463 /* Apply render targets */
6464 for (i = 0; i < GL_LIMITS(buffers); ++i) {
6465 IWineD3DSurface *render_target = This->render_targets[i];
6466 if (This->fbo_color_attachments[i] != render_target) {
6467 set_render_target_fbo(iface, i, render_target);
6468 This->fbo_color_attachments[i] = render_target;
6469 }
6470 }
6471
6472 /* Apply depth targets */
6473 if (This->fbo_depth_attachment != This->stencilBufferTarget || depth_mismatch_fbo(iface)) {
6474 unsigned int w = ((IWineD3DSurfaceImpl *)This->render_targets[0])->pow2Width;
6475 unsigned int h = ((IWineD3DSurfaceImpl *)This->render_targets[0])->pow2Height;
6476
6477 if (This->stencilBufferTarget) {
6478 surface_set_compatible_renderbuffer(This->stencilBufferTarget, w, h);
6479 }
6480 set_depth_stencil_fbo(iface, This->stencilBufferTarget);
6481 This->fbo_depth_attachment = This->stencilBufferTarget;
6482 }
6483
6484 if (GL_SUPPORT(ARB_DRAW_BUFFERS)) {
6485 GL_EXTCALL(glDrawBuffersARB(GL_LIMITS(buffers), This->draw_buffers));
6486 checkGLcall("glDrawBuffers()");
6487 } else {
6488 glDrawBuffer(This->draw_buffers[0]);
6489 checkGLcall("glDrawBuffer()");
6490 }
6491 } else {
6492 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
6493 }
6494
6495 check_fbo_status(iface);
6496 }
6497
6498 void stretch_rect_fbo(IWineD3DDevice *iface, IWineD3DSurface *src_surface, WINED3DRECT *src_rect,
6499 IWineD3DSurface *dst_surface, WINED3DRECT *dst_rect, const WINED3DTEXTUREFILTERTYPE filter, BOOL flip) {
6500 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6501 GLbitfield mask = GL_COLOR_BUFFER_BIT; /* TODO: Support blitting depth/stencil surfaces */
6502 IWineD3DSwapChain *src_swapchain, *dst_swapchain;
6503 GLenum gl_filter;
6504
6505 TRACE("(%p) : src_surface %p, src_rect %p, dst_surface %p, dst_rect %p, filter %s (0x%08x), flip %u\n",
6506 This, src_surface, src_rect, dst_surface, dst_rect, debug_d3dtexturefiltertype(filter), filter, flip);
6507 TRACE("src_rect [%u, %u]->[%u, %u]\n", src_rect->x1, src_rect->y1, src_rect->x2, src_rect->y2);
6508 TRACE("dst_rect [%u, %u]->[%u, %u]\n", dst_rect->x1, dst_rect->y1, dst_rect->x2, dst_rect->y2);
6509
6510 switch (filter) {
6511 case WINED3DTEXF_LINEAR:
6512 gl_filter = GL_LINEAR;
6513 break;
6514
6515 default:
6516 FIXME("Unsupported filter mode %s (0x%08x)\n", debug_d3dtexturefiltertype(filter), filter);
6517 case WINED3DTEXF_NONE:
6518 case WINED3DTEXF_POINT:
6519 gl_filter = GL_NEAREST;
6520 break;
6521 }
6522
6523 /* Attach src surface to src fbo */
6524 src_swapchain = get_swapchain(src_surface);
6525 if (src_swapchain) {
6526 GLenum buffer;
6527
6528 TRACE("Source surface %p is onscreen\n", src_surface);
6529 ActivateContext(This, src_surface, CTXUSAGE_RESOURCELOAD);
6530 /* Make sure the drawable is up to date. In the offscreen case
6531 * attach_surface_fbo() implicitly takes care of this. */
6532 IWineD3DSurface_LoadLocation(src_surface, SFLAG_INDRAWABLE, NULL);
6533
6534 ENTER_GL();
6535 GL_EXTCALL(glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, 0));
6536 buffer = surface_get_gl_buffer(src_surface, src_swapchain);
6537 glReadBuffer(buffer);
6538 checkGLcall("glReadBuffer()");
6539
6540 src_rect->y1 = ((IWineD3DSurfaceImpl *)src_surface)->currentDesc.Height - src_rect->y1;
6541 src_rect->y2 = ((IWineD3DSurfaceImpl *)src_surface)->currentDesc.Height - src_rect->y2;
6542 } else {
6543 TRACE("Source surface %p is offscreen\n", src_surface);
6544 ENTER_GL();
6545 bind_fbo(iface, GL_READ_FRAMEBUFFER_EXT, &This->src_fbo);
6546 attach_surface_fbo(This, GL_READ_FRAMEBUFFER_EXT, 0, src_surface);
6547 glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);
6548 checkGLcall("glReadBuffer()");
6549 }
6550 LEAVE_GL();
6551
6552 /* Attach dst surface to dst fbo */
6553 dst_swapchain = get_swapchain(dst_surface);
6554 if (dst_swapchain) {
6555 GLenum buffer;
6556
6557 TRACE("Destination surface %p is onscreen\n", dst_surface);
6558 ActivateContext(This, dst_surface, CTXUSAGE_RESOURCELOAD);
6559 /* Make sure the drawable is up to date. In the offscreen case
6560 * attach_surface_fbo() implicitly takes care of this. */
6561 IWineD3DSurface_LoadLocation(dst_surface, SFLAG_INDRAWABLE, NULL);
6562
6563 ENTER_GL();
6564 GL_EXTCALL(glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0));
6565 buffer = surface_get_gl_buffer(dst_surface, dst_swapchain);
6566 glDrawBuffer(buffer);
6567 checkGLcall("glDrawBuffer()");
6568
6569 dst_rect->y1 = ((IWineD3DSurfaceImpl *)dst_surface)->currentDesc.Height - dst_rect->y1;
6570 dst_rect->y2 = ((IWineD3DSurfaceImpl *)dst_surface)->currentDesc.Height - dst_rect->y2;
6571 } else {
6572 TRACE("Destination surface %p is offscreen\n", dst_surface);
6573
6574 /* No src or dst swapchain? Make sure some context is active(multithreading) */
6575 if(!src_swapchain) {
6576 ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
6577 }
6578
6579 ENTER_GL();
6580 bind_fbo(iface, GL_DRAW_FRAMEBUFFER_EXT, &This->dst_fbo);
6581 attach_surface_fbo(This, GL_DRAW_FRAMEBUFFER_EXT, 0, dst_surface);
6582 glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
6583 checkGLcall("glDrawBuffer()");
6584 }
6585 glDisable(GL_SCISSOR_TEST);
6586 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE));
6587
6588 if (flip) {
6589 GL_EXTCALL(glBlitFramebufferEXT(src_rect->x1, src_rect->y1, src_rect->x2, src_rect->y2,
6590 dst_rect->x1, dst_rect->y2, dst_rect->x2, dst_rect->y1, mask, gl_filter));
6591 checkGLcall("glBlitFramebuffer()");
6592 } else {
6593 GL_EXTCALL(glBlitFramebufferEXT(src_rect->x1, src_rect->y1, src_rect->x2, src_rect->y2,
6594 dst_rect->x1, dst_rect->y1, dst_rect->x2, dst_rect->y2, mask, gl_filter));
6595 checkGLcall("glBlitFramebuffer()");
6596 }
6597
6598 IWineD3DSurface_ModifyLocation(dst_surface, SFLAG_INDRAWABLE, TRUE);
6599
6600 if (This->render_offscreen) {
6601 bind_fbo(iface, GL_FRAMEBUFFER_EXT, &This->fbo);
6602 } else {
6603 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
6604 checkGLcall("glBindFramebuffer()");
6605 }
6606
6607 /* If we switched from GL_BACK to GL_FRONT above, we need to switch back here */
6608 if (dst_swapchain && dst_surface == ((IWineD3DSwapChainImpl *)dst_swapchain)->frontBuffer
6609 && ((IWineD3DSwapChainImpl *)dst_swapchain)->backBuffer) {
6610 glDrawBuffer(GL_BACK);
6611 checkGLcall("glDrawBuffer()");
6612 }
6613 LEAVE_GL();
6614 }
6615
6616 static HRESULT WINAPI IWineD3DDeviceImpl_SetRenderTarget(IWineD3DDevice *iface, DWORD RenderTargetIndex, IWineD3DSurface *pRenderTarget) {
6617 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6618 WINED3DVIEWPORT viewport;
6619
6620 TRACE("(%p) : Setting rendertarget %d to %p\n", This, RenderTargetIndex, pRenderTarget);
6621
6622 if (RenderTargetIndex >= GL_LIMITS(buffers)) {
6623 WARN("(%p) : Unsupported target %u set, returning WINED3DERR_INVALIDCALL(only %u supported)\n",
6624 This, RenderTargetIndex, GL_LIMITS(buffers));
6625 return WINED3DERR_INVALIDCALL;
6626 }
6627
6628 /* MSDN says that null disables the render target
6629 but a device must always be associated with a render target
6630 nope MSDN says that we return invalid call to a null rendertarget with an index of 0
6631 */
6632 if (RenderTargetIndex == 0 && pRenderTarget == NULL) {
6633 FIXME("Trying to set render target 0 to NULL\n");
6634 return WINED3DERR_INVALIDCALL;
6635 }
6636 if (pRenderTarget && !(((IWineD3DSurfaceImpl *)pRenderTarget)->resource.usage & WINED3DUSAGE_RENDERTARGET)) {
6637 FIXME("(%p)Trying to set the render target to a surface(%p) that wasn't created with a usage of WINED3DUSAGE_RENDERTARGET\n",This ,pRenderTarget);
6638 return WINED3DERR_INVALIDCALL;
6639 }
6640
6641 /* If we are trying to set what we already have, don't bother */
6642 if (pRenderTarget == This->render_targets[RenderTargetIndex]) {
6643 TRACE("Trying to do a NOP SetRenderTarget operation\n");
6644 return WINED3D_OK;
6645 }
6646 if(pRenderTarget) IWineD3DSurface_AddRef(pRenderTarget);
6647 if(This->render_targets[RenderTargetIndex]) IWineD3DSurface_Release(This->render_targets[RenderTargetIndex]);
6648 This->render_targets[RenderTargetIndex] = pRenderTarget;
6649
6650 /* Render target 0 is special */
6651 if(RenderTargetIndex == 0) {
6652 /* Finally, reset the viewport as the MSDN states. */
6653 viewport.Height = ((IWineD3DSurfaceImpl *)This->render_targets[0])->currentDesc.Height;
6654 viewport.Width = ((IWineD3DSurfaceImpl *)This->render_targets[0])->currentDesc.Width;
6655 viewport.X = 0;
6656 viewport.Y = 0;
6657 viewport.MaxZ = 1.0f;
6658 viewport.MinZ = 0.0f;
6659 IWineD3DDeviceImpl_SetViewport(iface, &viewport);
6660 /* Make sure the viewport state is dirty, because the render_offscreen thing affects it.
6661 * SetViewport may catch NOP viewport changes, which would occur when switching between equally sized targets
6662 */
6663 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VIEWPORT);
6664
6665 /* Activate the new render target for now. This shouldn't stay here, but is needed until all methods using gl activate the
6666 * ctx properly.
6667 * Use resourceload usage, this will just set the drawables and context but not apply any states. The stateblock may be
6668 * incomplete or incorrect when SetRenderTarget is called. DrawPrim() will apply the states when it is called.
6669 */
6670 ActivateContext(This, This->render_targets[0], CTXUSAGE_RESOURCELOAD);
6671 }
6672 return WINED3D_OK;
6673 }
6674
6675 static HRESULT WINAPI IWineD3DDeviceImpl_SetDepthStencilSurface(IWineD3DDevice *iface, IWineD3DSurface *pNewZStencil) {
6676 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6677 HRESULT hr = WINED3D_OK;
6678 IWineD3DSurface *tmp;
6679
6680 TRACE("(%p) Swapping z-buffer. Old = %p, new = %p\n",This, This->stencilBufferTarget, pNewZStencil);
6681
6682 if (pNewZStencil == This->stencilBufferTarget) {
6683 TRACE("Trying to do a NOP SetRenderTarget operation\n");
6684 } else {
6685 /** OpenGL doesn't support 'sharing' of the stencilBuffer so we may incur an extra memory overhead
6686 * depending on the renter target implementation being used.
6687 * A shared context implementation will share all buffers between all rendertargets (including swapchains),
6688 * implementations that use separate pbuffers for different swapchains or rendertargets will have to duplicate the
6689 * stencil buffer and incur an extra memory overhead
6690 ******************************************************/
6691
6692 tmp = This->stencilBufferTarget;
6693 This->stencilBufferTarget = pNewZStencil;
6694 This->depth_copy_state = WINED3D_DCS_NO_COPY;
6695 /* should we be calling the parent or the wined3d surface? */
6696 if (NULL != This->stencilBufferTarget) IWineD3DSurface_AddRef(This->stencilBufferTarget);
6697 if (NULL != tmp) IWineD3DSurface_Release(tmp);
6698 hr = WINED3D_OK;
6699
6700 if((!tmp && pNewZStencil) || (!pNewZStencil && tmp)) {
6701 /* Swapping NULL / non NULL depth stencil affects the depth and tests */
6702 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_ZENABLE));
6703 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_STENCILENABLE));
6704 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_STENCILWRITEMASK));
6705 }
6706 }
6707
6708 return hr;
6709 }
6710
6711 static HRESULT WINAPI IWineD3DDeviceImpl_SetCursorProperties(IWineD3DDevice* iface, UINT XHotSpot,
6712 UINT YHotSpot, IWineD3DSurface *pCursorBitmap) {
6713 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6714 /* TODO: the use of Impl is deprecated. */
6715 IWineD3DSurfaceImpl * pSur = (IWineD3DSurfaceImpl *) pCursorBitmap;
6716 WINED3DLOCKED_RECT lockedRect;
6717
6718 TRACE("(%p) : Spot Pos(%u,%u)\n", This, XHotSpot, YHotSpot);
6719
6720 /* some basic validation checks */
6721 if(This->cursorTexture) {
6722 ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
6723 ENTER_GL();
6724 glDeleteTextures(1, &This->cursorTexture);
6725 LEAVE_GL();
6726 This->cursorTexture = 0;
6727 }
6728
6729 if ( (pSur->currentDesc.Width == 32) && (pSur->currentDesc.Height == 32) )
6730 This->haveHardwareCursor = TRUE;
6731 else
6732 This->haveHardwareCursor = FALSE;
6733
6734 if(pCursorBitmap) {
6735 WINED3DLOCKED_RECT rect;
6736
6737 /* MSDN: Cursor must be A8R8G8B8 */
6738 if (WINED3DFMT_A8R8G8B8 != pSur->resource.format) {
6739 ERR("(%p) : surface(%p) has an invalid format\n", This, pCursorBitmap);
6740 return WINED3DERR_INVALIDCALL;
6741 }
6742
6743 /* MSDN: Cursor must be smaller than the display mode */
6744 if(pSur->currentDesc.Width > This->ddraw_width ||
6745 pSur->currentDesc.Height > This->ddraw_height) {
6746 ERR("(%p) : Surface(%p) is %dx%d pixels, but screen res is %dx%d\n", This, pSur, pSur->currentDesc.Width, pSur->currentDesc.Height, This->ddraw_width, This->ddraw_height);
6747 return WINED3DERR_INVALIDCALL;
6748 }
6749
6750 if (!This->haveHardwareCursor) {
6751 /* TODO: MSDN: Cursor sizes must be a power of 2 */
6752
6753 /* Do not store the surface's pointer because the application may
6754 * release it after setting the cursor image. Windows doesn't
6755 * addref the set surface, so we can't do this either without
6756 * creating circular refcount dependencies. Copy out the gl texture
6757 * instead.
6758 */
6759 This->cursorWidth = pSur->currentDesc.Width;
6760 This->cursorHeight = pSur->currentDesc.Height;
6761 if (SUCCEEDED(IWineD3DSurface_LockRect(pCursorBitmap, &rect, NULL, WINED3DLOCK_READONLY)))
6762 {
6763 const GlPixelFormatDesc *glDesc;
6764 const StaticPixelFormatDesc *tableEntry = getFormatDescEntry(WINED3DFMT_A8R8G8B8, &GLINFO_LOCATION, &glDesc);
6765 char *mem, *bits = (char *)rect.pBits;
6766 GLint intfmt = glDesc->glInternal;
6767 GLint format = glDesc->glFormat;
6768 GLint type = glDesc->glType;
6769 INT height = This->cursorHeight;
6770 INT width = This->cursorWidth;
6771 INT bpp = tableEntry->bpp;
6772 INT i;
6773
6774 /* Reformat the texture memory (pitch and width can be
6775 * different) */
6776 mem = HeapAlloc(GetProcessHeap(), 0, width * height * bpp);
6777 for(i = 0; i < height; i++)
6778 memcpy(&mem[width * bpp * i], &bits[rect.Pitch * i], width * bpp);
6779 IWineD3DSurface_UnlockRect(pCursorBitmap);
6780 ENTER_GL();
6781
6782 if(GL_SUPPORT(APPLE_CLIENT_STORAGE)) {
6783 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
6784 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
6785 }
6786
6787 /* Make sure that a proper texture unit is selected */
6788 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
6789 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB));
6790 checkGLcall("glActiveTextureARB");
6791 }
6792 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(0));
6793 /* Create a new cursor texture */
6794 glGenTextures(1, &This->cursorTexture);
6795 checkGLcall("glGenTextures");
6796 glBindTexture(GL_TEXTURE_2D, This->cursorTexture);
6797 checkGLcall("glBindTexture");
6798 /* Copy the bitmap memory into the cursor texture */
6799 glTexImage2D(GL_TEXTURE_2D, 0, intfmt, width, height, 0, format, type, mem);
6800 HeapFree(GetProcessHeap(), 0, mem);
6801 checkGLcall("glTexImage2D");
6802
6803 if(GL_SUPPORT(APPLE_CLIENT_STORAGE)) {
6804 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
6805 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
6806 }
6807
6808 LEAVE_GL();
6809 }
6810 else
6811 {
6812 FIXME("A cursor texture was not returned.\n");
6813 This->cursorTexture = 0;
6814 }
6815 }
6816 else
6817 {
6818 /* Draw a hardware cursor */
6819 ICONINFO cursorInfo;
6820 HCURSOR cursor;
6821 /* Create and clear maskBits because it is not needed for
6822 * 32-bit cursors. 32x32 bits split into 32-bit chunks == 32
6823 * chunks. */
6824 DWORD *maskBits = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
6825 (pSur->currentDesc.Width * pSur->currentDesc.Height / 8));
6826 IWineD3DSurface_LockRect(pCursorBitmap, &lockedRect, NULL,
6827 WINED3DLOCK_NO_DIRTY_UPDATE |
6828 WINED3DLOCK_READONLY
6829 );
6830 TRACE("width: %i height: %i\n", pSur->currentDesc.Width,
6831 pSur->currentDesc.Height);
6832
6833 cursorInfo.fIcon = FALSE;
6834 cursorInfo.xHotspot = XHotSpot;
6835 cursorInfo.yHotspot = YHotSpot;
6836 cursorInfo.hbmMask = CreateBitmap(pSur->currentDesc.Width,
6837 pSur->currentDesc.Height, 1,
6838 1, &maskBits);
6839 cursorInfo.hbmColor = CreateBitmap(pSur->currentDesc.Width,
6840 pSur->currentDesc.Height, 1,
6841 32, lockedRect.pBits);
6842 IWineD3DSurface_UnlockRect(pCursorBitmap);
6843 /* Create our cursor and clean up. */
6844 cursor = CreateIconIndirect(&cursorInfo);
6845 SetCursor(cursor);
6846 if (cursorInfo.hbmMask) DeleteObject(cursorInfo.hbmMask);
6847 if (cursorInfo.hbmColor) DeleteObject(cursorInfo.hbmColor);
6848 if (This->hardwareCursor) DestroyCursor(This->hardwareCursor);
6849 This->hardwareCursor = cursor;
6850 HeapFree(GetProcessHeap(), 0, maskBits);
6851 }
6852 }
6853
6854 This->xHotSpot = XHotSpot;
6855 This->yHotSpot = YHotSpot;
6856 return WINED3D_OK;
6857 }
6858
6859 static void WINAPI IWineD3DDeviceImpl_SetCursorPosition(IWineD3DDevice* iface, int XScreenSpace, int YScreenSpace, DWORD Flags) {
6860 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6861 TRACE("(%p) : SetPos to (%u,%u)\n", This, XScreenSpace, YScreenSpace);
6862
6863 This->xScreenSpace = XScreenSpace;
6864 This->yScreenSpace = YScreenSpace;
6865
6866 return;
6867
6868 }
6869
6870 static BOOL WINAPI IWineD3DDeviceImpl_ShowCursor(IWineD3DDevice* iface, BOOL bShow) {
6871 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6872 BOOL oldVisible = This->bCursorVisible;
6873 POINT pt;
6874
6875 TRACE("(%p) : visible(%d)\n", This, bShow);
6876
6877 /*
6878 * When ShowCursor is first called it should make the cursor appear at the OS's last
6879 * known cursor position. Because of this, some applications just repetitively call
6880 * ShowCursor in order to update the cursor's position. This behavior is undocumented.
6881 */
6882 GetCursorPos(&pt);
6883 This->xScreenSpace = pt.x;
6884 This->yScreenSpace = pt.y;
6885
6886 if (This->haveHardwareCursor) {
6887 This->bCursorVisible = bShow;
6888 if (bShow)
6889 SetCursor(This->hardwareCursor);
6890 else
6891 SetCursor(NULL);
6892 }
6893 else
6894 {
6895 if (This->cursorTexture)
6896 This->bCursorVisible = bShow;
6897 }
6898
6899 return oldVisible;
6900 }
6901
6902 static HRESULT WINAPI IWineD3DDeviceImpl_TestCooperativeLevel(IWineD3DDevice* iface) {
6903 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6904 IWineD3DResourceImpl *resource;
6905 TRACE("(%p) : state (%u)\n", This, This->state);
6906
6907 /* TODO: Implement wrapping of the WndProc so that mimimize and maxamise can be monitored and the states adjusted. */
6908 switch (This->state) {
6909 case WINED3D_OK:
6910 return WINED3D_OK;
6911 case WINED3DERR_DEVICELOST:
6912 {
6913 LIST_FOR_EACH_ENTRY(resource, &This->resources, IWineD3DResourceImpl, resource.resource_list_entry) {
6914 if (resource->resource.pool == WINED3DPOOL_DEFAULT)
6915 return WINED3DERR_DEVICENOTRESET;
6916 }
6917 return WINED3DERR_DEVICELOST;
6918 }
6919 case WINED3DERR_DRIVERINTERNALERROR:
6920 return WINED3DERR_DRIVERINTERNALERROR;
6921 }
6922
6923 /* Unknown state */
6924 return WINED3DERR_DRIVERINTERNALERROR;
6925 }
6926
6927
6928 static HRESULT WINAPI IWineD3DDeviceImpl_EvictManagedResources(IWineD3DDevice* iface) {
6929 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6930 /** FIXME: Resource tracking needs to be done,
6931 * The closes we can do to this is set the priorities of all managed textures low
6932 * and then reset them.
6933 ***********************************************************/
6934 FIXME("(%p) : stub\n", This);
6935 return WINED3D_OK;
6936 }
6937
6938 static void updateSurfaceDesc(IWineD3DSurfaceImpl *surface, WINED3DPRESENT_PARAMETERS* pPresentationParameters) {
6939 IWineD3DDeviceImpl *This = surface->resource.wineD3DDevice; /* for GL_SUPPORT */
6940
6941 /* Reallocate proper memory for the front and back buffer and adjust their sizes */
6942 if(surface->Flags & SFLAG_DIBSECTION) {
6943 /* Release the DC */
6944 SelectObject(surface->hDC, surface->dib.holdbitmap);
6945 DeleteDC(surface->hDC);
6946 /* Release the DIB section */
6947 DeleteObject(surface->dib.DIBsection);
6948 surface->dib.bitmap_data = NULL;
6949 surface->resource.allocatedMemory = NULL;
6950 surface->Flags &= ~SFLAG_DIBSECTION;
6951 }
6952 surface->currentDesc.Width = pPresentationParameters->BackBufferWidth;
6953 surface->currentDesc.Height = pPresentationParameters->BackBufferHeight;
6954 if (GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO) || GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
6955 surface->pow2Width = pPresentationParameters->BackBufferWidth;
6956 surface->pow2Height = pPresentationParameters->BackBufferHeight;
6957 } else {
6958 surface->pow2Width = surface->pow2Height = 1;
6959 while (surface->pow2Width < pPresentationParameters->BackBufferWidth) surface->pow2Width <<= 1;
6960 while (surface->pow2Height < pPresentationParameters->BackBufferHeight) surface->pow2Height <<= 1;
6961 }
6962 surface->glRect.left = 0;
6963 surface->glRect.top = 0;
6964 surface->glRect.right = surface->pow2Width;
6965 surface->glRect.bottom = surface->pow2Height;
6966
6967 if(surface->glDescription.textureName) {
6968 ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
6969 ENTER_GL();
6970 glDeleteTextures(1, &surface->glDescription.textureName);
6971 LEAVE_GL();
6972 surface->glDescription.textureName = 0;
6973 surface->Flags &= ~SFLAG_CLIENT;
6974 }
6975 if(surface->pow2Width != pPresentationParameters->BackBufferWidth ||
6976 surface->pow2Height != pPresentationParameters->BackBufferHeight) {
6977 surface->Flags |= SFLAG_NONPOW2;
6978 } else {
6979 surface->Flags &= ~SFLAG_NONPOW2;
6980 }
6981 HeapFree(GetProcessHeap(), 0, surface->resource.heapMemory);
6982 surface->resource.allocatedMemory = NULL;
6983 surface->resource.heapMemory = NULL;
6984 surface->resource.size = IWineD3DSurface_GetPitch((IWineD3DSurface *) surface) * surface->pow2Width;
6985 }
6986
6987 static HRESULT WINAPI reset_unload_resources(IWineD3DResource *resource, void *data) {
6988 TRACE("Unloading resource %p\n", resource);
6989 IWineD3DResource_UnLoad(resource);
6990 IWineD3DResource_Release(resource);
6991 return S_OK;
6992 }
6993
6994 static void reset_fbo_state(IWineD3DDevice *iface) {
6995 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6996 unsigned int i;
6997
6998 ENTER_GL();
6999 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
7000 checkGLcall("glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0)");
7001
7002 if (This->fbo) {
7003 GL_EXTCALL(glDeleteFramebuffersEXT(1, &This->fbo));
7004 This->fbo = 0;
7005 }
7006 if (This->src_fbo) {
7007 GL_EXTCALL(glDeleteFramebuffersEXT(1, &This->src_fbo));
7008 This->src_fbo = 0;
7009 }
7010 if (This->dst_fbo) {
7011 GL_EXTCALL(glDeleteFramebuffersEXT(1, &This->dst_fbo));
7012 This->dst_fbo = 0;
7013 }
7014 checkGLcall("Tear down fbos\n");
7015 LEAVE_GL();
7016
7017 for (i = 0; i < GL_LIMITS(buffers); ++i) {
7018 This->fbo_color_attachments[i] = NULL;
7019 }
7020 This->fbo_depth_attachment = NULL;
7021 }
7022
7023 static BOOL is_display_mode_supported(IWineD3DDeviceImpl *This, WINED3DPRESENT_PARAMETERS *pp) {
7024 UINT i, count;
7025 WINED3DDISPLAYMODE m;
7026 HRESULT hr;
7027
7028 /* All Windowed modes are supported, as is leaving the current mode */
7029 if(pp->Windowed) return TRUE;
7030 if(!pp->BackBufferWidth) return TRUE;
7031 if(!pp->BackBufferHeight) return TRUE;
7032
7033 count = IWineD3D_GetAdapterModeCount(This->wineD3D, This->adapter->num, WINED3DFMT_UNKNOWN);
7034 for(i = 0; i < count; i++) {
7035 memset(&m, 0, sizeof(m));
7036 hr = IWineD3D_EnumAdapterModes(This->wineD3D, This->adapter->num, WINED3DFMT_UNKNOWN, i, &m);
7037 if(FAILED(hr)) {
7038 ERR("EnumAdapterModes failed\n");
7039 }
7040 if(m.Width == pp->BackBufferWidth && m.Height == pp->BackBufferHeight) {
7041 /* Mode found, it is supported */
7042 return TRUE;
7043 }
7044 }
7045 /* Mode not found -> not supported */
7046 return FALSE;
7047 }
7048
7049 static HRESULT WINAPI IWineD3DDeviceImpl_Reset(IWineD3DDevice* iface, WINED3DPRESENT_PARAMETERS* pPresentationParameters) {
7050 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
7051 IWineD3DSwapChainImpl *swapchain;
7052 HRESULT hr;
7053 BOOL DisplayModeChanged = FALSE;
7054 WINED3DDISPLAYMODE mode;
7055 IWineD3DBaseShaderImpl *shader;
7056 IWineD3DSurfaceImpl *target;
7057 UINT i;
7058 TRACE("(%p)\n", This);
7059
7060 hr = IWineD3DDevice_GetSwapChain(iface, 0, (IWineD3DSwapChain **) &swapchain);
7061 if(FAILED(hr)) {
7062 ERR("Failed to get the first implicit swapchain\n");
7063 return hr;
7064 }
7065
7066 if(!is_display_mode_supported(This, pPresentationParameters)) {
7067 WARN("Rejecting Reset() call because the requested display mode is not supported\n");
7068 WARN("Requested mode: %d, %d\n", pPresentationParameters->BackBufferWidth,
7069 pPresentationParameters->BackBufferHeight);
7070 return WINED3DERR_INVALIDCALL;
7071 }
7072
7073 /* Is it necessary to recreate the gl context? Actually every setting can be changed
7074 * on an existing gl context, so there's no real need for recreation.
7075 *
7076 * TODO: Figure out how Reset influences resources in D3DPOOL_DEFAULT, D3DPOOL_SYSTEMMEMORY and D3DPOOL_MANAGED
7077 *
7078 * TODO: Figure out what happens to explicit swapchains, or if we have more than one implicit swapchain
7079 */
7080 TRACE("New params:\n");
7081 TRACE("BackBufferWidth = %d\n", pPresentationParameters->BackBufferWidth);
7082 TRACE("BackBufferHeight = %d\n", pPresentationParameters->BackBufferHeight);
7083 TRACE("BackBufferFormat = %s\n", debug_d3dformat(pPresentationParameters->BackBufferFormat));
7084 TRACE("BackBufferCount = %d\n", pPresentationParameters->BackBufferCount);
7085 TRACE("MultiSampleType = %d\n", pPresentationParameters->MultiSampleType);
7086 TRACE("MultiSampleQuality = %d\n", pPresentationParameters->MultiSampleQuality);
7087 TRACE("SwapEffect = %d\n", pPresentationParameters->SwapEffect);
7088 TRACE("hDeviceWindow = %p\n", pPresentationParameters->hDeviceWindow);
7089 TRACE("Windowed = %s\n", pPresentationParameters->Windowed ? "true" : "false");
7090 TRACE("EnableAutoDepthStencil = %s\n", pPresentationParameters->EnableAutoDepthStencil ? "true" : "false");
7091 TRACE("Flags = %08x\n", pPresentationParameters->Flags);
7092 TRACE("FullScreen_RefreshRateInHz = %d\n", pPresentationParameters->FullScreen_RefreshRateInHz);
7093 TRACE("PresentationInterval = %d\n", pPresentationParameters->PresentationInterval);
7094
7095 /* No special treatment of these parameters. Just store them */
7096 swapchain->presentParms.SwapEffect = pPresentationParameters->SwapEffect;
7097 swapchain->presentParms.Flags = pPresentationParameters->Flags;
7098 swapchain->presentParms.PresentationInterval = pPresentationParameters->PresentationInterval;
7099 swapchain->presentParms.FullScreen_RefreshRateInHz = pPresentationParameters->FullScreen_RefreshRateInHz;
7100
7101 /* What to do about these? */
7102 if(pPresentationParameters->BackBufferCount != 0 &&
7103 pPresentationParameters->BackBufferCount != swapchain->presentParms.BackBufferCount) {
7104 ERR("Cannot change the back buffer count yet\n");
7105 }
7106 if(pPresentationParameters->BackBufferFormat != WINED3DFMT_UNKNOWN &&
7107 pPresentationParameters->BackBufferFormat != swapchain->presentParms.BackBufferFormat) {
7108 ERR("Cannot change the back buffer format yet\n");
7109 }
7110 if(pPresentationParameters->hDeviceWindow != NULL &&
7111 pPresentationParameters->hDeviceWindow != swapchain->presentParms.hDeviceWindow) {
7112 ERR("Cannot change the device window yet\n");
7113 }
7114 if(pPresentationParameters->EnableAutoDepthStencil != swapchain->presentParms.EnableAutoDepthStencil) {
7115 ERR("What do do about a changed auto depth stencil parameter?\n");
7116 }
7117
7118 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) {
7119 reset_fbo_state((IWineD3DDevice *) This);
7120 }
7121
7122 IWineD3DDevice_EnumResources(iface, reset_unload_resources, NULL);
7123 LIST_FOR_EACH_ENTRY(shader, &This->shaders, IWineD3DBaseShaderImpl, baseShader.shader_list_entry) {
7124 This->shader_backend->shader_destroy((IWineD3DBaseShader *) shader);
7125 }
7126
7127 ENTER_GL();
7128 if(This->depth_blt_texture) {
7129 glDeleteTextures(1, &This->depth_blt_texture);
7130 This->depth_blt_texture = 0;
7131 }
7132 This->shader_backend->shader_destroy_depth_blt(iface);
7133 This->shader_backend->shader_free_private(iface);
7134
7135 for (i = 0; i < GL_LIMITS(textures); i++) {
7136 /* Textures are recreated below */
7137 glDeleteTextures(1, &This->dummyTextureName[i]);
7138 checkGLcall("glDeleteTextures(1, &This->dummyTextureName[i])");
7139 This->dummyTextureName[i] = 0;
7140 }
7141 LEAVE_GL();
7142
7143 while(This->numContexts) {
7144 DestroyContext(This, This->contexts[0]);
7145 }
7146 This->activeContext = NULL;
7147 HeapFree(GetProcessHeap(), 0, swapchain->context);
7148 swapchain->context = NULL;
7149 swapchain->num_contexts = 0;
7150
7151 if(pPresentationParameters->Windowed) {
7152 mode.Width = swapchain->orig_width;
7153 mode.Height = swapchain->orig_height;
7154 mode.RefreshRate = 0;
7155 mode.Format = swapchain->presentParms.BackBufferFormat;
7156 } else {
7157 mode.Width = pPresentationParameters->BackBufferWidth;
7158 mode.Height = pPresentationParameters->BackBufferHeight;
7159 mode.RefreshRate = pPresentationParameters->FullScreen_RefreshRateInHz;
7160 mode.Format = swapchain->presentParms.BackBufferFormat;
7161 }
7162
7163 /* Should Width == 800 && Height == 0 set 800x600? */
7164 if(pPresentationParameters->BackBufferWidth != 0 && pPresentationParameters->BackBufferHeight != 0 &&
7165 (pPresentationParameters->BackBufferWidth != swapchain->presentParms.BackBufferWidth ||
7166 pPresentationParameters->BackBufferHeight != swapchain->presentParms.BackBufferHeight))
7167 {
7168 WINED3DVIEWPORT vp;
7169 int i;
7170
7171 vp.X = 0;
7172 vp.Y = 0;
7173 vp.Width = pPresentationParameters->BackBufferWidth;
7174 vp.Height = pPresentationParameters->BackBufferHeight;
7175 vp.MinZ = 0;
7176 vp.MaxZ = 1;
7177
7178 if(!pPresentationParameters->Windowed) {
7179 DisplayModeChanged = TRUE;
7180 }
7181 swapchain->presentParms.BackBufferWidth = pPresentationParameters->BackBufferWidth;
7182 swapchain->presentParms.BackBufferHeight = pPresentationParameters->BackBufferHeight;
7183
7184 updateSurfaceDesc((IWineD3DSurfaceImpl *)swapchain->frontBuffer, pPresentationParameters);
7185 for(i = 0; i < swapchain->presentParms.BackBufferCount; i++) {
7186 updateSurfaceDesc((IWineD3DSurfaceImpl *)swapchain->backBuffer[i], pPresentationParameters);
7187 }
7188 if(This->auto_depth_stencil_buffer) {
7189 updateSurfaceDesc((IWineD3DSurfaceImpl *)This->auto_depth_stencil_buffer, pPresentationParameters);
7190 }
7191
7192
7193 /* Now set the new viewport */
7194 IWineD3DDevice_SetViewport(iface, &vp);
7195 }
7196
7197 if((pPresentationParameters->Windowed && !swapchain->presentParms.Windowed) ||
7198 (swapchain->presentParms.Windowed && !pPresentationParameters->Windowed) ||
7199 DisplayModeChanged) {
7200
7201 IWineD3DDevice_SetFullscreen(iface, !pPresentationParameters->Windowed);
7202 swapchain->presentParms.Windowed = pPresentationParameters->Windowed;
7203 IWineD3DDevice_SetDisplayMode(iface, 0, &mode);
7204 } else if(!pPresentationParameters->Windowed) {
7205 DWORD style = This->style, exStyle = This->exStyle;
7206 /* If we're in fullscreen, and the mode wasn't changed, we have to get the window back into
7207 * the right position. Some applications(Battlefield 2, Guild Wars) move it and then call
7208 * Reset to clear up their mess. Guild Wars also loses the device during that.
7209 */
7210 This->style = 0;
7211 This->exStyle = 0;
7212 IWineD3DDeviceImpl_SetupFullscreenWindow(iface, This->ddraw_window);
7213 This->style = style;
7214 This->exStyle = exStyle;
7215 }
7216
7217 /* Recreate the primary swapchain's context */
7218 swapchain->context = HeapAlloc(GetProcessHeap(), 0, sizeof(*swapchain->context));
7219 if(swapchain->backBuffer) {
7220 target = (IWineD3DSurfaceImpl *) swapchain->backBuffer[0];
7221 } else {
7222 target = (IWineD3DSurfaceImpl *) swapchain->frontBuffer;
7223 }
7224 swapchain->context[0] = CreateContext(This, target, swapchain->win_handle, FALSE,
7225 &swapchain->presentParms);
7226 swapchain->num_contexts = 1;
7227 This->activeContext = swapchain->context[0];
7228 IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
7229
7230 hr = IWineD3DStateBlock_InitStartupStateBlock((IWineD3DStateBlock *) This->stateBlock);
7231 if(FAILED(hr)) {
7232 ERR("Resetting the stateblock failed with error 0x%08x\n", hr);
7233 }
7234 create_dummy_textures(This);
7235
7236
7237 hr = This->shader_backend->shader_alloc_private(iface);
7238 if(FAILED(hr)) {
7239 ERR("Failed to recreate shader private data\n");
7240 return hr;
7241 }
7242
7243 /* All done. There is no need to reload resources or shaders, this will happen automatically on the
7244 * first use
7245 */
7246 return WINED3D_OK;
7247 }
7248
7249 static HRESULT WINAPI IWineD3DDeviceImpl_SetDialogBoxMode(IWineD3DDevice *iface, BOOL bEnableDialogs) {
7250 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
7251 /** FIXME: always true at the moment **/
7252 if(!bEnableDialogs) {
7253 FIXME("(%p) Dialogs cannot be disabled yet\n", This);
7254 }
7255 return WINED3D_OK;
7256 }
7257
7258
7259 static HRESULT WINAPI IWineD3DDeviceImpl_GetCreationParameters(IWineD3DDevice *iface, WINED3DDEVICE_CREATION_PARAMETERS *pParameters) {
7260 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
7261 TRACE("(%p) : pParameters %p\n", This, pParameters);
7262
7263 *pParameters = This->createParms;
7264 return WINED3D_OK;
7265 }
7266
7267 static void WINAPI IWineD3DDeviceImpl_SetGammaRamp(IWineD3DDevice * iface, UINT iSwapChain, DWORD Flags, CONST WINED3DGAMMARAMP* pRamp) {
7268 IWineD3DSwapChain *swapchain;
7269 HRESULT hrc = WINED3D_OK;
7270
7271 TRACE("Relaying to swapchain\n");
7272
7273 if ((hrc = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapchain)) == WINED3D_OK) {
7274 IWineD3DSwapChain_SetGammaRamp(swapchain, Flags, (WINED3DGAMMARAMP *)pRamp);
7275 IWineD3DSwapChain_Release(swapchain);
7276 }
7277 return;
7278 }
7279
7280 static void WINAPI IWineD3DDeviceImpl_GetGammaRamp(IWineD3DDevice *iface, UINT iSwapChain, WINED3DGAMMARAMP* pRamp) {
7281 IWineD3DSwapChain *swapchain;
7282 HRESULT hrc = WINED3D_OK;
7283
7284 TRACE("Relaying to swapchain\n");
7285
7286 if ((hrc = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapchain)) == WINED3D_OK) {
7287 hrc =IWineD3DSwapChain_GetGammaRamp(swapchain, pRamp);
7288 IWineD3DSwapChain_Release(swapchain);
7289 }
7290 return;
7291 }
7292
7293
7294 /** ********************************************************
7295 * Notification functions
7296 ** ********************************************************/
7297 /** This function must be called in the release of a resource when ref == 0,
7298 * the contents of resource must still be correct,
7299 * any handles to other resource held by the caller must be closed
7300 * (e.g. a texture should release all held surfaces because telling the device that it's been released.)
7301 *****************************************************/
7302 static void WINAPI IWineD3DDeviceImpl_AddResource(IWineD3DDevice *iface, IWineD3DResource *resource){
7303 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
7304
7305 TRACE("(%p) : Adding Resource %p\n", This, resource);
7306 list_add_head(&This->resources, &((IWineD3DResourceImpl *) resource)->resource.resource_list_entry);
7307 }
7308
7309 static void WINAPI IWineD3DDeviceImpl_RemoveResource(IWineD3DDevice *iface, IWineD3DResource *resource){
7310 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
7311
7312 TRACE("(%p) : Removing resource %p\n", This, resource);
7313
7314 list_remove(&((IWineD3DResourceImpl *) resource)->resource.resource_list_entry);
7315 }
7316
7317
7318 static void WINAPI IWineD3DDeviceImpl_ResourceReleased(IWineD3DDevice *iface, IWineD3DResource *resource){
7319 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
7320 int counter;
7321
7322 TRACE("(%p) : resource %p\n", This, resource);
7323 switch(IWineD3DResource_GetType(resource)){
7324 /* TODO: check front and back buffers, rendertargets etc.. possibly swapchains? */
7325 case WINED3DRTYPE_SURFACE: {
7326 unsigned int i;
7327
7328 /* Cleanup any FBO attachments if d3d is enabled */
7329 if(This->d3d_initialized) {
7330 if((IWineD3DSurface *)resource == This->lastActiveRenderTarget) {
7331 IWineD3DSwapChainImpl *swapchain = This->swapchains ? (IWineD3DSwapChainImpl *) This->swapchains[0] : NULL;
7332
7333 TRACE("Last active render target destroyed\n");
7334 /* Find a replacement surface for the currently active back buffer. The context manager does not do NULL
7335 * checks, so switch to a valid target as long as the currently set surface is still valid. Use the
7336 * surface of the implicit swpchain. If that is the same as the destroyed surface the device is destroyed
7337 * and the lastActiveRenderTarget member shouldn't matter
7338 */
7339 if(swapchain) {
7340 if(swapchain->backBuffer && swapchain->backBuffer[0] != (IWineD3DSurface *)resource) {
7341 TRACE("Activating primary back buffer\n");
7342 ActivateContext(This, swapchain->backBuffer[0], CTXUSAGE_RESOURCELOAD);
7343 } else if(!swapchain->backBuffer && swapchain->frontBuffer != (IWineD3DSurface *)resource) {
7344 /* Single buffering environment */
7345 TRACE("Activating primary front buffer\n");
7346 ActivateContext(This, swapchain->frontBuffer, CTXUSAGE_RESOURCELOAD);
7347 } else {
7348 TRACE("Device is being destroyed, setting lastActiveRenderTarget = 0xdeadbabe\n");
7349 /* Implicit render target destroyed, that means the device is being destroyed
7350 * whatever we set here, it shouldn't matter
7351 */
7352 This->lastActiveRenderTarget = (IWineD3DSurface *) 0xdeadbabe;
7353 }
7354 } else {
7355 /* May happen during ddraw uninitialization */
7356 TRACE("Render target set, but swapchain does not exist!\n");
7357 This->lastActiveRenderTarget = (IWineD3DSurface *) 0xdeadcafe;
7358 }
7359 }
7360
7361 for (i = 0; i < GL_LIMITS(buffers); ++i) {
7362 if (This->fbo_color_attachments[i] == (IWineD3DSurface *)resource) {
7363 bind_fbo(iface, GL_FRAMEBUFFER_EXT, &This->fbo);
7364 set_render_target_fbo(iface, i, NULL);
7365 This->fbo_color_attachments[i] = NULL;
7366 }
7367 }
7368 if (This->fbo_depth_attachment == (IWineD3DSurface *)resource) {
7369 bind_fbo(iface, GL_FRAMEBUFFER_EXT, &This->fbo);
7370 set_depth_stencil_fbo(iface, NULL);
7371 This->fbo_depth_attachment = NULL;
7372 }
7373 }
7374
7375 break;
7376 }
7377 case WINED3DRTYPE_TEXTURE:
7378 case WINED3DRTYPE_CUBETEXTURE:
7379 case WINED3DRTYPE_VOLUMETEXTURE:
7380 for (counter = 0; counter < MAX_COMBINED_SAMPLERS; counter++) {
7381 if (This->stateBlock != NULL && This->stateBlock->textures[counter] == (IWineD3DBaseTexture *)resource) {
7382 WARN("Texture being released is still by a stateblock, Stage = %u Texture = %p\n", counter, resource);
7383 This->stateBlock->textures[counter] = NULL;
7384 }
7385 if (This->updateStateBlock != This->stateBlock ){
7386 if (This->updateStateBlock->textures[counter] == (IWineD3DBaseTexture *)resource) {
7387 WARN("Texture being released is still by a stateblock, Stage = %u Texture = %p\n", counter, resource);
7388 This->updateStateBlock->textures[counter] = NULL;
7389 }
7390 }
7391 }
7392 break;
7393 case WINED3DRTYPE_VOLUME:
7394 /* TODO: nothing really? */
7395 break;
7396 case WINED3DRTYPE_VERTEXBUFFER:
7397 /* MSDN: When an application no longer holds a references to this interface, the interface will automatically be freed. */
7398 {
7399 int streamNumber;
7400 TRACE("Cleaning up stream pointers\n");
7401
7402 for(streamNumber = 0; streamNumber < MAX_STREAMS; streamNumber ++){
7403 /* FINDOUT: should a warn be generated if were recording and updateStateBlock->streamSource is lost?
7404 FINDOUT: should changes.streamSource[StreamNumber] be set ?
7405 */
7406 if (This->updateStateBlock != NULL ) { /* ==NULL when device is being destroyed */
7407 if ((IWineD3DResource *)This->updateStateBlock->streamSource[streamNumber] == resource) {
7408 FIXME("Vertex buffer released while bound to a state block, stream %d\n", streamNumber);
7409 This->updateStateBlock->streamSource[streamNumber] = 0;
7410 /* Set changed flag? */
7411 }
7412 }
7413 if (This->stateBlock != NULL ) { /* only happens if there is an error in the application, or on reset/release (because we don't manage internal tracking properly) */
7414 if ((IWineD3DResource *)This->stateBlock->streamSource[streamNumber] == resource) {
7415 TRACE("Vertex buffer released while bound to a state block, stream %d\n", streamNumber);
7416 This->stateBlock->streamSource[streamNumber] = 0;
7417 }
7418 }
7419 #if 0 /* TODO: Manage internal tracking properly so that 'this shouldn't happen' */
7420 else { /* This shouldn't happen */
7421 FIXME("Calling application has released the device before relasing all the resources bound to the device\n");
7422 }
7423 #endif
7424
7425 }
7426 }
7427 break;
7428 case WINED3DRTYPE_INDEXBUFFER:
7429 /* MSDN: When an application no longer holds a references to this interface, the interface will automatically be freed.*/
7430 if (This->updateStateBlock != NULL ) { /* ==NULL when device is being destroyed */
7431 if (This->updateStateBlock->pIndexData == (IWineD3DIndexBuffer *)resource) {
7432 This->updateStateBlock->pIndexData = NULL;
7433 }
7434 }
7435 if (This->stateBlock != NULL ) { /* ==NULL when device is being destroyed */
7436 if (This->stateBlock->pIndexData == (IWineD3DIndexBuffer *)resource) {
7437 This->stateBlock->pIndexData = NULL;
7438 }
7439 }
7440
7441 break;
7442 default:
7443 FIXME("(%p) unknown resource type %p %u\n", This, resource, IWineD3DResource_GetType(resource));
7444 break;
7445 }
7446
7447
7448 /* Remove the resource from the resourceStore */
7449 IWineD3DDeviceImpl_RemoveResource(iface, resource);
7450
7451 TRACE("Resource released\n");
7452
7453 }
7454
7455 static HRESULT WINAPI IWineD3DDeviceImpl_EnumResources(IWineD3DDevice *iface, D3DCB_ENUMRESOURCES pCallback, void *pData) {
7456 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
7457 IWineD3DResourceImpl *resource, *cursor;
7458 HRESULT ret;
7459 TRACE("(%p)->(%p,%p)\n", This, pCallback, pData);
7460
7461 LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &This->resources, IWineD3DResourceImpl, resource.resource_list_entry) {
7462 TRACE("enumerating resource %p\n", resource);
7463 IWineD3DResource_AddRef((IWineD3DResource *) resource);
7464 ret = pCallback((IWineD3DResource *) resource, pData);
7465 if(ret == S_FALSE) {
7466 TRACE("Canceling enumeration\n");
7467 break;
7468 }
7469 }
7470 return WINED3D_OK;
7471 }
7472
7473 /**********************************************************
7474 * IWineD3DDevice VTbl follows
7475 **********************************************************/
7476
7477 const IWineD3DDeviceVtbl IWineD3DDevice_Vtbl =
7478 {
7479 /*** IUnknown methods ***/
7480 IWineD3DDeviceImpl_QueryInterface,
7481 IWineD3DDeviceImpl_AddRef,
7482 IWineD3DDeviceImpl_Release,
7483 /*** IWineD3DDevice methods ***/
7484 IWineD3DDeviceImpl_GetParent,
7485 /*** Creation methods**/
7486 IWineD3DDeviceImpl_CreateVertexBuffer,
7487 IWineD3DDeviceImpl_CreateIndexBuffer,
7488 IWineD3DDeviceImpl_CreateStateBlock,
7489 IWineD3DDeviceImpl_CreateSurface,
7490 IWineD3DDeviceImpl_CreateTexture,
7491 IWineD3DDeviceImpl_CreateVolumeTexture,
7492 IWineD3DDeviceImpl_CreateVolume,
7493 IWineD3DDeviceImpl_CreateCubeTexture,
7494 IWineD3DDeviceImpl_CreateQuery,
7495 IWineD3DDeviceImpl_CreateAdditionalSwapChain,
7496 IWineD3DDeviceImpl_CreateVertexDeclaration,
7497 IWineD3DDeviceImpl_CreateVertexDeclarationFromFVF,
7498 IWineD3DDeviceImpl_CreateVertexShader,
7499 IWineD3DDeviceImpl_CreatePixelShader,
7500 IWineD3DDeviceImpl_CreatePalette,
7501 /*** Odd functions **/
7502 IWineD3DDeviceImpl_Init3D,
7503 IWineD3DDeviceImpl_Uninit3D,
7504 IWineD3DDeviceImpl_SetFullscreen,
7505 IWineD3DDeviceImpl_SetMultithreaded,
7506 IWineD3DDeviceImpl_EvictManagedResources,
7507 IWineD3DDeviceImpl_GetAvailableTextureMem,
7508 IWineD3DDeviceImpl_GetBackBuffer,
7509 IWineD3DDeviceImpl_GetCreationParameters,
7510 IWineD3DDeviceImpl_GetDeviceCaps,
7511 IWineD3DDeviceImpl_GetDirect3D,
7512 IWineD3DDeviceImpl_GetDisplayMode,
7513 IWineD3DDeviceImpl_SetDisplayMode,
7514 IWineD3DDeviceImpl_GetHWND,
7515 IWineD3DDeviceImpl_SetHWND,
7516 IWineD3DDeviceImpl_GetNumberOfSwapChains,
7517 IWineD3DDeviceImpl_GetRasterStatus,
7518 IWineD3DDeviceImpl_GetSwapChain,
7519 IWineD3DDeviceImpl_Reset,
7520 IWineD3DDeviceImpl_SetDialogBoxMode,
7521 IWineD3DDeviceImpl_SetCursorProperties,
7522 IWineD3DDeviceImpl_SetCursorPosition,
7523 IWineD3DDeviceImpl_ShowCursor,
7524 IWineD3DDeviceImpl_TestCooperativeLevel,
7525 /*** Getters and setters **/
7526 IWineD3DDeviceImpl_SetClipPlane,
7527 IWineD3DDeviceImpl_GetClipPlane,
7528 IWineD3DDeviceImpl_SetClipStatus,
7529 IWineD3DDeviceImpl_GetClipStatus,
7530 IWineD3DDeviceImpl_SetCurrentTexturePalette,
7531 IWineD3DDeviceImpl_GetCurrentTexturePalette,
7532 IWineD3DDeviceImpl_SetDepthStencilSurface,
7533 IWineD3DDeviceImpl_GetDepthStencilSurface,
7534 IWineD3DDeviceImpl_SetFVF,
7535 IWineD3DDeviceImpl_GetFVF,
7536 IWineD3DDeviceImpl_SetGammaRamp,
7537 IWineD3DDeviceImpl_GetGammaRamp,
7538 IWineD3DDeviceImpl_SetIndices,
7539 IWineD3DDeviceImpl_GetIndices,
7540 IWineD3DDeviceImpl_SetBaseVertexIndex,
7541 IWineD3DDeviceImpl_GetBaseVertexIndex,
7542 IWineD3DDeviceImpl_SetLight,
7543 IWineD3DDeviceImpl_GetLight,
7544 IWineD3DDeviceImpl_SetLightEnable,
7545 IWineD3DDeviceImpl_GetLightEnable,
7546 IWineD3DDeviceImpl_SetMaterial,
7547 IWineD3DDeviceImpl_GetMaterial,
7548 IWineD3DDeviceImpl_SetNPatchMode,
7549 IWineD3DDeviceImpl_GetNPatchMode,
7550 IWineD3DDeviceImpl_SetPaletteEntries,
7551 IWineD3DDeviceImpl_GetPaletteEntries,
7552 IWineD3DDeviceImpl_SetPixelShader,
7553 IWineD3DDeviceImpl_GetPixelShader,
7554 IWineD3DDeviceImpl_SetPixelShaderConstantB,
7555 IWineD3DDeviceImpl_GetPixelShaderConstantB,
7556 IWineD3DDeviceImpl_SetPixelShaderConstantI,
7557 IWineD3DDeviceImpl_GetPixelShaderConstantI,
7558 IWineD3DDeviceImpl_SetPixelShaderConstantF,
7559 IWineD3DDeviceImpl_GetPixelShaderConstantF,
7560 IWineD3DDeviceImpl_SetRenderState,
7561 IWineD3DDeviceImpl_GetRenderState,
7562 IWineD3DDeviceImpl_SetRenderTarget,
7563 IWineD3DDeviceImpl_GetRenderTarget,
7564 IWineD3DDeviceImpl_SetFrontBackBuffers,
7565 IWineD3DDeviceImpl_SetSamplerState,
7566 IWineD3DDeviceImpl_GetSamplerState,
7567 IWineD3DDeviceImpl_SetScissorRect,
7568 IWineD3DDeviceImpl_GetScissorRect,
7569 IWineD3DDeviceImpl_SetSoftwareVertexProcessing,
7570 IWineD3DDeviceImpl_GetSoftwareVertexProcessing,
7571 IWineD3DDeviceImpl_SetStreamSource,
7572 IWineD3DDeviceImpl_GetStreamSource,
7573 IWineD3DDeviceImpl_SetStreamSourceFreq,
7574 IWineD3DDeviceImpl_GetStreamSourceFreq,
7575 IWineD3DDeviceImpl_SetTexture,
7576 IWineD3DDeviceImpl_GetTexture,
7577 IWineD3DDeviceImpl_SetTextureStageState,
7578 IWineD3DDeviceImpl_GetTextureStageState,
7579 IWineD3DDeviceImpl_SetTransform,
7580 IWineD3DDeviceImpl_GetTransform,
7581 IWineD3DDeviceImpl_SetVertexDeclaration,
7582 IWineD3DDeviceImpl_GetVertexDeclaration,
7583 IWineD3DDeviceImpl_SetVertexShader,
7584 IWineD3DDeviceImpl_GetVertexShader,
7585 IWineD3DDeviceImpl_SetVertexShaderConstantB,
7586 IWineD3DDeviceImpl_GetVertexShaderConstantB,
7587 IWineD3DDeviceImpl_SetVertexShaderConstantI,
7588 IWineD3DDeviceImpl_GetVertexShaderConstantI,
7589 IWineD3DDeviceImpl_SetVertexShaderConstantF,
7590 IWineD3DDeviceImpl_GetVertexShaderConstantF,
7591 IWineD3DDeviceImpl_SetViewport,
7592 IWineD3DDeviceImpl_GetViewport,
7593 IWineD3DDeviceImpl_MultiplyTransform,
7594 IWineD3DDeviceImpl_ValidateDevice,
7595 IWineD3DDeviceImpl_ProcessVertices,
7596 /*** State block ***/
7597 IWineD3DDeviceImpl_BeginStateBlock,
7598 IWineD3DDeviceImpl_EndStateBlock,
7599 /*** Scene management ***/
7600 IWineD3DDeviceImpl_BeginScene,
7601 IWineD3DDeviceImpl_EndScene,
7602 IWineD3DDeviceImpl_Present,
7603 IWineD3DDeviceImpl_Clear,
7604 /*** Drawing ***/
7605 IWineD3DDeviceImpl_DrawPrimitive,
7606 IWineD3DDeviceImpl_DrawIndexedPrimitive,
7607 IWineD3DDeviceImpl_DrawPrimitiveUP,
7608 IWineD3DDeviceImpl_DrawIndexedPrimitiveUP,
7609 IWineD3DDeviceImpl_DrawPrimitiveStrided,
7610 IWineD3DDeviceImpl_DrawIndexedPrimitiveStrided,
7611 IWineD3DDeviceImpl_DrawRectPatch,
7612 IWineD3DDeviceImpl_DrawTriPatch,
7613 IWineD3DDeviceImpl_DeletePatch,
7614 IWineD3DDeviceImpl_ColorFill,
7615 IWineD3DDeviceImpl_UpdateTexture,
7616 IWineD3DDeviceImpl_UpdateSurface,
7617 IWineD3DDeviceImpl_GetFrontBufferData,
7618 /*** object tracking ***/
7619 IWineD3DDeviceImpl_ResourceReleased,
7620 IWineD3DDeviceImpl_EnumResources
7621 };
7622
7623 const IWineD3DDeviceVtbl IWineD3DDevice_DirtyConst_Vtbl =
7624 {
7625 /*** IUnknown methods ***/
7626 IWineD3DDeviceImpl_QueryInterface,
7627 IWineD3DDeviceImpl_AddRef,
7628 IWineD3DDeviceImpl_Release,
7629 /*** IWineD3DDevice methods ***/
7630 IWineD3DDeviceImpl_GetParent,
7631 /*** Creation methods**/
7632 IWineD3DDeviceImpl_CreateVertexBuffer,
7633 IWineD3DDeviceImpl_CreateIndexBuffer,
7634 IWineD3DDeviceImpl_CreateStateBlock,
7635 IWineD3DDeviceImpl_CreateSurface,
7636 IWineD3DDeviceImpl_CreateTexture,
7637 IWineD3DDeviceImpl_CreateVolumeTexture,
7638 IWineD3DDeviceImpl_CreateVolume,
7639 IWineD3DDeviceImpl_CreateCubeTexture,
7640 IWineD3DDeviceImpl_CreateQuery,
7641 IWineD3DDeviceImpl_CreateAdditionalSwapChain,
7642 IWineD3DDeviceImpl_CreateVertexDeclaration,
7643 IWineD3DDeviceImpl_CreateVertexDeclarationFromFVF,
7644 IWineD3DDeviceImpl_CreateVertexShader,
7645 IWineD3DDeviceImpl_CreatePixelShader,
7646 IWineD3DDeviceImpl_CreatePalette,
7647 /*** Odd functions **/
7648 IWineD3DDeviceImpl_Init3D,
7649 IWineD3DDeviceImpl_Uninit3D,
7650 IWineD3DDeviceImpl_SetFullscreen,
7651 IWineD3DDeviceImpl_SetMultithreaded,
7652 IWineD3DDeviceImpl_EvictManagedResources,
7653 IWineD3DDeviceImpl_GetAvailableTextureMem,
7654 IWineD3DDeviceImpl_GetBackBuffer,
7655 IWineD3DDeviceImpl_GetCreationParameters,
7656 IWineD3DDeviceImpl_GetDeviceCaps,
7657 IWineD3DDeviceImpl_GetDirect3D,
7658 IWineD3DDeviceImpl_GetDisplayMode,
7659 IWineD3DDeviceImpl_SetDisplayMode,
7660 IWineD3DDeviceImpl_GetHWND,
7661 IWineD3DDeviceImpl_SetHWND,
7662 IWineD3DDeviceImpl_GetNumberOfSwapChains,
7663 IWineD3DDeviceImpl_GetRasterStatus,
7664 IWineD3DDeviceImpl_GetSwapChain,
7665 IWineD3DDeviceImpl_Reset,
7666 IWineD3DDeviceImpl_SetDialogBoxMode,
7667 IWineD3DDeviceImpl_SetCursorProperties,
7668 IWineD3DDeviceImpl_SetCursorPosition,
7669 IWineD3DDeviceImpl_ShowCursor,
7670 IWineD3DDeviceImpl_TestCooperativeLevel,
7671 /*** Getters and setters **/
7672 IWineD3DDeviceImpl_SetClipPlane,
7673 IWineD3DDeviceImpl_GetClipPlane,
7674 IWineD3DDeviceImpl_SetClipStatus,
7675 IWineD3DDeviceImpl_GetClipStatus,
7676 IWineD3DDeviceImpl_SetCurrentTexturePalette,
7677 IWineD3DDeviceImpl_GetCurrentTexturePalette,
7678 IWineD3DDeviceImpl_SetDepthStencilSurface,
7679 IWineD3DDeviceImpl_GetDepthStencilSurface,
7680 IWineD3DDeviceImpl_SetFVF,
7681 IWineD3DDeviceImpl_GetFVF,
7682 IWineD3DDeviceImpl_SetGammaRamp,
7683 IWineD3DDeviceImpl_GetGammaRamp,
7684 IWineD3DDeviceImpl_SetIndices,
7685 IWineD3DDeviceImpl_GetIndices,
7686 IWineD3DDeviceImpl_SetBaseVertexIndex,
7687 IWineD3DDeviceImpl_GetBaseVertexIndex,
7688 IWineD3DDeviceImpl_SetLight,
7689 IWineD3DDeviceImpl_GetLight,
7690 IWineD3DDeviceImpl_SetLightEnable,
7691 IWineD3DDeviceImpl_GetLightEnable,
7692 IWineD3DDeviceImpl_SetMaterial,
7693 IWineD3DDeviceImpl_GetMaterial,
7694 IWineD3DDeviceImpl_SetNPatchMode,
7695 IWineD3DDeviceImpl_GetNPatchMode,
7696 IWineD3DDeviceImpl_SetPaletteEntries,
7697 IWineD3DDeviceImpl_GetPaletteEntries,
7698 IWineD3DDeviceImpl_SetPixelShader,
7699 IWineD3DDeviceImpl_GetPixelShader,
7700 IWineD3DDeviceImpl_SetPixelShaderConstantB,
7701 IWineD3DDeviceImpl_GetPixelShaderConstantB,
7702 IWineD3DDeviceImpl_SetPixelShaderConstantI,
7703 IWineD3DDeviceImpl_GetPixelShaderConstantI,
7704 IWineD3DDeviceImpl_SetPixelShaderConstantF_DirtyConst,
7705 IWineD3DDeviceImpl_GetPixelShaderConstantF,
7706 IWineD3DDeviceImpl_SetRenderState,
7707 IWineD3DDeviceImpl_GetRenderState,
7708 IWineD3DDeviceImpl_SetRenderTarget,
7709 IWineD3DDeviceImpl_GetRenderTarget,
7710 IWineD3DDeviceImpl_SetFrontBackBuffers,
7711 IWineD3DDeviceImpl_SetSamplerState,
7712 IWineD3DDeviceImpl_GetSamplerState,
7713 IWineD3DDeviceImpl_SetScissorRect,
7714 IWineD3DDeviceImpl_GetScissorRect,
7715 IWineD3DDeviceImpl_SetSoftwareVertexProcessing,
7716 IWineD3DDeviceImpl_GetSoftwareVertexProcessing,
7717 IWineD3DDeviceImpl_SetStreamSource,
7718 IWineD3DDeviceImpl_GetStreamSource,
7719 IWineD3DDeviceImpl_SetStreamSourceFreq,
7720 IWineD3DDeviceImpl_GetStreamSourceFreq,
7721 IWineD3DDeviceImpl_SetTexture,
7722 IWineD3DDeviceImpl_GetTexture,
7723 IWineD3DDeviceImpl_SetTextureStageState,
7724 IWineD3DDeviceImpl_GetTextureStageState,
7725 IWineD3DDeviceImpl_SetTransform,
7726 IWineD3DDeviceImpl_GetTransform,
7727 IWineD3DDeviceImpl_SetVertexDeclaration,
7728 IWineD3DDeviceImpl_GetVertexDeclaration,
7729 IWineD3DDeviceImpl_SetVertexShader,
7730 IWineD3DDeviceImpl_GetVertexShader,
7731 IWineD3DDeviceImpl_SetVertexShaderConstantB,
7732 IWineD3DDeviceImpl_GetVertexShaderConstantB,
7733 IWineD3DDeviceImpl_SetVertexShaderConstantI,
7734 IWineD3DDeviceImpl_GetVertexShaderConstantI,
7735 IWineD3DDeviceImpl_SetVertexShaderConstantF_DirtyConst,
7736 IWineD3DDeviceImpl_GetVertexShaderConstantF,
7737 IWineD3DDeviceImpl_SetViewport,
7738 IWineD3DDeviceImpl_GetViewport,
7739 IWineD3DDeviceImpl_MultiplyTransform,
7740 IWineD3DDeviceImpl_ValidateDevice,
7741 IWineD3DDeviceImpl_ProcessVertices,
7742 /*** State block ***/
7743 IWineD3DDeviceImpl_BeginStateBlock,
7744 IWineD3DDeviceImpl_EndStateBlock,
7745 /*** Scene management ***/
7746 IWineD3DDeviceImpl_BeginScene,
7747 IWineD3DDeviceImpl_EndScene,
7748 IWineD3DDeviceImpl_Present,
7749 IWineD3DDeviceImpl_Clear,
7750 /*** Drawing ***/
7751 IWineD3DDeviceImpl_DrawPrimitive,
7752 IWineD3DDeviceImpl_DrawIndexedPrimitive,
7753 IWineD3DDeviceImpl_DrawPrimitiveUP,
7754 IWineD3DDeviceImpl_DrawIndexedPrimitiveUP,
7755 IWineD3DDeviceImpl_DrawPrimitiveStrided,
7756 IWineD3DDeviceImpl_DrawIndexedPrimitiveStrided,
7757 IWineD3DDeviceImpl_DrawRectPatch,
7758 IWineD3DDeviceImpl_DrawTriPatch,
7759 IWineD3DDeviceImpl_DeletePatch,
7760 IWineD3DDeviceImpl_ColorFill,
7761 IWineD3DDeviceImpl_UpdateTexture,
7762 IWineD3DDeviceImpl_UpdateSurface,
7763 IWineD3DDeviceImpl_GetFrontBufferData,
7764 /*** object tracking ***/
7765 IWineD3DDeviceImpl_ResourceReleased,
7766 IWineD3DDeviceImpl_EnumResources
7767 };
7768
7769 const DWORD SavedPixelStates_R[NUM_SAVEDPIXELSTATES_R] = {
7770 WINED3DRS_ALPHABLENDENABLE ,
7771 WINED3DRS_ALPHAFUNC ,
7772 WINED3DRS_ALPHAREF ,
7773 WINED3DRS_ALPHATESTENABLE ,
7774 WINED3DRS_BLENDOP ,
7775 WINED3DRS_COLORWRITEENABLE ,
7776 WINED3DRS_DESTBLEND ,
7777 WINED3DRS_DITHERENABLE ,
7778 WINED3DRS_FILLMODE ,
7779 WINED3DRS_FOGDENSITY ,
7780 WINED3DRS_FOGEND ,
7781 WINED3DRS_FOGSTART ,
7782 WINED3DRS_LASTPIXEL ,
7783 WINED3DRS_SHADEMODE ,
7784 WINED3DRS_SRCBLEND ,
7785 WINED3DRS_STENCILENABLE ,
7786 WINED3DRS_STENCILFAIL ,
7787 WINED3DRS_STENCILFUNC ,
7788 WINED3DRS_STENCILMASK ,
7789 WINED3DRS_STENCILPASS ,
7790 WINED3DRS_STENCILREF ,
7791 WINED3DRS_STENCILWRITEMASK ,
7792 WINED3DRS_STENCILZFAIL ,
7793 WINED3DRS_TEXTUREFACTOR ,
7794 WINED3DRS_WRAP0 ,
7795 WINED3DRS_WRAP1 ,
7796 WINED3DRS_WRAP2 ,
7797 WINED3DRS_WRAP3 ,
7798 WINED3DRS_WRAP4 ,
7799 WINED3DRS_WRAP5 ,
7800 WINED3DRS_WRAP6 ,
7801 WINED3DRS_WRAP7 ,
7802 WINED3DRS_ZENABLE ,
7803 WINED3DRS_ZFUNC ,
7804 WINED3DRS_ZWRITEENABLE
7805 };
7806
7807 const DWORD SavedPixelStates_T[NUM_SAVEDPIXELSTATES_T] = {
7808 WINED3DTSS_ADDRESSW ,
7809 WINED3DTSS_ALPHAARG0 ,
7810 WINED3DTSS_ALPHAARG1 ,
7811 WINED3DTSS_ALPHAARG2 ,
7812 WINED3DTSS_ALPHAOP ,
7813 WINED3DTSS_BUMPENVLOFFSET ,
7814 WINED3DTSS_BUMPENVLSCALE ,
7815 WINED3DTSS_BUMPENVMAT00 ,
7816 WINED3DTSS_BUMPENVMAT01 ,
7817 WINED3DTSS_BUMPENVMAT10 ,
7818 WINED3DTSS_BUMPENVMAT11 ,
7819 WINED3DTSS_COLORARG0 ,
7820 WINED3DTSS_COLORARG1 ,
7821 WINED3DTSS_COLORARG2 ,
7822 WINED3DTSS_COLOROP ,
7823 WINED3DTSS_RESULTARG ,
7824 WINED3DTSS_TEXCOORDINDEX ,
7825 WINED3DTSS_TEXTURETRANSFORMFLAGS
7826 };
7827
7828 const DWORD SavedPixelStates_S[NUM_SAVEDPIXELSTATES_S] = {
7829 WINED3DSAMP_ADDRESSU ,
7830 WINED3DSAMP_ADDRESSV ,
7831 WINED3DSAMP_ADDRESSW ,
7832 WINED3DSAMP_BORDERCOLOR ,
7833 WINED3DSAMP_MAGFILTER ,
7834 WINED3DSAMP_MINFILTER ,
7835 WINED3DSAMP_MIPFILTER ,
7836 WINED3DSAMP_MIPMAPLODBIAS ,
7837 WINED3DSAMP_MAXMIPLEVEL ,
7838 WINED3DSAMP_MAXANISOTROPY ,
7839 WINED3DSAMP_SRGBTEXTURE ,
7840 WINED3DSAMP_ELEMENTINDEX
7841 };
7842
7843 const DWORD SavedVertexStates_R[NUM_SAVEDVERTEXSTATES_R] = {
7844 WINED3DRS_AMBIENT ,
7845 WINED3DRS_AMBIENTMATERIALSOURCE ,
7846 WINED3DRS_CLIPPING ,
7847 WINED3DRS_CLIPPLANEENABLE ,
7848 WINED3DRS_COLORVERTEX ,
7849 WINED3DRS_DIFFUSEMATERIALSOURCE ,
7850 WINED3DRS_EMISSIVEMATERIALSOURCE ,
7851 WINED3DRS_FOGDENSITY ,
7852 WINED3DRS_FOGEND ,
7853 WINED3DRS_FOGSTART ,
7854 WINED3DRS_FOGTABLEMODE ,
7855 WINED3DRS_FOGVERTEXMODE ,
7856 WINED3DRS_INDEXEDVERTEXBLENDENABLE ,
7857 WINED3DRS_LIGHTING ,
7858 WINED3DRS_LOCALVIEWER ,
7859 WINED3DRS_MULTISAMPLEANTIALIAS ,
7860 WINED3DRS_MULTISAMPLEMASK ,
7861 WINED3DRS_NORMALIZENORMALS ,
7862 WINED3DRS_PATCHEDGESTYLE ,
7863 WINED3DRS_POINTSCALE_A ,
7864 WINED3DRS_POINTSCALE_B ,
7865 WINED3DRS_POINTSCALE_C ,
7866 WINED3DRS_POINTSCALEENABLE ,
7867 WINED3DRS_POINTSIZE ,
7868 WINED3DRS_POINTSIZE_MAX ,
7869 WINED3DRS_POINTSIZE_MIN ,
7870 WINED3DRS_POINTSPRITEENABLE ,
7871 WINED3DRS_RANGEFOGENABLE ,
7872 WINED3DRS_SPECULARMATERIALSOURCE ,
7873 WINED3DRS_TWEENFACTOR ,
7874 WINED3DRS_VERTEXBLEND ,
7875 WINED3DRS_CULLMODE ,
7876 WINED3DRS_FOGCOLOR
7877 };
7878
7879 const DWORD SavedVertexStates_T[NUM_SAVEDVERTEXSTATES_T] = {
7880 WINED3DTSS_TEXCOORDINDEX ,
7881 WINED3DTSS_TEXTURETRANSFORMFLAGS
7882 };
7883
7884 const DWORD SavedVertexStates_S[NUM_SAVEDVERTEXSTATES_S] = {
7885 WINED3DSAMP_DMAPOFFSET
7886 };
7887
7888 void IWineD3DDeviceImpl_MarkStateDirty(IWineD3DDeviceImpl *This, DWORD state) {
7889 DWORD rep = This->shader_backend->StateTable[state].representative;
7890 DWORD idx;
7891 BYTE shift;
7892 UINT i;
7893 WineD3DContext *context;
7894
7895 if(!rep) return;
7896 for(i = 0; i < This->numContexts; i++) {
7897 context = This->contexts[i];
7898 if(isStateDirty(context, rep)) continue;
7899
7900 context->dirtyArray[context->numDirtyEntries++] = rep;
7901 idx = rep >> 5;
7902 shift = rep & 0x1f;
7903 context->isStateDirty[idx] |= (1 << shift);
7904 }
7905 }
7906
7907 void get_drawable_size_pbuffer(IWineD3DSurfaceImpl *This, UINT *width, UINT *height) {
7908 IWineD3DDeviceImpl *dev = This->resource.wineD3DDevice;
7909 /* The drawable size of a pbuffer render target is the current pbuffer size
7910 */
7911 *width = dev->pbufferWidth;
7912 *height = dev->pbufferHeight;
7913 }
7914
7915 void get_drawable_size_fbo(IWineD3DSurfaceImpl *This, UINT *width, UINT *height) {
7916 /* The drawable size of a fbo target is the opengl texture size, which is the power of two size
7917 */
7918 *width = This->pow2Width;
7919 *height = This->pow2Height;
7920 }
7921
7922 void get_drawable_size_backbuffer(IWineD3DSurfaceImpl *This, UINT *width, UINT *height) {
7923 IWineD3DDeviceImpl *dev = This->resource.wineD3DDevice;
7924 /* The drawable size of a backbuffer / aux buffer offscreen target is the size of the
7925 * current context's drawable, which is the size of the back buffer of the swapchain
7926 * the active context belongs to. The back buffer of the swapchain is stored as the
7927 * surface the context belongs to.
7928 */
7929 *width = ((IWineD3DSurfaceImpl *) dev->activeContext->surface)->currentDesc.Width;
7930 *height = ((IWineD3DSurfaceImpl *) dev->activeContext->surface)->currentDesc.Height;
7931 }
Windows API implementation