Compare commits
No commits in common. "master" and "v1.4.0" have entirely different histories.
1
.gitignore
vendored
1
.gitignore
vendored
@ -1,4 +1,3 @@
|
||||
.*/
|
||||
*~
|
||||
*.3dsx
|
||||
*.elf
|
||||
|
||||
10
Makefile
10
Makefile
@ -9,8 +9,8 @@ endif
|
||||
include $(DEVKITARM)/3ds_rules
|
||||
|
||||
export CITRO3D_MAJOR := 1
|
||||
export CITRO3D_MINOR := 7
|
||||
export CITRO3D_PATCH := 1
|
||||
export CITRO3D_MINOR := 4
|
||||
export CITRO3D_PATCH := 0
|
||||
|
||||
VERSION := $(CITRO3D_MAJOR).$(CITRO3D_MINOR).$(CITRO3D_PATCH)
|
||||
|
||||
@ -31,11 +31,11 @@ INCLUDES := include
|
||||
#---------------------------------------------------------------------------------
|
||||
ARCH := -march=armv6k -mtune=mpcore -mfloat-abi=hard -mtp=soft
|
||||
|
||||
CFLAGS := -g -Wall -Wno-sizeof-array-div -Werror -mword-relocations \
|
||||
CFLAGS := -g -Wall -Werror -mword-relocations \
|
||||
-ffunction-sections -fdata-sections \
|
||||
$(ARCH) $(BUILD_CFLAGS)
|
||||
|
||||
CFLAGS += $(INCLUDE) -D__3DS__ -DCITRO3D_BUILD
|
||||
CFLAGS += $(INCLUDE) -DARM11 -D_3DS -DCITRO3D_BUILD
|
||||
|
||||
CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions -std=gnu++11
|
||||
|
||||
@ -114,7 +114,7 @@ debug:
|
||||
|
||||
lib/libcitro3d.a : lib release $(SOURCES) $(INCLUDES)
|
||||
@$(MAKE) BUILD=release OUTPUT=$(CURDIR)/$@ \
|
||||
BUILD_CFLAGS="-DNDEBUG=1 -O2 -fomit-frame-pointer -fno-math-errno" \
|
||||
BUILD_CFLAGS="-DNDEBUG=1 -O2 -fomit-frame-pointer" \
|
||||
DEPSDIR=$(CURDIR)/release \
|
||||
--no-print-directory -C release \
|
||||
-f $(CURDIR)/Makefile
|
||||
|
||||
@ -11,6 +11,7 @@ enum
|
||||
};
|
||||
|
||||
bool C3D_Init(size_t cmdBufSize);
|
||||
void C3D_FlushAsync(void);
|
||||
void C3D_Fini(void);
|
||||
|
||||
float C3D_GetCmdBufUsage(void);
|
||||
@ -33,6 +34,23 @@ static inline void C3D_ImmDrawRestartPrim(void)
|
||||
GPUCMD_AddWrite(GPUREG_RESTART_PRIMITIVE, 1);
|
||||
}
|
||||
|
||||
static inline void C3D_FlushAwait(void)
|
||||
{
|
||||
gspWaitForP3D();
|
||||
}
|
||||
|
||||
static inline void C3D_Flush(void)
|
||||
{
|
||||
C3D_FlushAsync();
|
||||
C3D_FlushAwait();
|
||||
}
|
||||
|
||||
static inline void C3D_VideoSync(void)
|
||||
{
|
||||
gspWaitForEvent(GSPGPU_EVENT_VBlank0, false);
|
||||
gfxSwapBuffersGpu();
|
||||
}
|
||||
|
||||
// Fixed vertex attributes
|
||||
C3D_FVec* C3D_FixedAttribGetWritePtr(int id);
|
||||
|
||||
|
||||
@ -7,12 +7,6 @@ typedef struct
|
||||
u32 data[128];
|
||||
} C3D_FogLut;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
u32 diff[8];
|
||||
u32 color[8];
|
||||
} C3D_GasLut;
|
||||
|
||||
static inline float FogLut_CalcZ(float depth, float near, float far)
|
||||
{
|
||||
return far*near/(depth*(far-near)+near);
|
||||
@ -24,16 +18,3 @@ void FogLut_Exp(C3D_FogLut* lut, float density, float gradient, float near, floa
|
||||
void C3D_FogGasMode(GPU_FOGMODE fogMode, GPU_GASMODE gasMode, bool zFlip);
|
||||
void C3D_FogColor(u32 color);
|
||||
void C3D_FogLutBind(C3D_FogLut* lut);
|
||||
|
||||
void GasLut_FromArray(C3D_GasLut* lut, const u32 data[9]);
|
||||
|
||||
void C3D_GasBeginAcc(void);
|
||||
void C3D_GasDeltaZ(float value);
|
||||
|
||||
void C3D_GasAccMax(float value);
|
||||
void C3D_GasAttn(float value);
|
||||
void C3D_GasLightPlanar(float min, float max, float attn);
|
||||
void C3D_GasLightView(float min, float max, float attn);
|
||||
void C3D_GasLightDirection(float dotp);
|
||||
void C3D_GasLutInput(GPU_GASLUTINPUT input);
|
||||
void C3D_GasLutBind(C3D_GasLut* lut);
|
||||
|
||||
@ -77,14 +77,6 @@ enum
|
||||
void C3D_LightEnvFresnel(C3D_LightEnv* env, GPU_FRESNELSEL selector);
|
||||
void C3D_LightEnvBumpMode(C3D_LightEnv* env, GPU_BUMPMODE mode);
|
||||
void C3D_LightEnvBumpSel(C3D_LightEnv* env, int texUnit);
|
||||
|
||||
/**
|
||||
* @brief Configures whether to use the z component of the normal map.
|
||||
* @param[out] env Pointer to light environment structure.
|
||||
* @param[in] enable false if the z component is reconstructed from the xy components
|
||||
* of the normal map, true if the z component is taken from the normal map.
|
||||
*/
|
||||
void C3D_LightEnvBumpNormalZ(C3D_LightEnv *env, bool enable);
|
||||
void C3D_LightEnvShadowMode(C3D_LightEnv* env, u32 mode);
|
||||
void C3D_LightEnvShadowSel(C3D_LightEnv* env, int texUnit);
|
||||
void C3D_LightEnvClampHighlights(C3D_LightEnv* env, bool clamp);
|
||||
|
||||
@ -13,12 +13,7 @@
|
||||
* The one true circumference-to-radius ratio.
|
||||
* See http://tauday.com/tau-manifesto
|
||||
*/
|
||||
#define M_TAU (6.28318530717958647692528676655900576)
|
||||
|
||||
// Define the legacy circle constant as well
|
||||
#ifndef M_PI
|
||||
#define M_PI (M_TAU/2)
|
||||
#endif
|
||||
#define M_TAU (2*M_PI)
|
||||
|
||||
/**
|
||||
* @brief Convert an angle from revolutions to radians
|
||||
|
||||
@ -14,7 +14,9 @@ struct C3D_RenderTarget_tag
|
||||
bool linked;
|
||||
gfxScreen_t screen;
|
||||
gfx3dSide_t side;
|
||||
C3D_ClearBits clearBits;
|
||||
u32 transferFlags;
|
||||
u32 clearColor, clearDepth;
|
||||
};
|
||||
|
||||
// Flags for C3D_FrameBegin
|
||||
@ -62,18 +64,18 @@ public:
|
||||
C3D_RenderTarget* C3D_RenderTargetCreate(int width, int height, GPU_COLORBUF colorFmt, C3D_DEPTHTYPE depthFmt);
|
||||
C3D_RenderTarget* C3D_RenderTargetCreateFromTex(C3D_Tex* tex, GPU_TEXFACE face, int level, C3D_DEPTHTYPE depthFmt);
|
||||
void C3D_RenderTargetDelete(C3D_RenderTarget* target);
|
||||
C3D_DEPRECATED void C3D_RenderTargetSetClear(C3D_RenderTarget* target, C3D_ClearBits clearBits, u32 clearColor, u32 clearDepth);
|
||||
void C3D_RenderTargetSetOutput(C3D_RenderTarget* target, gfxScreen_t screen, gfx3dSide_t side, u32 transferFlags);
|
||||
|
||||
static inline void C3D_RenderTargetDetachOutput(C3D_RenderTarget* target)
|
||||
{
|
||||
C3D_RenderTargetSetOutput(NULL, target->screen, target->side, 0);
|
||||
}
|
||||
|
||||
static inline void C3D_RenderTargetClear(C3D_RenderTarget* target, C3D_ClearBits clearBits, u32 clearColor, u32 clearDepth)
|
||||
{
|
||||
C3D_FrameBufClear(&target->frameBuf, clearBits, clearColor, clearDepth);
|
||||
}
|
||||
|
||||
C3D_DEPRECATED void C3D_SafeDisplayTransfer(u32* inadr, u32 indim, u32* outadr, u32 outdim, u32 flags);
|
||||
C3D_DEPRECATED void C3D_SafeTextureCopy(u32* inadr, u32 indim, u32* outadr, u32 outdim, u32 size, u32 flags);
|
||||
C3D_DEPRECATED void C3D_SafeMemoryFill(u32* buf0a, u32 buf0v, u32* buf0e, u16 control0, u32* buf1a, u32 buf1v, u32* buf1e, u16 control1);
|
||||
|
||||
void C3D_SyncDisplayTransfer(u32* inadr, u32 indim, u32* outadr, u32 outdim, u32 flags);
|
||||
void C3D_SyncTextureCopy(u32* inadr, u32 indim, u32* outadr, u32 outdim, u32 size, u32 flags);
|
||||
void C3D_SyncMemoryFill(u32* buf0a, u32 buf0v, u32* buf0e, u16 control0, u32* buf1a, u32 buf1v, u32* buf1e, u16 control1);
|
||||
|
||||
@ -46,6 +46,11 @@ static inline void C3D_TexEnvInit(C3D_TexEnv* env)
|
||||
#define _C3D_DEFAULT(x)
|
||||
#endif
|
||||
|
||||
C3D_DEPRECATED static inline void TexEnv_Init(C3D_TexEnv* env)
|
||||
{
|
||||
C3D_TexEnvInit(env);
|
||||
}
|
||||
|
||||
static inline void C3D_TexEnvSrc(C3D_TexEnv* env, C3D_TexEnvMode mode,
|
||||
GPU_TEVSRC s1,
|
||||
GPU_TEVSRC s2 _C3D_DEFAULT(GPU_PRIMARY_COLOR),
|
||||
@ -58,6 +63,15 @@ static inline void C3D_TexEnvSrc(C3D_TexEnv* env, C3D_TexEnvMode mode,
|
||||
env->srcAlpha = param;
|
||||
}
|
||||
|
||||
C3D_DEPRECATED static inline void C3D_TexEnvOp(C3D_TexEnv* env, C3D_TexEnvMode mode, int o1, int o2, int o3)
|
||||
{
|
||||
int param = GPU_TEVOPERANDS(o1, o2, o3);
|
||||
if ((int)mode & C3D_RGB)
|
||||
env->opRgb = param;
|
||||
if ((int)mode & C3D_Alpha)
|
||||
env->opAlpha = param;
|
||||
}
|
||||
|
||||
static inline void C3D_TexEnvOpRgb(C3D_TexEnv* env,
|
||||
GPU_TEVOP_RGB o1,
|
||||
GPU_TEVOP_RGB o2 _C3D_DEFAULT(GPU_TEVOP_RGB_SRC_COLOR),
|
||||
|
||||
@ -41,7 +41,7 @@ typedef struct
|
||||
};
|
||||
} C3D_Tex;
|
||||
|
||||
typedef struct CTR_ALIGN(8)
|
||||
typedef struct ALIGN(8)
|
||||
{
|
||||
u16 width;
|
||||
u16 height;
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
#pragma once
|
||||
#if defined(__3DS__) || defined(_3DS)
|
||||
#ifdef _3DS
|
||||
#include <3ds.h>
|
||||
#else
|
||||
#include <stdbool.h>
|
||||
|
||||
@ -38,7 +38,7 @@ extern "C" {
|
||||
#endif
|
||||
|
||||
/** @brief Subtexture
|
||||
* @note If top < bottom, the subtexture is rotated 1/4 revolution counter-clockwise
|
||||
* @note If top > bottom, the subtexture is rotated 1/4 revolution counter-clockwise
|
||||
*/
|
||||
typedef struct Tex3DS_SubTexture
|
||||
{
|
||||
|
||||
@ -8,6 +8,14 @@ C3D_Context __C3D_Context;
|
||||
|
||||
static aptHookCookie hookCookie;
|
||||
|
||||
__attribute__((weak)) void C3Di_RenderQueueWaitDone(void)
|
||||
{
|
||||
}
|
||||
|
||||
__attribute__((weak)) void C3Di_RenderQueueExit(void)
|
||||
{
|
||||
}
|
||||
|
||||
__attribute__((weak)) void C3Di_LightEnvUpdate(C3D_LightEnv* env)
|
||||
{
|
||||
(void)env;
|
||||
@ -28,11 +36,6 @@ __attribute__((weak)) void C3Di_ProcTexDirty(C3D_Context* ctx)
|
||||
(void)ctx;
|
||||
}
|
||||
|
||||
__attribute__((weak)) void C3Di_GasUpdate(C3D_Context* ctx)
|
||||
{
|
||||
(void)ctx;
|
||||
}
|
||||
|
||||
static void C3Di_AptEventHook(APT_HookType hookType, C3D_UNUSED void* param)
|
||||
{
|
||||
C3D_Context* ctx = C3Di_GetContext();
|
||||
@ -42,27 +45,22 @@ static void C3Di_AptEventHook(APT_HookType hookType, C3D_UNUSED void* param)
|
||||
case APTHOOK_ONSUSPEND:
|
||||
{
|
||||
C3Di_RenderQueueWaitDone();
|
||||
C3Di_RenderQueueDisableVBlank();
|
||||
break;
|
||||
}
|
||||
case APTHOOK_ONRESTORE:
|
||||
{
|
||||
C3Di_RenderQueueEnableVBlank();
|
||||
ctx->flags |= C3DiF_AttrInfo | C3DiF_BufInfo | C3DiF_Effect | C3DiF_FrameBuf
|
||||
| C3DiF_Viewport | C3DiF_Scissor | C3DiF_Program | C3DiF_VshCode | C3DiF_GshCode
|
||||
| C3DiF_TexAll | C3DiF_TexEnvBuf | C3DiF_TexEnvAll | C3DiF_LightEnv | C3DiF_Gas;
|
||||
| C3DiF_TexAll | C3DiF_TexEnvBuf | C3DiF_TexEnvAll | C3DiF_LightEnv;
|
||||
|
||||
C3Di_DirtyUniforms(GPU_VERTEX_SHADER);
|
||||
C3Di_DirtyUniforms(GPU_GEOMETRY_SHADER);
|
||||
|
||||
ctx->fixedAttribDirty |= ctx->fixedAttribEverDirty;
|
||||
ctx->gasFlags |= C3DiG_BeginAcc | C3DiG_AccStage | C3DiG_RenderStage;
|
||||
|
||||
C3D_LightEnv* env = ctx->lightEnv;
|
||||
if (ctx->fogLut)
|
||||
ctx->flags |= C3DiF_FogLut;
|
||||
if (ctx->gasLut)
|
||||
ctx->flags |= C3DiF_GasLut;
|
||||
if (env)
|
||||
C3Di_LightEnvDirty(env);
|
||||
C3Di_ProcTexDirty(ctx);
|
||||
@ -96,6 +94,10 @@ bool C3D_Init(size_t cmdBufSize)
|
||||
return false;
|
||||
}
|
||||
|
||||
GPUCMD_SetBuffer(ctx->cmdBuf, ctx->cmdBufSize, 0);
|
||||
GX_BindQueue(&ctx->gxQueue);
|
||||
gxCmdQueueRun(&ctx->gxQueue);
|
||||
|
||||
ctx->flags = C3DiF_Active | C3DiF_TexEnvBuf | C3DiF_TexEnvAll | C3DiF_Effect | C3DiF_TexStatus | C3DiF_TexAll;
|
||||
|
||||
// TODO: replace with direct struct access
|
||||
@ -127,7 +129,6 @@ bool C3D_Init(size_t cmdBufSize)
|
||||
ctx->fixedAttribDirty = 0;
|
||||
ctx->fixedAttribEverDirty = 0;
|
||||
|
||||
C3Di_RenderQueueInit();
|
||||
aptHook(&hookCookie, C3Di_AptEventHook, NULL);
|
||||
|
||||
return true;
|
||||
@ -160,6 +161,12 @@ void C3Di_UpdateContext(void)
|
||||
int i;
|
||||
C3D_Context* ctx = C3Di_GetContext();
|
||||
|
||||
if (ctx->flags & C3DiF_Program)
|
||||
{
|
||||
shaderProgramConfigure(ctx->program, (ctx->flags & C3DiF_VshCode) != 0, (ctx->flags & C3DiF_GshCode) != 0);
|
||||
ctx->flags &= ~(C3DiF_Program | C3DiF_VshCode | C3DiF_GshCode);
|
||||
}
|
||||
|
||||
if (ctx->flags & C3DiF_FrameBuf)
|
||||
{
|
||||
ctx->flags &= ~C3DiF_FrameBuf;
|
||||
@ -185,12 +192,6 @@ void C3Di_UpdateContext(void)
|
||||
GPUCMD_AddIncrementalWrites(GPUREG_SCISSORTEST_MODE, ctx->scissor, 3);
|
||||
}
|
||||
|
||||
if (ctx->flags & C3DiF_Program)
|
||||
{
|
||||
shaderProgramConfigure(ctx->program, (ctx->flags & C3DiF_VshCode) != 0, (ctx->flags & C3DiF_GshCode) != 0);
|
||||
ctx->flags &= ~(C3DiF_Program | C3DiF_VshCode | C3DiF_GshCode);
|
||||
}
|
||||
|
||||
if (ctx->flags & C3DiF_AttrInfo)
|
||||
{
|
||||
ctx->flags &= ~C3DiF_AttrInfo;
|
||||
@ -232,14 +233,9 @@ void C3Di_UpdateContext(void)
|
||||
if (ctx->flags & C3DiF_TexStatus)
|
||||
{
|
||||
ctx->flags &= ~C3DiF_TexStatus;
|
||||
GPUCMD_AddMaskedWrite(GPUREG_TEXUNIT_CONFIG, 0xB, ctx->texConfig);
|
||||
// Clear texture cache if requested *after* configuring texture units
|
||||
if (ctx->texConfig & BIT(16))
|
||||
{
|
||||
ctx->texConfig &= ~BIT(16);
|
||||
GPUCMD_AddMaskedWrite(GPUREG_TEXUNIT_CONFIG, 0x4, BIT(16));
|
||||
}
|
||||
GPUCMD_AddWrite(GPUREG_TEXUNIT_CONFIG, ctx->texConfig);
|
||||
GPUCMD_AddWrite(GPUREG_TEXUNIT0_SHADOW, ctx->texShadow);
|
||||
ctx->texConfig &= ~BIT(16); // Remove clear-texture-cache flag
|
||||
}
|
||||
|
||||
if (ctx->flags & (C3DiF_ProcTex | C3DiF_ProcTexColorLut | C3DiF_ProcTexLutAll))
|
||||
@ -253,7 +249,7 @@ void C3Di_UpdateContext(void)
|
||||
GPUCMD_AddWrite(GPUREG_FOG_COLOR, ctx->fogClr);
|
||||
}
|
||||
|
||||
if ((ctx->flags & C3DiF_FogLut) && (ctx->texEnvBuf&7) != GPU_NO_FOG)
|
||||
if (ctx->flags & C3DiF_FogLut)
|
||||
{
|
||||
ctx->flags &= ~C3DiF_FogLut;
|
||||
if (ctx->fogLut)
|
||||
@ -263,9 +259,6 @@ void C3Di_UpdateContext(void)
|
||||
}
|
||||
}
|
||||
|
||||
if ((ctx->texEnvBuf&7) == GPU_GAS)
|
||||
C3Di_GasUpdate(ctx);
|
||||
|
||||
if (ctx->flags & C3DiF_TexEnvAll)
|
||||
{
|
||||
for (i = 0; i < 6; i ++)
|
||||
@ -327,6 +320,25 @@ bool C3Di_SplitFrame(u32** pBuf, u32* pSize)
|
||||
return true;
|
||||
}
|
||||
|
||||
void C3D_FlushAsync(void)
|
||||
{
|
||||
C3D_Context* ctx = C3Di_GetContext();
|
||||
|
||||
if (!(ctx->flags & C3DiF_Active))
|
||||
return;
|
||||
|
||||
u32* cmdBuf;
|
||||
u32 cmdBufSize;
|
||||
C3Di_SplitFrame(&cmdBuf, &cmdBufSize);
|
||||
GPUCMD_SetBuffer(ctx->cmdBuf, ctx->cmdBufSize, 0);
|
||||
|
||||
//take advantage of GX_FlushCacheRegions to flush gsp heap
|
||||
extern u32 __ctru_linear_heap;
|
||||
extern u32 __ctru_linear_heap_size;
|
||||
GX_FlushCacheRegions(cmdBuf, cmdBufSize*4, (u32 *) __ctru_linear_heap, __ctru_linear_heap_size, NULL, 0);
|
||||
GX_ProcessCommandList(cmdBuf, cmdBufSize*4, 0x0);
|
||||
}
|
||||
|
||||
float C3D_GetCmdBufUsage(void)
|
||||
{
|
||||
return C3Di_GetContext()->cmdBufUsage;
|
||||
@ -339,8 +351,11 @@ void C3D_Fini(void)
|
||||
if (!(ctx->flags & C3DiF_Active))
|
||||
return;
|
||||
|
||||
aptUnhook(&hookCookie);
|
||||
C3Di_RenderQueueExit();
|
||||
aptUnhook(&hookCookie);
|
||||
gxCmdQueueStop(&ctx->gxQueue);
|
||||
gxCmdQueueWait(&ctx->gxQueue, -1);
|
||||
GX_BindQueue(NULL);
|
||||
free(ctx->gxQueue.entries);
|
||||
linearFree(ctx->cmdBuf);
|
||||
ctx->flags = 0;
|
||||
|
||||
@ -93,7 +93,6 @@ void C3Di_EffectBind(C3D_Effect* e)
|
||||
GPUCMD_AddWrite(GPUREG_FACECULLING_CONFIG, e->cullMode & 0x3);
|
||||
GPUCMD_AddIncrementalWrites(GPUREG_DEPTHMAP_SCALE, (u32*)&e->zScale, 2);
|
||||
GPUCMD_AddIncrementalWrites(GPUREG_FRAGOP_ALPHA_TEST, (u32*)&e->alphaTest, 4);
|
||||
GPUCMD_AddMaskedWrite(GPUREG_GAS_DELTAZ_DEPTH, 0x8, (u32)GPU_MAKEGASDEPTHFUNC((e->depthTest>>4)&7) << 24);
|
||||
GPUCMD_AddWrite(GPUREG_BLEND_COLOR, e->blendClr);
|
||||
GPUCMD_AddWrite(GPUREG_BLEND_FUNC, e->alphaBlend);
|
||||
GPUCMD_AddWrite(GPUREG_LOGIC_OP, e->clrLogicOp);
|
||||
|
||||
184
source/gas.c
184
source/gas.c
@ -1,184 +0,0 @@
|
||||
#include "internal.h"
|
||||
|
||||
static inline u32 calc_diff(u32 a, u32 b, int pos)
|
||||
{
|
||||
float fa = ((a>>pos)&0xFF)/255.0f;
|
||||
float fb = ((b>>pos)&0xFF)/255.0f;
|
||||
float x = fb-fa;
|
||||
u32 diff = 0;
|
||||
if (x < 0)
|
||||
{
|
||||
diff = 0x80;
|
||||
x = -x;
|
||||
}
|
||||
diff |= (u32)(x*0x7F);
|
||||
return diff<<pos;
|
||||
}
|
||||
|
||||
static inline u32 conv_u8(float x, int pos)
|
||||
{
|
||||
if (x < 0.0f) x = 0.0f;
|
||||
else if (x > 1.0f) x = 1.0f;
|
||||
return ((u32)x*255)<<pos;
|
||||
}
|
||||
|
||||
static inline u32 color_diff(u32 a, u32 b)
|
||||
{
|
||||
return calc_diff(a,b,0) | calc_diff(a,b,8) | calc_diff(a,b,16);
|
||||
}
|
||||
|
||||
void GasLut_FromArray(C3D_GasLut* lut, const u32 data[9])
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i <= 8; i ++)
|
||||
{
|
||||
if (i < 8)
|
||||
lut->color[i] = data[i];
|
||||
if (i > 0)
|
||||
lut->diff[i-1] = color_diff(data[i-1], data[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void C3D_GasBeginAcc(void)
|
||||
{
|
||||
C3D_Context* ctx = C3Di_GetContext();
|
||||
|
||||
if (!(ctx->flags & C3DiF_Active))
|
||||
return;
|
||||
|
||||
ctx->gasFlags |= C3DiG_BeginAcc;
|
||||
}
|
||||
|
||||
void C3D_GasDeltaZ(float value)
|
||||
{
|
||||
C3D_Context* ctx = C3Di_GetContext();
|
||||
|
||||
if (!(ctx->flags & C3DiF_Active))
|
||||
return;
|
||||
|
||||
ctx->flags |= C3DiF_Gas;
|
||||
ctx->gasDeltaZ = (u32)(value*0x100);
|
||||
ctx->gasFlags |= C3DiG_AccStage;
|
||||
}
|
||||
|
||||
void C3D_GasAccMax(float value)
|
||||
{
|
||||
C3D_Context* ctx = C3Di_GetContext();
|
||||
|
||||
if (!(ctx->flags & C3DiF_Active))
|
||||
return;
|
||||
|
||||
ctx->flags |= C3DiF_Gas;
|
||||
ctx->gasAccMax = f32tof16(1.0f / value);
|
||||
ctx->gasFlags |= C3DiG_SetAccMax;
|
||||
}
|
||||
|
||||
void C3D_GasAttn(float value)
|
||||
{
|
||||
C3D_Context* ctx = C3Di_GetContext();
|
||||
|
||||
if (!(ctx->flags & C3DiF_Active))
|
||||
return;
|
||||
|
||||
ctx->flags |= C3DiF_Gas;
|
||||
ctx->gasAttn = f32tof16(value);
|
||||
ctx->gasFlags |= C3DiG_RenderStage;
|
||||
}
|
||||
|
||||
void C3D_GasLightPlanar(float min, float max, float attn)
|
||||
{
|
||||
C3D_Context* ctx = C3Di_GetContext();
|
||||
|
||||
if (!(ctx->flags & C3DiF_Active))
|
||||
return;
|
||||
|
||||
ctx->flags |= C3DiF_Gas;
|
||||
ctx->gasLightXY = conv_u8(min,0) | conv_u8(max,8) | conv_u8(attn,16);
|
||||
ctx->gasFlags |= C3DiG_RenderStage;
|
||||
}
|
||||
|
||||
void C3D_GasLightView(float min, float max, float attn)
|
||||
{
|
||||
C3D_Context* ctx = C3Di_GetContext();
|
||||
|
||||
if (!(ctx->flags & C3DiF_Active))
|
||||
return;
|
||||
|
||||
ctx->flags |= C3DiF_Gas;
|
||||
ctx->gasLightZ = conv_u8(min,0) | conv_u8(max,8) | conv_u8(attn,16);
|
||||
ctx->gasFlags |= C3DiG_RenderStage;
|
||||
}
|
||||
|
||||
void C3D_GasLightDirection(float dotp)
|
||||
{
|
||||
C3D_Context* ctx = C3Di_GetContext();
|
||||
|
||||
if (!(ctx->flags & C3DiF_Active))
|
||||
return;
|
||||
|
||||
ctx->flags |= C3DiF_Gas;
|
||||
ctx->gasLightZColor &= ~0xFF;
|
||||
ctx->gasLightZColor |= conv_u8(dotp,0);
|
||||
ctx->gasFlags |= C3DiG_RenderStage;
|
||||
}
|
||||
|
||||
void C3D_GasLutInput(GPU_GASLUTINPUT input)
|
||||
{
|
||||
C3D_Context* ctx = C3Di_GetContext();
|
||||
|
||||
if (!(ctx->flags & C3DiF_Active))
|
||||
return;
|
||||
|
||||
ctx->flags |= C3DiF_Gas;
|
||||
ctx->gasLightZColor &= ~0x100;
|
||||
ctx->gasLightZColor |= (input&1)<<8;
|
||||
ctx->gasFlags |= C3DiG_RenderStage;
|
||||
}
|
||||
|
||||
void C3D_GasLutBind(C3D_GasLut* lut)
|
||||
{
|
||||
C3D_Context* ctx = C3Di_GetContext();
|
||||
|
||||
if (!(ctx->flags & C3DiF_Active))
|
||||
return;
|
||||
|
||||
if (lut)
|
||||
{
|
||||
ctx->flags |= C3DiF_GasLut;
|
||||
ctx->gasLut = lut;
|
||||
} else
|
||||
ctx->flags &= ~C3DiF_GasLut;
|
||||
}
|
||||
|
||||
void C3Di_GasUpdate(C3D_Context* ctx)
|
||||
{
|
||||
if (ctx->flags & C3DiF_Gas)
|
||||
{
|
||||
ctx->flags &= ~C3DiF_Gas;
|
||||
u32 gasFlags = ctx->gasFlags;
|
||||
ctx->gasFlags = 0;
|
||||
|
||||
if (gasFlags & C3DiG_BeginAcc)
|
||||
GPUCMD_AddMaskedWrite(GPUREG_GAS_ACCMAX_FEEDBACK, 0x3, 0);
|
||||
if (gasFlags & C3DiG_AccStage)
|
||||
GPUCMD_AddMaskedWrite(GPUREG_GAS_DELTAZ_DEPTH, 0x7, ctx->gasDeltaZ);
|
||||
if (gasFlags & C3DiG_SetAccMax)
|
||||
GPUCMD_AddWrite(GPUREG_GAS_ACCMAX, ctx->gasAccMax);
|
||||
if (gasFlags & C3DiG_RenderStage)
|
||||
{
|
||||
GPUCMD_AddWrite(GPUREG_GAS_ATTENUATION, ctx->gasAttn);
|
||||
GPUCMD_AddWrite(GPUREG_GAS_LIGHT_XY, ctx->gasLightXY);
|
||||
GPUCMD_AddWrite(GPUREG_GAS_LIGHT_Z, ctx->gasLightZ);
|
||||
GPUCMD_AddWrite(GPUREG_GAS_LIGHT_Z_COLOR, ctx->gasLightZColor);
|
||||
}
|
||||
}
|
||||
if (ctx->flags & C3DiF_GasLut)
|
||||
{
|
||||
ctx->flags &= ~C3DiF_GasLut;
|
||||
if (ctx->gasLut)
|
||||
{
|
||||
GPUCMD_AddWrite(GPUREG_GAS_LUT_INDEX, 0);
|
||||
GPUCMD_AddWrites(GPUREG_GAS_LUT_DATA, (u32*)ctx->gasLut, 16);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -52,12 +52,6 @@ typedef struct
|
||||
u32 fogClr;
|
||||
C3D_FogLut* fogLut;
|
||||
|
||||
u16 gasAttn, gasAccMax;
|
||||
u32 gasLightXY, gasLightZ, gasLightZColor;
|
||||
u32 gasDeltaZ : 24;
|
||||
u32 gasFlags : 8;
|
||||
C3D_GasLut* gasLut;
|
||||
|
||||
C3D_ProcTex* procTex;
|
||||
C3D_ProcTexLut* procTexLut[3];
|
||||
C3D_ProcTexColorLut* procTexColorLut;
|
||||
@ -89,8 +83,6 @@ enum
|
||||
C3DiF_ProcTex = BIT(15),
|
||||
C3DiF_ProcTexColorLut = BIT(16),
|
||||
C3DiF_FogLut = BIT(17),
|
||||
C3DiF_Gas = BIT(18),
|
||||
C3DiF_GasLut = BIT(19),
|
||||
|
||||
#define C3DiF_ProcTexLut(n) BIT(20+(n))
|
||||
C3DiF_ProcTexLutAll = 7 << 20,
|
||||
@ -100,14 +92,6 @@ enum
|
||||
C3DiF_TexEnvAll = 0x3F << 26,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
C3DiG_BeginAcc = BIT(0),
|
||||
C3DiG_AccStage = BIT(1),
|
||||
C3DiG_SetAccMax = BIT(2),
|
||||
C3DiG_RenderStage = BIT(3),
|
||||
};
|
||||
|
||||
static inline C3D_Context* C3Di_GetContext(void)
|
||||
{
|
||||
extern C3D_Context __C3D_Context;
|
||||
@ -124,18 +108,6 @@ static inline bool C3Di_TexIs2D(C3D_Tex* tex)
|
||||
return !typeIsCube(C3D_TexGetType(tex));
|
||||
}
|
||||
|
||||
static inline bool addrIsVRAM(const void* addr)
|
||||
{
|
||||
u32 vaddr = (u32)addr;
|
||||
return vaddr >= OS_VRAM_VADDR && vaddr < OS_VRAM_VADDR + OS_VRAM_SIZE;
|
||||
}
|
||||
|
||||
static inline vramAllocPos addrGetVRAMBank(const void* addr)
|
||||
{
|
||||
u32 vaddr = (u32)addr;
|
||||
return vaddr < OS_VRAM_VADDR + OS_VRAM_SIZE/2 ? VRAM_ALLOC_A : VRAM_ALLOC_B;
|
||||
}
|
||||
|
||||
void C3Di_UpdateContext(void);
|
||||
void C3Di_AttrInfoBind(C3D_AttrInfo* info);
|
||||
void C3Di_BufInfoBind(C3D_BufInfo* info);
|
||||
@ -143,7 +115,6 @@ void C3Di_FrameBufBind(C3D_FrameBuf* fb);
|
||||
void C3Di_TexEnvBind(int id, C3D_TexEnv* env);
|
||||
void C3Di_SetTex(int unit, C3D_Tex* tex);
|
||||
void C3Di_EffectBind(C3D_Effect* effect);
|
||||
void C3Di_GasUpdate(C3D_Context* ctx);
|
||||
|
||||
void C3Di_LightMtlBlend(C3D_Light* light);
|
||||
|
||||
@ -152,9 +123,3 @@ void C3Di_LoadShaderUniforms(shaderInstance_s* si);
|
||||
void C3Di_ClearShaderUniforms(GPU_SHADER_TYPE type);
|
||||
|
||||
bool C3Di_SplitFrame(u32** pBuf, u32* pSize);
|
||||
|
||||
void C3Di_RenderQueueInit(void);
|
||||
void C3Di_RenderQueueExit(void);
|
||||
void C3Di_RenderQueueWaitDone(void);
|
||||
void C3Di_RenderQueueEnableVBlank(void);
|
||||
void C3Di_RenderQueueDisableVBlank(void);
|
||||
|
||||
@ -250,14 +250,6 @@ void C3D_LightEnvBumpSel(C3D_LightEnv* env, int texUnit)
|
||||
env->flags |= C3DF_LightEnv_Dirty;
|
||||
}
|
||||
|
||||
void C3D_LightEnvBumpNormalZ(C3D_LightEnv *env, bool usez) {
|
||||
if (usez)
|
||||
env->conf.config[0] |= BIT(30);
|
||||
else
|
||||
env->conf.config[0] &= ~BIT(30);
|
||||
env->flags |= C3DF_LightEnv_Dirty;
|
||||
}
|
||||
|
||||
void C3D_LightEnvShadowMode(C3D_LightEnv* env, u32 mode)
|
||||
{
|
||||
mode &= 0xF<<16;
|
||||
|
||||
@ -8,16 +8,22 @@ static C3D_RenderTarget *linkedTarget[3];
|
||||
|
||||
static TickCounter gpuTime, cpuTime;
|
||||
|
||||
#define STAGE_HAS_TRANSFER(n) BIT(0+(n))
|
||||
#define STAGE_HAS_ANY_TRANSFER (7<<0)
|
||||
#define STAGE_NEED_TRANSFER(n) BIT(3+(n))
|
||||
#define STAGE_NEED_TOP_TRANSFER (STAGE_NEED_TRANSFER(0)|STAGE_NEED_TRANSFER(1))
|
||||
#define STAGE_NEED_BOT_TRANSFER STAGE_NEED_TRANSFER(2)
|
||||
#define STAGE_WAIT_TRANSFER BIT(6)
|
||||
|
||||
static bool initialized;
|
||||
static bool inFrame, inSafeTransfer, measureGpuTime;
|
||||
static bool needSwapTop, needSwapBot, isTopStereo;
|
||||
static u8 frameStage;
|
||||
static float framerate = 60.0f;
|
||||
static float framerateCounter[2] = { 60.0f, 60.0f };
|
||||
static u32 frameCounter[2];
|
||||
static void (* frameEndCb)(void*);
|
||||
static void* frameEndCbData;
|
||||
|
||||
static void C3Di_RenderTargetDestroy(C3D_RenderTarget* target);
|
||||
|
||||
static bool framerateLimit(int id)
|
||||
{
|
||||
framerateCounter[id] -= framerate;
|
||||
@ -31,12 +37,50 @@ static bool framerateLimit(int id)
|
||||
|
||||
static void onVBlank0(C3D_UNUSED void* unused)
|
||||
{
|
||||
if (frameStage & STAGE_NEED_TOP_TRANSFER)
|
||||
{
|
||||
C3D_RenderTarget *left = linkedTarget[0], *right = linkedTarget[1];
|
||||
if (left && !(frameStage&STAGE_NEED_TRANSFER(0)))
|
||||
left = NULL;
|
||||
if (right && !(frameStage&STAGE_NEED_TRANSFER(1)))
|
||||
right = NULL;
|
||||
if (gfxIs3D() && !right)
|
||||
right = left;
|
||||
|
||||
frameStage &= ~STAGE_NEED_TOP_TRANSFER;
|
||||
if (left || right)
|
||||
{
|
||||
frameStage |= STAGE_WAIT_TRANSFER;
|
||||
if (left)
|
||||
C3D_FrameBufTransfer(&left->frameBuf, GFX_TOP, GFX_LEFT, left->transferFlags);
|
||||
if (right)
|
||||
C3D_FrameBufTransfer(&right->frameBuf, GFX_TOP, GFX_RIGHT, right->transferFlags);
|
||||
if (left && left->clearBits)
|
||||
C3D_FrameBufClear(&left->frameBuf, left->clearBits, left->clearColor, left->clearDepth);
|
||||
if (right && right != left && right->clearBits)
|
||||
C3D_FrameBufClear(&right->frameBuf, right->clearBits, right->clearColor, right->clearDepth);
|
||||
gfxConfigScreen(GFX_TOP, false);
|
||||
}
|
||||
}
|
||||
if (framerateLimit(0))
|
||||
frameCounter[0]++;
|
||||
}
|
||||
|
||||
static void onVBlank1(C3D_UNUSED void* unused)
|
||||
{
|
||||
if (frameStage & STAGE_NEED_BOT_TRANSFER)
|
||||
{
|
||||
frameStage &= ~STAGE_NEED_BOT_TRANSFER;
|
||||
C3D_RenderTarget* target = linkedTarget[2];
|
||||
if (target)
|
||||
{
|
||||
frameStage |= STAGE_WAIT_TRANSFER;
|
||||
C3D_FrameBufTransfer(&target->frameBuf, GFX_BOTTOM, GFX_LEFT, target->transferFlags);
|
||||
if (target->clearBits)
|
||||
C3D_FrameBufClear(&target->frameBuf, target->clearBits, target->clearColor, target->clearDepth);
|
||||
gfxConfigScreen(GFX_BOTTOM, false);
|
||||
}
|
||||
}
|
||||
if (framerateLimit(1))
|
||||
frameCounter[1]++;
|
||||
}
|
||||
@ -57,18 +101,12 @@ static void onQueueFinish(gxCmdQueue_s* queue)
|
||||
gxCmdQueueClear(queue);
|
||||
}
|
||||
}
|
||||
else if (frameStage & STAGE_WAIT_TRANSFER)
|
||||
frameStage &= ~STAGE_WAIT_TRANSFER;
|
||||
else
|
||||
{
|
||||
if (needSwapTop)
|
||||
{
|
||||
gfxScreenSwapBuffers(GFX_TOP, isTopStereo);
|
||||
needSwapTop = false;
|
||||
}
|
||||
if (needSwapBot)
|
||||
{
|
||||
gfxScreenSwapBuffers(GFX_BOTTOM, false);
|
||||
needSwapBot = false;
|
||||
}
|
||||
u8 needs = frameStage & STAGE_HAS_ANY_TRANSFER;
|
||||
frameStage = (frameStage&~STAGE_HAS_ANY_TRANSFER) | (needs<<3);
|
||||
}
|
||||
}
|
||||
|
||||
@ -94,60 +132,72 @@ static bool C3Di_WaitAndClearQueue(s64 timeout)
|
||||
gxCmdQueue_s* queue = &C3Di_GetContext()->gxQueue;
|
||||
if (!gxCmdQueueWait(queue, timeout))
|
||||
return false;
|
||||
if (timeout==0 && frameStage)
|
||||
return false;
|
||||
while (frameStage)
|
||||
gspWaitForAnyEvent();
|
||||
gxCmdQueueStop(queue);
|
||||
gxCmdQueueClear(queue);
|
||||
return true;
|
||||
}
|
||||
|
||||
void C3Di_RenderQueueEnableVBlank(void)
|
||||
static void C3Di_RenderQueueInit(void)
|
||||
{
|
||||
gspSetEventCallback(GSPGPU_EVENT_VBlank0, onVBlank0, NULL, false);
|
||||
gspSetEventCallback(GSPGPU_EVENT_VBlank1, onVBlank1, NULL, false);
|
||||
gxCmdQueueSetCallback(&C3Di_GetContext()->gxQueue, onQueueFinish, NULL);
|
||||
}
|
||||
|
||||
void C3Di_RenderQueueDisableVBlank(void)
|
||||
{
|
||||
gspSetEventCallback(GSPGPU_EVENT_VBlank0, NULL, NULL, false);
|
||||
gspSetEventCallback(GSPGPU_EVENT_VBlank1, NULL, NULL, false);
|
||||
}
|
||||
|
||||
void C3Di_RenderQueueInit(void)
|
||||
{
|
||||
C3D_Context* ctx = C3Di_GetContext();
|
||||
|
||||
C3Di_RenderQueueEnableVBlank();
|
||||
|
||||
GX_BindQueue(&ctx->gxQueue);
|
||||
gxCmdQueueSetCallback(&ctx->gxQueue, onQueueFinish, NULL);
|
||||
gxCmdQueueRun(&ctx->gxQueue);
|
||||
}
|
||||
static void C3Di_RenderTargetDestroy(C3D_RenderTarget* target);
|
||||
|
||||
void C3Di_RenderQueueExit(void)
|
||||
{
|
||||
int i;
|
||||
C3D_RenderTarget *a, *next;
|
||||
|
||||
if (!initialized)
|
||||
return;
|
||||
|
||||
C3Di_WaitAndClearQueue(-1);
|
||||
gxCmdQueueSetCallback(&C3Di_GetContext()->gxQueue, NULL, NULL);
|
||||
GX_BindQueue(NULL);
|
||||
|
||||
C3Di_RenderQueueDisableVBlank();
|
||||
|
||||
for (i = 0; i < 3; i ++)
|
||||
linkedTarget[i] = NULL;
|
||||
|
||||
for (a = firstTarget; a; a = next)
|
||||
{
|
||||
next = a->next;
|
||||
C3Di_RenderTargetDestroy(a);
|
||||
}
|
||||
|
||||
gspSetEventCallback(GSPGPU_EVENT_VBlank0, NULL, NULL, false);
|
||||
gspSetEventCallback(GSPGPU_EVENT_VBlank1, NULL, NULL, false);
|
||||
gxCmdQueueSetCallback(&C3Di_GetContext()->gxQueue, NULL, NULL);
|
||||
|
||||
for (i = 0; i < 3; i ++)
|
||||
linkedTarget[i] = NULL;
|
||||
|
||||
initialized = false;
|
||||
}
|
||||
|
||||
void C3Di_RenderQueueWaitDone(void)
|
||||
{
|
||||
if (!initialized)
|
||||
return;
|
||||
C3Di_WaitAndClearQueue(-1);
|
||||
}
|
||||
|
||||
static bool checkRenderQueueInit(void)
|
||||
{
|
||||
C3D_Context* ctx = C3Di_GetContext();
|
||||
|
||||
if (!(ctx->flags & C3DiF_Active))
|
||||
return false;
|
||||
|
||||
if (!initialized)
|
||||
{
|
||||
C3Di_RenderQueueInit();
|
||||
initialized = true;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
float C3D_FrameRate(float fps)
|
||||
{
|
||||
float old = framerate;
|
||||
@ -162,17 +212,13 @@ float C3D_FrameRate(float fps)
|
||||
|
||||
bool C3D_FrameBegin(u8 flags)
|
||||
{
|
||||
C3D_Context* ctx = C3Di_GetContext();
|
||||
if (inFrame) return false;
|
||||
|
||||
if (flags & C3D_FRAME_SYNCDRAW)
|
||||
C3D_FrameSync();
|
||||
if (!C3Di_WaitAndClearQueue((flags & C3D_FRAME_NONBLOCK) ? 0 : -1))
|
||||
return false;
|
||||
|
||||
inFrame = true;
|
||||
osTickCounterStart(&cpuTime);
|
||||
GPUCMD_SetBuffer(ctx->cmdBuf, ctx->cmdBufSize, 0);
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -197,15 +243,13 @@ void C3D_FrameSplit(u8 flags)
|
||||
void C3D_FrameEnd(u8 flags)
|
||||
{
|
||||
C3D_Context* ctx = C3Di_GetContext();
|
||||
if (!inFrame) return;
|
||||
|
||||
if (frameEndCb)
|
||||
frameEndCb(frameEndCbData);
|
||||
|
||||
C3D_FrameSplit(flags);
|
||||
GPUCMD_SetBuffer(NULL, 0, 0);
|
||||
osTickCounterUpdate(&cpuTime);
|
||||
inFrame = false;
|
||||
osTickCounterUpdate(&cpuTime);
|
||||
|
||||
// Flush the entire linear memory if the user did not explicitly mandate to flush the command list
|
||||
if (!(flags & GX_CMDLIST_FLUSH))
|
||||
@ -217,24 +261,24 @@ void C3D_FrameEnd(u8 flags)
|
||||
|
||||
int i;
|
||||
C3D_RenderTarget* target;
|
||||
isTopStereo = false;
|
||||
for (i = 2; i >= 0; i --)
|
||||
{
|
||||
target = linkedTarget[i];
|
||||
if (!target || !target->used)
|
||||
continue;
|
||||
target->used = false;
|
||||
C3D_FrameBufTransfer(&target->frameBuf, target->screen, target->side, target->transferFlags);
|
||||
if (target->screen == GFX_TOP)
|
||||
{
|
||||
needSwapTop = true;
|
||||
if (target->side == GFX_RIGHT)
|
||||
isTopStereo = true;
|
||||
}
|
||||
else if (target->screen == GFX_BOTTOM)
|
||||
needSwapBot = true;
|
||||
frameStage |= STAGE_HAS_TRANSFER(i);
|
||||
}
|
||||
|
||||
for (target = firstTarget; target; target = target->next)
|
||||
{
|
||||
if (!target->used || !target->clearBits)
|
||||
continue;
|
||||
target->used = false;
|
||||
C3D_FrameBufClear(&target->frameBuf, target->clearBits, target->clearColor, target->clearDepth);
|
||||
}
|
||||
|
||||
GPUCMD_SetBuffer(ctx->cmdBuf, ctx->cmdBufSize, 0);
|
||||
measureGpuTime = true;
|
||||
osTickCounterStart(&gpuTime);
|
||||
gxCmdQueueRun(&ctx->gxQueue);
|
||||
@ -277,6 +321,8 @@ static void C3Di_RenderTargetFinishInit(C3D_RenderTarget* target)
|
||||
|
||||
C3D_RenderTarget* C3D_RenderTargetCreate(int width, int height, GPU_COLORBUF colorFmt, C3D_DEPTHTYPE depthFmt)
|
||||
{
|
||||
if (!checkRenderQueueInit()) goto _fail0;
|
||||
|
||||
GPU_DEPTHBUF depthFmtReal = GPU_RB_DEPTH16;
|
||||
void* depthBuf = NULL;
|
||||
void* colorBuf = vramAlloc(C3D_CalcColorBufSize(width,height,colorFmt));
|
||||
@ -284,10 +330,7 @@ C3D_RenderTarget* C3D_RenderTargetCreate(int width, int height, GPU_COLORBUF col
|
||||
if (C3D_DEPTHTYPE_OK(depthFmt))
|
||||
{
|
||||
depthFmtReal = C3D_DEPTHTYPE_VAL(depthFmt);
|
||||
size_t depthSize = C3D_CalcDepthBufSize(width,height,depthFmtReal);
|
||||
vramAllocPos vramBank = addrGetVRAMBank(colorBuf);
|
||||
depthBuf = vramAllocAt(depthSize, vramBank ^ VRAM_ALLOC_ANY); // Attempt opposite bank first...
|
||||
if (!depthBuf) depthBuf = vramAllocAt(depthSize, vramBank); // ... if that fails, attempt same bank
|
||||
depthBuf = vramAlloc(C3D_CalcDepthBufSize(width,height,depthFmtReal));
|
||||
if (!depthBuf) goto _fail1;
|
||||
}
|
||||
|
||||
@ -316,7 +359,8 @@ _fail0:
|
||||
|
||||
C3D_RenderTarget* C3D_RenderTargetCreateFromTex(C3D_Tex* tex, GPU_TEXFACE face, int level, C3D_DEPTHTYPE depthFmt)
|
||||
{
|
||||
if (!addrIsVRAM(tex->data)) return NULL; // Render targets must be in VRAM
|
||||
if (!checkRenderQueueInit()) return NULL;
|
||||
|
||||
C3D_RenderTarget* target = C3Di_RenderTargetNew();
|
||||
if (!target) return NULL;
|
||||
|
||||
@ -326,10 +370,7 @@ C3D_RenderTarget* C3D_RenderTargetCreateFromTex(C3D_Tex* tex, GPU_TEXFACE face,
|
||||
if (C3D_DEPTHTYPE_OK(depthFmt))
|
||||
{
|
||||
GPU_DEPTHBUF depthFmtReal = C3D_DEPTHTYPE_VAL(depthFmt);
|
||||
size_t depthSize = C3D_CalcDepthBufSize(fb->width,fb->height,depthFmtReal);
|
||||
vramAllocPos vramBank = addrGetVRAMBank(tex->data);
|
||||
void* depthBuf = vramAllocAt(depthSize, vramBank ^ VRAM_ALLOC_ANY); // Attempt opposite bank first...
|
||||
if (!depthBuf) depthBuf = vramAllocAt(depthSize, vramBank); // ... if that fails, attempt same bank
|
||||
void* depthBuf = vramAlloc(C3D_CalcDepthBufSize(fb->width,fb->height,depthFmtReal));
|
||||
if (!depthBuf)
|
||||
{
|
||||
free(target);
|
||||
@ -362,32 +403,36 @@ void C3D_RenderTargetDelete(C3D_RenderTarget* target)
|
||||
{
|
||||
if (inFrame)
|
||||
svcBreak(USERBREAK_PANIC); // Shouldn't happen.
|
||||
if (target->linked)
|
||||
C3D_RenderTargetDetachOutput(target);
|
||||
else
|
||||
C3Di_WaitAndClearQueue(-1);
|
||||
C3Di_WaitAndClearQueue(-1);
|
||||
C3Di_RenderTargetDestroy(target);
|
||||
}
|
||||
|
||||
void C3D_RenderTargetSetClear(C3D_RenderTarget* target, C3D_ClearBits clearBits, u32 clearColor, u32 clearDepth)
|
||||
{
|
||||
if (!target->frameBuf.colorBuf) clearBits &= ~C3D_CLEAR_COLOR;
|
||||
if (!target->frameBuf.depthBuf) clearBits &= ~C3D_CLEAR_DEPTH;
|
||||
|
||||
C3D_ClearBits oldClearBits = target->clearBits;
|
||||
target->clearBits = clearBits;
|
||||
target->clearColor = clearColor;
|
||||
target->clearDepth = clearDepth;
|
||||
|
||||
if (clearBits &~ oldClearBits)
|
||||
C3D_FrameBufClear(&target->frameBuf, clearBits, clearColor, clearDepth);
|
||||
}
|
||||
|
||||
void C3D_RenderTargetSetOutput(C3D_RenderTarget* target, gfxScreen_t screen, gfx3dSide_t side, u32 transferFlags)
|
||||
{
|
||||
int id = 0;
|
||||
if (screen==GFX_BOTTOM) id = 2;
|
||||
else if (side==GFX_RIGHT) id = 1;
|
||||
if (linkedTarget[id])
|
||||
{
|
||||
linkedTarget[id]->linked = false;
|
||||
if (!inFrame)
|
||||
C3Di_WaitAndClearQueue(-1);
|
||||
}
|
||||
linkedTarget[id] = target;
|
||||
if (target)
|
||||
{
|
||||
target->linked = true;
|
||||
target->transferFlags = transferFlags;
|
||||
target->screen = screen;
|
||||
target->side = side;
|
||||
}
|
||||
target->linked = true;
|
||||
target->transferFlags = transferFlags;
|
||||
target->screen = screen;
|
||||
target->side = side;
|
||||
}
|
||||
|
||||
static void C3Di_SafeDisplayTransfer(u32* inadr, u32 indim, u32* outadr, u32 outdim, u32 flags)
|
||||
@ -414,6 +459,21 @@ static void C3Di_SafeMemoryFill(u32* buf0a, u32 buf0v, u32* buf0e, u16 control0,
|
||||
gxCmdQueueRun(&C3Di_GetContext()->gxQueue);
|
||||
}
|
||||
|
||||
void C3D_SafeDisplayTransfer(u32* inadr, u32 indim, u32* outadr, u32 outdim, u32 flags)
|
||||
{
|
||||
C3Di_SafeDisplayTransfer(inadr, indim, outadr, outdim, flags);
|
||||
}
|
||||
|
||||
void C3D_SafeTextureCopy(u32* inadr, u32 indim, u32* outadr, u32 outdim, u32 size, u32 flags)
|
||||
{
|
||||
C3Di_SafeTextureCopy(inadr, indim, outadr, outdim, size, flags);
|
||||
}
|
||||
|
||||
void C3D_SafeMemoryFill(u32* buf0a, u32 buf0v, u32* buf0e, u16 control0, u32* buf1a, u32 buf1v, u32* buf1e, u16 control1)
|
||||
{
|
||||
C3Di_SafeMemoryFill(buf0a, buf0v, buf0e, control0, buf1a, buf1v, buf1e, control1);
|
||||
}
|
||||
|
||||
void C3D_SyncDisplayTransfer(u32* inadr, u32 indim, u32* outadr, u32 outdim, u32 flags)
|
||||
{
|
||||
if (inFrame)
|
||||
|
||||
@ -30,6 +30,12 @@ static inline size_t fmtSize(GPU_TEXCOLOR fmt)
|
||||
}
|
||||
}
|
||||
|
||||
static inline bool addrIsVRAM(const void* addr)
|
||||
{
|
||||
u32 vaddr = (u32)addr;
|
||||
return vaddr >= 0x1F000000 && vaddr < 0x1F600000;
|
||||
}
|
||||
|
||||
static inline bool checkTexSize(u32 size)
|
||||
{
|
||||
if (size < 8 || size > 1024)
|
||||
|
||||
@ -47,10 +47,10 @@ ICON :=
|
||||
ARCH := -march=armv6k -mtune=mpcore -mfloat-abi=hard -mtp=soft
|
||||
|
||||
CFLAGS := -g -Wall -O3 -mword-relocations \
|
||||
-ffunction-sections \
|
||||
-fomit-frame-pointer -ffunction-sections \
|
||||
$(ARCH)
|
||||
|
||||
CFLAGS += $(INCLUDE) -D__3DS__
|
||||
CFLAGS += $(INCLUDE) -DARM11 -D_3DS
|
||||
|
||||
CXXFLAGS := $(CFLAGS) -fno-rtti -std=gnu++11
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user