ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'jayfoxrox/texgen-rebased' into texgen-rebased

This commit is contained in:
espes 2015-08-20 11:57:10 +10:00
parent 61789be0c4 92d79c8a7d
commit ec4c7c2f4c
2 changed files with 138 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
hw/xbox/nv2a.c
View File

@ -871,6 +871,10 @@
# define NV097_SET_COMPOSITE_MATRIX 0x00970680
# define NV097_SET_TEXTURE_MATRIX 0x009706C0
# define NV097_SET_FOG_PARAMS 0x009709C0
# define NV097_SET_TEXGEN_PLANE_S 0x00970840
# define NV097_SET_TEXGEN_PLANE_T 0x00970850
# define NV097_SET_TEXGEN_PLANE_R 0x00970860
# define NV097_SET_TEXGEN_PLANE_Q 0x00970870
# define NV097_SET_TEXGEN_VIEW_MODEL 0x009709CC
# define NV097_SET_TEXGEN_VIEW_MODEL_LOCAL_VIEWER 0
# define NV097_SET_TEXGEN_VIEW_MODEL_INFINITE_VIEWER 1
@ -1493,8 +1497,9 @@ typedef struct PGRAPHState {
float composite_matrix[16];
/* FIXME: These are probably stored in the vshader consts */
bool texture_matrix_enable[4];
float texture_matrix[4][16]; /* 4 stages with 4x4 matrix each */
bool texture_matrix_enable[NV2A_MAX_TEXTURES];
float texture_matrix[NV2A_MAX_TEXTURES][16]; /* 4 stages with 4x4 matrix each */
float texture_plane[NV2A_MAX_TEXTURES][4][4]; /* 4 stages, 4 components + plane for each */
float projection_matrix[16];
float inverse_model_view_matrix[4][16]; /* 4 weights with 4x4 matrix each */
float model_view_matrix[4][16]; /* 4 weights with 4x4 matrix each */
@ -1503,7 +1508,7 @@ typedef struct PGRAPHState {
float fog_plane[4];
/* FIXME: Move to NV_PGRAPH_BUMPMAT... */
float bump_env_matrix[3][4]; /* 4 stages with 2x2 matrix each */
float bump_env_matrix[NV2A_MAX_TEXTURES-1][4]; /* 3 allowed stages with 2x2 matrix each */
GloContext *gl_context;
GLuint gl_framebuffer;
@ -2939,7 +2944,7 @@ static void pgraph_bind_shaders(PGRAPHState *pg)
}
/* For each texture stage */
for (i = 0; i < 4; i++) {
for (i = 0; i < NV2A_MAX_TEXTURES; i++) {
char name[32];
GLint loc;
@ -2975,6 +2980,16 @@ static void pgraph_bind_shaders(PGRAPHState *pg)
glUniformMatrix4fv(loc, 1, GL_FALSE, pg->texture_matrix[i]);
}
/* TexGen planes */
for(j = 0; j < 4; j++) {
char cSuffix = "STRQ"[j];
snprintf(name, sizeof(name), "texPlane%c%d", cSuffix, i);
loc = glGetUniformLocation(pg->shader_binding->gl_program, name);
if (loc != -1) {
glUniform4fv(loc, 1, pg->texture_plane[i][j]);
}
}
}
/* Fog */
@ -4412,6 +4427,16 @@ static void pgraph_method(NV2AState *d,
/* FIXME: No idea where slot = 2 is */
}
break;
/* Handles NV097_SET_TEXGEN_PLANE_S,T,R,Q */
case NV097_SET_TEXGEN_PLANE_S ...
NV097_SET_TEXGEN_PLANE_S + 0xfc: {
slot = (class_method - NV097_SET_TEXGEN_PLANE_S) / 4;
unsigned int part = slot % 16;
pg->texture_plane[slot / 16][part / 4][part % 4] = *(float*)&parameter;
break;
}
case NV097_SET_TEXGEN_VIEW_MODEL:
SET_MASK(pg->regs[NV_PGRAPH_CSV0_D], NV_PGRAPH_CSV0_D_TEXGEN_REF,
parameter);

156
hw/xbox/nv2a_shaders.c
View File

@ -72,7 +72,43 @@ static QString* generate_geometry_shader(enum ShaderPrimitiveMode primitive_mode
return s;
}
static void pgraph_append_skinning_code(QString* str, bool mix,
unsigned int count, const char* type,
const char* output, const char* input,
const char* matrix, const char* swizzle)
{
if (count == 0) {
qstring_append_fmt(str, "%s %s = (%s * %s0).%s;\n",
type, output, input, matrix, swizzle);
} else {
qstring_append_fmt(str, "%s %s = %s(0.0);\n", type, output, type);
if (mix) {
/* Tweening */
if (count == 2) {
qstring_append_fmt(str,
"%s += mix((%s * %s1).%s,\n"
" (%s * %s0).%s, weight.x);\n",
output,
input, matrix, swizzle,
input, matrix, swizzle);
} else {
/* FIXME: Not sure how blend weights are calculated */
assert(false);
}
} else {
/* Individual matrices */
int i;
for (i = 0; i < count; i++) {
char c = "xyzw"[i];
qstring_append_fmt(str, "%s += (%s * %s%d * weight.%c).%s;\n",
output, input, matrix, i, c,
swizzle);
}
assert(false); /* FIXME: Untested */
}
}
}
static QString* generate_fixed_function(const ShaderState state,
char out_prefix)
@ -118,6 +154,22 @@ static QString* generate_fixed_function(const ShaderState state,
"uniform vec4 fogColor;\n"
"uniform vec4 fogPlane;\n"
"uniform float fogParam[2];\n"
"uniform vec4 texPlaneS0;\n"
"uniform vec4 texPlaneT0;\n"
"uniform vec4 texPlaneQ0;\n"
"uniform vec4 texPlaneR0;\n"
"uniform vec4 texPlaneS1;\n"
"uniform vec4 texPlaneT1;\n"
"uniform vec4 texPlaneQ1;\n"
"uniform vec4 texPlaneR1;\n"
"uniform vec4 texPlaneS2;\n"
"uniform vec4 texPlaneT2;\n"
"uniform vec4 texPlaneQ2;\n"
"uniform vec4 texPlaneR2;\n"
"uniform vec4 texPlaneS3;\n"
"uniform vec4 texPlaneT3;\n"
"uniform vec4 texPlaneQ3;\n"
"uniform vec4 texPlaneR3;\n"
"uniform mat4 texMat0;\n"
"uniform mat4 texMat1;\n"
"uniform mat4 texMat2;\n"
@ -141,7 +193,7 @@ static QString* generate_fixed_function(const ShaderState state,
bool mix;
switch (state.skinning) {
case SKINNING_OFF:
count = 0; break;
mix = false; count = 0; break;
case SKINNING_1WEIGHTS:
mix = true; count = 2; break;
case SKINNING_2WEIGHTS:
@ -160,37 +212,27 @@ static QString* generate_fixed_function(const ShaderState state,
}
qstring_append_fmt(s, "/* Skinning mode %d */\n",
state.skinning);
if (count == 0) {
qstring_append(s, "vec4 tPosition = position * modelViewMat0;\n");
/* FIXME: Is the normal still transformed? */
qstring_append(s, "vec3 tNormal = (vec4(normal, 0.0) * invModelViewMat0).xyz;\n");
} else {
qstring_append(s, "vec4 tPosition = vec4(0.0);\n");
qstring_append(s, "vec3 tNormal = vec3(0.0);\n");
if (mix) {
/* Tweening */
if (count == 2) {
qstring_append(s,
"tPosition += mix(position * modelViewMat1,\n"
" position * modelViewMat0, weight.x);\n"
"tNormal += mix((vec4(normal, 0.0) * invModelViewMat1).xyz,\n"
" (vec4(normal, 0.0) * invModelViewMat0).xyz, weight.x);\n");
} else {
/* FIXME: Not sure how blend weights are calculated */
assert(false);
}
} else {
/* Individual matrices */
for (i = 0; i < count; i++) {
char c = "xyzw"[i];
qstring_append_fmt(s,
"tPosition += position * modelViewMat%d * weight.%c;\n",
i, c);
qstring_append_fmt(s,
"tNormal += (vec4(normal, 0.0) * invModelViewMat%d * weight.%c).xyz;\n",
i, c);
}
assert(false); /* FIXME: Untested */
pgraph_append_skinning_code(s, mix, count, "vec4",
"tPosition", "position",
"modelViewMat", "xyzw");
pgraph_append_skinning_code(s, mix, count, "vec3",
"tNormal", "vec4(normal, 0.0)",
"invModelViewMat", "xyz");
for(i = 0; i < 4 /* FIXME: NV2A_MAX_TEXTURES*/; i++) {
for(j = 0; j < 4; j++) {
/* FIXME: Only do these if necessary */
char output[16];
char input[16];
char cSuffix = "STRQ"[j];
snprintf(output, sizeof(output), "tTexPlane%c%d", cSuffix, i);
snprintf(input, sizeof(input), "texPlane%c%d", cSuffix, i);
pgraph_append_skinning_code(s, mix, count,
"vec4", output, input,
"invModelViewMat", "xyzw");
}
}
@ -200,7 +242,7 @@ static QString* generate_fixed_function(const ShaderState state,
}
/* Texgen */
for (i = 0; i < 4; i++) {
for (i = 0; i < 4 /* FIXME: NV2A_MAX_TEXTURES */; i++) {
qstring_append_fmt(s, "/* Texgen for stage %d */\n",
i);
qstring_append_fmt(s, "vec4 tTexture%d;\n",
@ -208,38 +250,58 @@ static QString* generate_fixed_function(const ShaderState state,
/* Set each component individually */
/* FIXME: could be nicer if some channels share the same texgen */
for (j = 0; j < 4; j++) {
/* TODO: TexGen View Model missing! */
char c = "xyzw"[j];
char cSuffix = "STRQ"[j];
switch (state.texgen[i][j]) {
case TEXGEN_DISABLE:
qstring_append_fmt(s,
"tTexture%d.%c = texture%d.%c;\n",
qstring_append_fmt(s, "tTexture%d.%c = texture%d.%c;\n",
i, c, i, c);
break;
case TEXGEN_EYE_LINEAR:
qstring_append_fmt(s,
"tTexture%d.%c = tPosition.%c;\n",
i, c, c);
qstring_append_fmt(s, "tTexture%d.%c = dot(tTexPlane%c%d, tPosition);\n",
i, c, cSuffix, i);
assert(false); /* Untested */
break;
case TEXGEN_OBJECT_LINEAR:
qstring_append_fmt(s,
"tTexture%d.%c = position.%c;\n",
i, c, c);
qstring_append_fmt(s, "tTexture%d.%c = dot(texPlane%c%d, position);\n",
i, c, cSuffix, i);
assert(false); /* Untested */
break;
case TEXGEN_SPHERE_MAP:
assert(i < 2); /* Channels S,T only! */
assert(false);
qstring_append(s, "{\n");
/* FIXME: u, r and m only have to be calculated once */
qstring_append(s, " vec3 u = normalize(tPosition.xyz);\n");
//FIXME: tNormal before or after normalization? Always normalize?
qstring_append(s, " vec3 r = reflect(u, tNormal);\n");
/* FIXME: This would consume 1 division fewer and *might* be
* faster than length:
* // [z=1/(2*x) => z=1/x*0.5]
* vec3 ro = r + vec3(0.0, 0.0, 1.0);
* float m = inversesqrt(dot(ro,ro))*0.5;
*/
qstring_append(s, " float invM = 1.0 / (2.0 * length(r + vec3(0.0, 0.0, 1.0)));\n");
qstring_append_fmt(s, " tTexture%d.%c = r.%c * invM + 0.5;\n",
i, c, c);
qstring_append(s, "}\n");
assert(false); /* Untested */
break;
case TEXGEN_REFLECTION_MAP:
assert(i < 3); /* Channels S,T,R only! */
qstring_append_fmt(s,
"tTexture%d.%c = reflect(???, tNormal).%c;\n",
qstring_append(s, "{\n");
/* FIXME: u and r only have to be calculated once, can share the one from SPHERE_MAP */
qstring_append(s, " vec3 u = normalize(tPosition.xyz);\n");
qstring_append(s, " vec3 r = reflect(u, tNormal);\n");
qstring_append_fmt(s, " tTexture%d.%c = r.%c;\n",
i, c, c);
assert(false); /* FIXME: Code not complete yet! */
qstring_append(s, "}\n");
break;
case TEXGEN_NORMAL_MAP:
assert(i < 3); /* Channels S,T,R only! */
qstring_append_fmt(s,
"tTexture%d.%c = tNormal.%c;\n",
qstring_append_fmt(s, "tTexture%d.%c = tNormal.%c;\n",
i, c, c);
break;
default: