settings.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_SETTINGS_H
#define TOXIC_RENDERER_SETTINGS_H

#include "common/math/real.h"
#include "globals.h"

namespace toxic {

    //! All settings come from the scene settings file.
    //! The Renderer class is the only class that accesses this settings.
    class Settings {
    public:
        struct SamplingSettings {
            enum Algorithm {
                RANDOM_SAMPLING,
                REGULAR_SAMPLING,
                STRATIFIED_SAMPLING
            } m_algorithm;

            //! Random sampling settings.
            struct RandomSampling {
                int m_samples;              //!< Number of samples.
                bool IsConsistent() const;
            } m_random_sampling;

            //! Regular sampling settings.
            struct RegularSampling {
                int m_width, m_height;      //!< Grid size (number of samples is m_width * m_height).
                bool IsConsistent() const;
            } m_regular_sampling;

            //! Stratified sampling settings.
            struct StratifiedSampling {
                int m_width, m_height;      //!< Grid size (number of samples is m_width * m_height).
                bool IsConsistent() const;
            } m_stratified_sampling;

            bool IsConsistent() const;
        };

        struct RadianceEstimateSettings {
            int m_max_photons;              //!< Maximum number of photons in the radiance estimate.
            sheep::Real m_max_distance;     //!< Maximum search distance in the radiance estimate.
            bool IsConsistent() const;
        };

        //! <Rendering>
        struct Rendering {
            //! <PixelSampling>
            struct PixelSampling {
                enum Algorithm {
                    SUPERSAMPLING,
                    WHITTED_ADAPTIVE_SAMPLING
                } m_algorithm;

                //! <Supersampling>
                struct Supersampling : public SamplingSettings {
                } m_supersampling;

                //! <WhittedAdaptiveSampling>
                struct WhittedAdaptiveSampling {
                    sheep::Real m_contrast_threshold;   //!< Contrast threshold to decide when to subdivide further.
                    int m_max_depth;                    //!< Maximum recursion level.
                    bool IsConsistent() const;
                } m_whitted_adaptive_sampling;

                bool IsConsistent() const;
            } m_pixel_sampling;

            //! <Components>
            struct Components {
                //! <DirectLighting>
                struct DirectLighting {
                    bool m_enabled;         //!< Include direct lighting?

                    //! <ArealightSampling>
                    struct ArealightSampling : public SamplingSettings {
                    } m_arealight_sampling;

                    bool IsConsistent() const;
                } m_direct_lighting;

                //! <IndirectLighting>
                struct IndirectLighting {
                    bool m_enabled;         //!< Include indirect lighting?

                    //! <PhotonTracing>
                    struct PhotonTracing {
                        int m_photons;      //!< Number of indirect lighting photons to emit.
                        bool IsConsistent() const;
                    } m_photon_tracing;

                    //! <RadiancePrecomputation>
                    struct RadiancePrecomp {
                        bool m_enabled;                 //!< Precompute radiance estimates?
                        int m_spacing;                  //!< Spacing between precomputed samples.
                        sheep::Real m_max_search_dist;  //!< Maximum distance to search for a photon carrying a precomputed radiance estimate.
                        bool IsConsistent() const;
                    } m_radiance_precomp;

                    //! <RadianceEstimate>
                    struct RadianceEstimate : public RadianceEstimateSettings {
                    } m_radiance_est;

                    //! <PrimaryFinalGathering>
                    struct PrimaryFinalGathering : public SamplingSettings {
                        bool m_enabled;     //!< Is primary final gathering enabled?
                        bool IsConsistent() const;
                    } m_primary_fg;

                    //! <SecondaryFinalGathering>
                    struct SecondaryFinalGathering : public SamplingSettings {
                        bool m_enabled;                     //!< Is secondary final gathering enabled?
                        sheep::Real m_distance_threshold;   //!< Distance threshold under which a secondary final gathering is triggered.
                        bool IsConsistent() const;
                    } m_secondary_fg;

                    bool IsConsistent() const;
                } m_indirect_lighting;

                //! <SpecularReflections>
                struct SpecularReflections {
                    bool m_enabled;         //!< Include specular reflections?
                    int m_max_depth;        //!< Maximum recursion level.
                    bool IsConsistent() const;
                } m_specular_reflections;

                //! <Caustics>
                struct Caustics {
                    bool m_enabled;         //!< Include caustics?

                    //! <PhotonTracing>
                    struct PhotonTracing {
                        int m_photons;      //!< Number of caustics photons to emit.
                        bool IsConsistent() const;
                    } m_photon_tracing;

                    //! <RadianceEstimate>
                    struct RadianceEstimate : public RadianceEstimateSettings {
                    } m_radiance_est;

                    bool IsConsistent() const;
                } m_caustics;

                bool IsConsistent() const;
            } m_components;

            bool IsConsistent() const;
        } m_rendering;

        //! <Output>
        struct Output {
            //! <RenderArea>
            struct RenderArea {
                bool m_enabled;                 //!< Restrict render area? If disabled, render the whole image.
                int m_x0, m_y0, m_x1, m_y1;     //!< Render area bounds.
                bool IsConsistent() const;
            } m_render_area;

            //! <GammaCorrection>
            struct GammaCorrection {
                bool m_enabled;                 //!< Perform gamma correction?
                sheep::Real m_target_gamma;     //!< Target gamma.
                bool IsConsistent() const;
            } m_gamma_correction;

            bool IsConsistent() const;
        } m_output;

        bool IsConsistent() const;
    };

#include "settings.inl"

}

#endif  // !TOXIC_RENDERER_SETTINGS_H

---