AstralTransRocketries/ClassiCube
1
0
Fork 0
mirror of https://github.com/ClassiCube/ClassiCube.git synced 2025-09-18 20:15:35 -04:00
Code Issues Packages Projects Releases Wiki Activity

Implement comment state tracking for Gfx_SetAlphaBlending

Browse Source
This commit is contained in:
UnknownShadow200 2024-05-04 21:22:53 +10:00
parent fd1f6ef424
commit 3081e4b304
22 changed files with 121 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Graphics_3DS.c
View File

@ -439,7 +439,7 @@ void Gfx_SetFaceCulling(cc_bool enabled) {
void Gfx_SetAlphaArgBlend(cc_bool enabled) { }
void Gfx_SetAlphaBlending(cc_bool enabled) {
static void SetAlphaBlend(cc_bool enabled) {
if (enabled) {
C3D_AlphaBlend(GPU_BLEND_ADD, GPU_BLEND_ADD, GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA);
} else {

7
src/Graphics_D3D11.c
View File

@ -889,7 +889,7 @@ static ID3D11DepthStencilView* depthbufferView;
static ID3D11BlendState* om_blendStates[4];
static ID3D11DepthStencilState* om_depthStates[4];
static float gfx_clearColor[4];
static cc_bool gfx_alphaBlending, gfx_colorEnabled = true;
static cc_bool gfx_colorEnabled = true;
static cc_bool gfx_depthTest, gfx_depthWrite;
static void OM_Clear(GfxBuffers buffers) {
@ -980,7 +980,7 @@ static void OM_CreateBlendStates(void) {
}
static void OM_UpdateBlendState(void) {
ID3D11BlendState* blendState = om_blendStates[gfx_colorEnabled | (gfx_alphaBlending << 1)];
ID3D11BlendState* blendState = om_blendStates[gfx_colorEnabled | (gfx_alphaBlend << 1)];
ID3D11DeviceContext_OMSetBlendState(context, blendState, NULL, 0xffffffff);
}
@ -1029,8 +1029,7 @@ void Gfx_SetDepthWrite(cc_bool enabled) {
OM_UpdateDepthState();
}
void Gfx_SetAlphaBlending(cc_bool enabled) {
gfx_alphaBlending = enabled;
static void SetAlphaBlend(cc_bool enabled) {
OM_UpdateBlendState();
}

5
src/Graphics_D3D9.c
View File

@ -460,10 +460,7 @@ static void SetAlphaTest(cc_bool enabled) {
IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHATESTENABLE, enabled);
}
void Gfx_SetAlphaBlending(cc_bool enabled) {
if (gfx_alphaBlending == enabled) return;
gfx_alphaBlending = enabled;
static void SetAlphaBlend(cc_bool enabled) {
if (Gfx.LostContext) return;
IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, enabled);
}

25
src/Graphics_Dreamcast.c
View File

@ -60,7 +60,7 @@ void Gfx_Free(void) {
*#########################################################################################################################*/
static PackedCol gfx_clearColor;
void Gfx_SetFaceCulling(cc_bool enabled) { gl_Toggle(GL_CULL_FACE); }
void Gfx_SetAlphaBlending(cc_bool enabled) { gl_Toggle(GL_BLEND); }
static void SetAlphaBlend(cc_bool enabled) { gl_Toggle(GL_BLEND); }
void Gfx_SetAlphaArgBlend(cc_bool enabled) { }
void Gfx_ClearColor(PackedCol color) {
@ -353,7 +353,7 @@ static FogFunc gfx_fogMode = -1;
void Gfx_SetFog(cc_bool enabled) {
gfx_fogEnabled = enabled;
if (enabled) { glEnable(GL_FOG); } else { glDisable(GL_FOG); }
gl_Toggle(GL_FOG);
}
void Gfx_SetFogCol(PackedCol color) {
@ -372,7 +372,7 @@ static void UpdateFog(void) {
if (gfx_fogMode == FOG_LINEAR) {
pvr_fog_table_linear(0.0f, gfx_fogEnd);
} else if (gfx_fogMode == FOG_EXP) {
pvr_fog_table_exp(gfx_fogDensity);
pvr_fog_table_exp(gfx_fogDensity);
} else if (gfx_fogMode == FOG_EXP2) {
pvr_fog_table_exp2(gfx_fogDensity);
}
@ -482,17 +482,6 @@ void DrawQuads(int count) {
}
}
static void SetupVertices(int startVertex) {
if (gfx_format == VERTEX_FORMAT_TEXTURED) {
cc_uint32 offset = startVertex * SIZEOF_VERTEX_TEXTURED;
gldcVertexPointer(SIZEOF_VERTEX_TEXTURED, (void*)(VB_PTR + offset));
} else {
cc_uint32 offset = startVertex * SIZEOF_VERTEX_COLOURED;
gldcVertexPointer(SIZEOF_VERTEX_COLOURED, (void*)(VB_PTR + offset));
}
}
void Gfx_SetVertexFormat(VertexFormat fmt) {
if (fmt == gfx_format) return;
gfx_format = fmt;
@ -512,10 +501,10 @@ void Gfx_DrawVb_Lines(int verticesCount) {
void Gfx_DrawVb_IndexedTris_Range(int verticesCount, int startVertex) {
if (gfx_format == VERTEX_FORMAT_TEXTURED) {
VERTEX_PTR = gfx_vertices + startVertex * SIZEOF_VERTEX_TEXTURED;
} else {
VERTEX_PTR = gfx_vertices + startVertex * SIZEOF_VERTEX_COLOURED;
}
VERTEX_PTR = gfx_vertices + startVertex * SIZEOF_VERTEX_TEXTURED;
} else {
VERTEX_PTR = gfx_vertices + startVertex * SIZEOF_VERTEX_COLOURED;
}
DrawQuads(verticesCount);
}

2
src/Graphics_GCWii.c
View File

@ -187,7 +187,7 @@ void Gfx_SetFaceCulling(cc_bool enabled) {
GX_SetCullMode(enabled ? GX_CULL_FRONT : GX_CULL_NONE);
}
void Gfx_SetAlphaBlending(cc_bool enabled) {
static void SetAlphaBlend(cc_bool enabled) {
if (enabled) {
GX_SetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
} else {

2
src/Graphics_N64.c
View File

@ -237,7 +237,7 @@ void Gfx_DisableMipmaps(void) { }
*-----------------------------------------------------State management----------------------------------------------------*
*#########################################################################################################################*/
void Gfx_SetFaceCulling(cc_bool enabled) { gl_Toggle(GL_CULL_FACE); }
void Gfx_SetAlphaBlending(cc_bool enabled) { gl_Toggle(GL_BLEND); }
static void SetAlphaBlend(cc_bool enabled) { gl_Toggle(GL_BLEND); }
void Gfx_SetAlphaArgBlend(cc_bool enabled) { }
static void SetColorWrite(cc_bool r, cc_bool g, cc_bool b, cc_bool a) {

2
src/Graphics_NDS.c
View File

@ -176,7 +176,7 @@ void Gfx_SetFaceCulling(cc_bool enabled) {
glPolyFmt(POLY_ALPHA(31) | (enabled ? POLY_CULL_BACK : POLY_CULL_NONE));
}
void Gfx_SetAlphaBlending(cc_bool enabled) {
static void SetAlphaBlend(cc_bool enabled) {
/*if (enabled) {
glEnable(GL_BLEND);
} else {

2
src/Graphics_PS1.c
View File

@ -291,7 +291,7 @@ void Gfx_SetFaceCulling(cc_bool enabled) {
static void SetAlphaTest(cc_bool enabled) {
}
void Gfx_SetAlphaBlending(cc_bool enabled) {
static void SetAlphaBlend(cc_bool enabled) {
}
void Gfx_SetAlphaArgBlend(cc_bool enabled) { }

4
src/Graphics_PS2.c
View File

@ -243,7 +243,6 @@ void Gfx_DisableMipmaps(void) { }
*------------------------------------------------------State management---------------------------------------------------*
*#########################################################################################################################*/
static int clearR, clearG, clearB;
static cc_bool gfx_alphaBlend;
static cc_bool gfx_depthTest;
static cc_bool stateDirty;
@ -277,8 +276,7 @@ static void SetAlphaTest(cc_bool enabled) {
stateDirty = true;
}
void Gfx_SetAlphaBlending(cc_bool enabled) {
gfx_alphaBlend = enabled;
static void SetAlphaBlend(cc_bool enabled) {
// TODO update primitive state
}

2
src/Graphics_PS3.c
View File

@ -286,7 +286,7 @@ void Gfx_SetFaceCulling(cc_bool enabled) {
rsxSetCullFaceEnable(context, enabled);
}
void Gfx_SetAlphaBlending(cc_bool enabled) {
static void SetAlphaBlend(cc_bool enabled) {
rsxSetBlendEnable(context, enabled);
}
void Gfx_SetAlphaArgBlend(cc_bool enabled) { }

2
src/Graphics_PSP.c
View File

@ -163,7 +163,7 @@ void Gfx_BindTexture(GfxResourceID texId) {
*#########################################################################################################################*/
static PackedCol gfx_clearColor;
void Gfx_SetFaceCulling(cc_bool enabled) { GU_Toggle(GU_CULL_FACE); }
void Gfx_SetAlphaBlending(cc_bool enabled) { GU_Toggle(GU_BLEND); }
static void SetAlphaBlend(cc_bool enabled) { GU_Toggle(GU_BLEND); }
void Gfx_SetAlphaArgBlend(cc_bool enabled) { }
void Gfx_ClearColor(PackedCol color) {

6
src/Graphics_PSVita.c
View File

@ -8,7 +8,6 @@
// TODO track last frame used on
static cc_bool gfx_depthOnly;
static cc_bool gfx_alphaBlending;
static int frontBufferIndex, backBufferIndex;
// Inspired from
// https://github.com/xerpi/gxmfun/blob/master/source/main.c
@ -242,7 +241,7 @@ static void FP_SwitchActive(void) {
// [normal rendering, blend rendering, no rendering]
if (gfx_depthOnly) {
index += 2;
} else if (gfx_alphaBlending) {
} else if (gfx_alphaBlend) {
index += 1;
}
@ -968,8 +967,7 @@ static void SetAlphaTest(cc_bool enabled) {
FP_SwitchActive();
}
void Gfx_SetAlphaBlending(cc_bool enabled) {
gfx_alphaBlending = enabled;
static void SetAlphaBlend(cc_bool enabled) {
FP_SwitchActive();
}

2
src/Graphics_Saturn.c
View File

@ -146,7 +146,7 @@ void Gfx_SetFaceCulling(cc_bool enabled) {
static void SetAlphaTest(cc_bool enabled) {
}
void Gfx_SetAlphaBlending(cc_bool enabled) {
static void SetAlphaBlend(cc_bool enabled) {
}
void Gfx_SetAlphaArgBlend(cc_bool enabled) { }

8
src/Graphics_SoftGPU.c
View File

@ -10,8 +10,6 @@ static struct Bitmap fb_bmp;
static float vp_hwidth, vp_hheight;
static int sc_maxX, sc_maxY;
static cc_bool alphaBlending;
static PackedCol* colorBuffer;
static PackedCol clearColor;
static cc_bool colWrite = true;
@ -118,8 +116,8 @@ static void SetAlphaTest(cc_bool enabled) {
/* Uses value from Gfx_SetAlphaTest */
}
void Gfx_SetAlphaBlending(cc_bool enabled) {
alphaBlending = enabled;
static void SetAlphaBlend(cc_bool enabled) {
/* Uses value from Gfx_SetAlphaBlending */
}
void Gfx_SetAlphaArgBlend(cc_bool enabled) { }
@ -390,7 +388,7 @@ static void DrawTriangle(Vector4 frag1, Vector4 frag2, Vector4 frag3,
int B = PackedCol_B(fragColor);
int A = PackedCol_A(fragColor);
if (alphaBlending) {
if (gfx_alphaBlend) {
PackedCol dst = colorBuffer[index];
int dstR = BitmapCol_R(dst);
int dstG = BitmapCol_G(dst);

4
src/Graphics_WiiU.c
View File

@ -181,12 +181,12 @@ static void SetAlphaTest(cc_bool enabled) {
GX2SetAlphaTest(enabled, GX2_COMPARE_FUNC_GEQUAL, 0.5f);
}
void Gfx_SetAlphaBlending(cc_bool enabled) {
static void SetAlphaBlend(cc_bool enabled) {
GX2SetBlendControl(GX2_RENDER_TARGET_0,
GX2_BLEND_MODE_SRC_ALPHA, GX2_BLEND_MODE_INV_SRC_ALPHA, GX2_BLEND_COMBINE_MODE_ADD,
true,
GX2_BLEND_MODE_SRC_ALPHA, GX2_BLEND_MODE_INV_SRC_ALPHA, GX2_BLEND_COMBINE_MODE_ADD);
GX2SetColorControl(GX2_LOGIC_OP_COPY, enabled, FALSE, TRUE);
GX2SetColorControl(GX2_LOGIC_OP_COPY, enabled, FALSE, TRUE);
}
void Gfx_SetAlphaArgBlend(cc_bool enabled) {

2
src/Graphics_Xbox.c
View File

@ -299,7 +299,7 @@ void Gfx_SetFaceCulling(cc_bool enabled) {
void Gfx_SetAlphaArgBlend(cc_bool enabled) { }
void Gfx_SetAlphaBlending(cc_bool enabled) {
static void SetAlphaBlend(cc_bool enabled) {
uint32_t* p = pb_begin();
p = pb_push1(p, NV097_SET_BLEND_ENABLE, enabled);
pb_end(p);

4
src/Graphics_Xbox360.c
View File

@ -82,7 +82,7 @@ static void Gfx_FreeState(void) {
static void Gfx_RestoreState(void) {
InitDefaultResources();
Gfx_SetFaceCulling(false);
Gfx_SetAlphaBlending(false);
SetAlphaBlend(false);
Xe_SetAlphaFunc(xe, XE_CMP_GREATER);
Xe_SetAlphaRef(xe, 0.5f);
@ -159,7 +159,7 @@ static void SetAlphaTest(cc_bool enabled) {
Xe_SetAlphaTestEnable(xe, enabled);
}
void Gfx_SetAlphaBlending(cc_bool enabled) {
static void SetAlphaBlend(cc_bool enabled) {
if (enabled) {
Xe_SetBlendControl(xe,
XE_BLEND_SRCALPHA, XE_BLENDOP_ADD, XE_BLEND_INVSRCALPHA,

2
src/_GLShared.h
View File

@ -177,7 +177,7 @@ void Gfx_DisableMipmaps(void) { }
*#########################################################################################################################*/
static PackedCol gfx_clearColor;
void Gfx_SetFaceCulling(cc_bool enabled) { gl_Toggle(GL_CULL_FACE); }
void Gfx_SetAlphaBlending(cc_bool enabled) { gl_Toggle(GL_BLEND); }
static void SetAlphaBlend(cc_bool enabled) { gl_Toggle(GL_BLEND); }
void Gfx_SetAlphaArgBlend(cc_bool enabled) { }
static void GL_ClearColor(PackedCol color) {

10
src/_GraphicsBase.h
View File

@ -31,7 +31,7 @@ static float gfx_minFrameMs;
*#########################################################################################################################*/
static cc_bool gfx_colorMask[4] = { true, true, true, true };
cc_bool Gfx_GetFog(void) { return gfx_fogEnabled; }
static cc_bool gfx_alphaTest;
static cc_bool gfx_alphaTest, gfx_alphaBlend;
static void SetAlphaTest(cc_bool enabled);
void Gfx_SetAlphaTest(cc_bool enabled) {
@ -41,6 +41,14 @@ void Gfx_SetAlphaTest(cc_bool enabled) {
SetAlphaTest(enabled);
}
static void SetAlphaBlend(cc_bool enabled);
void Gfx_SetAlphaBlending(cc_bool enabled) {
if (gfx_alphaBlend == enabled) return;
gfx_alphaBlend = enabled;
SetAlphaBlend(enabled);
}
/* Initialises/Restores render state */
CC_NOINLINE static void Gfx_RestoreState(void);
/* Destroys render state, but can be restored later */

221
third_party/gldc/src/platform.h vendored
View File

@ -133,74 +133,6 @@ typedef enum GPUTextureEnv {
GPU_TXRENV_MODULATEALPHA = 3
} GPUTextureEnv;
/* Duplication of pvr_poly_cxt_t from KOS so that we can
* compile on non-KOS platforms for testing */
typedef struct {
GPUList list_type;
struct {
int alpha;
int shading;
int fog_type;
int culling;
int color_clamp;
int clip_mode;
int modifier_mode;
int specular;
int alpha2;
int fog_type2;
int color_clamp2;
} gen;
struct {
int src;
int dst;
int src_enable;
int dst_enable;
int src2;
int dst2;
int src_enable2;
int dst_enable2;
} blend;
struct {
int color;
int uv;
int modifier;
} fmt;
struct {
int comparison;
int write;
} depth;
struct {
int enable;
int filter;
int mipmap;
int mipmap_bias;
int uv_flip;
int uv_clamp;
int alpha;
int env;
int width;
int height;
int format;
void* base;
} txr;
struct {
int enable;
int filter;
int mipmap;
int mipmap_bias;
int uv_flip;
int uv_clamp;
int alpha;
int env;
int width;
int height;
int format;
void* base;
} txr2;
} PolyContext;
typedef struct {
uint32_t cmd;
uint32_t mode1;
@ -223,96 +155,6 @@ enum GPUCommand {
void SceneListSubmit(Vertex* v2, int n);
#define GPU_TA_CMD_TYPE_SHIFT 24
#define GPU_TA_CMD_TYPE_MASK (7 << GPU_TA_CMD_TYPE_SHIFT)
#define GPU_TA_CMD_USERCLIP_SHIFT 16
#define GPU_TA_CMD_USERCLIP_MASK (3 << GPU_TA_CMD_USERCLIP_SHIFT)
#define GPU_TA_CMD_CLRFMT_SHIFT 4
#define GPU_TA_CMD_CLRFMT_MASK (7 << GPU_TA_CMD_CLRFMT_SHIFT)
#define GPU_TA_CMD_SPECULAR_SHIFT 2
#define GPU_TA_CMD_SPECULAR_MASK (1 << GPU_TA_CMD_SPECULAR_SHIFT)
#define GPU_TA_CMD_SHADE_SHIFT 1
#define GPU_TA_CMD_SHADE_MASK (1 << GPU_TA_CMD_SHADE_SHIFT)
#define GPU_TA_CMD_UVFMT_SHIFT 0
#define GPU_TA_CMD_UVFMT_MASK (1 << GPU_TA_CMD_UVFMT_SHIFT)
#define GPU_TA_CMD_MODIFIER_SHIFT 7
#define GPU_TA_CMD_MODIFIER_MASK (1 << GPU_TA_CMD_MODIFIER_SHIFT)
#define GPU_TA_CMD_MODIFIERMODE_SHIFT 6
#define GPU_TA_CMD_MODIFIERMODE_MASK (1 << GPU_TA_CMD_MODIFIERMODE_SHIFT)
#define GPU_TA_PM1_DEPTHCMP_SHIFT 29
#define GPU_TA_PM1_DEPTHCMP_MASK (7 << GPU_TA_PM1_DEPTHCMP_SHIFT)
#define GPU_TA_PM1_CULLING_SHIFT 27
#define GPU_TA_PM1_CULLING_MASK (3 << GPU_TA_PM1_CULLING_SHIFT)
#define GPU_TA_PM1_DEPTHWRITE_SHIFT 26
#define GPU_TA_PM1_DEPTHWRITE_MASK (1 << GPU_TA_PM1_DEPTHWRITE_SHIFT)
#define GPU_TA_PM1_TXRENABLE_SHIFT 25
#define GPU_TA_PM1_TXRENABLE_MASK (1 << GPU_TA_PM1_TXRENABLE_SHIFT)
#define GPU_TA_PM1_MODIFIERINST_SHIFT 29
#define GPU_TA_PM1_MODIFIERINST_MASK (3 << GPU_TA_PM1_MODIFIERINST_SHIFT)
#define GPU_TA_PM2_SRCBLEND_SHIFT 29
#define GPU_TA_PM2_SRCBLEND_MASK (7 << GPU_TA_PM2_SRCBLEND_SHIFT)
#define GPU_TA_PM2_DSTBLEND_SHIFT 26
#define GPU_TA_PM2_DSTBLEND_MASK (7 << GPU_TA_PM2_DSTBLEND_SHIFT)
#define GPU_TA_PM2_SRCENABLE_SHIFT 25
#define GPU_TA_PM2_SRCENABLE_MASK (1 << GPU_TA_PM2_SRCENABLE_SHIFT)
#define GPU_TA_PM2_DSTENABLE_SHIFT 24
#define GPU_TA_PM2_DSTENABLE_MASK (1 << GPU_TA_PM2_DSTENABLE_SHIFT)
#define GPU_TA_PM2_FOG_SHIFT 22
#define GPU_TA_PM2_FOG_MASK (3 << GPU_TA_PM2_FOG_SHIFT)
#define GPU_TA_PM2_CLAMP_SHIFT 21
#define GPU_TA_PM2_CLAMP_MASK (1 << GPU_TA_PM2_CLAMP_SHIFT)
#define GPU_TA_PM2_ALPHA_SHIFT 20
#define GPU_TA_PM2_ALPHA_MASK (1 << GPU_TA_PM2_ALPHA_SHIFT)
#define GPU_TA_PM2_TXRALPHA_SHIFT 19
#define GPU_TA_PM2_TXRALPHA_MASK (1 << GPU_TA_PM2_TXRALPHA_SHIFT)
#define GPU_TA_PM2_UVFLIP_SHIFT 17
#define GPU_TA_PM2_UVFLIP_MASK (3 << GPU_TA_PM2_UVFLIP_SHIFT)
#define GPU_TA_PM2_UVCLAMP_SHIFT 15
#define GPU_TA_PM2_UVCLAMP_MASK (3 << GPU_TA_PM2_UVCLAMP_SHIFT)
#define GPU_TA_PM2_FILTER_SHIFT 12
#define GPU_TA_PM2_FILTER_MASK (7 << GPU_TA_PM2_FILTER_SHIFT)
#define GPU_TA_PM2_MIPBIAS_SHIFT 8
#define GPU_TA_PM2_MIPBIAS_MASK (15 << GPU_TA_PM2_MIPBIAS_SHIFT)
#define GPU_TA_PM2_TXRENV_SHIFT 6
#define GPU_TA_PM2_TXRENV_MASK (3 << GPU_TA_PM2_TXRENV_SHIFT)
#define GPU_TA_PM2_USIZE_SHIFT 3
#define GPU_TA_PM2_USIZE_MASK (7 << GPU_TA_PM2_USIZE_SHIFT)
#define GPU_TA_PM2_VSIZE_SHIFT 0
#define GPU_TA_PM2_VSIZE_MASK (7 << GPU_TA_PM2_VSIZE_SHIFT)
#define GPU_TA_PM3_MIPMAP_SHIFT 31
#define GPU_TA_PM3_MIPMAP_MASK (1 << GPU_TA_PM3_MIPMAP_SHIFT)
#define GPU_TA_PM3_TXRFMT_SHIFT 0
#define GPU_TA_PM3_TXRFMT_MASK 0xffffffff
static inline int DimensionFlag(const int w) {
switch(w) {
case 16: return 1;
@ -328,67 +170,4 @@ static inline int DimensionFlag(const int w) {
}
}
/* Compile a polygon context into a polygon header */
static inline void CompilePolyHeader(PolyHeader *dst, const PolyContext *src) {
uint32_t txr_base;
/* Basically we just take each parameter, clip it, shift it
into place, and OR it into the final result. */
/* The base values for CMD */
dst->cmd = GPU_CMD_POLYHDR;
dst->cmd |= src->txr.enable << 3;
/* Or in the list type, shading type, color and UV formats */
dst->cmd |= (src->list_type << GPU_TA_CMD_TYPE_SHIFT) & GPU_TA_CMD_TYPE_MASK;
dst->cmd |= (src->fmt.color << GPU_TA_CMD_CLRFMT_SHIFT) & GPU_TA_CMD_CLRFMT_MASK;
dst->cmd |= (src->gen.shading << GPU_TA_CMD_SHADE_SHIFT) & GPU_TA_CMD_SHADE_MASK;
dst->cmd |= (src->fmt.uv << GPU_TA_CMD_UVFMT_SHIFT) & GPU_TA_CMD_UVFMT_MASK;
dst->cmd |= (src->gen.clip_mode << GPU_TA_CMD_USERCLIP_SHIFT) & GPU_TA_CMD_USERCLIP_MASK;
dst->cmd |= (src->gen.specular << GPU_TA_CMD_SPECULAR_SHIFT) & GPU_TA_CMD_SPECULAR_MASK;
/* Polygon mode 1 */
dst->mode1 = (src->depth.comparison << GPU_TA_PM1_DEPTHCMP_SHIFT) & GPU_TA_PM1_DEPTHCMP_MASK;
dst->mode1 |= (src->gen.culling << GPU_TA_PM1_CULLING_SHIFT) & GPU_TA_PM1_CULLING_MASK;
dst->mode1 |= (src->depth.write << GPU_TA_PM1_DEPTHWRITE_SHIFT) & GPU_TA_PM1_DEPTHWRITE_MASK;
dst->mode1 |= (src->txr.enable << GPU_TA_PM1_TXRENABLE_SHIFT) & GPU_TA_PM1_TXRENABLE_MASK;
/* Polygon mode 2 */
dst->mode2 = (src->blend.src << GPU_TA_PM2_SRCBLEND_SHIFT) & GPU_TA_PM2_SRCBLEND_MASK;
dst->mode2 |= (src->blend.dst << GPU_TA_PM2_DSTBLEND_SHIFT) & GPU_TA_PM2_DSTBLEND_MASK;
dst->mode2 |= (src->blend.src_enable << GPU_TA_PM2_SRCENABLE_SHIFT) & GPU_TA_PM2_SRCENABLE_MASK;
dst->mode2 |= (src->blend.dst_enable << GPU_TA_PM2_DSTENABLE_SHIFT) & GPU_TA_PM2_DSTENABLE_MASK;
dst->mode2 |= (src->gen.fog_type << GPU_TA_PM2_FOG_SHIFT) & GPU_TA_PM2_FOG_MASK;
dst->mode2 |= (src->gen.color_clamp << GPU_TA_PM2_CLAMP_SHIFT) & GPU_TA_PM2_CLAMP_MASK;
dst->mode2 |= (src->gen.alpha << GPU_TA_PM2_ALPHA_SHIFT) & GPU_TA_PM2_ALPHA_MASK;
if(src->txr.enable == GPU_TEXTURE_DISABLE) {
dst->mode3 = 0;
}
else {
dst->mode2 |= (src->txr.alpha << GPU_TA_PM2_TXRALPHA_SHIFT) & GPU_TA_PM2_TXRALPHA_MASK;
dst->mode2 |= (src->txr.uv_flip << GPU_TA_PM2_UVFLIP_SHIFT) & GPU_TA_PM2_UVFLIP_MASK;
dst->mode2 |= (src->txr.uv_clamp << GPU_TA_PM2_UVCLAMP_SHIFT) & GPU_TA_PM2_UVCLAMP_MASK;
dst->mode2 |= (src->txr.filter << GPU_TA_PM2_FILTER_SHIFT) & GPU_TA_PM2_FILTER_MASK;
dst->mode2 |= (src->txr.mipmap_bias << GPU_TA_PM2_MIPBIAS_SHIFT) & GPU_TA_PM2_MIPBIAS_MASK;
dst->mode2 |= (src->txr.env << GPU_TA_PM2_TXRENV_SHIFT) & GPU_TA_PM2_TXRENV_MASK;
dst->mode2 |= (DimensionFlag(src->txr.width) << GPU_TA_PM2_USIZE_SHIFT) & GPU_TA_PM2_USIZE_MASK;
dst->mode2 |= (DimensionFlag(src->txr.height) << GPU_TA_PM2_VSIZE_SHIFT) & GPU_TA_PM2_VSIZE_MASK;
/* Polygon mode 3 */
dst->mode3 = (src->txr.mipmap << GPU_TA_PM3_MIPMAP_SHIFT) & GPU_TA_PM3_MIPMAP_MASK;
dst->mode3 |= (src->txr.format << GPU_TA_PM3_TXRFMT_SHIFT) & GPU_TA_PM3_TXRFMT_MASK;
/* Convert the texture address */
txr_base = (uint32_t) src->txr.base;
txr_base = (txr_base & 0x00fffff8) >> 3;
dst->mode3 |= txr_base;
}
dst->d1 = dst->d2 = 0xffffffff;
dst->d3 = dst->d4 = 0xffffffff;
}
#include "sh4.h"

5
third_party/gldc/src/private.h vendored
View File

@ -40,11 +40,6 @@ typedef struct {
} PolyList;
typedef struct {
GLint x;
GLint y;
GLint width;
GLint height;
float x_plus_hwidth;
float y_plus_hheight;
float hwidth; /* width * 0.5f */

148
third_party/gldc/src/state.c vendored
View File

@ -264,85 +264,99 @@ void APIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
}
GL_FORCE_INLINE void _updatePVRTextureContext(PolyContext *context, GLshort textureUnit) {
void apply_poly_header(PolyHeader* dst, PolyList* activePolyList) {
const TextureObject *tx1 = TEXTURE_ACTIVE;
/* Disable all texturing to start with */
context->txr.enable = GPU_TEXTURE_DISABLE;
context->txr2.enable = GPU_TEXTURE_DISABLE;
context->txr2.alpha = GPU_TXRALPHA_DISABLE;
if(!TEXTURES_ENABLED || !tx1 || !tx1->data) {
context->txr.base = NULL;
return;
}
context->txr.alpha = (BLEND_ENABLED || ALPHA_TEST_ENABLED) ? GPU_TXRALPHA_ENABLE : GPU_TXRALPHA_DISABLE;
GLuint filter = GPU_FILTER_NEAREST;
if(tx1->minFilter == GL_LINEAR && tx1->magFilter == GL_LINEAR) {
filter = GPU_FILTER_BILINEAR;
}
if(tx1->data) {
context->txr.enable = GPU_TEXTURE_ENABLE;
context->txr.filter = filter;
context->txr.width = tx1->width;
context->txr.height = tx1->height;
context->txr.mipmap = GL_FALSE;
context->txr.mipmap_bias = tx1->mipmap_bias;
context->txr.base = tx1->data;
context->txr.format = tx1->color;
context->txr.env = tx1->env;
context->txr.uv_flip = GPU_UVFLIP_NONE;
context->txr.uv_clamp = GPU_UVCLAMP_NONE;
}
}
void apply_poly_header(PolyHeader* header, PolyList* activePolyList) {
uint32_t txr_base;
TRACE();
// Compile the header
PolyContext ctx;
memset(&ctx, 0, sizeof(PolyContext));
int list_type = activePolyList->list_type;
int gen_color_clamp = GPU_CLRCLAMP_DISABLE;
ctx.list_type = activePolyList->list_type;
ctx.fmt.color = GPU_CLRFMT_ARGBPACKED;
ctx.fmt.uv = GPU_UVFMT_32BIT;
ctx.gen.color_clamp = GPU_CLRCLAMP_DISABLE;
int gen_culling = CULLING_ENABLED ? GPU_CULLING_CW : GPU_CULLING_SMALL;
int depth_comp = DEPTH_TEST_ENABLED ? GPU_DEPTHCMP_GEQUAL : GPU_DEPTHCMP_ALWAYS;
int depth_write = DEPTH_MASK_ENABLED ? GPU_DEPTHWRITE_ENABLE : GPU_DEPTHWRITE_DISABLE;
ctx.gen.culling = CULLING_ENABLED ? GPU_CULLING_CW : GPU_CULLING_SMALL;
ctx.depth.comparison = DEPTH_TEST_ENABLED ? GPU_DEPTHCMP_GEQUAL : GPU_DEPTHCMP_ALWAYS;
ctx.depth.write = DEPTH_MASK_ENABLED ? GPU_DEPTHWRITE_ENABLE : GPU_DEPTHWRITE_DISABLE;
int gen_shading = (SHADE_MODEL == GL_SMOOTH) ? GPU_SHADE_GOURAUD : GPU_SHADE_FLAT;
int gen_clip_mode = SCISSOR_TEST_ENABLED ? GPU_USERCLIP_INSIDE : GPU_USERCLIP_DISABLE;
int gen_fog_type = FOG_ENABLED ? GPU_FOG_TABLE : GPU_FOG_DISABLE;
ctx.gen.shading = (SHADE_MODEL == GL_SMOOTH) ? GPU_SHADE_GOURAUD : GPU_SHADE_FLAT;
ctx.gen.clip_mode = SCISSOR_TEST_ENABLED ? GPU_USERCLIP_INSIDE : GPU_USERCLIP_DISABLE;
ctx.gen.fog_type = FOG_ENABLED ? GPU_FOG_TABLE : GPU_FOG_DISABLE;
int gen_alpha = (BLEND_ENABLED || ALPHA_TEST_ENABLED) ? GPU_ALPHA_ENABLE : GPU_ALPHA_DISABLE;
int blend_src = PVR_BLEND_SRCALPHA;
int blend_dst = PVR_BLEND_INVSRCALPHA;
ctx.gen.alpha = (BLEND_ENABLED || ALPHA_TEST_ENABLED) ? GPU_ALPHA_ENABLE : GPU_ALPHA_DISABLE;
ctx.blend.src = PVR_BLEND_SRCALPHA;
ctx.blend.dst = PVR_BLEND_INVSRCALPHA;
if(ctx.list_type == GPU_LIST_OP_POLY) {
if (list_type == GPU_LIST_OP_POLY) {
/* Opaque polys are always one/zero */
ctx.blend.src = PVR_BLEND_ONE;
ctx.blend.dst = PVR_BLEND_ZERO;
} else if(ctx.list_type == GPU_LIST_PT_POLY) {
blend_src = PVR_BLEND_ONE;
blend_dst = PVR_BLEND_ZERO;
} else if (list_type == GPU_LIST_PT_POLY) {
/* Punch-through polys require fixed blending and depth modes */
ctx.blend.src = PVR_BLEND_SRCALPHA;
ctx.blend.dst = PVR_BLEND_INVSRCALPHA;
ctx.depth.comparison = GPU_DEPTHCMP_LEQUAL;
} else if(ctx.list_type == GPU_LIST_TR_POLY && AUTOSORT_ENABLED) {
blend_src = PVR_BLEND_SRCALPHA;
blend_dst = PVR_BLEND_INVSRCALPHA;
depth_comp = GPU_DEPTHCMP_LEQUAL;
} else if (list_type == GPU_LIST_TR_POLY && AUTOSORT_ENABLED) {
/* Autosort mode requires this mode for transparent polys */
ctx.depth.comparison = GPU_DEPTHCMP_GEQUAL;
depth_comp = GPU_DEPTHCMP_GEQUAL;
}
_updatePVRTextureContext(&ctx, 0);
CompilePolyHeader(header, &ctx);
int txr_enable, txr_alpha;
if (!TEXTURES_ENABLED || !tx1 || !tx1->data) {
/* Disable all texturing to start with */
txr_enable = GPU_TEXTURE_DISABLE;
} else {
txr_alpha = (BLEND_ENABLED || ALPHA_TEST_ENABLED) ? GPU_TXRALPHA_ENABLE : GPU_TXRALPHA_DISABLE;
txr_enable = GPU_TEXTURE_ENABLE;
}
/* The base values for CMD */
dst->cmd = GPU_CMD_POLYHDR;
dst->cmd |= txr_enable << 3;
/* Force bits 18 and 19 on to switch to 6 triangle strips */
header->cmd |= 0xC0000;
dst->cmd |= 0xC0000;
/* Or in the list type, shading type, color and UV formats */
dst->cmd |= (list_type << PVR_TA_CMD_TYPE_SHIFT) & PVR_TA_CMD_TYPE_MASK;
dst->cmd |= (GPU_CLRFMT_ARGBPACKED << PVR_TA_CMD_CLRFMT_SHIFT) & PVR_TA_CMD_CLRFMT_MASK;
dst->cmd |= (gen_shading << PVR_TA_CMD_SHADE_SHIFT) & PVR_TA_CMD_SHADE_MASK;
dst->cmd |= (GPU_UVFMT_32BIT << PVR_TA_CMD_UVFMT_SHIFT) & PVR_TA_CMD_UVFMT_MASK;
dst->cmd |= (gen_clip_mode << PVR_TA_CMD_USERCLIP_SHIFT) & PVR_TA_CMD_USERCLIP_MASK;
/* Polygon mode 1 */
dst->mode1 = (depth_comp << PVR_TA_PM1_DEPTHCMP_SHIFT) & PVR_TA_PM1_DEPTHCMP_MASK;
dst->mode1 |= (gen_culling << PVR_TA_PM1_CULLING_SHIFT) & PVR_TA_PM1_CULLING_MASK;
dst->mode1 |= (depth_write << PVR_TA_PM1_DEPTHWRITE_SHIFT) & PVR_TA_PM1_DEPTHWRITE_MASK;
dst->mode1 |= (txr_enable << PVR_TA_PM1_TXRENABLE_SHIFT) & PVR_TA_PM1_TXRENABLE_MASK;
/* Polygon mode 2 */
dst->mode2 = (blend_src << PVR_TA_PM2_SRCBLEND_SHIFT) & PVR_TA_PM2_SRCBLEND_MASK;
dst->mode2 |= (blend_dst << PVR_TA_PM2_DSTBLEND_SHIFT) & PVR_TA_PM2_DSTBLEND_MASK;
dst->mode2 |= (gen_fog_type << PVR_TA_PM2_FOG_SHIFT) & PVR_TA_PM2_FOG_MASK;
dst->mode2 |= (gen_color_clamp << PVR_TA_PM2_CLAMP_SHIFT) & PVR_TA_PM2_CLAMP_MASK;
dst->mode2 |= (gen_alpha << PVR_TA_PM2_ALPHA_SHIFT) & PVR_TA_PM2_ALPHA_MASK;
if (txr_enable == GPU_TEXTURE_DISABLE) {
dst->mode3 = 0;
} else {
GLuint filter = GPU_FILTER_NEAREST;
if (tx1->minFilter == GL_LINEAR && tx1->magFilter == GL_LINEAR) filter = GPU_FILTER_BILINEAR;
dst->mode2 |= (txr_alpha << PVR_TA_PM2_TXRALPHA_SHIFT) & PVR_TA_PM2_TXRALPHA_MASK;
dst->mode2 |= (filter << PVR_TA_PM2_FILTER_SHIFT) & PVR_TA_PM2_FILTER_MASK;
dst->mode2 |= (tx1->mipmap_bias << PVR_TA_PM2_MIPBIAS_SHIFT) & PVR_TA_PM2_MIPBIAS_MASK;
dst->mode2 |= (tx1->env << PVR_TA_PM2_TXRENV_SHIFT) & PVR_TA_PM2_TXRENV_MASK;
dst->mode2 |= (DimensionFlag(tx1->width) << PVR_TA_PM2_USIZE_SHIFT) & PVR_TA_PM2_USIZE_MASK;
dst->mode2 |= (DimensionFlag(tx1->height) << PVR_TA_PM2_VSIZE_SHIFT) & PVR_TA_PM2_VSIZE_MASK;
/* Polygon mode 3 */
dst->mode3 = (GL_FALSE << PVR_TA_PM3_MIPMAP_SHIFT) & PVR_TA_PM3_MIPMAP_MASK;
dst->mode3 |= (tx1->color << PVR_TA_PM3_TXRFMT_SHIFT) & PVR_TA_PM3_TXRFMT_MASK;
/* Convert the texture address */
txr_base = (uint32_t)tx1->data;
txr_base = (txr_base & 0x00fffff8) >> 3;
dst->mode3 |= txr_base;
}
dst->d1 = dst->d2 = 0xffffffff;
dst->d3 = dst->d4 = 0xffffffff;
}