1019 lines
36 KiB
C
1019 lines
36 KiB
C
/* Direct3D Texture
|
|
* Copyright (c) 1998 Lionel ULMER
|
|
*
|
|
* This file contains the implementation of interface Direct3DTexture2.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <string.h>
|
|
|
|
#define NONAMELESSUNION
|
|
#define NONAMELESSSTRUCT
|
|
#include "windef.h"
|
|
#include "winerror.h"
|
|
#include "objbase.h"
|
|
#include "ddraw.h"
|
|
#include "d3d.h"
|
|
#include "wine/debug.h"
|
|
|
|
#include "mesa_private.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
|
|
|
|
/* Define this if you want to save to a file all the textures used by a game
|
|
(can be funny to see how they managed to cram all the pictures in
|
|
texture memory) */
|
|
#undef TEXTURE_SNOOP
|
|
|
|
#ifdef TEXTURE_SNOOP
|
|
#include <stdio.h>
|
|
|
|
static void
|
|
snoop_texture(IDirectDrawSurfaceImpl *This) {
|
|
IDirect3DTextureGLImpl *glThis = (IDirect3DTextureGLImpl *) This->tex_private;
|
|
char buf[128];
|
|
FILE *f;
|
|
|
|
sprintf(buf, "tex_%05d_%02d.pnm", glThis->tex_name, This->mipmap_level);
|
|
f = fopen(buf, "wb");
|
|
DDRAW_dump_surface_to_disk(This, f);
|
|
}
|
|
|
|
#else
|
|
|
|
#define snoop_texture(a)
|
|
|
|
#endif
|
|
|
|
static IDirectDrawSurfaceImpl *
|
|
get_sub_mimaplevel(IDirectDrawSurfaceImpl *tex_ptr)
|
|
{
|
|
/* Now go down the mipmap chain to the next surface */
|
|
static const DDSCAPS2 mipmap_caps = { DDSCAPS_MIPMAP | DDSCAPS_TEXTURE, 0, 0, 0 };
|
|
LPDIRECTDRAWSURFACE7 next_level;
|
|
IDirectDrawSurfaceImpl *surf_ptr;
|
|
HRESULT hr;
|
|
|
|
hr = IDirectDrawSurface7_GetAttachedSurface(ICOM_INTERFACE(tex_ptr, IDirectDrawSurface7),
|
|
(DDSCAPS2 *) &mipmap_caps, &next_level);
|
|
if (FAILED(hr)) return NULL;
|
|
|
|
surf_ptr = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, next_level);
|
|
IDirectDrawSurface7_Release(next_level);
|
|
|
|
return surf_ptr;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* IDirectSurface callback methods
|
|
*/
|
|
HRESULT
|
|
gltex_upload_texture(IDirectDrawSurfaceImpl *This) {
|
|
IDirect3DTextureGLImpl *glThis = (IDirect3DTextureGLImpl *) This->tex_private;
|
|
#if 0
|
|
static BOOL color_table_queried = FALSE;
|
|
#endif
|
|
static void (*ptr_ColorTableEXT) (GLenum target, GLenum internalformat,
|
|
GLsizei width, GLenum format, GLenum type, const GLvoid *table) = NULL;
|
|
IDirectDrawSurfaceImpl *surf_ptr;
|
|
GLuint tex_name = glThis->tex_name;
|
|
|
|
TRACE(" activating OpenGL texture id %d.\n", tex_name);
|
|
glBindTexture(GL_TEXTURE_2D, tex_name);
|
|
|
|
if (This->mipmap_level != 0) {
|
|
WARN(" application activating a sub-level of the mipmapping chain (level %d) !\n", This->mipmap_level);
|
|
}
|
|
|
|
surf_ptr = This;
|
|
while (surf_ptr != NULL) {
|
|
GLenum internal_format = GL_RGBA, format = GL_RGBA, pixel_format = GL_UNSIGNED_BYTE; /* This is only to prevent warnings.. */
|
|
VOID *surface = NULL;
|
|
DDSURFACEDESC *src_d = (DDSURFACEDESC *)&(surf_ptr->surface_desc);
|
|
IDirect3DTextureGLImpl *gl_surf_ptr = (IDirect3DTextureGLImpl *) surf_ptr->tex_private;
|
|
BOOL upload_done = FALSE;
|
|
BOOL error = FALSE;
|
|
|
|
if (gl_surf_ptr->dirty_flag == FALSE) {
|
|
TRACE(" - level %d already uploaded.\n", surf_ptr->mipmap_level);
|
|
} else {
|
|
TRACE(" - uploading texture level %d (initial done = %d).\n",
|
|
surf_ptr->mipmap_level, gl_surf_ptr->initial_upload_done);
|
|
|
|
/* Texture snooping for the curious :-) */
|
|
snoop_texture(surf_ptr);
|
|
|
|
if (src_d->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) {
|
|
/* ****************
|
|
Paletted Texture
|
|
**************** */
|
|
IDirectDrawPaletteImpl* pal = surf_ptr->palette;
|
|
BYTE table[256][4];
|
|
int i;
|
|
|
|
#if 0
|
|
if (color_table_queried == FALSE) {
|
|
ptr_ColorTableEXT =
|
|
((Mesa_DeviceCapabilities *) ((x11_dd_private *) surf_ptr->surface->s.ddraw->d->private)->device_capabilities)->ptr_ColorTableEXT;
|
|
}
|
|
#endif
|
|
|
|
if (pal == NULL) {
|
|
/* Upload a black texture. The real one will be uploaded on palette change */
|
|
WARN("Palettized texture Loading with a NULL palette !\n");
|
|
memset(table, 0, 256 * 4);
|
|
} else {
|
|
/* Get the surface's palette */
|
|
for (i = 0; i < 256; i++) {
|
|
table[i][0] = pal->palents[i].peRed;
|
|
table[i][1] = pal->palents[i].peGreen;
|
|
table[i][2] = pal->palents[i].peBlue;
|
|
if ((src_d->dwFlags & DDSD_CKSRCBLT) &&
|
|
(i >= src_d->ddckCKSrcBlt.dwColorSpaceLowValue) &&
|
|
(i <= src_d->ddckCKSrcBlt.dwColorSpaceHighValue))
|
|
/* We should maybe here put a more 'neutral' color than the standard bright purple
|
|
one often used by application to prevent the nice purple borders when bi-linear
|
|
filtering is on */
|
|
table[i][3] = 0x00;
|
|
else
|
|
table[i][3] = 0xFF;
|
|
}
|
|
}
|
|
|
|
if (ptr_ColorTableEXT != NULL) {
|
|
/* use Paletted Texture Extension */
|
|
ptr_ColorTableEXT(GL_TEXTURE_2D, /* target */
|
|
GL_RGBA, /* internal format */
|
|
256, /* table size */
|
|
GL_RGBA, /* table format */
|
|
GL_UNSIGNED_BYTE, /* table type */
|
|
table); /* the color table */
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, /* target */
|
|
surf_ptr->mipmap_level, /* level */
|
|
GL_COLOR_INDEX8_EXT, /* internal format */
|
|
src_d->dwWidth, src_d->dwHeight, /* width, height */
|
|
0, /* border */
|
|
GL_COLOR_INDEX, /* texture format */
|
|
GL_UNSIGNED_BYTE, /* texture type */
|
|
src_d->lpSurface); /* the texture */
|
|
|
|
upload_done = TRUE;
|
|
} else {
|
|
DWORD i;
|
|
BYTE *src = (BYTE *) src_d->lpSurface, *dst;
|
|
|
|
if (glThis->surface_ptr != NULL)
|
|
surface = glThis->surface_ptr;
|
|
else
|
|
surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, src_d->dwWidth * src_d->dwHeight * sizeof(DWORD));
|
|
dst = (BYTE *) surface;
|
|
|
|
for (i = 0; i < src_d->dwHeight * src_d->dwWidth; i++) {
|
|
BYTE color = *src++;
|
|
*dst++ = table[color][0];
|
|
*dst++ = table[color][1];
|
|
*dst++ = table[color][2];
|
|
*dst++ = table[color][3];
|
|
}
|
|
|
|
format = GL_RGBA;
|
|
internal_format = GL_RGBA;
|
|
pixel_format = GL_UNSIGNED_BYTE;
|
|
}
|
|
} else if (src_d->ddpfPixelFormat.dwFlags & DDPF_RGB) {
|
|
/* ************
|
|
RGB Textures
|
|
************ */
|
|
if (src_d->ddpfPixelFormat.u1.dwRGBBitCount == 8) {
|
|
if ((src_d->ddpfPixelFormat.u2.dwRBitMask == 0xE0) &&
|
|
(src_d->ddpfPixelFormat.u3.dwGBitMask == 0x1C) &&
|
|
(src_d->ddpfPixelFormat.u4.dwBBitMask == 0x03)) {
|
|
/* **********************
|
|
GL_UNSIGNED_BYTE_3_3_2
|
|
********************** */
|
|
if (src_d->dwFlags & DDSD_CKSRCBLT) {
|
|
/* This texture format will never be used.. So do not care about color keying
|
|
up until the point in time it will be needed :-) */
|
|
error = TRUE;
|
|
} else {
|
|
format = GL_RGB;
|
|
internal_format = GL_RGB;
|
|
pixel_format = GL_UNSIGNED_BYTE_3_3_2;
|
|
}
|
|
} else {
|
|
error = TRUE;
|
|
}
|
|
} else if (src_d->ddpfPixelFormat.u1.dwRGBBitCount == 16) {
|
|
if ((src_d->ddpfPixelFormat.u2.dwRBitMask == 0xF800) &&
|
|
(src_d->ddpfPixelFormat.u3.dwGBitMask == 0x07E0) &&
|
|
(src_d->ddpfPixelFormat.u4.dwBBitMask == 0x001F) &&
|
|
(src_d->ddpfPixelFormat.u5.dwRGBAlphaBitMask == 0x0000)) {
|
|
if (src_d->dwFlags & DDSD_CKSRCBLT) {
|
|
/* Converting the 565 format in 5551 packed to emulate color-keying.
|
|
|
|
Note : in all these conversion, it would be best to average the averaging
|
|
pixels to get the color of the pixel that will be color-keyed to
|
|
prevent 'color bleeding'. This will be done later on if ever it is
|
|
too visible.
|
|
|
|
Note2: when using color-keying + alpha, are the alpha bits part of the
|
|
color-space or not ?
|
|
*/
|
|
DWORD i;
|
|
WORD *src = (WORD *) src_d->lpSurface, *dst;
|
|
|
|
if (glThis->surface_ptr != NULL)
|
|
surface = glThis->surface_ptr;
|
|
else
|
|
surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
src_d->dwWidth * src_d->dwHeight * sizeof(WORD));
|
|
dst = (WORD *) surface;
|
|
for (i = 0; i < src_d->dwHeight * src_d->dwWidth; i++) {
|
|
WORD color = *src++;
|
|
*dst = ((color & 0xFFC0) | ((color & 0x1F) << 1));
|
|
if ((color < src_d->ddckCKSrcBlt.dwColorSpaceLowValue) ||
|
|
(color > src_d->ddckCKSrcBlt.dwColorSpaceHighValue))
|
|
*dst |= 0x0001;
|
|
dst++;
|
|
}
|
|
|
|
format = GL_RGBA;
|
|
internal_format = GL_RGBA;
|
|
pixel_format = GL_UNSIGNED_SHORT_5_5_5_1;
|
|
} else {
|
|
format = GL_RGB;
|
|
internal_format = GL_RGB;
|
|
pixel_format = GL_UNSIGNED_SHORT_5_6_5;
|
|
}
|
|
} else if ((src_d->ddpfPixelFormat.u2.dwRBitMask == 0xF800) &&
|
|
(src_d->ddpfPixelFormat.u3.dwGBitMask == 0x07C0) &&
|
|
(src_d->ddpfPixelFormat.u4.dwBBitMask == 0x003E) &&
|
|
(src_d->ddpfPixelFormat.u5.dwRGBAlphaBitMask == 0x0001)) {
|
|
format = GL_RGBA;
|
|
internal_format = GL_RGBA;
|
|
pixel_format = GL_UNSIGNED_SHORT_5_5_5_1;
|
|
if (src_d->dwFlags & DDSD_CKSRCBLT) {
|
|
/* Change the alpha value of the color-keyed pixels to emulate color-keying. */
|
|
DWORD i;
|
|
WORD *src = (WORD *) src_d->lpSurface, *dst;
|
|
|
|
if (glThis->surface_ptr != NULL)
|
|
surface = glThis->surface_ptr;
|
|
else
|
|
surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
src_d->dwWidth * src_d->dwHeight * sizeof(WORD));
|
|
dst = (WORD *) surface;
|
|
for (i = 0; i < src_d->dwHeight * src_d->dwWidth; i++) {
|
|
WORD color = *src++;
|
|
*dst = color & 0xFFFE;
|
|
if ((color < src_d->ddckCKSrcBlt.dwColorSpaceLowValue) ||
|
|
(color > src_d->ddckCKSrcBlt.dwColorSpaceHighValue))
|
|
*dst |= color & 0x0001;
|
|
dst++;
|
|
}
|
|
}
|
|
} else if ((src_d->ddpfPixelFormat.u2.dwRBitMask == 0xF000) &&
|
|
(src_d->ddpfPixelFormat.u3.dwGBitMask == 0x0F00) &&
|
|
(src_d->ddpfPixelFormat.u4.dwBBitMask == 0x00F0) &&
|
|
(src_d->ddpfPixelFormat.u5.dwRGBAlphaBitMask == 0x000F)) {
|
|
format = GL_RGBA;
|
|
internal_format = GL_RGBA;
|
|
pixel_format = GL_UNSIGNED_SHORT_4_4_4_4;
|
|
if (src_d->dwFlags & DDSD_CKSRCBLT) {
|
|
/* Change the alpha value of the color-keyed pixels to emulate color-keying. */
|
|
DWORD i;
|
|
WORD *src = (WORD *) src_d->lpSurface, *dst;
|
|
|
|
if (glThis->surface_ptr != NULL)
|
|
surface = glThis->surface_ptr;
|
|
else
|
|
surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
src_d->dwWidth * src_d->dwHeight * sizeof(WORD));
|
|
dst = (WORD *) surface;
|
|
for (i = 0; i < src_d->dwHeight * src_d->dwWidth; i++) {
|
|
WORD color = *src++;
|
|
*dst = color & 0xFFF0;
|
|
if ((color < src_d->ddckCKSrcBlt.dwColorSpaceLowValue) ||
|
|
(color > src_d->ddckCKSrcBlt.dwColorSpaceHighValue))
|
|
*dst |= color & 0x000F;
|
|
dst++;
|
|
}
|
|
}
|
|
} else if ((src_d->ddpfPixelFormat.u2.dwRBitMask == 0x0F00) &&
|
|
(src_d->ddpfPixelFormat.u3.dwGBitMask == 0x00F0) &&
|
|
(src_d->ddpfPixelFormat.u4.dwBBitMask == 0x000F) &&
|
|
(src_d->ddpfPixelFormat.u5.dwRGBAlphaBitMask == 0xF000)) {
|
|
/* Move the four Alpha bits... */
|
|
if (src_d->dwFlags & DDSD_CKSRCBLT) {
|
|
DWORD i;
|
|
WORD *src = (WORD *) src_d->lpSurface, *dst;
|
|
|
|
if (glThis->surface_ptr != NULL)
|
|
surface = glThis->surface_ptr;
|
|
else
|
|
surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
src_d->dwWidth * src_d->dwHeight * sizeof(WORD));
|
|
dst = surface;
|
|
|
|
for (i = 0; i < src_d->dwHeight * src_d->dwWidth; i++) {
|
|
WORD color = *src++;
|
|
*dst = (color & 0x0FFF) << 4;
|
|
if ((color < src_d->ddckCKSrcBlt.dwColorSpaceLowValue) ||
|
|
(color > src_d->ddckCKSrcBlt.dwColorSpaceHighValue))
|
|
*dst |= (color & 0xF000) >> 12;
|
|
dst++;
|
|
}
|
|
format = GL_RGBA;
|
|
internal_format = GL_RGBA;
|
|
pixel_format = GL_UNSIGNED_SHORT_4_4_4_4;
|
|
} else {
|
|
format = GL_BGRA;
|
|
internal_format = GL_RGBA;
|
|
pixel_format = GL_UNSIGNED_SHORT_4_4_4_4_REV;
|
|
}
|
|
} else if ((src_d->ddpfPixelFormat.u2.dwRBitMask == 0x7C00) &&
|
|
(src_d->ddpfPixelFormat.u3.dwGBitMask == 0x03E0) &&
|
|
(src_d->ddpfPixelFormat.u4.dwBBitMask == 0x001F) &&
|
|
(src_d->ddpfPixelFormat.u5.dwRGBAlphaBitMask == 0x8000)) {
|
|
if (src_d->dwFlags & DDSD_CKSRCBLT) {
|
|
DWORD i;
|
|
WORD *src = (WORD *) src_d->lpSurface, *dst;
|
|
|
|
if (glThis->surface_ptr != NULL)
|
|
surface = glThis->surface_ptr;
|
|
else
|
|
surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
src_d->dwWidth * src_d->dwHeight * sizeof(WORD));
|
|
dst = (WORD *) surface;
|
|
|
|
for (i = 0; i < src_d->dwHeight * src_d->dwWidth; i++) {
|
|
WORD color = *src++;
|
|
*dst = (color & 0x7FFF) << 1;
|
|
if ((color < src_d->ddckCKSrcBlt.dwColorSpaceLowValue) ||
|
|
(color > src_d->ddckCKSrcBlt.dwColorSpaceHighValue))
|
|
*dst |= (color & 0x8000) >> 15;
|
|
dst++;
|
|
}
|
|
format = GL_RGBA;
|
|
internal_format = GL_RGBA;
|
|
pixel_format = GL_UNSIGNED_SHORT_5_5_5_1;
|
|
} else {
|
|
format = GL_BGRA;
|
|
internal_format = GL_RGBA;
|
|
pixel_format = GL_UNSIGNED_SHORT_1_5_5_5_REV;
|
|
}
|
|
} else if ((src_d->ddpfPixelFormat.u2.dwRBitMask == 0x7C00) &&
|
|
(src_d->ddpfPixelFormat.u3.dwGBitMask == 0x03E0) &&
|
|
(src_d->ddpfPixelFormat.u4.dwBBitMask == 0x001F) &&
|
|
(src_d->ddpfPixelFormat.u5.dwRGBAlphaBitMask == 0x0000)) {
|
|
/* Converting the 0555 format in 5551 packed */
|
|
DWORD i;
|
|
WORD *src = (WORD *) src_d->lpSurface, *dst;
|
|
|
|
if (glThis->surface_ptr != NULL)
|
|
surface = glThis->surface_ptr;
|
|
else
|
|
surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
src_d->dwWidth * src_d->dwHeight * sizeof(WORD));
|
|
dst = (WORD *) surface;
|
|
|
|
if (src_d->dwFlags & DDSD_CKSRCBLT) {
|
|
for (i = 0; i < src_d->dwHeight * src_d->dwWidth; i++) {
|
|
WORD color = *src++;
|
|
*dst = (color & 0x7FFF) << 1;
|
|
if ((color < src_d->ddckCKSrcBlt.dwColorSpaceLowValue) ||
|
|
(color > src_d->ddckCKSrcBlt.dwColorSpaceHighValue))
|
|
*dst |= 0x0001;
|
|
dst++;
|
|
}
|
|
} else {
|
|
for (i = 0; i < src_d->dwHeight * src_d->dwWidth; i++) {
|
|
WORD color = *src++;
|
|
*dst++ = ((color & 0x7FFF) << 1) | 0x0001;
|
|
}
|
|
}
|
|
|
|
format = GL_RGBA;
|
|
internal_format = GL_RGBA;
|
|
pixel_format = GL_UNSIGNED_SHORT_5_5_5_1;
|
|
} else {
|
|
error = TRUE;
|
|
}
|
|
} else if (src_d->ddpfPixelFormat.u1.dwRGBBitCount == 24) {
|
|
if ((src_d->ddpfPixelFormat.u2.dwRBitMask == 0x00FF0000) &&
|
|
(src_d->ddpfPixelFormat.u3.dwGBitMask == 0x0000FF00) &&
|
|
(src_d->ddpfPixelFormat.u4.dwBBitMask == 0x000000FF) &&
|
|
(src_d->ddpfPixelFormat.u5.dwRGBAlphaBitMask == 0x00000000)) {
|
|
if (src_d->dwFlags & DDSD_CKSRCBLT) {
|
|
/* This is a pain :-) */
|
|
DWORD i;
|
|
BYTE *src = (BYTE *) src_d->lpSurface;
|
|
DWORD *dst;
|
|
|
|
if (glThis->surface_ptr != NULL)
|
|
surface = glThis->surface_ptr;
|
|
else
|
|
surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
src_d->dwWidth * src_d->dwHeight * sizeof(DWORD));
|
|
dst = (DWORD *) surface;
|
|
for (i = 0; i < src_d->dwHeight * src_d->dwWidth; i++) {
|
|
DWORD color = *((DWORD *) src) & 0x00FFFFFF;
|
|
src += 3;
|
|
*dst = *src++ << 8;
|
|
if ((color < src_d->ddckCKSrcBlt.dwColorSpaceLowValue) ||
|
|
(color > src_d->ddckCKSrcBlt.dwColorSpaceHighValue))
|
|
*dst |= 0xFF;
|
|
dst++;
|
|
}
|
|
format = GL_RGBA;
|
|
internal_format = GL_RGBA;
|
|
pixel_format = GL_UNSIGNED_INT_8_8_8_8;
|
|
} else {
|
|
format = GL_BGR;
|
|
internal_format = GL_RGB;
|
|
pixel_format = GL_UNSIGNED_BYTE;
|
|
}
|
|
} else {
|
|
error = TRUE;
|
|
}
|
|
} else if (src_d->ddpfPixelFormat.u1.dwRGBBitCount == 32) {
|
|
if ((src_d->ddpfPixelFormat.u2.dwRBitMask == 0xFF000000) &&
|
|
(src_d->ddpfPixelFormat.u3.dwGBitMask == 0x00FF0000) &&
|
|
(src_d->ddpfPixelFormat.u4.dwBBitMask == 0x0000FF00) &&
|
|
(src_d->ddpfPixelFormat.u5.dwRGBAlphaBitMask == 0x000000FF)) {
|
|
if (src_d->dwFlags & DDSD_CKSRCBLT) {
|
|
/* Just use the alpha component to handle color-keying... */
|
|
DWORD i;
|
|
DWORD *src = (DWORD *) src_d->lpSurface, *dst;
|
|
|
|
if (glThis->surface_ptr != NULL)
|
|
surface = glThis->surface_ptr;
|
|
else
|
|
surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
src_d->dwWidth * src_d->dwHeight * sizeof(DWORD));
|
|
|
|
dst = (DWORD *) surface;
|
|
for (i = 0; i < src_d->dwHeight * src_d->dwWidth; i++) {
|
|
DWORD color = *src++;
|
|
*dst = color & 0xFFFFFF00;
|
|
if ((color < src_d->ddckCKSrcBlt.dwColorSpaceLowValue) ||
|
|
(color > src_d->ddckCKSrcBlt.dwColorSpaceHighValue))
|
|
*dst |= color & 0x000000FF;
|
|
dst++;
|
|
}
|
|
}
|
|
format = GL_RGBA;
|
|
internal_format = GL_RGBA;
|
|
pixel_format = GL_UNSIGNED_INT_8_8_8_8;
|
|
} else if ((src_d->ddpfPixelFormat.u2.dwRBitMask == 0x00FF0000) &&
|
|
(src_d->ddpfPixelFormat.u3.dwGBitMask == 0x0000FF00) &&
|
|
(src_d->ddpfPixelFormat.u4.dwBBitMask == 0x000000FF) &&
|
|
(src_d->ddpfPixelFormat.u5.dwRGBAlphaBitMask == 0xFF000000)) {
|
|
if (src_d->dwFlags & DDSD_CKSRCBLT) {
|
|
DWORD i;
|
|
DWORD *src = (DWORD *) src_d->lpSurface, *dst;
|
|
|
|
if (glThis->surface_ptr != NULL)
|
|
surface = glThis->surface_ptr;
|
|
else
|
|
surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, src_d->dwWidth * src_d->dwHeight * sizeof(DWORD));
|
|
|
|
dst = (DWORD *) surface;
|
|
for (i = 0; i < src_d->dwHeight * src_d->dwWidth; i++) {
|
|
DWORD color = *src++;
|
|
*dst = (color & 0x00FFFFFF) << 8;
|
|
if ((color < src_d->ddckCKSrcBlt.dwColorSpaceLowValue) ||
|
|
(color > src_d->ddckCKSrcBlt.dwColorSpaceHighValue))
|
|
*dst |= (color & 0xFF000000) >> 24;
|
|
dst++;
|
|
}
|
|
format = GL_RGBA;
|
|
internal_format = GL_RGBA;
|
|
pixel_format = GL_UNSIGNED_INT_8_8_8_8;
|
|
} else {
|
|
format = GL_BGRA;
|
|
internal_format = GL_RGBA;
|
|
pixel_format = GL_UNSIGNED_INT_8_8_8_8_REV;
|
|
}
|
|
} else if ((src_d->ddpfPixelFormat.u2.dwRBitMask == 0x00FF0000) &&
|
|
(src_d->ddpfPixelFormat.u3.dwGBitMask == 0x0000FF00) &&
|
|
(src_d->ddpfPixelFormat.u4.dwBBitMask == 0x000000FF) &&
|
|
(src_d->ddpfPixelFormat.u5.dwRGBAlphaBitMask == 0x00000000)) {
|
|
/* Just add an alpha component and handle color-keying... */
|
|
DWORD i;
|
|
DWORD *src = (DWORD *) src_d->lpSurface, *dst;
|
|
|
|
if (glThis->surface_ptr != NULL)
|
|
surface = glThis->surface_ptr;
|
|
else
|
|
surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, src_d->dwWidth * src_d->dwHeight * sizeof(DWORD));
|
|
dst = (DWORD *) surface;
|
|
|
|
if (src_d->dwFlags & DDSD_CKSRCBLT) {
|
|
for (i = 0; i < src_d->dwHeight * src_d->dwWidth; i++) {
|
|
DWORD color = *src++;
|
|
*dst = color << 8;
|
|
if ((color < src_d->ddckCKSrcBlt.dwColorSpaceLowValue) ||
|
|
(color > src_d->ddckCKSrcBlt.dwColorSpaceHighValue))
|
|
*dst |= 0xFF;
|
|
dst++;
|
|
}
|
|
} else {
|
|
for (i = 0; i < src_d->dwHeight * src_d->dwWidth; i++) {
|
|
*dst++ = (*src++ << 8) | 0xFF;
|
|
}
|
|
}
|
|
format = GL_RGBA;
|
|
internal_format = GL_RGBA;
|
|
pixel_format = GL_UNSIGNED_INT_8_8_8_8;
|
|
} else {
|
|
error = TRUE;
|
|
}
|
|
} else {
|
|
error = TRUE;
|
|
}
|
|
} else {
|
|
error = TRUE;
|
|
}
|
|
|
|
if ((upload_done == FALSE) && (error == FALSE)) {
|
|
if (gl_surf_ptr->initial_upload_done == FALSE) {
|
|
glTexImage2D(GL_TEXTURE_2D,
|
|
surf_ptr->mipmap_level,
|
|
internal_format,
|
|
src_d->dwWidth, src_d->dwHeight,
|
|
0,
|
|
format,
|
|
pixel_format,
|
|
surface == NULL ? src_d->lpSurface : surface);
|
|
gl_surf_ptr->initial_upload_done = TRUE;
|
|
} else {
|
|
glTexSubImage2D(GL_TEXTURE_2D,
|
|
surf_ptr->mipmap_level,
|
|
0, 0,
|
|
src_d->dwWidth, src_d->dwHeight,
|
|
format,
|
|
pixel_format,
|
|
surface == NULL ? src_d->lpSurface : surface);
|
|
}
|
|
gl_surf_ptr->dirty_flag = FALSE;
|
|
|
|
/* And store the surface pointer for future reuse.. */
|
|
if (surface)
|
|
glThis->surface_ptr = surface;
|
|
} else if (error == TRUE) {
|
|
if (ERR_ON(ddraw)) {
|
|
ERR(" unsupported pixel format for textures : \n");
|
|
DDRAW_dump_pixelformat(&src_d->ddpfPixelFormat);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (surf_ptr->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP) {
|
|
surf_ptr = get_sub_mimaplevel(surf_ptr);
|
|
} else {
|
|
surf_ptr = NULL;
|
|
}
|
|
}
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_IDirect3DTextureImpl_1_Initialize(LPDIRECT3DTEXTURE iface,
|
|
LPDIRECT3DDEVICE lpDirect3DDevice,
|
|
LPDIRECTDRAWSURFACE lpDDSurface)
|
|
{
|
|
ICOM_THIS_FROM(IDirectDrawSurfaceImpl, IDirect3DTexture, iface);
|
|
FIXME("(%p/%p)->(%p,%p) no-op...\n", This, iface, lpDirect3DDevice, lpDDSurface);
|
|
return DD_OK;
|
|
}
|
|
|
|
static HRESULT
|
|
gltex_setcolorkey_cb(IDirectDrawSurfaceImpl *This, DWORD dwFlags, LPDDCOLORKEY ckey )
|
|
{
|
|
IDirect3DTextureGLImpl *glThis = (IDirect3DTextureGLImpl *) This->tex_private;
|
|
|
|
glThis->dirty_flag = TRUE;
|
|
/* TODO: check color-keying on mipmapped surfaces... */
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_IDirect3DTextureImpl_2_1T_PaletteChanged(LPDIRECT3DTEXTURE2 iface,
|
|
DWORD dwStart,
|
|
DWORD dwCount)
|
|
{
|
|
ICOM_THIS_FROM(IDirectDrawSurfaceImpl, IDirect3DTexture2, iface);
|
|
FIXME("(%p/%p)->(%08lx,%08lx): stub!\n", This, iface, dwStart, dwCount);
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_IDirect3DTextureImpl_1_Unload(LPDIRECT3DTEXTURE iface)
|
|
{
|
|
ICOM_THIS_FROM(IDirectDrawSurfaceImpl, IDirect3DTexture, iface);
|
|
FIXME("(%p/%p)->(): stub!\n", This, iface);
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_IDirect3DTextureImpl_2_1T_GetHandle(LPDIRECT3DTEXTURE2 iface,
|
|
LPDIRECT3DDEVICE2 lpDirect3DDevice2,
|
|
LPD3DTEXTUREHANDLE lpHandle)
|
|
{
|
|
ICOM_THIS_FROM(IDirectDrawSurfaceImpl, IDirect3DTexture2, iface);
|
|
IDirect3DDeviceImpl *lpDeviceImpl = ICOM_OBJECT(IDirect3DDeviceImpl, IDirect3DDevice2, lpDirect3DDevice2);
|
|
|
|
TRACE("(%p/%p)->(%p,%p)\n", This, iface, lpDirect3DDevice2, lpHandle);
|
|
|
|
/* The handle is simply the pointer to the implementation structure */
|
|
*lpHandle = (D3DTEXTUREHANDLE) This;
|
|
|
|
TRACE(" returning handle %08lx.\n", *lpHandle);
|
|
|
|
/* Now set the device for this texture */
|
|
This->d3ddevice = lpDeviceImpl;
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_IDirect3DTextureImpl_2_1T_Load(LPDIRECT3DTEXTURE2 iface,
|
|
LPDIRECT3DTEXTURE2 lpD3DTexture2)
|
|
{
|
|
ICOM_THIS_FROM(IDirectDrawSurfaceImpl, IDirect3DTexture2, iface);
|
|
FIXME("(%p/%p)->(%p): stub!\n", This, iface, lpD3DTexture2);
|
|
return DD_OK;
|
|
}
|
|
|
|
static void gltex_set_palette(IDirectDrawSurfaceImpl* This, IDirectDrawPaletteImpl* pal)
|
|
{
|
|
IDirect3DTextureGLImpl *glThis = (IDirect3DTextureGLImpl *) This->tex_private;
|
|
|
|
/* First call the previous set_palette function */
|
|
glThis->set_palette(This, pal);
|
|
|
|
/* And set the dirty flag */
|
|
glThis->dirty_flag = TRUE;
|
|
|
|
/* TODO: check palette on mipmapped surfaces... */
|
|
}
|
|
|
|
static void
|
|
gltex_final_release(IDirectDrawSurfaceImpl *This)
|
|
{
|
|
IDirect3DTextureGLImpl *glThis = (IDirect3DTextureGLImpl *) This->tex_private;
|
|
DWORD mem_used;
|
|
int i;
|
|
|
|
TRACE(" deleting texture with GL id %d.\n", glThis->tex_name);
|
|
|
|
/* And delete texture handle */
|
|
ENTER_GL();
|
|
if (glThis->tex_name != 0)
|
|
glDeleteTextures(1, &(glThis->tex_name));
|
|
LEAVE_GL();
|
|
|
|
if (glThis->surface_ptr != NULL)
|
|
HeapFree(GetProcessHeap(), 0, glThis->surface_ptr);
|
|
|
|
/* And if this texture was the current one, remove it at the device level */
|
|
if (This->d3ddevice != NULL)
|
|
for (i = 0; i < MAX_TEXTURES; i++)
|
|
if (This->d3ddevice->current_texture[i] == This)
|
|
This->d3ddevice->current_texture[i] = NULL;
|
|
|
|
/* All this should be part of main surface management not just a hack for texture.. */
|
|
if (glThis->loaded) {
|
|
mem_used = This->surface_desc.dwHeight *
|
|
This->surface_desc.u1.lPitch;
|
|
This->ddraw_owner->free_memory(This->ddraw_owner, mem_used);
|
|
}
|
|
|
|
glThis->final_release(This);
|
|
}
|
|
|
|
static void
|
|
gltex_lock_update(IDirectDrawSurfaceImpl* This, LPCRECT pRect, DWORD dwFlags)
|
|
{
|
|
IDirect3DTextureGLImpl *glThis = (IDirect3DTextureGLImpl *) This->tex_private;
|
|
|
|
glThis->lock_update(This, pRect, dwFlags);
|
|
}
|
|
|
|
static void
|
|
gltex_unlock_update(IDirectDrawSurfaceImpl* This, LPCRECT pRect)
|
|
{
|
|
IDirect3DTextureGLImpl *glThis = (IDirect3DTextureGLImpl *) This->tex_private;
|
|
|
|
glThis->unlock_update(This, pRect);
|
|
|
|
/* Set the dirty flag according to the lock type */
|
|
if ((This->lastlocktype & DDLOCK_READONLY) == 0)
|
|
glThis->dirty_flag = TRUE;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
GL_IDirect3DTextureImpl_2_1T_Load(LPDIRECT3DTEXTURE2 iface,
|
|
LPDIRECT3DTEXTURE2 lpD3DTexture2)
|
|
{
|
|
ICOM_THIS_FROM(IDirectDrawSurfaceImpl, IDirect3DTexture2, iface);
|
|
IDirectDrawSurfaceImpl *src_ptr = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirect3DTexture2, lpD3DTexture2);
|
|
IDirectDrawSurfaceImpl *dst_ptr = This;
|
|
HRESULT ret_value = D3D_OK;
|
|
|
|
TRACE("(%p/%p)->(%p)\n", This, iface, lpD3DTexture2);
|
|
|
|
if (((src_ptr->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP) != (dst_ptr->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP)) ||
|
|
(src_ptr->surface_desc.u2.dwMipMapCount != dst_ptr->surface_desc.u2.dwMipMapCount)) {
|
|
ERR("Trying to load surfaces with different mip-map counts !\n");
|
|
}
|
|
|
|
/* Now loop through all mipmap levels and load all of them... */
|
|
while (1) {
|
|
IDirect3DTextureGLImpl *gl_dst_ptr = (IDirect3DTextureGLImpl *) dst_ptr->tex_private;
|
|
DDSURFACEDESC *src_d, *dst_d;
|
|
|
|
if (gl_dst_ptr != NULL) {
|
|
if (gl_dst_ptr->loaded == FALSE) {
|
|
/* Only check memory for not already loaded texture... */
|
|
DWORD mem_used = dst_ptr->surface_desc.dwHeight * dst_ptr->surface_desc.u1.lPitch;
|
|
if (This->ddraw_owner->allocate_memory(This->ddraw_owner, mem_used) < 0) {
|
|
TRACE(" out of virtual memory... Warning application.\n");
|
|
return D3DERR_TEXTURE_LOAD_FAILED;
|
|
}
|
|
}
|
|
gl_dst_ptr->loaded = TRUE;
|
|
}
|
|
|
|
TRACE(" copying surface %p to surface %p (mipmap level %d)\n", src_ptr, dst_ptr, src_ptr->mipmap_level);
|
|
|
|
if ( dst_ptr->surface_desc.ddsCaps.dwCaps & DDSCAPS_ALLOCONLOAD )
|
|
/* If the surface is not allocated and its location is not yet specified,
|
|
force it to video memory */
|
|
if ( !(dst_ptr->surface_desc.ddsCaps.dwCaps & (DDSCAPS_SYSTEMMEMORY|DDSCAPS_VIDEOMEMORY)) )
|
|
dst_ptr->surface_desc.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
|
|
|
|
/* Suppress the ALLOCONLOAD flag */
|
|
dst_ptr->surface_desc.ddsCaps.dwCaps &= ~DDSCAPS_ALLOCONLOAD;
|
|
|
|
/* After seeing some logs, not sure at all about this... */
|
|
if (dst_ptr->palette == NULL) {
|
|
dst_ptr->palette = src_ptr->palette;
|
|
if (src_ptr->palette != NULL) IDirectDrawPalette_AddRef(ICOM_INTERFACE(src_ptr->palette, IDirectDrawPalette));
|
|
} else {
|
|
if (src_ptr->palette != NULL) {
|
|
PALETTEENTRY palent[256];
|
|
IDirectDrawPalette_GetEntries(ICOM_INTERFACE(src_ptr->palette, IDirectDrawPalette),
|
|
0, 0, 256, palent);
|
|
IDirectDrawPalette_SetEntries(ICOM_INTERFACE(dst_ptr->palette, IDirectDrawPalette),
|
|
0, 0, 256, palent);
|
|
}
|
|
}
|
|
|
|
/* Copy one surface on the other */
|
|
dst_d = (DDSURFACEDESC *)&(dst_ptr->surface_desc);
|
|
src_d = (DDSURFACEDESC *)&(src_ptr->surface_desc);
|
|
|
|
if ((src_d->dwWidth != dst_d->dwWidth) || (src_d->dwHeight != dst_d->dwHeight)) {
|
|
/* Should also check for same pixel format, u1.lPitch, ... */
|
|
ERR("Error in surface sizes\n");
|
|
return D3DERR_TEXTURE_LOAD_FAILED;
|
|
} else {
|
|
/* LPDIRECT3DDEVICE2 d3dd = (LPDIRECT3DDEVICE2) This->D3Ddevice; */
|
|
/* I should put a macro for the calculus of bpp */
|
|
|
|
/* Copy also the ColorKeying stuff */
|
|
if (src_d->dwFlags & DDSD_CKSRCBLT) {
|
|
dst_d->dwFlags |= DDSD_CKSRCBLT;
|
|
dst_d->ddckCKSrcBlt.dwColorSpaceLowValue = src_d->ddckCKSrcBlt.dwColorSpaceLowValue;
|
|
dst_d->ddckCKSrcBlt.dwColorSpaceHighValue = src_d->ddckCKSrcBlt.dwColorSpaceHighValue;
|
|
}
|
|
|
|
/* Copy the main memory texture into the surface that corresponds to the OpenGL
|
|
texture object. */
|
|
memcpy(dst_d->lpSurface, src_d->lpSurface, src_d->u1.lPitch * src_d->dwHeight);
|
|
|
|
if (gl_dst_ptr != NULL) {
|
|
/* If the GetHandle was not done, it is an error... */
|
|
if (gl_dst_ptr->tex_name == 0) ERR("Unbound GL texture !!!\n");
|
|
|
|
/* Set this texture as dirty */
|
|
gl_dst_ptr->dirty_flag = TRUE;
|
|
}
|
|
}
|
|
|
|
if (src_ptr->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP) {
|
|
src_ptr = get_sub_mimaplevel(src_ptr);
|
|
} else {
|
|
src_ptr = NULL;
|
|
}
|
|
if (dst_ptr->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP) {
|
|
dst_ptr = get_sub_mimaplevel(dst_ptr);
|
|
} else {
|
|
dst_ptr = NULL;
|
|
}
|
|
|
|
if ((src_ptr == NULL) || (dst_ptr == NULL)) {
|
|
if (src_ptr != dst_ptr) {
|
|
ERR(" Loading surface with different mipmap structure !!!\n");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ret_value;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Thunk_IDirect3DTextureImpl_2_QueryInterface(LPDIRECT3DTEXTURE2 iface,
|
|
REFIID riid,
|
|
LPVOID* obp)
|
|
{
|
|
TRACE("(%p)->(%s,%p) thunking to IDirectDrawSurface7 interface.\n", iface, debugstr_guid(riid), obp);
|
|
return IDirectDrawSurface7_QueryInterface(COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirect3DTexture2, IDirectDrawSurface7, iface),
|
|
riid,
|
|
obp);
|
|
}
|
|
|
|
ULONG WINAPI
|
|
Thunk_IDirect3DTextureImpl_2_AddRef(LPDIRECT3DTEXTURE2 iface)
|
|
{
|
|
TRACE("(%p)->() thunking to IDirectDrawSurface7 interface.\n", iface);
|
|
return IDirectDrawSurface7_AddRef(COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirect3DTexture2, IDirectDrawSurface7, iface));
|
|
}
|
|
|
|
ULONG WINAPI
|
|
Thunk_IDirect3DTextureImpl_2_Release(LPDIRECT3DTEXTURE2 iface)
|
|
{
|
|
TRACE("(%p)->() thunking to IDirectDrawSurface7 interface.\n", iface);
|
|
return IDirectDrawSurface7_Release(COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirect3DTexture2, IDirectDrawSurface7, iface));
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Thunk_IDirect3DTextureImpl_1_QueryInterface(LPDIRECT3DTEXTURE iface,
|
|
REFIID riid,
|
|
LPVOID* obp)
|
|
{
|
|
TRACE("(%p)->(%s,%p) thunking to IDirectDrawSurface7 interface.\n", iface, debugstr_guid(riid), obp);
|
|
return IDirectDrawSurface7_QueryInterface(COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirect3DTexture, IDirectDrawSurface7, iface),
|
|
riid,
|
|
obp);
|
|
}
|
|
|
|
ULONG WINAPI
|
|
Thunk_IDirect3DTextureImpl_1_AddRef(LPDIRECT3DTEXTURE iface)
|
|
{
|
|
TRACE("(%p)->() thunking to IDirectDrawSurface7 interface.\n", iface);
|
|
return IDirectDrawSurface7_AddRef(COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirect3DTexture, IDirectDrawSurface7, iface));
|
|
}
|
|
|
|
ULONG WINAPI
|
|
Thunk_IDirect3DTextureImpl_1_Release(LPDIRECT3DTEXTURE iface)
|
|
{
|
|
TRACE("(%p)->() thunking to IDirectDrawSurface7 interface.\n", iface);
|
|
return IDirectDrawSurface7_Release(COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirect3DTexture, IDirectDrawSurface7, iface));
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Thunk_IDirect3DTextureImpl_1_PaletteChanged(LPDIRECT3DTEXTURE iface,
|
|
DWORD dwStart,
|
|
DWORD dwCount)
|
|
{
|
|
TRACE("(%p)->(%08lx,%08lx) thunking to IDirect3DTexture2 interface.\n", iface, dwStart, dwCount);
|
|
return IDirect3DTexture2_PaletteChanged(COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirect3DTexture, IDirect3DTexture2, iface),
|
|
dwStart,
|
|
dwCount);
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Thunk_IDirect3DTextureImpl_1_GetHandle(LPDIRECT3DTEXTURE iface,
|
|
LPDIRECT3DDEVICE lpDirect3DDevice,
|
|
LPD3DTEXTUREHANDLE lpHandle)
|
|
{
|
|
TRACE("(%p)->(%p,%p) thunking to IDirect3DTexture2 interface.\n", iface, lpDirect3DDevice, lpHandle);
|
|
return IDirect3DTexture2_GetHandle(COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirect3DTexture, IDirect3DTexture2, iface),
|
|
COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice, IDirect3DDevice2, lpDirect3DDevice),
|
|
lpHandle);
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Thunk_IDirect3DTextureImpl_1_Load(LPDIRECT3DTEXTURE iface,
|
|
LPDIRECT3DTEXTURE lpD3DTexture)
|
|
{
|
|
TRACE("(%p)->(%p) thunking to IDirect3DTexture2 interface.\n", iface, lpD3DTexture);
|
|
return IDirect3DTexture2_Load(COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirect3DTexture, IDirect3DTexture2, iface),
|
|
COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirect3DTexture, IDirect3DTexture2, lpD3DTexture));
|
|
}
|
|
|
|
#if !defined(__STRICT_ANSI__) && defined(__GNUC__)
|
|
# define XCAST(fun) (typeof(VTABLE_IDirect3DTexture2.fun))
|
|
#else
|
|
# define XCAST(fun) (void*)
|
|
#endif
|
|
|
|
ICOM_VTABLE(IDirect3DTexture2) VTABLE_IDirect3DTexture2 =
|
|
{
|
|
ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
|
|
XCAST(QueryInterface) Thunk_IDirect3DTextureImpl_2_QueryInterface,
|
|
XCAST(AddRef) Thunk_IDirect3DTextureImpl_2_AddRef,
|
|
XCAST(Release) Thunk_IDirect3DTextureImpl_2_Release,
|
|
XCAST(GetHandle) Main_IDirect3DTextureImpl_2_1T_GetHandle,
|
|
XCAST(PaletteChanged) Main_IDirect3DTextureImpl_2_1T_PaletteChanged,
|
|
XCAST(Load) GL_IDirect3DTextureImpl_2_1T_Load,
|
|
};
|
|
|
|
#if !defined(__STRICT_ANSI__) && defined(__GNUC__)
|
|
#undef XCAST
|
|
#endif
|
|
|
|
|
|
#if !defined(__STRICT_ANSI__) && defined(__GNUC__)
|
|
# define XCAST(fun) (typeof(VTABLE_IDirect3DTexture.fun))
|
|
#else
|
|
# define XCAST(fun) (void*)
|
|
#endif
|
|
|
|
ICOM_VTABLE(IDirect3DTexture) VTABLE_IDirect3DTexture =
|
|
{
|
|
ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
|
|
XCAST(QueryInterface) Thunk_IDirect3DTextureImpl_1_QueryInterface,
|
|
XCAST(AddRef) Thunk_IDirect3DTextureImpl_1_AddRef,
|
|
XCAST(Release) Thunk_IDirect3DTextureImpl_1_Release,
|
|
XCAST(Initialize) Main_IDirect3DTextureImpl_1_Initialize,
|
|
XCAST(GetHandle) Thunk_IDirect3DTextureImpl_1_GetHandle,
|
|
XCAST(PaletteChanged) Thunk_IDirect3DTextureImpl_1_PaletteChanged,
|
|
XCAST(Load) Thunk_IDirect3DTextureImpl_1_Load,
|
|
XCAST(Unload) Main_IDirect3DTextureImpl_1_Unload,
|
|
};
|
|
|
|
#if !defined(__STRICT_ANSI__) && defined(__GNUC__)
|
|
#undef XCAST
|
|
#endif
|
|
|
|
HRESULT d3dtexture_create(IDirect3DImpl *d3d, IDirectDrawSurfaceImpl *surf, BOOLEAN at_creation,
|
|
IDirectDrawSurfaceImpl *main)
|
|
{
|
|
/* First, initialize the texture vtables... */
|
|
ICOM_INIT_INTERFACE(surf, IDirect3DTexture, VTABLE_IDirect3DTexture);
|
|
ICOM_INIT_INTERFACE(surf, IDirect3DTexture2, VTABLE_IDirect3DTexture2);
|
|
|
|
/* Only create all the private stuff if we actually have an OpenGL context.. */
|
|
if (d3d->current_device != NULL) {
|
|
IDirect3DTextureGLImpl *private;
|
|
|
|
private = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DTextureGLImpl));
|
|
if (private == NULL) return DDERR_OUTOFMEMORY;
|
|
|
|
private->final_release = surf->final_release;
|
|
private->lock_update = surf->lock_update;
|
|
private->unlock_update = surf->unlock_update;
|
|
private->set_palette = surf->set_palette;
|
|
|
|
/* If at creation, we can optimize stuff and wait the first 'unlock' to upload a valid stuff to OpenGL.
|
|
Otherwise, it will be uploaded here (and may be invalid). */
|
|
surf->final_release = gltex_final_release;
|
|
surf->lock_update = gltex_lock_update;
|
|
surf->unlock_update = gltex_unlock_update;
|
|
surf->tex_private = private;
|
|
surf->aux_setcolorkey_cb = gltex_setcolorkey_cb;
|
|
surf->set_palette = gltex_set_palette;
|
|
|
|
ENTER_GL();
|
|
if (surf->mipmap_level == 0) {
|
|
glGenTextures(1, &(private->tex_name));
|
|
if (private->tex_name == 0) ERR("Error at creation of OpenGL texture ID !\n");
|
|
TRACE(" GL texture created for surface %p (private data at %p and GL id %d).\n", surf, private, private->tex_name);
|
|
} else {
|
|
private->tex_name = ((IDirect3DTextureGLImpl *) (main->tex_private))->tex_name;
|
|
TRACE(" GL texture created for surface %p (private data at %p and GL id reusing id %d from surface %p (%p)).\n",
|
|
surf, private, private->tex_name, main, main->tex_private);
|
|
}
|
|
LEAVE_GL();
|
|
|
|
/* And set the dirty flag accordingly */
|
|
private->dirty_flag = (at_creation == FALSE);
|
|
private->initial_upload_done = FALSE;
|
|
}
|
|
|
|
return D3D_OK;
|
|
}
|