Event.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012> <EDF-R&D> <FRANCE>
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#ifndef EVENT_H
#define EVENT_H
 
#include <vector>
#include "Geometry/Sampler.h"
#include "Base.h"
 
enum typeevent
{
    UNKNOWN = -1,
    SPECULARREFLEXION = 0,
    DIFFRACTION,
    NOTHING
};
 
class Shape;
 
class Event : public Base
{
public:
    Event(const vec3& position = vec3(0.0, 0.0, 0.0), const vec3& incomingDirection = vec3(0.0, 0.0, 0.0),
          Shape* _shape = NULL)
        : Base(), pos(position), from(incomingDirection), nbResponseLeft(0), initialNbResponse(0),
          sampler(NULL), shape(_shape), type(UNKNOWN)
    {
        name = "unknown event";
    }
    Event(const Event& other) : Base(other)
    {
        pos = vec3(other.pos);
        from = vec3(other.pos);
        nbResponseLeft = other.nbResponseLeft;
        initialNbResponse = other.initialNbResponse;
        type = other.type;
        shape = other.shape;
        if (other.sampler)
        {
            sampler = new Sampler(*(other.sampler));
        }
        else
        {
            sampler = NULL;
        }
    }
    virtual ~Event()
    {
        if (sampler)
        {
            delete sampler;
        }
    };
 
    // Unused function:
    // virtual bool isDiffuse() { return false; }
 
    const vec3& getPosition() const
    {
        return pos;
    }
 
    void setPosition(const vec3& _pos)
    {
        pos = vec3(_pos);
    }
 
    vec3 getIncomingDirection()
    {
        return from;
    }
 
    void setIncomingDirection(const vec3& _from)
    {
        from = vec3(_from);
    }
 
    bool isReponseLeft()
    {
        return nbResponseLeft > 0;
    }
    int getNbResponseLeft()
    {
        return nbResponseLeft;
    }
    virtual void setNbResponseLeft(int _nbResponseLeft)
    {
        nbResponseLeft = _nbResponseLeft;
    }
    virtual int getInitialNbResponseLeft() const
    {
        return initialNbResponse;
    }
 
    Shape* getShape()
    {
        return shape;
    }
 
    const Shape* getShape() const
    {
        return shape;
    }
 
    void setShape(Shape* _shape)
    {
        shape = _shape;
    }
 
    virtual bool getResponse(vec3& r, bool force = false)
    {
        return false;
    }
 
    virtual bool isAcceptableResponse(vec3& test)
    {
        return false;
    }
 
    virtual bool generateTest(std::vector<vec3>& succededTest, std::vector<vec3>& failTest,
                              unsigned int nbResponses)
    {
        return true;
    }
 
    virtual bool generateResponse(std::vector<vec3>& responses, unsigned int nbResponses)
    {
        return false;
    }
 
    virtual bool appendTarget(vec3 target, bool force = false)
    {
        return false;
    }
 
    virtual int getType() const
    {
        return type;
    }
 
    virtual void setType(const typeevent& _type)
    {
        type = _type;
    }
 
    virtual double getAngle() const
    {
        return 0.0;
    }
 
    const decimal distance(const Event& other) const
    {
        return this->pos.distance(other.getPosition());
    }
 
protected:
    vec3 pos;              
    vec3 from;             
    int nbResponseLeft;    
    int initialNbResponse; 
    Sampler* sampler;      
    Shape* shape;          
    typeevent type;        
 
#ifdef _ALLOW_TARGETING_
    std::vector<vec3> targets;
#endif
};
 
#endif