void initVitaShell() {
// Init
if (sceSysmoduleIsLoaded(SCE_SYSMODULE_NET) != SCE_SYSMODULE_LOADED)
sceSysmoduleLoadModule(SCE_SYSMODULE_NET);
sceSysmoduleLoadModule(SCE_SYSMODULE_PGF);
initSceAppUtil();
initVita2dLib();
}
static void frontend_psp_init(void *data)
{
#ifndef IS_SALAMANDER
#ifdef VITA
scePowerSetArmClockFrequency(444);
sceSysmoduleLoadModule(SCE_SYSMODULE_NET);
pthread_init();
#else
(void)data;
/* initialize debug screen */
pspDebugScreenInit();
pspDebugScreenClear();
setup_callback();
pspFpuSetEnable(0); /* disable FPU exceptions */
scePowerSetClockFrequency(333,333,166);
#endif
#endif
#if defined(HAVE_KERNEL_PRX) || defined(IS_SALAMANDER)
#ifndef VITA
pspSdkLoadStartModule("kernel_functions.prx", PSP_MEMORY_PARTITION_KERNEL);
#endif
#endif
}
void console_init()
{
SceNetInitParam initparam;
if (console_initialzed) {
return;
}
console_mtx = sceKernelCreateMutex("console_mutex", 0, 0, NULL);
if (sceSysmoduleIsLoaded(SCE_SYSMODULE_NET) != SCE_SYSMODULE_LOADED)
sceSysmoduleLoadModule(SCE_SYSMODULE_NET);
if (sceNetShowNetstat() == SCE_NET_ERROR_ENOTINIT) {
net_memory = malloc(NET_INIT_SIZE);
initparam.memory = net_memory;
initparam.size = NET_INIT_SIZE;
initparam.flags = 0;
sceNetInit(&initparam);
}
sock = sceNetSocket("netdbg", SCE_NET_AF_INET, SCE_NET_SOCK_DGRAM, 0);
memset(&target, 0, sizeof(target));
target.sin_family = SCE_NET_AF_INET;
target.sin_port = sceNetHtons(3490);
sceNetInetPton(SCE_NET_AF_INET, "192.168.1.104", &target.sin_addr);
console_initialzed = 1;
}
cothread_t co_active(void)
{
if(!co_active_)
{
sceSysmoduleLoadModule(SCE_SYSMODULE_FIBER);
co_active_ = (cothread_t)1;
}
return co_active_;
}
Pass::Pass(xml_node<>* passNode, std::string& directory, int passIndex, std::string& threadMethod, int numThreads, std::string& ioMethod) :
directory(directory), passIndex(passIndex), threadMethod(threadMethod), ioMethod(ioMethod) {
numFrames = convertStringToNumber<int>(passNode->first_attribute("frames")->value());
if (threadMethod == "tp" || threadMethod == "p") {
threadCount = numThreads;
}
else {
threadCount = convertStringToNumber<int>(passNode->first_attribute("threads")->value());
}
for (xml_node<>* moveNode = passNode->first_node(); moveNode; moveNode = moveNode->next_sibling()) {
moves.push_back(Move(moveNode));
}
int ret = sceSysmoduleLoadModule(SCE_SYSMODULE_FIBER);
assert(ret == SCE_OK);
}
cothread_t co_create(unsigned int heapsize, void (*coentry)(void))
{
SceFiber* tailFiber = malloc(sizeof(SceFiber));
char * m_contextBuffer = malloc(sizeof(char)*heapsize);
if(!co_active_)
{
sceSysmoduleLoadModule(SCE_SYSMODULE_FIBER);
co_active_ = (cothread_t)1;
}
//_sceFiberInitializeImpl
int ret = _sceFiberInitializeImpl(tailFiber, "tailFiber", co_thunk, (uint32_t)coentry, (void*) m_contextBuffer, heapsize, NULL);
if(ret==0){
return (cothread_t)tailFiber;
}else{
return (cothread_t)ret;
}
}
int main()
{
lua_State *lua = luaL_newstate();
lua_atpanic(lua, panic);
// Net init
sceSysmoduleLoadModule(SCE_SYSMODULE_NET);
SceNetInitParam netInitParam;
int size = 1024 * 512;
netInitParam.memory = malloc(size);
netInitParam.size = size;
netInitParam.flags = 0;
sceNetInit(&netInitParam);
sceSysmoduleLoadModule(SCE_SYSMODULE_HTTP);
#ifdef DEBUGGER_IP
debugNetInit(DEBUGGER_IP, DEBUGGER_PORT, DEBUG);
#endif
sceHttpInit(1024 * 50);
// Init libs
debugf("Init libs....\n");
debugf("vita2d...\n");
vita2d_init();
debugf("physfs\n");
PHYSFS_init(NULL);
debugf("lualibs\n");
luaL_openlibs(lua);
debugf("ffi\n");
open_ffi(lua);
lua_pushcfunction(lua, print);
lua_setglobal(lua, "print");
/*
// Display splash
unsigned int goal = 2*60;
unsigned int counter = 0;
vita2d_texture *tex = vita2d_load_PNG_buffer(splash_data);
SceCtrlData pad;
memset(&pad, 0, sizeof(pad));
for (;;) {
++counter;
if (counter >= goal)
break;
sceCtrlPeekBufferPositive(0, &pad, 1);
if (pad.buttons & SCE_CTRL_ANY)
break;
vita2d_start_drawing();
vita2d_clear_screen();
vita2d_draw_texture(tex, 0, 0);
vita2d_end_drawing();
vita2d_swap_buffers();
}
*/
debugf("[Lua] Loading app0:/lib/init.lua ...\n");
if(luaL_loadfile(lua, "app0:/lib/init.lua") == 0)
{
if(lua_pcall(lua, 0, 0, 0) != 0)
{
debugf("[Lua] init error: %s\n", lua_tostring(lua, -1));
lua_pop(lua, 1);
}
}
/*debugf("[Lua] Loading app0:/boot.lua ...\n");
if(luaL_loadfile(lua, "app0:/boot.lua") == 0)
{
if(lua_pcall(lua, 0, 0, 0) != 0)
{
debugf("[Lua] bootscript err: %s\n", lua_tostring(lua, -1));
lua_pop(lua, 1);
}
}
else
{
debugf("[Lua] bootscript load err: %s\n", lua_tostring(lua, -1));
lua_pop(lua, 1);
}*/
debugf("Deinit. Goodbye.\n");
sceHttpTerm();
PHYSFS_deinit();
vita2d_fini();
//vita2d_free_texture(tex);
sceKernelExitProcess(0);
return 0;
}
int vita2d_init_advanced(unsigned int temp_pool_size)
{
int err;
unsigned int i, x, y;
UNUSED(err);
if (vita2d_initialized) {
DEBUG("libvita2d is already initialized!\n");
return 1;
}
SceGxmInitializeParams initializeParams;
memset(&initializeParams, 0, sizeof(SceGxmInitializeParams));
initializeParams.flags = 0;
initializeParams.displayQueueMaxPendingCount = DISPLAY_MAX_PENDING_SWAPS;
initializeParams.displayQueueCallback = display_callback;
initializeParams.displayQueueCallbackDataSize = sizeof(vita2d_display_data);
initializeParams.parameterBufferSize = SCE_GXM_DEFAULT_PARAMETER_BUFFER_SIZE;
err = sceGxmInitialize(&initializeParams);
DEBUG("sceGxmInitialize(): 0x%08X\n", err);
// allocate ring buffer memory using default sizes
void *vdmRingBuffer = gpu_alloc(
SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE,
4,
SCE_GXM_MEMORY_ATTRIB_READ,
&vdmRingBufferUid);
void *vertexRingBuffer = gpu_alloc(
SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE,
4,
SCE_GXM_MEMORY_ATTRIB_READ,
&vertexRingBufferUid);
void *fragmentRingBuffer = gpu_alloc(
SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE,
4,
SCE_GXM_MEMORY_ATTRIB_READ,
&fragmentRingBufferUid);
unsigned int fragmentUsseRingBufferOffset;
void *fragmentUsseRingBuffer = fragment_usse_alloc(
SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE,
&fragmentUsseRingBufferUid,
&fragmentUsseRingBufferOffset);
memset(&contextParams, 0, sizeof(SceGxmContextParams));
contextParams.hostMem = malloc(SCE_GXM_MINIMUM_CONTEXT_HOST_MEM_SIZE);
contextParams.hostMemSize = SCE_GXM_MINIMUM_CONTEXT_HOST_MEM_SIZE;
contextParams.vdmRingBufferMem = vdmRingBuffer;
contextParams.vdmRingBufferMemSize = SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE;
contextParams.vertexRingBufferMem = vertexRingBuffer;
contextParams.vertexRingBufferMemSize = SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE;
contextParams.fragmentRingBufferMem = fragmentRingBuffer;
contextParams.fragmentRingBufferMemSize = SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE;
contextParams.fragmentUsseRingBufferMem = fragmentUsseRingBuffer;
contextParams.fragmentUsseRingBufferMemSize = SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE;
contextParams.fragmentUsseRingBufferOffset = fragmentUsseRingBufferOffset;
err = sceGxmCreateContext(&contextParams, &_vita2d_context);
DEBUG("sceGxmCreateContext(): 0x%08X\n", err);
// set up parameters
SceGxmRenderTargetParams renderTargetParams;
memset(&renderTargetParams, 0, sizeof(SceGxmRenderTargetParams));
renderTargetParams.flags = 0;
renderTargetParams.width = DISPLAY_WIDTH;
renderTargetParams.height = DISPLAY_HEIGHT;
renderTargetParams.scenesPerFrame = 1;
renderTargetParams.multisampleMode = MSAA_MODE;
renderTargetParams.multisampleLocations = 0;
renderTargetParams.driverMemBlock = -1; // Invalid UID
// create the render target
err = sceGxmCreateRenderTarget(&renderTargetParams, &renderTarget);
DEBUG("sceGxmCreateRenderTarget(): 0x%08X\n", err);
// allocate memory and sync objects for display buffers
for (i = 0; i < DISPLAY_BUFFER_COUNT; i++) {
// allocate memory for display
displayBufferData[i] = gpu_alloc(
SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW,
4*DISPLAY_STRIDE_IN_PIXELS*DISPLAY_HEIGHT,
SCE_GXM_COLOR_SURFACE_ALIGNMENT,
SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
&displayBufferUid[i]);
// memset the buffer to black
for (y = 0; y < DISPLAY_HEIGHT; y++) {
unsigned int *row = (unsigned int *)displayBufferData[i] + y*DISPLAY_STRIDE_IN_PIXELS;
for (x = 0; x < DISPLAY_WIDTH; x++) {
row[x] = 0xff000000;
}
}
// initialize a color surface for this display buffer
err = sceGxmColorSurfaceInit(
&displaySurface[i],
DISPLAY_COLOR_FORMAT,
SCE_GXM_COLOR_SURFACE_LINEAR,
(MSAA_MODE == SCE_GXM_MULTISAMPLE_NONE) ? SCE_GXM_COLOR_SURFACE_SCALE_NONE : SCE_GXM_COLOR_SURFACE_SCALE_MSAA_DOWNSCALE,
SCE_GXM_OUTPUT_REGISTER_SIZE_32BIT,
DISPLAY_WIDTH,
DISPLAY_HEIGHT,
DISPLAY_STRIDE_IN_PIXELS,
displayBufferData[i]);
// create a sync object that we will associate with this buffer
err = sceGxmSyncObjectCreate(&displayBufferSync[i]);
}
// compute the memory footprint of the depth buffer
const unsigned int alignedWidth = ALIGN(DISPLAY_WIDTH, SCE_GXM_TILE_SIZEX);
const unsigned int alignedHeight = ALIGN(DISPLAY_HEIGHT, SCE_GXM_TILE_SIZEY);
unsigned int sampleCount = alignedWidth*alignedHeight;
unsigned int depthStrideInSamples = alignedWidth;
if (MSAA_MODE == SCE_GXM_MULTISAMPLE_4X) {
// samples increase in X and Y
sampleCount *= 4;
depthStrideInSamples *= 2;
} else if (MSAA_MODE == SCE_GXM_MULTISAMPLE_2X) {
// samples increase in Y only
sampleCount *= 2;
}
// allocate the depth buffer
depthBufferData = gpu_alloc(
SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
4*sampleCount,
SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT,
SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
&depthBufferUid);
// create the SceGxmDepthStencilSurface structure
err = sceGxmDepthStencilSurfaceInit(
&depthSurface,
SCE_GXM_DEPTH_STENCIL_FORMAT_S8D24,
SCE_GXM_DEPTH_STENCIL_SURFACE_TILED,
depthStrideInSamples,
depthBufferData,
NULL);
// set buffer sizes for this sample
const unsigned int patcherBufferSize = 64*1024;
const unsigned int patcherVertexUsseSize = 64*1024;
const unsigned int patcherFragmentUsseSize = 64*1024;
// allocate memory for buffers and USSE code
void *patcherBuffer = gpu_alloc(
SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
patcherBufferSize,
4,
SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
&patcherBufferUid);
unsigned int patcherVertexUsseOffset;
void *patcherVertexUsse = vertex_usse_alloc(
patcherVertexUsseSize,
&patcherVertexUsseUid,
&patcherVertexUsseOffset);
unsigned int patcherFragmentUsseOffset;
void *patcherFragmentUsse = fragment_usse_alloc(
patcherFragmentUsseSize,
&patcherFragmentUsseUid,
&patcherFragmentUsseOffset);
// create a shader patcher
SceGxmShaderPatcherParams patcherParams;
memset(&patcherParams, 0, sizeof(SceGxmShaderPatcherParams));
patcherParams.userData = NULL;
patcherParams.hostAllocCallback = &patcher_host_alloc;
patcherParams.hostFreeCallback = &patcher_host_free;
patcherParams.bufferAllocCallback = NULL;
patcherParams.bufferFreeCallback = NULL;
patcherParams.bufferMem = patcherBuffer;
patcherParams.bufferMemSize = patcherBufferSize;
patcherParams.vertexUsseAllocCallback = NULL;
patcherParams.vertexUsseFreeCallback = NULL;
patcherParams.vertexUsseMem = patcherVertexUsse;
patcherParams.vertexUsseMemSize = patcherVertexUsseSize;
patcherParams.vertexUsseOffset = patcherVertexUsseOffset;
patcherParams.fragmentUsseAllocCallback = NULL;
patcherParams.fragmentUsseFreeCallback = NULL;
patcherParams.fragmentUsseMem = patcherFragmentUsse;
patcherParams.fragmentUsseMemSize = patcherFragmentUsseSize;
patcherParams.fragmentUsseOffset = patcherFragmentUsseOffset;
err = sceGxmShaderPatcherCreate(&patcherParams, &shaderPatcher);
DEBUG("sceGxmShaderPatcherCreate(): 0x%08X\n", err);
// check the shaders
err = sceGxmProgramCheck(clearVertexProgramGxp);
DEBUG("clear_v sceGxmProgramCheck(): 0x%08X\n", err);
err = sceGxmProgramCheck(clearFragmentProgramGxp);
DEBUG("clear_f sceGxmProgramCheck(): 0x%08X\n", err);
err = sceGxmProgramCheck(colorVertexProgramGxp);
DEBUG("color_v sceGxmProgramCheck(): 0x%08X\n", err);
err = sceGxmProgramCheck(colorFragmentProgramGxp);
DEBUG("color_f sceGxmProgramCheck(): 0x%08X\n", err);
err = sceGxmProgramCheck(textureVertexProgramGxp);
DEBUG("texture_v sceGxmProgramCheck(): 0x%08X\n", err);
err = sceGxmProgramCheck(textureFragmentProgramGxp);
DEBUG("texture_f sceGxmProgramCheck(): 0x%08X\n", err);
err = sceGxmProgramCheck(textureTintFragmentProgramGxp);
DEBUG("texture_tint_f sceGxmProgramCheck(): 0x%08X\n", err);
// register programs with the patcher
err = sceGxmShaderPatcherRegisterProgram(shaderPatcher, clearVertexProgramGxp, &clearVertexProgramId);
DEBUG("clear_v sceGxmShaderPatcherRegisterProgram(): 0x%08X\n", err);
err = sceGxmShaderPatcherRegisterProgram(shaderPatcher, clearFragmentProgramGxp, &clearFragmentProgramId);
DEBUG("clear_f sceGxmShaderPatcherRegisterProgram(): 0x%08X\n", err);
err = sceGxmShaderPatcherRegisterProgram(shaderPatcher, colorVertexProgramGxp, &colorVertexProgramId);
DEBUG("color_v sceGxmShaderPatcherRegisterProgram(): 0x%08X\n", err);
err = sceGxmShaderPatcherRegisterProgram(shaderPatcher, colorFragmentProgramGxp, &colorFragmentProgramId);
DEBUG("color_f sceGxmShaderPatcherRegisterProgram(): 0x%08X\n", err);
err = sceGxmShaderPatcherRegisterProgram(shaderPatcher, textureVertexProgramGxp, &textureVertexProgramId);
DEBUG("texture_v sceGxmShaderPatcherRegisterProgram(): 0x%08X\n", err);
err = sceGxmShaderPatcherRegisterProgram(shaderPatcher, textureFragmentProgramGxp, &textureFragmentProgramId);
DEBUG("texture_f sceGxmShaderPatcherRegisterProgram(): 0x%08X\n", err);
err = sceGxmShaderPatcherRegisterProgram(shaderPatcher, textureTintFragmentProgramGxp, &textureTintFragmentProgramId);
DEBUG("texture_tint_f sceGxmShaderPatcherRegisterProgram(): 0x%08X\n", err);
// Fill SceGxmBlendInfo
static const SceGxmBlendInfo blend_info = {
.colorFunc = SCE_GXM_BLEND_FUNC_ADD,
.alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
.colorSrc = SCE_GXM_BLEND_FACTOR_SRC_ALPHA,
.colorDst = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
.alphaSrc = SCE_GXM_BLEND_FACTOR_ONE,
.alphaDst = SCE_GXM_BLEND_FACTOR_ZERO,
.colorMask = SCE_GXM_COLOR_MASK_ALL
};
// get attributes by name to create vertex format bindings
const SceGxmProgramParameter *paramClearPositionAttribute = sceGxmProgramFindParameterByName(clearVertexProgramGxp, "aPosition");
// create clear vertex format
SceGxmVertexAttribute clearVertexAttributes[1];
SceGxmVertexStream clearVertexStreams[1];
clearVertexAttributes[0].streamIndex = 0;
clearVertexAttributes[0].offset = 0;
clearVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
clearVertexAttributes[0].componentCount = 2;
clearVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramClearPositionAttribute);
clearVertexStreams[0].stride = sizeof(vita2d_clear_vertex);
clearVertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
// create clear programs
err = sceGxmShaderPatcherCreateVertexProgram(
shaderPatcher,
clearVertexProgramId,
clearVertexAttributes,
1,
clearVertexStreams,
1,
&clearVertexProgram);
DEBUG("clear sceGxmShaderPatcherCreateVertexProgram(): 0x%08X\n", err);
err = sceGxmShaderPatcherCreateFragmentProgram(
shaderPatcher,
clearFragmentProgramId,
SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
MSAA_MODE,
NULL,
clearVertexProgramGxp,
&clearFragmentProgram);
DEBUG("clear sceGxmShaderPatcherCreateFragmentProgram(): 0x%08X\n", err);
// create the clear triangle vertex/index data
clearVertices = (vita2d_clear_vertex *)gpu_alloc(
SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
3*sizeof(vita2d_clear_vertex),
4,
SCE_GXM_MEMORY_ATTRIB_READ,
&clearVerticesUid);
clearIndices = (uint16_t *)gpu_alloc(
SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
3*sizeof(uint16_t),
2,
SCE_GXM_MEMORY_ATTRIB_READ,
&clearIndicesUid);
clearVertices[0].x = -1.0f;
clearVertices[0].y = -1.0f;
clearVertices[1].x = 3.0f;
clearVertices[1].y = -1.0f;
clearVertices[2].x = -1.0f;
clearVertices[2].y = 3.0f;
clearIndices[0] = 0;
clearIndices[1] = 1;
clearIndices[2] = 2;
const SceGxmProgramParameter *paramColorPositionAttribute = sceGxmProgramFindParameterByName(colorVertexProgramGxp, "aPosition");
DEBUG("aPosition sceGxmProgramFindParameterByName(): %p\n", paramColorPositionAttribute);
const SceGxmProgramParameter *paramColorColorAttribute = sceGxmProgramFindParameterByName(colorVertexProgramGxp, "aColor");
DEBUG("aColor sceGxmProgramFindParameterByName(): %p\n", paramColorColorAttribute);
// create color vertex format
SceGxmVertexAttribute colorVertexAttributes[2];
SceGxmVertexStream colorVertexStreams[1];
/* x,y,z: 3 float 32 bits */
colorVertexAttributes[0].streamIndex = 0;
colorVertexAttributes[0].offset = 0;
colorVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
colorVertexAttributes[0].componentCount = 3; // (x, y, z)
colorVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramColorPositionAttribute);
/* color: 4 unsigned char = 32 bits */
colorVertexAttributes[1].streamIndex = 0;
colorVertexAttributes[1].offset = 12; // (x, y, z) * 4 = 12 bytes
colorVertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_U8N;
colorVertexAttributes[1].componentCount = 4; // (color)
colorVertexAttributes[1].regIndex = sceGxmProgramParameterGetResourceIndex(paramColorColorAttribute);
// 16 bit (short) indices
colorVertexStreams[0].stride = sizeof(vita2d_color_vertex);
colorVertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
// create color shaders
err = sceGxmShaderPatcherCreateVertexProgram(
shaderPatcher,
colorVertexProgramId,
colorVertexAttributes,
2,
colorVertexStreams,
1,
&_vita2d_colorVertexProgram);
DEBUG("color sceGxmShaderPatcherCreateVertexProgram(): 0x%08X\n", err);
err = sceGxmShaderPatcherCreateFragmentProgram(
shaderPatcher,
colorFragmentProgramId,
SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
MSAA_MODE,
&blend_info,
colorVertexProgramGxp,
&_vita2d_colorFragmentProgram);
DEBUG("color sceGxmShaderPatcherCreateFragmentProgram(): 0x%08X\n", err);
const SceGxmProgramParameter *paramTexturePositionAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aPosition");
DEBUG("aPosition sceGxmProgramFindParameterByName(): %p\n", paramTexturePositionAttribute);
const SceGxmProgramParameter *paramTextureTexcoordAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aTexcoord");
DEBUG("aTexcoord sceGxmProgramFindParameterByName(): %p\n", paramTextureTexcoordAttribute);
// create texture vertex format
SceGxmVertexAttribute textureVertexAttributes[2];
SceGxmVertexStream textureVertexStreams[1];
/* x,y,z: 3 float 32 bits */
textureVertexAttributes[0].streamIndex = 0;
textureVertexAttributes[0].offset = 0;
textureVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
textureVertexAttributes[0].componentCount = 3; // (x, y, z)
textureVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramTexturePositionAttribute);
/* u,v: 2 floats 32 bits */
textureVertexAttributes[1].streamIndex = 0;
textureVertexAttributes[1].offset = 12; // (x, y, z) * 4 = 12 bytes
textureVertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
textureVertexAttributes[1].componentCount = 2; // (u, v)
textureVertexAttributes[1].regIndex = sceGxmProgramParameterGetResourceIndex(paramTextureTexcoordAttribute);
// 16 bit (short) indices
textureVertexStreams[0].stride = sizeof(vita2d_texture_vertex);
textureVertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
// create texture shaders
err = sceGxmShaderPatcherCreateVertexProgram(
shaderPatcher,
textureVertexProgramId,
textureVertexAttributes,
2,
textureVertexStreams,
1,
&_vita2d_textureVertexProgram);
DEBUG("texture sceGxmShaderPatcherCreateVertexProgram(): 0x%08X\n", err);
err = sceGxmShaderPatcherCreateFragmentProgram(
shaderPatcher,
textureFragmentProgramId,
SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
MSAA_MODE,
&blend_info,
textureVertexProgramGxp,
&_vita2d_textureFragmentProgram);
DEBUG("texture sceGxmShaderPatcherCreateFragmentProgram(): 0x%08X\n", err);
err = sceGxmShaderPatcherCreateFragmentProgram(
shaderPatcher,
textureTintFragmentProgramId,
SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
MSAA_MODE,
&blend_info,
textureVertexProgramGxp,
&_vita2d_textureTintFragmentProgram);
DEBUG("texture_tint sceGxmShaderPatcherCreateFragmentProgram(): 0x%08X\n", err);
// find vertex uniforms by name and cache parameter information
_vita2d_clearClearColorParam = sceGxmProgramFindParameterByName(clearFragmentProgramGxp, "uClearColor");
DEBUG("_vita2d_clearClearColorParam sceGxmProgramFindParameterByName(): %p\n", _vita2d_clearClearColorParam);
_vita2d_colorWvpParam = sceGxmProgramFindParameterByName(colorVertexProgramGxp, "wvp");
DEBUG("color wvp sceGxmProgramFindParameterByName(): %p\n", _vita2d_colorWvpParam);
_vita2d_textureWvpParam = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "wvp");
DEBUG("texture wvp sceGxmProgramFindParameterByName(): %p\n", _vita2d_textureWvpParam);
_vita2d_textureTintColorParam = sceGxmProgramFindParameterByName(textureTintFragmentProgramGxp, "uTintColor");
DEBUG("texture wvp sceGxmProgramFindParameterByName(): %p\n", _vita2d_textureWvpParam);
// Allocate memory for the memory pool
pool_size = temp_pool_size;
pool_addr = gpu_alloc(
SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
pool_size,
sizeof(void *),
SCE_GXM_MEMORY_ATTRIB_READ,
&poolUid);
matrix_init_orthographic(_vita2d_ortho_matrix, 0.0f, DISPLAY_WIDTH, DISPLAY_HEIGHT, 0.0f, 0.0f, 1.0f);
backBufferIndex = 0;
frontBufferIndex = 0;
pgf_module_was_loaded = sceSysmoduleIsLoaded(SCE_SYSMODULE_PGF);
if (pgf_module_was_loaded != SCE_SYSMODULE_LOADED)
sceSysmoduleLoadModule(SCE_SYSMODULE_PGF);
vita2d_initialized = 1;
return 1;
}
