void CitroBindUniforms(shaderProgram_s* program)
{
int location;
location = shaderInstanceGetUniformLocation(program->vertexShader, "projection");
MtxStack_Bind(&projectionMatrix, GPU_VERTEX_SHADER, location, 4);
location = shaderInstanceGetUniformLocation(program->vertexShader, "modelview");
MtxStack_Bind(&modelviewMatrix, GPU_VERTEX_SHADER, location, 4);
location = shaderInstanceGetUniformLocation(program->vertexShader, "texture");
MtxStack_Bind(&textureMatrix, GPU_VERTEX_SHADER, location, 4);
}
int ShaderProgram::getUniformLocation(const std::string& name) const
{
if(!_initialized)
{
return -1;
}
auto it = _locationsMap.find(name);
if(it != _locationsMap.end())
{
return it->second;
}
int result;
#ifdef _3DS
result = shaderInstanceGetUniformLocation(_shaderProgram.vertexShader, name.c_str());
#else
result = glGetUniformLocation(_program, name.c_str());
#endif // _3DS
if(result >= 0)
{
_locationsMap[name] = result;
}
return result;
}
void initEmancipation(void)
{
int i;
for(i=0;i<NUMEMANCIPATORS;i++)
{
emancipators[i].used=false;
}
for(i=0;i<NUMEMANCIPATIONGRIDS;i++)
{
emancipationGrids[i].used=false;
}
md2ReadModel(&gridModel, "grid.md2");
textureLoad(&gridTexture, "balllauncher.png", GPU_TEXTURE_MAG_FILTER(GPU_LINEAR)|GPU_TEXTURE_MIN_FILTER(GPU_LINEAR), 0);
textureLoad(&gridSurfaceTexture, "grid.png", GPU_TEXTURE_MAG_FILTER(GPU_LINEAR)|GPU_TEXTURE_MIN_FILTER(GPU_LINEAR)|GPU_TEXTURE_WRAP_S(GPU_REPEAT)|GPU_TEXTURE_WRAP_T(GPU_REPEAT), 0);
md2InstanceInit(&gridInstance, &gridModel, &gridTexture);
emancipationRectangleVertexData = linearAlloc(sizeof(emancipationRectangleData));
memcpy(emancipationRectangleVertexData, emancipationRectangleData, sizeof(emancipationRectangleData));
emancipationDvlb = DVLB_ParseFile((u32*)emancipation_vsh_shbin, emancipation_vsh_shbin_size);
if(!emancipationDvlb)return;
shaderProgramInit(&emancipationProgram);
shaderProgramSetVsh(&emancipationProgram, &emancipationDvlb->DVLE[0]);
emancipationUniformTextureDimensions = shaderInstanceGetUniformLocation(emancipationProgram.vertexShader, "textureDimensions");
emancipationSFX=createSFX("emancipation.raw", SOUND_FORMAT_16BIT);
}
GLint glGetUniformLocation(GLuint program, const GLchar *name) {
shaderProgram_s *shaderprogram = (shaderProgram_s *)ctr_handle_get(CTR_HANDLE_PROGRAM, program);
if (shaderprogram == 0) {
return 0;
}
GLint result = shaderInstanceGetUniformLocation(shaderprogram->vertexShader, name);
return result;
}
void TextEngine::Initialize(gfxScreen_t scn) {
//The two screens are different sizes
if(scn == GFX_TOP) {
target = C3D_RenderTargetCreate(240, 400, GPU_RB_RGBA8, GPU_RB_DEPTH24_STENCIL8);
} else {
target = C3D_RenderTargetCreate(240, 320, GPU_RB_RGBA8, GPU_RB_DEPTH24_STENCIL8);
}
C3D_RenderTargetSetClear(target, C3D_CLEAR_ALL, CLEAR_COLOR, 0);
C3D_RenderTargetSetOutput(target, scn, GFX_LEFT, DISPLAY_TRANSFER_FLAGS);
Result res = fontEnsureMapped();
if (R_FAILED(res))
printf("fontEnsureMapped: %08lX\n", res);
vshader_dvlb = DVLB_ParseFile((u32*)vshader_v_shbin, vshader_v_shbin_size);
shaderProgramInit(&program);
shaderProgramSetVsh(&program, &vshader_dvlb->DVLE[0]);
C3D_BindProgram(&program);
// Get the location of the uniforms
uLoc_projection = shaderInstanceGetUniformLocation(program.vertexShader, "projection");
// Configure attributes for use with the vertex shader
C3D_AttrInfo* attrInfo = C3D_GetAttrInfo();
AttrInfo_Init(attrInfo);
AttrInfo_AddLoader(attrInfo, 0, GPU_FLOAT, 3); // v0=position
AttrInfo_AddLoader(attrInfo, 1, GPU_FLOAT, 2); // v1=texcoord
if(scn == GFX_TOP) {
// Compute the projection matrix
Mtx_OrthoTilt(&projection, 0.0, 400.0, 240.0, 0.0, 0.0, 1.0);
} else {
Mtx_OrthoTilt(&projection, 0.0, 320.0, 240.0, 0.0, 0.0, 1.0);
}
// Configure depth test to overwrite pixels with the same depth (needed to draw overlapping glyphs)
C3D_DepthTest(true, GPU_GEQUAL, GPU_WRITE_ALL);
// Load the glyph texture sheets
int i;
TGLP_s* glyphInfo = fontGetGlyphInfo();
glyphSheets = malloc(sizeof(C3D_Tex)*glyphInfo->nSheets);
for (i = 0; i < glyphInfo->nSheets; i ++)
{
C3D_Tex* tex = &glyphSheets[i];
tex->data = fontGetGlyphSheetTex(i);
tex->fmt = glyphInfo->sheetFmt;
tex->size = glyphInfo->sheetSize;
tex->width = glyphInfo->sheetWidth;
tex->height = glyphInfo->sheetHeight;
tex->param = GPU_TEXTURE_MAG_FILTER(GPU_LINEAR) | GPU_TEXTURE_MIN_FILTER(GPU_LINEAR)
| GPU_TEXTURE_WRAP_S(GPU_CLAMP_TO_EDGE) | GPU_TEXTURE_WRAP_T(GPU_CLAMP_TO_EDGE);
}
// Create the text vertex array
textVtxArray = (textVertex_s*)linearAlloc(sizeof(textVertex_s)*TEXT_VTX_ARRAY_COUNT);
}
void OSystem_3DS::initGraphics() {
_pfGame = Graphics::PixelFormat::createFormatCLUT8();
_pfGameTexture = Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0);
C3D_Init(C3D_DEFAULT_CMDBUF_SIZE);
// Initialize the render targets
_renderTargetTop =
C3D_RenderTargetCreate(240, 400, GPU_RB_RGBA8, GPU_RB_DEPTH24_STENCIL8);
C3D_RenderTargetSetClear(_renderTargetTop, C3D_CLEAR_ALL, 0x0000000, 0);
C3D_RenderTargetSetOutput(_renderTargetTop, GFX_TOP, GFX_LEFT,
DISPLAY_TRANSFER_FLAGS);
_renderTargetBottom =
C3D_RenderTargetCreate(240, 320, GPU_RB_RGBA8, GPU_RB_DEPTH24_STENCIL8);
C3D_RenderTargetSetClear(_renderTargetBottom, C3D_CLEAR_ALL, 0x00000000, 0);
C3D_RenderTargetSetOutput(_renderTargetBottom, GFX_BOTTOM, GFX_LEFT,
DISPLAY_TRANSFER_FLAGS);
// Load and bind simple default shader (shader.v.pica)
_dvlb = DVLB_ParseFile((u32*)shader_shbin, shader_shbin_size);
shaderProgramInit(&_program);
shaderProgramSetVsh(&_program, &_dvlb->DVLE[0]);
C3D_BindProgram(&_program);
_projectionLocation = shaderInstanceGetUniformLocation(_program.vertexShader, "projection");
_modelviewLocation = shaderInstanceGetUniformLocation(_program.vertexShader, "modelView");
C3D_AttrInfo *attrInfo = C3D_GetAttrInfo();
AttrInfo_Init(attrInfo);
AttrInfo_AddLoader(attrInfo, 0, GPU_FLOAT, 3); // v0=position
AttrInfo_AddLoader(attrInfo, 1, GPU_FLOAT, 2); // v1=texcoord
Mtx_OrthoTilt(&_projectionTop, 0.0, 400.0, 240.0, 0.0, 0.0, 1.0);
Mtx_OrthoTilt(&_projectionBottom, 0.0, 320.0, 240.0, 0.0, 0.0, 1.0);
C3D_TexEnv *env = C3D_GetTexEnv(0);
C3D_TexEnvSrc(env, C3D_Both, GPU_TEXTURE0, 0, 0);
C3D_TexEnvOp(env, C3D_Both, 0, 0, 0);
C3D_TexEnvFunc(env, C3D_Both, GPU_REPLACE);
C3D_DepthTest(false, GPU_GEQUAL, GPU_WRITE_ALL);
C3D_CullFace(GPU_CULL_NONE);
}
bool ctrInitGpu() {
// Load vertex shader binary
uiShader = DVLB_ParseFile((u32*) uishader, uishader_size);
if (uiShader == NULL) {
return false;
}
// Create shader
shaderProgramInit(&uiProgram);
Result res = shaderProgramSetVsh(&uiProgram, &uiShader->DVLE[0]);
if (res < 0) {
return false;
}
res = shaderProgramSetGsh(&uiProgram, &uiShader->DVLE[1], 4);
if (res < 0) {
return false;
}
C3D_BindProgram(&uiProgram);
GSH_FVEC_projectionMtx = shaderInstanceGetUniformLocation(uiProgram.geometryShader, "projectionMtx");
GSH_FVEC_textureMtx = shaderInstanceGetUniformLocation(uiProgram.geometryShader, "textureMtx");
// Allocate buffers
ctrVertexBuffer = linearAlloc(VERTEX_BUFFER_SIZE);
if (ctrVertexBuffer == NULL) {
return false;
}
C3D_CullFace(GPU_CULL_NONE);
C3D_DepthTest(false, GPU_ALWAYS, GPU_WRITE_ALL);
C3D_AlphaBlend(GPU_BLEND_ADD, GPU_BLEND_ADD, GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA);
C3D_AlphaTest(false, GPU_ALWAYS, 0);
C3D_BlendingColor(0);
C3D_AttrInfo* attrInfo = C3D_GetAttrInfo();
AttrInfo_Init(attrInfo);
AttrInfo_AddLoader(attrInfo, 0, GPU_SHORT, 4); // in_pos
AttrInfo_AddLoader(attrInfo, 1, GPU_SHORT, 4); // in_tc0
AttrInfo_AddLoader(attrInfo, 2, GPU_UNSIGNED_BYTE, 4); // in_col
AttrInfo_AddLoader(attrInfo, 3, GPU_FLOAT, 2); // in_rot
return true;
}
void roomInit()
{
roomDvlb = DVLB_ParseFile((u32*)room_vsh_shbin, room_vsh_shbin_size);
if(!roomDvlb)return;
shaderProgramInit(&roomProgram);
shaderProgramSetVsh(&roomProgram, &roomDvlb->DVLE[0]);
roomUniformTextureDimensions = shaderInstanceGetUniformLocation(roomProgram.vertexShader, "textureDimensions");
}
void drawPortals(portal_s* portals[], int n, renderSceneCallback_t callback, camera_s* c, int depth, u8 stencil)
{
if(!portals || !portalVertexData || !callback || !c || !depth)return;
int i;
gsSwitchRenderMode(-1);
GPU_SetAttributeBuffers(
1, // number of attributes
(u32*)osConvertVirtToPhys(portalBaseAddr), // we use the start of linear heap as base since that's where all our buffers are located
GPU_ATTRIBFMT(0, 3, GPU_FLOAT), // we want v0 (vertex position)
0xFFE, // mask : we want v0
0x0, // permutation : we use identity
1, // number of buffers : we have one attribute per buffer
(u32[]){(u32)portalOutlineVertexData-portalBaseAddr}, // buffer offsets (placeholders)
(u64[]){0x0}, // attribute permutations for each buffer
(u8[]){1} // number of attributes for each buffer
);
gsPushMatrix();
shaderInstanceSetBool(portalProgram.vertexShader, 0, true);
gsSetShader(&portalProgram);
//TEMP
int colorUniformLoc = shaderInstanceGetUniformLocation(portalProgram.vertexShader, "color");
GPU_SetTexEnv(0,
GPU_TEVSOURCES(GPU_PRIMARY_COLOR, GPU_PRIMARY_COLOR, GPU_PRIMARY_COLOR),
GPU_TEVSOURCES(GPU_PRIMARY_COLOR, GPU_PRIMARY_COLOR, GPU_PRIMARY_COLOR),
GPU_TEVOPERANDS(0,0,0),
GPU_TEVOPERANDS(0,0,0),
GPU_MODULATE, GPU_MODULATE,
0xFFFFFFFF);
for(i=0; i<n; i++)
{
portal_s* p = portals[i];
if(!p->draw)continue;
GPU_SetFloatUniform(GPU_VERTEX_SHADER, colorUniformLoc, (u32*)(float[]){1.0f, p->color.z, p->color.y, p->color.x}, 1);
gsPushMatrix();
gsTranslate(p->position.x, p->position.y, p->position.z);
gsMultMatrix(p->matrix);
gsUpdateTransformation();
GPU_DrawArray(GPU_TRIANGLE_STRIP, portalNumVertices);
gsPopMatrix();
}
int sf2d_init_advanced(int gpucmd_size, int temppool_size)
{
if (sf2d_initialized) return 0;
gpu_fb_addr = vramMemAlign(400*240*8, 0x100);
gpu_depth_fb_addr = vramMemAlign(400*240*8, 0x100);
gpu_cmd = linearAlloc(gpucmd_size * 4);
pool_addr = linearAlloc(temppool_size);
pool_size = temppool_size;
gpu_cmd_size = gpucmd_size;
//gfxInitDefault();
GPU_Init(NULL);
//gfxSet3D(false);
GPU_Reset(NULL, gpu_cmd, gpucmd_size);
//Setup the shader
dvlb = DVLB_ParseFile((u32 *)shader_vsh_shbin, shader_vsh_shbin_size);
shaderProgramInit(&shader);
shaderProgramSetVsh(&shader, &dvlb->DVLE[0]);
//Get shader uniform descriptors
projection_desc = shaderInstanceGetUniformLocation(shader.vertexShader, "projection");
shaderProgramUse(&shader);
matrix_init_orthographic(ortho_matrix_top, 0.0f, 400.0f, 0.0f, 240.0f, 0.0f, 1.0f);
matrix_init_orthographic(ortho_matrix_bot, 0.0f, 320.0f, 0.0f, 240.0f, 0.0f, 1.0f);
matrix_gpu_set_uniform(ortho_matrix_top, projection_desc);
//Register the apt callback hook
//aptHook(&apt_hook_cookie, apt_hook_func, NULL);
vblank_wait = 1;
current_fps = 0.0f;
frames = 0;
last_time = osGetTime();
cur_screen = GFX_TOP;
cur_side = GFX_LEFT;
GPUCMD_Finalize();
GPUCMD_FlushAndRun();
gspWaitForP3D();
sf2d_pool_reset();
sf2d_initialized = 1;
return 1;
}
void init_gpu_stuff() {
// Load the vertex shader, create a shader program and bind it
vshader_dvlb = DVLB_ParseFile((u32*) vshader_shbin, vshader_shbin_size);
shaderProgramInit(&program);
shaderProgramSetVsh(&program, &vshader_dvlb->DVLE[0]);
C3D_BindProgram(&program);
// Get the location of the uniforms
proj_uloc = shaderInstanceGetUniformLocation(program.vertexShader, "projection");
// Configure attributes for use with the vertex shader
// Attribute format and element count are ignored in immediate mode
C3D_AttrInfo* attrInfo = C3D_GetAttrInfo();
AttrInfo_Init(attrInfo);
AttrInfo_AddLoader(attrInfo, 0, GPU_FLOAT, 3); // v0=position
AttrInfo_AddLoader(attrInfo, 1, GPU_FLOAT, 2); // v1=texcoord
AttrInfo_AddLoader(attrInfo, 2, GPU_FLOAT, 4); // v2=color
// Compute the projection matrix
// Note: we're setting top to 240 here so origin is at top left.
Mtx_OrthoTilt(&proj_mat, 0.0, 400.0, 240.0, 0.0, 0.0, 1.0, true);
// Configure buffers
C3D_BufInfo* bufInfo = C3D_GetBufInfo();
BufInfo_Init(bufInfo);
// Load textures
load_texture(&background_tex, background_png, background_png_size);
load_texture(&empty_tex, empty_png, empty_png_size);
load_texture(&frame_tex, frame_png, frame_png_size);
load_texture(&text_tex, ui_font_png, ui_font_png_size);
load_texture(&tileset_tex, tileset_png, tileset_png_size);
load_texture(&outline_tex, outline_png, outline_png_size);
// Configure the first fragment shading substage to just pass through the texture color
// See https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnv.xml for more insight
C3D_TexEnv* env = C3D_GetTexEnv(0);
C3D_TexEnvSrc(env, C3D_Both, GPU_TEXTURE0, GPU_PRIMARY_COLOR, GPU_PRIMARY_COLOR);
//C3D_TexEnvSrc(env, C3D_Both, GPU_TEXTURE0, 0, 0);
//C3D_TexEnvOp(env, C3D_Both, 0, 0, 0);
C3D_TexEnvFunc(env, C3D_Both, GPU_MODULATE);
//C3D_TexEnvFunc(env, C3D_Both, GPU_REPLACE);
// Configure depth test to overwrite pixels with the same depth (needed to draw overlapping sprites)
C3D_DepthTest(true, GPU_GEQUAL, GPU_WRITE_ALL);
C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, proj_uloc, &proj_mat);
}
static void sceneInit(void)
{
// Load the vertex shader and create a shader program
vshader_dvlb = DVLB_ParseFile((u32*)vshader_shbin, vshader_shbin_size);
shaderProgramInit(&program);
shaderProgramSetVsh(&program, &vshader_dvlb->DVLE[0]);
// Get the location of the projection matrix uniform
uLoc_projection = shaderInstanceGetUniformLocation(program.vertexShader, "projection");
// Compute the projection matrix
m4x4_ortho_tilt(&projection, 0.0, 400.0, 0.0, 240.0, 0.0, 1.0);
// Create the VBO (vertex buffer object)
vbo_data = linearAlloc(sizeof(vertex_list));
memcpy(vbo_data, vertex_list, sizeof(vertex_list));
}
void gpuSetUniform(u32 shader, ShaderType type, const char* name, const void* data, u32 elements) {
if(name == NULL || data == NULL) {
return;
}
ShaderData* shdr = (ShaderData*) shader;
if(shdr == NULL || shdr->dvlb == NULL) {
return;
}
shaderInstance_s* instance = type == VERTEX_SHADER ? shdr->program.vertexShader : shdr->program.geometryShader;
if(instance != NULL) {
Result res = shaderInstanceGetUniformLocation(instance, name);
if(res >= 0) {
GPU_SetFloatUniform((GPU_SHADER_TYPE) type, (u32) res, (u32 *) data, elements);
}
}
}
static void sceneInit(void)
{
// Load the shaders and create a shader program
// The geoshader stride is set to 6 so that it processes a triangle at a time
vshader_dvlb = DVLB_ParseFile((u32*)vshader_shbin, vshader_shbin_size);
gshader_dvlb = DVLB_ParseFile((u32*)gshader_shbin, gshader_shbin_size);
shaderProgramInit(&program);
shaderProgramSetVsh(&program, &vshader_dvlb->DVLE[0]);
shaderProgramSetGsh(&program, &gshader_dvlb->DVLE[0], 6);
// Get the location of the projection matrix uniform
uLoc_projection = shaderInstanceGetUniformLocation(program.geometryShader, "projection");
// Compute the projection matrix
m4x4_ortho_tilt(&projection, 0.0, 400.0, 0.0, 240.0, 0.0, 1.0);
// Create the VBO (vertex buffer object)
vbo_data = linearAlloc(sizeof(vertex_list));
memcpy(vbo_data, vertex_list, sizeof(vertex_list));
}
void initialize(void) {
// Load the vertex shader, create a shader program and bind it
vshader_dvlb = DVLB_ParseFile((u32*)vshader_shbin, vshader_shbin_size);
shaderProgramInit(&program);
shaderProgramSetVsh(&program, &vshader_dvlb->DVLE[0]);
C3D_BindProgram(&program);
// Get the location of the uniforms
uLoc_projection = shaderInstanceGetUniformLocation(program.vertexShader, "projection");
// Compute the projection matrix
Mtx_OrthoTilt(&projection, -200.0, 200.0, -120.0, 120.0, 0.0, 1.0);
// Update the uniforms
C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, uLoc_projection, &projection);
// Create the VBO (vertex buffer object)
vbo_data = linearAlloc(sizeof(vertices));
memcpy(vbo_data, vertices, sizeof(vertices));
// Configure buffers
C3D_BufInfo* bufInfo = C3D_GetBufInfo();
BufInfo_Init(bufInfo);
BufInfo_Add(bufInfo, vbo_data, sizeof(vertices[0]), 2, 0x10);
// Configure attributes for use with the vertex shader
C3D_AttrInfo* attrInfo = C3D_GetAttrInfo();
AttrInfo_Init(attrInfo);
AttrInfo_AddLoader(attrInfo, 0, GPU_FLOAT, 2); // v0=x,y
AttrInfo_AddLoader(attrInfo, 1, GPU_FLOAT, 3); // v1=r,g,b
// Configure the first fragment shading substage to just pass through the vertex color
// See https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnv.xml for more insight
C3D_TexEnv* env = C3D_GetTexEnv(0);
C3D_TexEnvSrc(env, C3D_Both, GPU_PRIMARY_COLOR, 0, 0);
C3D_TexEnvOp(env, C3D_Both, 0, 0, 0);
C3D_TexEnvFunc(env, C3D_Both, GPU_REPLACE);
}
static void sceneInit(void)
{
// Load the vertex shader, create a shader program and bind it
vshader_dvlb = DVLB_ParseFile((u32*)vshader_shbin, vshader_shbin_size);
shaderProgramInit(&program);
shaderProgramSetVsh(&program, &vshader_dvlb->DVLE[0]);
C3D_BindProgram(&program);
// Get the location of the uniforms
uLoc_projection = shaderInstanceGetUniformLocation(program.vertexShader, "Projection");
// Configure attributes for use with the vertex shader
C3D_AttrInfo* attrInfo = C3D_GetAttrInfo();
AttrInfo_Init(attrInfo);
AttrInfo_AddLoader(attrInfo, 0, GPU_FLOAT, 3); // v0=position
AttrInfo_AddFixed(attrInfo, 1); // v1=color
// Set the fixed attribute (color) to solid white
C3D_FixedAttribSet(1, 1.0, 1.0, 1.0, 1.0);
// Compute the projection matrix
Mtx_OrthoTilt(&projection, 0.0, 400.0, 0.0, 240.0, 0.0, 1.0);
// Create the VBO (vertex buffer object)
vbo_data = linearAlloc(sizeof(vertex_list));
memcpy(vbo_data, vertex_list, sizeof(vertex_list));
// Configure buffers
C3D_BufInfo* bufInfo = C3D_GetBufInfo();
BufInfo_Init(bufInfo);
BufInfo_Add(bufInfo, vbo_data, sizeof(vertex), 1, 0x0);
// Configure the first fragment shading substage to just pass through the vertex color
// See https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnv.xml for more insight
C3D_TexEnv* env = C3D_GetTexEnv(0);
C3D_TexEnvSrc(env, C3D_Both, GPU_PRIMARY_COLOR, 0, 0);
C3D_TexEnvOp(env, C3D_Both, 0, 0, 0);
C3D_TexEnvFunc(env, C3D_Both, GPU_REPLACE);
}
static void sceneInit(void)
{
// Load the shaders and create a shader program
// The geoshader stride is set to 6 so that it processes a triangle at a time
program_dvlb = DVLB_ParseFile((u32*)program_shbin, program_shbin_size);
shaderProgramInit(&program);
shaderProgramSetVsh(&program, &program_dvlb->DVLE[0]);
shaderProgramSetGsh(&program, &program_dvlb->DVLE[1], 6);
C3D_BindProgram(&program);
// Get the location of the projection matrix uniform
uLoc_projection = shaderInstanceGetUniformLocation(program.geometryShader, "projection");
// Configure attributes for use with the vertex shader
C3D_AttrInfo* attrInfo = C3D_GetAttrInfo();
AttrInfo_Init(attrInfo);
AttrInfo_AddLoader(attrInfo, 0, GPU_FLOAT, 3); // v0=position
AttrInfo_AddLoader(attrInfo, 1, GPU_FLOAT, 4); // v1=color
// Compute the projection matrix
Mtx_OrthoTilt(&projection, 0.0, 400.0, 0.0, 240.0, 0.0, 1.0);
// Create the VBO (vertex buffer object)
vbo_data = linearAlloc(sizeof(vertex_list));
memcpy(vbo_data, vertex_list, sizeof(vertex_list));
// Configure buffers
C3D_BufInfo* bufInfo = C3D_GetBufInfo();
BufInfo_Init(bufInfo);
BufInfo_Add(bufInfo, vbo_data, sizeof(vertex), 2, 0x10);
// Configure the first fragment shading substage to just pass through the vertex color
// See https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnv.xml for more insight
C3D_TexEnv* env = C3D_GetTexEnv(0);
C3D_TexEnvSrc(env, C3D_Both, GPU_PRIMARY_COLOR, 0, 0);
C3D_TexEnvOp(env, C3D_Both, 0, 0, 0);
C3D_TexEnvFunc(env, C3D_Both, GPU_REPLACE);
}
//---------------------------------------------------------------------------------
static void sceneInit(void) {
//---------------------------------------------------------------------------------
int i;
// Load the vertex shader, create a shader program and bind it
vshader_dvlb = DVLB_ParseFile((u32*)vshader_shbin, vshader_shbin_size);
shaderProgramInit(&program);
shaderProgramSetVsh(&program, &vshader_dvlb->DVLE[0]);
C3D_BindProgram(&program);
// Get the location of the uniforms
uLoc_projection = shaderInstanceGetUniformLocation(program.vertexShader, "projection");
// Configure attributes for use with the vertex shader
// Attribute format and element count are ignored in immediate mode
C3D_AttrInfo* attrInfo = C3D_GetAttrInfo();
AttrInfo_Init(attrInfo);
AttrInfo_AddLoader(attrInfo, 0, GPU_FLOAT, 3); // v0=position
AttrInfo_AddLoader(attrInfo, 1, GPU_FLOAT, 2); // v2=texcoord
// Compute the projection matrix
// Note: we're setting top to 240 here so origin is at top left.
Mtx_OrthoTilt(&projection, 0.0, 400.0, 240.0, 0.0, 0.0, 1.0);
// Configure buffers
C3D_BufInfo* bufInfo = C3D_GetBufInfo();
BufInfo_Init(bufInfo);
unsigned char* image;
unsigned width, height;
lodepng_decode32(&image, &width, &height, ballsprites_png, ballsprites_png_size);
u8 *gpusrc = linearAlloc(width*height*4);
// GX_DisplayTransfer needs input buffer in linear RAM
u8* src=image; u8 *dst=gpusrc;
// lodepng outputs big endian rgba so we need to convert
for(int i = 0; i<width*height; i++) {
int r = *src++;
int g = *src++;
int b = *src++;
int a = *src++;
*dst++ = a;
*dst++ = b;
*dst++ = g;
*dst++ = r;
}
// ensure data is in physical ram
GSPGPU_FlushDataCache(gpusrc, width*height*4);
// Load the texture and bind it to the first texture unit
C3D_TexInit(&spritesheet_tex, width, height, GPU_RGBA8);
// Convert image to 3DS tiled texture format
C3D_SafeDisplayTransfer ((u32*)gpusrc, GX_BUFFER_DIM(width,height), (u32*)spritesheet_tex.data, GX_BUFFER_DIM(width,height), TEXTURE_TRANSFER_FLAGS);
gspWaitForPPF();
C3D_TexSetFilter(&spritesheet_tex, GPU_LINEAR, GPU_NEAREST);
C3D_TexBind(0, &spritesheet_tex);
free(image);
linearFree(gpusrc);
// Configure the first fragment shading substage to just pass through the texture color
// See https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnv.xml for more insight
C3D_TexEnv* env = C3D_GetTexEnv(0);
C3D_TexEnvSrc(env, C3D_Both, GPU_TEXTURE0, 0, 0);
C3D_TexEnvOp(env, C3D_Both, 0, 0, 0);
C3D_TexEnvFunc(env, C3D_Both, GPU_REPLACE);
srand(time(NULL));
for(i = 0; i < NUM_SPRITES; i++) {
//random place and speed
sprites[i].x = (rand() % (400 - 32 )) << 8;
sprites[i].y = (rand() % (240 - 32 )) << 8 ;
sprites[i].dx = (rand() & 0xFF) + 0x100;
sprites[i].dy = (rand() & 0xFF) + 0x100;
sprites[i].image = rand() & 3;
if(rand() & 1)
sprites[i].dx = -sprites[i].dx;
if(rand() & 1)
sprites[i].dy = -sprites[i].dy;
}
// Configure depth test to overwrite pixels with the same depth (needed to draw overlapping sprites)
C3D_DepthTest(true, GPU_GEQUAL, GPU_WRITE_ALL);
}
void gfxDrawScreen() {
int screenTexSize = 256;
u32* transferBuffer = screenBuffer;
GPU_TEXTURE_FILTER_PARAM filter = GPU_NEAREST;
if(scaleMode != 0 && scaleFilter != 0) {
filter = GPU_LINEAR;
if(scaleFilter == 2) {
screenTexSize = 512;
transferBuffer = scale2xBuffer;
gfxScale2xRGBA8888(screenBuffer, 256, scale2xBuffer, 512, 256, 224);
}
}
if(!screenInit || screenTexture.width != screenTexSize || screenTexture.height != screenTexSize) {
if(screenInit) {
C3D_TexDelete(&screenTexture);
screenInit = false;
}
screenInit = C3D_TexInit(&screenTexture, screenTexSize, screenTexSize, GPU_RGBA8);
}
C3D_TexSetFilter(&screenTexture, filter, filter);
GSPGPU_FlushDataCache(transferBuffer, screenTexSize * screenTexSize * sizeof(u32));
if(R_SUCCEEDED(GX_DisplayTransfer(transferBuffer, (u32) GX_BUFFER_DIM(screenTexSize, screenTexSize), (u32*) screenTexture.data, (u32) GX_BUFFER_DIM(screenTexSize, screenTexSize), GX_TRANSFER_FLIP_VERT(1) | GX_TRANSFER_OUT_TILED(1) | GX_TRANSFER_RAW_COPY(0) | GX_TRANSFER_IN_FORMAT(GX_TRANSFER_FMT_RGBA8) | GX_TRANSFER_OUT_FORMAT(GX_TRANSFER_FMT_RGBA8) | GX_TRANSFER_SCALING(GX_TRANSFER_SCALE_NO)))) {
gspWaitForPPF();
}
GSPGPU_InvalidateDataCache(screenTexture.data, screenTexture.size);
if(!C3D_FrameBegin(0)) {
return;
}
C3D_RenderTarget* target = gameScreen == 0 ? targetTop : targetBottom;
C3D_FrameDrawOn(target);
C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, shaderInstanceGetUniformLocation(program.vertexShader, "projection"), gameScreen == 0 ? &projectionTop : &projectionBottom);
u16 viewportWidth = target->renderBuf.colorBuf.height;
u16 viewportHeight = target->renderBuf.colorBuf.width;
// Draw the screen.
if(screenInit) {
// Calculate the VBO dimensions.
int screenWidth = 256;
int screenHeight = 224;
if(scaleMode == 1) {
screenWidth *= 1.25f;
screenHeight *= 1.25f;
} else if(scaleMode == 2) {
screenWidth *= 1.50f;
screenHeight *= 1.50f;
} else if(scaleMode == 3) {
screenWidth *= viewportHeight / (float) screenHeight;
screenHeight = viewportHeight;
} else if(scaleMode == 4) {
screenWidth = viewportWidth;
screenHeight = viewportHeight;
}
// Calculate VBO points.
const float x1 = ((int) viewportWidth - screenWidth) / 2.0f;
const float y1 = ((int) viewportHeight - screenHeight) / 2.0f;
const float x2 = x1 + screenWidth;
const float y2 = y1 + screenHeight;
static const float baseTX2 = 256.0f / 256.0f;
static const float baseTY2 = 224.0f / 256.0f;
static const float baseFilterMod = 0.25f / 256.0f;
float tx2 = baseTX2;
float ty2 = baseTY2;
if(scaleMode != 0 && scaleFilter == 1) {
tx2 -= baseFilterMod;
ty2 -= baseFilterMod;
}
C3D_TexBind(0, &screenTexture);
C3D_ImmDrawBegin(GPU_TRIANGLES);
C3D_ImmSendAttrib(x1, y1, 0.5f, 0.0f);
C3D_ImmSendAttrib(0, 0, 0.0f, 0.0f);
C3D_ImmSendAttrib(x2, y2, 0.5f, 0.0f);
C3D_ImmSendAttrib(tx2, ty2, 0.0f, 0.0f);
C3D_ImmSendAttrib(x2, y1, 0.5f, 0.0f);
C3D_ImmSendAttrib(tx2, 0, 0.0f, 0.0f);
C3D_ImmSendAttrib(x1, y1, 0.5f, 0.0f);
C3D_ImmSendAttrib(0, 0, 0.0f, 0.0f);
C3D_ImmSendAttrib(x1, y2, 0.5f, 0.0f);
C3D_ImmSendAttrib(0, ty2, 0.0f, 0.0f);
C3D_ImmSendAttrib(x2, y2, 0.5f, 0.0f);
C3D_ImmSendAttrib(tx2, ty2, 0.0f, 0.0f);
C3D_ImmDrawEnd();
}
// Draw the border.
if(borderInit && scaleMode != 4) {
// Calculate VBO points.
int scaledBorderWidth = borderWidth;
int scaledBorderHeight = borderHeight;
if(borderScaleMode == 1) {
if(scaleMode == 1) {
scaledBorderWidth *= 1.25f;
scaledBorderHeight *= 1.25f;
} else if(scaleMode == 2) {
scaledBorderWidth *= 1.50f;
scaledBorderHeight *= 1.50f;
} else if(scaleMode == 3) {
scaledBorderWidth *= viewportHeight / 224.0f;
scaledBorderHeight *= viewportHeight / 224.0f;
} else if(scaleMode == 4) {
scaledBorderWidth *= viewportWidth / 256.0f;
scaledBorderHeight *= viewportHeight / 224.0f;
}
}
const float x1 = ((int) viewportWidth - scaledBorderWidth) / 2.0f;
const float y1 = ((int) viewportHeight - scaledBorderHeight) / 2.0f;
const float x2 = x1 + scaledBorderWidth;
const float y2 = y1 + scaledBorderHeight;
float tx2 = (float) borderWidth / (float) gpuBorderWidth;
float ty2 = (float) borderHeight / (float) gpuBorderHeight;
C3D_TexBind(0, &borderTexture);
C3D_ImmDrawBegin(GPU_TRIANGLES);
C3D_ImmSendAttrib(x1, y1, 0.5f, 0.0f);
C3D_ImmSendAttrib(0, 0, 0.0f, 0.0f);
C3D_ImmSendAttrib(x2, y2, 0.5f, 0.0f);
C3D_ImmSendAttrib(tx2, ty2, 0.0f, 0.0f);
C3D_ImmSendAttrib(x2, y1, 0.5f, 0.0f);
C3D_ImmSendAttrib(tx2, 0, 0.0f, 0.0f);
C3D_ImmSendAttrib(x1, y1, 0.5f, 0.0f);
C3D_ImmSendAttrib(0, 0, 0.0f, 0.0f);
C3D_ImmSendAttrib(x1, y2, 0.5f, 0.0f);
C3D_ImmSendAttrib(0, ty2, 0.0f, 0.0f);
C3D_ImmSendAttrib(x2, y2, 0.5f, 0.0f);
C3D_ImmSendAttrib(tx2, ty2, 0.0f, 0.0f);
C3D_ImmDrawEnd();
}
C3D_FrameEnd(0);
}