ReactOS  0.4.15-dev-425-gc40b086
shader.c File Reference
#include "wine/test.h"
#include "d3dx9.h"
Include dependency graph for shader.c:

Go to the source code of this file.

Classes

struct  registerset_test
 
struct  registerset_constants
 

Macros

#define FCC_TEXT   MAKEFOURCC('T','E','X','T')
 
#define FCC_CTAB   MAKEFOURCC('C','T','A','B')
 
#define REGISTER_OUTPUT_SIZE   48
 

Enumerations

enum  Type {
  T_UNKNOWN = -1, T_IGNORED_STATEMENT, T_TIDENT, T_MACRO,
  T_DEFINE, T_VARIABLE, T_FUNCTION, T_FUNCTION_PTR,
  T_IF, T_WHILE, T_DO, T_STRUCT,
  SetFloat, SetInt, SetBool, SetIntArray,
  SetBoolArray, SetFloatArray, SetMatrix, SetMatrixTranspose,
  SetMatrixArray, SetMatrixTransposeArray, SetVector, SetVectorArray,
  SetValue, SetMatrixPointerArray, SetMatrixTransposePointerArray
}
 

Functions

static void test_get_shader_size (void)
 
static void test_get_shader_version (void)
 
static void test_find_shader_comment (void)
 
static void test_get_shader_constant_table_ex (void)
 
static void test_constant_table (const char *test_name, const DWORD *ctable_fn, const D3DXCONSTANT_DESC *expecteds, UINT count)
 
static void test_constant_tables (void)
 
static void test_setting_basic_table (IDirect3DDevice9 *device)
 
static void test_setting_matrices_table (IDirect3DDevice9 *device)
 
static void test_setting_arrays_table (IDirect3DDevice9 *device)
 
static void test_SetDefaults (IDirect3DDevice9 *device)
 
static void test_SetValue (IDirect3DDevice9 *device)
 
static void test_setting_constants (void)
 
static void test_get_sampler_index (void)
 
static void test_get_shader_samplers (void)
 
static void test_get_shader_constant_variables (void)
 
static void registerset_clear (IDirect3DDevice9 *device)
 
static UINT registerset_compare (IDirect3DDevice9 *device, BOOL is_vs, D3DXREGISTER_SET regset, UINT start, UINT in_count, const DWORD *expected)
 
static UINT registerset_compare_all (IDirect3DDevice9 *device, BOOL is_vs, D3DXREGISTER_SET regset, UINT start, UINT in_count, const DWORD *expected)
 
static HRESULT registerset_apply (ID3DXConstantTable *ctable, IDirect3DDevice9 *device, D3DXHANDLE constant, UINT index, DWORD count, enum Type type)
 
static void test_registerset (void)
 
static void test_registerset_defaults (void)
 
static void test_shader_semantics (void)
 
static void test_disassemble_shader (void)
 
 START_TEST (shader)
 

Variables

static const DWORD shader_zero [] = {0x0}
 
static const DWORD shader_invalid [] = {0xeeee0100}
 
static const DWORD shader_empty [] = {0xfffe0200, 0x0000ffff}
 
static const DWORD simple_fx [] = {0x46580000, 0x0002fffe, FCC_TEXT, 0x00000000, 0x0000ffff}
 
static const DWORD simple_tx [] = {0x54580000, 0x0002fffe, FCC_TEXT, 0x00000000, 0x0000ffff}
 
static const DWORD simple_7ffe [] = {0x7ffe0000, 0x0002fffe, FCC_TEXT, 0x00000000, 0x0000ffff}
 
static const DWORD simple_7fff [] = {0x7fff0000, 0x0002fffe, FCC_TEXT, 0x00000000, 0x0000ffff}
 
static const DWORD simple_vs []
 
static const DWORD simple_ps []
 
static const DWORD shader_with_ctab []
 
static const DWORD shader_with_invalid_ctab []
 
static const DWORD shader_with_ctab_constants []
 
static const DWORD ctab_basic []
 
static const D3DXCONSTANT_DESC ctab_basic_expected []
 
static const DWORD ctab_matrices []
 
static const D3DXCONSTANT_DESC ctab_matrices_expected []
 
static const DWORD ctab_matrices2 []
 
static const D3DXCONSTANT_DESC ctab_matrices2_expected []
 
static const DWORD ctab_arrays []
 
static const D3DXCONSTANT_DESC ctab_arrays_expected []
 
static const DWORD ctab_with_default_values []
 
static const float mat4_default_value [] = {1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, 4, 8, 12, 16}
 
static const float mat3_default_value [] = {11, 55, 99, 1313, 22, 66, 1010, 1414, 33, 77, 1111, 1515, 44, 88, 1212, 1616}
 
static const float arr_default_value [] = {100, 0, 0, 0, 200, 0, 0, 0, 300, 0, 0, 0}
 
static const float vec4_default_value [] = {10, 20, 30, 40}
 
static const float flt_default_value [] = {9.99, 0, 0, 0}
 
static const D3DXCONSTANT_DESC ctab_with_default_values_expected []
 
static const DWORD ctab_samplers []
 
static const D3DXCONSTANT_DESC ctab_samplers_expected []
 
static const DWORD fx_shader_with_ctab []
 
static const DWORD get_shader_samplers_blob []
 
static const DWORD test_get_shader_constant_variables_blob []
 
struct {
   const char *   fullname
 
   D3DXCONSTANT_DESC   desc
 
   UINT   ctaboffset
 
test_get_shader_constant_variables_data []
 
static const DWORD registerset_test_input [][REGISTER_OUTPUT_SIZE]
 
static const DWORD registerset_blob_scalar []
 
static const struct registerset_constants registerset_constants_scalar_float []
 
static const struct registerset_test registerset_test_scalar_float []
 
static const struct registerset_constants registerset_constants_scalar_int []
 
static const struct registerset_test registerset_test_scalar_int []
 
static const struct registerset_constants registerset_constants_scalar_int_float []
 
static const struct registerset_test registerset_test_scalar_int_float []
 
static const struct registerset_constants registerset_constants_scalar_bool_float []
 
static const struct registerset_test registerset_test_scalar_bool_float []
 
static const struct registerset_constants registerset_constants_scalar_bool []
 
static const struct registerset_test registerset_test_scalar_bool []
 
static const DWORD registerset_blob_scalar_array []
 
static const struct registerset_constants registerset_constants_scalar_array_float []
 
static const struct registerset_test registerset_test_scalar_array_float []
 
static const struct registerset_constants registerset_constants_scalar_array_int []
 
static const struct registerset_test registerset_test_scalar_array_int []
 
static const struct registerset_constants registerset_constants_scalar_array_bool []
 
static const struct registerset_test registerset_test_scalar_array_bool []
 
static const struct registerset_constants registerset_constants_scalar_array_bool_float []
 
static const struct registerset_test registerset_test_scalar_array_bool_float []
 
static const struct registerset_constants registerset_constants_scalar_array_int_float []
 
static const struct registerset_test registerset_test_scalar_array_int_float []
 
static const DWORD registerset_blob_vector []
 
static const struct registerset_constants registerset_constants_vector_float []
 
static const struct registerset_test registerset_test_vector_float []
 
static const struct registerset_constants registerset_constants_vector_int []
 
static const struct registerset_test registerset_test_vector_int []
 
static const struct registerset_constants registerset_constants_vector_bool []
 
static const struct registerset_test registerset_test_vector_bool []
 
static const struct registerset_constants registerset_constants_vector_bool_float []
 
static const struct registerset_test registerset_test_vector_bool_float []
 
static const struct registerset_constants registerset_constants_vector_int_float []
 
static const struct registerset_test registerset_test_vector_int_float []
 
static const DWORD registerset_blob_vector_array []
 
static const struct registerset_constants registerset_constants_vector_array_float []
 
static const struct registerset_test registerset_test_vector_array_float []
 
static const struct registerset_constants registerset_constants_vector_array_int []
 
static const struct registerset_test registerset_test_vector_array_int []
 
static const struct registerset_constants registerset_constants_vector_array_bool []
 
static const struct registerset_test registerset_test_vector_array_bool []
 
static const struct registerset_constants registerset_constants_vector_array_bool_float []
 
static const struct registerset_test registerset_test_vector_array_bool_float []
 
static const struct registerset_constants registerset_constants_vector_array_int_float []
 
static const struct registerset_test registerset_test_vector_array_int_float []
 
static const DWORD registerset_blob_column []
 
static const struct registerset_constants registerset_constants_column_float []
 
static const struct registerset_test registerset_test_column_float []
 
static const struct registerset_constants registerset_constants_column_int []
 
static const struct registerset_test registerset_test_column_int []
 
static const struct registerset_constants registerset_constants_column_bool []
 
static const struct registerset_test registerset_test_column_bool []
 
static const struct registerset_constants registerset_constants_column_int_float []
 
static const struct registerset_test registerset_test_column_int_float []
 
static const struct registerset_constants registerset_constants_column_bool_float []
 
static const struct registerset_test registerset_test_column_bool_float []
 
static const DWORD registerset_blob_column_array []
 
static const struct registerset_constants registerset_constants_column_array_float []
 
static const struct registerset_test registerset_test_column_array_float []
 
static const struct registerset_constants registerset_constants_column_array_int []
 
static const struct registerset_test registerset_test_column_array_int []
 
static const struct registerset_constants registerset_constants_column_array_bool []
 
static const struct registerset_test registerset_test_column_array_bool []
 
static const struct registerset_constants registerset_constants_column_array_int_float []
 
static const struct registerset_test registerset_test_column_array_int_float []
 
static const struct registerset_constants registerset_constants_column_array_bool_float []
 
static const struct registerset_test registerset_test_column_array_bool_float []
 
static const DWORD registerset_blob_row []
 
static const struct registerset_constants registerset_constants_row_float []
 
static const struct registerset_test registerset_test_row_float []
 
static const struct registerset_constants registerset_constants_row_int []
 
static const struct registerset_test registerset_test_row_int []
 
static const struct registerset_constants registerset_constants_row_bool []
 
static const struct registerset_test registerset_test_row_bool []
 
static const struct registerset_constants registerset_constants_row_int_float []
 
static const struct registerset_test registerset_test_row_int_float []
 
static const struct registerset_constants registerset_constants_row_bool_float []
 
static const struct registerset_test registerset_test_row_bool_float []
 
static const DWORD registerset_blob_row_array []
 
static const struct registerset_constants registerset_constants_row_array_float []
 
static const struct registerset_test registerset_test_row_array_float []
 
static const struct registerset_constants registerset_constants_row_array_int []
 
static const struct registerset_test registerset_test_row_array_int []
 
static const struct registerset_constants registerset_constants_row_array_bool []
 
static const struct registerset_test registerset_test_row_array_bool []
 
static const struct registerset_constants registerset_constants_row_array_int_float []
 
static const struct registerset_test registerset_test_row_array_int_float []
 
static const struct registerset_constants registerset_constants_row_array_bool_float []
 
static const struct registerset_test registerset_test_row_array_bool_float []
 
static const DWORD registerset_blob_struct []
 
static const struct registerset_constants registerset_constants_struct_float []
 
static const struct registerset_test registerset_test_struct_float []
 
static const struct registerset_constants registerset_constants_struct_int []
 
static const struct registerset_test registerset_test_struct_int []
 
static const struct registerset_constants registerset_constants_struct_bool []
 
static const struct registerset_test registerset_test_struct_bool []
 
static const struct registerset_constants registerset_constants_struct_int_float []
 
static const struct registerset_test registerset_test_struct_int_float []
 
static const struct registerset_constants registerset_constants_struct_bool_float []
 
static const struct registerset_test registerset_test_struct_bool_float []
 
static const DWORD registerset_blob_struct_array []
 
static const struct registerset_constants registerset_constants_struct_array_float []
 
static const struct registerset_test registerset_test_struct_array_float []
 
static const struct registerset_constants registerset_constants_struct_array_int []
 
static const struct registerset_test registerset_test_struct_array_int []
 
static const struct registerset_constants registerset_constants_struct_array_bool []
 
static const struct registerset_test registerset_test_struct_array_bool []
 
static const struct registerset_constants registerset_constants_struct_array_int_float []
 
static const struct registerset_test registerset_test_struct_array_int_float []
 
static const struct registerset_constants registerset_constants_struct_array_bool_float []
 
static const struct registerset_test registerset_test_struct_array_bool_float []
 
static const DWORD registerset_blob_struct_struct []
 
static const struct registerset_constants registerset_constants_struct_struct_float []
 
static const struct registerset_test registerset_test_struct_struct_float []
 
static const struct registerset_constants registerset_constants_struct_struct_int []
 
static const struct registerset_test registerset_test_struct_struct_int []
 
static const struct registerset_constants registerset_constants_struct_struct_bool []
 
static const struct registerset_test registerset_test_struct_struct_bool []
 
static const struct registerset_constants registerset_constants_struct_struct_int_float []
 
static const struct registerset_test registerset_test_struct_struct_int_float []
 
static const struct registerset_constants registerset_constants_struct_struct_bool_float []
 
static const struct registerset_test registerset_test_struct_struct_bool_float []
 
static const DWORD registerset_blob_special_int []
 
static const struct registerset_constants registerset_constants_special_int []
 
static const DWORD registerset_blob_bigvec []
 
static const struct registerset_constants registerset_constants_bigvec_float []
 
static const struct registerset_test registerset_test_bigvec_float []
 
static const DWORD registerset_blob_matrix_column_clamp []
 
static const struct registerset_constants registerset_constants_matrix_column_clamp []
 
static const struct registerset_test registerset_test_matrix_column_clamp []
 
struct {
   const char *   name
 
   const char *   var
 
   UINT   start
 
   D3DXREGISTER_SET   regset
 
   const DWORD *   blob
 
   const struct registerset_test *   tests
 
   UINT   test_count
 
   const struct registerset_constants *   constants
 
   UINT   constant_count
 
registerset_data []
 
struct {
   const char *   name
 
   const DWORD *   blob
 
   unsigned int   float_count
 
   unsigned int   int_count
 
   unsigned int   bool_count
 
   const DWORD   floats [1024]
 
   const DWORD   ints [256]
 
   const DWORD   bools [16]
 
registerset_defaults_data []
 
static const DWORD ps_tex []
 
static const DWORD ps_texld_1_4 []
 
static const DWORD ps_texld_2_0 []
 
static const DWORD ps_texcoord []
 
static const DWORD ps_texcrd []
 
static const DWORD ps_sincos_2_0 []
 
static const DWORD ps_sincos_3_0 []
 
static const DWORD vs_sincos_2_0 []
 
static const DWORD vs_sincos_3_0 []
 

Macro Definition Documentation

◆ FCC_CTAB

#define FCC_CTAB   MAKEFOURCC('C','T','A','B')

Definition at line 24 of file shader.c.

◆ FCC_TEXT

#define FCC_TEXT   MAKEFOURCC('T','E','X','T')

Definition at line 23 of file shader.c.

◆ REGISTER_OUTPUT_SIZE

#define REGISTER_OUTPUT_SIZE   48

Definition at line 1964 of file shader.c.

Enumeration Type Documentation

◆ Type

Enumerator
T_UNKNOWN 
T_IGNORED_STATEMENT 
T_TIDENT 
T_MACRO 
T_DEFINE 
T_VARIABLE 
T_FUNCTION 
T_FUNCTION_PTR 
T_IF 
T_WHILE 
T_DO 
T_STRUCT 
SetFloat 
SetInt 
SetBool 
SetIntArray 
SetBoolArray 
SetFloatArray 
SetMatrix 
SetMatrixTranspose 
SetMatrixArray 
SetMatrixTransposeArray 
SetVector 
SetVectorArray 
SetValue 
SetMatrixPointerArray 
SetMatrixTransposePointerArray 

Definition at line 1966 of file shader.c.

Function Documentation

◆ registerset_apply()

static HRESULT registerset_apply ( ID3DXConstantTable *  ctable,
IDirect3DDevice9 *  device,
D3DXHANDLE  constant,
UINT  index,
DWORD  count,
enum Type  type 
)
static

Definition at line 5964 of file shader.c.

5966 {
5968  const D3DXMATRIX *inp[REGISTER_OUTPUT_SIZE / 16];
5969  unsigned int i;
5970 
5971  /* overlap, to see the difference between Array and PointerArray */
5972  for (i = 0; i < REGISTER_OUTPUT_SIZE / 16; i++)
5973  {
5974  inp[i] = (D3DXMATRIX *)&in[i * 15];
5975  }
5976 
5977  switch (type)
5978  {
5979  case SetInt:
5981  case SetFloat:
5983  case SetBool:
5985  case SetIntArray:
5987  case SetBoolArray:
5989  case SetFloatArray:
5991  case SetMatrix:
5993  case SetMatrixTranspose:
5995  case SetMatrixArray:
5999  case SetVector:
6001  case SetVectorArray:
6003  case SetValue:
6005  case SetMatrixPointerArray:
6009  }
6010 
6011  ok(0, "This should not happen!\n");
6012  return D3D_OK;
6013 }
#define ID3DXConstantTable_SetMatrixTranspose(p, a, b, c)
Definition: d3dx9shader.h:201
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define ID3DXConstantTable_SetBoolArray(p, a, b, c, d)
Definition: d3dx9shader.h:191
#define ID3DXConstantTable_SetIntArray(p, a, b, c, d)
Definition: d3dx9shader.h:193
#define ID3DXConstantTable_SetFloat(p, a, b, c)
Definition: d3dx9shader.h:194
int32_t INT
Definition: typedefs.h:57
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
unsigned int BOOL
Definition: ntddk_ex.h:94
Definition: devices.h:37
#define ID3DXConstantTable_SetMatrixPointerArray(p, a, b, c, d)
Definition: d3dx9shader.h:200
#define ID3DXConstantTable_SetMatrixTransposeArray(p, a, b, c, d)
Definition: d3dx9shader.h:202
static _Locale_mask_t ctable[256]
#define ID3DXConstantTable_SetMatrixTransposePointerArray(p, a, b, c, d)
Definition: d3dx9shader.h:203
#define ID3DXConstantTable_SetBool(p, a, b, c)
Definition: d3dx9shader.h:190
static const DWORD registerset_test_input[][REGISTER_OUTPUT_SIZE]
Definition: shader.c:1987
unsigned long DWORD
Definition: ntddk_ex.h:95
#define ID3DXConstantTable_SetFloatArray(p, a, b, c, d)
Definition: d3dx9shader.h:195
#define index(s, c)
Definition: various.h:29
#define ID3DXConstantTable_SetVectorArray(p, a, b, c, d)
Definition: d3dx9shader.h:197
#define ID3DXConstantTable_SetMatrixArray(p, a, b, c, d)
Definition: d3dx9shader.h:199
#define ID3DXConstantTable_SetMatrix(p, a, b, c)
Definition: d3dx9shader.h:198
#define ID3DXConstantTable_SetInt(p, a, b, c)
Definition: d3dx9shader.h:192
#define D3D_OK
Definition: d3d.h:106
GLuint in
Definition: glext.h:9616
#define REGISTER_OUTPUT_SIZE
Definition: shader.c:1964
#define ID3DXConstantTable_SetValue(p, a, b, c, d)
Definition: d3dx9shader.h:189
#define ok(value,...)
Definition: atltest.h:57
float FLOAT
Definition: typedefs.h:68
#define ID3DXConstantTable_SetVector(p, a, b, c)
Definition: d3dx9shader.h:196

Referenced by test_registerset().

◆ registerset_clear()

static void registerset_clear ( IDirect3DDevice9 *  device)
static

Definition at line 5864 of file shader.c.

5865 {
5866  DWORD zero[1024];
5867  HRESULT hr;
5868 
5869  memset(zero, 0xde, 4096);
5870 
5872  ok(hr == D3D_OK, "Clear failed, got %08x, expected %08x\n", hr, D3D_OK);
5873 
5875  ok(hr == D3D_OK, "Clear failed, got %08x, expected %08x\n", hr, D3D_OK);
5876 
5878  ok(hr == D3D_OK, "Clear failed, got %08x, expected %08x\n", hr, D3D_OK);
5879 
5881  ok(hr == D3D_OK, "Clear failed, got %08x, expected %08x\n", hr, D3D_OK);
5882 
5884  ok(hr == D3D_OK, "Clear failed, got %08x, expected %08x\n", hr, D3D_OK);
5885 
5887  ok(hr == D3D_OK, "Clear failed, got %08x, expected %08x\n", hr, D3D_OK);
5888 }
#define IDirect3DDevice9_SetPixelShaderConstantB(p, a, b, c)
Definition: d3d9.h:1620
HRESULT hr
Definition: shlfolder.c:183
#define IDirect3DDevice9_SetVertexShaderConstantI(p, a, b, c)
Definition: d3d9.h:1603
int32_t INT
Definition: typedefs.h:57
unsigned int BOOL
Definition: ntddk_ex.h:94
Definition: devices.h:37
#define IDirect3DDevice9_SetVertexShaderConstantF(p, a, b, c)
Definition: d3d9.h:1601
#define IDirect3DDevice9_SetPixelShaderConstantI(p, a, b, c)
Definition: d3d9.h:1618
LONG HRESULT
Definition: typedefs.h:78
unsigned long DWORD
Definition: ntddk_ex.h:95
static double zero
Definition: j0_y0.c:96
#define D3D_OK
Definition: d3d.h:106
#define IDirect3DDevice9_SetVertexShaderConstantB(p, a, b, c)
Definition: d3d9.h:1605
#define ok(value,...)
Definition: atltest.h:57
float FLOAT
Definition: typedefs.h:68
#define IDirect3DDevice9_SetPixelShaderConstantF(p, a, b, c)
Definition: d3d9.h:1616
#define memset(x, y, z)
Definition: compat.h:39

Referenced by test_registerset(), and test_registerset_defaults().

◆ registerset_compare()

static UINT registerset_compare ( IDirect3DDevice9 *  device,
BOOL  is_vs,
D3DXREGISTER_SET  regset,
UINT  start,
UINT  in_count,
const DWORD expected 
)
static

Definition at line 5890 of file shader.c.

5892 {
5893  DWORD ret[1024] = {0};
5894  HRESULT hr;
5895  UINT count = 1024, i, err = 0;
5896 
5897  memset(ret, 0xde, 4096);
5898 
5899  /* get shader constants */
5900  switch (regset)
5901  {
5902  case D3DXRS_BOOL:
5903  count = 16;
5906  ok(hr == D3D_OK, "Get*ShaderConstantB failed, got %08x\n", hr);
5907  break;
5908 
5909  case D3DXRS_INT4:
5910  count = 256;
5911  if (is_vs) hr = IDirect3DDevice9_GetVertexShaderConstantI(device, 0, (INT*)ret, 16);
5913  ok(hr == D3D_OK, "Get*ShaderConstantI failed, got %08x\n", hr);
5914  break;
5915 
5916  case D3DXRS_FLOAT4:
5917  if (is_vs) hr = IDirect3DDevice9_GetVertexShaderConstantF(device, 0, (FLOAT*)ret, 256);
5918  else
5919  {
5920  count = 896;
5922  }
5923  ok(hr == D3D_OK, "Get*ShaderConstantF failed, got %08x\n", hr);
5924  break;
5925 
5926  default:
5927  ok(0, "This should not happen!\n");
5928  break;
5929  }
5930 
5931  /* compare shader constants */
5932  for (i = 0; i < count; ++i)
5933  {
5934  DWORD value = 0xdededede;
5935  if (i >= start && i < start + in_count) value = expected[i - start];
5936 
5937  ok(ret[i] == value, "Get*ShaderConstant failed, %u got 0x%x(%f) expected 0x%x(%f)\n", i,
5938  ret[i], ((FLOAT *)ret)[i], value, *((FLOAT *)&value));
5939  if (ret[i] != value) err++;
5940  }
5941 
5942  return err;
5943 }
#define IDirect3DDevice9_GetPixelShaderConstantI(p, a, b, c)
Definition: d3d9.h:1619
HRESULT hr
Definition: shlfolder.c:183
D3DXREGISTER_SET regset
Definition: shader.c:5668
GLuint GLuint GLsizei count
Definition: gl.h:1545
UINT start
Definition: shader.c:5667
int32_t INT
Definition: typedefs.h:57
#define IDirect3DDevice9_GetVertexShaderConstantI(p, a, b, c)
Definition: d3d9.h:1604
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
unsigned int BOOL
Definition: ntddk_ex.h:94
Definition: devices.h:37
#define IDirect3DDevice9_GetPixelShaderConstantF(p, a, b, c)
Definition: d3d9.h:1617
#define IDirect3DDevice9_GetVertexShaderConstantF(p, a, b, c)
Definition: d3d9.h:1602
LONG HRESULT
Definition: typedefs.h:78
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
#define IDirect3DDevice9_GetPixelShaderConstantB(p, a, b, c)
Definition: d3d9.h:1621
#define err(...)
#define D3D_OK
Definition: d3d.h:106
GLuint start
Definition: gl.h:1545
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
float FLOAT
Definition: typedefs.h:68
#define memset(x, y, z)
Definition: compat.h:39
BOOL expected
Definition: store.c:2063
#define IDirect3DDevice9_GetVertexShaderConstantB(p, a, b, c)
Definition: d3d9.h:1606

Referenced by registerset_compare_all(), and test_registerset_defaults().

◆ registerset_compare_all()

static UINT registerset_compare_all ( IDirect3DDevice9 *  device,
BOOL  is_vs,
D3DXREGISTER_SET  regset,
UINT  start,
UINT  in_count,
const DWORD expected 
)
static

Definition at line 5945 of file shader.c.

5947 {
5949  UINT err = 0, i;
5950 
5951  for (i = 0; i < ARRAY_SIZE(regsets); i++)
5952  {
5953  if (regset == regsets[i])
5954  err += registerset_compare(device, is_vs, regset, start, in_count, expected);
5955  else
5956  err += registerset_compare(device, is_vs, regsets[i], 0, 0, NULL);
5957 
5958  err += registerset_compare(device, !is_vs, regsets[i], 0, 0, NULL);
5959  }
5960 
5961  return err;
5962 }
D3DXREGISTER_SET regset
Definition: shader.c:5668
static UINT registerset_compare(IDirect3DDevice9 *device, BOOL is_vs, D3DXREGISTER_SET regset, UINT start, UINT in_count, const DWORD *expected)
Definition: shader.c:5890
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
Definition: devices.h:37
smooth NULL
Definition: ftsmooth.c:416
enum _D3DXREGISTER_SET D3DXREGISTER_SET
#define err(...)
GLuint start
Definition: gl.h:1545
#define ARRAY_SIZE(a)
Definition: main.h:24
unsigned int UINT
Definition: ndis.h:50
BOOL expected
Definition: store.c:2063

Referenced by test_registerset().

◆ START_TEST()

START_TEST ( shader  )

Definition at line 6786 of file shader.c.

6787 {
6797  test_registerset();
6801 }
static void test_registerset_defaults(void)
Definition: shader.c:6320
static void test_constant_tables(void)
Definition: shader.c:649
static void test_registerset(void)
Definition: shader.c:6015
static void test_get_shader_constant_table_ex(void)
Definition: shader.c:404
static void test_get_shader_constant_variables(void)
Definition: shader.c:1830
static void test_disassemble_shader(void)
Definition: shader.c:6632
static void test_get_sampler_index(void)
Definition: shader.c:1499
static void test_get_shader_samplers(void)
Definition: shader.c:1592
static void test_get_shader_size(void)
Definition: shader.c:302
static void test_shader_semantics(void)
Definition: shader.c:6415
static void test_get_shader_version(void)
Definition: shader.c:318
static void test_setting_constants(void)
Definition: shader.c:1449
static void test_find_shader_comment(void)
Definition: shader.c:334

◆ test_constant_table()

static void test_constant_table ( const char test_name,
const DWORD ctable_fn,
const D3DXCONSTANT_DESC expecteds,
UINT  count 
)
static

Definition at line 571 of file shader.c.

573 {
574  UINT i;
575  ID3DXConstantTable *ctable;
576 
577  HRESULT res;
578 
579  /* Get the constant table from the shader itself */
580  res = D3DXGetShaderConstantTable(ctable_fn, &ctable);
581  ok(res == D3D_OK, "D3DXGetShaderConstantTable failed on %s: got %08x\n", test_name, res);
582 
583  for (i = 0; i < count; i++)
584  {
585  const D3DXCONSTANT_DESC *expected = &expecteds[i];
586  D3DXHANDLE const_handle;
587  D3DXCONSTANT_DESC actual;
588  UINT pCount = 1;
589 
591 
592  res = ID3DXConstantTable_GetConstantDesc(ctable, const_handle, &actual, &pCount);
593  ok(SUCCEEDED(res), "%s in %s: ID3DXConstantTable_GetConstantDesc returned %08x\n", expected->Name,
594  test_name, res);
595  ok(pCount == 1, "%s in %s: Got more or less descriptions: %d\n", expected->Name, test_name, pCount);
596 
597  ok(strcmp(actual.Name, expected->Name) == 0,
598  "%s in %s: Got different names: Got %s, expected %s\n", expected->Name,
599  test_name, actual.Name, expected->Name);
600  ok(actual.RegisterSet == expected->RegisterSet,
601  "%s in %s: Got different register sets: Got %d, expected %d\n",
602  expected->Name, test_name, actual.RegisterSet, expected->RegisterSet);
603  ok(actual.RegisterIndex == expected->RegisterIndex,
604  "%s in %s: Got different register indices: Got %d, expected %d\n",
605  expected->Name, test_name, actual.RegisterIndex, expected->RegisterIndex);
606  ok(actual.RegisterCount == expected->RegisterCount,
607  "%s in %s: Got different register counts: Got %d, expected %d\n",
608  expected->Name, test_name, actual.RegisterCount, expected->RegisterCount);
609  ok(actual.Class == expected->Class,
610  "%s in %s: Got different classes: Got %d, expected %d\n", expected->Name,
611  test_name, actual.Class, expected->Class);
612  ok(actual.Type == expected->Type,
613  "%s in %s: Got different types: Got %d, expected %d\n", expected->Name,
614  test_name, actual.Type, expected->Type);
615  ok(actual.Rows == expected->Rows && actual.Columns == expected->Columns,
616  "%s in %s: Got different dimensions: Got (%d, %d), expected (%d, %d)\n",
617  expected->Name, test_name, actual.Rows, actual.Columns, expected->Rows,
618  expected->Columns);
619  ok(actual.Elements == expected->Elements,
620  "%s in %s: Got different element count: Got %d, expected %d\n",
621  expected->Name, test_name, actual.Elements, expected->Elements);
622  ok(actual.StructMembers == expected->StructMembers,
623  "%s in %s: Got different struct member count: Got %d, expected %d\n",
624  expected->Name, test_name, actual.StructMembers, expected->StructMembers);
625  ok(actual.Bytes == expected->Bytes,
626  "%s in %s: Got different byte count: Got %d, expected %d\n",
627  expected->Name, test_name, actual.Bytes, expected->Bytes);
628 
629  if (!expected->DefaultValue)
630  {
631  ok(actual.DefaultValue == NULL,
632  "%s in %s: Got different default value: expected NULL\n",
633  expected->Name, test_name);
634  }
635  else
636  {
637  ok(actual.DefaultValue != NULL,
638  "%s in %s: Got different default value: expected non-NULL\n",
639  expected->Name, test_name);
640  ok(memcmp(actual.DefaultValue, expected->DefaultValue, expected->Bytes) == 0,
641  "%s in %s: Got different default value\n", expected->Name, test_name);
642  }
643  }
644 
645  /* Finally, release the constant table */
647 }
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
const char * D3DXHANDLE
Definition: d3dx9shader.h:48
HRESULT WINAPI D3DXGetShaderConstantTable(const DWORD *byte_code, ID3DXConstantTable **constant_table)
Definition: shader.c:2104
GLuint GLuint GLsizei count
Definition: gl.h:1545
#define ID3DXConstantTable_Release(p)
Definition: d3dx9shader.h:177
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define ID3DXConstantTable_GetConstantDesc(p, a, b, c)
Definition: d3dx9shader.h:183
smooth NULL
Definition: ftsmooth.c:416
static _Locale_mask_t ctable[256]
D3DXPARAMETER_CLASS Class
Definition: d3dx9shader.h:109
#define ID3DXConstantTable_GetConstantByName(p, a, b)
Definition: d3dx9shader.h:186
D3DXREGISTER_SET RegisterSet
Definition: d3dx9shader.h:106
LONG HRESULT
Definition: typedefs.h:78
const char * Name
Definition: d3dx9shader.h:105
const void * DefaultValue
Definition: d3dx9shader.h:116
static const char * test_name
Definition: run.c:177
#define D3D_OK
Definition: d3d.h:106
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
GLuint res
Definition: glext.h:9613
D3DXPARAMETER_TYPE Type
Definition: d3dx9shader.h:110
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
BOOL expected
Definition: store.c:2063
#define SUCCEEDED(hr)
Definition: intsafe.h:57

Referenced by test_constant_tables().

◆ test_constant_tables()

static void test_constant_tables ( void  )
static

Definition at line 649 of file shader.c.

650 {
663 }
static void test_constant_table(const char *test_name, const DWORD *ctable_fn, const D3DXCONSTANT_DESC *expecteds, UINT count)
Definition: shader.c:571
static const D3DXCONSTANT_DESC ctab_matrices2_expected[]
Definition: shader.c:166
static const D3DXCONSTANT_DESC ctab_matrices_expected[]
Definition: shader.c:134
static const DWORD ctab_basic[]
Definition: shader.c:90
static const DWORD ctab_arrays[]
Definition: shader.c:174
static const D3DXCONSTANT_DESC ctab_samplers_expected[]
Definition: shader.c:278
static const D3DXCONSTANT_DESC ctab_arrays_expected[]
Definition: shader.c:201
static const DWORD ctab_matrices[]
Definition: shader.c:116
static const D3DXCONSTANT_DESC ctab_basic_expected[]
Definition: shader.c:109
static const DWORD ctab_matrices2[]
Definition: shader.c:140
static const DWORD ctab_samplers[]
Definition: shader.c:260
#define ARRAY_SIZE(a)
Definition: main.h:24
static const D3DXCONSTANT_DESC ctab_with_default_values_expected[]
Definition: shader.c:253
static const DWORD ctab_with_default_values[]
Definition: shader.c:209

Referenced by START_TEST().

◆ test_disassemble_shader()

static void test_disassemble_shader ( void  )
static

Definition at line 6632 of file shader.c.

6633 {
6634  static const char disasm_vs[] = " vs_1_1\n"
6635  " dcl_position v0\n"
6636  " dp4 oPos.x, v0, c0\n"
6637  " dp4 oPos.y, v0, c1\n"
6638  " dp4 oPos.z, v0, c2\n"
6639  " dp4 oPos.w, v0, c3\n";
6640  static const char disasm_ps[] = " ps_1_1\n"
6641  " def c1, 1, 0, 0, 0\n"
6642  " tex t0\n"
6643  " dp3 r0, c1, c0\n"
6644  " mul r0, v0, r0\n"
6645  " mul r0, t0, r0\n";
6646  static const char disasm_ps_tex[] = " ps_1_3\n"
6647  " tex t0\n"
6648  " nop\n";
6649  static const char disasm_ps_texld_1_4[] = " ps_1_4\n"
6650  " texld t0, c0\n"
6651  " nop\n";
6652  static const char disasm_ps_texld_2_0[] = " ps_2_0\n"
6653  " texld t0, c0, c1\n"
6654  " nop\n";
6655  static const char disasm_ps_texcoord[] = " ps_1_3\n"
6656  " texcoord t0\n"
6657  " nop\n";
6658  static const char disasm_ps_texcrd[] = " ps_1_4\n"
6659  " texcrd t0, c0\n"
6660  " nop\n";
6661  static const char disasm_ps_sincos_2_0[] = " ps_2_0\n"
6662  " sincos t0, c0, c1, c2\n"
6663  " nop\n";
6664  static const char disasm_ps_sincos_3_0[] = " ps_3_0\n"
6665  " sincos t0, c0\n"
6666  " nop\n";
6667  static const char disasm_vs_sincos_2_0[] = " vs_2_0\n"
6668  " sincos a0, c0, c1, c2\n"
6669  " nop\n";
6670  static const char disasm_vs_sincos_3_0[] = " vs_3_0\n"
6671  " sincos a0, c0\n"
6672  " nop\n";
6673  ID3DXBuffer *disassembly;
6674  HRESULT ret;
6675  char *ptr;
6676 
6677  /* Check wrong parameters */
6679  ok(ret == D3DERR_INVALIDCALL, "Returned %#x, expected %#x\n", ret, D3DERR_INVALIDCALL);
6680  ret = D3DXDisassembleShader(NULL, FALSE, NULL, &disassembly);
6681  ok(ret == D3DERR_INVALIDCALL, "Returned %#x, expected %#x\n", ret, D3DERR_INVALIDCALL);
6683  ok(ret == D3DERR_INVALIDCALL, "Returned %#x, expected %#x\n", ret, D3DERR_INVALIDCALL);
6684 
6685  /* Test with vertex shader */
6686  disassembly = (void *)0xdeadbeef;
6687  ret = D3DXDisassembleShader(simple_vs, FALSE, NULL, &disassembly);
6688  ok(ret == D3D_OK, "Failed with %#x\n", ret);
6689  ptr = ID3DXBuffer_GetBufferPointer(disassembly);
6690  ok(!memcmp(ptr, disasm_vs, sizeof(disasm_vs) - 1), /* compare beginning */
6691  "Returned '%s', expected '%s'\n", ptr, disasm_vs);
6692  ID3DXBuffer_Release(disassembly);
6693 
6694  /* Test with pixel shader */
6695  disassembly = (void *)0xdeadbeef;
6696  ret = D3DXDisassembleShader(simple_ps, FALSE, NULL, &disassembly);
6697  ok(ret == D3D_OK, "Failed with %#x\n", ret);
6698  ptr = ID3DXBuffer_GetBufferPointer(disassembly);
6699  ok(!memcmp(ptr, disasm_ps, sizeof(disasm_ps) - 1), /* compare beginning */
6700  "Returned '%s', expected '%s'\n", ptr, disasm_ps);
6701  ID3DXBuffer_Release(disassembly);
6702 
6703  /* Test tex instruction with pixel shader 1.3 */
6704  disassembly = (void *)0xdeadbeef;
6705  ret = D3DXDisassembleShader(ps_tex, FALSE, NULL, &disassembly);
6706  ok(ret == D3D_OK, "Failed with %#x\n", ret);
6707  ptr = ID3DXBuffer_GetBufferPointer(disassembly);
6708  ok(!memcmp(ptr, disasm_ps_tex, sizeof(disasm_ps_tex) - 1), /* compare beginning */
6709  "Returned '%s', expected '%s'\n", ptr, disasm_ps_tex);
6710  ID3DXBuffer_Release(disassembly);
6711 
6712  /* Test texld instruction with pixel shader 1.4 */
6713  disassembly = (void *)0xdeadbeef;
6714  ret = D3DXDisassembleShader(ps_texld_1_4, FALSE, NULL, &disassembly);
6715  ok(ret == D3D_OK, "Failed with %#x\n", ret);
6716  ptr = ID3DXBuffer_GetBufferPointer(disassembly);
6717  ok(!memcmp(ptr, disasm_ps_texld_1_4, sizeof(disasm_ps_texld_1_4) - 1), /* compare beginning */
6718  "Returned '%s', expected '%s'\n", ptr, disasm_ps_texld_1_4);
6719  ID3DXBuffer_Release(disassembly);
6720 
6721  /* Test texld instruction with pixel shader 2.0 */
6722  disassembly = (void *)0xdeadbeef;
6723  ret = D3DXDisassembleShader(ps_texld_2_0, FALSE, NULL, &disassembly);
6724  ok(ret == D3D_OK, "Failed with %#x\n", ret);
6725  ptr = ID3DXBuffer_GetBufferPointer(disassembly);
6726  ok(!memcmp(ptr, disasm_ps_texld_2_0, sizeof(disasm_ps_texld_2_0) - 1), /* compare beginning */
6727  "Returned '%s', expected '%s'\n", ptr, disasm_ps_texld_2_0);
6728  ID3DXBuffer_Release(disassembly);
6729 
6730  /* Test texcoord instruction with pixel shader 1.3 */
6731  disassembly = (void *)0xdeadbeef;
6732  ret = D3DXDisassembleShader(ps_texcoord, FALSE, NULL, &disassembly);
6733  ok(ret == D3D_OK, "Failed with %#x\n", ret);
6734  ptr = ID3DXBuffer_GetBufferPointer(disassembly);
6735  ok(!memcmp(ptr, disasm_ps_texcoord, sizeof(disasm_ps_texcoord) - 1), /* compare beginning */
6736  "Returned '%s', expected '%s'\n", ptr, disasm_ps_texcoord);
6737  ID3DXBuffer_Release(disassembly);
6738 
6739  /* Test texcrd instruction with pixel shader 1.4 */
6740  disassembly = (void *)0xdeadbeef;
6741  ret = D3DXDisassembleShader(ps_texcrd, FALSE, NULL, &disassembly);
6742  ok(ret == D3D_OK, "Failed with %#x\n", ret);
6743  ptr = ID3DXBuffer_GetBufferPointer(disassembly);
6744  ok(!memcmp(ptr, disasm_ps_texcrd, sizeof(disasm_ps_texcrd) - 1), /* compare beginning */
6745  "Returned '%s', expected '%s'\n", ptr, disasm_ps_texcrd);
6746  ID3DXBuffer_Release(disassembly);
6747 
6748  /* Test sincos instruction pixel shader 2.0 */
6749  disassembly = (void *)0xdeadbeef;
6750  ret = D3DXDisassembleShader(ps_sincos_2_0, FALSE, NULL, &disassembly);
6751  ok(ret == D3D_OK, "Failed with %#x\n", ret);
6752  ptr = ID3DXBuffer_GetBufferPointer(disassembly);
6753  ok(!memcmp(ptr, disasm_ps_sincos_2_0, sizeof(disasm_ps_sincos_2_0) - 1), /* compare beginning */
6754  "Returned '%s', expected '%s'\n", ptr, disasm_ps_sincos_2_0);
6755  ID3DXBuffer_Release(disassembly);
6756 
6757  /* Test sincos instruction with pixel shader 3.0 */
6758  disassembly = (void *)0xdeadbeef;
6759  ret = D3DXDisassembleShader(ps_sincos_3_0, FALSE, NULL, &disassembly);
6760  ok(ret == D3D_OK, "Failed with %#x\n", ret);
6761  ptr = ID3DXBuffer_GetBufferPointer(disassembly);
6762  ok(!memcmp(ptr, disasm_ps_sincos_3_0, sizeof(disasm_ps_sincos_3_0) - 1), /* compare beginning */
6763  "Returned '%s', expected '%s'\n", ptr, disasm_ps_sincos_3_0);
6764  ID3DXBuffer_Release(disassembly);
6765 
6766  /* Test sincos instruction with pixel shader 2.0 */
6767  disassembly = (void *)0xdeadbeef;
6768  ret = D3DXDisassembleShader(vs_sincos_2_0, FALSE, NULL, &disassembly);
6769  ok(ret == D3D_OK, "Failed with %#x\n", ret);
6770  ptr = ID3DXBuffer_GetBufferPointer(disassembly);
6771  ok(!memcmp(ptr, disasm_vs_sincos_2_0, sizeof(disasm_vs_sincos_2_0) - 1), /* compare beginning */
6772  "Returned '%s', expected '%s'\n", ptr, disasm_vs_sincos_2_0);
6773  ID3DXBuffer_Release(disassembly);
6774 
6775  /* Test sincos instruction with pixel shader 3.0 */
6776  disassembly = (void *)0xdeadbeef;
6777  ret = D3DXDisassembleShader(vs_sincos_3_0, FALSE, NULL, &disassembly);
6778  ok(ret == D3D_OK, "Failed with %#x\n", ret);
6779  ptr = ID3DXBuffer_GetBufferPointer(disassembly);
6780  ok(!memcmp(ptr, disasm_vs_sincos_3_0, sizeof(disasm_vs_sincos_3_0) - 1), /* compare beginning */
6781  "Returned '%s', expected '%s'\n", ptr, disasm_vs_sincos_3_0);
6782  ID3DXBuffer_Release(disassembly);
6783 
6784 }
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
static const DWORD simple_vs[]
Definition: shader.c:40
#define D3DERR_INVALIDCALL
static const DWORD vs_sincos_2_0[]
Definition: shader.c:6620
static const DWORD ps_texcoord[]
Definition: shader.c:6596
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
static const DWORD ps_texld_2_0[]
Definition: shader.c:6590
struct ID3DXBuffer ID3DXBuffer
Definition: d3dx8core.h:51
LONG HRESULT
Definition: typedefs.h:78
int ret
HRESULT WINAPI D3DXDisassembleShader(const DWORD *shader, BOOL colorcode, const char *comments, ID3DXBuffer **disassembly)
Definition: shader.c:2445
static const DWORD ps_texld_1_4[]
Definition: shader.c:6584
static const DWORD ps_sincos_3_0[]
Definition: shader.c:6614
#define D3D_OK
Definition: d3d.h:106
static const DWORD ps_sincos_2_0[]
Definition: shader.c:6608
#define ID3DXBuffer_Release(p)
Definition: d3dx9core.h:83
#define ok(value,...)
Definition: atltest.h:57
static const DWORD ps_tex[]
Definition: shader.c:6578
static const DWORD simple_ps[]
Definition: shader.c:49
#define ID3DXBuffer_GetBufferPointer(p)
Definition: d3dx9core.h:85
static const DWORD ps_texcrd[]
Definition: shader.c:6602
static const DWORD vs_sincos_3_0[]
Definition: shader.c:6626

Referenced by START_TEST().

◆ test_find_shader_comment()

static void test_find_shader_comment ( void  )
static

Definition at line 334 of file shader.c.

335 {
336  const void *data = (void *)0xdeadbeef;
337  HRESULT hr;
338  UINT size = 100;
339 
340  hr = D3DXFindShaderComment(NULL, MAKEFOURCC('C','T','A','B'), &data, &size);
341  ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
342  ok(!data, "Got %p, expected NULL\n", data);
343  ok(!size, "Got %u, expected 0\n", size);
344 
346  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
347  ok(size == 28, "Got %u, expected 28\n", size);
348 
350  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
351  ok(data == shader_with_ctab + 6, "Got result %p, expected %p\n", data, shader_with_ctab + 6);
352 
354  ok(hr == S_FALSE, "Got result %x, expected 1 (S_FALSE)\n", hr);
355  ok(!data, "Got %p, expected NULL\n", data);
356  ok(!size, "Got %u, expected 0\n", size);
357 
358  hr = D3DXFindShaderComment(shader_with_ctab, MAKEFOURCC('X','X','X','X'), &data, &size);
359  ok(hr == S_FALSE, "Got result %x, expected 1 (S_FALSE)\n", hr);
360  ok(!data, "Got %p, expected NULL\n", data);
361  ok(!size, "Got %u, expected 0\n", size);
362 
363  hr = D3DXFindShaderComment(shader_with_ctab, MAKEFOURCC('C','T','A','B'), &data, &size);
364  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
365  ok(data == shader_with_ctab + 6, "Got result %p, expected %p\n", data, shader_with_ctab + 6);
366  ok(size == 28, "Got result %u, expected 28\n", size);
367 
368  hr = D3DXFindShaderComment(shader_zero, MAKEFOURCC('C','T','A','B'), &data, &size);
369  ok(hr == D3DXERR_INVALIDDATA, "Got result %x, expected %x (D3DXERR_INVALIDDATA)\n", hr, D3DXERR_INVALIDDATA);
370  ok(!data, "Got %p, expected NULL\n", data);
371  ok(!size, "Got %u, expected 0\n", size);
372 
373  hr = D3DXFindShaderComment(shader_invalid, MAKEFOURCC('C','T','A','B'), &data, &size);
374  ok(hr == D3DXERR_INVALIDDATA, "Got result %x, expected %x (D3DXERR_INVALIDDATA)\n", hr, D3DXERR_INVALIDDATA);
375  ok(!data, "Got %p, expected NULL\n", data);
376  ok(!size, "Got %u, expected 0\n", size);
377 
378  hr = D3DXFindShaderComment(shader_empty, MAKEFOURCC('C','T','A','B'), &data, &size);
379  ok(hr == S_FALSE, "Got result %x, expected %x (S_FALSE)\n", hr, S_FALSE);
380  ok(!data, "Got %p, expected NULL\n", data);
381  ok(!size, "Got %u, expected 0\n", size);
382 
384  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
385  ok(data == simple_fx + 3, "Got result %p, expected %p\n", data, simple_fx + 3);
386  ok(size == 4, "Got result %u, expected 4\n", size);
387 
389  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
390  ok(data == simple_tx + 3, "Got result %p, expected %p\n", data, simple_tx + 3);
391  ok(size == 4, "Got result %u, expected 4\n", size);
392 
394  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
395  ok(data == simple_7ffe + 3, "Got result %p, expected %p\n", data, simple_7ffe + 3);
396  ok(size == 4, "Got result %u, expected 4\n", size);
397 
399  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
400  ok(data == simple_7fff + 3, "Got result %p, expected %p\n", data, simple_7fff + 3);
401  ok(size == 4, "Got result %u, expected 4\n", size);
402 }
static const DWORD shader_with_ctab[]
Definition: shader.c:58
HRESULT hr
Definition: shlfolder.c:183
static const DWORD shader_zero[]
Definition: shader.c:26
#define D3DERR_INVALIDCALL
HRESULT WINAPI D3DXFindShaderComment(const DWORD *byte_code, DWORD fourcc, const void **data, UINT *size)
Definition: shader.c:149
static const DWORD shader_invalid[]
Definition: shader.c:28
#define FCC_TEXT
Definition: shader.c:23
#define S_FALSE
Definition: winerror.h:2357
smooth NULL
Definition: ftsmooth.c:416
static const DWORD simple_tx[]
Definition: shader.c:34
GLsizeiptr size
Definition: glext.h:5919
LONG HRESULT
Definition: typedefs.h:78
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
static const DWORD simple_7ffe[]
Definition: shader.c:36
#define D3D_OK
Definition: d3d.h:106
static const DWORD simple_fx[]
Definition: shader.c:32
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
static const DWORD shader_empty[]
Definition: shader.c:30
static const DWORD simple_7fff[]
Definition: shader.c:38
#define MAKEFOURCC(ch0, ch1, ch2, ch3)
Definition: dmdls.h:24

Referenced by START_TEST().

◆ test_get_sampler_index()

static void test_get_sampler_index ( void  )
static

Definition at line 1499 of file shader.c.

1500 {
1501  ID3DXConstantTable *ctable;
1502 
1503  HRESULT res;
1504  UINT index;
1505 
1506  ULONG refcnt;
1507 
1509  ok(res == D3D_OK, "D3DXGetShaderConstantTable failed on ctab_samplers: got %08x\n", res);
1510 
1512  ok(index == 0, "ID3DXConstantTable_GetSamplerIndex returned wrong index: Got %d, expected 0\n", index);
1513 
1515  ok(index == 3, "ID3DXConstantTable_GetSamplerIndex returned wrong index: Got %d, expected 3\n", index);
1516 
1518  ok(index == -1, "ID3DXConstantTable_GetSamplerIndex found nonexistent sampler: Got %d\n",
1519  index);
1520 
1522  ok(index == -1, "ID3DXConstantTable_GetSamplerIndex succeeded on non-sampler constant: Got %d\n",
1523  index);
1524 
1526  ok(refcnt == 0, "The ID3DXConstantTable reference count was %u, should be 0\n", refcnt);
1527 }
#define ID3DXConstantTable_GetSamplerIndex(p, a)
Definition: d3dx9shader.h:184
HRESULT WINAPI D3DXGetShaderConstantTable(const DWORD *byte_code, ID3DXConstantTable **constant_table)
Definition: shader.c:2104
#define ID3DXConstantTable_Release(p)
Definition: d3dx9shader.h:177
static _Locale_mask_t ctable[256]
GLuint index
Definition: glext.h:6031
LONG HRESULT
Definition: typedefs.h:78
#define index(s, c)
Definition: various.h:29
static const DWORD ctab_samplers[]
Definition: shader.c:260
#define D3D_OK
Definition: d3d.h:106
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
GLuint res
Definition: glext.h:9613
unsigned int ULONG
Definition: retypes.h:1

Referenced by START_TEST().

◆ test_get_shader_constant_table_ex()

static void test_get_shader_constant_table_ex ( void  )
static

Definition at line 404 of file shader.c.

405 {
406  ID3DXConstantTable *constant_table;
407  HRESULT hr;
408  void *data;
409  DWORD size;
411 
412  constant_table = (ID3DXConstantTable *)0xdeadbeef;
413  hr = D3DXGetShaderConstantTableEx(NULL, 0, &constant_table);
414  ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
415  ok(constant_table == NULL, "D3DXGetShaderConstantTableEx() failed, got %p\n", constant_table);
416 
417  constant_table = (ID3DXConstantTable *)0xdeadbeef;
418  hr = D3DXGetShaderConstantTableEx(shader_zero, 0, &constant_table);
419  ok(hr == D3D_OK, "Got result %x, expected %x (D3D_OK)\n", hr, D3D_OK);
420  ok(constant_table == NULL, "D3DXGetShaderConstantTableEx() failed, got %p\n", constant_table);
421 
422  constant_table = (ID3DXConstantTable *)0xdeadbeef;
423  hr = D3DXGetShaderConstantTableEx(shader_invalid, 0, &constant_table);
424  ok(hr == D3D_OK, "Got result %x, expected %x (D3D_OK)\n", hr, D3D_OK);
425  ok(constant_table == NULL, "D3DXGetShaderConstantTableEx() failed, got %p\n", constant_table);
426 
427  constant_table = (ID3DXConstantTable *)0xdeadbeef;
428  hr = D3DXGetShaderConstantTableEx(shader_empty, 0, &constant_table);
429  ok(hr == D3DXERR_INVALIDDATA, "Got result %x, expected %x (D3DXERR_INVALIDDATA)\n", hr, D3DXERR_INVALIDDATA);
430  ok(constant_table == NULL, "D3DXGetShaderConstantTableEx() failed, got %p\n", constant_table);
431 
432  /* No CTAB data */
433  constant_table = (ID3DXConstantTable *)0xdeadbeef;
434  hr = D3DXGetShaderConstantTableEx(simple_ps, 0, &constant_table);
435  ok(hr == D3DXERR_INVALIDDATA, "Got result %x, expected %x (D3DXERR_INVALIDDATA)\n", hr, D3DXERR_INVALIDDATA);
436  ok(constant_table == NULL, "D3DXGetShaderConstantTableEx() failed, got %p\n", constant_table);
437 
438  /* With invalid CTAB data */
440  ok(hr == D3DXERR_INVALIDDATA || broken(hr == D3D_OK), /* winxp 64-bit, w2k3 64-bit */
441  "Got result %x, expected %x (D3DXERR_INVALIDDATA)\n", hr, D3DXERR_INVALIDDATA);
442  if (constant_table) ID3DXConstantTable_Release(constant_table);
443 
444  hr = D3DXGetShaderConstantTableEx(simple_fx, 0, &constant_table);
445  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK).\n", hr);
446  ok(!constant_table, "D3DXGetShaderConstantTableEx() returned a non-NULL constant table.\n");
447 
448  hr = D3DXGetShaderConstantTableEx(simple_tx, 0, &constant_table);
449  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK).\n", hr);
450  ok(!constant_table, "D3DXGetShaderConstantTableEx() returned a non-NULL constant table.\n");
451 
452  hr = D3DXGetShaderConstantTableEx(shader_with_ctab, 0, &constant_table);
453  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
454  ok(constant_table != NULL, "D3DXGetShaderConstantTableEx() failed, got NULL\n");
455 
456  if (constant_table)
457  {
458  size = ID3DXConstantTable_GetBufferSize(constant_table);
459  ok(size == 28, "Got result %x, expected 28\n", size);
460 
461  data = ID3DXConstantTable_GetBufferPointer(constant_table);
462  ok(!memcmp(data, shader_with_ctab + 6, size), "Retrieved wrong CTAB data\n");
463 
464  hr = ID3DXConstantTable_GetDesc(constant_table, NULL);
465  ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
466 
467  hr = ID3DXConstantTable_GetDesc(constant_table, &desc);
468  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
469  ok(desc.Creator == (const char *)data + 0x10, "Got result %p, expected %p\n",
470  desc.Creator, (const char *)data + 0x10);
471  ok(desc.Version == D3DVS_VERSION(3, 0), "Got result %x, expected %x\n", desc.Version, D3DVS_VERSION(3, 0));
472  ok(desc.Constants == 0, "Got result %x, expected 0\n", desc.Constants);
473 
474  ID3DXConstantTable_Release(constant_table);
475  }
476 
478  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
479  ok(constant_table != NULL, "D3DXGetShaderConstantTableEx() failed, got NULL\n");
480 
481  if (constant_table)
482  {
484  D3DXCONSTANT_DESC constant_desc;
485  D3DXCONSTANT_DESC constant_desc_save;
486  UINT nb;
487 
488  /* Test GetDesc */
489  hr = ID3DXConstantTable_GetDesc(constant_table, &desc);
490  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
491  ok(!strcmp(desc.Creator, "Wine project"), "Got result '%s', expected 'Wine project'\n", desc.Creator);
492  ok(desc.Version == D3DVS_VERSION(3, 0), "Got result %x, expected %x\n", desc.Version, D3DVS_VERSION(3, 0));
493  ok(desc.Constants == 3, "Got result %x, expected 3\n", desc.Constants);
494 
495  /* Test GetConstant */
496  constant = ID3DXConstantTable_GetConstant(constant_table, NULL, 0);
497  ok(constant != NULL, "No constant found\n");
498  hr = ID3DXConstantTable_GetConstantDesc(constant_table, constant, &constant_desc, &nb);
499  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
500  ok(!strcmp(constant_desc.Name, "Constant1"), "Got result '%s', expected 'Constant1'\n",
501  constant_desc.Name);
502  ok(constant_desc.Class == D3DXPC_VECTOR, "Got result %x, expected %u (D3DXPC_VECTOR)\n",
503  constant_desc.Class, D3DXPC_VECTOR);
504  ok(constant_desc.Type == D3DXPT_FLOAT, "Got result %x, expected %u (D3DXPT_FLOAT)\n",
505  constant_desc.Type, D3DXPT_FLOAT);
506  ok(constant_desc.Rows == 1, "Got result %x, expected 1\n", constant_desc.Rows);
507  ok(constant_desc.Columns == 4, "Got result %x, expected 4\n", constant_desc.Columns);
508 
509  constant = ID3DXConstantTable_GetConstant(constant_table, NULL, 1);
510  ok(constant != NULL, "No constant found\n");
511  hr = ID3DXConstantTable_GetConstantDesc(constant_table, constant, &constant_desc, &nb);
512  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
513  ok(!strcmp(constant_desc.Name, "Constant2"), "Got result '%s', expected 'Constant2'\n",
514  constant_desc.Name);
515  ok(constant_desc.Class == D3DXPC_MATRIX_COLUMNS, "Got result %x, expected %u (D3DXPC_MATRIX_COLUMNS)\n",
516  constant_desc.Class, D3DXPC_MATRIX_COLUMNS);
517  ok(constant_desc.Type == D3DXPT_FLOAT, "Got result %x, expected %u (D3DXPT_FLOAT)\n",
518  constant_desc.Type, D3DXPT_FLOAT);
519  ok(constant_desc.Rows == 4, "Got result %x, expected 1\n", constant_desc.Rows);
520  ok(constant_desc.Columns == 4, "Got result %x, expected 4\n", constant_desc.Columns);
521 
522  constant = ID3DXConstantTable_GetConstant(constant_table, NULL, 2);
523  ok(constant != NULL, "No constant found\n");
524  hr = ID3DXConstantTable_GetConstantDesc(constant_table, constant, &constant_desc, &nb);
525  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
526  ok(!strcmp(constant_desc.Name, "Constant3"), "Got result '%s', expected 'Constant3'\n",
527  constant_desc.Name);
528  ok(constant_desc.Class == D3DXPC_MATRIX_COLUMNS, "Got result %x, expected %u (D3DXPC_MATRIX_COLUMNS)\n",
529  constant_desc.Class, D3DXPC_MATRIX_COLUMNS);
530  ok(constant_desc.Type == D3DXPT_FLOAT, "Got result %x, expected %u (D3DXPT_FLOAT)\n",
531  constant_desc.Type, D3DXPT_FLOAT);
532  ok(constant_desc.Rows == 4, "Got result %x, expected 1\n", constant_desc.Rows);
533  ok(constant_desc.Columns == 4, "Got result %x, expected 4\n", constant_desc.Columns);
534  constant_desc_save = constant_desc; /* For GetConstantDesc test */
535 
536  constant = ID3DXConstantTable_GetConstant(constant_table, NULL, 3);
537  ok(constant == NULL, "Got result %p, expected NULL\n", constant);
538 
539  /* Test GetConstantByName */
540  constant = ID3DXConstantTable_GetConstantByName(constant_table, NULL, "Constant unknown");
541  ok(constant == NULL, "Got result %p, expected NULL\n", constant);
542  constant = ID3DXConstantTable_GetConstantByName(constant_table, NULL, "Constant3");
543  ok(constant != NULL, "No constant found\n");
544  hr = ID3DXConstantTable_GetConstantDesc(constant_table, constant, &constant_desc, &nb);
545  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
546  ok(!memcmp(&constant_desc, &constant_desc_save, sizeof(D3DXCONSTANT_DESC)), "Got different constant data\n");
547 
548  /* Test GetConstantDesc */
549  constant = ID3DXConstantTable_GetConstant(constant_table, NULL, 0);
550  ok(constant != NULL, "No constant found\n");
551  hr = ID3DXConstantTable_GetConstantDesc(constant_table, NULL, &constant_desc, &nb);
552  ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
553  hr = ID3DXConstantTable_GetConstantDesc(constant_table, constant, NULL, &nb);
554  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
555  hr = ID3DXConstantTable_GetConstantDesc(constant_table, constant, &constant_desc, NULL);
556  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
557  hr = ID3DXConstantTable_GetConstantDesc(constant_table, "Constant unknown", &constant_desc, &nb);
558  ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
559  hr = ID3DXConstantTable_GetConstantDesc(constant_table, "Constant3", &constant_desc, &nb);
560  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
561  ok(!memcmp(&constant_desc, &constant_desc_save, sizeof(D3DXCONSTANT_DESC)), "Got different constant data\n");
562 
563  ID3DXConstantTable_Release(constant_table);
564  }
565 
566  hr = D3DXGetShaderConstantTableEx(fx_shader_with_ctab, 0, &constant_table);
567  ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK).\n", hr);
568  ok(!constant_table, "D3DXGetShaderConstantTableEx() returned a non-NULL constant table.\n");
569 }
static const DWORD shader_with_ctab[]
Definition: shader.c:58
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
HRESULT hr
Definition: shlfolder.c:183
const char * D3DXHANDLE
Definition: d3dx9shader.h:48
static const DWORD shader_zero[]
Definition: shader.c:26
#define D3DERR_INVALIDCALL
#define ID3DXConstantTable_GetConstant(p, a, b)
Definition: d3dx9shader.h:185
#define ID3DXConstantTable_Release(p)
Definition: d3dx9shader.h:177
HRESULT WINAPI D3DXGetShaderConstantTableEx(const DWORD *byte_code, DWORD flags, ID3DXConstantTable **constant_table)
Definition: shader.c:1986
D3DXCONSTANT_DESC desc
Definition: shader.c:1767
static const DWORD shader_invalid[]
Definition: shader.c:28
#define D3DVS_VERSION(major, minor)
Definition: d3d8types.h:475
static const DWORD fx_shader_with_ctab[]
Definition: shader.c:283
#define ID3DXConstantTable_GetConstantDesc(p, a, b, c)
Definition: d3dx9shader.h:183
static const DWORD shader_with_invalid_ctab[]
Definition: shader.c:66
smooth NULL
Definition: ftsmooth.c:416
static const DWORD simple_tx[]
Definition: shader.c:34
D3DXPARAMETER_CLASS Class
Definition: d3dx9shader.h:109
#define ID3DXConstantTable_GetConstantByName(p, a, b)
Definition: d3dx9shader.h:186
#define ID3DXConstantTable_GetBufferPointer(p)
Definition: d3dx9shader.h:179
GLsizeiptr size
Definition: glext.h:5919
LONG HRESULT
Definition: typedefs.h:78
unsigned long DWORD
Definition: ntddk_ex.h:95
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define ID3DXConstantTable_GetDesc(p, a)
Definition: d3dx9shader.h:182
const char * Name
Definition: d3dx9shader.h:105
#define broken(x)
Definition: _sntprintf.h:21
#define D3D_OK
Definition: d3d.h:106
static const DWORD simple_fx[]
Definition: shader.c:32
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
static const DWORD shader_empty[]
Definition: shader.c:30
static const DWORD shader_with_ctab_constants[]
Definition: shader.c:73
D3DXPARAMETER_TYPE Type
Definition: d3dx9shader.h:110
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define ID3DXConstantTable_GetBufferSize(p)
Definition: d3dx9shader.h:180
static const DWORD simple_ps[]
Definition: shader.c:49

Referenced by START_TEST().

◆ test_get_shader_constant_variables()

static void test_get_shader_constant_variables ( void  )
static

Definition at line 1830 of file shader.c.

1831 {
1832  ID3DXConstantTable *ctable;
1833  HRESULT hr;
1834  ULONG count;
1835  UINT i;
1836  UINT nr = 1;
1839  DWORD *ctab;
1840 
1842  ok(hr == D3D_OK, "D3DXGetShaderConstantTable failed, got %08x, expected %08x\n", hr, D3D_OK);
1843 
1845  ok(ctab[0] == test_get_shader_constant_variables_blob[3], "ID3DXConstantTable_GetBufferPointer failed\n");
1846 
1848  {
1849  const char *fullname = test_get_shader_constant_variables_data[i].fullname;
1850  const D3DXCONSTANT_DESC *expected_desc = &test_get_shader_constant_variables_data[i].desc;
1852 
1854  ok(constant != NULL, "GetConstantByName \"%s\" failed\n", fullname);
1855 
1857  ok(hr == D3D_OK, "GetConstantDesc \"%s\" failed, got %08x, expected %08x\n", fullname, hr, D3D_OK);
1858 
1859  ok(!strcmp(expected_desc->Name, desc.Name), "GetConstantDesc \"%s\" failed, got \"%s\", expected \"%s\"\n",
1860  fullname, desc.Name, expected_desc->Name);
1861  ok(expected_desc->RegisterSet == desc.RegisterSet, "GetConstantDesc \"%s\" failed, got %#x, expected %#x\n",
1862  fullname, desc.RegisterSet, expected_desc->RegisterSet);
1863  ok(expected_desc->RegisterIndex == desc.RegisterIndex, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
1864  fullname, desc.RegisterIndex, expected_desc->RegisterIndex);
1865  ok(expected_desc->RegisterCount == desc.RegisterCount, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
1866  fullname, desc.RegisterCount, expected_desc->RegisterCount);
1867  ok(expected_desc->Class == desc.Class, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
1868  fullname, desc.Class, expected_desc->Class);
1869  ok(expected_desc->Type == desc.Type, "GetConstantDesc \"%s\" failed, got %#x, expected %#x\n",
1870  fullname, desc.Type, expected_desc->Type);
1871  ok(expected_desc->Rows == desc.Rows, "GetConstantDesc \"%s\" failed, got %#x, expected %#x\n",
1872  fullname, desc.Rows, expected_desc->Rows);
1873  ok(expected_desc->Columns == desc.Columns, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
1874  fullname, desc.Columns, expected_desc->Columns);
1875  ok(expected_desc->Elements == desc.Elements, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
1876  fullname, desc.Elements, expected_desc->Elements);
1877  ok(expected_desc->StructMembers == desc.StructMembers, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
1878  fullname, desc.StructMembers, expected_desc->StructMembers);
1879  ok(expected_desc->Bytes == desc.Bytes, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
1880  fullname, desc.Bytes, expected_desc->Bytes);
1881  ok(ctaboffset == (DWORD *)desc.DefaultValue - ctab, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
1882  fullname, (UINT)((DWORD *)desc.DefaultValue - ctab), ctaboffset);
1883  }
1884 
1886  ok(element == NULL, "GetConstantElement failed\n");
1887 
1889  ok(constant != NULL, "GetConstantByName failed\n");
1890 
1892  ok(constant == element, "GetConstantByName failed, got %p, expected %p\n", element, constant);
1893 
1895  ok(element == constant, "GetConstantElement failed, got %p, expected %p\n", element, constant);
1896 
1898  ok(constant != NULL, "GetConstantByName failed\n");
1899 
1901  ok(element == constant, "GetConstant failed, got %p, expected %p\n", element, constant);
1902 
1904  ok(element == NULL, "GetConstant failed\n");
1905 
1907  ok(element == NULL, "GetConstant failed\n");
1908 
1910  ok(constant == element, "GetConstantByName failed, got %p, expected %p\n", element, constant);
1911 
1913  ok(NULL == element, "GetConstantByName failed\n");
1914 
1916  ok(constant == element, "GetConstantByName failed, got %p, expected %p\n", element, constant);
1917 
1919  ok(element == NULL, "GetConstantByName failed\n");
1920 
1922  ok(element == constant, "GetConstantElement failed, got %p, expected %p\n", element, constant);
1923 
1925  ok(element == NULL, "GetConstantElement failed\n");
1926 
1928  ok(constant != NULL, "GetConstantByName failed\n");
1929 
1931  ok(element != constant, "GetConstantByName failed, got %p, expected %p\n", element, constant);
1932 
1934  ok(element == constant, "GetConstantElement failed, got %p, expected %p\n", element, constant);
1935 
1937  ok(constant != NULL, "GetConstantByName failed\n");
1938 
1940  ok(element == constant, "GetConstantElement failed, got %p, expected %p\n", element, constant);
1941 
1943  ok(constant != NULL, "GetConstantByName failed\n");
1944 
1946  ok(element == constant, "GetConstant failed, got %p, expected %p\n", element, constant);
1947 
1949  ok(element == constant, "GetConstantByName failed, got %p, expected %p\n", element, constant);
1950 
1951  element = ID3DXConstantTable_GetConstantByName(ctable, "s_2[0]", "invalid");
1952  ok(element == NULL, "GetConstantByName failed\n");
1953 
1955  ok(constant != NULL, "GetConstantByName failed\n");
1956 
1958  ok(constant == element, "GetConstantByName failed, got %p, expected %p\n", element, constant);
1959 
1961  ok(count == 0, "Release failed, got %u, expected %u\n", count, 0);
1962 }
#define ID3DXConstantTable_GetConstantElement(p, a, b)
Definition: d3dx9shader.h:187
static const DWORD test_get_shader_constant_variables_blob[]
Definition: shader.c:1700
HRESULT hr
Definition: shlfolder.c:183
ULONG nr
Definition: thread.c:7
const char * D3DXHANDLE
Definition: d3dx9shader.h:48
HRESULT WINAPI D3DXGetShaderConstantTable(const DWORD *byte_code, ID3DXConstantTable **constant_table)
Definition: shader.c:2104
GLuint GLuint GLsizei count
Definition: gl.h:1545
#define ID3DXConstantTable_GetConstant(p, a, b)
Definition: d3dx9shader.h:185
#define ID3DXConstantTable_Release(p)
Definition: d3dx9shader.h:177
D3DXCONSTANT_DESC desc
Definition: shader.c:1767
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define ID3DXConstantTable_GetConstantDesc(p, a, b, c)
Definition: d3dx9shader.h:183
const struct @1630 test_get_shader_constant_variables_data[]
smooth NULL
Definition: ftsmooth.c:416
static _Locale_mask_t ctable[256]
D3DXPARAMETER_CLASS Class
Definition: d3dx9shader.h:109
#define ID3DXConstantTable_GetConstantByName(p, a, b)
Definition: d3dx9shader.h:186
D3DXREGISTER_SET RegisterSet
Definition: d3dx9shader.h:106
UINT ctaboffset
Definition: shader.c:1768
#define ID3DXConstantTable_GetBufferPointer(p)
Definition: d3dx9shader.h:179
LONG HRESULT
Definition: typedefs.h:78
unsigned long DWORD
Definition: ntddk_ex.h:95
const char * fullname
Definition: shader.c:1766
const char * Name
Definition: d3dx9shader.h:105
const void * DefaultValue
Definition: d3dx9shader.h:116
#define D3D_OK
Definition: d3d.h:106
#define ARRAY_SIZE(a)
Definition: main.h:24
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
D3DXPARAMETER_TYPE Type
Definition: d3dx9shader.h:110
unsigned int ULONG
Definition: retypes.h:1
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469

Referenced by START_TEST().

◆ test_get_shader_samplers()

static void test_get_shader_samplers ( void  )
static

Definition at line 1592 of file shader.c.

1593 {
1594  const char *samplers[16] = {NULL}; /* maximum number of sampler registers v/ps 3.0 = 16 */
1595  const char *sampler_orig;
1596  UINT count = 2;
1597  HRESULT hr;
1598 
1599 if (0)
1600 {
1601  /* crashes if bytecode is NULL */
1603  ok(hr == D3D_OK, "D3DXGetShaderSamplers failed, got %x, expected %x\n", hr, D3D_OK);
1604 }
1605 
1607  ok(hr == D3D_OK, "D3DXGetShaderSamplers failed, got %x, expected %x\n", hr, D3D_OK);
1608 
1609  samplers[5] = "dummy";
1610 
1612  ok(hr == D3D_OK, "D3DXGetShaderSamplers failed, got %x, expected %x\n", hr, D3D_OK);
1613 
1614  /* check that sampler points to shader blob */
1615  sampler_orig = (const char *)&get_shader_samplers_blob[0x2e];
1616  ok(sampler_orig == samplers[0], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[0], sampler_orig);
1617 
1618  sampler_orig = (const char *)&get_shader_samplers_blob[0x33];
1619  ok(sampler_orig == samplers[1], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[1], sampler_orig);
1620 
1621  sampler_orig = (const char *)&get_shader_samplers_blob[0x38];
1622  ok(sampler_orig == samplers[2], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[2], sampler_orig);
1623 
1624  sampler_orig = (const char *)&get_shader_samplers_blob[0x3d];
1625  ok(sampler_orig == samplers[3], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[3], sampler_orig);
1626 
1627  sampler_orig = (const char *)&get_shader_samplers_blob[0x42];
1628  ok(sampler_orig == samplers[4], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[4], sampler_orig);
1629 
1630  ok(!strcmp(samplers[5], "dummy"), "D3DXGetShaderSamplers failed, got \"%s\", expected \"%s\"\n", samplers[5], "dummy");
1631 
1632  /* reset samplers */
1633  memset(samplers, 0, sizeof(samplers));
1634  samplers[5] = "dummy";
1635 
1637  ok(hr == D3D_OK, "D3DXGetShaderSamplers failed, got %x, expected %x\n", hr, D3D_OK);
1638  ok(count == 5, "D3DXGetShaderSamplers failed, got %u, expected %u\n", count, 5);
1639 
1641  ok(hr == D3D_OK, "D3DXGetShaderSamplers failed, got %x, expected %x\n", hr, D3D_OK);
1642  ok(count == 5, "D3DXGetShaderSamplers failed, got %u, expected %u\n", count, 5);
1643 
1644  /* check that sampler points to shader blob */
1645  sampler_orig = (const char *)&get_shader_samplers_blob[0x2e];
1646  ok(sampler_orig == samplers[0], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[0], sampler_orig);
1647 
1648  sampler_orig = (const char *)&get_shader_samplers_blob[0x33];
1649  ok(sampler_orig == samplers[1], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[1], sampler_orig);
1650 
1651  sampler_orig = (const char *)&get_shader_samplers_blob[0x38];
1652  ok(sampler_orig == samplers[2], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[2], sampler_orig);
1653 
1654  sampler_orig = (const char *)&get_shader_samplers_blob[0x3d];
1655  ok(sampler_orig == samplers[3], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[3], sampler_orig);
1656 
1657  sampler_orig = (const char *)&get_shader_samplers_blob[0x42];
1658  ok(sampler_orig == samplers[4], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[4], sampler_orig);
1659 
1660  ok(!strcmp(samplers[5], "dummy"), "D3DXGetShaderSamplers failed, got \"%s\", expected \"%s\"\n", samplers[5], "dummy");
1661 
1662  /* check without ctab */
1664  ok(hr == D3D_OK, "D3DXGetShaderSamplers failed, got %x, expected %x\n", hr, D3D_OK);
1665  ok(count == 0, "D3DXGetShaderSamplers failed, got %u, expected %u\n", count, 0);
1666 
1667  /* check invalid ctab */
1669  ok(hr == D3D_OK, "D3DXGetShaderSamplers failed, got %x, expected %x\n", hr, D3D_OK);
1670  ok(count == 0, "D3DXGetShaderSamplers failed, got %u, expected %u\n", count, 0);
1671 }
HRESULT hr
Definition: shlfolder.c:183
GLuint GLuint GLsizei count
Definition: gl.h:1545
static const DWORD simple_vs[]
Definition: shader.c:40
static const DWORD shader_with_invalid_ctab[]
Definition: shader.c:66
smooth NULL
Definition: ftsmooth.c:416
LONG HRESULT
Definition: typedefs.h:78
HRESULT WINAPI D3DXGetShaderSamplers(const DWORD *byte_code, const char **samplers, UINT *count)
Definition: shader.c:2132
#define D3D_OK
Definition: d3d.h:106
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
GLuint * samplers
Definition: glext.h:7280
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define memset(x, y, z)
Definition: compat.h:39
static const DWORD get_shader_samplers_blob[]
Definition: shader.c:1551

Referenced by START_TEST().

◆ test_get_shader_size()

static void test_get_shader_size ( void  )
static

Definition at line 302 of file shader.c.

303 {
304  UINT shader_size, expected;
305 
306  shader_size = D3DXGetShaderSize(simple_vs);
307  expected = sizeof(simple_vs);
308  ok(shader_size == expected, "Got shader size %u, expected %u\n", shader_size, expected);
309 
310  shader_size = D3DXGetShaderSize(simple_ps);
311  expected = sizeof(simple_ps);
312  ok(shader_size == expected, "Got shader size %u, expected %u\n", shader_size, expected);
313 
314  shader_size = D3DXGetShaderSize(NULL);
315  ok(shader_size == 0, "Got shader size %u, expected 0\n", shader_size);
316 }
static const DWORD simple_vs[]
Definition: shader.c:40
smooth NULL
Definition: ftsmooth.c:416
UINT WINAPI D3DXGetShaderSize(const DWORD *byte_code)
Definition: shader.c:90
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
static const DWORD simple_ps[]
Definition: shader.c:49
BOOL expected
Definition: store.c:2063

Referenced by START_TEST().

◆ test_get_shader_version()

static void test_get_shader_version ( void  )
static

Definition at line 318 of file shader.c.

319 {
320  DWORD shader_version;
321 
322  shader_version = D3DXGetShaderVersion(simple_vs);
323  ok(shader_version == D3DVS_VERSION(1, 1), "Got shader version 0x%08x, expected 0x%08x\n",
324  shader_version, D3DVS_VERSION(1, 1));
325 
326  shader_version = D3DXGetShaderVersion(simple_ps);
327  ok(shader_version == D3DPS_VERSION(1, 1), "Got shader version 0x%08x, expected 0x%08x\n",
328  shader_version, D3DPS_VERSION(1, 1));
329 
330  shader_version = D3DXGetShaderVersion(NULL);
331  ok(shader_version == 0, "Got shader version 0x%08x, expected 0\n", shader_version);
332 }
static const DWORD simple_vs[]
Definition: shader.c:40
#define D3DPS_VERSION(major, minor)
Definition: d3d8types.h:474
#define D3DVS_VERSION(major, minor)
Definition: d3d8types.h:475
smooth NULL
Definition: ftsmooth.c:416
unsigned long DWORD
Definition: ntddk_ex.h:95
#define ok(value,...)
Definition: atltest.h:57
DWORD WINAPI D3DXGetShaderVersion(const DWORD *byte_code)
Definition: shader.c:113
static const DWORD simple_ps[]
Definition: shader.c:49

Referenced by START_TEST().

◆ test_registerset()

static void test_registerset ( void  )
static

Definition at line 6015 of file shader.c.

6016 {
6017  UINT k;
6018  HWND wnd;
6019  IDirect3D9 *d3d;
6020  IDirect3DDevice9 *device;
6021  D3DPRESENT_PARAMETERS d3dpp;
6022  HRESULT hr;
6023  ULONG count;
6024  D3DCAPS9 caps;
6025 
6026  if (!(wnd = CreateWindowA("static", "d3dx9_test", WS_OVERLAPPEDWINDOW, 0, 0,
6027  640, 480, NULL, NULL, NULL, NULL)))
6028  {
6029  skip("Couldn't create application window\n");
6030  return;
6031  }
6032  if (!(d3d = Direct3DCreate9(D3D_SDK_VERSION)))
6033  {
6034  skip("Couldn't create IDirect3D9 object\n");
6035  DestroyWindow(wnd);
6036  return;
6037  }
6038 
6039  ZeroMemory(&d3dpp, sizeof(d3dpp));
6040  d3dpp.Windowed = TRUE;
6043  if (FAILED(hr))
6044  {
6045  skip("Failed to create IDirect3DDevice9 object %#x\n", hr);
6046  IDirect3D9_Release(d3d);
6047  DestroyWindow(wnd);
6048  return;
6049  }
6050 
6052  ok(SUCCEEDED(hr), "Failed to get device caps, hr %#x.\n", hr);
6053  if (caps.VertexShaderVersion < D3DVS_VERSION(3, 0)
6054  || caps.PixelShaderVersion < D3DPS_VERSION(3, 0))
6055  {
6056  skip("Skipping: Test requires VS >= 3 and PS >= 3.\n");
6058  IDirect3D9_Release(d3d);
6059  DestroyWindow(wnd);
6060  return;
6061  }
6062 
6063  for (k = 0; k < ARRAY_SIZE(registerset_data); ++k)
6064  {
6065  const char *tablename = registerset_data[k].name;
6066  const char *name = registerset_data[k].var;
6067  ID3DXConstantTable *ctable;
6068  D3DXCONSTANTTABLE_DESC tdesc;
6070  UINT i;
6071  BOOL is_vs;
6072  DWORD *ctab;
6073 
6075  ok(hr == D3D_OK, "D3DXGetShaderConstantTable \"%s\" failed, got %08x, expected %08x\n", tablename, hr, D3D_OK);
6076 
6078  ok(hr == D3D_OK, "GetDesc \"%s\" failed, got %08x, expected %08x\n", tablename, hr, D3D_OK);
6079 
6081  ok(ctab[0] == registerset_data[k].blob[3], "ID3DXConstantTable_GetBufferPointer failed\n");
6082 
6083  is_vs = (tdesc.Version & 0xFFFF0000) == 0xFFFE0000;
6084 
6085  for (i = 0; i < registerset_data[k].constant_count; ++i)
6086  {
6087  const char *fullname = registerset_data[k].constants[i].fullname;
6088  const D3DXCONSTANT_DESC *expected_desc = &registerset_data[k].constants[i].desc;
6090  UINT nr = 0;
6091  UINT ctaboffset = registerset_data[k].constants[i].ctaboffset;
6092 
6094  ok(constant != NULL, "GetConstantByName \"%s\" failed\n", fullname);
6095 
6097  ok(hr == D3D_OK, "GetConstantDesc \"%s\" failed, got %08x, expected %08x\n", fullname, hr, D3D_OK);
6098 
6099  ok(!strcmp(expected_desc->Name, desc.Name), "GetConstantDesc \"%s\" failed, got \"%s\", expected \"%s\"\n",
6100  fullname, desc.Name, expected_desc->Name);
6101  ok(expected_desc->RegisterSet == desc.RegisterSet, "GetConstantDesc \"%s\" failed, got %#x, expected %#x\n",
6102  fullname, desc.RegisterSet, expected_desc->RegisterSet);
6103  ok(expected_desc->RegisterIndex == desc.RegisterIndex,
6104  "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
6105  fullname, desc.RegisterIndex, expected_desc->RegisterIndex);
6106  ok(expected_desc->RegisterCount == desc.RegisterCount,
6107  "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
6108  fullname, desc.RegisterCount, expected_desc->RegisterCount);
6109  ok(expected_desc->Class == desc.Class, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
6110  fullname, desc.Class, expected_desc->Class);
6111  ok(expected_desc->Type == desc.Type, "GetConstantDesc \"%s\" failed, got %#x, expected %#x\n",
6112  fullname, desc.Type, expected_desc->Type);
6113  ok(expected_desc->Rows == desc.Rows, "GetConstantDesc \"%s\" failed, got %#x, expected %#x\n",
6114  fullname, desc.Rows, expected_desc->Rows);
6115  ok(expected_desc->Columns == desc.Columns, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
6116  fullname, desc.Columns, expected_desc->Columns);
6117  ok(expected_desc->Elements == desc.Elements, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
6118  fullname, desc.Elements, expected_desc->Elements);
6119  ok(expected_desc->StructMembers == desc.StructMembers,
6120  "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
6121  fullname, desc.StructMembers, expected_desc->StructMembers);
6122  ok(expected_desc->Bytes == desc.Bytes, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
6123  fullname, desc.Bytes, expected_desc->Bytes);
6124  if (ctaboffset)
6125  {
6126  ok(ctaboffset == (DWORD *)desc.DefaultValue - ctab,
6127  "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
6128  fullname, (UINT)((DWORD *)desc.DefaultValue - ctab), ctaboffset);
6129  }
6130  }
6131 
6133  ok(constant != NULL, "GetConstantByName \"%s\" \"%s\" failed\n", tablename, name);
6134 
6135  for (i = 0; i < registerset_data[k].test_count; ++i)
6136  {
6137  const struct registerset_test *test = &registerset_data[k].tests[i];
6138  UINT ret;
6139 
6141 
6142  hr = registerset_apply(ctable, device, constant, test->in_index, test->in_count_min, test->type);
6143  ok(hr == D3D_OK, "Set* \"%s\" index %u, count %u failed, got %x, expected %x\n", tablename, i,
6144  test->in_count_min, hr, D3D_OK);
6145 
6147  registerset_data[k].start, test->out_count, test->out);
6148  ok(ret == 0, "Get*ShaderConstant \"%s\" index %u, count %u failed\n", tablename, i, test->in_count_min);
6149 
6150  if (test->in_count_max > test->in_count_min)
6151  {
6153 
6154  hr = registerset_apply(ctable, device, constant, test->in_index, test->in_count_max, test->type);
6155  ok(hr == D3D_OK, "Set* \"%s\" index %u, count %u failed, got %x, expected %x\n", tablename, i,
6156  test->in_count_max, hr, D3D_OK);
6157 
6159  registerset_data[k].start, test->out_count, test->out);
6160  ok(ret == 0, "Get*ShaderConstant \"%s\" index %u, count %u failed\n", tablename, i, test->in_count_max);
6161  }
6162  }
6163 
6165  ok(count == 0, "Release \"%s\" failed, got %u, expected %u\n", tablename, count, 0);
6166  }
6167 
6168  /* Release resources */
6170  ok(count == 0, "The Direct3D device reference count was %u, should be 0\n", count);
6171 
6172  count = IDirect3D9_Release(d3d);
6173  ok(count == 0, "The Direct3D object referenct count was %u, should be 0\n", count);
6174 
6175  if (wnd) DestroyWindow(wnd);
6176 }
#define IDirect3D9_CreateDevice(p, a, b, c, d, e, f)
Definition: d3d9.h:235
#define D3DADAPTER_DEFAULT
Definition: d3d8.h:57
#define TRUE
Definition: types.h:120
HRESULT hr
Definition: shlfolder.c:183
D3DXREGISTER_SET regset
Definition: shader.c:5668
Definition: image.c:133
ULONG nr
Definition: thread.c:7
const char * D3DXHANDLE
Definition: d3dx9shader.h:48
HRESULT WINAPI D3DXGetShaderConstantTable(const DWORD *byte_code, ID3DXConstantTable **constant_table)
Definition: shader.c:2104
GLuint GLuint GLsizei count
Definition: gl.h:1545
static UINT registerset_compare_all(IDirect3DDevice9 *device, BOOL is_vs, D3DXREGISTER_SET regset, UINT start, UINT in_count, const DWORD *expected)
Definition: shader.c:5945
DWORD VertexShaderVersion
Definition: d3d9caps.h:313
#define ZeroMemory
Definition: winbase.h:1648
#define test
Definition: rosglue.h:37
#define ID3DXConstantTable_Release(p)
Definition: d3dx9shader.h:177
BOOL WINAPI DestroyWindow(_In_ HWND)
#define D3DPS_VERSION(major, minor)
Definition: d3d8types.h:474
IDirect3D9 *WINAPI Direct3DCreate9(UINT SDKVersion)
Definition: d3d9.c:57
D3DXCONSTANT_DESC desc
Definition: shader.c:1767
#define IDirect3D9_Release(p)
Definition: d3d9.h:220
#define D3DVS_VERSION(major, minor)
Definition: d3d8types.h:475
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define ID3DXConstantTable_GetConstantDesc(p, a, b, c)
Definition: d3dx9shader.h:183
unsigned int BOOL
Definition: ntddk_ex.h:94
Definition: devices.h:37
#define CreateWindowA(a, b, c, d, e, f, g, h, i, j, k)
Definition: winuser.h:4290
#define IDirect3DDevice9_Release(p)
Definition: d3d9.h:1508
smooth NULL
Definition: ftsmooth.c:416
static void registerset_clear(IDirect3DDevice9 *device)
Definition: shader.c:5864
static _Locale_mask_t ctable[256]
static const struct @1631 registerset_data[]
D3DXPARAMETER_CLASS Class
Definition: d3dx9shader.h:109
#define ID3DXConstantTable_GetConstantByName(p, a, b)
Definition: d3dx9shader.h:186
D3DXREGISTER_SET RegisterSet
Definition: d3dx9shader.h:106
UINT ctaboffset
Definition: shader.c:1768
#define ID3DXConstantTable_GetBufferPointer(p)
Definition: d3dx9shader.h:179
#define D3D_SDK_VERSION
Definition: d3d8.h:56
LONG HRESULT
Definition: typedefs.h:78
unsigned long DWORD
Definition: ntddk_ex.h:95
static HRESULT registerset_apply(ID3DXConstantTable *ctable, IDirect3DDevice9 *device, D3DXHANDLE constant, UINT index, DWORD count, enum Type type)
Definition: shader.c:5964
int ret
const char * fullname
Definition: shader.c:1766
#define ID3DXConstantTable_GetDesc(p, a)
Definition: d3dx9shader.h:182
const char * Name
Definition: d3dx9shader.h:105
DWORD PixelShaderVersion
Definition: d3d9caps.h:315
const void * DefaultValue
Definition: d3dx9shader.h:116
#define D3D_OK
Definition: d3d.h:106
GLuint start
Definition: gl.h:1545
#define ARRAY_SIZE(a)
Definition: main.h:24
#define IDirect3DDevice9_GetDeviceCaps(p, a)
Definition: d3d9.h:1514
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
#define D3DCREATE_MIXED_VERTEXPROCESSING
Definition: d3d8.h:46
#define skip(...)
Definition: atltest.h:64
Definition: name.c:38
D3DXPARAMETER_TYPE Type
Definition: d3dx9shader.h:110
#define WS_OVERLAPPEDWINDOW
Definition: pedump.c:637
unsigned int ULONG
Definition: retypes.h:1
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
int k
Definition: mpi.c:3369
#define SUCCEEDED(hr)
Definition: intsafe.h:57
D3DSWAPEFFECT SwapEffect
Definition: d3d8types.h:1128

Referenced by START_TEST().

◆ test_registerset_defaults()

static void test_registerset_defaults ( void  )
static

Definition at line 6320 of file shader.c.

6321 {
6322  UINT k;
6323  HWND wnd;
6324  IDirect3D9 *d3d;
6325  IDirect3DDevice9 *device;
6326  D3DPRESENT_PARAMETERS d3dpp;
6327  HRESULT hr;
6328  ULONG count;
6329  D3DCAPS9 caps;
6330 
6331  if (!(wnd = CreateWindowA("static", "d3dx9_test", WS_OVERLAPPEDWINDOW, 0, 0,
6332  640, 480, NULL, NULL, NULL, NULL)))
6333  {
6334  skip("Couldn't create application window\n");
6335  return;
6336  }
6337  if (!(d3d = Direct3DCreate9(D3D_SDK_VERSION)))
6338  {
6339  skip("Couldn't create IDirect3D9 object\n");
6340  DestroyWindow(wnd);
6341  return;
6342  }
6343 
6344  ZeroMemory(&d3dpp, sizeof(d3dpp));
6345  d3dpp.Windowed = TRUE;
6348  if (FAILED(hr))
6349  {
6350  skip("Failed to create IDirect3DDevice9 object %#x\n", hr);
6351  IDirect3D9_Release(d3d);
6352  DestroyWindow(wnd);
6353  return;
6354  }
6355 
6357  ok(SUCCEEDED(hr), "Failed to get device caps, hr %#x.\n", hr);
6358  if (caps.VertexShaderVersion < D3DVS_VERSION(3, 0)
6359  || caps.PixelShaderVersion < D3DPS_VERSION(3, 0))
6360  {
6361  skip("Skipping: Test requires VS >= 3 and PS >= 3.\n");
6363  IDirect3D9_Release(d3d);
6364  DestroyWindow(wnd);
6365  return;
6366  }
6367 
6368  for (k = 0; k < ARRAY_SIZE(registerset_defaults_data); ++k)
6369  {
6370  const char *tablename = registerset_defaults_data[k].name;
6371  ID3DXConstantTable *ctable;
6372  D3DXCONSTANTTABLE_DESC tdesc;
6373  BOOL is_vs;
6374  UINT ret;
6375 
6377  ok(hr == D3D_OK, "D3DXGetShaderConstantTable \"%s\" failed, got %08x, expected %08x\n", tablename, hr, D3D_OK);
6378 
6380  ok(hr == D3D_OK, "GetDesc \"%s\" failed, got %08x, expected %08x\n", tablename, hr, D3D_OK);
6381 
6382  is_vs = (tdesc.Version & 0xFFFF0000) == 0xFFFE0000;
6383 
6385 
6387  ok(hr == D3D_OK, "SetDefaults \"%s\" failed, got %08x, expected %08x\n", tablename, hr, D3D_OK);
6388 
6391  ok(ret == 0, "Get*ShaderConstantF \"%s\" failed\n", tablename);
6392 
6395  ok(ret == 0, "Get*ShaderConstantI \"%s\" failed\n", tablename);
6396 
6399  ok(ret == 0, "Get*ShaderConstantB \"%s\" failed\n", tablename);
6400 
6402  ok(count == 0, "Release \"%s\" failed, got %u, expected %u\n", tablename, count, 0);
6403  }
6404 
6405  /* Release resources */
6407  ok(count == 0, "The Direct3D device reference count was %u, should be 0\n", count);
6408 
6409  count = IDirect3D9_Release(d3d);
6410  ok(count == 0, "The Direct3D object referenct count was %u, should be 0\n", count);
6411 
6412  if (wnd) DestroyWindow(wnd);
6413 }
#define IDirect3D9_CreateDevice(p, a, b, c, d, e, f)
Definition: d3d9.h:235
#define D3DADAPTER_DEFAULT
Definition: d3d8.h:57
#define TRUE
Definition: types.h:120
unsigned int bool_count
Definition: shader.c:6190
HRESULT hr
Definition: shlfolder.c:183
Definition: image.c:133
HRESULT WINAPI D3DXGetShaderConstantTable(const DWORD *byte_code, ID3DXConstantTable **constant_table)
Definition: shader.c:2104
GLuint GLuint GLsizei count
Definition: gl.h:1545
DWORD VertexShaderVersion
Definition: d3d9caps.h:313
#define ZeroMemory
Definition: winbase.h:1648
#define ID3DXConstantTable_Release(p)
Definition: d3dx9shader.h:177
BOOL WINAPI DestroyWindow(_In_ HWND)
#define D3DPS_VERSION(major, minor)
Definition: d3d8types.h:474
IDirect3D9 *WINAPI Direct3DCreate9(UINT SDKVersion)
Definition: d3d9.c:57
static UINT registerset_compare(IDirect3DDevice9 *device, BOOL is_vs, D3DXREGISTER_SET regset, UINT start, UINT in_count, const DWORD *expected)
Definition: shader.c:5890
#define IDirect3D9_Release(p)
Definition: d3d9.h:220
#define D3DVS_VERSION(major, minor)
Definition: d3d8types.h:475
unsigned int BOOL
Definition: ntddk_ex.h:94
Definition: devices.h:37
#define CreateWindowA(a, b, c, d, e, f, g, h, i, j, k)
Definition: winuser.h:4290
#define IDirect3DDevice9_Release(p)
Definition: d3d9.h:1508
smooth NULL
Definition: ftsmooth.c:416
static void registerset_clear(IDirect3DDevice9 *device)
Definition: shader.c:5864
static _Locale_mask_t ctable[256]
#define ID3DXConstantTable_SetDefaults(p, a)
Definition: d3dx9shader.h:188
#define D3D_SDK_VERSION
Definition: d3d8.h:56
LONG HRESULT
Definition: typedefs.h:78
unsigned int float_count
Definition: shader.c:6188
int ret
#define ID3DXConstantTable_GetDesc(p, a)
Definition: d3dx9shader.h:182
unsigned int int_count
Definition: shader.c:6189
DWORD PixelShaderVersion
Definition: d3d9caps.h:315
static const struct @1632 registerset_defaults_data[]
#define D3D_OK
Definition: d3d.h:106
#define ARRAY_SIZE(a)
Definition: main.h:24
#define IDirect3DDevice9_GetDeviceCaps(p, a)
Definition: d3d9.h:1514
#define ok(value,...)
Definition: atltest.h:57
unsigned int UINT
Definition: ndis.h:50
#define D3DCREATE_MIXED_VERTEXPROCESSING
Definition: d3d8.h:46
#define skip(...)
Definition: atltest.h:64
#define WS_OVERLAPPEDWINDOW
Definition: pedump.c:637
const DWORD floats[1024]
Definition: shader.c:6191
unsigned int ULONG
Definition: retypes.h:1
const DWORD bools[16]
Definition: shader.c:6193
int k
Definition: mpi.c:3369
#define SUCCEEDED(hr)
Definition: intsafe.h:57
D3DSWAPEFFECT SwapEffect
Definition: d3d8types.h:1128
const DWORD ints[256]
Definition: shader.c:6192

Referenced by START_TEST().

◆ test_SetDefaults()

static void test_SetDefaults ( IDirect3DDevice9 *  device)
static

Definition at line 1198 of file shader.c.

1199 {
1200  static const D3DXMATRIX mvp = {{{
1201  0.51f, 0.62f, 0.80f, 0.78f,
1202  0.23f, 0.95f, 0.37f, 0.48f,
1203  0.10f, 0.58f, 0.90f, 0.25f,
1204  0.89f, 0.41f, 0.93f, 0.27f}}};
1205  static const D3DXVECTOR4 f4 = {0.2f, 0.4f, 0.8f, 1.2f};
1206 
1207  float out[16];
1208 
1209  HRESULT res;
1210  ID3DXConstantTable *ctable;
1211 
1213  ok(res == D3D_OK, "D3DXGetShaderConstantTable failed: got %08x\n", res);
1214 
1216  ok(res == D3D_OK, "ID3DXConstantTable_SetVector failed: got %08x\n", res);
1217 
1218  res = ID3DXConstantTable_SetMatrix(ctable, device, "mvp", &mvp);
1219  ok(res == D3D_OK, "ID3DXConstantTable_SetMatrix failed: got %08x\n", res);
1220 
1222  ok(res == D3D_OK, "ID3dXConstantTable_SetDefaults failed: got %08x\n", res);
1223 
1224  /* SetDefaults doesn't change constants without default values */
1226  ok(out[0] == S(U(mvp))._11 && out[4] == S(U(mvp))._12 && out[8] == S(U(mvp))._13 && out[12] == S(U(mvp))._14,
1227  "The first row of mvp was not set correctly, got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
1228  out[0], out[4], out[8], out[12], S(U(mvp))._11, S(U(mvp))._12, S(U(mvp))._13, S(U(mvp))._14);
1229  ok(out[1] == S(U(mvp))._21 && out[5] == S(U(mvp))._22 && out[9] == S(U(mvp))._23 && out[13] == S(U(mvp))._24,
1230  "The second row of mvp was not set correctly, got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
1231  out[1], out[5], out[9], out[13], S(U(mvp))._21, S(U(mvp))._22, S(U(mvp))._23, S(U(mvp))._24);
1232  ok(out[2] == S(U(mvp))._31 && out[6] == S(U(mvp))._32 && out[10] == S(U(mvp))._33 && out[14] == S(U(mvp))._34,
1233  "The third row of mvp was not set correctly, got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
1234  out[2], out[6], out[10], out[14], S(U(mvp))._31, S(U(mvp))._32, S(U(mvp))._33, S(U(mvp))._34);
1235  ok(out[3] == S(U(mvp))._41 && out[7] == S(U(mvp))._42 && out[11] == S(U(mvp))._43 && out[15] == S(U(mvp))._44,
1236  "The fourth row of mvp was not set correctly, got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
1237  out[3], out[7], out[11], out[15], S(U(mvp))._41, S(U(mvp))._42, S(U(mvp))._43, S(U(mvp))._44);
1238 
1240  ok(memcmp(out, &f4, sizeof(f4)) == 0,
1241  "The variable f4 was not set correctly, out={%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
1242  out[0], out[1], out[2], out[3], f4.x, f4.y, f4.z, f4.w);
1243 
1245 
1247  ok(res == D3D_OK, "D3DXGetShaderConstantTable failed: got %08x\n", res);
1248 
1250  ok(res == D3D_OK, "ID3DXConstantTable_SetDefaults failed: got %08x\n", res);
1251 
1254  "The variable mat4 was not set correctly to default value\n");
1255 
1258  "The variable mat3 was not set correctly to default value\n");
1259 
1262  "The variable array was not set correctly to default value\n");
1263 
1266  "The variable vec4 was not set correctly to default value\n");
1267 
1270  "The variable flt was not set correctly to default value\n");
1271 
1273 }
static const DWORD ctab_basic[]
Definition: shader.c:90
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
HRESULT WINAPI D3DXGetShaderConstantTable(const DWORD *byte_code, ID3DXConstantTable **constant_table)
Definition: shader.c:2104
#define U(x)
Definition: wordpad.c:45
#define S(x)
Definition: test.h:206
#define ID3DXConstantTable_Release(p)
Definition: d3dx9shader.h:177
static const float mat4_default_value[]
Definition: shader.c:247
static const float arr_default_value[]
Definition: shader.c:249
Definition: devices.h:37
static const float flt_default_value[]
Definition: shader.c:251
static _Locale_mask_t ctable[256]
#define ID3DXConstantTable_SetDefaults(p, a)
Definition: d3dx9shader.h:188
#define IDirect3DDevice9_GetVertexShaderConstantF(p, a, b, c)
Definition: d3d9.h:1602
LONG HRESULT
Definition: typedefs.h:78
static FILE * out
Definition: regtests2xml.c:44
#define f4(x, y, z)
Definition: sha1.c:33
#define _11
Definition: ke_i.h:85
#define ID3DXConstantTable_SetMatrix(p, a, b, c)
Definition: d3dx9shader.h:198
#define D3D_OK
Definition: d3d.h:106
static const float mat3_default_value[]
Definition: shader.c:248
#define ok(value,...)
Definition: atltest.h:57
GLuint res
Definition: glext.h:9613
static const float vec4_default_value[]
Definition: shader.c:250
static const DWORD ctab_with_default_values[]
Definition: shader.c:209
#define ID3DXConstantTable_SetVector(p, a, b, c)
Definition: d3dx9shader.h:196

Referenced by test_setting_constants().

◆ test_setting_arrays_table()

static void test_setting_arrays_table ( IDirect3DDevice9 *  device)
static

Definition at line 1086 of file shader.c.

1087 {
1088  static const float farray[8] = {
1089  0.005f, 0.745f, 0.973f, 0.264f,
1090  0.010f, 0.020f, 0.030f, 0.040f};
1091  static const D3DXMATRIX fmtxarray[2] = {
1092  {{{0.001f, 0.002f, 0.003f, 0.004f,
1093  0.005f, 0.006f, 0.007f, 0.008f,
1094  0.009f, 0.010f, 0.011f, 0.012f,
1095  0.013f, 0.014f, 0.015f, 0.016f}}},
1096  {{{0.010f, 0.020f, 0.030f, 0.040f,
1097  0.050f, 0.060f, 0.070f, 0.080f,
1098  0.090f, 0.100f, 0.110f, 0.120f,
1099  0.130f, 0.140f, 0.150f, 0.160f}}}};
1100  static const int iarray[4] = {1, 2, 3, 4};
1101  static const D3DXVECTOR4 fvecarray[2] = {
1102  {0.745f, 0.997f, 0.353f, 0.237f},
1103  {0.060f, 0.455f, 0.333f, 0.983f}};
1104  static BOOL barray[4] = {FALSE, 100, TRUE, TRUE};
1105 
1106  ID3DXConstantTable *ctable;
1107 
1108  HRESULT res;
1109  float out[32];
1110  ULONG refcnt;
1111 
1112  /* Clear registers */
1113  memset(out, 0, sizeof(out));
1116 
1117  /* Get the constant table from the shader */
1119  ok(res == D3D_OK, "D3DXGetShaderConstantTable failed: got 0x%08x\n", res);
1120 
1121  /* Set constants */
1122 
1123  /* Make sure that we cannot set registers that do not belong to this constant */
1124  res = ID3DXConstantTable_SetFloatArray(ctable, device, "farray", farray, 8);
1125  ok(res == D3D_OK, "ID3DXConstantTable_SetFloatArray failed: got 0x%08x\n", res);
1126 
1128  ok(out[0] == farray[0] && out[4] == farray[1] && out[8] == farray[2] && out[12] == farray[3],
1129  "The in-bounds elements of the array were not set, out={%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
1130  out[0], out[4], out[8], out[12], farray[0], farray[1], farray[2], farray[3]);
1131  ok(out[16] == 0.0f && out[20] == 0.0f && out[24] == 0.0f && out[28] == 0.0f,
1132  "The excess elements of the array were set, out={%f, %f, %f, %f}, should be all 0.0f\n",
1133  out[16], out[20], out[24], out[28]);
1134 
1135  /* ivecarray takes up only 1 register, but a matrix takes up 4, so no elements should be set */
1136  res = ID3DXConstantTable_SetMatrix(ctable, device, "ivecarray", &fmtxarray[0]);
1137  ok(res == D3D_OK, "ID3DXConstantTable_SetMatrix failed: got 0x%08x\n", res);
1138 
1140  ok(out[0] == 0.0f && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f,
1141  "The array was set, out={%f, %f, %f, %f}, should be all 0.0f\n", out[0], out[1], out[2], out[3]);
1142 
1143  /* Try setting an integer array to an array declared as a float array */
1144  res = ID3DXConstantTable_SetIntArray(ctable, device, "farray", iarray, 4);
1145  ok(res == D3D_OK, "ID3DXConstantTable_SetIntArray failed: got 0x%08x\n", res);
1146 
1148  ok(out[0] == iarray[0] && out[4] == iarray[1] && out[8] == iarray[2] && out[12] == iarray[3],
1149  "SetIntArray did not properly set a float array: out={%f, %f, %f, %f}, should be {%d, %d, %d, %d}\n",
1150  out[0], out[4], out[8], out[12], iarray[0], iarray[1], iarray[2], iarray[3]);
1151 
1152  res = ID3DXConstantTable_SetFloatArray(ctable, device, "farray", farray, 4);
1153  ok(res == D3D_OK, "ID3DXConstantTable_SetFloatArray failed: got x0%08x\n", res);
1154 
1155  res = ID3DXConstantTable_SetVectorArray(ctable, device, "fvecarray", fvecarray, 2);
1156  ok(res == D3D_OK, "ID3DXConstantTable_SetVectorArray failed: got 0x%08x\n", res);
1157 
1158  res = ID3DXConstantTable_SetMatrixArray(ctable, device, "fmtxarray", fmtxarray, 2);
1159  ok(res == D3D_OK, "ID3DXConstantTable_SetMatrixArray failed: got 0x%08x\n", res);
1160 
1161  res = ID3DXConstantTable_SetBoolArray(ctable, device, "barray", barray, 2);
1162  ok(res == D3D_OK, "ID3DXConstantTable_SetBoolArray failed: got 0x%08x\n", res);
1163 
1164  /* Read back constants */
1166  ok(out[0] == farray[0] && out[4] == farray[1] && out[8] == farray[2] && out[12] == farray[3],
1167  "The variable farray was not set correctly, out={%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
1168  out[0], out[4], out[8], out[12], farray[0], farray[1], farray[2], farray[3]);
1169 
1171  ok(out[0] == fvecarray[0].x && out[1] == fvecarray[0].y && out[2] == fvecarray[0].z && out[3] == fvecarray[0].w &&
1172  out[4] == fvecarray[1].x && out[5] == fvecarray[1].y && out[6] == fvecarray[1].z && out[7] == fvecarray[1].w,
1173  "The variable fvecarray was not set correctly, out={{%f, %f, %f, %f}, {%f, %f, %f, %f}}, should be "
1174  "{{%f, %f, %f, %f}, {%f, %f, %f, %f}}\n", out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7],
1175  fvecarray[0].x, fvecarray[0].y, fvecarray[0].z, fvecarray[0].w, fvecarray[1].x, fvecarray[1].y,
1176  fvecarray[1].z, fvecarray[1].w);
1177 
1179  ok(out[0] == 0.0f && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f
1180  && out[4] == 1.0f && out[5] == 0.0f && out[6] == 0.0f && out[7] == 0.0f,
1181  "The variable barray was not set correctly, out={%f, %f %f, %f; %f, %f, %f, %f}, should be {%f, %f, %f, %f; %f, %f, %f, %f}\n",
1182  out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7],
1183  0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f);
1184 
1186  /* Just check a few elements in each matrix to make sure fmtxarray was set row-major */
1187  ok(out[0] == S(U(fmtxarray[0]))._11 && out[1] == S(U(fmtxarray[0]))._12 && out[2] == S(U(fmtxarray[0]))._13 && out[3] == S(U(fmtxarray[0]))._14,
1188  "The variable fmtxarray was not set row-major, out={%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
1189  out[0], out[1], out[2], out[3], S(U(fmtxarray[0]))._11, S(U(fmtxarray[0]))._12, S(U(fmtxarray[0]))._13, S(U(fmtxarray[0]))._14);
1190  ok(out[16] == S(U(fmtxarray[1]))._11 && out[17] == S(U(fmtxarray[1]))._12 && out[18] == S(U(fmtxarray[1]))._13 && out[19] == S(U(fmtxarray[1]))._14,
1191  "The variable fmtxarray was not set row-major, out={%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
1192  out[16], out[17], out[18], out[19], S(U(fmtxarray[1]))._11, S(U(fmtxarray[1]))._12, S(U(fmtxarray[1]))._13, S(U(fmtxarray[1]))._14);
1193 
1195  ok(refcnt == 0, "The constant table reference count was %u, should be 0\n", refcnt);
1196 }
#define TRUE
Definition: types.h:120
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
HRESULT WINAPI D3DXGetShaderConstantTable(const DWORD *byte_code, ID3DXConstantTable **constant_table)
Definition: shader.c:2104
#define U(x)
Definition: wordpad.c:45
static const DWORD ctab_arrays[]
Definition: shader.c:174
#define S(x)
Definition: test.h:206
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
#define ID3DXConstantTable_Release(p)
Definition: d3dx9shader.h:177
#define ID3DXConstantTable_SetBoolArray(p, a, b, c, d)
Definition: d3dx9shader.h:191
#define ID3DXConstantTable_SetIntArray(p, a, b, c, d)
Definition: d3dx9shader.h:193
unsigned int BOOL
Definition: ntddk_ex.h:94
Definition: devices.h:37
#define IDirect3DDevice9_SetVertexShaderConstantF(p, a, b, c)
Definition: d3d9.h:1601
GLdouble GLdouble z
Definition: glext.h:5874
static _Locale_mask_t ctable[256]
#define IDirect3DDevice9_GetVertexShaderConstantF(p, a, b, c)
Definition: d3d9.h:1602
GLfloat f
Definition: glext.h:7540
LONG HRESULT
Definition: typedefs.h:78
static FILE * out
Definition: regtests2xml.c:44
#define ID3DXConstantTable_SetFloatArray(p, a, b, c, d)
Definition: d3dx9shader.h:195
#define _11
Definition: ke_i.h:85
#define ID3DXConstantTable_SetVectorArray(p, a, b, c, d)
Definition: d3dx9shader.h:197
#define ID3DXConstantTable_SetMatrixArray(p, a, b, c, d)
Definition: d3dx9shader.h:199
#define ID3DXConstantTable_SetMatrix(p, a, b, c)
Definition: d3dx9shader.h:198
#define D3D_OK
Definition: d3d.h:106
#define ok(value,...)
Definition: atltest.h:57
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLuint res
Definition: glext.h:9613
unsigned int ULONG
Definition: retypes.h:1
#define memset(x, y, z)
Definition: compat.h:39

Referenced by test_setting_constants().

◆ test_setting_basic_table()

static void test_setting_basic_table ( IDirect3DDevice9 *  device)
static

Definition at line 665 of file shader.c.

666 {
667  static const D3DXMATRIX mvp = {{{
668  0.514f, 0.626f, 0.804f, 0.786f,
669  0.238f, 0.956f, 0.374f, 0.483f,
670  0.109f, 0.586f, 0.900f, 0.255f,
671  0.898f, 0.411f, 0.932f, 0.275f}}};
672  static const D3DXVECTOR4 f4 = {0.350f, 0.526f, 0.925f, 0.021f};
673  static const float f = 0.12543f;
674  static const int i = 321;
675  static const D3DXMATRIX *matrix_pointer[] = {&mvp};
676 
677  ID3DXConstantTable *ctable;
678 
679  HRESULT res;
680  float out[16];
681  ULONG refcnt;
682 
683  /* Get the constant table from the shader itself */
685  ok(res == D3D_OK, "D3DXGetShaderConstantTable failed: got 0x%08x\n", res);
686 
687  /* Set constants */
689  ok(res == D3D_OK, "ID3DXConstantTable_SetMatrix failed on variable mvp: got 0x%08x\n", res);
690 
692  ok(res == D3D_OK, "ID3DXConstantTable_SetInt failed on variable i: got 0x%08x\n", res);
693 
694  /* Check that setting i again will overwrite the previous value */
696  ok(res == D3D_OK, "ID3DXConstantTable_SetInt failed on variable i: got 0x%08x\n", res);
697 
699  ok(res == D3D_OK, "ID3DXConstantTable_SetFloat failed on variable f: got 0x%08x\n", res);
700 
702  ok(res == D3D_OK, "ID3DXConstantTable_SetVector failed on variable f4: got 0x%08x\n", res);
703 
704  /* Get constants back and validate */
706  ok(out[0] == S(U(mvp))._11 && out[4] == S(U(mvp))._12 && out[8] == S(U(mvp))._13 && out[12] == S(U(mvp))._14,
707  "The first row of mvp was not set correctly, got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
708  out[0], out[4], out[8], out[12], S(U(mvp))._11, S(U(mvp))._12, S(U(mvp))._13, S(U(mvp))._14);
709  ok(out[1] == S(U(mvp))._21 && out[5] == S(U(mvp))._22 && out[9] == S(U(mvp))._23 && out[13] == S(U(mvp))._24,
710  "The second row of mvp was not set correctly, got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
711  out[1], out[5], out[9], out[13], S(U(mvp))._21, S(U(mvp))._22, S(U(mvp))._23, S(U(mvp))._24);
712  ok(out[2] == S(U(mvp))._31 && out[6] == S(U(mvp))._32 && out[10] == S(U(mvp))._33 && out[14] == S(U(mvp))._34,
713  "The third row of mvp was not set correctly, got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
714  out[2], out[6], out[10], out[14], S(U(mvp))._31, S(U(mvp))._32, S(U(mvp))._33, S(U(mvp))._34);
715  ok(out[3] == S(U(mvp))._41 && out[7] == S(U(mvp))._42 && out[11] == S(U(mvp))._43 && out[15] == S(U(mvp))._44,
716  "The fourth row of mvp was not set correctly, got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
717  out[3], out[7], out[11], out[15], S(U(mvp))._41, S(U(mvp))._42, S(U(mvp))._43, S(U(mvp))._44);
718 
720  ok(out[0] == (float)i && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f,
721  "The variable i was not set correctly, out={%f, %f, %f, %f}, should be {%d, 0.0, 0.0, 0.0}\n",
722  out[0], out[1], out[2], out[3], i);
723 
725  ok(out[0] == f && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f,
726  "The variable f was not set correctly, out={%f, %f, %f, %f}, should be {%f, 0.0, 0.0, 0.0}\n",
727  out[0], out[1], out[2], out[3], f);
728 
730  ok(memcmp(out, &f4, sizeof(f4)) == 0,
731  "The variable f4 was not set correctly, out={%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
732  out[0], out[1], out[2], out[3], f4.x, f4.y, f4.z, f4.w);
733 
734  /* Finally test using a set* function for one type to set a variable of another type (should succeed) */
736  ok(res == D3D_OK, "ID3DXConstantTable_SetVector failed on variable f: 0x%08x\n", res);
737 
739  ok(out[0] == f4.x && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f,
740  "The variable f was not set correctly by ID3DXConstantTable_SetVector, got %f, should be %f\n",
741  out[0], f4.x);
742 
743  memset(out, 0, sizeof(out));
746  ok(res == D3D_OK, "ID3DXConstantTable_SetMatrix failed on variable f: 0x%08x\n", res);
747 
749  ok(out[0] == S(U(mvp))._11 && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f,
750  "The variable f was not set correctly by ID3DXConstantTable_SetMatrix, got %f, should be %f\n",
751  out[0], S(U(mvp))._11);
752 
753  /* Clear registers */
754  memset(out, 0, sizeof(out));
758 
759  /* SetVector shouldn't change the value of a matrix constant */
761  ok(res == D3D_OK, "ID3DXConstantTable_SetVector failed on variable f: 0x%08x\n", res);
762 
764  ok(out[0] == 0.0f && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f
765  && out[4] == 0.0f && out[5] == 0.0f && out[6] == 0.0f && out[7] == 0.0f
766  && out[8] == 0.0f && out[9] == 0.0f && out[10] == 0.0f && out[11] == 0.0f
767  && out[12] == 0.0f && out[13] == 0.0f && out[14] == 0.0f && out[15] == 0.0f,
768  "The variable mvp was not set correctly by ID3DXConstantTable_SetVector, "
769  "got {%f, %f, %f, %f; %f, %f, %f, %f; %f, %f, %f %f; %f, %f, %f, %f}, "
770  "should be all 0.0f\n",
771  out[0], out[1], out[2], out[3],
772  out[4], out[5], out[6], out[7],
773  out[8], out[9], out[10], out[11],
774  out[12], out[13], out[14], out[15]);
775 
777  ok(res == D3D_OK, "ID3DXConstantTable_SetFloat failed on variable mvp: 0x%08x\n", res);
778 
780  ok(out[0] == 0.0f && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f
781  && out[4] == 0.0f && out[5] == 0.0f && out[6] == 0.0f && out[7] == 0.0f
782  && out[8] == 0.0f && out[9] == 0.0f && out[10] == 0.0f && out[11] == 0.0f
783  && out[12] == 0.0f && out[13] == 0.0f && out[14] == 0.0f && out[15] == 0.0f,
784  "The variable mvp was not set correctly by ID3DXConstantTable_SetFloat, "
785  "got {%f, %f, %f, %f; %f, %f, %f, %f; %f, %f, %f %f; %f, %f, %f, %f}, "
786  "should be all 0.0f\n",
787  out[0], out[1], out[2], out[3],
788  out[4], out[5], out[6], out[7],
789  out[8], out[9], out[10], out[11],
790  out[12], out[13], out[14], out[15]);
791 
793  ok(res == D3D_OK, "ID3DXConstantTable_SetFloat failed on variable f4: 0x%08x\n", res);
794 
796  ok(out[0] == 0.0f && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f,
797  "The variable f4 was not set correctly by ID3DXConstantTable_SetFloat, "
798  "got {%f, %f, %f, %f}, should be all 0.0f\n",
799  out[0], out[1], out[2], out[3]);
800 
802  ok(res == D3D_OK, "ID3DXConstantTable_SetMatrixTranspose failed on variable f: 0x%08x\n", res);
803 
805  ok(out[0] == S(U(mvp))._11 && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f,
806  "The variable f was not set correctly by ID3DXConstantTable_SetMatrixTranspose, got %f, should be %f\n",
807  out[0], S(U(mvp))._11);
808 
810  ok(res == D3D_OK, "ID3DXConstantTable_SetMatrixTranspose failed on variable f4: 0x%08x\n", res);
811 
813  ok(out[0] == S(U(mvp))._11 && out[1] == S(U(mvp))._21 && out[2] == S(U(mvp))._31 && out[3] == S(U(mvp))._41,
814  "The variable f4 was not set correctly by ID3DXConstantTable_SetMatrixTranspose, "
815  "got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
816  out[0], out[1], out[2], out[3],
817  S(U(mvp))._11, S(U(mvp))._21, S(U(mvp))._31, S(U(mvp))._41);
818 
819  memset(out, 0, sizeof(out));
821  res = ID3DXConstantTable_SetMatrixPointerArray(ctable, device, "f", matrix_pointer, 1);
822  ok(res == D3D_OK, "ID3DXConstantTable_SetMatrixPointerArray failed on variable f: got %#x\n", res);
823 
825  ok(out[0] == S(U(mvp))._11 && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f,
826  "The variable f was not set correctly by ID3DXConstantTable_SetMatrixPointerArray, "
827  "got %f, should be %f\n",
828  out[0], S(U(mvp))._11);
829 
830  res = ID3DXConstantTable_SetMatrixPointerArray(ctable, device, "f4", matrix_pointer, 1);
831  ok(res == D3D_OK, "ID3DXConstantTable_SetMatrixPointerArray failed on variable f4: got %#x\n", res);
832 
834  ok(out[0] == S(U(mvp))._11 && out[1] == S(U(mvp))._12 && out[2] == S(U(mvp))._13 && out[3] == S(U(mvp))._14,
835  "The variable f4 was not set correctly by ID3DXConstantTable_SetMatrixPointerArray, "
836  "got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
837  out[0], out[1], out[2], out[3],
838  S(U(mvp))._11, S(U(mvp))._12, S(U(mvp))._13, S(U(mvp))._14);
839 
840  memset(out, 0, sizeof(out));
843  ok(res == D3D_OK, "ID3DXConstantTable_SetMatrixTransposePointerArray failed on variable f: got %#x\n", res);
844 
846  ok(out[0] == S(U(mvp))._11 && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f,
847  "The variable f was not set correctly by ID3DXConstantTable_SetMatrixTransposePointerArray, "
848  "got %f, should be %f\n",
849  out[0], S(U(mvp))._11);
850 
852  ok(res == D3D_OK, "ID3DXConstantTable_SetMatrixTransposePointerArray failed on variable f4: got %#x\n", res);
853 
855  ok(out[0] == S(U(mvp))._11 && out[1] == S(U(mvp))._21 && out[2] == S(U(mvp))._31 && out[3] == S(U(mvp))._41,
856  "The variable f4 was not set correctly by ID3DXConstantTable_SetMatrixTransposePointerArray, "
857  "got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
858  out[0], out[1], out[2], out[3],
859  S(U(mvp))._11, S(U(mvp))._21, S(U(mvp))._31, S(U(mvp))._41);
860 
862  ok(refcnt == 0, "The constant table reference count was %u, should be 0\n", refcnt);
863 }
#define ID3DXConstantTable_SetMatrixTranspose(p, a, b, c)
Definition: d3dx9shader.h:201
static const DWORD ctab_basic[]
Definition: shader.c:90
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
HRESULT WINAPI D3DXGetShaderConstantTable(const DWORD *byte_code, ID3DXConstantTable **constant_table)
Definition: shader.c:2104
#define U(x)
Definition: wordpad.c:45
#define S(x)
Definition: test.h:206
#define ID3DXConstantTable_Release(p)
Definition: d3dx9shader.h:177
#define ID3DXConstantTable_SetFloat(p, a, b, c)
Definition: d3dx9shader.h:194
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
Definition: devices.h:37
#define ID3DXConstantTable_SetMatrixPointerArray(p, a, b, c, d)
Definition: d3dx9shader.h:200
#define IDirect3DDevice9_SetVertexShaderConstantF(p, a, b, c)
Definition: d3d9.h:1601
static _Locale_mask_t ctable[256]
#define IDirect3DDevice9_GetVertexShaderConstantF(p, a, b, c)
Definition: d3d9.h:1602
#define ID3DXConstantTable_SetMatrixTransposePointerArray(p, a, b, c, d)
Definition: d3dx9shader.h:203
GLfloat f
Definition: glext.h:7540
LONG HRESULT
Definition: typedefs.h:78
static FILE * out
Definition: regtests2xml.c:44
#define f4(x, y, z)
Definition: sha1.c:33
#define _11
Definition: ke_i.h:85
#define ID3DXConstantTable_SetMatrix(p, a, b, c)
Definition: d3dx9shader.h:198
#define ID3DXConstantTable_SetInt(p, a, b, c)
Definition: d3dx9shader.h:192
#define D3D_OK
Definition: d3d.h:106
#define ok(value,...)
Definition: atltest.h:57
GLuint res
Definition: glext.h:9613
unsigned int ULONG
Definition: retypes.h:1
#define memset(x, y, z)
Definition: compat.h:39
#define ID3DXConstantTable_SetVector(p, a, b, c)
Definition: d3dx9shader.h:196

Referenced by test_setting_constants().

◆ test_setting_constants()

static void test_setting_constants ( void  )
static

Definition at line 1449 of file shader.c.

1450 {
1451  HWND wnd;
1452  IDirect3D9 *d3d;
1453  IDirect3DDevice9 *device;
1454  D3DPRESENT_PARAMETERS d3dpp;
1455  HRESULT hr;
1456  ULONG refcnt;
1457 
1458  if (!(wnd = CreateWindowA("static", "d3dx9_test", WS_OVERLAPPEDWINDOW, 0, 0,
1459  640, 480, NULL, NULL, NULL, NULL)))
1460  {
1461  skip("Couldn't create application window\n");
1462  return;
1463  }
1464  if (!(d3d = Direct3DCreate9(D3D_SDK_VERSION)))
1465  {
1466  skip("Couldn't create IDirect3D9 object\n");
1467  DestroyWindow(wnd);
1468  return;
1469  }
1470 
1471  ZeroMemory(&d3dpp, sizeof(d3dpp));
1472  d3dpp.Windowed = TRUE;
1475  if (FAILED(hr))
1476  {
1477  skip("Failed to create IDirect3DDevice9 object %#x\n", hr);
1478  IDirect3D9_Release(d3d);
1479  DestroyWindow(wnd);</