ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/dlls/wined3d/utils.c

3502 lines
177 KiB
C
Raw Normal View History

- Make d3d8 know about the wined3d device and start using it. - Move some of the screen mode related functions into wined3d and add untested support for the new d3d9 options of providing the format to some of the calls. - Move other functions from the directx interface into the common library and implement the calls from d3d9 as well. - Copy across the first of the functions used to make traces more readable, creating utils.c to store them in. Eventually the ones in d3d8 will be removed but for now just duplicate the code.
2004-09-28 04:12:12 +02:00
/*
* Utility functions for the WineD3D Library
*
* Copyright 2002-2004 Jason Edmeades
* Copyright 2003-2004 Raphael Junqueira
* Copyright 2004 Christian Costa
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
* Copyright 2005 Oliver Stieber
wined3d: Add some hash table code.
2007-02-27 20:51:48 +01:00
* Copyright 2006-2007 Henri Verbeet
wined3d: Update copyright lines.
2008-03-29 02:36:13 +01:00
* Copyright 2007-2008 Stefan D<EFBFBD>singer for CodeWeavers
- Make d3d8 know about the wined3d device and start using it. - Move some of the screen mode related functions into wined3d and add untested support for the new d3d9 options of providing the format to some of the calls. - Move other functions from the directx interface into the common library and implement the calls from d3d9 as well. - Copy across the first of the functions used to make traces more readable, creating utils.c to store them in. Eventually the ones in d3d8 will be removed but for now just duplicate the code.
2004-09-28 04:12:12 +02:00
*
* 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
Update the address of the Free Software Foundation.
2006-05-18 14:49:52 +02:00
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
- Make d3d8 know about the wined3d device and start using it. - Move some of the screen mode related functions into wined3d and add untested support for the new d3d9 options of providing the format to some of the calls. - Move other functions from the directx interface into the common library and implement the calls from d3d9 as well. - Copy across the first of the functions used to make traces more readable, creating utils.c to store them in. Eventually the ones in d3d8 will be removed but for now just duplicate the code.
2004-09-28 04:12:12 +02:00
*/
#include "config.h"
#include "wined3d_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(d3d);
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
/*****************************************************************************
* Pixel format array
wined3d: Add an alpha blending test.
2007-12-06 22:33:26 +01:00
*
* For the formats WINED3DFMT_A32B32G32R32F, WINED3DFMT_A16B16G16R16F,
* and WINED3DFMT_A16B16G16R16 do not have correct alpha masks, because the
* high masks do not fit into the 32 bit values needed for ddraw. It is only
* used for ddraw mostly, and to figure out if the format has alpha at all, so
* setting a mask like 0x1 for those surfaces is correct. The 64 and 128 bit
* formats are not usable in 2D rendering because ddraw doesn't support them.
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
*/
wined3d: Split up the format table.
2007-07-23 11:13:37 +02:00
static const StaticPixelFormatDesc formats[] = {
wined3d: Better pixelformat selection code.
2007-08-09 01:04:30 +02:00
/*{WINED3DFORMAT ,alphamask ,redmask ,greenmask ,bluemask ,bpp ,depth ,stencil, isFourcc*/
{WINED3DFMT_UNKNOWN ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,FALSE },
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
/* FourCC formats, kept here to have WINED3DFMT_R8G8B8(=20) at position 20 */
wined3d: Better pixelformat selection code.
2007-08-09 01:04:30 +02:00
{WINED3DFMT_UYVY ,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,0 ,0 ,TRUE },
{WINED3DFMT_YUY2 ,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,0 ,0 ,TRUE },
ddraw: Add yv12 detection support.
2008-02-21 23:46:43 +01:00
{WINED3DFMT_YV12 ,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,0 ,0 ,TRUE },
wined3d: Better pixelformat selection code.
2007-08-09 01:04:30 +02:00
{WINED3DFMT_DXT1 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,TRUE },
{WINED3DFMT_DXT2 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,TRUE },
{WINED3DFMT_DXT3 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,TRUE },
{WINED3DFMT_DXT4 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,TRUE },
{WINED3DFMT_DXT5 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,TRUE },
{WINED3DFMT_MULTI2_ARGB8,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,0 ,0 ,TRUE },
{WINED3DFMT_G8R8_G8B8 ,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,0 ,0 ,TRUE },
{WINED3DFMT_R8G8_B8G8 ,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,0 ,0 ,TRUE },
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
/* IEEE formats */
wined3d: Better pixelformat selection code.
2007-08-09 01:04:30 +02:00
{WINED3DFMT_R32F ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,0 ,0 ,FALSE },
{WINED3DFMT_G32R32F ,0x0 ,0x0 ,0x0 ,0x0 ,8 ,0 ,0 ,FALSE },
wined3d: Add an alpha blending test.
2007-12-06 22:33:26 +01:00
{WINED3DFMT_A32B32G32R32F,0x1 ,0x0 ,0x0 ,0x0 ,16 ,0 ,0 ,FALSE },
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
/* Hmm? */
wined3d: Better pixelformat selection code.
2007-08-09 01:04:30 +02:00
{WINED3DFMT_CxV8U8 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,FALSE },
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
/* Float */
wined3d: Better pixelformat selection code.
2007-08-09 01:04:30 +02:00
{WINED3DFMT_R16F ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,FALSE },
{WINED3DFMT_G16R16F ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,0 ,0 ,FALSE },
wined3d: Add an alpha blending test.
2007-12-06 22:33:26 +01:00
{WINED3DFMT_A16B16G16R16F,0x1 ,0x0 ,0x0 ,0x0 ,8 ,0 ,0 ,FALSE },
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
/* Palettized formats */
wined3d: Better pixelformat selection code.
2007-08-09 01:04:30 +02:00
{WINED3DFMT_A8P8 ,0x0000ff00 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,FALSE },
{WINED3DFMT_P8 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,FALSE },
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
/* Standard ARGB formats. Keep WINED3DFMT_R8G8B8(=20) at position 20 */
wined3d: Better pixelformat selection code.
2007-08-09 01:04:30 +02:00
{WINED3DFMT_R8G8B8 ,0x0 ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,3 ,0 ,0 ,FALSE },
{WINED3DFMT_A8R8G8B8 ,0xff000000 ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,4 ,0 ,0 ,FALSE },
{WINED3DFMT_X8R8G8B8 ,0x0 ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,4 ,0 ,0 ,FALSE },
{WINED3DFMT_R5G6B5 ,0x0 ,0x0000F800 ,0x000007e0 ,0x0000001f ,2 ,0 ,0 ,FALSE },
{WINED3DFMT_X1R5G5B5 ,0x0 ,0x00007c00 ,0x000003e0 ,0x0000001f ,2 ,0 ,0 ,FALSE },
{WINED3DFMT_A1R5G5B5 ,0x00008000 ,0x00007c00 ,0x000003e0 ,0x0000001f ,2 ,0 ,0 ,FALSE },
{WINED3DFMT_A4R4G4B4 ,0x0000f000 ,0x00000f00 ,0x000000f0 ,0x0000000f ,2 ,0 ,0 ,FALSE },
{WINED3DFMT_R3G3B2 ,0x0 ,0x000000e0 ,0x0000001c ,0x00000003 ,1 ,0 ,0 ,FALSE },
{WINED3DFMT_A8 ,0x000000ff ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,FALSE },
{WINED3DFMT_A8R3G3B2 ,0x0000ff00 ,0x000000e0 ,0x0000001c ,0x00000003 ,2 ,0 ,0 ,FALSE },
{WINED3DFMT_X4R4G4B4 ,0x0 ,0x00000f00 ,0x000000f0 ,0x0000000f ,2 ,0 ,0 ,FALSE },
{WINED3DFMT_A2B10G10R10 ,0xb0000000 ,0x000003ff ,0x000ffc00 ,0x3ff00000 ,4 ,0 ,0 ,FALSE },
{WINED3DFMT_A8B8G8R8 ,0xff000000 ,0x000000ff ,0x0000ff00 ,0x00ff0000 ,4 ,0 ,0 ,FALSE },
{WINED3DFMT_X8B8G8R8 ,0x0 ,0x000000ff ,0x0000ff00 ,0x00ff0000 ,4 ,0 ,0 ,FALSE },
{WINED3DFMT_G16R16 ,0x0 ,0x0000ffff ,0xffff0000 ,0x0 ,4 ,0 ,0 ,FALSE },
{WINED3DFMT_A2R10G10B10 ,0xb0000000 ,0x3ff00000 ,0x000ffc00 ,0x000003ff ,4 ,0 ,0 ,FALSE },
wined3d: Add an alpha blending test.
2007-12-06 22:33:26 +01:00
{WINED3DFMT_A16B16G16R16,0x1 ,0x0000ffff ,0xffff0000 ,0x0 ,8 ,0 ,0 ,FALSE },
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
/* Luminance */
wined3d: Better pixelformat selection code.
2007-08-09 01:04:30 +02:00
{WINED3DFMT_L8 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,FALSE },
{WINED3DFMT_A8L8 ,0x0000ff00 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,FALSE },
{WINED3DFMT_A4L4 ,0x000000f0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,FALSE },
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
/* Bump mapping stuff */
wined3d: Better pixelformat selection code.
2007-08-09 01:04:30 +02:00
{WINED3DFMT_V8U8 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,FALSE },
{WINED3DFMT_L6V5U5 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,FALSE },
{WINED3DFMT_X8L8V8U8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,0 ,0 ,FALSE },
{WINED3DFMT_Q8W8V8U8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,0 ,0 ,FALSE },
{WINED3DFMT_V16U16 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,0 ,0 ,FALSE },
{WINED3DFMT_W11V11U10 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,0 ,0 ,FALSE },
{WINED3DFMT_A2W10V10U10 ,0xb0000000 ,0x0 ,0x0 ,0x0 ,4 ,0 ,0 ,FALSE },
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
/* Depth stencil formats */
wined3d: Better pixelformat selection code.
2007-08-09 01:04:30 +02:00
{WINED3DFMT_D16_LOCKABLE,0x0 ,0x0 ,0x0 ,0x0 ,2 ,16 ,0 ,FALSE },
{WINED3DFMT_D32 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,32 ,0 ,FALSE },
{WINED3DFMT_D15S1 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,15 ,1 ,FALSE },
{WINED3DFMT_D24S8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,24 ,8 ,FALSE },
{WINED3DFMT_D24X8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,24 ,0 ,FALSE },
{WINED3DFMT_D24X4S4 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,24 ,4 ,FALSE },
wined3d: Fix WINED3DFMT D16/L16 bugs in the pixelformat table.
2007-08-11 12:21:15 +02:00
{WINED3DFMT_D16 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,16 ,0 ,FALSE },
{WINED3DFMT_L16 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,16 ,0 ,FALSE },
wined3d: Better pixelformat selection code.
2007-08-09 01:04:30 +02:00
{WINED3DFMT_D32F_LOCKABLE,0x0 ,0x0 ,0x0 ,0x0 ,4 ,32 ,0 ,FALSE },
{WINED3DFMT_D24FS8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,24 ,8 ,FALSE },
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
/* Is this a vertex buffer? */
wined3d: Better pixelformat selection code.
2007-08-09 01:04:30 +02:00
{WINED3DFMT_VERTEXDATA ,0x0 ,0x0 ,0x0 ,0x0 ,0 ,0 ,0 ,FALSE },
{WINED3DFMT_INDEX16 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,FALSE },
{WINED3DFMT_INDEX32 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,0 ,0 ,FALSE },
{WINED3DFMT_Q16W16V16U16,0x0 ,0x0 ,0x0 ,0x0 ,8 ,0 ,0 ,FALSE },
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
};
wined3d: A more dynamic initialization of the gl pixel formats.
2007-07-24 10:25:35 +02:00
typedef struct {
WINED3DFORMAT fmt;
wined3d: Allow using a different internal format for fbos. OpenGL drivers do not support some low precision internal formats like GL_RGB5 for fbo color targets. Direct3D application depend on them, so provide a fallback format for render targets if the requested format itself is not supported.
2007-11-23 14:17:21 +01:00
GLint glInternal, glGammaInternal, rtInternal, glFormat, glType;
wined3d: Initial post pixelshader blending support. [attempt 2]. For each pixel format we store a flag in the table whether it supports post pixelshader blending. Before applying blending or during a context switch we verify that blending is turned off for the format. In case of R32F this gave a 5-6x performance boost (without filtering and software conversion).
2008-03-28 10:02:39 +01:00
unsigned int Flags;
wined3d: A more dynamic initialization of the gl pixel formats.
2007-07-24 10:25:35 +02:00
} GlPixelFormatDescTemplate;
wined3d: Split up the format table.
2007-07-23 11:13:37 +02:00
/*****************************************************************************
wined3d: A more dynamic initialization of the gl pixel formats.
2007-07-24 10:25:35 +02:00
* OpenGL format template. Contains unexciting formats which do not need
* extension checks. The order in this table is independent of the order in
* the table StaticPixelFormatDesc above. Not all formats have to be in this
* table.
wined3d: Split up the format table.
2007-07-23 11:13:37 +02:00
*/
wined3d: A more dynamic initialization of the gl pixel formats.
2007-07-24 10:25:35 +02:00
static const GlPixelFormatDescTemplate gl_formats_template[] = {
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
/*{ internal ,srgbInternal , rtInternal, format ,type \
,Flags }*/
{WINED3DFMT_UNKNOWN ,0 ,0 , 0, 0 ,0
,0 },
wined3d: A more dynamic initialization of the gl pixel formats.
2007-07-24 10:25:35 +02:00
/* FourCC formats */
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_UYVY ,0 ,0 , 0, 0 ,0
,0 },
{WINED3DFMT_YUY2 ,0 ,0 , 0, 0 ,0
,0 },
{WINED3DFMT_DXT1 ,GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT , 0, GL_RGBA ,GL_UNSIGNED_BYTE
,WINED3DFMT_FLAG_FILTERING },
{WINED3DFMT_DXT2 ,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT , 0, GL_RGBA ,GL_UNSIGNED_BYTE
,WINED3DFMT_FLAG_FILTERING },
{WINED3DFMT_DXT3 ,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT , 0, GL_RGBA ,GL_UNSIGNED_BYTE
,WINED3DFMT_FLAG_FILTERING },
{WINED3DFMT_DXT4 ,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT , 0, GL_RGBA ,GL_UNSIGNED_BYTE
,WINED3DFMT_FLAG_FILTERING },
{WINED3DFMT_DXT5 ,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT , 0, GL_RGBA ,GL_UNSIGNED_BYTE
,WINED3DFMT_FLAG_FILTERING },
{WINED3DFMT_MULTI2_ARGB8 ,0 ,0 , 0, 0 ,0
,0 },
{WINED3DFMT_G8R8_G8B8 ,0 ,0 , 0, 0 ,0
,0 },
{WINED3DFMT_R8G8_B8G8 ,0 ,0 , 0, 0 ,0
,0 },
wined3d: Split up the format table.
2007-07-23 11:13:37 +02:00
/* IEEE formats */
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_R32F ,GL_RGB32F_ARB ,GL_RGB32F_ARB , 0, GL_RED ,GL_FLOAT
wined3d: Also move the rendertarget capability to the formats table.
2008-03-29 01:10:52 +01:00
,WINED3DFMT_FLAG_RENDERTARGET },
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_G32R32F ,0 ,0 , 0, 0 ,0
wined3d: Also move the rendertarget capability to the formats table.
2008-03-29 01:10:52 +01:00
,WINED3DFMT_FLAG_RENDERTARGET },
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_A32B32G32R32F ,GL_RGBA32F_ARB ,GL_RGBA32F_ARB , 0, GL_RGBA ,GL_FLOAT
wined3d: Also move the rendertarget capability to the formats table.
2008-03-29 01:10:52 +01:00
,WINED3DFMT_FLAG_RENDERTARGET },
wined3d: Split up the format table.
2007-07-23 11:13:37 +02:00
/* Hmm? */
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_CxV8U8 ,0 ,0 , 0, 0 ,0
,0 },
wined3d: Split up the format table.
2007-07-23 11:13:37 +02:00
/* Float */
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_R16F ,GL_RGB16F_ARB ,GL_RGB16F_ARB , 0, GL_RED ,GL_HALF_FLOAT_ARB
wined3d: Also move the rendertarget capability to the formats table.
2008-03-29 01:10:52 +01:00
,WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_G16R16F ,0 ,0 , 0, 0 ,0
wined3d: Also move the rendertarget capability to the formats table.
2008-03-29 01:10:52 +01:00
,WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_A16B16G16R16F ,GL_RGBA16F_ARB ,GL_RGBA16F_ARB , 0, GL_RGBA ,GL_HALF_FLOAT_ARB
wined3d: Also move the rendertarget capability to the formats table.
2008-03-29 01:10:52 +01:00
,WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
wined3d: Split up the format table.
2007-07-23 11:13:37 +02:00
/* Palettized formats */
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_A8P8, 0 ,0 , 0, 0 ,0
,0 },
{WINED3DFMT_P8, GL_COLOR_INDEX8_EXT ,GL_COLOR_INDEX8_EXT , 0, GL_COLOR_INDEX ,GL_UNSIGNED_BYTE
,0 },
wined3d: A more dynamic initialization of the gl pixel formats.
2007-07-24 10:25:35 +02:00
/* Standard ARGB formats */
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_R8G8B8 ,GL_RGB8 ,GL_RGB8 , 0, GL_BGR ,GL_UNSIGNED_BYTE
wined3d: Also move the rendertarget capability to the formats table.
2008-03-29 01:10:52 +01:00
,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_A8R8G8B8 ,GL_RGBA8 ,GL_SRGB8_ALPHA8_EXT , 0, GL_BGRA ,GL_UNSIGNED_INT_8_8_8_8_REV
wined3d: Also move the rendertarget capability to the formats table.
2008-03-29 01:10:52 +01:00
,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_X8R8G8B8 ,GL_RGB8 ,GL_SRGB8_EXT , 0, GL_BGRA ,GL_UNSIGNED_INT_8_8_8_8_REV
wined3d: Also move the rendertarget capability to the formats table.
2008-03-29 01:10:52 +01:00
,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_R5G6B5 ,GL_RGB5 ,GL_RGB5 , GL_RGB8, GL_RGB ,GL_UNSIGNED_SHORT_5_6_5
wined3d: Also move the rendertarget capability to the formats table.
2008-03-29 01:10:52 +01:00
,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_X1R5G5B5 ,GL_RGB5 ,GL_RGB5_A1 , 0, GL_BGRA ,GL_UNSIGNED_SHORT_1_5_5_5_REV
,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING },
{WINED3DFMT_A1R5G5B5 ,GL_RGB5_A1 ,GL_RGB5_A1 , 0, GL_BGRA ,GL_UNSIGNED_SHORT_1_5_5_5_REV
,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING },
{WINED3DFMT_A4R4G4B4 ,GL_RGBA4 ,GL_SRGB8_ALPHA8_EXT , 0, GL_BGRA ,GL_UNSIGNED_SHORT_4_4_4_4_REV
,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING },
{WINED3DFMT_R3G3B2 ,GL_R3_G3_B2 ,GL_R3_G3_B2 , 0, GL_RGB ,GL_UNSIGNED_BYTE_3_3_2
,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING },
{WINED3DFMT_A8 ,GL_ALPHA8 ,GL_ALPHA8 , 0, GL_ALPHA ,GL_UNSIGNED_BYTE
,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING },
{WINED3DFMT_A8R3G3B2 ,0 ,0 , 0, 0 ,0
,0 },
{WINED3DFMT_X4R4G4B4 ,GL_RGB4 ,GL_RGB4 , 0, GL_BGRA ,GL_UNSIGNED_SHORT_4_4_4_4_REV
,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
{WINED3DFMT_A2B10G10R10 ,GL_RGBA ,GL_RGBA , 0, GL_RGBA ,GL_UNSIGNED_INT_2_10_10_10_REV
,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
{WINED3DFMT_A8B8G8R8 ,GL_RGBA8 ,GL_RGBA8 , 0, GL_RGBA ,GL_UNSIGNED_INT_8_8_8_8_REV
,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
{WINED3DFMT_X8B8G8R8 ,GL_RGB8 ,GL_RGB8 , 0, GL_RGBA ,GL_UNSIGNED_INT_8_8_8_8_REV
,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
{WINED3DFMT_G16R16 ,GL_RGB16_EXT ,GL_RGB16_EXT , 0, GL_RGB ,GL_UNSIGNED_SHORT
,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING },
{WINED3DFMT_A2R10G10B10 ,GL_RGBA ,GL_RGBA , 0, GL_BGRA ,GL_UNSIGNED_INT_2_10_10_10_REV
,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING },
{WINED3DFMT_A16B16G16R16 ,GL_RGBA16_EXT ,GL_RGBA16_EXT , 0, GL_RGBA ,GL_UNSIGNED_SHORT
wined3d: Also move the rendertarget capability to the formats table.
2008-03-29 01:10:52 +01:00
,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
wined3d: Split up the format table.
2007-07-23 11:13:37 +02:00
/* Luminance */
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_L8 ,GL_LUMINANCE8 ,GL_SLUMINANCE8_EXT , 0, GL_LUMINANCE ,GL_UNSIGNED_BYTE
,WINED3DFMT_FLAG_FILTERING },
{WINED3DFMT_A8L8 ,GL_LUMINANCE8_ALPHA8 ,GL_SLUMINANCE8_ALPHA8_EXT , 0, GL_LUMINANCE_ALPHA ,GL_UNSIGNED_BYTE
,WINED3DFMT_FLAG_FILTERING },
{WINED3DFMT_A4L4 ,GL_LUMINANCE4_ALPHA4 ,GL_LUMINANCE4_ALPHA4 , 0, GL_LUMINANCE_ALPHA ,GL_UNSIGNED_BYTE
,0 },
wined3d: Split up the format table.
2007-07-23 11:13:37 +02:00
/* Bump mapping stuff */
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_V8U8 ,GL_DSDT8_NV ,GL_DSDT8_NV , 0, GL_DSDT_NV ,GL_BYTE
,WINED3DFMT_FLAG_FILTERING },
{WINED3DFMT_L6V5U5 ,GL_DSDT8_MAG8_NV ,GL_DSDT8_MAG8_NV , 0, GL_DSDT_MAG_NV ,GL_BYTE
,WINED3DFMT_FLAG_FILTERING },
{WINED3DFMT_X8L8V8U8 ,GL_DSDT8_MAG8_INTENSITY8_NV ,GL_DSDT8_MAG8_INTENSITY8_NV , 0, GL_DSDT_MAG_VIB_NV ,GL_UNSIGNED_INT_8_8_S8_S8_REV_NV
,WINED3DFMT_FLAG_FILTERING },
{WINED3DFMT_Q8W8V8U8 ,GL_SIGNED_RGBA8_NV ,GL_SIGNED_RGBA8_NV , 0, GL_RGBA ,GL_BYTE
,WINED3DFMT_FLAG_FILTERING },
{WINED3DFMT_V16U16 ,GL_SIGNED_HILO16_NV ,GL_SIGNED_HILO16_NV , 0, GL_HILO_NV ,GL_SHORT
,WINED3DFMT_FLAG_FILTERING },
{WINED3DFMT_W11V11U10 ,0 ,0 , 0, 0 ,0
,0 },
{WINED3DFMT_A2W10V10U10 ,0 ,0 , 0, 0 ,0
,0 },
wined3d: Split up the format table.
2007-07-23 11:13:37 +02:00
/* Depth stencil formats */
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_D16_LOCKABLE ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB , 0, GL_DEPTH_COMPONENT ,GL_UNSIGNED_SHORT
wined3d: Add a depthstencil flag to the formats table and make use of it in CheckDepthStencilCapability.
2008-03-29 00:29:38 +01:00
,WINED3DFMT_FLAG_DEPTH },
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_D32 ,GL_DEPTH_COMPONENT32_ARB ,GL_DEPTH_COMPONENT32_ARB , 0, GL_DEPTH_COMPONENT ,GL_UNSIGNED_INT
wined3d: Add a depthstencil flag to the formats table and make use of it in CheckDepthStencilCapability.
2008-03-29 00:29:38 +01:00
,WINED3DFMT_FLAG_DEPTH },
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_D15S1 ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB , 0, GL_DEPTH_COMPONENT ,GL_UNSIGNED_SHORT
wined3d: Add a depthstencil flag to the formats table and make use of it in CheckDepthStencilCapability.
2008-03-29 00:29:38 +01:00
,WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL },
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_D24S8 ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB , 0, GL_DEPTH_COMPONENT ,GL_UNSIGNED_INT
wined3d: Add a depthstencil flag to the formats table and make use of it in CheckDepthStencilCapability.
2008-03-29 00:29:38 +01:00
,WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL },
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_D24X8 ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB , 0, GL_DEPTH_COMPONENT ,GL_UNSIGNED_INT
wined3d: Add a depthstencil flag to the formats table and make use of it in CheckDepthStencilCapability.
2008-03-29 00:29:38 +01:00
,WINED3DFMT_FLAG_DEPTH },
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_D24X4S4 ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB , 0, GL_DEPTH_COMPONENT ,GL_UNSIGNED_INT
wined3d: Add a depthstencil flag to the formats table and make use of it in CheckDepthStencilCapability.
2008-03-29 00:29:38 +01:00
,WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL },
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_D16 ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB , 0, GL_DEPTH_COMPONENT ,GL_UNSIGNED_SHORT
wined3d: Add a depthstencil flag to the formats table and make use of it in CheckDepthStencilCapability.
2008-03-29 00:29:38 +01:00
,WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH },
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_L16 ,GL_LUMINANCE16_EXT ,GL_LUMINANCE16_EXT , 0, GL_LUMINANCE ,GL_UNSIGNED_SHORT
,WINED3DFMT_FLAG_FILTERING },
{WINED3DFMT_D32F_LOCKABLE ,GL_DEPTH_COMPONENT32_ARB ,GL_DEPTH_COMPONENT32_ARB , 0, GL_DEPTH_COMPONENT ,GL_FLOAT
wined3d: Add a depthstencil flag to the formats table and make use of it in CheckDepthStencilCapability.
2008-03-29 00:29:38 +01:00
,WINED3DFMT_FLAG_DEPTH },
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_D24FS8 ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB , 0, GL_DEPTH_COMPONENT ,GL_FLOAT
wined3d: Add a depthstencil flag to the formats table and make use of it in CheckDepthStencilCapability.
2008-03-29 00:29:38 +01:00
,WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL},
wined3d: Split up the format table.
2007-07-23 11:13:37 +02:00
/* Is this a vertex buffer? */
wined3d: Make the filtering capability of a format a flag in the formats table.
2008-03-29 00:18:41 +01:00
{WINED3DFMT_VERTEXDATA ,0 ,0 , 0, 0 ,0
,0 },
{WINED3DFMT_INDEX16 ,0 ,0 , 0, 0 ,0
,0 },
{WINED3DFMT_INDEX32 ,0 ,0 , 0, 0 ,0
,0 },
{WINED3DFMT_Q16W16V16U16 ,GL_COLOR_INDEX ,GL_COLOR_INDEX , 0, GL_COLOR_INDEX ,GL_UNSIGNED_SHORT
,0 }
wined3d: Split up the format table.
2007-07-23 11:13:37 +02:00
};
wined3d: Store the gl format table in the gl info structure.
2007-07-27 13:22:54 +02:00
static inline int getFmtIdx(WINED3DFORMAT fmt) {
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
/* First check if the format is at the position of its value.
* This will catch the argb formats before the loop is entered
*/
if(fmt < (sizeof(formats) / sizeof(formats[0])) && formats[fmt].format == fmt) {
wined3d: Store the gl format table in the gl info structure.
2007-07-27 13:22:54 +02:00
return fmt;
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
} else {
unsigned int i;
for(i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
if(formats[i].format == fmt) {
wined3d: Store the gl format table in the gl info structure.
2007-07-27 13:22:54 +02:00
return i;
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
}
}
}
wined3d: Store the gl format table in the gl info structure.
2007-07-27 13:22:54 +02:00
return -1;
}
wined3d: Recompile glsl pixelshaders if the sampler format changes.
2007-09-21 23:47:40 +02:00
#define GLINFO_LOCATION (*gl_info)
wined3d: Store the gl format table in the gl info structure.
2007-07-27 13:22:54 +02:00
BOOL initPixelFormats(WineD3D_GL_Info *gl_info)
{
wined3d: A more dynamic initialization of the gl pixel formats.
2007-07-24 10:25:35 +02:00
unsigned int src;
wined3d: Recompile glsl pixelshaders if the sampler format changes.
2007-09-21 23:47:40 +02:00
int dst;
wined3d: A more dynamic initialization of the gl pixel formats.
2007-07-24 10:25:35 +02:00
gl_info->gl_formats = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
sizeof(formats) / sizeof(formats[0]) * sizeof(gl_info->gl_formats[0]));
wined3d: Store the gl format table in the gl info structure.
2007-07-27 13:22:54 +02:00
if(!gl_info->gl_formats) return FALSE;
wined3d: A more dynamic initialization of the gl pixel formats.
2007-07-24 10:25:35 +02:00
/* If a format depends on some extensions, remove them from the table above and initialize them
* after this loop
*/
for(src = 0; src < sizeof(gl_formats_template) / sizeof(gl_formats_template[0]); src++) {
wined3d: Recompile glsl pixelshaders if the sampler format changes.
2007-09-21 23:47:40 +02:00
dst = getFmtIdx(gl_formats_template[src].fmt);
wined3d: A more dynamic initialization of the gl pixel formats.
2007-07-24 10:25:35 +02:00
gl_info->gl_formats[dst].glInternal = gl_formats_template[src].glInternal;
gl_info->gl_formats[dst].glGammaInternal = gl_formats_template[src].glGammaInternal;
gl_info->gl_formats[dst].glFormat = gl_formats_template[src].glFormat;
gl_info->gl_formats[dst].glType = gl_formats_template[src].glType;
wined3d: Recompile glsl pixelshaders if the sampler format changes.
2007-09-21 23:47:40 +02:00
gl_info->gl_formats[dst].conversion_group= WINED3DFMT_UNKNOWN;
wined3d: Initial post pixelshader blending support. [attempt 2]. For each pixel format we store a flag in the table whether it supports post pixelshader blending. Before applying blending or during a context switch we verify that blending is turned off for the format. In case of R32F this gave a 5-6x performance boost (without filtering and software conversion).
2008-03-28 10:02:39 +01:00
gl_info->gl_formats[dst].Flags = gl_formats_template[src].Flags;
wined3d: Allow using a different internal format for fbos. OpenGL drivers do not support some low precision internal formats like GL_RGB5 for fbo color targets. Direct3D application depend on them, so provide a fallback format for render targets if the requested format itself is not supported.
2007-11-23 14:17:21 +01:00
if(wined3d_settings.offscreen_rendering_mode == ORM_FBO &&
gl_formats_template[src].rtInternal != 0) {
GLuint tex, fb;
GLenum status;
/* Check if the default internal format is supported as a frame buffer target, otherwise
* fall back to the render target internal.
*
* Try to stick to the standard format if possible, this limits precision differences
*/
while(glGetError());
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, gl_formats_template[src].glInternal, 16, 16, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
GL_EXTCALL(glGenFramebuffersEXT(1, &fb));
GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb));
GL_EXTCALL(glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D, tex, 0));
status = GL_EXTCALL(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT));
GL_EXTCALL(glDeleteFramebuffersEXT(1, &fb));
glDeleteTextures(1, &tex);
checkGLcall("Framebuffer format check");
if(status != GL_FRAMEBUFFER_COMPLETE_EXT) {
TRACE("Internal format of %s not supported as frame buffer target, using render target internal instead\n",
debug_d3dformat(gl_formats_template[src].fmt));
gl_info->gl_formats[dst].rtInternal = gl_formats_template[src].rtInternal;
} else {
TRACE("Format %s is supported as fbo target\n", debug_d3dformat(gl_formats_template[src].fmt));
gl_info->gl_formats[dst].rtInternal = gl_formats_template[src].glInternal;
}
} else {
gl_info->gl_formats[dst].rtInternal = gl_formats_template[src].glInternal;
}
wined3d: Recompile glsl pixelshaders if the sampler format changes.
2007-09-21 23:47:40 +02:00
}
wined3d: Put V8U8 back into the UNKNOWN format group.
2007-09-24 16:16:31 +02:00
/* V8U8 is supported natively by GL_ATI_envmap_bumpmap and GL_NV_texture_shader.
* V16U16 is only supported by GL_NV_texture_shader. The formats need fixup if
* their extensions are not available.
*
* In theory, V8U8 and V16U16 need a fixup of the undefined blue channel. OpenGL
* returns 0.0 when sampling from it, DirectX 1.0. This is disabled until we find
* an application that needs this because it causes performance problems due to
* shader recompiling in some games.
wined3d: Recompile glsl pixelshaders if the sampler format changes.
2007-09-21 23:47:40 +02:00
*/
wined3d: Put V8U8 back into the UNKNOWN format group.
2007-09-24 16:16:31 +02:00
if(!GL_SUPPORT(ATI_ENVMAP_BUMPMAP) && !GL_SUPPORT(NV_TEXTURE_SHADER2)) {
/* signed -> unsigned fixup */
dst = getFmtIdx(WINED3DFMT_V8U8);
wined3d: Recompile glsl pixelshaders if the sampler format changes.
2007-09-21 23:47:40 +02:00
gl_info->gl_formats[dst].conversion_group = WINED3DFMT_V8U8;
wined3d: Put V8U8 back into the UNKNOWN format group.
2007-09-24 16:16:31 +02:00
dst = getFmtIdx(WINED3DFMT_V16U16);
gl_info->gl_formats[dst].conversion_group = WINED3DFMT_V8U8;
} else if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP)) {
/* signed -> unsigned fixup */
dst = getFmtIdx(WINED3DFMT_V16U16);
wined3d: Recompile glsl pixelshaders if the sampler format changes.
2007-09-21 23:47:40 +02:00
gl_info->gl_formats[dst].conversion_group = WINED3DFMT_V16U16;
wined3d: Put V8U8 back into the UNKNOWN format group.
2007-09-24 16:16:31 +02:00
} else {
/* Blue = 1.0 fixup, disabled for now */
#if 0
dst = getFmtIdx(WINED3DFMT_V8U8);
gl_info->gl_formats[dst].conversion_group = WINED3DFMT_V8U8;
dst = getFmtIdx(WINED3DFMT_V16U16);
gl_info->gl_formats[dst].conversion_group = WINED3DFMT_V8U8;
#endif
wined3d: Recompile glsl pixelshaders if the sampler format changes.
2007-09-21 23:47:40 +02:00
}
if(!GL_SUPPORT(NV_TEXTURE_SHADER)) {
/* If GL_NV_texture_shader is not supported, those formats are converted, incompatibly
* with each other
*/
dst = getFmtIdx(WINED3DFMT_L6V5U5);
gl_info->gl_formats[dst].conversion_group = WINED3DFMT_L6V5U5;
dst = getFmtIdx(WINED3DFMT_X8L8V8U8);
gl_info->gl_formats[dst].conversion_group = WINED3DFMT_X8L8V8U8;
dst = getFmtIdx(WINED3DFMT_Q8W8V8U8);
gl_info->gl_formats[dst].conversion_group = WINED3DFMT_Q8W8V8U8;
} else {
/* If GL_NV_texture_shader is supported, WINED3DFMT_L6V5U5 and WINED3DFMT_X8L8V8U8
* are converted at surface loading time, but they do not need any modification in
* the shader, thus they are compatible with all WINED3DFMT_UNKNOWN group formats.
* WINED3DFMT_Q8W8V8U8 doesn't even need load-time conversion
*/
wined3d: A more dynamic initialization of the gl pixel formats.
2007-07-24 10:25:35 +02:00
}
wined3d: Store the gl format table in the gl info structure.
2007-07-27 13:22:54 +02:00
return TRUE;
}
wined3d: Move the GL info structure into the adapter.
2007-12-19 02:51:53 +01:00
/* NOTE: Make sure these are in the correct numerical order. (see /include/wined3d_types.h) */
static WINED3DGLTYPE const glTypeLookupTemplate[WINED3DDECLTYPE_UNUSED] = {
{WINED3DDECLTYPE_FLOAT1, 1, GL_FLOAT , GL_FALSE ,sizeof(float)},
{WINED3DDECLTYPE_FLOAT2, 2, GL_FLOAT , GL_FALSE ,sizeof(float)},
{WINED3DDECLTYPE_FLOAT3, 3, GL_FLOAT , GL_FALSE ,sizeof(float)},
{WINED3DDECLTYPE_FLOAT4, 4, GL_FLOAT , GL_FALSE ,sizeof(float)},
{WINED3DDECLTYPE_D3DCOLOR, 4, GL_UNSIGNED_BYTE , GL_TRUE ,sizeof(BYTE)},
{WINED3DDECLTYPE_UBYTE4, 4, GL_UNSIGNED_BYTE , GL_FALSE ,sizeof(BYTE)},
{WINED3DDECLTYPE_SHORT2, 2, GL_SHORT , GL_FALSE ,sizeof(short int)},
{WINED3DDECLTYPE_SHORT4, 4, GL_SHORT , GL_FALSE ,sizeof(short int)},
{WINED3DDECLTYPE_UBYTE4N, 4, GL_UNSIGNED_BYTE , GL_TRUE ,sizeof(BYTE)},
{WINED3DDECLTYPE_SHORT2N, 2, GL_SHORT , GL_TRUE ,sizeof(short int)},
{WINED3DDECLTYPE_SHORT4N, 4, GL_SHORT , GL_TRUE ,sizeof(short int)},
{WINED3DDECLTYPE_USHORT2N, 2, GL_UNSIGNED_SHORT , GL_TRUE ,sizeof(short int)},
{WINED3DDECLTYPE_USHORT4N, 4, GL_UNSIGNED_SHORT , GL_TRUE ,sizeof(short int)},
{WINED3DDECLTYPE_UDEC3, 3, GL_UNSIGNED_SHORT , GL_FALSE ,sizeof(short int)},
{WINED3DDECLTYPE_DEC3N, 3, GL_SHORT , GL_TRUE ,sizeof(short int)},
{WINED3DDECLTYPE_FLOAT16_2, 2, GL_HALF_FLOAT_NV , GL_FALSE ,sizeof(GLhalfNV)},
{WINED3DDECLTYPE_FLOAT16_4, 4, GL_HALF_FLOAT_NV , GL_FALSE ,sizeof(GLhalfNV)}};
void init_type_lookup(WineD3D_GL_Info *gl_info) {
memcpy(gl_info->glTypeLookup, glTypeLookupTemplate, sizeof(glTypeLookupTemplate));
if(!GL_SUPPORT(NV_HALF_FLOAT)) {
wined3d: Spelling fixes.
2008-01-09 20:37:05 +01:00
/* Do not change the size of the type, it is CPU side. We have to change the GPU-side information though.
wined3d: Move the GL info structure into the adapter.
2007-12-19 02:51:53 +01:00
* It is the job of the vertex buffer code to make sure that the vbos have the right format
*/
gl_info->glTypeLookup[WINED3DDECLTYPE_FLOAT16_2].glType = GL_FLOAT;
gl_info->glTypeLookup[WINED3DDECLTYPE_FLOAT16_4].glType = GL_FLOAT;
}
}
wined3d: Recompile glsl pixelshaders if the sampler format changes.
2007-09-21 23:47:40 +02:00
#undef GLINFO_LOCATION
#define GLINFO_LOCATION This->adapter->gl_info
wined3d: Store the gl format table in the gl info structure.
2007-07-27 13:22:54 +02:00
const StaticPixelFormatDesc *getFormatDescEntry(WINED3DFORMAT fmt, WineD3D_GL_Info *gl_info, const GlPixelFormatDesc **glDesc)
{
int idx = getFmtIdx(fmt);
if(idx == -1) {
FIXME("Can't find format %s(%d) in the format lookup table\n", debug_d3dformat(fmt), fmt);
/* Get the caller a valid pointer */
idx = getFmtIdx(WINED3DFMT_UNKNOWN);
}
if(glDesc) {
wined3d: Return a fake pixel format if gl is not loaded.
2008-03-28 23:04:34 +01:00
if(!gl_info->gl_formats) {
/* If we do not have gl format information, provide a dummy NULL format. This is an easy way to make
* all gl caps check return "unsupported" than catching the lack of gl all over the code. ANSI C requires
* static variables to be initialized to 0.
*/
static const GlPixelFormatDesc dummyFmt;
*glDesc = &dummyFmt;
} else {
*glDesc = &gl_info->gl_formats[idx];
wined3d: Store the gl format table in the gl info structure.
2007-07-27 13:22:54 +02:00
}
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
}
wined3d: Store the gl format table in the gl info structure.
2007-07-27 13:22:54 +02:00
return &formats[idx];
wined3d: Pixel format cleanup.
2006-06-21 10:36:14 +02:00
}
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
/*****************************************************************************
* Trace formatting of useful values
*/
Correct a few formats that were incorrect.
2005-07-13 21:38:39 +02:00
const char* debug_d3dformat(WINED3DFORMAT fmt) {
- Make d3d8 know about the wined3d device and start using it. - Move some of the screen mode related functions into wined3d and add untested support for the new d3d9 options of providing the format to some of the calls. - Move other functions from the directx interface into the common library and implement the calls from d3d9 as well. - Copy across the first of the functions used to make traces more readable, creating utils.c to store them in. Eventually the ones in d3d8 will be removed but for now just duplicate the code.
2004-09-28 04:12:12 +02:00
switch (fmt) {
#define FMT_TO_STR(fmt) case fmt: return #fmt
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
FMT_TO_STR(WINED3DFMT_UNKNOWN);
FMT_TO_STR(WINED3DFMT_R8G8B8);
FMT_TO_STR(WINED3DFMT_A8R8G8B8);
FMT_TO_STR(WINED3DFMT_X8R8G8B8);
FMT_TO_STR(WINED3DFMT_R5G6B5);
FMT_TO_STR(WINED3DFMT_X1R5G5B5);
FMT_TO_STR(WINED3DFMT_A1R5G5B5);
FMT_TO_STR(WINED3DFMT_A4R4G4B4);
FMT_TO_STR(WINED3DFMT_R3G3B2);
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
FMT_TO_STR(WINED3DFMT_A8);
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
FMT_TO_STR(WINED3DFMT_A8R3G3B2);
FMT_TO_STR(WINED3DFMT_X4R4G4B4);
wined3d: Add a couple more debugging output formats.
2006-04-03 17:01:19 +02:00
FMT_TO_STR(WINED3DFMT_A2B10G10R10);
wined3d: Add D3DFMT_L16.
2006-04-04 15:34:46 +02:00
FMT_TO_STR(WINED3DFMT_A8B8G8R8);
wined3d: Add a couple more debugging output formats.
2006-04-03 17:01:19 +02:00
FMT_TO_STR(WINED3DFMT_X8B8G8R8);
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
FMT_TO_STR(WINED3DFMT_G16R16);
FMT_TO_STR(WINED3DFMT_A2R10G10B10);
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
FMT_TO_STR(WINED3DFMT_A16B16G16R16);
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
FMT_TO_STR(WINED3DFMT_A8P8);
FMT_TO_STR(WINED3DFMT_P8);
FMT_TO_STR(WINED3DFMT_L8);
FMT_TO_STR(WINED3DFMT_A8L8);
FMT_TO_STR(WINED3DFMT_A4L4);
FMT_TO_STR(WINED3DFMT_V8U8);
FMT_TO_STR(WINED3DFMT_L6V5U5);
FMT_TO_STR(WINED3DFMT_X8L8V8U8);
FMT_TO_STR(WINED3DFMT_Q8W8V8U8);
FMT_TO_STR(WINED3DFMT_V16U16);
FMT_TO_STR(WINED3DFMT_W11V11U10);
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
FMT_TO_STR(WINED3DFMT_A2W10V10U10);
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
FMT_TO_STR(WINED3DFMT_UYVY);
FMT_TO_STR(WINED3DFMT_YUY2);
FMT_TO_STR(WINED3DFMT_DXT1);
FMT_TO_STR(WINED3DFMT_DXT2);
FMT_TO_STR(WINED3DFMT_DXT3);
FMT_TO_STR(WINED3DFMT_DXT4);
FMT_TO_STR(WINED3DFMT_DXT5);
d3d: Fix the D3DFMT_XXX constant declarations.
2007-01-17 17:32:09 +01:00
FMT_TO_STR(WINED3DFMT_MULTI2_ARGB8);
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
FMT_TO_STR(WINED3DFMT_G8R8_G8B8);
FMT_TO_STR(WINED3DFMT_R8G8_B8G8);
FMT_TO_STR(WINED3DFMT_D16_LOCKABLE);
FMT_TO_STR(WINED3DFMT_D32);
FMT_TO_STR(WINED3DFMT_D15S1);
FMT_TO_STR(WINED3DFMT_D24S8);
FMT_TO_STR(WINED3DFMT_D24X8);
FMT_TO_STR(WINED3DFMT_D24X4S4);
FMT_TO_STR(WINED3DFMT_D16);
wined3d: Add D3DFMT_L16.
2006-04-04 15:34:46 +02:00
FMT_TO_STR(WINED3DFMT_L16);
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
FMT_TO_STR(WINED3DFMT_D32F_LOCKABLE);
wined3d: Add D3DFMT_L16.
2006-04-04 15:34:46 +02:00
FMT_TO_STR(WINED3DFMT_D24FS8);
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
FMT_TO_STR(WINED3DFMT_VERTEXDATA);
FMT_TO_STR(WINED3DFMT_INDEX16);
FMT_TO_STR(WINED3DFMT_INDEX32);
FMT_TO_STR(WINED3DFMT_Q16W16V16U16);
FMT_TO_STR(WINED3DFMT_R16F);
FMT_TO_STR(WINED3DFMT_G16R16F);
FMT_TO_STR(WINED3DFMT_A16B16G16R16F);
wined3d: Add a few more WINED3DFMT formats to be recognized.
2006-03-06 03:26:19 +01:00
FMT_TO_STR(WINED3DFMT_R32F);
FMT_TO_STR(WINED3DFMT_G32R32F);
FMT_TO_STR(WINED3DFMT_A32B32G32R32F);
FMT_TO_STR(WINED3DFMT_CxV8U8);
- Make d3d8 know about the wined3d device and start using it. - Move some of the screen mode related functions into wined3d and add untested support for the new d3d9 options of providing the format to some of the calls. - Move other functions from the directx interface into the common library and implement the calls from d3d9 as well. - Copy across the first of the functions used to make traces more readable, creating utils.c to store them in. Eventually the ones in d3d8 will be removed but for now just duplicate the code.
2004-09-28 04:12:12 +02:00
#undef FMT_TO_STR
default:
wined3d: Also print the format like a fourcc if unknown in debug_d3dformat.
2006-06-09 17:29:57 +02:00
{
char fourcc[5];
fourcc[0] = (char)(fmt);
fourcc[1] = (char)(fmt >> 8);
fourcc[2] = (char)(fmt >> 16);
fourcc[3] = (char)(fmt >> 24);
fourcc[4] = 0;
if( isprint(fourcc[0]) && isprint(fourcc[1]) && isprint(fourcc[2]) && isprint(fourcc[3]) )
wined3d: D3DFORMAT: Consistently use WINED3D namespace.
2006-10-11 03:51:13 +02:00
FIXME("Unrecognized %u (as fourcc: %s) WINED3DFORMAT!\n", fmt, fourcc);
wined3d: Also print the format like a fourcc if unknown in debug_d3dformat.
2006-06-09 17:29:57 +02:00
else
wined3d: D3DFORMAT: Consistently use WINED3D namespace.
2006-10-11 03:51:13 +02:00
FIXME("Unrecognized %u WINED3DFORMAT!\n", fmt);
wined3d: Also print the format like a fourcc if unknown in debug_d3dformat.
2006-06-09 17:29:57 +02:00
}
- Make d3d8 know about the wined3d device and start using it. - Move some of the screen mode related functions into wined3d and add untested support for the new d3d9 options of providing the format to some of the calls. - Move other functions from the directx interface into the common library and implement the calls from d3d9 as well. - Copy across the first of the functions used to make traces more readable, creating utils.c to store them in. Eventually the ones in d3d8 will be removed but for now just duplicate the code.
2004-09-28 04:12:12 +02:00
return "unrecognized";
}
}
Move the Check* type functions into wined3d and copy from d3d9, and flag that they are mostly stubs.
2004-10-05 04:14:06 +02:00
wined3d: D3DDEVTYPE: Consistently use in WINED3D namespace.
2006-10-11 03:52:00 +02:00
const char* debug_d3ddevicetype(WINED3DDEVTYPE devtype) {
Move the Check* type functions into wined3d and copy from d3d9, and flag that they are mostly stubs.
2004-10-05 04:14:06 +02:00
switch (devtype) {
#define DEVTYPE_TO_STR(dev) case dev: return #dev
wined3d: D3DDEVTYPE: Consistently use in WINED3D namespace.
2006-10-11 03:52:00 +02:00
DEVTYPE_TO_STR(WINED3DDEVTYPE_HAL);
DEVTYPE_TO_STR(WINED3DDEVTYPE_REF);
DEVTYPE_TO_STR(WINED3DDEVTYPE_SW);
Move the Check* type functions into wined3d and copy from d3d9, and flag that they are mostly stubs.
2004-10-05 04:14:06 +02:00
#undef DEVTYPE_TO_STR
default:
wined3d: D3DDEVTYPE: Consistently use in WINED3D namespace.
2006-10-11 03:52:00 +02:00
FIXME("Unrecognized %u WINED3DDEVTYPE!\n", devtype);
Move the Check* type functions into wined3d and copy from d3d9, and flag that they are mostly stubs.
2004-10-05 04:14:06 +02:00
return "unrecognized";
}
}
const char* debug_d3dusage(DWORD usage) {
wined3d: Start checking for D3DUSAGE_QUERY_* items, improve traces.
2006-07-28 21:33:20 +02:00
switch (usage & WINED3DUSAGE_MASK) {
wined3d: Define D3D usage flags in wined3d_types.h.
2006-03-06 23:08:42 +01:00
#define WINED3DUSAGE_TO_STR(u) case u: return #u
WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET);
WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL);
WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY);
WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING);
WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP);
WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS);
WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES);
WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES);
WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC);
wined3d: Start checking for D3DUSAGE_QUERY_* items, improve traces.
2006-07-28 21:33:20 +02:00
WINED3DUSAGE_TO_STR(WINED3DUSAGE_AUTOGENMIPMAP);
WINED3DUSAGE_TO_STR(WINED3DUSAGE_DMAP);
wined3d: Define D3D usage flags in wined3d_types.h.
2006-03-06 23:08:42 +01:00
#undef WINED3DUSAGE_TO_STR
Move the Check* type functions into wined3d and copy from d3d9, and flag that they are mostly stubs.
2004-10-05 04:14:06 +02:00
case 0: return "none";
default:
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
FIXME("Unrecognized %u Usage!\n", usage);
Move the Check* type functions into wined3d and copy from d3d9, and flag that they are mostly stubs.
2004-10-05 04:14:06 +02:00
return "unrecognized";
}
}
wined3d: Start checking for D3DUSAGE_QUERY_* items, improve traces.
2006-07-28 21:33:20 +02:00
const char* debug_d3dusagequery(DWORD usagequery) {
switch (usagequery & WINED3DUSAGE_QUERY_MASK) {
#define WINED3DUSAGEQUERY_TO_STR(u) case u: return #u
WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_FILTER);
WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_LEGACYBUMPMAP);
WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING);
WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBREAD);
WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBWRITE);
WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_VERTEXTEXTURE);
WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_WRAPANDMIP);
#undef WINED3DUSAGEQUERY_TO_STR
case 0: return "none";
default:
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
FIXME("Unrecognized %u Usage Query!\n", usagequery);
wined3d: Start checking for D3DUSAGE_QUERY_* items, improve traces.
2006-07-28 21:33:20 +02:00
return "unrecognized";
}
}
wined3d: Add a couple of traces to the vertexdeclaration creation code.
2006-08-07 19:21:54 +02:00
const char* debug_d3ddeclmethod(WINED3DDECLMETHOD method) {
switch (method) {
#define WINED3DDECLMETHOD_TO_STR(u) case u: return #u
WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_DEFAULT);
WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALU);
WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALV);
WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_CROSSUV);
WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_UV);
WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUP);
WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUPPRESAMPLED);
#undef WINED3DDECLMETHOD_TO_STR
default:
FIXME("Unrecognized %u declaration method!\n", method);
return "unrecognized";
}
}
const char* debug_d3ddecltype(WINED3DDECLTYPE type) {
switch (type) {
#define WINED3DDECLTYPE_TO_STR(u) case u: return #u
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT1);
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT2);
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT3);
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT4);
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_D3DCOLOR);
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UBYTE4);
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT2);
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT4);
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UBYTE4N);
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT2N);
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT4N);
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_USHORT2N);
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_USHORT4N);
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UDEC3);
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_DEC3N);
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT16_2);
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT16_4);
WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UNUSED);
#undef WINED3DDECLTYPE_TO_STR
default:
FIXME("Unrecognized %u declaration type!\n", type);
return "unrecognized";
}
}
wined3d: Add a function to print out D3DDECLUSAGE9 values.
2006-07-03 08:11:15 +02:00
const char* debug_d3ddeclusage(BYTE usage) {
switch (usage) {
#define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
wined3d: Add WINED3DDECLUSAGE, use it.
2007-02-13 23:12:14 +01:00
WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITION);
WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDWEIGHT);
WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDINDICES);
WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_NORMAL);
WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_PSIZE);
WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TEXCOORD);
WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TANGENT);
WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BINORMAL);
WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TESSFACTOR);
WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITIONT);
WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_COLOR);
WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_FOG);
WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_DEPTH);
WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_SAMPLE);
wined3d: Add a function to print out D3DDECLUSAGE9 values.
2006-07-03 08:11:15 +02:00
#undef WINED3DDECLUSAGE_TO_STR
default:
FIXME("Unrecognized %u declaration usage!\n", usage);
return "unrecognized";
}
}
wined3d: Consistently use WINED3DRESOURCETYPE.
2006-03-09 23:21:16 +01:00
const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res) {
Move the Check* type functions into wined3d and copy from d3d9, and flag that they are mostly stubs.
2004-10-05 04:14:06 +02:00
switch (res) {
#define RES_TO_STR(res) case res: return #res;
wined3d: Consistently use WINED3DRESOURCETYPE.
2006-03-09 23:21:16 +01:00
RES_TO_STR(WINED3DRTYPE_SURFACE);
RES_TO_STR(WINED3DRTYPE_VOLUME);
RES_TO_STR(WINED3DRTYPE_TEXTURE);
RES_TO_STR(WINED3DRTYPE_VOLUMETEXTURE);
RES_TO_STR(WINED3DRTYPE_CUBETEXTURE);
RES_TO_STR(WINED3DRTYPE_VERTEXBUFFER);
RES_TO_STR(WINED3DRTYPE_INDEXBUFFER);
Move the Check* type functions into wined3d and copy from d3d9, and flag that they are mostly stubs.
2004-10-05 04:14:06 +02:00
#undef RES_TO_STR
default:
wined3d: Consistently use WINED3DRESOURCETYPE.
2006-03-09 23:21:16 +01:00
FIXME("Unrecognized %u WINED3DRESOURCETYPE!\n", res);
Move the Check* type functions into wined3d and copy from d3d9, and flag that they are mostly stubs.
2004-10-05 04:14:06 +02:00
return "unrecognized";
}
}
Add {G,S}etIndices, {G,S}Viewport and enable the basic drawing functionality into wined3d and call from d3d9.
2004-12-09 12:42:34 +01:00
wined3d: Merge D3DPRIMITIVETYPE types into one type in WINED3D namespace.
2006-10-12 08:23:55 +02:00
const char* debug_d3dprimitivetype(WINED3DPRIMITIVETYPE PrimitiveType) {
Add {G,S}etIndices, {G,S}Viewport and enable the basic drawing functionality into wined3d and call from d3d9.
2004-12-09 12:42:34 +01:00
switch (PrimitiveType) {
#define PRIM_TO_STR(prim) case prim: return #prim;
wined3d: Merge D3DPRIMITIVETYPE types into one type in WINED3D namespace.
2006-10-12 08:23:55 +02:00
PRIM_TO_STR(WINED3DPT_POINTLIST);
PRIM_TO_STR(WINED3DPT_LINELIST);
PRIM_TO_STR(WINED3DPT_LINESTRIP);
PRIM_TO_STR(WINED3DPT_TRIANGLELIST);
PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP);
PRIM_TO_STR(WINED3DPT_TRIANGLEFAN);
Add {G,S}etIndices, {G,S}Viewport and enable the basic drawing functionality into wined3d and call from d3d9.
2004-12-09 12:42:34 +01:00
#undef PRIM_TO_STR
default:
wined3d: Merge D3DPRIMITIVETYPE types into one type in WINED3D namespace.
2006-10-12 08:23:55 +02:00
FIXME("Unrecognized %u WINED3DPRIMITIVETYPE!\n", PrimitiveType);
Add {G,S}etIndices, {G,S}Viewport and enable the basic drawing functionality into wined3d and call from d3d9.
2004-12-09 12:42:34 +01:00
return "unrecognized";
}
}
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
const char* debug_d3drenderstate(DWORD state) {
switch (state) {
#define D3DSTATE_TO_STR(u) case u: return #u
wined3d: Add missing render states to the dumping function.
2006-05-15 20:28:13 +02:00
D3DSTATE_TO_STR(WINED3DRS_TEXTUREHANDLE );
D3DSTATE_TO_STR(WINED3DRS_ANTIALIAS );
D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESS );
D3DSTATE_TO_STR(WINED3DRS_TEXTUREPERSPECTIVE );
D3DSTATE_TO_STR(WINED3DRS_WRAPU );
D3DSTATE_TO_STR(WINED3DRS_WRAPV );
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
D3DSTATE_TO_STR(WINED3DRS_ZENABLE );
D3DSTATE_TO_STR(WINED3DRS_FILLMODE );
D3DSTATE_TO_STR(WINED3DRS_SHADEMODE );
D3DSTATE_TO_STR(WINED3DRS_LINEPATTERN );
wined3d: Add missing render states to the dumping function.
2006-05-15 20:28:13 +02:00
D3DSTATE_TO_STR(WINED3DRS_MONOENABLE );
D3DSTATE_TO_STR(WINED3DRS_ROP2 );
D3DSTATE_TO_STR(WINED3DRS_PLANEMASK );
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
D3DSTATE_TO_STR(WINED3DRS_ZWRITEENABLE );
D3DSTATE_TO_STR(WINED3DRS_ALPHATESTENABLE );
D3DSTATE_TO_STR(WINED3DRS_LASTPIXEL );
wined3d: Add missing render states to the dumping function.
2006-05-15 20:28:13 +02:00
D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAG );
D3DSTATE_TO_STR(WINED3DRS_TEXTUREMIN );
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
D3DSTATE_TO_STR(WINED3DRS_SRCBLEND );
D3DSTATE_TO_STR(WINED3DRS_DESTBLEND );
wined3d: Add missing render states to the dumping function.
2006-05-15 20:28:13 +02:00
D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAPBLEND );
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
D3DSTATE_TO_STR(WINED3DRS_CULLMODE );
D3DSTATE_TO_STR(WINED3DRS_ZFUNC );
D3DSTATE_TO_STR(WINED3DRS_ALPHAREF );
D3DSTATE_TO_STR(WINED3DRS_ALPHAFUNC );
D3DSTATE_TO_STR(WINED3DRS_DITHERENABLE );
D3DSTATE_TO_STR(WINED3DRS_ALPHABLENDENABLE );
D3DSTATE_TO_STR(WINED3DRS_FOGENABLE );
D3DSTATE_TO_STR(WINED3DRS_SPECULARENABLE );
D3DSTATE_TO_STR(WINED3DRS_ZVISIBLE );
wined3d: Add missing render states to the dumping function.
2006-05-15 20:28:13 +02:00
D3DSTATE_TO_STR(WINED3DRS_SUBPIXEL );
D3DSTATE_TO_STR(WINED3DRS_SUBPIXELX );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEDALPHA );
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
D3DSTATE_TO_STR(WINED3DRS_FOGCOLOR );
D3DSTATE_TO_STR(WINED3DRS_FOGTABLEMODE );
D3DSTATE_TO_STR(WINED3DRS_FOGSTART );
D3DSTATE_TO_STR(WINED3DRS_FOGEND );
D3DSTATE_TO_STR(WINED3DRS_FOGDENSITY );
wined3d: Add missing render states to the dumping function.
2006-05-15 20:28:13 +02:00
D3DSTATE_TO_STR(WINED3DRS_STIPPLEENABLE );
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
D3DSTATE_TO_STR(WINED3DRS_EDGEANTIALIAS );
wined3d: Add missing render states to the dumping function.
2006-05-15 20:28:13 +02:00
D3DSTATE_TO_STR(WINED3DRS_COLORKEYENABLE );
D3DSTATE_TO_STR(WINED3DRS_BORDERCOLOR );
D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSU );
D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSV );
D3DSTATE_TO_STR(WINED3DRS_MIPMAPLODBIAS );
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
D3DSTATE_TO_STR(WINED3DRS_ZBIAS );
D3DSTATE_TO_STR(WINED3DRS_RANGEFOGENABLE );
wined3d: Add missing render states to the dumping function.
2006-05-15 20:28:13 +02:00
D3DSTATE_TO_STR(WINED3DRS_ANISOTROPY );
D3DSTATE_TO_STR(WINED3DRS_FLUSHBATCH );
D3DSTATE_TO_STR(WINED3DRS_TRANSLUCENTSORTINDEPENDENT);
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
D3DSTATE_TO_STR(WINED3DRS_STENCILENABLE );
D3DSTATE_TO_STR(WINED3DRS_STENCILFAIL );
D3DSTATE_TO_STR(WINED3DRS_STENCILZFAIL );
D3DSTATE_TO_STR(WINED3DRS_STENCILPASS );
D3DSTATE_TO_STR(WINED3DRS_STENCILFUNC );
D3DSTATE_TO_STR(WINED3DRS_STENCILREF );
D3DSTATE_TO_STR(WINED3DRS_STENCILMASK );
D3DSTATE_TO_STR(WINED3DRS_STENCILWRITEMASK );
D3DSTATE_TO_STR(WINED3DRS_TEXTUREFACTOR );
wined3d: Add WINED3DRS_STIPPLEPATTERNxy.
2006-12-17 17:21:30 +01:00
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN00 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN01 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN02 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN03 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN04 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN05 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN06 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN07 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN08 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN09 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN10 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN11 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN12 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN13 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN14 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN15 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN16 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN17 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN18 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN19 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN20 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN21 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN22 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN23 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN24 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN25 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN26 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN27 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN28 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN29 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN30 );
D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN31 );
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
D3DSTATE_TO_STR(WINED3DRS_WRAP0 );
D3DSTATE_TO_STR(WINED3DRS_WRAP1 );
D3DSTATE_TO_STR(WINED3DRS_WRAP2 );
D3DSTATE_TO_STR(WINED3DRS_WRAP3 );
D3DSTATE_TO_STR(WINED3DRS_WRAP4 );
D3DSTATE_TO_STR(WINED3DRS_WRAP5 );
D3DSTATE_TO_STR(WINED3DRS_WRAP6 );
D3DSTATE_TO_STR(WINED3DRS_WRAP7 );
D3DSTATE_TO_STR(WINED3DRS_CLIPPING );
D3DSTATE_TO_STR(WINED3DRS_LIGHTING );
wined3d: Add missing render states to the dumping function.
2006-05-15 20:28:13 +02:00
D3DSTATE_TO_STR(WINED3DRS_EXTENTS );
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
D3DSTATE_TO_STR(WINED3DRS_AMBIENT );
D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE );
D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX );
D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER );
D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS );
wined3d: Add missing render states to the dumping function.
2006-05-15 20:28:13 +02:00
D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE );
Added a stubbed out version of query to d3d9 and wined3d. Update the d3d9 headers and creates wined3d types where d3d9 and d3d8 are incompatible.
2005-03-03 14:57:15 +01:00
D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE );
D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE );
D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE );
D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE );
D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND );
D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE );
D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING );
D3DSTATE_TO_STR(WINED3DRS_POINTSIZE );
D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN );
D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE );
D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE );
D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A );
D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B );
D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C );
D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS );
D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK );
D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE );
D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS );
D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN );
D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX );
D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE );
D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE );
D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR );
D3DSTATE_TO_STR(WINED3DRS_BLENDOP );
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE );
D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE );
wined3d: Extend debug_d3drenderstate with missing states.
2006-02-11 12:15:31 +01:00
D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE );
D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS );
D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE );
D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL );
D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL );
D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X );
D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y );
D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z );
D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W );
D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION);
D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE );
D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL );
D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL );
D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS );
D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC );
D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1 );
D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2 );
D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3 );
D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR );
D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE );
D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS );
D3DSTATE_TO_STR(WINED3DRS_WRAP8 );
D3DSTATE_TO_STR(WINED3DRS_WRAP9 );
D3DSTATE_TO_STR(WINED3DRS_WRAP10 );
D3DSTATE_TO_STR(WINED3DRS_WRAP11 );
D3DSTATE_TO_STR(WINED3DRS_WRAP12 );
D3DSTATE_TO_STR(WINED3DRS_WRAP13 );
D3DSTATE_TO_STR(WINED3DRS_WRAP14 );
D3DSTATE_TO_STR(WINED3DRS_WRAP15 );
D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE );
D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA );
D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA );
D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA );
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
#undef D3DSTATE_TO_STR
default:
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
FIXME("Unrecognized %u render state!\n", state);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
return "unrecognized";
}
}
Add support for samplers. Switch from using d3d9 constants to wined3d constants so that there's no recursive dependencies.
2005-06-24 13:53:07 +02:00
const char* debug_d3dsamplerstate(DWORD state) {
switch (state) {
#define D3DSTATE_TO_STR(u) case u: return #u
D3DSTATE_TO_STR(WINED3DSAMP_BORDERCOLOR );
D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSU );
D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSV );
D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSW );
D3DSTATE_TO_STR(WINED3DSAMP_MAGFILTER );
D3DSTATE_TO_STR(WINED3DSAMP_MINFILTER );
D3DSTATE_TO_STR(WINED3DSAMP_MIPFILTER );
D3DSTATE_TO_STR(WINED3DSAMP_MIPMAPLODBIAS);
D3DSTATE_TO_STR(WINED3DSAMP_MAXMIPLEVEL );
D3DSTATE_TO_STR(WINED3DSAMP_MAXANISOTROPY);
Correct a few formats that were incorrect.
2005-07-13 21:38:39 +02:00
D3DSTATE_TO_STR(WINED3DSAMP_SRGBTEXTURE );
D3DSTATE_TO_STR(WINED3DSAMP_ELEMENTINDEX );
D3DSTATE_TO_STR(WINED3DSAMP_DMAPOFFSET );
Add support for samplers. Switch from using d3d9 constants to wined3d constants so that there's no recursive dependencies.
2005-06-24 13:53:07 +02:00
#undef D3DSTATE_TO_STR
default:
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
FIXME("Unrecognized %u sampler state!\n", state);
Add support for samplers. Switch from using d3d9 constants to wined3d constants so that there's no recursive dependencies.
2005-06-24 13:53:07 +02:00
return "unrecognized";
}
}
wined3d: Add a function to dump WINED3DTEXTUREFILTERTYPE values.
2007-04-09 01:53:38 +02:00
const char *debug_d3dtexturefiltertype(WINED3DTEXTUREFILTERTYPE filter_type) {
switch (filter_type) {
#define D3DTEXTUREFILTERTYPE_TO_STR(u) case u: return #u
D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_NONE);
D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_POINT);
D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_LINEAR);
D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_ANISOTROPIC);
D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_FLATCUBIC);
D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANCUBIC);
D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_PYRAMIDALQUAD);
D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANQUAD);
#undef D3DTEXTUREFILTERTYPE_TO_STR
default:
FIXME("Unrecognied texture filter type 0x%08x\n", filter_type);
return "unrecognized";
}
}
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
const char* debug_d3dtexturestate(DWORD state) {
switch (state) {
#define D3DSTATE_TO_STR(u) case u: return #u
Add support for samplers. Switch from using d3d9 constants to wined3d constants so that there's no recursive dependencies.
2005-06-24 13:53:07 +02:00
D3DSTATE_TO_STR(WINED3DTSS_COLOROP );
D3DSTATE_TO_STR(WINED3DTSS_COLORARG1 );
D3DSTATE_TO_STR(WINED3DTSS_COLORARG2 );
D3DSTATE_TO_STR(WINED3DTSS_ALPHAOP );
D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG1 );
D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG2 );
D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT00 );
D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT01 );
D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT10 );
D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT11 );
D3DSTATE_TO_STR(WINED3DTSS_TEXCOORDINDEX );
D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLSCALE );
D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLOFFSET );
D3DSTATE_TO_STR(WINED3DTSS_TEXTURETRANSFORMFLAGS );
D3DSTATE_TO_STR(WINED3DTSS_ADDRESSW );
D3DSTATE_TO_STR(WINED3DTSS_COLORARG0 );
D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG0 );
D3DSTATE_TO_STR(WINED3DTSS_RESULTARG );
Correct a few formats that were incorrect.
2005-07-13 21:38:39 +02:00
D3DSTATE_TO_STR(WINED3DTSS_CONSTANT );
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
#undef D3DSTATE_TO_STR
case 12:
wined3d: D3DTEXTURESTAGESTATETYPE: Consistently use in WINED3D namespace.
2006-10-11 03:52:50 +02:00
/* Note WINED3DTSS are not consecutive, so skip these */
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
return "unused";
default:
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
FIXME("Unrecognized %u texture state!\n", state);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
return "unrecognized";
}
}
Mark several functions as static.
2007-03-12 16:50:54 +01:00
static const char* debug_d3dtop(WINED3DTEXTUREOP d3dtop) {
wined3d: Add & use D3DTEXTUREOP dumping code.
2006-06-27 23:40:02 +02:00
switch (d3dtop) {
#define D3DTOP_TO_STR(u) case u: return #u
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
D3DTOP_TO_STR(WINED3DTOP_DISABLE);
D3DTOP_TO_STR(WINED3DTOP_SELECTARG1);
D3DTOP_TO_STR(WINED3DTOP_SELECTARG2);
D3DTOP_TO_STR(WINED3DTOP_MODULATE);
D3DTOP_TO_STR(WINED3DTOP_MODULATE2X);
D3DTOP_TO_STR(WINED3DTOP_MODULATE4X);
D3DTOP_TO_STR(WINED3DTOP_ADD);
D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED);
wined3d: Add WINED3DTOP_ADDSIGNED2X to debug_d3dtop().
2008-05-24 10:33:25 +02:00
D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED2X);
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
D3DTOP_TO_STR(WINED3DTOP_SUBTRACT);
D3DTOP_TO_STR(WINED3DTOP_ADDSMOOTH);
D3DTOP_TO_STR(WINED3DTOP_BLENDDIFFUSEALPHA);
D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHA);
D3DTOP_TO_STR(WINED3DTOP_BLENDFACTORALPHA);
D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHAPM);
D3DTOP_TO_STR(WINED3DTOP_BLENDCURRENTALPHA);
D3DTOP_TO_STR(WINED3DTOP_PREMODULATE);
D3DTOP_TO_STR(WINED3DTOP_MODULATEALPHA_ADDCOLOR);
D3DTOP_TO_STR(WINED3DTOP_MODULATECOLOR_ADDALPHA);
D3DTOP_TO_STR(WINED3DTOP_MODULATEINVALPHA_ADDCOLOR);
D3DTOP_TO_STR(WINED3DTOP_MODULATEINVCOLOR_ADDALPHA);
D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAP);
D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAPLUMINANCE);
D3DTOP_TO_STR(WINED3DTOP_DOTPRODUCT3);
D3DTOP_TO_STR(WINED3DTOP_MULTIPLYADD);
D3DTOP_TO_STR(WINED3DTOP_LERP);
wined3d: Add & use D3DTEXTUREOP dumping code.
2006-06-27 23:40:02 +02:00
#undef D3DTOP_TO_STR
default:
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
FIXME("Unrecognized %u WINED3DTOP\n", d3dtop);
wined3d: Add & use D3DTEXTUREOP dumping code.
2006-06-27 23:40:02 +02:00
return "unrecognized";
}
}
wined3d: Improve traces for D3DTRANSFORMSTATETYPE. Added debug function for WINED3DTRANSFORMSTATETYPE and changed all references from D3DTS_* to WINED3DTS_*.
2006-07-24 04:54:30 +02:00
const char* debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype) {
switch (tstype) {
#define TSTYPE_TO_STR(tstype) case tstype: return #tstype
TSTYPE_TO_STR(WINED3DTS_VIEW);
TSTYPE_TO_STR(WINED3DTS_PROJECTION);
TSTYPE_TO_STR(WINED3DTS_TEXTURE0);
TSTYPE_TO_STR(WINED3DTS_TEXTURE1);
TSTYPE_TO_STR(WINED3DTS_TEXTURE2);
TSTYPE_TO_STR(WINED3DTS_TEXTURE3);
TSTYPE_TO_STR(WINED3DTS_TEXTURE4);
TSTYPE_TO_STR(WINED3DTS_TEXTURE5);
TSTYPE_TO_STR(WINED3DTS_TEXTURE6);
TSTYPE_TO_STR(WINED3DTS_TEXTURE7);
TSTYPE_TO_STR(WINED3DTS_WORLDMATRIX(0));
#undef TSTYPE_TO_STR
default:
if (tstype > 256 && tstype < 512) {
FIXME("WINED3DTS_WORLDMATRIX(%u). 1..255 not currently supported\n", tstype);
return ("WINED3DTS_WORLDMATRIX > 0");
}
FIXME("Unrecognized %u WINED3DTS\n", tstype);
return "unrecognized";
}
}
wined3d: Add WINED3DPOOL to wined3d_types.h.
2006-03-28 14:20:47 +02:00
const char* debug_d3dpool(WINED3DPOOL Pool) {
- Add texture support for all the texture types for d3d9->wined3d. - Add prototypes for the COM interfaces. - Fix some incorrect types from the last patch.
2005-01-17 14:44:57 +01:00
switch (Pool) {
#define POOL_TO_STR(p) case p: return #p;
wined3d: Add WINED3DPOOL to wined3d_types.h.
2006-03-28 14:20:47 +02:00
POOL_TO_STR(WINED3DPOOL_DEFAULT);
POOL_TO_STR(WINED3DPOOL_MANAGED);
POOL_TO_STR(WINED3DPOOL_SYSTEMMEM);
POOL_TO_STR(WINED3DPOOL_SCRATCH);
- Add texture support for all the texture types for d3d9->wined3d. - Add prototypes for the COM interfaces. - Fix some incorrect types from the last patch.
2005-01-17 14:44:57 +01:00
#undef POOL_TO_STR
default:
wined3d: Add WINED3DPOOL to wined3d_types.h.
2006-03-28 14:20:47 +02:00
FIXME("Unrecognized %u WINED3DPOOL!\n", Pool);
- Add texture support for all the texture types for d3d9->wined3d. - Add prototypes for the COM interfaces. - Fix some incorrect types from the last patch.
2005-01-17 14:44:57 +01:00
return "unrecognized";
}
}
wined3d: Add a couple of traces to the vertexdeclaration creation code.
2006-08-07 19:21:54 +02:00
wined3d: Add a function for dumping FBO status codes.
2007-04-16 21:19:12 +02:00
const char *debug_fbostatus(GLenum status) {
switch(status) {
#define FBOSTATUS_TO_STR(u) case u: return #u
FBOSTATUS_TO_STR(GL_FRAMEBUFFER_COMPLETE_EXT);
FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT);
FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT);
FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT);
FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT);
FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT);
FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT);
FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNSUPPORTED_EXT);
#undef FBOSTATUS_TO_STR
default:
FIXME("Unrecognied FBO status 0x%08x\n", status);
return "unrecognized";
}
}
wined3d: Output pretty GL errors in checkGLcall and vcheckGLcall.
2007-04-23 22:02:50 +02:00
const char *debug_glerror(GLenum error) {
switch(error) {
#define GLERROR_TO_STR(u) case u: return #u
GLERROR_TO_STR(GL_NO_ERROR);
GLERROR_TO_STR(GL_INVALID_ENUM);
GLERROR_TO_STR(GL_INVALID_VALUE);
GLERROR_TO_STR(GL_INVALID_OPERATION);
GLERROR_TO_STR(GL_STACK_OVERFLOW);
GLERROR_TO_STR(GL_STACK_UNDERFLOW);
GLERROR_TO_STR(GL_OUT_OF_MEMORY);
GLERROR_TO_STR(GL_INVALID_FRAMEBUFFER_OPERATION_EXT);
#undef GLERROR_TO_STR
default:
FIXME("Unrecognied GL error 0x%08x\n", error);
return "unrecognized";
}
}
wined3d: Implement high order patches.
2007-07-04 17:57:45 +02:00
const char *debug_d3dbasis(WINED3DBASISTYPE basis) {
switch(basis) {
case WINED3DBASIS_BEZIER: return "WINED3DBASIS_BEZIER";
case WINED3DBASIS_BSPLINE: return "WINED3DBASIS_BSPLINE";
case WINED3DBASIS_INTERPOLATE: return "WINED3DBASIS_INTERPOLATE";
default: return "unrecognized";
}
}
const char *debug_d3ddegree(WINED3DDEGREETYPE degree) {
switch(degree) {
case WINED3DDEGREE_LINEAR: return "WINED3DDEGREE_LINEAR";
case WINED3DDEGREE_QUADRATIC: return "WINED3DDEGREE_QUADRATIC";
case WINED3DDEGREE_CUBIC: return "WINED3DDEGREE_CUBIC";
case WINED3DDEGREE_QUINTIC: return "WINED3DDEGREE_QUINTIC";
default: return "unrecognized";
}
}
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
/*****************************************************************************
* Useful functions mapping GL <-> D3D values
*/
GLenum StencilOp(DWORD op) {
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
switch(op) {
wined3d: Add D3DSTENCILOP to the WINED3D namespace.
2006-10-30 03:44:22 +01:00
case WINED3DSTENCILOP_KEEP : return GL_KEEP;
case WINED3DSTENCILOP_ZERO : return GL_ZERO;
case WINED3DSTENCILOP_REPLACE : return GL_REPLACE;
case WINED3DSTENCILOP_INCRSAT : return GL_INCR;
case WINED3DSTENCILOP_DECRSAT : return GL_DECR;
case WINED3DSTENCILOP_INVERT : return GL_INVERT;
case WINED3DSTENCILOP_INCR : return GL_INCR_WRAP_EXT;
case WINED3DSTENCILOP_DECR : return GL_DECR_WRAP_EXT;
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
default:
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
FIXME("Unrecognized stencil op %d\n", op);
wined3d: Fix stencil related render states.
2006-06-09 17:32:18 +02:00
return GL_KEEP;
}
}
wined3d: Use a common function for all D3DCMPFUNC -> GLenum conversions.
2006-08-25 16:28:34 +02:00
GLenum CompareFunc(DWORD func) {
wined3d: Add D3DCMPFUNC to the WINED3D namespace.
2006-10-30 03:44:58 +01:00
switch ((WINED3DCMPFUNC)func) {
case WINED3DCMP_NEVER : return GL_NEVER;
case WINED3DCMP_LESS : return GL_LESS;
case WINED3DCMP_EQUAL : return GL_EQUAL;
case WINED3DCMP_LESSEQUAL : return GL_LEQUAL;
case WINED3DCMP_GREATER : return GL_GREATER;
case WINED3DCMP_NOTEQUAL : return GL_NOTEQUAL;
case WINED3DCMP_GREATEREQUAL : return GL_GEQUAL;
case WINED3DCMP_ALWAYS : return GL_ALWAYS;
wined3d: Fix stencil related render states.
2006-06-09 17:32:18 +02:00
default:
wined3d: Add D3DCMPFUNC to the WINED3D namespace.
2006-10-30 03:44:58 +01:00
FIXME("Unrecognized WINED3DCMPFUNC value %d\n", func);
wined3d: Use a common function for all D3DCMPFUNC -> GLenum conversions.
2006-08-25 16:28:34 +02:00
return 0;
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
}
}
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
static GLenum d3dta_to_combiner_input(DWORD d3dta, DWORD stage, INT texture_idx) {
switch (d3dta) {
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
case WINED3DTA_DIFFUSE:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
return GL_PRIMARY_COLOR_NV;
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
case WINED3DTA_CURRENT:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
if (stage) return GL_SPARE0_NV;
else return GL_PRIMARY_COLOR_NV;
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
case WINED3DTA_TEXTURE:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
if (texture_idx > -1) return GL_TEXTURE0_ARB + texture_idx;
else return GL_PRIMARY_COLOR_NV;
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
case WINED3DTA_TFACTOR:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
return GL_CONSTANT_COLOR0_NV;
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
case WINED3DTA_SPECULAR:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
return GL_SECONDARY_COLOR_NV;
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
case WINED3DTA_TEMP:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
return GL_SPARE1_NV;
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
case WINED3DTA_CONSTANT:
wined3d: D3DTEXTURESTAGESTATETYPE: Consistently use in WINED3D namespace.
2006-10-11 03:52:50 +02:00
/* TODO: Support per stage constants (WINED3DTSS_CONSTANT, NV_register_combiners2) */
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
FIXME("WINED3DTA_CONSTANT, not properly supported.\n");
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
return GL_CONSTANT_COLOR1_NV;
default:
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
FIXME("Unrecognized texture arg %#x\n", d3dta);
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
return GL_TEXTURE;
}
}
static GLenum invert_mapping(GLenum mapping) {
if (mapping == GL_UNSIGNED_INVERT_NV) return GL_SIGNED_IDENTITY_NV;
else if (mapping == GL_SIGNED_IDENTITY_NV) return GL_UNSIGNED_INVERT_NV;
FIXME("Unhandled mapping %#x\n", mapping);
return mapping;
}
static void get_src_and_opr_nvrc(DWORD stage, DWORD arg, BOOL is_alpha, GLenum* input, GLenum* mapping, GLenum *component_usage, INT texture_idx) {
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
/* The WINED3DTA_COMPLEMENT flag specifies the complement of the input should
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
* be used. */
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
if (arg & WINED3DTA_COMPLEMENT) *mapping = GL_UNSIGNED_INVERT_NV;
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
else *mapping = GL_SIGNED_IDENTITY_NV;
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
/* The WINED3DTA_ALPHAREPLICATE flag specifies the alpha component of the input
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
* should be used for all input components. */
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
if (is_alpha || arg & WINED3DTA_ALPHAREPLICATE) *component_usage = GL_ALPHA;
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
else *component_usage = GL_RGB;
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
*input = d3dta_to_combiner_input(arg & WINED3DTA_SELECTMASK, stage, texture_idx);
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
}
typedef struct {
GLenum input[3];
GLenum mapping[3];
GLenum component_usage[3];
} tex_op_args;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
static BOOL is_invalid_op(IWineD3DDeviceImpl *This, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3) {
if (op == WINED3DTOP_DISABLE) return FALSE;
wined3d: Texture stages that reference NULL textures should just pass through the result of the previous stage.
2006-07-12 00:44:03 +02:00
if (This->stateBlock->textures[stage]) return FALSE;
wined3d: Mask texture stage state arguments with WINED3DTA_SELECTMASK when comparing them.
2007-06-17 23:39:24 +02:00
if ((arg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
&& op != WINED3DTOP_SELECTARG2) return TRUE;
if ((arg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
&& op != WINED3DTOP_SELECTARG1) return TRUE;
if ((arg3 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
&& (op == WINED3DTOP_MULTIPLYADD || op == WINED3DTOP_LERP)) return TRUE;
wined3d: Texture stages that reference NULL textures should just pass through the result of the previous stage.
2006-07-12 00:44:03 +02:00
return FALSE;
}
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
void set_tex_op_nvrc(IWineD3DDevice *iface, BOOL is_alpha, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3, INT texture_idx, DWORD dst) {
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl*)iface;
tex_op_args tex_op_args = {{0}, {0}, {0}};
GLenum portion = is_alpha ? GL_ALPHA : GL_RGB;
GLenum target = GL_COMBINER0_NV + stage;
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
GLenum output;
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
TRACE("stage %d, is_alpha %d, op %s, arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d\n",
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
stage, is_alpha, debug_d3dtop(op), arg1, arg2, arg3, texture_idx);
wined3d: Texture stages that reference NULL textures should just pass through the result of the previous stage.
2006-07-12 00:44:03 +02:00
/* If a texture stage references an invalid texture unit the stage just
* passes through the result from the previous stage */
if (is_invalid_op(This, stage, op, arg1, arg2, arg3)) {
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
arg1 = WINED3DTA_CURRENT;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
op = WINED3DTOP_SELECTARG1;
wined3d: Texture stages that reference NULL textures should just pass through the result of the previous stage.
2006-07-12 00:44:03 +02:00
}
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
get_src_and_opr_nvrc(stage, arg1, is_alpha, &tex_op_args.input[0],
&tex_op_args.mapping[0], &tex_op_args.component_usage[0], texture_idx);
get_src_and_opr_nvrc(stage, arg2, is_alpha, &tex_op_args.input[1],
&tex_op_args.mapping[1], &tex_op_args.component_usage[1], texture_idx);
get_src_and_opr_nvrc(stage, arg3, is_alpha, &tex_op_args.input[2],
&tex_op_args.mapping[2], &tex_op_args.component_usage[2], texture_idx);
wined3d: Activate a context before doing opengl calls.
2007-03-17 23:00:39 +01:00
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
if(dst == WINED3DTA_TEMP) {
output = GL_SPARE1_NV;
} else {
output = GL_SPARE0_NV;
}
wined3d: Activate a context before doing opengl calls.
2007-03-17 23:00:39 +01:00
/* This is called by a state handler which has the gl lock held and a context for the thread */
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
switch(op)
{
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_DISABLE:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
/* Only for alpha */
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
if (!is_alpha) ERR("Shouldn't be called for WINED3DTSS_COLOROP (WINED3DTOP_DISABLE)\n");
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
/* Input, prev_alpha*1 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_SELECTARG1:
case WINED3DTOP_SELECTARG2:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
/* Input, arg*1 */
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
if (op == WINED3DTOP_SELECTARG1) {
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
} else {
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
}
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
/* Output */
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATE:
case WINED3DTOP_MODULATE2X:
case WINED3DTOP_MODULATE4X:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
/* Input, arg1*arg2 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
/* Output */
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
if (op == WINED3DTOP_MODULATE) {
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
} else if (op == WINED3DTOP_MODULATE2X) {
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_DISCARD_NV, GL_SCALE_BY_TWO_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
} else if (op == WINED3DTOP_MODULATE4X) {
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_DISCARD_NV, GL_SCALE_BY_FOUR_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
}
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_ADD:
case WINED3DTOP_ADDSIGNED:
case WINED3DTOP_ADDSIGNED2X:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
/* Input, arg1*1+arg2*1 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
/* Output */
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
if (op == WINED3DTOP_ADD) {
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
} else if (op == WINED3DTOP_ADDSIGNED) {
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
output, GL_NONE, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_FALSE, GL_FALSE, GL_FALSE));
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
} else if (op == WINED3DTOP_ADDSIGNED2X) {
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
output, GL_SCALE_BY_TWO_NV, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_FALSE, GL_FALSE, GL_FALSE));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
}
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_SUBTRACT:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
/* Input, arg1*1+-arg2*1 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[1], GL_SIGNED_NEGATE_NV, tex_op_args.component_usage[1]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_ADDSMOOTH:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
/* Input, arg1*1+(1-arg1)*arg2 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_BLENDDIFFUSEALPHA:
case WINED3DTOP_BLENDTEXTUREALPHA:
case WINED3DTOP_BLENDFACTORALPHA:
case WINED3DTOP_BLENDTEXTUREALPHAPM:
case WINED3DTOP_BLENDCURRENTALPHA:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
{
GLenum alpha_src = GL_PRIMARY_COLOR_NV;
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
if (op == WINED3DTOP_BLENDDIFFUSEALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_DIFFUSE, stage, texture_idx);
else if (op == WINED3DTOP_BLENDTEXTUREALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_TEXTURE, stage, texture_idx);
else if (op == WINED3DTOP_BLENDFACTORALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_TFACTOR, stage, texture_idx);
else if (op == WINED3DTOP_BLENDTEXTUREALPHAPM) alpha_src = d3dta_to_combiner_input(WINED3DTA_TEXTURE, stage, texture_idx);
else if (op == WINED3DTOP_BLENDCURRENTALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_CURRENT, stage, texture_idx);
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
else FIXME("Unhandled WINED3DTOP %s, shouldn't happen\n", debug_d3dtop(op));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
/* Input, arg1*alpha_src+arg2*(1-alpha_src) */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
if (op == WINED3DTOP_BLENDTEXTUREALPHAPM)
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
{
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
} else {
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
alpha_src, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA));
}
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
alpha_src, GL_UNSIGNED_INVERT_NV, GL_ALPHA));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
break;
}
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
/* Input, arg1_alpha*arg2_rgb+arg1_rgb*1 */
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
if (is_alpha) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATEALPHA_ADDCOLOR)\n");
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATECOLOR_ADDALPHA:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
/* Input, arg1_rgb*arg2_rgb+arg1_alpha*1 */
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
if (is_alpha) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATECOLOR_ADDALPHA)\n");
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
/* Input, (1-arg1_alpha)*arg2_rgb+arg1_rgb*1 */
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
if (is_alpha) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATEINVALPHA_ADDCOLOR)\n");
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), GL_ALPHA));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
/* Input, (1-arg1_rgb)*arg2_rgb+arg1_alpha*1 */
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
if (is_alpha) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATEINVCOLOR_ADDALPHA)\n");
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_DOTPRODUCT3:
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
/* Input, arg1 . arg2 */
/* FIXME: DX7 uses a different calculation? */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], GL_EXPAND_NORMAL_NV, tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
tex_op_args.input[1], GL_EXPAND_NORMAL_NV, tex_op_args.component_usage[1]));
/* Output */
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_DISCARD_NV, GL_NONE, GL_NONE, GL_TRUE, GL_FALSE, GL_FALSE));
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MULTIPLYADD:
wined3d: Fix the nvrc implementation of WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP.
2008-05-24 10:33:31 +02:00
/* Input, arg3*1+arg1*arg2 */
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
wined3d: Fix the nvrc implementation of WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP.
2008-05-24 10:33:31 +02:00
tex_op_args.input[2], tex_op_args.mapping[2], tex_op_args.component_usage[2]));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
wined3d: Fix the nvrc implementation of WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP.
2008-05-24 10:33:31 +02:00
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
wined3d: Fix the nvrc implementation of WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP.
2008-05-24 10:33:31 +02:00
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_LERP:
wined3d: Fix the nvrc implementation of WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP.
2008-05-24 10:33:31 +02:00
/* Input, arg3*arg1+(1-arg3)*arg2 */
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
wined3d: Fix the nvrc implementation of WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP.
2008-05-24 10:33:31 +02:00
tex_op_args.input[2], tex_op_args.mapping[2], tex_op_args.component_usage[2]));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
wined3d: Fix the nvrc implementation of WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP.
2008-05-24 10:33:31 +02:00
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
wined3d: Fix the nvrc implementation of WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP.
2008-05-24 10:33:31 +02:00
tex_op_args.input[2], invert_mapping(tex_op_args.mapping[2]), tex_op_args.component_usage[2]));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
wined3d: Fix the nvrc implementation of WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP.
2008-05-24 10:33:31 +02:00
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
break;
wined3d: Support bump environment mapping using GL_NV_texture_shader.
2007-05-07 21:08:14 +02:00
case WINED3DTOP_BUMPENVMAPLUMINANCE:
case WINED3DTOP_BUMPENVMAP:
if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
/* The bump map stage itself isn't exciting, just read the texture. But tell the next stage to
* perform bump mapping and source from the current stage. Pretty much a SELECTARG2.
* ARG2 is passed through unmodified(apps will most likely use D3DTA_CURRENT for arg2, arg1
* (which will most likely be D3DTA_TEXTURE) is available as a texture shader input for the next stage
*/
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
wined3d: Implement TSSARGTEMP with register combiners.
2008-03-29 13:55:59 +01:00
/* Always pass through to CURRENT, ignore temp arg */
wined3d: Support bump environment mapping using GL_NV_texture_shader.
2007-05-07 21:08:14 +02:00
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
}
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
default:
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
FIXME("Unhandled WINED3DTOP: stage %d, is_alpha %d, op %s (%#x), arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d\n",
wined3d: Add code for using register combiners for texture stage operations. On nVidia cards the value of GL_MAX_TEXTURE_UNITS is generally not larger than 4. In Direct3D that would correspond to MaxSimultaneousTextures in the caps, rather than MaxTextureBlendStages (which can be much larger) to which it currently corresponds in wined3d. Using register combiners we can get around that limitation and get up to GL_MAX_GENERAL_COMBINERS_NV (typically 8) texture stages. This patch adds code for doing the texture operations with register combiners instead of ARB_texture_env_combine or NV_texture_env_combine4, but doesn't make use of that code yet. That's what the next patch will do.
2006-06-27 23:42:35 +02:00
stage, is_alpha, debug_d3dtop(op), op, arg1, arg2, arg3, texture_idx);
}
checkGLcall("set_tex_op_nvrc()\n");
}
wined3d: Cleanup GetSrcAndOpFromValue(). - Cleanup GetSrcAndOpFromValue(). - Use naming more consistent with the rest of the file.
2006-06-10 23:49:09 +02:00
static void get_src_and_opr(DWORD arg, BOOL is_alpha, GLenum* source, GLenum* operand) {
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
/* The WINED3DTA_ALPHAREPLICATE flag specifies the alpha component of the
* input should be used for all input components. The WINED3DTA_COMPLEMENT
wined3d: Cleanup GetSrcAndOpFromValue(). - Cleanup GetSrcAndOpFromValue(). - Use naming more consistent with the rest of the file.
2006-06-10 23:49:09 +02:00
* flag specifies the complement of the input should be used. */
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
BOOL from_alpha = is_alpha || arg & WINED3DTA_ALPHAREPLICATE;
BOOL complement = arg & WINED3DTA_COMPLEMENT;
wined3d: Cleanup GetSrcAndOpFromValue(). - Cleanup GetSrcAndOpFromValue(). - Use naming more consistent with the rest of the file.
2006-06-10 23:49:09 +02:00
/* Calculate the operand */
if (complement) {
if (from_alpha) *operand = GL_ONE_MINUS_SRC_ALPHA;
else *operand = GL_ONE_MINUS_SRC_COLOR;
} else {
if (from_alpha) *operand = GL_SRC_ALPHA;
else *operand = GL_SRC_COLOR;
}
/* Calculate the source */
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
switch (arg & WINED3DTA_SELECTMASK) {
case WINED3DTA_CURRENT: *source = GL_PREVIOUS_EXT; break;
case WINED3DTA_DIFFUSE: *source = GL_PRIMARY_COLOR_EXT; break;
case WINED3DTA_TEXTURE: *source = GL_TEXTURE; break;
case WINED3DTA_TFACTOR: *source = GL_CONSTANT_EXT; break;
case WINED3DTA_SPECULAR:
wined3d: Cleanup GetSrcAndOpFromValue(). - Cleanup GetSrcAndOpFromValue(). - Use naming more consistent with the rest of the file.
2006-06-10 23:49:09 +02:00
/*
* According to the GL_ARB_texture_env_combine specs, SPECULAR is
* 'Secondary color' and isn't supported until base GL supports it
* There is no concept of temp registers as far as I can tell
*/
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
FIXME("Unhandled texture arg WINED3DTA_SPECULAR\n");
wined3d: Cleanup GetSrcAndOpFromValue(). - Cleanup GetSrcAndOpFromValue(). - Use naming more consistent with the rest of the file.
2006-06-10 23:49:09 +02:00
*source = GL_TEXTURE;
break;
default:
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
FIXME("Unrecognized texture arg %#x\n", arg);
wined3d: Cleanup GetSrcAndOpFromValue(). - Cleanup GetSrcAndOpFromValue(). - Use naming more consistent with the rest of the file.
2006-06-10 23:49:09 +02:00
*source = GL_TEXTURE;
break;
}
}
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
/* Set texture operations up - The following avoids lots of ifdefs in this routine!*/
#if defined (GL_VERSION_1_3)
# define useext(A) A
# define combine_ext 1
#elif defined (GL_EXT_texture_env_combine)
# define useext(A) A##_EXT
# define combine_ext 1
#elif defined (GL_ARB_texture_env_combine)
# define useext(A) A##_ARB
# define combine_ext 1
#else
# undef combine_ext
#endif
#if !defined(combine_ext)
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
void set_tex_op(IWineD3DDevice *iface, BOOL isAlpha, int Stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
{
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
FIXME("Requires opengl combine extensions to work\n");
return;
}
#else
/* Setup the texture operations texture stage states */
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
void set_tex_op(IWineD3DDevice *iface, BOOL isAlpha, int Stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
{
GLenum src1, src2, src3;
GLenum opr1, opr2, opr3;
GLenum comb_target;
GLenum src0_target, src1_target, src2_target;
GLenum opr0_target, opr1_target, opr2_target;
GLenum scal_target;
GLenum opr=0, invopr, src3_target, opr3_target;
BOOL Handled = FALSE;
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
TRACE("Alpha?(%d), Stage:%d Op(%s), a1(%d), a2(%d), a3(%d)\n", isAlpha, Stage, debug_d3dtop(op), arg1, arg2, arg3);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
wined3d: Activate a context before doing opengl calls.
2007-03-17 23:00:39 +01:00
/* This is called by a state handler which has the gl lock held and a context for the thread */
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
/* Note: Operations usually involve two ars, src0 and src1 and are operations of
the form (a1 <operation> a2). However, some of the more complex operations
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
take 3 parameters. Instead of the (sensible) addition of a3, Microsoft added
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
in a third parameter called a0. Therefore these are operations of the form
Spelling fixes.
2008-04-23 07:13:32 +02:00
a0 <operation> a1 <operation> a2, i.e., the new parameter goes to the front.
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
However, below we treat the new (a0) parameter as src2/opr2, so in the actual
functions below, expect their syntax to differ slightly to those listed in the
Spelling fixes.
2008-04-23 07:13:32 +02:00
manuals, i.e., replace arg1 with arg3, arg2 with arg1 and arg3 with arg2
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
This affects WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP */
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
if (isAlpha) {
comb_target = useext(GL_COMBINE_ALPHA);
src0_target = useext(GL_SOURCE0_ALPHA);
src1_target = useext(GL_SOURCE1_ALPHA);
src2_target = useext(GL_SOURCE2_ALPHA);
opr0_target = useext(GL_OPERAND0_ALPHA);
opr1_target = useext(GL_OPERAND1_ALPHA);
opr2_target = useext(GL_OPERAND2_ALPHA);
scal_target = GL_ALPHA_SCALE;
}
else {
comb_target = useext(GL_COMBINE_RGB);
src0_target = useext(GL_SOURCE0_RGB);
src1_target = useext(GL_SOURCE1_RGB);
src2_target = useext(GL_SOURCE2_RGB);
opr0_target = useext(GL_OPERAND0_RGB);
opr1_target = useext(GL_OPERAND1_RGB);
opr2_target = useext(GL_OPERAND2_RGB);
scal_target = useext(GL_RGB_SCALE);
}
wined3d: Texture stages that reference NULL textures should just pass through the result of the previous stage.
2006-07-12 00:44:03 +02:00
/* If a texture stage references an invalid texture unit the stage just
* passes through the result from the previous stage */
if (is_invalid_op(This, Stage, op, arg1, arg2, arg3)) {
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
arg1 = WINED3DTA_CURRENT;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
op = WINED3DTOP_SELECTARG1;
wined3d: Texture stages that reference NULL textures should just pass through the result of the previous stage.
2006-07-12 00:44:03 +02:00
}
Add support for samplers. Switch from using d3d9 constants to wined3d constants so that there's no recursive dependencies.
2005-06-24 13:53:07 +02:00
/* From MSDN (WINED3DTSS_ALPHAARG1) :
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
The default argument is WINED3DTA_TEXTURE. If no texture is set for this stage,
then the default argument is WINED3DTA_DIFFUSE.
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
FIXME? If texture added/removed, may need to reset back as well? */
wined3d: Add D3DTA masks to the WINED3D namespace. Also fix usage of D3DTSS/D3DTA in ddraw.
2006-10-24 12:05:00 +02:00
if (isAlpha && This->stateBlock->textures[Stage] == NULL && arg1 == WINED3DTA_TEXTURE) {
get_src_and_opr(WINED3DTA_DIFFUSE, isAlpha, &src1, &opr1);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
} else {
wined3d: Cleanup GetSrcAndOpFromValue(). - Cleanup GetSrcAndOpFromValue(). - Use naming more consistent with the rest of the file.
2006-06-10 23:49:09 +02:00
get_src_and_opr(arg1, isAlpha, &src1, &opr1);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
}
wined3d: Cleanup GetSrcAndOpFromValue(). - Cleanup GetSrcAndOpFromValue(). - Use naming more consistent with the rest of the file.
2006-06-10 23:49:09 +02:00
get_src_and_opr(arg2, isAlpha, &src2, &opr2);
get_src_and_opr(arg3, isAlpha, &src3, &opr3);
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
TRACE("ct(%x), 1:(%x,%x), 2:(%x,%x), 3:(%x,%x)\n", comb_target, src1, opr1, src2, opr2, src3, opr3);
Handled = TRUE; /* Assume will be handled */
/* Other texture operations require special extensions: */
if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
if (isAlpha) {
opr = GL_SRC_ALPHA;
invopr = GL_ONE_MINUS_SRC_ALPHA;
src3_target = GL_SOURCE3_ALPHA_NV;
opr3_target = GL_OPERAND3_ALPHA_NV;
} else {
opr = GL_SRC_COLOR;
invopr = GL_ONE_MINUS_SRC_COLOR;
src3_target = GL_SOURCE3_RGB_NV;
opr3_target = GL_OPERAND3_RGB_NV;
}
switch (op) {
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_DISABLE: /* Only for alpha */
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_SELECTARG1: /* = a1 * 1 + 0 * 0 */
case WINED3DTOP_SELECTARG2: /* = a2 * 1 + 0 * 0 */
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
if (op == WINED3DTOP_SELECTARG1) {
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
} else {
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
}
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
break;
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATE:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATE2X:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATE4X:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_ADD:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_ADDSIGNED:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_ADDSIGNED2X:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_ADDSMOOTH:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_BLENDDIFFUSEALPHA:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, useext(GL_PRIMARY_COLOR));
checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_PRIMARY_COLOR)");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, useext(GL_PRIMARY_COLOR));
checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_PRIMARY_COLOR)");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_BLENDTEXTUREALPHA:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_TEXTURE);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_TEXTURE");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_TEXTURE);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_BLENDFACTORALPHA:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT));
checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT)");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT));
checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT)");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_BLENDTEXTUREALPHAPM:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_TEXTURE);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1); /* a0 = src1/opr1 */
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1"); /* a1 = 1 (see docs) */
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2); /* a2 = arg2 */
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2"); /* a3 = src1 alpha */
glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
switch (opr) {
case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATECOLOR_ADDALPHA:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_ALPHA; break;
case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MULTIPLYADD:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src3);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr3);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, src2);
checkGLcall("GL_TEXTURE_ENV, src3_target, src3");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr3");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_BUMPENVMAP:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
{
}
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_BUMPENVMAPLUMINANCE:
wined3d: Support bump environment mapping using GL_NV_texture_shader.
2007-05-07 21:08:14 +02:00
FIXME("Implement bump environment mapping in GL_NV_texture_env_combine4 path\n");
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
default:
Handled = FALSE;
}
if (Handled) {
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV");
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
return;
}
} /* GL_NV_texture_env_combine4 */
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
Handled = TRUE; /* Again, assume handled */
switch (op) {
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_DISABLE: /* Only for alpha */
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
checkGLcall("GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_SELECTARG1:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_SELECTARG2:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATE:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATE2X:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATE4X:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_ADD:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_ADDSIGNED:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext((GL_ADD_SIGNED)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_ADDSIGNED2X:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_SUBTRACT:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
if (GL_SUPPORT(ARB_TEXTURE_ENV_COMBINE)) {
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_SUBTRACT);
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_SUBTRACT)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else {
FIXME("This version of opengl does not support GL_SUBTRACT\n");
}
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_BLENDDIFFUSEALPHA:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_PRIMARY_COLOR));
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PRIMARY_COLOR");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_BLENDTEXTUREALPHA:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_TEXTURE);
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_TEXTURE");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_BLENDFACTORALPHA:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_CONSTANT));
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_CONSTANT");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_BLENDCURRENTALPHA:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_PREVIOUS));
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PREVIOUS");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_DOTPRODUCT3:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
if (GL_SUPPORT(ARB_TEXTURE_ENV_DOT3)) {
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB");
} else if (GL_SUPPORT(EXT_TEXTURE_ENV_DOT3)) {
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT");
} else {
FIXME("This version of opengl does not support GL_DOT3\n");
}
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_LERP:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src3);
checkGLcall("GL_TEXTURE_ENV, src2_target, src3");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr3);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr3");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_ADDSMOOTH:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
Handled = FALSE;
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_BLENDTEXTUREALPHAPM:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_TEXTURE);
checkGLcall("GL_TEXTURE_ENV, src0_target, GL_TEXTURE");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_APHA");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
Handled = FALSE;
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
Handled = FALSE;
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATECOLOR_ADDALPHA:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
Handled = FALSE;
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_ALPHA; break;
case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
Handled = FALSE;
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
Handled = FALSE;
break;
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_MULTIPLYADD:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src3);
checkGLcall("GL_TEXTURE_ENV, src0_target, src3");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr3);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr3");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
Handled = FALSE;
break;
wined3d: Implement environment bump mapping with GL_ATI_envmap_bumpmap.
2007-05-04 14:28:09 +02:00
case WINED3DTOP_BUMPENVMAPLUMINANCE:
if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP)) {
/* Some apps use BUMPENVMAPLUMINANCE instead of D3DTOP_BUMPENVMAP, although
* they check for the non-luminance cap flag. Well, give them what they asked
* for :-)
*/
WARN("Application uses WINED3DTOP_BUMPENVMAPLUMINANCE\n");
} else {
Handled = FALSE;
break;
}
/* Fall through */
case WINED3DTOP_BUMPENVMAP:
if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP)) {
TRACE("Using ati bumpmap on stage %d, target %d\n", Stage, Stage + 1);
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_BUMP_ENVMAP_ATI);
checkGLcall("glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_BUMP_ENVMAP_ATI)");
glTexEnvi(GL_TEXTURE_ENV, GL_BUMP_TARGET_ATI, GL_TEXTURE0_ARB + Stage + 1);
checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_BUMP_TARGET_ATI, GL_TEXTURE0_ARB + Stage + 1)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src3);
checkGLcall("GL_TEXTURE_ENV, src0_target, src3");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr3);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr3");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
Handled = TRUE;
wined3d: Prevent wrong bumpenvmap warnings.
2007-05-10 22:59:24 +02:00
break;
wined3d: Support bump environment mapping using GL_NV_texture_shader.
2007-05-07 21:08:14 +02:00
} else if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
/* Technically texture shader support without register combiners is possible, but not expected to occur
* on real world cards, so for now a fixme should be enough
wined3d: Implement environment bump mapping with GL_ATI_envmap_bumpmap.
2007-05-04 14:28:09 +02:00
*/
wined3d: Support bump environment mapping using GL_NV_texture_shader.
2007-05-07 21:08:14 +02:00
FIXME("Implement bump mapping with GL_NV_texture_shader in non register combiner path\n");
wined3d: Implement environment bump mapping with GL_ATI_envmap_bumpmap.
2007-05-04 14:28:09 +02:00
}
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
default:
Handled = FALSE;
}
if (Handled) {
BOOL combineOK = TRUE;
if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
DWORD op2;
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
if (isAlpha) {
Add support for samplers. Switch from using d3d9 constants to wined3d constants so that there's no recursive dependencies.
2005-06-24 13:53:07 +02:00
op2 = This->stateBlock->textureState[Stage][WINED3DTSS_COLOROP];
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
} else {
Add support for samplers. Switch from using d3d9 constants to wined3d constants so that there's no recursive dependencies.
2005-06-24 13:53:07 +02:00
op2 = This->stateBlock->textureState[Stage][WINED3DTSS_ALPHAOP];
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
}
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
/* Note: If COMBINE4 in effect can't go back to combine! */
switch (op2) {
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_ADDSMOOTH:
case WINED3DTOP_BLENDTEXTUREALPHAPM:
case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
case WINED3DTOP_MODULATECOLOR_ADDALPHA:
case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
case WINED3DTOP_MULTIPLYADD:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
/* Ignore those implemented in both cases */
switch (op) {
wined3d: Add D3DTEXTUREOP to the WINED3D namespace.
2006-10-13 05:33:03 +02:00
case WINED3DTOP_SELECTARG1:
case WINED3DTOP_SELECTARG2:
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
combineOK = FALSE;
Handled = FALSE;
break;
default:
wined3d: Add & use D3DTEXTUREOP dumping code.
2006-06-27 23:40:02 +02:00
FIXME("Can't use COMBINE4 and COMBINE together, thisop=%s, otherop=%s, isAlpha(%d)\n", debug_d3dtop(op), debug_d3dtop(op2), isAlpha);
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
return;
}
}
}
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
if (combineOK) {
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE));
checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE)");
Tidy up some comments and formatting.
2005-07-13 16:15:54 +02:00
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
return;
}
}
/* After all the extensions, if still unhandled, report fixme */
wined3d: Add & use D3DTEXTUREOP dumping code.
2006-06-27 23:40:02 +02:00
FIXME("Unhandled texture operation %s\n", debug_d3dtop(op));
wined3d: Allow using a different internal format for fbos. OpenGL drivers do not support some low precision internal formats like GL_RGB5 for fbo color targets. Direct3D application depend on them, so provide a fallback format for render targets if the requested format itself is not supported.
2007-11-23 14:17:21 +01:00
#undef GLINFO_LOCATION
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
}
#endif
/* Setup this textures matrix according to the texture flags*/
wined3d: Some texture transform fixes.
2007-08-27 14:33:46 +02:00
void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords, BOOL transformed, DWORD coordtype)
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
{
float mat[16];
glMatrixMode(GL_TEXTURE);
DirectX uses a R/Z transform to translate a texture but under OpenGL a Q transform must be used instead.
2005-07-26 22:01:29 +02:00
checkGLcall("glMatrixMode(GL_TEXTURE)");
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
wined3d: Some texture transform fixes.
2007-08-27 14:33:46 +02:00
if (flags == WINED3DTTFF_DISABLE || flags == WINED3DTTFF_COUNT1 || transformed) {
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glLoadIdentity();
checkGLcall("glLoadIdentity()");
return;
}
wined3d: Add D3DTEXTURETRANSFORMTYPE to the WINED3D namespace.
2006-10-13 05:36:09 +02:00
if (flags == (WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED)) {
ERR("Invalid texture transform flags: WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED\n");
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
return;
}
DirectX uses a R/Z transform to translate a texture but under OpenGL a Q transform must be used instead.
2005-07-26 22:01:29 +02:00
memcpy(mat, smat, 16 * sizeof(float));
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
wined3d: Add D3DTEXTURETRANSFORMTYPE to the WINED3D namespace.
2006-10-13 05:36:09 +02:00
if (flags & WINED3DTTFF_PROJECTED) {
switch (flags & ~WINED3DTTFF_PROJECTED) {
case WINED3DTTFF_COUNT2:
DirectX uses a R/Z transform to translate a texture but under OpenGL a Q transform must be used instead.
2005-07-26 22:01:29 +02:00
mat[3] = mat[1], mat[7] = mat[5], mat[11] = mat[9], mat[15] = mat[13];
mat[1] = mat[5] = mat[9] = mat[13] = 0;
break;
wined3d: Add D3DTEXTURETRANSFORMTYPE to the WINED3D namespace.
2006-10-13 05:36:09 +02:00
case WINED3DTTFF_COUNT3:
DirectX uses a R/Z transform to translate a texture but under OpenGL a Q transform must be used instead.
2005-07-26 22:01:29 +02:00
mat[3] = mat[2], mat[7] = mat[6], mat[11] = mat[10], mat[15] = mat[14];
mat[2] = mat[6] = mat[10] = mat[14] = 0;
break;
}
wined3d: Reinstall the projected texture disabling for generated coords.
2007-11-07 23:10:33 +01:00
} else { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
if(!calculatedCoords) {
switch(coordtype) {
case WINED3DDECLTYPE_FLOAT1:
/* Direct3D passes the default 1.0 in the 2nd coord, while gl passes it in the 4th.
* swap 2nd and 4th coord. No need to store the value of mat[12] in mat[4] because
* the input value to the transformation will be 0, so the matrix value is irrelevant
*/
mat[12] = mat[4];
mat[13] = mat[5];
mat[14] = mat[6];
mat[15] = mat[7];
break;
case WINED3DDECLTYPE_FLOAT2:
/* See above, just 3rd and 4th coord
*/
mat[12] = mat[8];
mat[13] = mat[9];
mat[14] = mat[10];
mat[15] = mat[11];
break;
case WINED3DDECLTYPE_FLOAT3: /* Opengl defaults match dx defaults */
case WINED3DDECLTYPE_FLOAT4: /* No defaults apply, all app defined */
wined3d: Some texture transform fixes.
2007-08-27 14:33:46 +02:00
wined3d: Spelling fixes.
2008-01-09 20:37:05 +01:00
/* This is to prevent swapping the matrix lines and put the default 4th coord = 1.0
wined3d: Reinstall the projected texture disabling for generated coords.
2007-11-07 23:10:33 +01:00
* into a bad place. The division elimination below will apply to make sure the
* 1.0 doesn't do anything bad. The caller will set this value if the stride is 0
*/
case WINED3DDECLTYPE_UNUSED: /* No texture coords, 0/0/0/1 defaults are passed */
break;
default:
FIXME("Unexpected fixed function texture coord input\n");
}
wined3d: Some texture transform fixes.
2007-08-27 14:33:46 +02:00
}
switch (flags & ~WINED3DTTFF_PROJECTED) {
/* case WINED3DTTFF_COUNT1: Won't ever get here */
case WINED3DTTFF_COUNT2: mat[2] = mat[6] = mat[10] = mat[14] = 0;
/* OpenGL divides the first 3 vertex coord by the 4th by default,
* which is essentially the same as D3DTTFF_PROJECTED. Make sure that
* the 4th coord evaluates to 1.0 to eliminate that.
*
* If the fixed function pipeline is used, the 4th value remains unused,
* so there is no danger in doing this. With vertex shaders we have a
* problem. Should an app hit that problem, the code here would have to
* check for pixel shaders, and the shader has to undo the default gl divide.
*
* A more serious problem occurs if the app passes 4 coordinates in, and the
* 4th is != 1.0(opengl default). This would have to be fixed in drawStridedSlow
* or a replacement shader
*/
default: mat[3] = mat[7] = mat[11] = 0; mat[15] = 1;
}
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
}
DirectX uses a R/Z transform to translate a texture but under OpenGL a Q transform must be used instead.
2005-07-26 22:01:29 +02:00
Add {G,S}etRenderState and {G,S}etTextureStageState support, and ensure the stateblock is fully populated at device startup.
2004-12-13 14:35:38 +01:00
glLoadMatrixf(mat);
checkGLcall("glLoadMatrixf(mat)");
}
wined3d: Better pixelformat selection code.
2007-08-09 01:04:30 +02:00
#define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
/* This small helper function is used to convert a bitmask into the number of masked bits */
unsigned int count_bits(unsigned int mask)
{
unsigned int count;
for (count = 0; mask; ++count)
{
mask &= mask - 1;
}
return count;
}
/* Helper function for retrieving color info for ChoosePixelFormat and wglChoosePixelFormatARB.
* The later function requires individual color components. */
BOOL getColorBits(WINED3DFORMAT fmt, short *redSize, short *greenSize, short *blueSize, short *alphaSize, short *totalSize)
{
const StaticPixelFormatDesc *desc;
TRACE("fmt: %s\n", debug_d3dformat(fmt));
switch(fmt)
{
case WINED3DFMT_X8R8G8B8:
wined3d: Add more pixelformats to getColorBits.
2007-08-11 16:47:47 +02:00
case WINED3DFMT_R8G8B8:
case WINED3DFMT_A8R8G8B8:
case WINED3DFMT_A2R10G10B10:
case WINED3DFMT_X1R5G5B5:
case WINED3DFMT_A1R5G5B5:
case WINED3DFMT_R5G6B5:
wined3d: Add X4R4G4B4 and A4R4G4B4 to formats allowed in getColorBits.
2007-09-06 07:15:40 +02:00
case WINED3DFMT_X4R4G4B4:
case WINED3DFMT_A4R4G4B4:
wined3d: Add more pixelformats to getColorBits.
2007-08-11 16:47:47 +02:00
case WINED3DFMT_R3G3B2:
case WINED3DFMT_A8P8:
case WINED3DFMT_P8:
wined3d: Better pixelformat selection code.
2007-08-09 01:04:30 +02:00
break;
default:
ERR("Unsupported format: %s\n", debug_d3dformat(fmt));
return FALSE;
}
desc = getFormatDescEntry(fmt, NULL, NULL);
if(!desc)
{
ERR("Unable to look up format: 0x%x\n", fmt);
return FALSE;
}
*redSize = count_bits(desc->redMask);
*greenSize = count_bits(desc->greenMask);
*blueSize = count_bits(desc->blueMask);
*alphaSize = count_bits(desc->alphaMask);
*totalSize = *redSize + *greenSize + *blueSize + *alphaSize;
TRACE("Returning red: %d, green: %d, blue: %d, alpha: %d, total: %d for fmt=%s\n", *redSize, *greenSize, *blueSize, *alphaSize, *totalSize, debug_d3dformat(fmt));
return TRUE;
}
/* Helper function for retrieving depth/stencil info for ChoosePixelFormat and wglChoosePixelFormatARB */
BOOL getDepthStencilBits(WINED3DFORMAT fmt, short *depthSize, short *stencilSize)
{
const StaticPixelFormatDesc *desc;
TRACE("fmt: %s\n", debug_d3dformat(fmt));
switch(fmt)
{
case WINED3DFMT_D16_LOCKABLE:
case WINED3DFMT_D16:
case WINED3DFMT_D15S1:
case WINED3DFMT_D24X8:
case WINED3DFMT_D24X4S4:
case WINED3DFMT_D24S8:
case WINED3DFMT_D24FS8:
case WINED3DFMT_D32:
wined3d: Add D32F_LOCKABLE to getDepthStencilBits.
2008-03-02 23:53:26 +01:00
case WINED3DFMT_D32F_LOCKABLE:
wined3d: Better pixelformat selection code.
2007-08-09 01:04:30 +02:00
break;
default:
FIXME("Unsupported stencil format: %s\n", debug_d3dformat(fmt));
return FALSE;
}
desc = getFormatDescEntry(fmt, NULL, NULL);
if(!desc)
{
ERR("Unable to look up format: 0x%x\n", fmt);
return FALSE;
}
*depthSize = desc->depthSize;
*stencilSize = desc->stencilSize;
TRACE("Returning depthSize: %d and stencilSize: %d for fmt=%s\n", *depthSize, *stencilSize, debug_d3dformat(fmt));
return TRUE;
}
#undef GLINFO_LOCATION
wined3d: Implement IWineD3DDevice::EnumDisplayModes.
2006-04-18 23:04:51 +02:00
/* DirectDraw stuff */
WINED3DFORMAT pixelformat_for_depth(DWORD depth) {
switch(depth) {
wined3d: Remove unreachable code: break after return. Found by Smatch.
2007-07-18 00:14:36 +02:00
case 8: return WINED3DFMT_P8;
case 15: return WINED3DFMT_X1R5G5B5;
case 16: return WINED3DFMT_R5G6B5;
wined3d: Unify bpp to format conversion.
2007-11-30 16:29:49 +01:00
case 24: return WINED3DFMT_X8R8G8B8; /* Robots needs 24bit to be X8R8G8B8 */
wined3d: Spelling fixes.
2008-01-09 20:37:05 +01:00
case 32: return WINED3DFMT_X8R8G8B8; /* EVE online and the Fur demo need 32bit AdapterDisplayMode to return X8R8G8B8 */
wined3d: Implement IWineD3DDevice::EnumDisplayModes.
2006-04-18 23:04:51 +02:00
default: return WINED3DFMT_UNKNOWN;
}
}
wined3d: Implement IWineD3DSurface::GetDC and IWineD3DSurface::ReleaseDC.
2006-05-06 18:08:33 +02:00
wined3d: Cast-qual warnings fix.
2006-11-24 15:15:06 +01:00
void multiply_matrix(WINED3DMATRIX *dest, const WINED3DMATRIX *src1, const WINED3DMATRIX *src2) {
wined3d: Merge D3DMATRIX types into one type in WINED3D namespace.
2006-10-12 08:21:39 +02:00
WINED3DMATRIX temp;
wined3d: Implement IWineD3DDevice::ProcessVertices.
2006-05-12 22:21:31 +02:00
/* Now do the multiplication 'by hand'.
I know that all this could be optimised, but this will be done later :-) */
temp.u.s._11 = (src1->u.s._11 * src2->u.s._11) + (src1->u.s._21 * src2->u.s._12) + (src1->u.s._31 * src2->u.s._13) + (src1->u.s._41 * src2->u.s._14);
temp.u.s._21 = (src1->u.s._11 * src2->u.s._21) + (src1->u.s._21 * src2->u.s._22) + (src1->u.s._31 * src2->u.s._23) + (src1->u.s._41 * src2->u.s._24);
temp.u.s._31 = (src1->u.s._11 * src2->u.s._31) + (src1->u.s._21 * src2->u.s._32) + (src1->u.s._31 * src2->u.s._33) + (src1->u.s._41 * src2->u.s._34);
temp.u.s._41 = (src1->u.s._11 * src2->u.s._41) + (src1->u.s._21 * src2->u.s._42) + (src1->u.s._31 * src2->u.s._43) + (src1->u.s._41 * src2->u.s._44);
temp.u.s._12 = (src1->u.s._12 * src2->u.s._11) + (src1->u.s._22 * src2->u.s._12) + (src1->u.s._32 * src2->u.s._13) + (src1->u.s._42 * src2->u.s._14);
temp.u.s._22 = (src1->u.s._12 * src2->u.s._21) + (src1->u.s._22 * src2->u.s._22) + (src1->u.s._32 * src2->u.s._23) + (src1->u.s._42 * src2->u.s._24);
temp.u.s._32 = (src1->u.s._12 * src2->u.s._31) + (src1->u.s._22 * src2->u.s._32) + (src1->u.s._32 * src2->u.s._33) + (src1->u.s._42 * src2->u.s._34);
temp.u.s._42 = (src1->u.s._12 * src2->u.s._41) + (src1->u.s._22 * src2->u.s._42) + (src1->u.s._32 * src2->u.s._43) + (src1->u.s._42 * src2->u.s._44);
temp.u.s._13 = (src1->u.s._13 * src2->u.s._11) + (src1->u.s._23 * src2->u.s._12) + (src1->u.s._33 * src2->u.s._13) + (src1->u.s._43 * src2->u.s._14);
temp.u.s._23 = (src1->u.s._13 * src2->u.s._21) + (src1->u.s._23 * src2->u.s._22) + (src1->u.s._33 * src2->u.s._23) + (src1->u.s._43 * src2->u.s._24);
temp.u.s._33 = (src1->u.s._13 * src2->u.s._31) + (src1->u.s._23 * src2->u.s._32) + (src1->u.s._33 * src2->u.s._33) + (src1->u.s._43 * src2->u.s._34);
temp.u.s._43 = (src1->u.s._13 * src2->u.s._41) + (src1->u.s._23 * src2->u.s._42) + (src1->u.s._33 * src2->u.s._43) + (src1->u.s._43 * src2->u.s._44);
temp.u.s._14 = (src1->u.s._14 * src2->u.s._11) + (src1->u.s._24 * src2->u.s._12) + (src1->u.s._34 * src2->u.s._13) + (src1->u.s._44 * src2->u.s._14);
temp.u.s._24 = (src1->u.s._14 * src2->u.s._21) + (src1->u.s._24 * src2->u.s._22) + (src1->u.s._34 * src2->u.s._23) + (src1->u.s._44 * src2->u.s._24);
temp.u.s._34 = (src1->u.s._14 * src2->u.s._31) + (src1->u.s._24 * src2->u.s._32) + (src1->u.s._34 * src2->u.s._33) + (src1->u.s._44 * src2->u.s._34);
temp.u.s._44 = (src1->u.s._14 * src2->u.s._41) + (src1->u.s._24 * src2->u.s._42) + (src1->u.s._34 * src2->u.s._43) + (src1->u.s._44 * src2->u.s._44);
/* And copy the new matrix in the good storage.. */
memcpy(dest, &temp, 16 * sizeof(float));
}
DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) {
DWORD size = 0;
int i;
wined3d: Add D3DFVF codes to the WINED3D namespace.
2006-10-31 09:16:08 +01:00
int numTextures = (d3dvtVertexType & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
if (d3dvtVertexType & WINED3DFVF_NORMAL) size += 3 * sizeof(float);
if (d3dvtVertexType & WINED3DFVF_DIFFUSE) size += sizeof(DWORD);
if (d3dvtVertexType & WINED3DFVF_SPECULAR) size += sizeof(DWORD);
if (d3dvtVertexType & WINED3DFVF_PSIZE) size += sizeof(DWORD);
switch (d3dvtVertexType & WINED3DFVF_POSITION_MASK) {
d3d: Calculate the size of WINED3DFVF_XYZBx FVFs.
2007-04-25 00:38:32 +02:00
case WINED3DFVF_XYZ: size += 3 * sizeof(float); break;
wined3d: Add D3DFVF codes to the WINED3D namespace.
2006-10-31 09:16:08 +01:00
case WINED3DFVF_XYZRHW: size += 4 * sizeof(float); break;
d3d: Calculate the size of WINED3DFVF_XYZBx FVFs.
2007-04-25 00:38:32 +02:00
case WINED3DFVF_XYZB1: size += 4 * sizeof(float); break;
case WINED3DFVF_XYZB2: size += 5 * sizeof(float); break;
case WINED3DFVF_XYZB3: size += 6 * sizeof(float); break;
case WINED3DFVF_XYZB4: size += 7 * sizeof(float); break;
case WINED3DFVF_XYZB5: size += 8 * sizeof(float); break;
default: ERR("Unexpected position mask\n");
wined3d: Implement IWineD3DDevice::ProcessVertices.
2006-05-12 22:21:31 +02:00
}
for (i = 0; i < numTextures; i++) {
size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float);
}
return size;
}
wined3d: Implement IWineGDISurface.
2006-05-13 22:22:16 +02:00
wined3d: OpengGL accelerated blits. Implement some basic opengl accelerated blts from and to render targets. It's not perfect yet, but enought to make some D3D apps happy. For now the only supported operations are: - Full screen back -> Front buffer: Just call present - Offscreen surface -> render target - Render target -> offscreen surface(slow) - render target colorfill
2006-05-23 00:48:54 +02:00
/***********************************************************************
* CalculateTexRect
*
* Calculates the dimensions of the opengl texture used for blits.
* Handled oversized opengl textures and updates the source rectangle
* accordingly
*
* Params:
* This: Surface to operate on
* Rect: Requested rectangle
*
* Returns:
* TRUE if the texture part can be loaded,
* FALSE otherwise
*
*********************************************************************/
wined3d: Store the gl information in a per adapter structure and initialize it only once.
2007-06-09 14:27:41 +02:00
#define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
wined3d: OpengGL accelerated blits. Implement some basic opengl accelerated blts from and to render targets. It's not perfect yet, but enought to make some D3D apps happy. For now the only supported operations are: - Full screen back -> Front buffer: Just call present - Offscreen surface -> render target - Render target -> offscreen surface(slow) - render target colorfill
2006-05-23 00:48:54 +02:00
BOOL CalculateTexRect(IWineD3DSurfaceImpl *This, RECT *Rect, float glTexCoord[4]) {
int x1 = Rect->left, x2 = Rect->right;
int y1 = Rect->top, y2 = Rect->bottom;
GLint maxSize = GL_LIMITS(texture_size);
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
TRACE("(%p)->(%d,%d)-(%d,%d)\n", This,
wined3d: OpengGL accelerated blits. Implement some basic opengl accelerated blts from and to render targets. It's not perfect yet, but enought to make some D3D apps happy. For now the only supported operations are: - Full screen back -> Front buffer: Just call present - Offscreen surface -> render target - Render target -> offscreen surface(slow) - render target colorfill
2006-05-23 00:48:54 +02:00
Rect->left, Rect->top, Rect->right, Rect->bottom);
/* The sizes might be reversed */
if(Rect->left > Rect->right) {
x1 = Rect->right;
x2 = Rect->left;
}
if(Rect->top > Rect->bottom) {
y1 = Rect->bottom;
y2 = Rect->top;
}
/* No oversized texture? This is easy */
if(!(This->Flags & SFLAG_OVERSIZE)) {
/* Which rect from the texture do I need? */
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
if(This->glDescription.target == GL_TEXTURE_RECTANGLE_ARB) {
glTexCoord[0] = (float) Rect->left;
glTexCoord[2] = (float) Rect->top;
glTexCoord[1] = (float) Rect->right;
glTexCoord[3] = (float) Rect->bottom;
} else {
glTexCoord[0] = (float) Rect->left / (float) This->pow2Width;
glTexCoord[2] = (float) Rect->top / (float) This->pow2Height;
glTexCoord[1] = (float) Rect->right / (float) This->pow2Width;
glTexCoord[3] = (float) Rect->bottom / (float) This->pow2Height;
}
wined3d: OpengGL accelerated blits. Implement some basic opengl accelerated blts from and to render targets. It's not perfect yet, but enought to make some D3D apps happy. For now the only supported operations are: - Full screen back -> Front buffer: Just call present - Offscreen surface -> render target - Render target -> offscreen surface(slow) - render target colorfill
2006-05-23 00:48:54 +02:00
return TRUE;
} else {
/* Check if we can succeed at all */
if( (x2 - x1) > maxSize ||
(y2 - y1) > maxSize ) {
TRACE("Requested rectangle is too large for gl\n");
return FALSE;
}
/* A part of the texture has to be picked. First, check if
* some texture part is loaded already, if yes try to re-use it.
* If the texture is dirty, or the part can't be used,
* re-position the part to load
*/
wined3d: Rework surface dirtification. Previously the surfaces stored a flag if the system memory copy was ahead of the gl copy(SFLAG_DIRTY) or the gl copy is ahead(SFLAG_GLDIRTY). The pbuffer copy was 'managed' differently using SFLAG_INPBUFFER and SFLAG_INTEXTURE. This patch replaces them with 3 flags, INSYSMEM, INPBUFFER and INTEXTURE which specify which copy contains the most up to date copy. It is perfectly valid to have more than one of those flags set. One must be set at least (except at init, when no content is in the surface yet). When one copy is modified, the flags for the others are removed.
2007-03-06 21:47:45 +01:00
if(This->Flags & SFLAG_INTEXTURE) {
wined3d: OpengGL accelerated blits. Implement some basic opengl accelerated blts from and to render targets. It's not perfect yet, but enought to make some D3D apps happy. For now the only supported operations are: - Full screen back -> Front buffer: Just call present - Offscreen surface -> render target - Render target -> offscreen surface(slow) - render target colorfill
2006-05-23 00:48:54 +02:00
if(This->glRect.left <= x1 && This->glRect.right >= x2 &&
This->glRect.top <= y1 && This->glRect.bottom >= x2 ) {
/* Ok, the rectangle is ok, re-use it */
TRACE("Using existing gl Texture\n");
} else {
/* Rectangle is not ok, dirtify the texture to reload it */
TRACE("Dirtifying texture to force reload\n");
wined3d: Rework surface dirtification. Previously the surfaces stored a flag if the system memory copy was ahead of the gl copy(SFLAG_DIRTY) or the gl copy is ahead(SFLAG_GLDIRTY). The pbuffer copy was 'managed' differently using SFLAG_INPBUFFER and SFLAG_INTEXTURE. This patch replaces them with 3 flags, INSYSMEM, INPBUFFER and INTEXTURE which specify which copy contains the most up to date copy. It is perfectly valid to have more than one of those flags set. One must be set at least (except at init, when no content is in the surface yet). When one copy is modified, the flags for the others are removed.
2007-03-06 21:47:45 +01:00
This->Flags &= ~SFLAG_INTEXTURE;
wined3d: OpengGL accelerated blits. Implement some basic opengl accelerated blts from and to render targets. It's not perfect yet, but enought to make some D3D apps happy. For now the only supported operations are: - Full screen back -> Front buffer: Just call present - Offscreen surface -> render target - Render target -> offscreen surface(slow) - render target colorfill
2006-05-23 00:48:54 +02:00
}
}
/* Now if we are dirty(no else if!) */
wined3d: Rework surface dirtification. Previously the surfaces stored a flag if the system memory copy was ahead of the gl copy(SFLAG_DIRTY) or the gl copy is ahead(SFLAG_GLDIRTY). The pbuffer copy was 'managed' differently using SFLAG_INPBUFFER and SFLAG_INTEXTURE. This patch replaces them with 3 flags, INSYSMEM, INPBUFFER and INTEXTURE which specify which copy contains the most up to date copy. It is perfectly valid to have more than one of those flags set. One must be set at least (except at init, when no content is in the surface yet). When one copy is modified, the flags for the others are removed.
2007-03-06 21:47:45 +01:00
if(!(This->Flags & SFLAG_INTEXTURE)) {
wined3d: OpengGL accelerated blits. Implement some basic opengl accelerated blts from and to render targets. It's not perfect yet, but enought to make some D3D apps happy. For now the only supported operations are: - Full screen back -> Front buffer: Just call present - Offscreen surface -> render target - Render target -> offscreen surface(slow) - render target colorfill
2006-05-23 00:48:54 +02:00
/* Set the new rectangle. Use the following strategy:
* 1) Use as big textures as possible.
* 2) Place the texture part in the way that the requested
* part is in the middle of the texture(well, almost)
* 3) If the texture is moved over the edges of the
* surface, replace it nicely
* 4) If the coord is not limiting the texture size,
* use the whole size
*/
if((This->pow2Width) > maxSize) {
This->glRect.left = x1 - maxSize / 2;
if(This->glRect.left < 0) {
This->glRect.left = 0;
}
This->glRect.right = This->glRect.left + maxSize;
if(This->glRect.right > This->currentDesc.Width) {
This->glRect.right = This->currentDesc.Width;
This->glRect.left = This->glRect.right - maxSize;
}
} else {
This->glRect.left = 0;
This->glRect.right = This->pow2Width;
}
if(This->pow2Height > maxSize) {
This->glRect.top = x1 - GL_LIMITS(texture_size) / 2;
if(This->glRect.top < 0) This->glRect.top = 0;
This->glRect.bottom = This->glRect.left + maxSize;
if(This->glRect.bottom > This->currentDesc.Height) {
This->glRect.bottom = This->currentDesc.Height;
This->glRect.top = This->glRect.bottom - maxSize;
}
} else {
This->glRect.top = 0;
This->glRect.bottom = This->pow2Height;
}
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
TRACE("(%p): Using rect (%d,%d)-(%d,%d)\n", This,
wined3d: OpengGL accelerated blits. Implement some basic opengl accelerated blts from and to render targets. It's not perfect yet, but enought to make some D3D apps happy. For now the only supported operations are: - Full screen back -> Front buffer: Just call present - Offscreen surface -> render target - Render target -> offscreen surface(slow) - render target colorfill
2006-05-23 00:48:54 +02:00
This->glRect.left, This->glRect.top, This->glRect.right, This->glRect.bottom);
}
/* Re-calculate the rect to draw */
Rect->left -= This->glRect.left;
Rect->right -= This->glRect.left;
Rect->top -= This->glRect.top;
Rect->bottom -= This->glRect.top;
Assorted spelling, case and grammar fixes.
2006-06-23 18:18:02 +02:00
/* Get the gl coordinates. The gl rectangle is a power of 2, eigher the max size,
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
* or the pow2Width / pow2Height of the surface.
*
* Can never be GL_TEXTURE_RECTANGLE_ARB because oversized surfaces are always set up
* as regular GL_TEXTURE_2D.
wined3d: OpengGL accelerated blits. Implement some basic opengl accelerated blts from and to render targets. It's not perfect yet, but enought to make some D3D apps happy. For now the only supported operations are: - Full screen back -> Front buffer: Just call present - Offscreen surface -> render target - Render target -> offscreen surface(slow) - render target colorfill
2006-05-23 00:48:54 +02:00
*/
glTexCoord[0] = (float) Rect->left / (float) (This->glRect.right - This->glRect.left);
glTexCoord[2] = (float) Rect->top / (float) (This->glRect.bottom - This->glRect.top);
glTexCoord[1] = (float) Rect->right / (float) (This->glRect.right - This->glRect.left);
glTexCoord[3] = (float) Rect->bottom / (float) (This->glRect.bottom - This->glRect.top);
}
return TRUE;
}
#undef GLINFO_LOCATION
wined3d: Add some hash table code.
2007-02-27 20:51:48 +01:00
/* Hash table functions */
hash_table_t *hash_table_create(hash_function_t *hash_function, compare_function_t *compare_function)
{
hash_table_t *table;
unsigned int initial_size = 8;
table = HeapAlloc(GetProcessHeap(), 0, sizeof(hash_table_t) + (initial_size * sizeof(struct list)));
if (!table)
{
ERR("Failed to allocate table, returning NULL.\n");
return NULL;
}
table->hash_function = hash_function;
table->compare_function = compare_function;
table->grow_size = initial_size - (initial_size >> 2);
table->shrink_size = 0;
table->buckets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, initial_size * sizeof(struct list));
if (!table->buckets)
{
ERR("Failed to allocate table buckets, returning NULL.\n");
HeapFree(GetProcessHeap(), 0, table);
return NULL;
}
table->bucket_count = initial_size;
table->entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, table->grow_size * sizeof(hash_table_entry_t));
if (!table->entries)
{
ERR("Failed to allocate table entries, returning NULL.\n");
HeapFree(GetProcessHeap(), 0, table->buckets);
HeapFree(GetProcessHeap(), 0, table);
return NULL;
}
table->entry_count = 0;
list_init(&table->free_entries);
table->count = 0;
return table;
}
void hash_table_destroy(hash_table_t *table)
{
unsigned int i = 0;
for (i = 0; i < table->entry_count; ++i)
{
HeapFree(GetProcessHeap(), 0, table->entries[i].key);
}
HeapFree(GetProcessHeap(), 0, table->entries);
HeapFree(GetProcessHeap(), 0, table->buckets);
HeapFree(GetProcessHeap(), 0, table);
}
static inline hash_table_entry_t *hash_table_get_by_idx(hash_table_t *table, void *key, unsigned int idx)
{
hash_table_entry_t *entry;
if (table->buckets[idx].next)
LIST_FOR_EACH_ENTRY(entry, &(table->buckets[idx]), hash_table_entry_t, entry)
if (table->compare_function(entry->key, key)) return entry;
return NULL;
}
static BOOL hash_table_resize(hash_table_t *table, unsigned int new_bucket_count)
{
unsigned int new_entry_count = 0;
hash_table_entry_t *new_entries;
struct list *new_buckets;
unsigned int grow_size = new_bucket_count - (new_bucket_count >> 2);
unsigned int i;
new_buckets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, new_bucket_count * sizeof(struct list));
if (!new_buckets)
{
ERR("Failed to allocate new buckets, returning FALSE.\n");
return FALSE;
}
new_entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, grow_size * sizeof(hash_table_entry_t));
if (!new_entries)
{
ERR("Failed to allocate new entries, returning FALSE.\n");
HeapFree(GetProcessHeap(), 0, new_buckets);
return FALSE;
}
for (i = 0; i < table->bucket_count; ++i)
{
if (table->buckets[i].next)
{
hash_table_entry_t *entry, *entry2;
LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &table->buckets[i], hash_table_entry_t, entry)
{
int j;
hash_table_entry_t *new_entry = new_entries + (new_entry_count++);
*new_entry = *entry;
j = new_entry->hash & (new_bucket_count - 1);
if (!new_buckets[j].next) list_init(&new_buckets[j]);
list_add_head(&new_buckets[j], &new_entry->entry);
}
}
}
HeapFree(GetProcessHeap(), 0, table->buckets);
table->buckets = new_buckets;
HeapFree(GetProcessHeap(), 0, table->entries);
table->entries = new_entries;
table->entry_count = new_entry_count;
list_init(&table->free_entries);
table->bucket_count = new_bucket_count;
table->grow_size = grow_size;
table->shrink_size = new_bucket_count > 8 ? new_bucket_count >> 2 : 0;
return TRUE;
}
void hash_table_put(hash_table_t *table, void *key, void *value)
{
unsigned int idx;
unsigned int hash;
hash_table_entry_t *entry;
hash = table->hash_function(key);
idx = hash & (table->bucket_count - 1);
entry = hash_table_get_by_idx(table, key, idx);
if (entry)
{
HeapFree(GetProcessHeap(), 0, key);
entry->value = value;
if (!value)
{
HeapFree(GetProcessHeap(), 0, entry->key);
entry->key = NULL;
/* Remove the entry */
list_remove(&entry->entry);
list_add_head(&table->free_entries, &entry->entry);
--table->count;
/* Shrink if necessary */
if (table->count < table->shrink_size) {
if (!hash_table_resize(table, table->bucket_count >> 1))
{
ERR("Failed to shrink the table...\n");
}
}
}
return;
}
if (!value) return;
/* Grow if necessary */
if (table->count >= table->grow_size)
{
if (!hash_table_resize(table, table->bucket_count << 1))
{
ERR("Failed to grow the table, returning.\n");
return;
}
idx = hash & (table->bucket_count - 1);
}
/* Find an entry to insert */
if (!list_empty(&table->free_entries))
{
struct list *elem = list_head(&table->free_entries);
list_remove(elem);
entry = LIST_ENTRY(elem, hash_table_entry_t, entry);
} else {
entry = table->entries + (table->entry_count++);
}
/* Insert the entry */
entry->key = key;
entry->value = value;
entry->hash = hash;
if (!table->buckets[idx].next) list_init(&table->buckets[idx]);
list_add_head(&table->buckets[idx], &entry->entry);
++table->count;
}
void hash_table_remove(hash_table_t *table, void *key)
{
hash_table_put(table, key, NULL);
}
void *hash_table_get(hash_table_t *table, void *key)
{
unsigned int idx;
hash_table_entry_t *entry;
idx = table->hash_function(key) & (table->bucket_count - 1);
entry = hash_table_get_by_idx(table, key, idx);
return entry ? entry->value : NULL;
}
wined3d: Fragment processing using GL_ATI_fragment_shader. This adds code for handling fixed function fragment processing with the GL_ATI_fragment_shader extension. This is a sort-of programmable interface for fragment processing at the level of shader model 1.4 in d3d. This code is of use on r200, r250 and r280 cards(radeon 8500 to 9200) which do not support GL_ARB_fragment_program, but support pixel shader 1.4 on Windows. This code is somewhat a counterpart to the existing fragment processing code using GL_NV_register_combiners and GL_NV_texture_shader.
2008-03-22 14:31:52 +01:00
#define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
void gen_ffp_op(IWineD3DStateBlockImpl *stateblock, struct texture_stage_op op[MAX_TEXTURES]) {
#define ARG1 0x01
#define ARG2 0x02
#define ARG0 0x04
static const unsigned char args[WINED3DTOP_LERP + 1] = {
/* undefined */ 0,
/* D3DTOP_DISABLE */ 0,
/* D3DTOP_SELECTARG1 */ ARG1,
/* D3DTOP_SELECTARG2 */ ARG2,
/* D3DTOP_MODULATE */ ARG1 | ARG2,
/* D3DTOP_MODULATE2X */ ARG1 | ARG2,
/* D3DTOP_MODULATE4X */ ARG1 | ARG2,
/* D3DTOP_ADD */ ARG1 | ARG2,
/* D3DTOP_ADDSIGNED */ ARG1 | ARG2,
/* D3DTOP_ADDSIGNED2X */ ARG1 | ARG2,
/* D3DTOP_SUBTRACT */ ARG1 | ARG2,
/* D3DTOP_ADDSMOOTH */ ARG1 | ARG2,
/* D3DTOP_BLENDDIFFUSEALPHA */ ARG1 | ARG2,
/* D3DTOP_BLENDTEXTUREALPHA */ ARG1 | ARG2,
/* D3DTOP_BLENDFACTORALPHA */ ARG1 | ARG2,
/* D3DTOP_BLENDTEXTUREALPHAPM */ ARG1 | ARG2,
/* D3DTOP_BLENDCURRENTALPHA */ ARG1 | ARG2,
/* D3DTOP_PREMODULATE */ ARG1 | ARG2,
/* D3DTOP_MODULATEALPHA_ADDCOLOR */ ARG1 | ARG2,
/* D3DTOP_MODULATECOLOR_ADDALPHA */ ARG1 | ARG2,
/* D3DTOP_MODULATEINVALPHA_ADDCOLOR */ ARG1 | ARG2,
/* D3DTOP_MODULATEINVCOLOR_ADDALPHA */ ARG1 | ARG2,
/* D3DTOP_BUMPENVMAP */ ARG1 | ARG2,
/* D3DTOP_BUMPENVMAPLUMINANCE */ ARG1 | ARG2,
/* D3DTOP_DOTPRODUCT3 */ ARG1 | ARG2,
/* D3DTOP_MULTIPLYADD */ ARG1 | ARG2 | ARG0,
/* D3DTOP_LERP */ ARG1 | ARG2 | ARG0
};
unsigned int i;
DWORD ttff;
for(i = 0; i < GL_LIMITS(texture_stages); i++) {
wined3d: Implement env bump mapping in the atifs ffp replacement.
2008-03-20 18:38:47 +01:00
IWineD3DBaseTextureImpl *texture;
wined3d: Fragment processing using GL_ATI_fragment_shader. This adds code for handling fixed function fragment processing with the GL_ATI_fragment_shader extension. This is a sort-of programmable interface for fragment processing at the level of shader model 1.4 in d3d. This code is of use on r200, r250 and r280 cards(radeon 8500 to 9200) which do not support GL_ARB_fragment_program, but support pixel shader 1.4 on Windows. This code is somewhat a counterpart to the existing fragment processing code using GL_NV_register_combiners and GL_NV_texture_shader.
2008-03-22 14:31:52 +01:00
if(stateblock->textureState[i][WINED3DTSS_COLOROP] == WINED3DTOP_DISABLE) {
op[i].cop = WINED3DTOP_DISABLE;
op[i].aop = WINED3DTOP_DISABLE;
op[i].carg0 = op[i].carg1 = op[i].carg2 = 0xffffffff;
op[i].aarg0 = op[i].aarg1 = op[i].aarg2 = 0xffffffff;
op[i].color_correction = WINED3DFMT_UNKNOWN;
wined3d: Implement D3DTA_TEMP in the GL_ATI_fragment_shader codepath.
2008-03-29 23:55:09 +01:00
op[i].dst = 0xffffffff;
wined3d: Fragment processing using GL_ATI_fragment_shader. This adds code for handling fixed function fragment processing with the GL_ATI_fragment_shader extension. This is a sort-of programmable interface for fragment processing at the level of shader model 1.4 in d3d. This code is of use on r200, r250 and r280 cards(radeon 8500 to 9200) which do not support GL_ARB_fragment_program, but support pixel shader 1.4 on Windows. This code is somewhat a counterpart to the existing fragment processing code using GL_NV_register_combiners and GL_NV_texture_shader.
2008-03-22 14:31:52 +01:00
i++;
break;
}
wined3d: Implement env bump mapping in the atifs ffp replacement.
2008-03-20 18:38:47 +01:00
texture = (IWineD3DBaseTextureImpl *) stateblock->textures[i];
op[i].color_correction = texture ? texture->baseTexture.shader_conversion_group : WINED3DFMT_UNKNOWN;
wined3d: Fragment processing using GL_ATI_fragment_shader. This adds code for handling fixed function fragment processing with the GL_ATI_fragment_shader extension. This is a sort-of programmable interface for fragment processing at the level of shader model 1.4 in d3d. This code is of use on r200, r250 and r280 cards(radeon 8500 to 9200) which do not support GL_ARB_fragment_program, but support pixel shader 1.4 on Windows. This code is somewhat a counterpart to the existing fragment processing code using GL_NV_register_combiners and GL_NV_texture_shader.
2008-03-22 14:31:52 +01:00
op[i].cop = stateblock->textureState[i][WINED3DTSS_COLOROP];
op[i].aop = stateblock->textureState[i][WINED3DTSS_ALPHAOP];
op[i].carg1 = (args[op[i].cop] & ARG1) ? stateblock->textureState[i][WINED3DTSS_COLORARG1] : 0xffffffff;
op[i].carg2 = (args[op[i].cop] & ARG2) ? stateblock->textureState[i][WINED3DTSS_COLORARG2] : 0xffffffff;
op[i].carg0 = (args[op[i].cop] & ARG0) ? stateblock->textureState[i][WINED3DTSS_COLORARG0] : 0xffffffff;
if(is_invalid_op(stateblock->wineD3DDevice, i, op[i].cop, op[i].carg1, op[i].carg2, op[i].carg0)) {
op[i].carg0 = 0xffffffff;
op[i].carg2 = 0xffffffff;
op[i].carg1 = WINED3DTA_CURRENT;
op[i].cop = WINED3DTOP_SELECTARG1;
}
op[i].aarg1 = (args[op[i].aop] & ARG1) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG1] : 0xffffffff;
op[i].aarg2 = (args[op[i].aop] & ARG2) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG2] : 0xffffffff;
op[i].aarg0 = (args[op[i].aop] & ARG0) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG0] : 0xffffffff;
if(is_invalid_op(stateblock->wineD3DDevice, i, op[i].aop, op[i].aarg1, op[i].aarg2, op[i].aarg0)) {
op[i].aarg0 = 0xffffffff;
op[i].aarg2 = 0xffffffff;
op[i].aarg1 = WINED3DTA_CURRENT;
op[i].aop = WINED3DTOP_SELECTARG1;
} else if(i == 0 && stateblock->textures[0] &&
stateblock->renderState[WINED3DRS_COLORKEYENABLE] &&
(stateblock->textureDimensions[0] == GL_TEXTURE_2D ||
stateblock->textureDimensions[0] == GL_TEXTURE_RECTANGLE_ARB)) {
IWineD3DSurfaceImpl *surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *) stateblock->textures[0])->surfaces[0];
if(surf->CKeyFlags & WINEDDSD_CKSRCBLT &&
getFormatDescEntry(surf->resource.format, NULL, NULL)->alphaMask == 0x00000000) {
if(op[0].aop == WINED3DTOP_DISABLE) {
op[0].aarg1 = WINED3DTA_TEXTURE;
op[0].aop = WINED3DTOP_SELECTARG1;
}
else if(op[0].aop == WINED3DTOP_SELECTARG1 && op[0].aarg1 != WINED3DTA_TEXTURE) {
if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE]) {
op[0].aarg2 = WINED3DTA_TEXTURE;
op[0].aop = WINED3DTOP_MODULATE;
}
else op[0].aarg1 = WINED3DTA_TEXTURE;
}
else if(op[0].aop == WINED3DTOP_SELECTARG2 && op[0].aarg2 != WINED3DTA_TEXTURE) {
if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE]) {
op[0].aarg1 = WINED3DTA_TEXTURE;
op[0].aop = WINED3DTOP_MODULATE;
}
else op[0].aarg2 = WINED3DTA_TEXTURE;
}
}
}
if(op[i].carg1 == WINED3DTA_TEXTURE || op[i].carg2 == WINED3DTA_TEXTURE || op[i].carg0 == WINED3DTA_TEXTURE ||
op[i].aarg1 == WINED3DTA_TEXTURE || op[i].aarg2 == WINED3DTA_TEXTURE || op[i].aarg0 == WINED3DTA_TEXTURE) {
ttff = stateblock->textureState[i][WINED3DTSS_TEXTURETRANSFORMFLAGS];
if(ttff == (WINED3DTTFF_PROJECTED | WINED3DTTFF_COUNT3)) {
op[i].projected = proj_count3;
} else if(ttff == (WINED3DTTFF_PROJECTED | WINED3DTTFF_COUNT4)) {
op[i].projected = proj_count4;
} else {
op[i].projected = proj_none;
}
} else {
op[i].projected = proj_none;
}
wined3d: Implement D3DTA_TEMP in the GL_ATI_fragment_shader codepath.
2008-03-29 23:55:09 +01:00
op[i].dst = stateblock->textureState[i][WINED3DTSS_RESULTARG];
wined3d: Fragment processing using GL_ATI_fragment_shader. This adds code for handling fixed function fragment processing with the GL_ATI_fragment_shader extension. This is a sort-of programmable interface for fragment processing at the level of shader model 1.4 in d3d. This code is of use on r200, r250 and r280 cards(radeon 8500 to 9200) which do not support GL_ARB_fragment_program, but support pixel shader 1.4 on Windows. This code is somewhat a counterpart to the existing fragment processing code using GL_NV_register_combiners and GL_NV_texture_shader.
2008-03-22 14:31:52 +01:00
}
/* Clear unsupported stages */
for(; i < MAX_TEXTURES; i++) {
memset(&op[i], 0xff, sizeof(op[i]));
}
}
#undef GLINFO_LOCATION
struct ffp_desc *find_ffp_shader(struct list *shaders, struct texture_stage_op op[MAX_TEXTURES])
{
struct ffp_desc *entry;
/* TODO: Optimize this. Finding the shader can be optimized by e.g. sorting the list,
* or maybe consider using hashtables
*/
LIST_FOR_EACH_ENTRY(entry, shaders, struct ffp_desc, entry) {
if(memcmp(op, entry->op, sizeof(struct texture_stage_op) * MAX_TEXTURES) == 0) {
wined3d: Remove some debug TRACE stuff.
2008-03-27 21:42:45 +01:00
TRACE("Found shader entry %p\n", entry);
wined3d: Fragment processing using GL_ATI_fragment_shader. This adds code for handling fixed function fragment processing with the GL_ATI_fragment_shader extension. This is a sort-of programmable interface for fragment processing at the level of shader model 1.4 in d3d. This code is of use on r200, r250 and r280 cards(radeon 8500 to 9200) which do not support GL_ARB_fragment_program, but support pixel shader 1.4 on Windows. This code is somewhat a counterpart to the existing fragment processing code using GL_NV_register_combiners and GL_NV_texture_shader.
2008-03-22 14:31:52 +01:00
return entry;
}
}
TRACE("Shader not found\n");
return NULL;
}
void add_ffp_shader(struct list *shaders, struct ffp_desc *desc) {
list_add_head(shaders, &desc->entry);
}
wined3d: Call activate_dimensions from the atifs code.
2008-04-23 22:23:57 +02:00
/* Activates the texture dimension according to the bound D3D texture.
* Does not care for the colorop or correct gl texture unit(when using nvrc)
* Requires the caller to activate the correct unit before
*/
#define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
void texture_activate_dimensions(DWORD stage, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
BOOL bumpmap = FALSE;
if(stage > 0 && (stateblock->textureState[stage - 1][WINED3DTSS_COLOROP] == WINED3DTOP_BUMPENVMAPLUMINANCE ||
stateblock->textureState[stage - 1][WINED3DTSS_COLOROP] == WINED3DTOP_BUMPENVMAP)) {
bumpmap = TRUE;
context->texShaderBumpMap |= (1 << stage);
} else {
context->texShaderBumpMap &= ~(1 << stage);
}
if(stateblock->textures[stage]) {
switch(stateblock->textureDimensions[stage]) {
case GL_TEXTURE_2D:
if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, bumpmap ? GL_OFFSET_TEXTURE_2D_NV : GL_TEXTURE_2D);
checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, ...)");
} else {
glDisable(GL_TEXTURE_3D);
checkGLcall("glDisable(GL_TEXTURE_3D)");
if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
}
if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
glDisable(GL_TEXTURE_RECTANGLE_ARB);
checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
}
glEnable(GL_TEXTURE_2D);
checkGLcall("glEnable(GL_TEXTURE_2D)");
}
break;
case GL_TEXTURE_RECTANGLE_ARB:
if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, bumpmap ? GL_OFFSET_TEXTURE_2D_NV : GL_TEXTURE_RECTANGLE_ARB);
checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, ...)");
} else {
glDisable(GL_TEXTURE_2D);
checkGLcall("glDisable(GL_TEXTURE_2D)");
glDisable(GL_TEXTURE_3D);
checkGLcall("glDisable(GL_TEXTURE_3D)");
if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
}
glEnable(GL_TEXTURE_RECTANGLE_ARB);
checkGLcall("glEnable(GL_TEXTURE_RECTANGLE_ARB)");
}
break;
case GL_TEXTURE_3D:
if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_3D);
checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_3D)");
} else {
if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
}
if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
glDisable(GL_TEXTURE_RECTANGLE_ARB);
checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
}
glDisable(GL_TEXTURE_2D);
checkGLcall("glDisable(GL_TEXTURE_2D)");
glEnable(GL_TEXTURE_3D);
checkGLcall("glEnable(GL_TEXTURE_3D)");
}
break;
case GL_TEXTURE_CUBE_MAP_ARB:
if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_CUBE_MAP_ARB);
checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_CUBE_MAP_ARB)");
} else {
glDisable(GL_TEXTURE_2D);
checkGLcall("glDisable(GL_TEXTURE_2D)");
glDisable(GL_TEXTURE_3D);
checkGLcall("glDisable(GL_TEXTURE_3D)");
if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
glDisable(GL_TEXTURE_RECTANGLE_ARB);
checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
}
glEnable(GL_TEXTURE_CUBE_MAP_ARB);
checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
}
break;
}
} else {
if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE);
checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE)");
} else {
glEnable(GL_TEXTURE_2D);
checkGLcall("glEnable(GL_TEXTURE_2D)");
glDisable(GL_TEXTURE_3D);
checkGLcall("glDisable(GL_TEXTURE_3D)");
if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
}
if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
glDisable(GL_TEXTURE_RECTANGLE_ARB);
checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
}
/* Binding textures is done by samplers. A dummy texture will be bound */
}
}
}
#undef GLINFO_LOCATION