523 lines
15 KiB
C++
523 lines
15 KiB
C++
#include "Game.h"
|
|
#include "AnimatedModel.h"
|
|
#include "BoneAnimatedModel.h"
|
|
#include "planet/PlanetData.h"
|
|
#include "utils/Utils.h"
|
|
#include "render/OpenGlExtensions.h"
|
|
#include <iostream>
|
|
#include "render/TextureManager.h"
|
|
#include "TextModel.h"
|
|
#include <random>
|
|
#include <cmath>
|
|
#include <algorithm>
|
|
#include <functional>
|
|
#ifdef __ANDROID__
|
|
#include <android/log.h>
|
|
#endif
|
|
|
|
#ifdef NETWORK
|
|
#ifdef EMSCRIPTEN
|
|
#include "network/WebSocketClientEmscripten.h"
|
|
#else
|
|
#include "network/WebSocketClient.h"
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef EMSCRIPTEN
|
|
#include <emscripten.h>
|
|
#endif
|
|
|
|
#include "network/LocalClient.h"
|
|
#include "network/ClientState.h"
|
|
|
|
|
|
namespace ZL
|
|
{
|
|
#ifdef EMSCRIPTEN
|
|
const char* CONST_ZIP_FILE = "resources.zip";
|
|
#else
|
|
//const char* CONST_ZIP_FILE = "C:\\Work\\Projects\\space-game001\\resources.zip";
|
|
const char* CONST_ZIP_FILE = "";
|
|
#endif
|
|
|
|
#ifdef EMSCRIPTEN
|
|
Game* Game::s_instance = nullptr;
|
|
|
|
void Game::onResourcesZipLoaded(const char* /*filename*/) {
|
|
if (s_instance) {
|
|
s_instance->mainThreadHandler.EnqueueMainThreadTask([&]() {
|
|
s_instance->setupPart2();
|
|
});
|
|
}
|
|
}
|
|
|
|
void Game::onResourcesZipError(const char* /*filename*/) {
|
|
std::cerr << "Failed to download resources.zip" << std::endl;
|
|
}
|
|
#endif
|
|
|
|
Game::Game()
|
|
: /*window(nullptr)
|
|
, glContext(nullptr)
|
|
, */newTickCount(0)
|
|
, lastTickCount(0)
|
|
, menuManager(renderer)
|
|
, space(renderer, taskManager, mainThreadHandler, networkClient, menuManager)
|
|
{
|
|
}
|
|
|
|
Game::~Game() {
|
|
/*
|
|
if (glContext) {
|
|
SDL_GL_DeleteContext(glContext);
|
|
}
|
|
if (window) {
|
|
SDL_DestroyWindow(window);
|
|
}*/
|
|
#ifndef EMSCRIPTEN
|
|
// In Emscripten, SDL must stay alive across context loss/restore cycles
|
|
// so the window remains valid when the game object is re-created.
|
|
SDL_Quit();
|
|
#endif
|
|
}
|
|
|
|
void Game::setup() {
|
|
//glContext = SDL_GL_CreateContext(ZL::Environment::window);
|
|
//glContext = in_glContext;
|
|
|
|
Environment::computeProjectionDimensions();
|
|
|
|
ZL::BindOpenGlFunctions();
|
|
ZL::CheckGlError();
|
|
renderer.InitOpenGL();
|
|
|
|
#ifdef EMSCRIPTEN
|
|
// These shaders and loading.png are preloaded separately (not from zip),
|
|
// so they are available immediately without waiting for resources.zip.
|
|
renderer.shaderManager.AddShaderFromFiles("defaultColor", "resources/shaders/defaultColor.vertex", "resources/shaders/defaultColor_web.fragment", "");
|
|
renderer.shaderManager.AddShaderFromFiles("default", "resources/shaders/default.vertex", "resources/shaders/default_web.fragment", "");
|
|
loadingTexture = std::make_unique<Texture>(CreateTextureDataFromPng("resources/loading.png", ""));
|
|
#else
|
|
renderer.shaderManager.AddShaderFromFiles("defaultColor", "resources/shaders/defaultColor.vertex", "resources/shaders/defaultColor_desktop.fragment", CONST_ZIP_FILE);
|
|
renderer.shaderManager.AddShaderFromFiles("default", "resources/shaders/default.vertex", "resources/shaders/default_desktop.fragment", CONST_ZIP_FILE);
|
|
loadingTexture = std::make_unique<Texture>(CreateTextureDataFromPng("resources/loading.png", CONST_ZIP_FILE));
|
|
#endif
|
|
|
|
loadingMesh.data = CreateRect2D({ 0.5f, 0.5f }, { 0.5f, 0.5f }, 3);
|
|
loadingMesh.RefreshVBO();
|
|
|
|
#ifdef EMSCRIPTEN
|
|
// Asynchronously download resources.zip; setupPart2() is called on completion.
|
|
// The loading screen stays visible until the download finishes.
|
|
s_instance = this;
|
|
std::cout << "Load resurces step 1" << std::endl;
|
|
emscripten_async_wget("resources.zip", "resources.zip", onResourcesZipLoaded, onResourcesZipError);
|
|
#else
|
|
mainThreadHandler.EnqueueMainThreadTask([this]() {
|
|
std::cout << "Load resurces step 2" << std::endl;
|
|
this->setupPart2();
|
|
std::cout << "Load resurces step 3" << std::endl;
|
|
});
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
void Game::setupPart2()
|
|
{
|
|
|
|
#ifdef EMSCRIPTEN
|
|
renderer.shaderManager.AddShaderFromFiles("env_sky", "resources/shaders/env_sky.vertex", "resources/shaders/env_sky_web.fragment", CONST_ZIP_FILE);
|
|
renderer.shaderManager.AddShaderFromFiles("defaultAtmosphere", "resources/shaders/defaultAtmosphere.vertex", "resources/shaders/defaultAtmosphere_web.fragment", CONST_ZIP_FILE);
|
|
renderer.shaderManager.AddShaderFromFiles("planetBake", "resources/shaders/planet_bake.vertex", "resources/shaders/planet_bake_web.fragment", CONST_ZIP_FILE);
|
|
renderer.shaderManager.AddShaderFromFiles("planetStone", "resources/shaders/planet_stone.vertex", "resources/shaders/planet_stone_web.fragment", CONST_ZIP_FILE);
|
|
renderer.shaderManager.AddShaderFromFiles("planetLand", "resources/shaders/planet_land.vertex", "resources/shaders/planet_land_web.fragment", CONST_ZIP_FILE);
|
|
renderer.shaderManager.AddShaderFromFiles("spark", "resources/shaders/spark.vertex", "resources/shaders/spark_web.fragment", CONST_ZIP_FILE);
|
|
|
|
#else
|
|
renderer.shaderManager.AddShaderFromFiles("env_sky", "resources/shaders/env_sky.vertex", "resources/shaders/env_sky_desktop.fragment", CONST_ZIP_FILE);
|
|
renderer.shaderManager.AddShaderFromFiles("defaultAtmosphere", "resources/shaders/defaultAtmosphere.vertex", "resources/shaders/defaultAtmosphere_desktop.fragment", CONST_ZIP_FILE);
|
|
renderer.shaderManager.AddShaderFromFiles("planetBake", "resources/shaders/planet_bake.vertex", "resources/shaders/planet_bake_desktop.fragment", CONST_ZIP_FILE);
|
|
renderer.shaderManager.AddShaderFromFiles("planetStone", "resources/shaders/planet_stone.vertex", "resources/shaders/planet_stone_desktop.fragment", CONST_ZIP_FILE);
|
|
renderer.shaderManager.AddShaderFromFiles("planetLand", "resources/shaders/planet_land.vertex", "resources/shaders/planet_land_desktop.fragment", CONST_ZIP_FILE);
|
|
renderer.shaderManager.AddShaderFromFiles("spark", "resources/shaders/spark.vertex", "resources/shaders/spark_desktop.fragment", CONST_ZIP_FILE);
|
|
#endif
|
|
|
|
menuManager.setupMenu();
|
|
|
|
menuManager.onSingleplayerPressed = [this](const std::string& nickname, int shipType) {
|
|
Environment::shipState.nickname = nickname;
|
|
Environment::shipState.shipType = shipType;
|
|
|
|
auto localClient = new LocalClient;
|
|
ClientState st = Environment::shipState;
|
|
st.id = localClient->GetClientId();
|
|
localClient->setLocalPlayerState(st);
|
|
|
|
networkClient = std::unique_ptr<INetworkClient>(localClient);
|
|
networkClient->Connect("", 0);
|
|
|
|
lastTickCount = 0;
|
|
spaceGameStarted = 1;
|
|
};
|
|
|
|
menuManager.onMultiplayerPressed = [this](const std::string& nickname, int shipType) {
|
|
Environment::shipState.nickname = nickname;
|
|
Environment::shipState.shipType = shipType;
|
|
|
|
|
|
#ifdef EMSCRIPTEN
|
|
networkClient = std::make_unique<WebSocketClientEmscripten>();
|
|
networkClient->Connect("localhost", 8081);
|
|
#else
|
|
//networkClient = std::make_unique<WebSocketClient>(taskManager.getIOContext());
|
|
//networkClient->Connect("localhost", 8081);
|
|
#endif
|
|
|
|
if (networkClient) {
|
|
std::string joinMsg = std::string("JOIN:") + nickname + ":" + std::to_string(shipType);
|
|
networkClient->Send(joinMsg);
|
|
std::cerr << "Sent JOIN: " << joinMsg << std::endl;
|
|
}
|
|
|
|
lastTickCount = 0;
|
|
spaceGameStarted = 1;
|
|
};
|
|
|
|
|
|
space.setup();
|
|
|
|
loadingCompleted = true;
|
|
}
|
|
|
|
|
|
void Game::drawUI()
|
|
{
|
|
static const std::string defaultShaderName = "default";
|
|
static const std::string envShaderName = "env";
|
|
static const std::string vPositionName = "vPosition";
|
|
static const std::string vTexCoordName = "vTexCoord";
|
|
static const std::string textureUniformName = "Texture";
|
|
|
|
glClear(GL_DEPTH_BUFFER_BIT);
|
|
|
|
renderer.shaderManager.PushShader(defaultShaderName);
|
|
renderer.RenderUniform1i(textureUniformName, 0);
|
|
renderer.EnableVertexAttribArray(vPositionName);
|
|
renderer.EnableVertexAttribArray(vTexCoordName);
|
|
|
|
renderer.DisableVertexAttribArray(vPositionName);
|
|
renderer.DisableVertexAttribArray(vTexCoordName);
|
|
glEnable(GL_BLEND);
|
|
menuManager.uiManager.draw(renderer);
|
|
glDisable(GL_BLEND);
|
|
renderer.shaderManager.PopShader();
|
|
CheckGlError();
|
|
}
|
|
|
|
void Game::drawUnderMainMenu()
|
|
{
|
|
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
|
|
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
|
|
|
|
}
|
|
|
|
void Game::drawScene() {
|
|
if (!loadingCompleted) {
|
|
drawLoading();
|
|
}
|
|
else
|
|
{
|
|
|
|
if (spaceGameStarted) {
|
|
space.drawScene();
|
|
}
|
|
else
|
|
{
|
|
drawUnderMainMenu();
|
|
}
|
|
drawUI();
|
|
}
|
|
CheckGlError();
|
|
}
|
|
|
|
void Game::drawLoading()
|
|
{
|
|
static const std::string defaultShaderName = "default";
|
|
static const std::string vPositionName = "vPosition";
|
|
static const std::string vTexCoordName = "vTexCoord";
|
|
static const std::string textureUniformName = "Texture";
|
|
|
|
glClear(GL_DEPTH_BUFFER_BIT);
|
|
|
|
renderer.shaderManager.PushShader(defaultShaderName);
|
|
renderer.RenderUniform1i(textureUniformName, 0);
|
|
renderer.EnableVertexAttribArray(vPositionName);
|
|
renderer.EnableVertexAttribArray(vTexCoordName);
|
|
|
|
//float width = Environment::projectionWidth;
|
|
//float height = Environment::projectionHeight;
|
|
|
|
renderer.PushProjectionMatrix(
|
|
0, 1,
|
|
0, 1,
|
|
-10, 10);
|
|
|
|
renderer.PushMatrix();
|
|
renderer.LoadIdentity();
|
|
|
|
glBindTexture(GL_TEXTURE_2D, loadingTexture->getTexID());
|
|
renderer.DrawVertexRenderStruct(loadingMesh);
|
|
|
|
renderer.PopMatrix();
|
|
renderer.PopProjectionMatrix();
|
|
|
|
renderer.DisableVertexAttribArray(vPositionName);
|
|
renderer.DisableVertexAttribArray(vTexCoordName);
|
|
renderer.shaderManager.PopShader();
|
|
CheckGlError();
|
|
}
|
|
|
|
int64_t Game::getSyncTimeMs() {
|
|
int64_t localNow = std::chrono::duration_cast<std::chrono::milliseconds>(
|
|
std::chrono::system_clock::now().time_since_epoch()).count();
|
|
if(networkClient)
|
|
{
|
|
return localNow + networkClient->getTimeOffset();
|
|
}
|
|
else
|
|
{
|
|
return localNow;
|
|
}
|
|
}
|
|
|
|
void Game::processTickCount() {
|
|
|
|
if (lastTickCount == 0) {
|
|
lastTickCount = getSyncTimeMs();
|
|
|
|
lastTickCount = (lastTickCount / 50) * 50;
|
|
|
|
return;
|
|
}
|
|
|
|
newTickCount = getSyncTimeMs();
|
|
|
|
newTickCount = (newTickCount / 50) * 50;
|
|
|
|
if (newTickCount - lastTickCount > CONST_TIMER_INTERVAL) {
|
|
|
|
int64_t delta = newTickCount - lastTickCount;
|
|
if (delta > CONST_MAX_TIME_INTERVAL)
|
|
{
|
|
//throw std::runtime_error("Synchronization is lost");
|
|
}
|
|
|
|
if (spaceGameStarted) {
|
|
space.processTickCount(newTickCount, delta);
|
|
}
|
|
menuManager.uiManager.update(static_cast<float>(delta));
|
|
lastTickCount = newTickCount;
|
|
}
|
|
}
|
|
|
|
void Game::render() {
|
|
//SDL_GL_MakeCurrent(ZL::Environment::window, glContext);
|
|
ZL::CheckGlError();
|
|
|
|
glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
drawScene();
|
|
processTickCount();
|
|
|
|
SDL_GL_SwapWindow(ZL::Environment::window);
|
|
}
|
|
|
|
void Game::update() {
|
|
SDL_Event event;
|
|
while (SDL_PollEvent(&event)) {
|
|
if (event.type == SDL_QUIT) {
|
|
Environment::exitGameLoop = true;
|
|
}
|
|
|
|
|
|
if (event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_RESIZED) {
|
|
// Обновляем размеры и сбрасываем кеш текстов, т.к. меши хранятся в пикселях
|
|
Environment::width = event.window.data1;
|
|
Environment::height = event.window.data2;
|
|
Environment::computeProjectionDimensions();
|
|
menuManager.uiManager.updateAllLayouts();
|
|
std::cout << "Window resized: " << Environment::width << "x" << Environment::height << std::endl;
|
|
|
|
space.clearTextRendererCache();
|
|
}
|
|
|
|
#ifdef __ANDROID__
|
|
if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_AC_BACK) {
|
|
Environment::exitGameLoop = true;
|
|
}
|
|
#endif
|
|
|
|
#ifdef __ANDROID__
|
|
if (event.type == SDL_FINGERDOWN) {
|
|
int mx = static_cast<int>(event.tfinger.x * Environment::projectionWidth);
|
|
int my = static_cast<int>(event.tfinger.y * Environment::projectionHeight);
|
|
handleDown(mx, my);
|
|
}
|
|
else if (event.type == SDL_FINGERUP) {
|
|
int mx = static_cast<int>(event.tfinger.x * Environment::projectionWidth);
|
|
int my = static_cast<int>(event.tfinger.y * Environment::projectionHeight);
|
|
handleUp(mx, my);
|
|
}
|
|
else if (event.type == SDL_FINGERMOTION) {
|
|
int mx = static_cast<int>(event.tfinger.x * Environment::projectionWidth);
|
|
int my = static_cast<int>(event.tfinger.y * Environment::projectionHeight);
|
|
handleMotion(mx, my);
|
|
}
|
|
#else
|
|
|
|
|
|
if (event.type == SDL_MOUSEBUTTONDOWN || event.type == SDL_MOUSEBUTTONUP) {
|
|
// Преобразуем экранные пиксели в проекционные единицы
|
|
int mx = static_cast<int>((float)event.button.x / Environment::width * Environment::projectionWidth);
|
|
int my = static_cast<int>((float)event.button.y / Environment::height * Environment::projectionHeight);
|
|
|
|
if (event.type == SDL_MOUSEBUTTONDOWN) handleDown(mx, my);
|
|
else handleUp(mx, my);
|
|
}
|
|
else if (event.type == SDL_MOUSEMOTION) {
|
|
int mx = static_cast<int>((float)event.motion.x / Environment::width * Environment::projectionWidth);
|
|
int my = static_cast<int>((float)event.motion.y / Environment::height * Environment::projectionHeight);
|
|
handleMotion(mx, my);
|
|
}
|
|
|
|
/*if (event.type == SDL_MOUSEBUTTONDOWN) {
|
|
int mx = event.button.x;
|
|
int my = event.button.y;
|
|
handleDown(mx, my);
|
|
}
|
|
if (event.type == SDL_MOUSEBUTTONUP) {
|
|
int mx = event.button.x;
|
|
int my = event.button.y;
|
|
handleUp(mx, my);
|
|
}
|
|
if (event.type == SDL_MOUSEMOTION) {
|
|
int mx = event.motion.x;
|
|
int my = event.motion.y;
|
|
handleMotion(mx, my);
|
|
}*/
|
|
|
|
if (event.type == SDL_MOUSEWHEEL) {
|
|
static const float zoomstep = 2.0f;
|
|
if (event.wheel.y > 0) {
|
|
Environment::zoom -= zoomstep;
|
|
}
|
|
else if (event.wheel.y < 0) {
|
|
Environment::zoom += zoomstep;
|
|
}
|
|
if (Environment::zoom < zoomstep) {
|
|
Environment::zoom = zoomstep;
|
|
}
|
|
}
|
|
|
|
// Обработка ввода текста
|
|
if (event.type == SDL_KEYDOWN) {
|
|
if (event.key.keysym.sym == SDLK_BACKSPACE) {
|
|
menuManager.uiManager.onKeyBackspace();
|
|
}
|
|
}
|
|
|
|
if (event.type == SDL_TEXTINPUT) {
|
|
// Пропускаем ctrl+c и другие команды
|
|
if ((event.text.text[0] & 0x80) == 0) { // ASCII символы
|
|
menuManager.uiManager.onKeyPress((unsigned char)event.text.text[0]);
|
|
}
|
|
}
|
|
|
|
if (event.type == SDL_KEYUP) {
|
|
if (event.key.keysym.sym == SDLK_a) {
|
|
//Environment::shipState.position = { 9466.15820, 1046.00159, 18531.2090 };
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
render();
|
|
|
|
if (networkClient) {
|
|
#ifndef NETWORK
|
|
auto localClient = dynamic_cast<ZL::LocalClient*>(networkClient.get());
|
|
if (localClient) {
|
|
localClient->setLocalPlayerState(Environment::shipState);
|
|
}
|
|
#endif
|
|
networkClient->Poll();
|
|
}
|
|
mainThreadHandler.processMainThreadTasks();
|
|
|
|
if (spaceGameStarted) {
|
|
space.update();
|
|
}
|
|
}
|
|
|
|
void Game::handleDown(int mx, int my)
|
|
{
|
|
int uiX = mx;
|
|
int uiY = Environment::projectionHeight - my;
|
|
|
|
menuManager.uiManager.onMouseDown(uiX, uiY);
|
|
|
|
bool uiHandled = false;
|
|
|
|
for (const auto& button : menuManager.uiManager.findButton("") ? std::vector<std::shared_ptr<UiButton>>{} : std::vector<std::shared_ptr<UiButton>>{}) {
|
|
(void)button;
|
|
}
|
|
|
|
auto pressedSlider = [&]() -> std::shared_ptr<UiSlider> {
|
|
for (const auto& slider : menuManager.uiManager.findSlider("") ? std::vector<std::shared_ptr<UiSlider>>{} : std::vector<std::shared_ptr<UiSlider>>{}) {
|
|
(void)slider;
|
|
}
|
|
return nullptr;
|
|
}();
|
|
|
|
if (!menuManager.uiManager.isUiInteraction()) {
|
|
if (spaceGameStarted) {
|
|
space.handleDown(mx, my);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void Game::handleUp(int mx, int my)
|
|
{
|
|
int uiX = mx;
|
|
int uiY = Environment::projectionHeight - my;
|
|
|
|
menuManager.uiManager.onMouseUp(uiX, uiY);
|
|
|
|
if (!menuManager.uiManager.isUiInteraction()) {
|
|
if (spaceGameStarted) {
|
|
space.handleUp(mx, my);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void Game::handleMotion(int mx, int my)
|
|
{
|
|
int uiX = mx;
|
|
int uiY = Environment::projectionHeight - my;
|
|
|
|
menuManager.uiManager.onMouseMove(uiX, uiY);
|
|
|
|
if (!menuManager.uiManager.isUiInteraction()) {
|
|
if (spaceGameStarted) {
|
|
space.handleMotion(mx, my);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
} // namespace ZL
|