objects.h

Go to the documentation of this file.

#ifndef OBJECTS_H
#define OBJECTS_H
 
#include <functional>
 
#include "utils.h"
#include "configuration.h"
#include "render.h"
#include "colormaps.h"
#include "geometry.h"
#include "objects_geometry.h"
#include "data_logger.h"
 
 
class Simulation;
class LightLevelMap;
 

class Object {
public:
    Object(float _x, float _y, ObjectGeometry& _geom, std::string const& _category = "objects");

    Object(Simulation* simulation, float _x, float _y, Configuration const& config, std::string const& _category = "objects");

    virtual ~Object();
 

    void init(b2WorldId world_id) {
        if (initialized) {
            throw std::runtime_error("Object::init() called twice.");
        }
        do_init(world_id);
        initialized = true;
    }

    bool is_initialized() const noexcept {
        return initialized;
    }
 

    virtual void render(SDL_Renderer* renderer, b2WorldId world_id) const = 0;

    virtual void launch_user_step(float f);

    ObjectGeometry* get_geometry() { return geom;} ;

    virtual void move(float x, float y, float theta = NAN);

    virtual bool is_tangible() const { return false; };

    virtual void serialize_base_values(DataLogger* data_logger, double t);

    virtual void create_serialization_fields(DataLogger* data_logger);

    virtual arena_polygons_t generate_contours(std::size_t points_per_contour = 0) const;
 
    // Physical information
    float x;                            
    float y;                            
    float theta;                        
 
    // Base information
    std::string category;               
 
protected:
    virtual void do_init([[maybe_unused]] b2WorldId world_id) { }

    virtual void parse_configuration(Configuration const& config, Simulation* simulation);
 
    ObjectGeometry* geom;                
 
private:
    bool initialized = false;
};
 

class PhysicalObject : public Object {
public:

    PhysicalObject(uint16_t _id, float _x, float _y,
           ObjectGeometry& geom,
           float _linear_damping = 0.0f, float _angular_damping = 0.0f,
           float _density = 10.0f, float _friction = 0.3f, float _restitution = 0.5f,
           std::string const& _category = "objects");

    PhysicalObject(Simulation* simulation, uint16_t _id, float _x, float _y,
           Configuration const& config,
           std::string const& _category = "objects");

    virtual void launch_user_step(float t) override;

    virtual b2Vec2 get_position() const;

    float get_angle() const;

    float get_angular_velocity() const;

    b2Vec2 get_linear_acceleration() const;

    virtual void render(SDL_Renderer* renderer, b2WorldId world_id) const override = 0 ;

    virtual void move(float x, float y, float theta = NAN) override;

    virtual bool is_tangible() const override { return true; };

    virtual void create_serialization_fields(DataLogger* data_logger) override;

    virtual void serialize_base_values(DataLogger* data_logger, double t) override;

    virtual arena_polygons_t generate_contours(std::size_t points_per_contour = 0) const override;
 
    // Base info
    uint16_t id;                         
 
 
protected:
    virtual void do_init([[maybe_unused]] b2WorldId world_id) override;

    virtual void parse_configuration(Configuration const& config, Simulation* simulation) override;

    virtual void create_body(b2WorldId world_id);
 
    // Physical information
    float linear_damping;
    float angular_damping;
    float density;
    float friction;
    float restitution;
    b2BodyId body_id;      
 
    // Useful to compute acceleration
    float _estimated_dt = 0.0f;
    float _last_time = 0.0f;
    b2Vec2 _prev_v = {NAN, NAN};
    b2Vec2 _lin_acc = {NAN, NAN};
};
 

class PassiveObject : public PhysicalObject {
public:

    PassiveObject(uint16_t _id, float _x, float _y,
           ObjectGeometry& geom,
           float _linear_damping = 0.0f, float _angular_damping = 0.0f,
           float _density = 10.0f, float _friction = 0.3f, float _restitution = 0.5f,
           std::string _colormap = "rainbow",
           std::string const& _category = "objects");

    PassiveObject(Simulation* simulation, uint16_t _id, float _x, float _y,
           Configuration const& config,
           std::string const& _category = "objects");

    void render(SDL_Renderer* renderer, b2WorldId world_id) const override;
 
protected:
    std::string colormap;

    virtual void parse_configuration(Configuration const& config, Simulation* simulation) override;
};
 

Object* object_factory(Simulation* simulation, uint16_t id, float x, float y, b2WorldId world_id, Configuration const& config, LightLevelMap* light_map, size_t userdatasize = 0, std::string const& category = "objects");

void get_cmap_val(std::string const name, uint8_t const value, uint8_t* r, uint8_t* g, uint8_t* b);
 
#endif
 
 
// MODELINE "{{{1
// vim:expandtab:softtabstop=4:shiftwidth=4:fileencoding=utf-8
// vim:foldmethod=marker