youmuliu/stgsharp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Daily update on 20250721-223448 by Nitload Youmu. Additional Message : Rename StgSHarp.C to StgSharp.Native. Add SDL to repo.

Browse Source 
Signed-off-by: Nitload <YoumuLiu_NSI@whv0t.onmicrosoft.com>
This commit is contained in:
Nitload
2025-07-21 22:34:48 +08:00
parent c624a8ca38
commit 28ea5d1d1e
1215 changed files with 628924 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files
StgSharp.Native/sdl-src/video/vita/SDL_vitavideo.c
+588
View File
@@ -0,0 +1,588 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_internal.h"
#ifdef SDL_VIDEO_DRIVER_VITA
// SDL internals
#include "../SDL_sysvideo.h"
#include "../../events/SDL_mouse_c.h"
#include "../../events/SDL_keyboard_c.h"
// VITA declarations
#include <psp2/kernel/processmgr.h>
#include "SDL_vitavideo.h"
#include "SDL_vitatouch.h"
#include "SDL_vitakeyboard.h"
#include "SDL_vitamouse_c.h"
#include "SDL_vitaframebuffer.h"
#include "SDL_vitamessagebox.h"
#if defined(SDL_VIDEO_VITA_PVR)
#define VITA_GLES_GetProcAddress SDL_EGL_GetProcAddressInternal
#define VITA_GLES_UnloadLibrary SDL_EGL_UnloadLibrary
#define VITA_GLES_SetSwapInterval SDL_EGL_SetSwapInterval
#define VITA_GLES_GetSwapInterval SDL_EGL_GetSwapInterval
#define VITA_GLES_DestroyContext SDL_EGL_DestroyContext
#endif
SDL_Window *Vita_Window;
static void VITA_Destroy(SDL_VideoDevice *device)
{
SDL_free(device->internal);
SDL_free(device);
}
static SDL_VideoDevice *VITA_Create(void)
{
SDL_VideoDevice *device;
SDL_VideoData *phdata;
#ifdef SDL_VIDEO_VITA_PIB
SDL_GLDriverData *gldata;
#endif
// Initialize SDL_VideoDevice structure
device = (SDL_VideoDevice *)SDL_calloc(1, sizeof(SDL_VideoDevice));
if (!device) {
return NULL;
}
// Initialize internal VITA specific data
phdata = (SDL_VideoData *)SDL_calloc(1, sizeof(SDL_VideoData));
if (!phdata) {
SDL_free(device);
return NULL;
}
#ifdef SDL_VIDEO_VITA_PIB
gldata = (SDL_GLDriverData *)SDL_calloc(1, sizeof(SDL_GLDriverData));
if (!gldata) {
SDL_free(device);
SDL_free(phdata);
return NULL;
}
device->gl_data = gldata;
phdata->egl_initialized = true;
#endif
phdata->ime_active = false;
device->internal = phdata;
// Setup amount of available displays and current display
device->num_displays = 0;
// Set device free function
device->free = VITA_Destroy;
// Setup all functions which we can handle
device->VideoInit = VITA_VideoInit;
device->VideoQuit = VITA_VideoQuit;
device->CreateSDLWindow = VITA_CreateWindow;
device->SetWindowTitle = VITA_SetWindowTitle;
device->SetWindowPosition = VITA_SetWindowPosition;
device->SetWindowSize = VITA_SetWindowSize;
device->ShowWindow = VITA_ShowWindow;
device->HideWindow = VITA_HideWindow;
device->RaiseWindow = VITA_RaiseWindow;
device->MaximizeWindow = VITA_MaximizeWindow;
device->MinimizeWindow = VITA_MinimizeWindow;
device->RestoreWindow = VITA_RestoreWindow;
device->SetWindowMouseGrab = VITA_SetWindowGrab;
device->SetWindowKeyboardGrab = VITA_SetWindowGrab;
device->DestroyWindow = VITA_DestroyWindow;
/*
// Disabled, causes issues on high-framerate updates. SDL still emulates this.
device->CreateWindowFramebuffer = VITA_CreateWindowFramebuffer;
device->UpdateWindowFramebuffer = VITA_UpdateWindowFramebuffer;
device->DestroyWindowFramebuffer = VITA_DestroyWindowFramebuffer;
*/
#if defined(SDL_VIDEO_VITA_PIB) || defined(SDL_VIDEO_VITA_PVR)
#ifdef SDL_VIDEO_VITA_PVR_OGL
if (SDL_GetHintBoolean(SDL_HINT_VITA_PVR_OPENGL, false)) {
device->GL_LoadLibrary = VITA_GL_LoadLibrary;
device->GL_CreateContext = VITA_GL_CreateContext;
device->GL_GetProcAddress = VITA_GL_GetProcAddress;
} else {
#endif
device->GL_LoadLibrary = VITA_GLES_LoadLibrary;
device->GL_CreateContext = VITA_GLES_CreateContext;
device->GL_GetProcAddress = VITA_GLES_GetProcAddress;
#ifdef SDL_VIDEO_VITA_PVR_OGL
}
#endif
device->GL_UnloadLibrary = VITA_GLES_UnloadLibrary;
device->GL_MakeCurrent = VITA_GLES_MakeCurrent;
device->GL_SetSwapInterval = VITA_GLES_SetSwapInterval;
device->GL_GetSwapInterval = VITA_GLES_GetSwapInterval;
device->GL_SwapWindow = VITA_GLES_SwapWindow;
device->GL_DestroyContext = VITA_GLES_DestroyContext;
#endif
device->HasScreenKeyboardSupport = VITA_HasScreenKeyboardSupport;
device->ShowScreenKeyboard = VITA_ShowScreenKeyboard;
device->HideScreenKeyboard = VITA_HideScreenKeyboard;
device->IsScreenKeyboardShown = VITA_IsScreenKeyboardShown;
device->PumpEvents = VITA_PumpEvents;
device->device_caps = VIDEO_DEVICE_CAPS_FULLSCREEN_ONLY;
return device;
}
VideoBootStrap VITA_bootstrap = {
"vita",
"VITA Video Driver",
VITA_Create,
VITA_ShowMessageBox,
false
};
/*****************************************************************************/
// SDL Video and Display initialization/handling functions
/*****************************************************************************/
bool VITA_VideoInit(SDL_VideoDevice *_this)
{
SDL_DisplayMode mode;
#ifdef SDL_VIDEO_VITA_PVR
const char *res = SDL_GetHint(SDL_HINT_VITA_RESOLUTION);
#endif
SDL_zero(mode);
#ifdef SDL_VIDEO_VITA_PVR
if (res) {
// 1088i for PSTV (Or Sharpscale)
if (SDL_strncmp(res, "1080", 4) == 0) {
mode.w = 1920;
mode.h = 1088;
}
// 725p for PSTV (Or Sharpscale)
else if (SDL_strncmp(res, "720", 3) == 0) {
mode.w = 1280;
mode.h = 725;
}
}
// 544p
else {
#endif
mode.w = 960;
mode.h = 544;
#ifdef SDL_VIDEO_VITA_PVR
}
#endif
mode.refresh_rate = 60.0f;
// 32 bpp for default
mode.format = SDL_PIXELFORMAT_ABGR8888;
if (SDL_AddBasicVideoDisplay(&mode) == 0) {
return false;
}
VITA_InitTouch();
VITA_InitKeyboard();
VITA_InitMouse();
return true;
}
void VITA_VideoQuit(SDL_VideoDevice *_this)
{
VITA_QuitTouch();
}
bool VITA_CreateWindow(SDL_VideoDevice *_this, SDL_Window *window, SDL_PropertiesID create_props)
{
SDL_WindowData *wdata;
#ifdef SDL_VIDEO_VITA_PVR
Psp2NativeWindow win;
int temp_major = 2;
int temp_minor = 1;
int temp_profile = 0;
#endif
// Allocate window internal data
wdata = (SDL_WindowData *)SDL_calloc(1, sizeof(SDL_WindowData));
if (!wdata) {
return false;
}
// Setup driver data for this window
window->internal = wdata;
// Vita can only have one window
if (Vita_Window) {
return SDL_SetError("Only one window supported");
}
Vita_Window = window;
#ifdef SDL_VIDEO_VITA_PVR
win.type = PSP2_DRAWABLE_TYPE_WINDOW;
win.numFlipBuffers = 2;
win.flipChainThrdAffinity = 0x20000;
// 1088i for PSTV (Or Sharpscale)
if (window->w == 1920) {
win.windowSize = PSP2_WINDOW_1920X1088;
}
// 725p for PSTV (Or Sharpscale)
else if (window->w == 1280) {
win.windowSize = PSP2_WINDOW_1280X725;
}
// 544p
else {
win.windowSize = PSP2_WINDOW_960X544;
}
if (window->flags & SDL_WINDOW_OPENGL) {
bool use_opengl = SDL_GetHintBoolean(SDL_HINT_VITA_PVR_OPENGL, false);
if (use_opengl) {
// Set version to 2.1 and PROFILE to ES
temp_major = _this->gl_config.major_version;
temp_minor = _this->gl_config.minor_version;
temp_profile = _this->gl_config.profile_mask;
_this->gl_config.major_version = 2;
_this->gl_config.minor_version = 1;
_this->gl_config.profile_mask = SDL_GL_CONTEXT_PROFILE_ES;
}
wdata->egl_surface = SDL_EGL_CreateSurface(_this, window, &win);
if (wdata->egl_surface == EGL_NO_SURFACE) {
return SDL_SetError("Could not create GLES window surface");
}
if (use_opengl) {
// Revert
_this->gl_config.major_version = temp_major;
_this->gl_config.minor_version = temp_minor;
_this->gl_config.profile_mask = temp_profile;
}
}
#endif
// fix input, we need to find a better way
SDL_SetKeyboardFocus(window);
// Window has been successfully created
return true;
}
void VITA_SetWindowTitle(SDL_VideoDevice *_this, SDL_Window *window)
{
}
bool VITA_SetWindowPosition(SDL_VideoDevice *_this, SDL_Window *window)
{
return SDL_Unsupported();
}
void VITA_SetWindowSize(SDL_VideoDevice *_this, SDL_Window *window)
{
}
void VITA_ShowWindow(SDL_VideoDevice *_this, SDL_Window *window)
{
}
void VITA_HideWindow(SDL_VideoDevice *_this, SDL_Window *window)
{
}
void VITA_RaiseWindow(SDL_VideoDevice *_this, SDL_Window *window)
{
}
void VITA_MaximizeWindow(SDL_VideoDevice *_this, SDL_Window *window)
{
}
void VITA_MinimizeWindow(SDL_VideoDevice *_this, SDL_Window *window)
{
}
void VITA_RestoreWindow(SDL_VideoDevice *_this, SDL_Window *window)
{
}
bool VITA_SetWindowGrab(SDL_VideoDevice *_this, SDL_Window *window, bool grabbed)
{
return true;
}
void VITA_DestroyWindow(SDL_VideoDevice *_this, SDL_Window *window)
{
SDL_WindowData *data;
data = window->internal;
if (data) {
// TODO: should we destroy egl context? No one sane should recreate ogl window as non-ogl
SDL_free(data);
}
window->internal = NULL;
Vita_Window = NULL;
}
bool VITA_HasScreenKeyboardSupport(SDL_VideoDevice *_this)
{
return true;
}
#ifndef SCE_IME_LANGUAGE_ENGLISH_US
#define SCE_IME_LANGUAGE_ENGLISH_US SCE_IME_LANGUAGE_ENGLISH
#endif
static void utf16_to_utf8(const uint16_t *src, uint8_t *dst)
{
int i;
for (i = 0; src[i]; i++) {
if (!(src[i] & 0xFF80)) {
*(dst++) = src[i] & 0xFF;
} else if (!(src[i] & 0xF800)) {
*(dst++) = ((src[i] >> 6) & 0xFF) | 0xC0;
*(dst++) = (src[i] & 0x3F) | 0x80;
} else if ((src[i] & 0xFC00) == 0xD800 && (src[i + 1] & 0xFC00) == 0xDC00) {
*(dst++) = (((src[i] + 64) >> 8) & 0x3) | 0xF0;
*(dst++) = (((src[i] >> 2) + 16) & 0x3F) | 0x80;
*(dst++) = ((src[i] >> 4) & 0x30) | 0x80 | ((src[i + 1] << 2) & 0xF);
*(dst++) = (src[i + 1] & 0x3F) | 0x80;
i += 1;
} else {
*(dst++) = ((src[i] >> 12) & 0xF) | 0xE0;
*(dst++) = ((src[i] >> 6) & 0x3F) | 0x80;
*(dst++) = (src[i] & 0x3F) | 0x80;
}
}
*dst = '\0';
}
#ifdef SDL_VIDEO_VITA_PVR
SceWChar16 libime_out[SCE_IME_MAX_PREEDIT_LENGTH + SCE_IME_MAX_TEXT_LENGTH + 1];
char libime_initval[8] = { 1 };
SceImeCaret caret_rev;
void VITA_ImeEventHandler(void *arg, const SceImeEventData *e)
{
SDL_VideoData *videodata = (SDL_VideoData *)arg;
uint8_t utf8_buffer[SCE_IME_MAX_TEXT_LENGTH];
switch (e->id) {
case SCE_IME_EVENT_UPDATE_TEXT:
if (e->param.text.caretIndex == 0) {
SDL_SendKeyboardKeyAutoRelease(0, SDL_SCANCODE_BACKSPACE);
sceImeSetText((SceWChar16 *)libime_initval, 4);
} else {
utf16_to_utf8((SceWChar16 *)&libime_out[1], utf8_buffer);
if (utf8_buffer[0] == ' ') {
SDL_SendKeyboardKeyAutoRelease(0, SDL_SCANCODE_SPACE);
} else {
SDL_SendKeyboardText((const char *)utf8_buffer);
}
SDL_memset(&caret_rev, 0, sizeof(SceImeCaret));
SDL_memset(libime_out, 0, ((SCE_IME_MAX_PREEDIT_LENGTH + SCE_IME_MAX_TEXT_LENGTH + 1) * sizeof(SceWChar16)));
caret_rev.index = 1;
sceImeSetCaret(&caret_rev);
sceImeSetText((SceWChar16 *)libime_initval, 4);
}
break;
case SCE_IME_EVENT_PRESS_ENTER:
SDL_SendKeyboardKeyAutoRelease(0, SDL_SCANCODE_RETURN);
break;
case SCE_IME_EVENT_PRESS_CLOSE:
sceImeClose();
videodata->ime_active = false;
break;
}
}
#endif
void VITA_ShowScreenKeyboard(SDL_VideoDevice *_this, SDL_Window *window, SDL_PropertiesID props)
{
SDL_VideoData *videodata = _this->internal;
SceInt32 res;
#ifdef SDL_VIDEO_VITA_PVR
SceUInt32 libime_work[SCE_IME_WORK_BUFFER_SIZE / sizeof(SceInt32)];
SceImeParam param;
sceImeParamInit(&param);
SDL_memset(libime_out, 0, ((SCE_IME_MAX_PREEDIT_LENGTH + SCE_IME_MAX_TEXT_LENGTH + 1) * sizeof(SceWChar16)));
param.supportedLanguages = SCE_IME_LANGUAGE_ENGLISH_US;
param.languagesForced = SCE_FALSE;
switch (SDL_GetTextInputType(props)) {
default:
case SDL_TEXTINPUT_TYPE_TEXT:
param.type = SCE_IME_TYPE_DEFAULT;
break;
case SDL_TEXTINPUT_TYPE_TEXT_NAME:
param.type = SCE_IME_TYPE_DEFAULT;
break;
case SDL_TEXTINPUT_TYPE_TEXT_EMAIL:
param.type = SCE_IME_TYPE_MAIL;
break;
case SDL_TEXTINPUT_TYPE_TEXT_USERNAME:
param.type = SCE_IME_TYPE_DEFAULT;
break;
case SDL_TEXTINPUT_TYPE_TEXT_PASSWORD_HIDDEN:
param.type = SCE_IME_TYPE_DEFAULT;
break;
case SDL_TEXTINPUT_TYPE_TEXT_PASSWORD_VISIBLE:
param.type = SCE_IME_TYPE_DEFAULT;
break;
case SDL_TEXTINPUT_TYPE_NUMBER:
param.type = SCE_IME_TYPE_NUMBER;
break;
case SDL_TEXTINPUT_TYPE_NUMBER_PASSWORD_HIDDEN:
param.type = SCE_IME_TYPE_NUMBER;
break;
case SDL_TEXTINPUT_TYPE_NUMBER_PASSWORD_VISIBLE:
param.type = SCE_IME_TYPE_NUMBER;
break;
}
param.option = 0;
if (SDL_GetTextInputCapitalization(props) != SDL_CAPITALIZE_SENTENCES) {
param.option |= SCE_IME_OPTION_NO_AUTO_CAPITALIZATION;
}
if (!SDL_GetTextInputAutocorrect(props)) {
param.option |= SCE_IME_OPTION_NO_ASSISTANCE;
}
if (SDL_GetTextInputMultiline(props)) {
param.option |= SCE_IME_OPTION_MULTILINE;
}
param.inputTextBuffer = libime_out;
param.maxTextLength = SCE_IME_MAX_TEXT_LENGTH;
param.handler = VITA_ImeEventHandler;
param.filter = NULL;
param.initialText = (SceWChar16 *)libime_initval;
param.arg = videodata;
param.work = libime_work;
res = sceImeOpen(&param);
if (res < 0) {
SDL_SetError("Failed to init IME");
return;
}
#else
SceWChar16 *title = u"";
SceWChar16 *text = u"";
SceImeDialogParam param;
sceImeDialogParamInit(&param);
param.supportedLanguages = 0;
param.languagesForced = SCE_FALSE;
param.type = SCE_IME_TYPE_DEFAULT;
param.option = 0;
param.textBoxMode = SCE_IME_DIALOG_TEXTBOX_MODE_WITH_CLEAR;
param.maxTextLength = SCE_IME_DIALOG_MAX_TEXT_LENGTH;
param.title = title;
param.initialText = text;
param.inputTextBuffer = videodata->ime_buffer;
res = sceImeDialogInit(&param);
if (res < 0) {
SDL_SetError("Failed to init IME dialog");
return;
}
#endif
videodata->ime_active = true;
}
void VITA_HideScreenKeyboard(SDL_VideoDevice *_this, SDL_Window *window)
{
#ifndef SDL_VIDEO_VITA_PVR
SDL_VideoData *videodata = _this->internal;
SceCommonDialogStatus dialogStatus = sceImeDialogGetStatus();
switch (dialogStatus) {
default:
case SCE_COMMON_DIALOG_STATUS_NONE:
case SCE_COMMON_DIALOG_STATUS_RUNNING:
break;
case SCE_COMMON_DIALOG_STATUS_FINISHED:
sceImeDialogTerm();
break;
}
videodata->ime_active = false;
#endif
}
bool VITA_IsScreenKeyboardShown(SDL_VideoDevice *_this, SDL_Window *window)
{
#ifdef SDL_VIDEO_VITA_PVR
SDL_VideoData *videodata = _this->internal;
return videodata->ime_active;
#else
SceCommonDialogStatus dialogStatus = sceImeDialogGetStatus();
return dialogStatus == SCE_COMMON_DIALOG_STATUS_RUNNING;
#endif
}
void VITA_PumpEvents(SDL_VideoDevice *_this)
{
#ifndef SDL_VIDEO_VITA_PVR
SDL_VideoData *videodata = _this->internal;
#endif
if (_this->suspend_screensaver) {
// cancel all idle timers to prevent vita going to sleep
sceKernelPowerTick(SCE_KERNEL_POWER_TICK_DEFAULT);
}
VITA_PollTouch();
VITA_PollKeyboard();
VITA_PollMouse();
#ifndef SDL_VIDEO_VITA_PVR
if (videodata->ime_active == true) {
// update IME status. Terminate, if finished
SceCommonDialogStatus dialogStatus = sceImeDialogGetStatus();
if (dialogStatus == SCE_COMMON_DIALOG_STATUS_FINISHED) {
uint8_t utf8_buffer[SCE_IME_DIALOG_MAX_TEXT_LENGTH];
SceImeDialogResult result;
SDL_memset(&result, 0, sizeof(SceImeDialogResult));
sceImeDialogGetResult(&result);
// Convert UTF16 to UTF8
utf16_to_utf8(videodata->ime_buffer, utf8_buffer);
// Send SDL event
SDL_SendKeyboardText((const char *)utf8_buffer);
// Send enter key only on enter
if (result.button == SCE_IME_DIALOG_BUTTON_ENTER) {
SDL_SendKeyboardKeyAutoRelease(0, SDL_SCANCODE_RETURN);
}
sceImeDialogTerm();
videodata->ime_active = false;
}
}
#endif
}
#endif // SDL_VIDEO_DRIVER_VITA