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; }