git repos / sago_multi_scrambler_puzzle2

commit eb5d7e97

Poul Sander · 2024-10-19 11:45
eb5d7e970817543e02094665e666e33d3dc3b6f8 patch · browse files
parent 3499316435e75f4f32c07463af0b33ce9c43748f 

Now scales the physical pieces

Changed files

M src/PuzzleSingleImageState.cpp before
M src/PuzzleSingleImageState.hpp before
M src/editor/SagoTextureSelector.cpp before
M src/sago_common.cpp before
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<SDL_RendererFlip>(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<SDL_Rect> 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<SDL_Rect> pieces_logical;
+ std::vector<SDL_Rect> pieces_physical;
int min_piece_size = 120;
bool shuffeled = false;
std::vector<size_t> 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);