Working on NXDK port of calculator2.c

.gitignore

@@ -6,3 +6,45 @@ Maths Calculator (C)/XCalculator.c.d
 Maths Calculator (C)/bin/default.xbe
 Maths Calculator (C)/main.exe
 Maths Calculator (C)/calculator.iso
+Maths Calculator (C)/main.pdb
+Maths Calculator (C)/SDLTest.iso
+Maths Calculator (C)/SDLtest.c.d
+Maths Calculator (C)/SDLtest.c
+Maths Calculator (C)/SDLtest.obj
+Maths Calculator (C)/.vscode/settings.json
+Maths Calculator (C)/XCalculator.iso
+test
+test.c
+Mandelbrot Set (C)/.vscode/c_cpp_properties.json
+Mandelbrot Set (C)/mandelbrot.c.d
+Mandelbrot Set (C)/main.exe
+Mandelbrot Set (C)/mandelbrot.obj
+Mandelbrot Set (C)/MandelbrotSetX.iso
+Mandelbrot Set (C)/bin/default.xbe
+Mandelbrot Set (C)/.vscode/settings.json
+Mandelbrot Set (C)/mandelbrot
+C11 standard.pdf
+Fibonacci Sequnce (C)/fibonacci
+Mandelbrot Set (C)/main.pdb
+.vscode/settings.json
+n4713.pdf
+.vscode/c_cpp_properties.json
+Music player (C)/music
+Music player (C)/player.c.d
+Music player (C)/player.obj
+Music player (C)/bin/default.xbe
+Music player (C)/main.exe
+Music player (C)/bin/nxdk.wav
+Music player (C)/XMusic.iso
+Music player (C)/bin/pausetest.wav
+Test code/main.c
+Test code/main.c.d
+Test code/main.exe
+Test code/main.obj
+Test code/main.pdb
+Test code/Makefile
+Test code/bin/default.xbe
+Test code/winapi_filefinD.iso
+Test code/bin/CivilSin.wav
+Test code/bin/O fortuna.wav
+Music player (C)/bin/Pause Test.wav

Mandelbrot Set (C)/Makefile.nxdk

@@ -0,0 +1,7 @@
+XBE_TITLE=MandelbrotSetX
+GEN_XISO = $(XBE_TITLE).iso
+SRCS = mandelbrot.c
+NXDK_DIR = /home/$(USERNAME)/nxdk
+NXDK_SDL = y
+include $(NXDK_DIR)/Makefile
+DEBUG = y

Mandelbrot Set (C)/README.md

@@ -0,0 +1,44 @@
+# mandelbrot-c-sdl2
+
+Forked from https://github.com/Geospace/mandelbrot-c-sdl2/tree/master
+
+The Xbox port is made by me
+
+Using the C language and the SDL2 library to draw the Mandelbrot set.
+
+## Features
+
+Controls:
+* Use **D-Pad** to move
+* Use **B** to zoom in
+* Use **X** to zoom out
+
+## Requirements
+
+PC:
+* C standard library with (G)CC
+* SDL2 library
+* Possibly MinGW if running Windows
+
+Xbox:
+* nxdk (https://github.com/XboxDev/nxdk)
+
+To compile for nxdk, use:
+
+make -f Makefile.nxdk 
+
+## Compilation
+
+```
+$ make help
+Just use make (without any argument) to compile.
+Use make clean in order to delete mandelbrot.
+If you have errors during compilation, you can contact me for help.
+Windows users, you can use MinGW with this project.
+```
+
+Then run the program and enjoy ! :-)
+
+![screenshot](screenshotx.png "This is beautiful...")
+
+Happy fractal !

Mandelbrot Set (C)/headers/myFractal.h

@@ -0,0 +1,146 @@
+// This file has no copyright.
+
+#ifndef HEADERS_MYFRACTAL_H_
+#define HEADERS_MYFRACTAL_H_
+
+#if defined(NXDK)
+#include <SDL.h>
+#include <SDL_gamecontroller.h>
+#else
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_gamecontroller.h>
+#endif
+#include "myStructures.h"
+#include "mySDL.h"
+
+bool fractal_init = false;
+
+Fractal *init_fractal() {
+
+  Fractal *fractal = malloc(sizeof(Fractal));
+
+  // Used to move camera
+  fractal->xMove = 0;
+  fractal->yMove = 0;
+
+  // Used to change the zoom and precision
+  fractal->zoom = 0.3;
+  fractal->iMax = 60;
+
+  fractal_init = true;
+
+  return fractal;
+} 
+
+void draw_mandelbrot(Sdl *sdl, Fractal *fractal) {
+  int i;
+
+  SDL_LockSurface(sdl->surface);
+
+  uint32_t *pixels = sdl->surface->pixels;
+  SDL_PixelFormat *pixelFormat = sdl->surface->format;
+
+  int xFrame = WINDOW_WIDTH;
+  int yFrame = WINDOW_HEIGHT;
+
+  // Formula is Z(n+1) = Z(n)^2 + C
+  // https://en.wikipedia.org/wiki/Mandelbrot_set
+  Complex c;
+  Complex z;
+
+  // Coordinate of each point
+  int x;
+  int y;
+
+  // Calculate all the y for every x
+  for (y = 0; y < yFrame; y++) {
+    c.i = ((y - yFrame / 2) / (0.5 * yFrame * fractal->zoom)) - fractal->yMove;
+
+    for (x = 0; x < xFrame; x++) {
+      c.r = ((x - xFrame / 2) / (0.5 * xFrame * fractal->zoom)) - fractal->xMove;
+
+      z.r = 0;
+      z.i = 0;
+
+      i = 0;
+
+
+      // Iterate in order to know if a certain point is in the set or not
+      do {
+        z.b = z.r;
+        z.r = z.r * z.r - z.i * z.i + c.r;
+        z.i = 2 * z.i * z.b + c.i;
+        i++;
+      } while (z.r * z.r + z.i * z.i < 4 && i < fractal->iMax);
+      // We don't use square root in order to reduce calculation time
+
+       if (i >= fractal->iMax) {
+        // In the set
+        pixels[(y * xFrame + x)] = SDL_MapRGB(pixelFormat, 0, 0, 255);
+      } else {
+        // Not in the set
+        pixels[(y * xFrame + x)] = SDL_MapRGB(pixelFormat, 0, 0, (i * (255 / fractal->iMax)));
+      }
+
+      // Render using SDL_RenderDrawPoint() is slow and should
+      // be replaced by SDL_RenderDrawPoints()
+    }
+  }
+  SDL_UnlockSurface(sdl->surface);
+  SDL_UpdateWindowSurface(sdl->window);
+}
+
+
+void is_user_moving(Sdl *sdl, Fractal *fractal) {
+
+    // Delta time to sync everything
+  float delta = 0.30;
+
+  // Movement speed
+  float moveStep = 0.5;
+  float zoomStep = 3.0;
+
+  while (SDL_PollEvent(&sdl->event)) {
+    if (sdl->event.type == SDL_CONTROLLERBUTTONDOWN) {
+      switch (sdl->event.cbutton.button) {
+        case SDL_CONTROLLER_BUTTON_DPAD_LEFT:
+          fractal->xMove = fractal->xMove + (moveStep / fractal->zoom * delta);
+          break;
+        case SDL_CONTROLLER_BUTTON_DPAD_RIGHT:
+          fractal->xMove = fractal->xMove - (moveStep / fractal->zoom * delta);
+          break;
+        case SDL_CONTROLLER_BUTTON_DPAD_UP:
+          fractal->yMove = fractal->yMove + (moveStep / fractal->zoom * delta);
+          break;
+        case SDL_CONTROLLER_BUTTON_DPAD_DOWN:
+          fractal->yMove = fractal->yMove - (moveStep / fractal->zoom * delta);
+          break;
+        case SDL_CONTROLLER_BUTTON_B:
+          fractal->zoom = fractal->zoom + (moveStep * fractal->zoom * delta);
+          fractal->iMax = fractal->iMax + zoomStep * delta;
+          break;
+        case SDL_CONTROLLER_BUTTON_X:
+          fractal->zoom = fractal->zoom - (moveStep * fractal->zoom * delta);
+          fractal->iMax = fractal->iMax - zoomStep * delta;
+          break;
+        default:
+          break;
+      }
+    }
+  }
+}
+
+bool is_user_exiting (Sdl *sdl)
+{
+  if(sdl->event.type == SDL_QUIT)
+  {
+    return true;
+  }
+  else
+  {
+    return false;
+  }
+
+}
+
+#endif  // HEADERS_MYFRACTAL_H_

Mandelbrot Set (C)/headers/mySDL.h

@@ -0,0 +1,95 @@
+// This file has no copyright.
+
+#ifndef HEADERS_MYSDL_H_
+#define HEADERS_MYSDL_H_
+
+#if defined(NXDK)
+#include <SDL.h>
+#include <SDL_gamecontroller.h>
+#else
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_gamecontroller.h>
+#endif
+#include <stdbool.h>
+#include <assert.h>
+
+bool sdl_init = false;
+
+SDL_GameController *controller = NULL; // We initialize a controller and give it a NULL value for now
+
+static bool isNewlyPressed(bool is_held, bool *was_held) {
+
+  if (is_held) { // If the button is held in this frame
+    if (*was_held) { // If it was held in the previous frame
+      return false; // The button isn't newly pressed
+    } 
+    else { // If it wasn't held in the previous frame
+      *was_held = true; // Set was_held to true because the current frame will be the previous frame in the next frame
+      return true; // The button is newly pressed, so we return true
+    } 
+
+  } 
+  else { // If it isn't held in the current frame
+    *was_held = false; // Set was_held to false
+    return false; // The button isn't pressed at all, so we return false
+  }
+}
+
+
+float remap(float value, float from_min, float from_max, float to_min, float to_max) { // Function to remap values to other values
+    value = ((value - from_min) / (from_max - from_min)) * (to_max - to_min) + to_min;
+    return value;
+}
+
+static float getAxis(int sdl_axis) { // Function to get an axis from the controller
+
+  const float deadzone = 0.2f;
+
+  // Get input in range -1 to +1
+  float amount = (float)SDL_GameControllerGetAxis(controller, sdl_axis) / (float)0x8000;
+
+  // Reject if the stick is in deadzone
+  if (fabsf(amount) < deadzone) {
+    return 0.0f;
+  }
+
+  if (amount > 0.0f) {
+  amount = remap(amount,  deadzone, +1.0f,  0.0f, +1.0f); // Remap from +[0.2, 1.0] to +[0.0, 1.0]
+  } 
+  else {
+  amount = -remap(-amount,  deadzone, +1.0f,  0.0f, +1.0f); // Remap from -[0.2, 1.0] to -[0.0, 1.0]
+  }
+  return amount;
+}
+
+Sdl *init_sdl() {
+
+  Sdl *sdl = malloc(sizeof(Sdl));
+
+  SDL_Init(SDL_INIT_GAMECONTROLLER|SDL_INIT_VIDEO);
+  SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, "1");
+
+  sdl->window = SDL_CreateWindow(WINDOW_TITLE, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WINDOW_WIDTH, WINDOW_HEIGHT, 0);
+
+  sdl->surface = SDL_GetWindowSurface(sdl->window);
+
+  assert(sdl->surface != NULL);
+
+  sdl_init = true;
+
+  return sdl;
+}
+
+/*
+void draw_cross(Sdl *sdl) {
+  // Draw a little cross when user zooms in/out or moves
+  int length = 15;
+  SDL_SetRenderDrawColor(sdl->renderer, 255, 255, 255, 255);
+
+  SDL_RenderDrawLine(sdl->renderer, WINDOW_WIDTH / 2 - length / 2,
+    WINDOW_HEIGHT / 2, WINDOW_WIDTH / 2 + length / 2, WINDOW_HEIGHT / 2);
+  SDL_RenderDrawLine(sdl->renderer, WINDOW_WIDTH / 2, WINDOW_HEIGHT
+    / 2 - length / 2, WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2 + length / 2);
+} */
+
+#endif  // HEADERS_MYSDL_H_

Mandelbrot Set (C)/headers/myStructures.h

@@ -0,0 +1,54 @@
+// This file has no copyright.
+
+#ifndef HEADERS_MYSTRUCTURES_H_
+#define HEADERS_MYSTRUCTURES_H_
+#if defined(NXDK)
+#include <SDL.h>
+#include <SDL_gamecontroller.h>
+#else
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_gamecontroller.h>
+#endif
+
+// This has to be a square
+#define WINDOW_WIDTH 480
+#define WINDOW_HEIGHT 480
+
+#define WINDOW_TITLE "Mandelbrot Fractal, by Geographer (Xbox port by Kosmas12)"
+
+typedef struct Sdl {
+  SDL_Window *window;
+  SDL_Surface *surface;
+  SDL_PixelFormat *format;
+  SDL_Event event;
+} Sdl;
+
+typedef struct Complex {
+  // Real part, imaginary part and a backup
+  double r;
+  double i;
+  double b;
+} Complex;
+
+typedef struct Fractal {
+  // See myFractal.h
+  double xMove;
+  double yMove;
+  double zoom;
+  unsigned int iMax;
+} Fractal;
+
+void free_everything(Sdl *sdl, Fractal *fractal) {
+
+  SDL_DestroyWindow(sdl->window);
+  free(sdl);
+
+  free(fractal);
+
+  SDL_Quit();
+
+  // You may observe memory leaks using this program
+  // SDL2 leaks by itself
+}
+
+#endif  // HEADERS_MYSTRUCTURES_H_