material.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2004-2015 Steve Baker <sjbaker1@airmail.net>
//  Copyright (C) 2010-2015 Steve Baker, Joerg Henrichs
//
//  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 3
//  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
#ifndef HEADER_MATERIAL_HPP
#define HEADER_MATERIAL_HPP
 
#include "utils/no_copy.hpp"
#include "utils/random_generator.hpp"
 
#include <array>
#include <assert.h>
#include <functional>
#include <map>
#include <string>
#include <vector>
 
namespace irr
{
    namespace video { class ITexture; class IImage; class SMaterial; }
    namespace scene { class ISceneNode; class IMeshBuffer; }
}
using namespace irr;
 
class XMLNode;
class SFXBase;
class ParticleKind;
 
class Material : public NoCopy
{
public:
    enum ParticleConditions
    {
        EMIT_ON_DRIVE = 0,
        EMIT_ON_SKID,
 
        EMIT_KINDS_COUNT
    };
 
    enum CollisionReaction
    {
        NORMAL,
        RESCUE,
        PUSH_BACK,
        PUSH_SOCCER_BALL
    };
 
private:
 
    video::ITexture *m_texture;
 
    std::array<video::ITexture*, 4> m_vk_textures;
 
    std::string      m_texname;
 
    std::string      m_full_path;
 
    std::string      m_sfx_name;
 
    char             m_mirror_axis_when_reverse;
 
    bool             m_below_surface;
 
    bool             m_falling_effect;
    bool             m_surface;
 
    bool             m_zipper;
 
    bool             m_drive_reset;
 
    bool             m_is_jump_texture;
 
    bool             m_has_gravity;
 
    bool             m_ignore;
 
    bool             m_high_tire_adhesion;
 
    bool  m_complain_if_not_found;
 
    bool  m_deprecated;
 
    bool  m_installed;
 
    bool             m_colorizable;
 
    bool             m_tex_compression;
 
    float            m_colorization_factor;
 
    CollisionReaction m_collision_reaction;
 
    std::string      m_collision_particles;
 
    std::map<void*, bool> m_mirrorred_mesh_buffers;
 
    ParticleKind*    m_particles_effects[EMIT_KINDS_COUNT];
 
    unsigned int     m_clamp_tex;
 
    std::vector<float> m_hue_settings;
 
    RandomGenerator m_random_hue;
 
    int              m_slowdown_ticks;
 
    float            m_max_speed_fraction;
 
    float            m_zipper_min_speed;
    float            m_sfx_min_speed;
    float            m_sfx_max_speed;
    float            m_sfx_min_pitch;
    float            m_sfx_max_pitch;
    float            m_sfx_pitch_per_speed;
    float            m_zipper_max_speed_increase;
    float            m_zipper_duration;
    float            m_zipper_speed_gain;
    float            m_zipper_fade_out_time;
    float            m_zipper_engine_force;
    
    std::string      m_mask;
 
    std::string      m_colorization_mask;
 
    void  init    ();
    void  install (std::function<void(video::IImage*)> image_mani = nullptr,
                   video::SMaterial* m = NULL);
    void  initCustomSFX(const XMLNode *sfx);
    void  initParticlesEffect(const XMLNode *node);
 
    // SP usage
    std::string      m_shader_name;
    std::string      m_uv_two_tex;
    // Full path for textures in sp shader
    std::array<std::string, 6> m_sampler_path;
    std::string      m_container_id;
    void loadContainerId();
 
public:
          Material(const XMLNode *node, bool deprecated);
          Material(const std::string& fname,
                   bool is_full_path=false,
                   bool complain_if_not_found=true,
                   bool load_texture = true,
                   const std::string& shader_name = "solid");
         ~Material ();
 
    void unloadTexture();
 
    void  setSFXSpeed(SFXBase *sfx, float speed, bool should_be_paused) const;
    void  setMaterialProperties(video::SMaterial *m, scene::IMeshBuffer* mb);
 
    video::ITexture *getTexture(bool srgb = true, bool premul_alpha = false);
    // ------------------------------------------------------------------------
    bool  isIgnore           () const { return m_ignore;             }
    // ------------------------------------------------------------------------
    bool  isZipper           () const { return m_zipper;             }
    // ------------------------------------------------------------------------
    bool  isDriveReset       () const { return m_drive_reset;        }
    // ------------------------------------------------------------------------
    bool  isColorizable      () const { return m_colorizable;        }
    // ------------------------------------------------------------------------
    float getColorizationFactor () const { return m_colorization_factor;   }
    // ------------------------------------------------------------------------
    bool hasRandomHue() const            { return !m_hue_settings.empty(); }
    // ------------------------------------------------------------------------
    float getRandomHue()
    {
        if (m_hue_settings.empty())
            return 0.0f;
        const unsigned int hue = m_random_hue.get((int)m_hue_settings.size());
        assert(hue < m_hue_settings.size());
        return m_hue_settings[hue];
    }
    // ------------------------------------------------------------------------
    CollisionReaction  getCollisionReaction() const { return m_collision_reaction; }
 
    // ------------------------------------------------------------------------
    std::string getCrashResetParticles() const { return m_collision_particles; }
 
    // ------------------------------------------------------------------------
    bool  highTireAdhesion   () const { return m_high_tire_adhesion; }
    // ------------------------------------------------------------------------
    const std::string&
          getTexFname        () const { return m_texname;            }
    // ------------------------------------------------------------------------
    const std::string&
          getTexFullPath     () const { return m_full_path;          }
 
    // ------------------------------------------------------------------------
    bool  isTransparent      () const
    {
        return m_shader_name == "additive" || m_shader_name == "alphablend" ||
               m_shader_name == "displace";
    }
 
    // ------------------------------------------------------------------------
    bool  useAlphaChannel    () const
    {
        return isTransparent() || m_shader_name == "alphatest" ||
               m_shader_name == "unlit" || m_shader_name == "grass";
    }
 
    // ------------------------------------------------------------------------
    float getMaxSpeedFraction() const { return m_max_speed_fraction; }
    // ------------------------------------------------------------------------
    int getSlowDownTicks() const { return m_slowdown_ticks;          }
    // ------------------------------------------------------------------------
    bool isBelowSurface      () const { return m_below_surface; }
    // ------------------------------------------------------------------------
    bool isSurface          () const { return m_surface; }
    // ------------------------------------------------------------------------
    const std::string &getSFXName() const { return m_sfx_name; }
    // ------------------------------------------------------------------------
    const ParticleKind* getParticlesWhen(ParticleConditions cond) const
    {
        return m_particles_effects[cond]; 
    }   // getParticlesWhen
    // ------------------------------------------------------------------------
    bool hasFallingEffect() const {return m_falling_effect; }
    // ------------------------------------------------------------------------
    bool isJumpTexture() const { return m_is_jump_texture; }
    // ------------------------------------------------------------------------
    bool hasGravity() const { return m_has_gravity; }
    // ------------------------------------------------------------------------
    void getZipperParameter(float *zipper_max_speed_increase,
                             float *zipper_duration,
                             float *zipper_speed_gain,
                             float *zipper_fade_out_time,
                             float *zipper_engine_force) const
    {
        *zipper_max_speed_increase = m_zipper_max_speed_increase;
        *zipper_duration           = m_zipper_duration;
        *zipper_speed_gain         = m_zipper_speed_gain;
        *zipper_fade_out_time      = m_zipper_fade_out_time;
        *zipper_engine_force       = m_zipper_engine_force;
    }   // getZipperParameter
    // ------------------------------------------------------------------------
    float getZipperMinSpeed() const { return m_zipper_min_speed; }
    // ------------------------------------------------------------------------
    char getMirrorAxisInReverse() const { return m_mirror_axis_when_reverse; }
    // ------------------------------------------------------------------------
    const std::string& getAlphaMask() const                 { return m_mask; }
    // ------------------------------------------------------------------------
    const std::string& getColorizationMask() const
                                               { return m_colorization_mask; }
    // ------------------------------------------------------------------------
    void setShaderName(const std::string& name)      { m_shader_name = name; }
    // ------------------------------------------------------------------------
    const std::string& getShaderName() const         { return m_shader_name; }
    // ------------------------------------------------------------------------
    /* This is used for finding correct material for spm*/
    const std::string& getUVTwoTexture() const
                                                      { return m_uv_two_tex; }
    // ------------------------------------------------------------------------
    bool use2UV() const                      { return !m_uv_two_tex.empty(); }
    // ------------------------------------------------------------------------
    const std::string& getSamplerPath(unsigned layer) const
    {
        assert(layer < 6);
        return m_sampler_path[layer];
    }
    // ------------------------------------------------------------------------
    /* Return the container id used by texture compression to cache texture in
     * cache folder with unique name, if no texture compression is used for
     * this material, then it will always return empty. */
    const std::string& getContainerId() const
    {
        static std::string empty;
        if (!m_tex_compression)
            return empty;
        return m_container_id;
    }
    // ------------------------------------------------------------------------
    std::function<void(irr::video::IImage*)> getMaskImageMani() const;
};
 
 
#endif
 
/* EOF */