diff --git a/src/PuzzleSingleImageState.cpp b/src/PuzzleSingleImageState.cpp index 0730377..8f2426c 100644 --- a/src/PuzzleSingleImageState.cpp +++ b/src/PuzzleSingleImageState.cpp @@ -60,26 +60,31 @@ void PuzzleSingleImageState::ProcessInput(const SDL_Event& event, bool &processe isActive = false; processed = true; } + if (event.type == SDL_WINDOWEVENT) { + if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED) { + ResizeImagePhysical(); + } + } ImGui_ImplSDL2_ProcessEvent(&event); } void PuzzleSingleImageState::Draw(SDL_Renderer* target) { globalData.spriteHolder->GetSprite("background_sixteen_nine").Draw(target, SDL_GetTicks(), 0, 0); SDL_Rect rect; - rect.x = globalData.xsize/2-resized_image_width/2; - rect.y = globalData.ysize/2-resized_image_height/2; - rect.h = resized_image_height; - rect.w = resized_image_width; + rect.x = globalData.xsize/2-resized_image_physical_width/2; + rect.y = globalData.ysize/2-resized_image_physical_height/2; + rect.h = resized_image_physical_height; + rect.w = resized_image_physical_width; if (!shuffeled) { SDL_RenderCopy(target, this->pictureTex, NULL, &rect); } else { - for (size_t i = 0; i < pieces.size(); ++i) { - SDL_Rect destination = pieces[i]; + for (size_t i = 0; i < pieces_physical.size(); ++i) { + SDL_Rect destination = pieces_physical[i]; destination.x += rect.x; destination.y += rect.y; - SDL_Rect source = pieces.at(shuffeled_pieces[i]); - double scale = double(source_image_height)/double(resized_image_height); + SDL_Rect source = pieces_logical.at(shuffeled_pieces[i]); + double scale = double(source_image_height)/double(resized_image_logical_height); source.x = double(source.x)*scale; source.y = double(source.y)*scale; source.w = double(source.w)*scale; @@ -92,17 +97,18 @@ void PuzzleSingleImageState::Draw(SDL_Renderer* target) { flip |= SDL_FLIP_VERTICAL; } SDL_RenderCopyEx(target, this->pictureTex, &source, &destination, 0, nullptr, static_cast(flip) ); + std::cout << "Writing piece " << i << " at " << destination.x << ", " << destination.y << " from " << source.x << ", " << source.y << "\n"; } - for (size_t i = 0; i < pieces.size(); ++i) { - const SDL_Rect& piece = pieces[i]; + for (size_t i = 0; i < pieces_physical.size(); ++i) { + const SDL_Rect& piece = pieces_physical[i]; if (i == marked_piece) { continue; } rectangleRGBA(target, rect.x+piece.x, rect.y+piece.y, rect.x+piece.x + piece.w, rect.y+piece.y + piece.h, 255, 255, 0, 255); } - if (marked_piece > -1 && marked_piece < pieces.size()) { - const SDL_Rect& piece = pieces.at(marked_piece); + if (marked_piece > -1 && marked_piece < pieces_physical.size()) { + const SDL_Rect& piece = pieces_physical.at(marked_piece); rectangleRGBA(target, rect.x+piece.x, rect.y+piece.y, rect.x+piece.x + piece.w, rect.y+piece.y + piece.h, 255, 0, 0, 255); } @@ -133,19 +139,19 @@ void PuzzleSingleImageState::Update() { globalData.mouseUp = false; SDL_Rect rect; - rect.x = globalData.xsize/2-resized_image_width/2; - rect.y = globalData.ysize/2-resized_image_height/2;; - rect.h = resized_image_height; - rect.w = resized_image_width; - for (size_t i = 0; i< pieces.size(); ++i) { - const SDL_Rect& piece = pieces[i]; + rect.x = globalData.xsize/2-resized_image_physical_width/2; + rect.y = globalData.ysize/2-resized_image_physical_height/2;; + rect.h = resized_image_physical_height; + rect.w = resized_image_physical_width; + for (size_t i = 0; i< pieces_physical.size(); ++i) { + const SDL_Rect& piece = pieces_physical[i]; bool clicked = (globalData.mousex > rect.x+piece.x && globalData.mousex < rect.x+piece.x + piece.w && globalData.mousey > rect.y+piece.y && globalData.mousey < rect.y+piece.y + piece.h); if (clicked) { if (flipMode) { rotated_pieces[i] = (rotated_pieces[i]+1)%4; } else { - if (i != marked_piece && marked_piece > -1 && marked_piece < pieces.size()) { + if (i != marked_piece && marked_piece > -1 && marked_piece < pieces_physical.size()) { std::swap(shuffeled_pieces[i], shuffeled_pieces[marked_piece]); marked_piece = -1; } @@ -162,6 +168,42 @@ void PuzzleSingleImageState::Update() { } } +void PuzzleSingleImageState::CreatePhysicalPieces() { + pieces_physical.clear(); + for (size_t i = 0; i < pieces_logical.size(); ++i) { + SDL_Rect piece = pieces_logical.at(i); + piece.x = (piece.x) * resized_image_physical_width / resized_image_logical_width; + piece.y = (piece.y) * resized_image_physical_height / resized_image_logical_height; + piece.w = piece.w * resized_image_physical_width / resized_image_logical_width; + piece.h = piece.h * resized_image_physical_height / resized_image_logical_height; + pieces_physical.push_back(piece); + } +} + +void PuzzleSingleImageState::ResizeImage() { + resized_image_logical_height = resized_image_logical_height_max; + resized_image_logical_width = double(resized_image_logical_height) * (double(source_image_width)/double(source_image_height)); + if (resized_image_logical_width > resized_image_logical_width_max) { + resized_image_logical_width = resized_image_logical_width_max; + resized_image_logical_height = double(resized_image_logical_width) * (double(source_image_height)/double(source_image_width)); + } + // Set default physical size to logical size + resized_image_physical_width = resized_image_logical_width; + resized_image_physical_height = resized_image_logical_height; +} + +void PuzzleSingleImageState::ResizeImagePhysical() { + int resized_image_physical_height_max = globalData.ysize-70; + int resized_image_physical_width_max = globalData.xsize-70; + resized_image_physical_height = resized_image_physical_height_max; + resized_image_physical_width = double(resized_image_physical_height) * (double(source_image_width)/double(source_image_height)); + if (resized_image_physical_width > resized_image_physical_width_max) { + resized_image_physical_width = resized_image_physical_width_max; + resized_image_physical_height = double(resized_image_physical_width) * (double(source_image_height)/double(source_image_width)); + } + CreatePhysicalPieces(); +} + void PuzzleSingleImageState::LoadPictureFromFile(const std::string& filename, SDL_Renderer* renderer) { ClearPicture(); IMG_Init(IMG_INIT_JPG|IMG_INIT_PNG); @@ -172,25 +214,21 @@ void PuzzleSingleImageState::LoadPictureFromFile(const std::string& filename, SD } source_image_height = bitmapSurface->h; source_image_width = bitmapSurface->w; - resized_image_height = resized_image_height_max; - resized_image_width = double(resized_image_height) * (double(source_image_width)/double(source_image_height)); - if (resized_image_width > resized_image_width_max) { - resized_image_width = resized_image_width_max; - resized_image_height = double(resized_image_width) * (double(source_image_height)/double(source_image_width)); - } + ResizeImage(); this->pictureTex = SDL_CreateTextureFromSurface(renderer, bitmapSurface); - std::cerr << resized_image_width << ", " << resized_image_height << "\n"; + std::cerr << resized_image_logical_width << ", " << resized_image_logical_height << "\n"; SDL_FreeSurface(bitmapSurface); - pieces.clear(); + pieces_logical.clear(); SDL_Rect piece; piece.x = 0; piece.y = 0; - piece.h = resized_image_height; - piece.w = resized_image_width; - pieces.push_back(piece); + piece.h = resized_image_logical_height; + piece.w = resized_image_logical_width; + pieces_logical.push_back(piece); for (int i = 0; i<10; ++i) { SplitPiece(); } + ResizeImagePhysical(); Shuffle(); } @@ -206,37 +244,37 @@ void PuzzleSingleImageState::SplitPiece(size_t piece_number) { } void PuzzleSingleImageState::SplitPieceVertical(size_t piece_number) { - SDL_Rect piece1 = pieces.at(piece_number); + SDL_Rect piece1 = pieces_logical.at(piece_number); if (piece1.w > 2*min_piece_size) { int new_piece_width = min_piece_size + (rand()%(piece1.w-2*min_piece_size)); SDL_Rect piece2 = piece1; piece2.w = new_piece_width; piece1.w -= new_piece_width; piece2.x = piece2.x + piece1.w; - pieces.at(piece_number) = piece1; - pieces.push_back(piece2); + pieces_logical.at(piece_number) = piece1; + pieces_logical.push_back(piece2); return; } } void PuzzleSingleImageState::SplitPieceHorisontal(size_t piece_number) { - SDL_Rect piece1 = pieces.at(piece_number); + SDL_Rect piece1 = pieces_logical.at(piece_number); if (piece1.h > 2*min_piece_size) { int new_piece_height = min_piece_size + (rand()%(piece1.h-2*min_piece_size)); SDL_Rect piece2 = piece1; piece2.h = new_piece_height; piece1.h -= new_piece_height; piece2.y = piece2.y + piece1.h; - pieces.at(piece_number) = piece1; - pieces.push_back(piece2); + pieces_logical.at(piece_number) = piece1; + pieces_logical.push_back(piece2); } } void PuzzleSingleImageState::SplitPiece() { - size_t number_of_pieces = pieces.size(); + size_t number_of_pieces = pieces_logical.size(); for (size_t i= 0; i < number_of_pieces; ++i ) { - const SDL_Rect& piece = pieces.at(i); + const SDL_Rect& piece = pieces_logical.at(i); if (piece.w > 2*min_piece_size || piece.h > 2*min_piece_size) { SplitPiece(i); } @@ -251,7 +289,7 @@ void PuzzleSingleImageState::ClearPicture() { } void PuzzleSingleImageState::Shuffle() { - size_t number_of_peices = pieces.size(); + size_t number_of_peices = pieces_logical.size(); shuffeled_pieces.resize(number_of_peices); rotated_pieces.resize(number_of_peices); for (size_t i = 0; i< shuffeled_pieces.size(); ++i) { diff --git a/src/PuzzleSingleImageState.hpp b/src/PuzzleSingleImageState.hpp index afc5521..0f98ffb 100644 --- a/src/PuzzleSingleImageState.hpp +++ b/src/PuzzleSingleImageState.hpp @@ -46,6 +46,10 @@ public: void Shuffle(); void CheckSolved(); + void ResizeImage(); + void ResizeImagePhysical(); + void CreatePhysicalPieces(); + bool flipMode = false; private: void ClearPicture(); @@ -54,11 +58,14 @@ private: SDL_Texture* pictureTex = NULL; int source_image_height = 1; int source_image_width = 1; - int resized_image_height = 700; - int resized_image_width = 1; - const int resized_image_height_max = 700; - const int resized_image_width_max = 1100; - std::vector pieces; + int resized_image_logical_height = 700; + int resized_image_logical_width = 1; + const int resized_image_logical_height_max = 700; + const int resized_image_logical_width_max = 1100; + int resized_image_physical_height = 700; + int resized_image_physical_width = 1100; + std::vector pieces_logical; + std::vector pieces_physical; int min_piece_size = 120; bool shuffeled = false; std::vector shuffeled_pieces; diff --git a/src/editor/SagoTextureSelector.cpp b/src/editor/SagoTextureSelector.cpp index b93ae96..d4a6b9c 100644 --- a/src/editor/SagoTextureSelector.cpp +++ b/src/editor/SagoTextureSelector.cpp @@ -64,7 +64,7 @@ void SagoTextureSelector::runTextureSelectorFrame(SDL_Renderer* target) { ImGui::End(); - ImGui::Begin("Canvas"); + ImGui::Begin("TextureViewer"); if (selected_texture.length()) { int tex_w, tex_h; SDL_Texture* current_texture = globalData.dataHolder->getTexturePtr(remove_file_extension(selected_texture)); diff --git a/src/sago_common.cpp b/src/sago_common.cpp index fc5eadc..5674612 100644 --- a/src/sago_common.cpp +++ b/src/sago_common.cpp @@ -37,6 +37,7 @@ void InitSagoFS(int argc, const char* argv[]) { void RunGameState(sago::GameStateInterface& state ) { bool done = false; //We are done! while (!done && !globalData.isShuttingDown) { + SDL_SetRenderDrawColor(globalData.screen, 0, 0, 0, 255); SDL_RenderClear(globalData.screen); ImGui_ImplSDLRenderer2_NewFrame(); ImGui_ImplSDL2_NewFrame(); @@ -67,6 +68,12 @@ void RunGameState(sago::GameStateInterface& state ) { done = true; } + if (event.type == SDL_WINDOWEVENT) { + if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED) { + SDL_GetRendererOutputSize(globalData.screen, &globalData.xsize, &globalData.ysize); + } + } + if ( event.key.keysym.sym == SDLK_F9 ) { mustWriteScreenshot = true; } @@ -127,7 +134,7 @@ void InitGame() { SDL_SetHint(SDL_HINT_MOUSE_RELATIVE_SCALING, "1"); win = SDL_CreateWindow(GAMENAME, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, width, height, SDL_WINDOW_RESIZABLE); globalData.screen = SDL_CreateRenderer(win, -1, rendererFlags); - SDL_RenderSetLogicalSize(globalData.screen, width, height); + //SDL_RenderSetLogicalSize(globalData.screen, width, height); InitImGui(win, globalData.screen, width, height); dataHolder.invalidateAll(globalData.screen);