renderer.h

Go to the documentation of this file.

/*
    toxic - A Global Illumination Renderer
    Copyright (C) 2003-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of toxic.

    toxic 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.

    toxic 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 toxic; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef TOXIC_RENDERER_RENDERER_H
#define TOXIC_RENDERER_RENDERER_H

#include "common/math/point3.h"
#include "common/math/real.h"
#include "common/math/vector3.h"
#include "framebuffer.h"
#include "globals.h"
#include "ilight.h"

#include <cassert>

namespace toxic {

    class Context;
    class Framebuffer;
    class Hit;
    class ICamera;
    class ISurfaceSampler;
    class ISurfaceShader;
    class PhotonMap;
    class Ray;
    class Scene;
    class ShadingData;

    class Renderer {
    public:
        Renderer();
        virtual ~Renderer();

        //! Sets the scene to render.
        void SetScene(const Scene *scene);

        //! Sets the camera.
        void SetCamera(const ICamera *camera);

        //! Sets the global photon map.
        void SetGlobalPhotonMap(const PhotonMap *global_pm);

        //! Sets the caustics photon map.
        void SetCausticsPhotonMap(const PhotonMap *cautics_pm);

        //! Sets the framebuffer and resets the render area.
        void SetFramebuffer(Framebuffer *framebuffer);

        //! Sets the render area to the rectangle (x0, y0)-(x1, y1). (x0, y0) are the
        //! coordinates of the upper left corner of the render area. (x1, y1) are the
        //! coordinates of the lower right corner of the render area. The given rectangle
        //! is clipped against the framebuffer boundaries. The framebuffer must be set
        //! prior to calling this method.
        //!\todo Should this method take a pair of sheep::Point2 (in NDC) instead of four ints?
        void SetRenderArea(int x0, int y0, int x1, int y1);

        //! Sets the render area to the full frame.
        void ResetRenderArea();

        //! Initializes the renderer. Must be called once just before calling the
        //! RenderNextPixel() method (and after having set the scene, the camera,
        //! the framebuffer and the render area).
        void Restart(const Context &context);

        //! Renders the next pixel. Does nothing if there is no more pixel to render.
        void RenderNextPixel(const Context &context);

        //! Methods for progress report.
        bool IsRenderComplete() const;
        int GetCompletedLines() const;
        sheep::Real GetProgress() const;

        void Annotate(const Context &context);

    private:
        const Scene *m_scene;
        const ICamera *m_camera;

        //! Taken from Jensen's book: "The global photon map contains all photons
        //! that hit diffuse surfaces in the model. The photons in the global
        //! photon map represent direct illumination, indirect illumination, and
        //! caustics (in path notation: L(S|D)*D)."
        const PhotonMap *m_global_pm;

        //! Jensen: "The caustics photon map contains photons that have been
        //! reflected or transmitted via one specular surface before hitting
        //! a diffuse surface. In the path notation these are LS+D."
        const PhotonMap *m_caustics_pm;

        Framebuffer *m_framebuffer;

        int m_area_x0, m_area_y0;               //!< Top-left corner of the render area.
        int m_area_x1, m_area_y1;               //!< Bottom-right corner of the render area.

        int m_x, m_y;                           //!< Coordinates of the next pixel to render.
        int m_completed_pixels;                 //!< Number of rendered pixels until now.

        //! Precomputed values.
        int m_area_pixels;                      //!< Number of pixels contained in the render area.
        sheep::Real m_inv_area_pixels;          //!< m_inv_area_pixels = 1.0 / m_area_pixels.

        //! Surface samplers.
        ISurfaceSampler *m_pixel_ss;            //!< Pixel surface sampler.
        ISurfaceSampler *m_arealight_ss;        //!< Area light surface sampler.
        ISurfaceSampler *m_primary_fg_hss;      //!< Hemisphere surface sampler when doing primary final gathering.
        ISurfaceSampler *m_secondary_fg_hss;    //!< Hemisphere surface sampler when doing secondary final gathering.

        //! Irradiance samples (area light sampling).
        ILight::IrradianceSampleVector m_irradiance_samples;

#ifdef ENABLE_WHITTED_SAMPLING_CACHE
        Color3 *m_prev_pixels;
#endif  // ENABLE_WHITTED_SAMPLING_CACHE

        void cleanup();

        //! Computes the radiance passing through the current pixel and stores it
        //! into the framebuffer.
        void render_pixel(const Context &context);

        void render_pixel_supersampling(const Context &context);
        void render_pixel_whitted(const Context &context);

        Color3 whitted_recursive_sampling(
            const Context &context,
            const sheep::Point2 &center,
            const sheep::Point2 &v0,
            const sheep::Point2 &v1,
            const sheep::Point2 &v2,
            const sheep::Point2 &v3,
            const Color3 &r0,
            const Color3 &r1,
            const Color3 &r2,
            const Color3 &r3,
            int recursion_level
        );  // not const because of trace()

        //! Traces a ray through the scene and returns the total reflected radiance
        //! along this ray. The ray is expressed in world space. The returned value
        //! is a radiance (W.m^-2.sr^-1).
        Color3 trace(
            const Context &context,
            const Ray &ray,
            int recursion_level
        );  // not const because of compute_direct_illumination()

        //! Computes the radiance reflected toward a given direction due to direct
        //! illumination of a given surface, at a given point. The point, the surface
        //! normal and the direction are expressed in world space. The direction is
        //! such as it leaves the surface, and is unit-length. The returned value is
        //! a radiance (W.m^-2.sr^-1).
        Color3 compute_direct_illumination(
            const Context &context,
            const sheep::Point3 &point,
            const sheep::Vector3 &geometric_normal,
            const sheep::Vector3 &shading_normal,
            const sheep::Vector3 &outgoing,
            const ISurfaceShader *surface_shader,
            const ShadingData &shadingdata
        );  // not const

        //! The returned value is a radiance (W.m^-2.sr^-1).
        Color3 compute_specular_reflections(
            const Context &context,
            const sheep::Point3 &point,
            const sheep::Vector3 &geometric_normal,
            const sheep::Vector3 &shading_normal,
            const sheep::Vector3 &outgoing,
            const ShadingData &shadingdata,
            int recursion_level
        );  // not const because of trace()

        //! The returned value is a radiance (W.m^-2.sr^-1).
        Color3 final_gathering(
            const Context &context,
            const sheep::Point3 &point,
            const sheep::Vector3 &geometric_normal,
            const sheep::Vector3 &shading_normal,
            const sheep::Vector3 &outgoing,
            const ShadingData &shadingdata,
            bool is_secondary = false
        ) const;

        //! The returned value is a radiance (W.m^-2.sr^-1).
        Color3 compute_caustics(
            const Context &context,
            const sheep::Point3 &point,
            const sheep::Vector3 &geometric_normal,
            const sheep::Vector3 &shading_normal,
            const sheep::Vector3 &outgoing,
            const ShadingData &shadingdata
        ) const;

        //! This is an auxiliary method used by the final_gathering() method.
        //! Computes the radiance reflected toward a given direction due to the photon
        //! density on a given surface, around a given point. The point, the surface
        //! normal and the outgoing direction are expressed in world space. The outgoing
        //! direction is such that it leaves the surface, and it is unit-length. The
        //! returned value is a radiance (W.m^-2.sr^-1).
        Color3 compute_indirect_illumination(
            const Context &context,
            const sheep::Point3 &point,
            const sheep::Vector3 &geometric_normal,
            const sheep::Vector3 &shading_normal,
            const sheep::Vector3 &outgoing,
            const ShadingData &shadingdata
        ) const;
    };

#include "renderer.inl"

}

#endif  // !TOXIC_RENDERER_RENDERER_H

---