Import source code

blocSpawn/Input.cpp

@@ -0,0 +1,153 @@
+#include "Input.h"
+
+
+// Constructeur et Destructeur
+Input::Input()
+        : m_x(0), m_y(0), m_xRel(0), m_yRel(0),
+          m_finished(false), m_relativeMouse(false), m_window(0), m_windowHalfHeight(0), m_windowHalfWidth(0) {
+    // Initialisation du tableau m_keys[]
+    for (int i(0); i < SDL_NUM_SCANCODES; i++)
+        m_keys[i] = false;
+
+    // Initialisation du tableau m_mouseKeys[]
+    for (int i(0); i < 8; i++)
+        m_mouseKeys[i] = false;
+}
+
+
+Input::~Input() {}
+
+
+// Méthodes
+void Input::updateEvents() {
+    // Réinitialise les coordonnées relatives
+    m_xRel = 0;
+    m_yRel = 0;
+
+    // Boucle d'évènements
+    while (SDL_PollEvent(&m_events)) {
+        // Switch sur le type d'évènement
+        switch (m_events.type) {
+            // Cas d'une touche enfoncée
+            case SDL_KEYDOWN:
+                m_keys[m_events.key.keysym.scancode] = true;
+                break;
+
+                // Cas d'une touche relâchée
+            case SDL_KEYUP:
+                m_keys[m_events.key.keysym.scancode] = false;
+                break;
+
+                // Cas de pression sur un bouton de la souris
+            case SDL_MOUSEBUTTONDOWN:
+                m_mouseKeys[m_events.button.button] = true;
+                break;
+
+                // Cas du relâchement d'un bouton de la souris
+            case SDL_MOUSEBUTTONUP:
+                m_mouseKeys[m_events.button.button] = false;
+                break;
+
+                // Cas d'un mouvement de souris
+            case SDL_MOUSEMOTION:
+                if (m_relativeMouse) {
+                    m_xRel = m_events.motion.x - m_windowHalfWidth;
+                    m_yRel = m_events.motion.y - m_windowHalfHeight;
+                } else {
+                    m_x = m_events.motion.x;
+                    m_y = m_events.motion.y;
+                    m_xRel = m_events.motion.xrel;
+                    m_yRel = m_events.motion.yrel;
+                }
+
+                break;
+
+                // Cas de la fermeture de la fenêtre
+            case SDL_WINDOWEVENT:
+                if (m_events.window.event == SDL_WINDOWEVENT_CLOSE)
+                    m_finished = true;
+                break;
+
+
+            default:
+                break;
+        }
+    }
+
+    // Pour éviter que la souris se barre en mode relative, on la "warp"
+    if (m_relativeMouse)
+        SDL_WarpMouseInWindow(m_window, m_windowHalfWidth, m_windowHalfHeight);
+}
+
+
+bool Input::isFinished() const {
+    return m_finished;
+}
+
+
+void Input::showCursor(bool reponse) const {
+    if (reponse)
+        SDL_ShowCursor(SDL_ENABLE);
+
+    else
+        SDL_ShowCursor(SDL_DISABLE);
+}
+
+
+void Input::capPtr(bool reponse) {
+    m_relativeMouse = reponse;
+}
+
+
+
+// Getters
+
+bool Input::getKey(const SDL_Scancode key) const {
+    return m_keys[key];
+}
+
+bool Input::getMouseKey(const Uint8 key) const {
+    return m_mouseKeys[key];
+}
+
+
+bool Input::isMouseMoving() const {
+    return !(m_xRel == 0 && m_yRel == 0);
+}
+
+
+// Getters concernant la position du curseur
+
+int Input::getX() const {
+    return m_x;
+}
+
+int Input::getY() const {
+    return m_y;
+}
+
+int Input::getXRel() const {
+    return m_xRel;
+}
+
+int Input::getYRel() const {
+    return m_yRel;
+}
+
+void Input::setWindow(SDL_Window *activWindow) {
+    // Attributio directe
+    m_window = activWindow;
+
+    // Détermination de l'endroit de capture du pointeur
+    SDL_GetWindowSize(activWindow, &m_windowHalfWidth, &m_windowHalfHeight);
+    m_windowHalfWidth /= 2;
+    m_windowHalfHeight /= 2;
+}
+
+int Input::getMouseRelX() const {
+    return m_xRel;
+}
+
+int Input::getMouseRelY() const {
+    return m_yRel;
+}

blocSpawn/Input.h

@@ -0,0 +1,59 @@
+#ifndef DEF_INPUT
+#define DEF_INPUT
+
+///Jovian
+///Adaptation pour CMake
+
+// Include
+#include <SDL.h>
+
+
+class Input
+{
+    public:
+
+    Input();
+    ~Input();
+
+    virtual void updateEvents();
+    bool isFinished() const;
+    void showCursor(bool reponse) const;
+    void capPtr(bool reponse);
+
+    bool getKey(const SDL_Scancode key) const;
+    bool getMouseKey(const Uint8 key) const;
+    bool isMouseMoving() const;
+
+    int getX() const;
+    int getY() const;
+
+    int getXRel() const;
+    int getYRel() const;
+
+    void setWindow(SDL_Window* activWindow);
+
+    int getMouseRelX() const;
+    int getMouseRelY() const;
+
+
+    protected:
+
+    SDL_Event m_events;
+    bool m_keys[SDL_NUM_SCANCODES];
+    bool m_mouseKeys[8];
+
+    int m_x;
+    int m_y;
+    int m_xRel;
+    int m_yRel;
+
+    bool m_finished;
+    bool m_relativeMouse;
+
+    SDL_Window* m_window;
+    int m_windowHalfHeight;
+    int m_windowHalfWidth;
+};
+
+#endif
+

blocSpawn/main.cpp

@@ -0,0 +1,123 @@
+#include <iostream>
+#include <SDL.h>
+#include <Box2D/Box2D.h>
+#include "texturer.h"
+#include "Input.h"
+
+using namespace std;
+
+int main() {
+    // Start
+    cout << "SDL2 app is loading..." << endl;
+
+    // Useful data
+    const int SCREEN_WIDTH = 1200;
+    const int SCREEN_HEIGHT = 700;
+
+    // Init video
+    if (SDL_Init(SDL_INIT_VIDEO) != 0) {
+        logSDLError(cout, "SDL_Init(SDL_INIT_VIDEO)");
+        return 1;
+    }
+
+    // Opening window
+    SDL_Window *win = SDL_CreateWindow("Hello Box2D!",
+                                       SDL_WINDOWPOS_UNDEFINED,
+                                       SDL_WINDOWPOS_UNDEFINED,
+                                       SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
+    if (win == nullptr) {
+        logSDLError(cout, "SDL_CreateWindow");
+        SDL_Quit();
+        return 1;
+    }
+
+    // Create a renderer
+    SDL_Renderer *ren = SDL_CreateRenderer(win, -1,
+                                           SDL_RENDERER_ACCELERATED |
+                                           SDL_RENDERER_PRESENTVSYNC);
+    if (ren == nullptr) {
+        SDL_DestroyWindow(win);
+        logSDLError(cout, "SDL_CreateRenderer");
+        SDL_Quit();
+        return 1;
+    }
+
+    // Events
+    Input myInput;
+
+    // Time
+    Uint32 frameRate(60);
+    Uint32 prevTime(0);
+    Uint32 waitTime(1000 / frameRate);
+    float timeStep(1.0f / frameRate);
+
+    int32 velocityIterations = 6;
+    int32 positionIterations = 2;
+
+    /// Physic
+    // World
+    b2Vec2 gravity(0.0f, 10.0f);
+    b2World world(gravity);
+    float zoom = 50.0f;
+
+    // Defs
+    b2BodyDef myBodyDef;
+    b2PolygonShape myBox;
+
+    // Ground body
+    myBodyDef.position.Set(10.0f, 17.0f);
+    b2Body* groundBody(world.CreateBody(&myBodyDef));
+
+    myBox.SetAsBox(50.0f, 5.0f);
+
+    groundBody->CreateFixture(&myBox, 0.0f); // Warning : simple function (no fixture)
+
+    // Crate body
+    myBodyDef.type = b2_dynamicBody;
+    myBodyDef.position.Set(10.0f, -4.0f);
+    b2Body* crateBody(world.CreateBody(&myBodyDef));
+
+    myBox.SetAsBox(1.0f, 1.0f);
+
+    b2FixtureDef myFixtureDef;
+    myFixtureDef.shape = &myBox;
+    myFixtureDef.density = 1.0f;
+    myFixtureDef.friction = 0.3f;
+    myFixtureDef.restitution = 0.3f;
+
+    crateBody->CreateFixture(&myFixtureDef);
+
+    while (!myInput.isFinished()) {
+        // Update events
+        myInput.updateEvents();
+
+        // Update physic
+        world.Step(timeStep, velocityIterations, positionIterations);
+
+        // Reset renderer
+        SDL_SetRenderDrawColor(ren, 0xFF, 0xFF, 0xFF, 0xFF);
+        SDL_RenderClear(ren);
+
+        // Foreground
+        b2Vec2 pos(crateBody->GetPosition());
+        float32 angle(crateBody->GetAngle());
+
+        SDL_Rect fillRect = {(int)(pos.x * zoom), (int)(pos.y * zoom), 100, 100};
+        SDL_SetRenderDrawColor(ren, 0xFF, 0x00, 0x00, 0xFF);
+        SDL_RenderFillRect(ren, &fillRect);
+
+        // Render
+        SDL_RenderPresent(ren);
+
+        // Pause
+        if (SDL_GetTicks() < prevTime + waitTime)
+            SDL_Delay(waitTime + prevTime - SDL_GetTicks());
+        prevTime = SDL_GetTicks();
+    }
+
+    // End
+    SDL_DestroyRenderer(ren);
+    SDL_DestroyWindow(win);
+    SDL_Quit();
+    return 0;
+}

blocSpawn/texturer.cpp

@@ -0,0 +1,9 @@
+//
+// Created by jovian on 16/07/17.
+//
+#include "texturer.h"
+
+void logSDLError(std::ostream &os, const std::string &msg) {
+    os << msg << " error: " << SDL_GetError() << std::endl;
+}
+

blocSpawn/texturer.h

@@ -0,0 +1,15 @@
+//
+// Created by jovian on 16/07/17.
+//
+
+#ifndef HELLOSDL_TEXTURER_H
+#define HELLOSDL_TEXTURER_H
+
+#include <iostream>
+#include <SDL.h>
+#include <SDL_image.h>
+
+
+void logSDLError(std::ostream &os, const std::string &msg);
+
+#endif //HELLOSDL_TEXTURER_H