{

const std::string external = SDL_GetAndroidExternalStoragePath();

const std::string dest = "/sdcard/kys-cpp/game/";

const std::string marker = dest + ".game_extracted";

auto create_parent_dirs = [](const std::string& path) {

size_t pos = path.find('/', 1);

while (pos != std::string::npos)

{

SDL_CreateDirectory(path.substr(0, pos).c_str());

pos = path.find('/', pos + 1);

}

SDL_CreateDirectory(path.c_str());

};

if (filefunc::fileExist(marker))

{

return;

}

SDL_Log("kys-cpp: extracting game assets to %s ...", dest.c_str());

SDL_IOStream* io = SDL_IOFromFile("game.zip", "rb");

if (!io)

{

SDL_Log("kys-cpp: cannot open game.zip from assets: %s", SDL_GetError());

return;

}

Sint64 size = SDL_GetIOSize(io);

std::string buf(size, '\0');

SDL_ReadIO(io, buf.data(), (size_t)size);

SDL_CloseIO(io);

const std::string tmp_zip = external + "/.game_tmp.zip";

filefunc::writeFile(buf.c_str(), (int)buf.size(), tmp_zip);

{

ZipFile2 zip;

zip.openRead(tmp_zip);

if (!zip.opened())

{

SDL_Log("kys-cpp: cannot open temp zip at %s", tmp_zip.c_str());

return;

}

for (const auto& f : zip.getFileNames())

{

std::string normalized = f;

for (char& c : normalized)

{

if (c == '\\')

{

c = '/';

}

}

if (normalized.empty() || normalized.back() == '/')

{

continue;

}

const std::string out_path = dest + normalized;

const size_t slash = out_path.rfind('/');

if (slash != std::string::npos)

{

create_parent_dirs(out_path.substr(0, slash));

}

const auto data = zip.readFile(f);

filefunc::writeFile(data.c_str(), (int)data.size(), out_path);

}

}

remove(tmp_zip.c_str());

filefunc::writeFile("ok", 2, marker);

SDL_Log("kys-cpp: assets extracted successfully.");

{

if (inited_)

{

return 0;

}

inited_ = true;

texture_top_left_highlight_enabled_ = GameUtil::getInstance()->getInt("game", "texture_top_left_highlight", 1) != 0;

#ifdef __ANDROID__

SDL_SetHint(SDL_HINT_ORIENTATIONS, "LandscapeLeft LandscapeRight");

#endif

#ifndef _WINDLL

if (!SDL_Init(SDL_INIT_EVENTS | SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_GAMEPAD | SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC | SDL_INIT_SENSOR))

{

return -1;

}

#endif

window_mode_ = handle_type;

auto create_window = [&]() -> Window*

{

if (handle)

{

#ifdef _WIN32

if (handle_type == 0)

{

Prop props;

props.set(SDL_PROP_WINDOW_CREATE_WIN32_HWND_POINTER, handle);

return SDL_CreateWindowWithProperties(props.id());

}

#endif

return (Window*)handle;

}

Prop props;

props.set(SDL_PROP_WINDOW_CREATE_RESIZABLE_BOOLEAN, true);

props.set(SDL_PROP_WINDOW_CREATE_MAXIMIZED_BOOLEAN, maximized);

#ifdef __ANDROID__

props.set(SDL_PROP_WINDOW_CREATE_FULLSCREEN_BOOLEAN, true);

#else

props.set(SDL_PROP_WINDOW_CREATE_FULLSCREEN_BOOLEAN, fullscreen != 0);

#endif

props.set(SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER, ui_w_);

props.set(SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER, ui_h_);

props.set(SDL_PROP_WINDOW_CREATE_TITLE_STRING, title_.c_str());

return SDL_CreateWindowWithProperties(props.id());

};

window_ = create_window();

if (!window_)

{

return -1;

}

#ifndef _WINDLL

SDL_ShowWindow(window_);

SDL_RaiseWindow(window_);

#endif

renderer_ = SDL_GetRenderer(window_);

std::print("{}\n", SDL_GetError());

if (renderer_ == nullptr)

{

Prop props;

props.set(SDL_PROP_RENDERER_CREATE_WINDOW_POINTER, window_);

std::vector<std::string> renderer_candidates;

auto add_renderer_candidate = [&renderer_candidates](const std::string& name)

{

if (name.empty()) { return; }

for (auto& existing : renderer_candidates)

{

if (existing == name) { return; }

}

renderer_candidates.push_back(name);

};

if (!str.empty())

{

auto str1 = strfunc::toLowerCase(str);

for (auto s : strfunc::splitString(str1, ","))

{

add_renderer_candidate(strfunc::trim(s));

}

}

#ifdef _WIN32

add_renderer_candidate("direct3d12");

add_renderer_candidate("direct3d");

#else

add_renderer_candidate("gpu");

add_renderer_candidate("opengles2");

#endif

add_renderer_candidate("opengl");

add_renderer_candidate("software");

for (auto& candidate : renderer_candidates)

{

SDL_SetHint(SDL_HINT_RENDER_DRIVER, candidate.c_str());

renderer_ = SDL_CreateRendererWithProperties(props.id());

if (renderer_)

{

std::print("Renderer fallback selected: {}\n", candidate);

renderer_self_ = true;

break;

}

}

if (renderer_ == nullptr)

{

renderer_ = SDL_CreateRendererWithProperties(props.id());

renderer_self_ = renderer_ != nullptr;

}

}

if (renderer_ == nullptr)

{

std::print("Failed to create renderer: {}\n", SDL_GetError());

return -1;

}

std::print("Renderer name: {}\n", SDL_GetRendererName(renderer_));

max_texture_size_ = (int)SDL_GetNumberProperty(SDL_GetRendererProperties(renderer_), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 0);

std::print("Max texture size: {}\n", max_texture_size_);

//SDL_SetDefaultTextureScaleMode(renderer_, SDL_SCALEMODE_PIXELART);

//SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1");

//SDL_EventState(SDL_EVENT_DROP_FILE, SDL_ENABLE);

//屏蔽触摸板

//SDL_EventState(SDL_EVENT_FINGER_UP, SDL_DISABLE);

//SDL_EventState(SDL_EVENT_FINGER_DOWN, SDL_DISABLE);

//SDL_EventState(SDL_EVENT_FINGER_MOTION, SDL_DISABLE);

//手柄

checkGameControllers();

int num_touch = 0;

SDL_GetTouchDevices(&num_touch);

std::print("Found {} touch(es)\n", num_touch);

rect_ = { 0, 0, ui_w_, ui_h_ };

renderPresent();

TTF_Init();

#ifdef _MSC_VER

RECT r;

SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&r, 0);

int w = GetSystemMetrics(SM_CXEDGE);

int h = GetSystemMetrics(SM_CYEDGE);

min_x_ = r.left + w;

min_y_ = r.top + h + GetSystemMetrics(SM_CYCAPTION);

max_x_ = r.right - w;

max_y_ = r.bottom - h;

#else

Rect r;

SDL_GetDisplayBounds(0, &r);

min_x_ = r.x;

min_y_ = r.y;

max_x_ = r.w + r.x;

max_y_ = r.h + r.y;

#endif

square_ = createRectTexture(100, 100, 0);

std::print("maximum width and height are: {}, {}\n", max_x_, max_y_);

createMainTexture(SDL_PixelFormat(0), TEXTUREACCESS_TARGET, ui_w_, ui_h_);

return 0;

{

int w, h;

getWindowSize(w, h);

return w;

{

int w, h;

getWindowSize(w, h);

return h;

{

if (b)

{

SDL_MaximizeWindow(window_);

}

else

{

SDL_RestoreWindow(window_);

}

{

if (getWindowIsMaximized())

{

return;

}

if (rotation_ == 90 || rotation_ == 270)

{

std::swap(w, h);

}

if (w <= 0 || h <= 0)

{

return;

}

//w = 1920;

//h = 1080;

win_w_ = std::min(max_x_ - min_x_, w);

win_h_ = std::min(max_y_ - min_y_, h);

double ratio;

ratio = std::min(1.0 * win_w_ / w, 1.0 * win_h_ / h);

win_w_ = w * ratio;

win_h_ = h * ratio;

//std::print("{}, {}, {}, {}, {}\n", win_w_, win_h_, w, h, ratio);

if (!window_)

{

return;

}

SDL_SetWindowSize(window_, win_w_, win_h_);

setPresentPosition(tex_);

SDL_ShowWindow(window_);

SDL_RaiseWindow(window_);

SDL_GetWindowSize(window_, &win_w_, &win_h_);

//std::print("{}, {}, {}, {}, {}\n", win_w_, win_h_, w, h, ratio);

//resetWindowsPosition();

//renderPresent();

{

int w, h;

getWindowSize(w, h);

if (x == WINDOWPOS_CENTERED)

{

x = min_x_ + (max_x_ - min_x_ - w) / 2;

}

if (y == WINDOWPOS_CENTERED)

{

y = min_y_ + (max_y_ - min_y_ - h) / 2;

}

SDL_SetWindowPosition(window_, x, y);

{

resetRenderTarget();

if (tex_)

{

SDL_DestroyTexture(tex_);

}

if (pixfmt < 0)

{

tex_ = createRenderedTexture(w, h);

}

else

{

tex_ = createTexture(pixfmt, a, w, h);

}

setPresentPosition(tex_);

{

float w0, h0;

uint32_t pix_fmt;

if (!SDL_GetTextureSize(tex_, &w0, &h0))

{

if (int(w0) != w || int(h0) != h)

{

//createMainTexture(pix_fmt, w, h);

}

}

{

//tex_ = createYUVTexture(w, h);

auto& tex = tex_map_[name];

if (tex)

{

SDL_DestroyTexture(tex);

}

int64_t pixfmt = 0;

SDL_GetNumberProperty(SDL_GetTextureProperties(tex_), SDL_PROP_TEXTURE_FORMAT_NUMBER, pixfmt);

tex = createTexture((SDL_PixelFormat)pixfmt, TEXTUREACCESS_TARGET, w, h);

//tex_ = createRenderedTexture(768, 480);

//SDL_SetTextureBlendMode(tex2_, SDL_BLENDMODE_BLEND);

{

if (!window_ || !tex_)

{

return false;

}

int windowW = 0;

int windowH = 0;

getWindowSize(windowW, windowH);

if (windowW <= 0 || windowH <= 0)

{

return false;

}

const int baseUiW = std::max(1, base_ui_w_);

const int baseUiH = std::max(1, base_ui_h_);

const double windowAspect = static_cast<double>(windowW) / windowH;

const double baseAspect = static_cast<double>(baseUiW) / baseUiH;

int newUiW = baseUiW;

int newUiH = baseUiH;

if (windowAspect >= baseAspect)

{

newUiW = std::max(baseUiW, static_cast<int>(std::round(windowAspect * baseUiH)));

}

else

{

newUiH = std::max(baseUiH, static_cast<int>(std::round(baseUiW / windowAspect)));

}

bool resized = false;

if (newUiW != ui_w_ || newUiH != ui_h_)

{

ui_w_ = newUiW;

ui_h_ = newUiH;

createMainTexture(SDL_PixelFormat(0), TEXTUREACCESS_TARGET, ui_w_, ui_h_);

resized = true;

}

auto sceneTexture = tex_map_.find("scene");

if (sceneTexture != tex_map_.end() && sceneTexture->second)

{

int sceneW = 0;

int sceneH = 0;

getTextureSize(sceneTexture->second, sceneW, sceneH);

const int newSceneH = std::max(1, sceneH > 0 ? sceneH : newUiH);

const int newSceneW = std::max(1, static_cast<int>(std::round(static_cast<double>(windowW) * newSceneH / windowH)));

if (newSceneW != sceneW || newSceneH != sceneH)

{

createAssistTexture("scene", newSceneW, newSceneH);

resized = true;

}

}

setPresentPosition(tex_);

return resized;

{

if (!tex)

{

return;

}

int w_dst = 0, h_dst = 0;

int w_src = 0, h_src = 0;

getWindowSize(w_dst, h_dst);

getTextureSize(tex, w_src, h_src);

w_src *= ratio_x_;

h_src *= ratio_y_;

if (keep_ratio_)

{

if (w_src == 0 || h_src == 0)

{

return;

}

double ratio = std::min(1.0 * w_dst / w_src, 1.0 * h_dst / h_src);

if (rotation_ == 90 || rotation_ == 270)

{

ratio = std::min(1.0 * w_dst / h_src, 1.0 * h_dst / w_src);

}

rect_.x = (w_dst - w_src * ratio) / 2;

rect_.y = (h_dst - h_src * ratio) / 2;

rect_.w = w_src * ratio;

rect_.h = h_src * ratio;

}

else

{

//unfinshed

rect_.x = 0;

rect_.y = 0;

rect_.w = w_dst;

rect_.h = h_dst;

if (rotation_ == 90 || rotation_ == 270)

{

rect_.x = (h_dst - w_dst) / 2;

rect_.y = (w_dst - h_dst) / 2;

rect_.w = h_dst;

rect_.h = w_dst;

}

}

{

//renderMainTextureToWindow();

SDL_RenderPresent(renderer_);

SDL_RenderClear(renderer_);

//setRenderMainTexture();

{

FRect rectf;

SDL_RectToFRect(&rect_, &rectf);

SDL_RenderTextureRotated(renderer_, t, nullptr, &rectf, angle, nullptr, SDL_FLIP_NONE);

render_times_++;

{

if (inPresent == 1)

{

x += rect_.x;

y += rect_.y;

}

int w0, h0;

getTextureSize(t, w0, h0);

if (w < 0)

{

w = w0;

}

if (h < 0)

{

h = h0;

}

Rect r = { x, y, w, h };

renderTexture(t, nullptr, &r, angle);

{

FRect rect0f, rect1f;

FRect *rect0f_ptr = nullptr, *rect1f_ptr = nullptr;

if (rect0)

{

SDL_RectToFRect(rect0, &rect0f);

rect0f_ptr = &rect0f;

}

if (rect1)

{

SDL_RectToFRect(rect1, &rect1f);

rect1f_ptr = &rect1f;

}

SDL_RenderTextureRotated(renderer_, t, rect0f_ptr, rect1f_ptr, angle, nullptr, SDL_FLIP_NONE);

render_times_++;

{

if (!t || v.size() < 4)

{

if (rect0)

{

renderTexture(t, rect0, rect0);

}

else

{

renderTexture(t);

}

return;

}

float tw = 1.0f, th = 1.0f;

SDL_GetTextureSize(t, &tw, &th);

FPoint src[4];

if (v2.size() >= 4)

{

for (int i = 0; i < 4; i++)

{

src[i] = v2[i];

}

}

else if (rect0)

{

src[0] = { float(rect0->x), float(rect0->y) };

src[1] = { float(rect0->x + rect0->w), float(rect0->y) };

src[2] = { float(rect0->x + rect0->w), float(rect0->y + rect0->h) };

src[3] = { float(rect0->x), float(rect0->y + rect0->h) };

}

else

{

src[0] = { 0, 0 };

src[1] = { tw, 0 };

src[2] = { tw, th };

src[3] = { 0, th };

}

SDL_Vertex vertices[4];

for (int i = 0; i < 4; i++)

{

vertices[i].position = v[i];

vertices[i].tex_coord = { src[i].x / tw, src[i].y / th };

vertices[i].color = { 1.0f, 1.0f, 1.0f, 1.0f };

}

int indices[6] = { 0, 1, 2, 2, 3, 0 };

SDL_RenderGeometry(renderer_, t, vertices, 4, indices, 6);

render_times_++;

const std::vector<Color>& colors, const std::vector<int>& indices, float top_left_brightness)

{

if (v.empty() || v.size() != v2.size() || indices.empty())

{

return;

}

float tw = 1.0f, th = 1.0f;

if (t)

{

SDL_GetTextureSize(t, &tw, &th);

}

std::vector<SDL_Vertex> vertices(v.size());

bool use_vertex_colors = colors.size() == v.size();

for (size_t i = 0; i < v.size(); i++)

{

vertices[i].position = v[i];

vertices[i].tex_coord = { v2[i].x / tw, v2[i].y / th };

if (use_vertex_colors)

{

vertices[i].color = {

colors[i].r / 255.0f,

colors[i].g / 255.0f,

colors[i].b / 255.0f,

colors[i].a / 255.0f

};

}

else

{

vertices[i].color = { 1.0f, 1.0f, 1.0f, 1.0f };

}

}

SDL_RenderGeometry(renderer_, t, vertices.data(), int(vertices.size()), indices.data(), int(indices.size()));

render_times_++;

if (texture_top_left_highlight_enabled_ && top_left_brightness > 0.0f)

{

float min_x = v[0].x;

float max_x = v[0].x;

float min_y = v[0].y;

float max_y = v[0].y;

for (const auto& point : v)

{

min_x = (std::min)(min_x, point.x);

max_x = (std::max)(max_x, point.x);

min_y = (std::min)(min_y, point.y);

max_y = (std::max)(max_y, point.y);

}

float width = (std::max)(1.0f, max_x - min_x);

float height = (std::max)(1.0f, max_y - min_y);

for (auto& vertex : vertices)

{

float left_weight = (max_x - vertex.position.x) / width;

float top_weight = (max_y - vertex.position.y) / height;

float brightness = top_left_brightness * std::clamp(left_weight, 0.0f, 1.0f) * std::clamp(top_weight, 0.0f, 1.0f);

vertex.color = { brightness, brightness, brightness, 1.0f };

}

SDL_BlendMode previous_blend = SDL_BLENDMODE_BLEND;

SDL_GetTextureBlendMode(t, &previous_blend);

SDL_SetTextureBlendMode(t, SDL_BLENDMODE_ADD);

SDL_RenderGeometry(renderer_, t, vertices.data(), int(vertices.size()), indices.data(), int(indices.size()));

SDL_SetTextureBlendMode(t, previous_blend);

render_times_++;

}

const std::vector<float>& brightness_v, double angle)

{

if (!t || !rect1)

{

return;

}

int w = rect1->w;

int h = rect1->h;

int w0, h0;

getTextureSize(t, w0, h0);

if (w < 0)

{

w = w0;

}

if (h < 0)

{

h = h0;

}

float x0 = float(rect1->x);

float y0 = float(rect1->y);

float x1 = x0 + w;

float y1 = y0 + h;

float tex_x0 = rect0 ? float(rect0->x) : 0.0f;

float tex_y0 = rect0 ? float(rect0->y) : 0.0f;

float tex_x1 = tex_x0 + (rect0 ? rect0->w : w0);

float tex_y1 = tex_y0 + (rect0 ? rect0->h : h0);

float tw = 1.0f, th = 1.0f;

float tw_f, th_f;

SDL_GetTextureSize(t, &tw_f, &th_f);

tw = tw_f;

th = th_f;

auto color_to_fcolor = [](const Color& c) -> SDL_FColor

{

return { float(c.r) / 255.0f, float(c.g) / 255.0f, float(c.b) / 255.0f, float(c.a) / 255.0f };

};

SDL_FColor default_color = { 1.0f, 1.0f, 1.0f, 1.0f };

SDL_Vertex vertices[4];

// colors 的顺序对应四个顶点：

// colors[0] -> 左上(x0, y0)

// colors[1] -> 右上(x1, y0)

// colors[2] -> 右下(x1, y1)

// colors[3] -> 左下(x0, y1)

// 若未提供某个索引的颜色，则该顶点使用默认白色。

vertices[0].position = { x0, y0 };

vertices[0].tex_coord = { tex_x0 / tw, tex_y0 / th };

vertices[0].color = colors.size() > 0 ? color_to_fcolor(colors[0]) : default_color;

vertices[1].position = { x1, y0 };

vertices[1].tex_coord = { tex_x1 / tw, tex_y0 / th };

vertices[1].color = colors.size() > 1 ? color_to_fcolor(colors[1]) : default_color;

vertices[2].position = { x1, y1 };

vertices[2].tex_coord = { tex_x1 / tw, tex_y1 / th };

vertices[2].color = colors.size() > 2 ? color_to_fcolor(colors[2]) : default_color;

vertices[3].position = { x0, y1 };

vertices[3].tex_coord = { tex_x0 / tw, tex_y1 / th };

vertices[3].color = colors.size() > 3 ? color_to_fcolor(colors[3]) : default_color;

if (angle != 0)

{

const double pi = 3.14159265358979323846;

const float rad = float(angle * pi / 180.0);

const float c = float(std::cos(rad));

const float s = float(std::sin(rad));

const float cx = x0 + w * 0.5f;

const float cy = y0 + h * 0.5f;

for (auto& v : vertices)

{

float rx = v.position.x - cx;

float ry = v.position.y - cy;

v.position.x = cx + rx * c - ry * s;

v.position.y = cy + rx * s + ry * c;

}

}

int indices[6] = { 0, 1, 2, 2, 3, 0 };

SDL_RenderGeometry(renderer_, t, vertices, 4, indices, 6);

render_times_++;

if (!brightness_v.empty())

{

float b[4] = { 0, 0, 0, 0 };

for (int i = 0; i < 4; i++)

{

if (i < (int)brightness_v.size())

{

b[i] = (std::max)(0.0f, brightness_v[i]);

}

}

if (!texture_top_left_highlight_enabled_)

{

b[0] = 0.0f;

}

float max_b = (std::max)((std::max)(b[0], b[1]), (std::max)(b[2], b[3]));

int full_pass = int(std::floor(max_b));

float remain = max_b - full_pass;

SDL_BlendMode prev_blend = SDL_BLENDMODE_BLEND;

SDL_GetTextureBlendMode(t, &prev_blend);

SDL_SetTextureBlendMode(t, SDL_BLENDMODE_ADD);

auto do_add_pass = [&](float pass_base)

{

SDL_Vertex add_vertices[4] = { vertices[0], vertices[1], vertices[2], vertices[3] };

for (int i = 0; i < 4; i++)

{

float k = b[i] - pass_base;

if (k > 1.0f) { k = 1.0f; }

if (k < 0.0f) { k = 0.0f; }

add_vertices[i].color = { k, k, k, 1.0f };

}

SDL_RenderGeometry(renderer_, t, add_vertices, 4, indices, 6);

render_times_++;

};

for (int p = 0; p < full_pass; p++)

{

do_add_pass(float(p));

}

if (remain > 0.0f)

{

do_add_pass(float(full_pass));

}

SDL_SetTextureBlendMode(t, prev_blend);

}

{

destroyTexture(tex_);

for (auto& [k, tex] : tex_map_)

{

destroyTexture(tex);

}

if (renderer_self_)

{

SDL_DestroyRenderer(renderer_);

}

if (window_mode_ == 0)

{

SDL_DestroyWindow(window_);

}

#ifndef _WINDLL

SDL_Quit();

#endif

{

uint32_t state = SDL_GetWindowFlags(window_);

full_screen_ = (state & SDL_WINDOW_FULLSCREEN);

return full_screen_;

{

full_screen_ = b;

SDL_SetWindowFullscreen(window_, full_screen_);

renderClear();

{

if (sur->format != SDL_PIXELFORMAT_RGBA8888)

{

auto sur2 = SDL_ConvertSurface(sur, SDL_PIXELFORMAT_RGBA8888);

SDL_DestroySurface(sur);

sur = sur2;

}

for (int y = 0; y < sur->h; y++)

{

for (int x = 0; x < sur->w; x++)

{

uint8_t r, g, b, a;

if (!SDL_ReadSurfacePixel(sur, x, y, &r, &g, &b, &a))

{

continue;

}

SDL_WriteSurfacePixel(sur, x, y, 255, 255, 255, a);

}

}

{

int x, y, w, h, x0, y0;