objects_geometry.h

Go to the documentation of this file.

#ifndef OBJECTS_GEOMETRY_H
#define OBJECTS_GEOMETRY_H
 
#include <functional>
#include <array>
 
#include "utils.h"
#include "configuration.h"
#include "render.h"
#include "colormaps.h"
 
 
class Simulation;

struct BoundingDisk {
    float center_x;
    float center_y;
    float radius;
};

struct BoundingBox {
    float x;
    float y;
    float width;
    float height;
};
 
 

class ObjectGeometry {
public:

    ObjectGeometry() {}

    virtual ~ObjectGeometry();

    virtual void create_box2d_shape(b2BodyId body_id, b2ShapeDef& shape_def) = 0;

    b2ShapeId get_shape_id() const { return shape_id; }

    virtual std::vector<std::vector<bool>> export_geometry_grid(size_t num_bins_x,
                                                                  size_t num_bins_y,
                                                                  float bin_width,
                                                                  float bin_height,
                                                                  float obj_x,
                                                                  float obj_y) const = 0;

    virtual void render(SDL_Renderer* renderer, b2WorldId world_id, float x, float y, float theta,
            uint8_t r, uint8_t g, uint8_t b, uint8_t alpha = 255) const = 0;

    virtual BoundingDisk compute_bounding_disk() const = 0;

    virtual BoundingBox compute_bounding_box() const = 0;

    virtual float get_distance_to(b2Vec2 orig, b2Vec2 point) const;

    virtual arena_polygons_t generate_contours(std::size_t points_per_contour = 0, b2Vec2 position = {0.0f, 0.0f}) const = 0;
 
protected:
    bool shape_created = false;
    b2ShapeId shape_id;     
};

class DiskGeometry : public ObjectGeometry {
public:

    DiskGeometry(float _radius) : radius(_radius) {}

    virtual void create_box2d_shape(b2BodyId body_id, b2ShapeDef& shape_def) override;

    float get_radius() const { return radius; }

    virtual std::vector<std::vector<bool>> export_geometry_grid(size_t num_bins_x,
                                                                  size_t num_bins_y,
                                                                  float bin_width,
                                                                  float bin_height,
                                                                  float obj_x,
                                                                  float obj_y) const override;

    virtual void render(SDL_Renderer* renderer, b2WorldId world_id, float x, float y, float theta,
            uint8_t r, uint8_t g, uint8_t b, uint8_t alpha = 255) const override;

    virtual BoundingDisk compute_bounding_disk() const override;

    virtual BoundingBox compute_bounding_box() const override;

    virtual arena_polygons_t generate_contours(std::size_t points_per_contour = 0, b2Vec2 position  = {0.0f, 0.0f}) const override;
 
protected:
    float radius;           
};
 
class RectangleGeometry : public ObjectGeometry {
public:
    RectangleGeometry(float _width, float _height) : width(_width), height(_height) {}

    virtual void create_box2d_shape(b2BodyId body_id, b2ShapeDef& shape_def) override;

    virtual std::vector<std::vector<bool>> export_geometry_grid(size_t num_bins_x,
                                                                  size_t num_bins_y,
                                                                  float bin_width,
                                                                  float bin_height,
                                                                  float obj_x,
                                                                  float obj_y) const override;

    virtual void render(SDL_Renderer* renderer, b2WorldId world_id, float x, float y, float theta,
                        uint8_t r, uint8_t g, uint8_t b, uint8_t alpha = 255) const override;

    float get_width() const { return width; }

    float get_height() const { return height; }

    virtual BoundingDisk compute_bounding_disk() const override;

    virtual BoundingBox compute_bounding_box() const override;

    virtual arena_polygons_t generate_contours(std::size_t points_per_contour = 0, b2Vec2 position  = {0.0f, 0.0f}) const override;
 
protected:
    float width;   
    float height;  
};
 
 
class TriangleGeometry : public ObjectGeometry {
public:
    explicit TriangleGeometry(float _side_length) : side_length(_side_length) {}

    void create_box2d_shape(b2BodyId body_id, b2ShapeDef& shape_def) override;

    std::vector<std::vector<bool>> export_geometry_grid(size_t num_bins_x,
                                                        size_t num_bins_y,
                                                        float bin_width,
                                                        float bin_height,
                                                        float obj_x,
                                                        float obj_y) const override;

    void render(SDL_Renderer* renderer, b2WorldId world_id, float x, float y, float theta,
                uint8_t r, uint8_t g, uint8_t b, uint8_t alpha = 255) const override;

    float get_side_length() const { return side_length; }

    BoundingDisk compute_bounding_disk() const override;

    BoundingBox compute_bounding_box() const override;

    arena_polygons_t generate_contours(std::size_t points_per_contour = 0, b2Vec2 position  = {0.0f, 0.0f}) const override;
 
private:
    std::array<b2Vec2, 3> get_local_vertices() const;
 
    float side_length;  
};
 

class GlobalGeometry final : public ObjectGeometry {
public:
    GlobalGeometry() {}

    virtual void create_box2d_shape(b2BodyId, b2ShapeDef&) override {};

    virtual std::vector<std::vector<bool>> export_geometry_grid(size_t num_bins_x,
                                                                  size_t num_bins_y,
                                                                  float bin_width,
                                                                  float bin_height,
                                                                  float obj_x,
                                                                  float obj_y) const override;

    virtual void render(SDL_Renderer*, b2WorldId, float, float, float, uint8_t, uint8_t, uint8_t, uint8_t = 255) const override {}

    virtual BoundingDisk compute_bounding_disk() const override;

    virtual BoundingBox compute_bounding_box() const override;

    virtual float get_distance_to([[maybe_unused]] b2Vec2 orig, [[maybe_unused]] b2Vec2 point) const override { return 0.0f; }

    virtual arena_polygons_t generate_contours([[maybe_unused]] std::size_t points_per_contour = 0, [[maybe_unused]] b2Vec2 position  = {0.0f, 0.0f}) const override { return {}; }
};
 

class ArenaGeometry final : public ObjectGeometry {
public:
    explicit ArenaGeometry(arena_polygons_t const& arena_polygons) noexcept
        : arena_polygons_{arena_polygons} {}
 
    /* ---------- ObjectGeometry interface ---------- */
 
    void create_box2d_shape([[maybe_unused]] b2BodyId body_id, [[maybe_unused]] b2ShapeDef& shape_def) override { }
 
    std::vector<std::vector<bool>>
    export_geometry_grid(std::size_t num_bins_x,
                         std::size_t num_bins_y,
                         float      bin_width,
                         float      bin_height,
                         float      obj_x,
                         float      obj_y) const override;
 
    void render(SDL_Renderer*, b2WorldId, float, float, float,
                uint8_t, uint8_t, uint8_t, uint8_t = 255) const override { }
 
    BoundingDisk  compute_bounding_disk() const override;
    BoundingBox   compute_bounding_box()  const override;

    float get_distance_to(b2Vec2 /*orig*/, b2Vec2 point) const override;
 
    arena_polygons_t const& get_arena_polygons() { return arena_polygons_; }

    virtual arena_polygons_t generate_contours(std::size_t points_per_contour = 0, b2Vec2 position  = {0.0f, 0.0f}) const override;
 
private:
    static float distance_point_segment(b2Vec2 p, b2Vec2 a, b2Vec2 b) noexcept;
    static bool  point_inside_polygon(b2Vec2 p, const std::vector<b2Vec2>& poly) noexcept;
 
    const arena_polygons_t& arena_polygons_;
};
 

ObjectGeometry* object_geometry_factory(Configuration const& config, Simulation* simulation);
 
 
#endif
 
// MODELINE "{{{1
// vim:expandtab:softtabstop=4:shiftwidth=4:fileencoding=utf-8
// vim:foldmethod=marker