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 "objects_geometry.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();
 

    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 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 parse_configuration(Configuration const& config, Simulation* simulation);
 
    ObjectGeometry* geom;                
};
 

class PhysicalObject : public Object {
public:

    PhysicalObject(uint16_t _id, float _x, float _y,
           ObjectGeometry& geom, b2WorldId world_id,
           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,
           b2WorldId world_id, 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 arena_polygons_t generate_contours(std::size_t points_per_contour = 0) const override;
 
    // Base info
    uint16_t id;                         
 
 
protected:
    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, b2WorldId world_id,
           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,
           b2WorldId world_id, 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