src/Scene.h

Go to the documentation of this file.

#ifndef SCENE_H
#define SCENE_H


#include <vector>
#include <cassert>

#include "Object.h"
#include "Light.h"
#include "Texture.h"
#include "Primitive.h"
#include "BilliardPhysics.h"


class Shader;
class Animator;


class Scene
{
public:
    Scene();

    ~Scene();

    bool castShadows() const
    {
        return mCastShadows;
    }

    void setCastShadows(bool cs)
    {
        mCastShadows = cs;
    }

    const Object * getObject(int i) const
    {
        assert(i>=0);
        return mObjects.at(i);
    }

    void addObject( Object *    obj )
    {
        assert(obj);
        mObjects.push_back(obj);
        if (obj->applyPhysics())
            mPhysics.add(obj);
    }

    void removeObject(Object * obj);

    const Light * getLight(int i) const
    {
        assert(i>=0);
        return mLights.at(i);
    }

    void addLight(Light * light)
    {
        assert(light);
        light->setScene(this);
        mLights.push_back(light);
    }

    void removeLight(Light * light);

    unsigned int lightsCount() const
    {
        return mLights.size();
    }

    void addTexture(Texture* tex)
    {
        assert(tex);
        mTextures.push_back(tex);
    }

    const Texture * getTexture(int i) const
    {
        assert(i>=0);
        return mTextures.at(i);
    }

    void addShader(Shader* sh)
    {
        assert(sh);
        mShaders.push_back(sh);
    }

    const Shader * getShader(int i) const
    {
        assert(i>=0);
        return mShaders.at(i);
    }

    void setBgColor(const RGBAColor & c)
    {
        mBgColor = c;
        mBgColor.setA(1);
    }

    const RGBAColor & bgColor() const
    {
        return mBgColor;
    }

    RGBAColor rayTrace(Ray & ray) const
    {
        // we use this value to manage maximal possible tracing depth
        // FIXME maybe kick maxBounce and only use ray.recDeep()
        // FIXME test if ray.recDeep() method works with multithreading
        static __thread int maxBounce = 400;

        // here we store the result
        RGBAColor result = mBgColor;

        // only shoot another ray if the maximum recursion depth is not exceeded
        if (maxBounce > 0 && ray.recDeep() < MAX_RECURSION_DEEP && intersect(ray))
        {
            maxBounce --;
            assert( ray.hit()->shader() );
            result = ray.hit()->shade(ray); // shade the primitive
            maxBounce ++;
        }
#ifdef DEBUG
        // some stats
        if (maxBounce <= 0 || ray.recDeep() >= MAX_RECURSION_DEEP)
        {
            mBounced++;
//            LOG("bounced");
//            return RGBAColor(0, 1, 0);    // FIXME DEBUG
        }
#endif

        return result;
    }

    bool intersect(Ray & ray) const
    {
        bool hit = false;
        for (unsigned int i=0; i < mObjects.size(); i++)
        {
            hit |= mObjects[i]->intersect(ray);
        }
        return hit;
    }

    void clear();

    void addAnimator(Animator * ani)
    {
        assert(ani);
        mAnimators.push_back(ani);
    }

    void step();

    void physicsDump(const std::string & file)
    {
        mPhysics.dumpToFile(file);
    }

    void physicsLoad(const std::string & file)
    {
        mPhysics.loadFromFile(file);
    }

private:
    std::vector<Object *>   mObjects;

    std::vector<Light *>    mLights;

    std::vector<Texture *>  mTextures;

    std::vector<Shader *>   mShaders;

    std::vector<Animator *> mAnimators;

    RGBAColor               mBgColor;

    bool                    mCastShadows;

    BilliardPhysics         mPhysics;

    int                     mFrameNr;

#ifdef DEBUG
    static __thread long long int   mBounced;
#endif
};

#endif

---