graphics/gpu/particles/source/main.c

#include <3ds.h>
#include <citro3d.h>
#include <stdio.h>
#include <string.h>
#include "particle_shbin.h"
 
#define CLEAR_COLOR 0
 
#define DISPLAY_TRANSFER_FLAGS \
 (GX_TRANSFER_FLIP_VERT(0) | GX_TRANSFER_OUT_TILED(0) | GX_TRANSFER_RAW_COPY(0) | \
 GX_TRANSFER_IN_FORMAT(GX_TRANSFER_FMT_RGBA8) | GX_TRANSFER_OUT_FORMAT(GX_TRANSFER_FMT_RGB8) | \
 GX_TRANSFER_SCALING(GX_TRANSFER_SCALE_NO))
 
typedef struct { float center[3]; float radius[3]; float attrib[4]; } controlPoint;
 
static const controlPoint point_list[] =
{
 { { -1.0f, 0.0f, -2.0f }, { 0.0f, 0.0f, 0.0f }, { 3*8/240.0f, 3*8/400.0f, 0.0f, 1.0f } },
 { { -0.3f, +1.5f, -4.0f }, { 0.0f, 0.1f, 0.1f }, { 3*12/240.0f, 3*12/400.0f, 0.0f, 1.0f } },
 { { +0.3f, -1.5f, -4.0f }, { 0.1f, 0.3f, 0.3f }, { 3*16/240.0f, 3*16/400.0f, 0.0f, 0.8f } },
 { { +1.0f, 0.0f, -2.0f }, { 0.2f, 0.5f, 0.5f }, { 3*32/240.0f, 3*32/400.0f, 0.0f, 0.0f } },
};
 
static const u8 point_index_list[] = { 0, 1, 2, 3 };
 
#define point_index_count (sizeof(point_index_list)/sizeof(point_index_list[0]))
 
static DVLB_s* particle_dvlb;
static shaderProgram_s program;
static int uLoc_projection, uLoc_modelView;
static int uLoc_gsh_param, uLoc_gsh_randParam, uLoc_gsh_randSeed, uLoc_gsh_uvCoords;
static int uLoc_gsh_multiplyW, uLoc_gsh_randSphere, uLoc_gsh_noRespawn;
static C3D_Mtx projection, modelView;
static float curTime = 0.0f;
static bool multiplyW = true, randSphere = true, noRespawn = false, additiveBlend = true;
 
static void* vbo_data;
static void* ibo_data;
 
static C3D_ProcTex pt;
static C3D_ProcTexLut pt_map;
static C3D_ProcTexLut pt_noise;
static C3D_ProcTexColorLut pt_clr;
 
static void setupProcTex(void)
{
#define NUMCOLORS 2
 C3D_ProcTexInit(&pt, 0, NUMCOLORS);
 C3D_ProcTexClamp(&pt, GPU_PT_MIRRORED_REPEAT, GPU_PT_MIRRORED_REPEAT);
 C3D_ProcTexNoiseCoefs(&pt, C3D_ProcTex_UV, 0.1f, 0.5f, 0.1f);
 C3D_ProcTexCombiner(&pt, false, GPU_PT_SQRT2, GPU_PT_SQRT2);
 C3D_ProcTexFilter(&pt, GPU_PT_LINEAR);
 C3D_ProcTexBind(0, &pt);
 
 float data[129];
 int i;
 for (i = 0; i <= 128; i ++)
 {
 float x = i/128.0f;
 data[i] = x;
 }
 ProcTexLut_FromArray(&pt_map, data);
 C3D_ProcTexLutBind(GPU_LUT_RGBMAP, &pt_map);
 
 // Noise smooth step equation
 for (i = 0; i <= 128; i ++)
 {
 float x = i/128.0f;
 data[i] = x*x*(3-2*x);
 }
 ProcTexLut_FromArray(&pt_noise, data);
 C3D_ProcTexLutBind(GPU_LUT_NOISE, &pt_noise);
 
 u32 colors[NUMCOLORS];
 colors[0] = 0xFFBABABA;
 colors[1] = 0x00888888;
 
 ProcTexColorLut_Write(&pt_clr, colors, 0, NUMCOLORS);
 C3D_ProcTexColorLutBind(&pt_clr);
}
 
static void sceneInit(void)
{
 // Load the vertex shader, create a shader program and bind it
 particle_dvlb = DVLB_ParseFile((u32*)particle_shbin, particle_shbin_size);
 shaderProgramInit(&program);
 shaderProgramSetVsh(&program, &particle_dvlb->DVLE[0]);
 shaderProgramSetGsh(&program, &particle_dvlb->DVLE[1], 0);
 C3D_BindProgram(&program);
 
 // Get the location of the uniforms
 uLoc_projection = shaderInstanceGetUniformLocation(program.vertexShader, "projection");
 uLoc_modelView = shaderInstanceGetUniformLocation(program.vertexShader, "modelView");
 uLoc_gsh_param = shaderInstanceGetUniformLocation(program.geometryShader, "param");
 uLoc_gsh_randParam = shaderInstanceGetUniformLocation(program.geometryShader, "randParam");
 uLoc_gsh_randSeed = shaderInstanceGetUniformLocation(program.geometryShader, "randSeed");
 uLoc_gsh_uvCoords = shaderInstanceGetUniformLocation(program.geometryShader, "uvCoords");
 uLoc_gsh_multiplyW = shaderInstanceGetUniformLocation(program.geometryShader, "multiplyW");
 uLoc_gsh_randSphere = shaderInstanceGetUniformLocation(program.geometryShader, "randSphere");
 uLoc_gsh_noRespawn = shaderInstanceGetUniformLocation(program.geometryShader, "noRespawn");
 
 // Configure attributes for use with the vertex shader
 C3D_AttrInfo* attrInfo = C3D_GetAttrInfo();
 AttrInfo_Init(attrInfo);
 AttrInfo_AddLoader(attrInfo, 0, GPU_FLOAT, 3); // v0=center
 AttrInfo_AddLoader(attrInfo, 1, GPU_FLOAT, 3); // v1=radius
 AttrInfo_AddLoader(attrInfo, 2, GPU_FLOAT, 4); // v2=attrib
 
 // Create the VBO (vertex buffer object)
 vbo_data = linearAlloc(sizeof(point_list));
 memcpy(vbo_data, point_list, sizeof(point_list));
 ibo_data = linearAlloc(sizeof(point_index_list));
 memcpy(ibo_data, point_index_list, sizeof(point_index_list));
 
 // Configure buffers
 C3D_BufInfo* bufInfo = C3D_GetBufInfo();
 BufInfo_Init(bufInfo);
 BufInfo_Add(bufInfo, vbo_data, sizeof(controlPoint), 3, 0x210);
 
 // Configure the first fragment shading substage to just pass through the proctex color
 // and blend the alpha coming from proctex and the vertex color
 // See https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnv.xml for more insight
 C3D_TexEnv* env = C3D_GetTexEnv(0);
 C3D_TexEnvInit(env);
 C3D_TexEnvSrc(env, C3D_RGB, GPU_TEXTURE3, 0, 0);
 C3D_TexEnvSrc(env, C3D_Alpha, GPU_TEXTURE3, GPU_PRIMARY_COLOR, 0);
 C3D_TexEnvFunc(env, C3D_RGB, GPU_REPLACE);
 C3D_TexEnvFunc(env, C3D_Alpha, GPU_MODULATE);
 setupProcTex();
}
 
static void sceneRender(float iod)
{
 // Compute the matrices
 Mtx_PerspStereoTilt(&projection, C3D_AngleFromDegrees(40.0f), C3D_AspectRatioTop, 0.01f, 20.0f, iod, 3.0f, false);
 Mtx_Identity(&modelView);
 
 // Update the uniforms
 C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, uLoc_projection, &projection);
 C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, uLoc_modelView, &modelView);
 C3D_FVUnifSet (GPU_GEOMETRY_SHADER, uLoc_gsh_param, 100.0f, curTime, 1.0f, 1.0f);
 C3D_FVUnifSet (GPU_GEOMETRY_SHADER, uLoc_gsh_randParam, 17, 37, 65535, 1.0f/65535);
 C3D_FVUnifSet (GPU_GEOMETRY_SHADER, uLoc_gsh_randSeed, 45, 47.564, 46.15, 45.9875);
 C3D_FVUnifSet (GPU_GEOMETRY_SHADER, uLoc_gsh_uvCoords+0, 3.0, 1.0, 3.0, 3.0);
 C3D_FVUnifSet (GPU_GEOMETRY_SHADER, uLoc_gsh_uvCoords+1, 1.0, 1.0, 1.0, 3.0);
 C3D_BoolUnifSet (GPU_GEOMETRY_SHADER, uLoc_gsh_multiplyW, multiplyW);
 C3D_BoolUnifSet (GPU_GEOMETRY_SHADER, uLoc_gsh_randSphere, randSphere);
 C3D_BoolUnifSet (GPU_GEOMETRY_SHADER, uLoc_gsh_noRespawn, noRespawn);
 
 if (additiveBlend)
 C3D_AlphaBlend(GPU_BLEND_ADD, GPU_BLEND_ADD, GPU_SRC_ALPHA, GPU_ONE, GPU_SRC_ALPHA, GPU_ONE);
 else
 C3D_AlphaBlend(GPU_BLEND_ADD, GPU_BLEND_ADD, GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA);
 
 // Draw the particles
 C3D_DepthTest(true, GPU_GREATER, GPU_WRITE_COLOR);
 C3D_DrawElements(GPU_GEOMETRY_PRIM, point_index_count, C3D_UNSIGNED_BYTE, ibo_data);
}
 
static void sceneExit(void)
{
 // Free the data
 linearFree(vbo_data);
 linearFree(ibo_data);
 
 // Free the shader program
 shaderProgramFree(&program);
 DVLB_Free(particle_dvlb);
}
 
int main()
{
 // Initialize graphics
 gfxInitDefault();
 gfxSet3D(true); // Enable stereoscopic 3D
 consoleInit(GFX_BOTTOM, NULL);
 C3D_Init(C3D_DEFAULT_CMDBUF_SIZE);
 
 // Initialize the render targets
 C3D_RenderTarget* targetLeft = C3D_RenderTargetCreate(240, 400, GPU_RB_RGBA8, GPU_RB_DEPTH24_STENCIL8);
 C3D_RenderTarget* targetRight = C3D_RenderTargetCreate(240, 400, GPU_RB_RGBA8, GPU_RB_DEPTH24_STENCIL8);
 C3D_RenderTargetSetOutput(targetLeft, GFX_TOP, GFX_LEFT, DISPLAY_TRANSFER_FLAGS);
 C3D_RenderTargetSetOutput(targetRight, GFX_TOP, GFX_RIGHT, DISPLAY_TRANSFER_FLAGS);
 
 // Initialize the scene
 sceneInit();
 
 // Main loop
 while (aptMainLoop())
 {
 hidScanInput();
 
 // Respond to user input
 u32 kDown = hidKeysDown();
 u32 kHeld = hidKeysHeld();
 if (kDown & KEY_START)
 break; // break in order to return to hbmenu
 
 float slider = osGet3DSliderState();
 float iod = slider/4;
 
 if (!(kHeld & KEY_L))
 curTime += 1/128.0f;
 if (kDown & KEY_A)
 curTime = 0.0f;
 
 if (kDown & KEY_X)
 noRespawn = !noRespawn;
 if (kDown & KEY_Y)
 randSphere = !randSphere;
 if (kDown & KEY_B)
 multiplyW = !multiplyW;
 if (kDown & KEY_R)
 additiveBlend = !additiveBlend;
 
 printf("\x1b[3;1Htime: %f \n", curTime);
 printf("\x1b[4;1HnoRespawn: %s \n", noRespawn ? "Yes" : "No");
 printf("\x1b[5;1HrandSphere: %s \n", randSphere ? "Yes" : "No");
 printf("\x1b[6;1HmultiplyW: %s \n", multiplyW ? "Yes" : "No");
 printf("\x1b[7;1HadditiveBlend: %s \n", additiveBlend ? "Yes" : "No");
 printf("\x1b[29;1Hgpu: %5.2f%% cpu: %5.2f%% buf:%5.2f%%\n", C3D_GetDrawingTime()*6, C3D_GetProcessingTime()*6, C3D_GetCmdBufUsage()*100);
 
 // Render the scene
 C3D_FrameBegin(C3D_FRAME_SYNCDRAW);
 {
 C3D_RenderTargetClear(targetLeft, C3D_CLEAR_ALL, CLEAR_COLOR, 0);
 C3D_FrameDrawOn(targetLeft);
 sceneRender(-iod);
 
 if (iod > 0.0f)
 {
 C3D_RenderTargetClear(targetRight, C3D_CLEAR_ALL, CLEAR_COLOR, 0);
 C3D_FrameDrawOn(targetRight);
 sceneRender(iod);
 }
 }
 C3D_FrameEnd(0);
 }
 
 // Deinitialize the scene
 sceneExit();
 
 // Deinitialize graphics
 C3D_Fini();
 gfxExit();
 return 0;
}