SO3Pass.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser 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 Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser 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, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#ifndef __SO3PASS_H__
#define __SO3PASS_H__
 
#include "SCOLBasic/SO3Prerequisites.h"
#include "SCOLBasic/SO3DataScol.h"
#include "SO3Material/SO3ShaderGenerator.h"
 
namespace SO3
{
 
class _SO3_Export SPass : public SData
{
public:
  enum PolygonMode
  {
    SO3_POLYGONMODE_POINTS = 1,
    SO3_POLYGONMODE_WIREFRAME = 2,
    SO3_POLYGONMODE_SOLID = 3
  };
  enum SceneBlendOperation
  {
    SO3_SCENE_BLEND_OPERATION_ADD,
    SO3_SCENE_BLEND_OPERATION_SUBTRACT,
    SO3_SCENE_BLEND_OPERATION_REVERSE_SUBTRACT,
    SO3_SCENE_BLEND_OPERATION_MIN,
    SO3_SCENE_BLEND_OPERATION_MAX
  };
  enum SceneBlendFactor
  {
    SO3_SCENE_BLEND_FACTOR_ONE,
    SO3_SCENE_BLEND_FACTOR_ZERO,
    SO3_SCENE_BLEND_FACTOR_DEST_COLOUR,
    SO3_SCENE_BLEND_FACTOR_SOURCE_COLOUR,
    SO3_SCENE_BLEND_FACTOR_ONE_MINUS_DEST_COLOUR,
    SO3_SCENE_BLEND_FACTOR_ONE_MINUS_SOURCE_COLOUR,
    SO3_SCENE_BLEND_FACTOR_DEST_ALPHA,
    SO3_SCENE_BLEND_FACTOR_SOURCE_ALPHA,
    SO3_SCENE_BLEND_FACTOR_ONE_MINUS_DEST_ALPHA,
    SO3_SCENE_BLEND_FACTOR_ONE_MINUS_SOURCE_ALPHA
  };
  enum CompareFunction
  {
    SO3_COMPARE_FUNCTION_ALWAYS_FAIL,
    SO3_COMPARE_FUNCTION_ALWAYS_PASS,
    SO3_COMPARE_FUNCTION_LESS,
    SO3_COMPARE_FUNCTION_LESS_EQUAL,
    SO3_COMPARE_FUNCTION_EQUAL,
    SO3_COMPARE_FUNCTION_NOT_EQUAL,
    SO3_COMPARE_FUNCTION_GREATER_EQUAL,
    SO3_COMPARE_FUNCTION_GREATER
  };
protected:
        Ogre::Pass* ogrePass;
  STechnique* parentTechnique;
  bool mGeneratedShader;
  float mPointSize;
private:
 
public:
  SPass(STechnique* technique, Ogre::Pass* ogrePassRef);
  
  ~SPass();
  
  static std::string GetTextureUnitTypedName(Ogre::TextureUnitState* unit);
 
  static SShaderGenerator::ShaderMapType GetTextureUnitType(Ogre::TextureUnitState* unit);
 
  STechnique* GetTechnique();
 
  Ogre::Pass* GetOgrePassPointer();
 
  int GetNumTextureUnitStates();
 
  std::string GetTextureUnitName(const unsigned int& textureUnit);
 
  int GetTextureUnitIndexByName(const std::string& texname);
 
  std::string GetTextureName(const unsigned int& textureUnit);
 
  std::string GetTextureFileName(const unsigned int& textureUnit);
 
  void SetTextureUScroll(const unsigned int& textureUnit, const float& value);
        
  float GetTextureUScroll(const unsigned int& textureUnit);
 
  void SetTextureVScroll(const unsigned int& textureUnit, const float& value);
 
  float GetTextureVScroll(const unsigned int& textureUnit);
 
  void SetTextureUScale(const unsigned int& textureUnit, const float& value);
 
  float GetTextureUScale(const unsigned int& textureUnit);
 
  void SetTextureVScale(const unsigned int& textureUnit, const float& value);
 
  float GetTextureVScale(const unsigned int& textureUnit);
 
  void SetTextureRotate(const unsigned int& textureUnit, const float& radianAngle);
 
  const float GetTextureRotate(const unsigned int& textureUnit);
 
  void SetTextureScrollAnimation(const unsigned int& textureUnit, const float& uSpeed, const float& vSpeed);
        
  void SetTextureRotateAnimation(const unsigned int& textureUnit, const float& speed);
 
  bool GetLightingEnabled();
 
  void SetLightingEnabled(const bool& state);
 
  void SetAmbientColor(const int& color);
  void SetAmbientColor(Ogre::ColourValue color);
 
  int GetAmbientColor();
 
  void SetDiffuseColor(const int& color);
  void SetDiffuseColor(Ogre::ColourValue color);
 
  int GetDiffuseColor();
 
  void SetSpecularColor(const int& color);
  void SetSpecularColor(Ogre::ColourValue color);
 
  int GetSpecularColor();
 
  void SetSelfIlluminationColor(const int& color);
  void SetSelfIlluminationColor(Ogre::ColourValue color);
 
  int GetSelfIlluminationColor();
 
  void SetShininess(const float& value);
 
  float GetShininess();
  
  void SetUseVertexColor(bool state);
 
  bool GetUseVertexColor();
 
  void SetTexture(const unsigned int& textureUnit, STexture* texture, std::string name = "");
 
  STexture* GetTexture(const unsigned int& textureUnit);
 
  int GetTextureUnitByType(SShaderGenerator::ShaderMapType type);
 
  const Ogre::GpuNamedConstants GetVertexProgramParameters();
 
  void SetVertexProgramAutoParameter(const std::string& paramName, const Ogre::GpuProgramParameters::AutoConstantType& paramType, const size_t& paramExtraInfos);
 
  void SetVertexProgramParameter(const std::string& paramName, const std::string& value);
 
  const Ogre::GpuNamedConstants GetFragmentProgramParameters();
 
  void SetFragmentProgramAutoParameter(const std::string& paramName, const Ogre::GpuProgramParameters::AutoConstantType& paramType, const size_t& paramExtraInfos);
 
  void SetFragmentProgramParameter(const std::string& paramName, const std::string& value);
 
  SceneBlendFactor GetSourceBlendFactor() const;
        
  SceneBlendFactor GetDestBlendFactor() const;
 
  SceneBlendFactor GetSourceBlendFactorAlpha() const;
        
  SceneBlendFactor GetDestBlendFactorAlpha() const;
 
  void SetSceneBlending(const SPass::SceneBlendFactor sourceFactor, const SPass::SceneBlendFactor destFactor);
 
  void SetSceneBlending(const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor, const SceneBlendFactor sourceFactorAlpha, const SceneBlendFactor destFactorAlpha);
 
  SceneBlendOperation GetSceneBlendingOperation() const;
 
  SceneBlendOperation GetSceneBlendingOperationAlpha() const;
 
  void SetSceneBlendingOperation(SceneBlendOperation op, SceneBlendOperation alphaOp);
 
  void SetDepthCheckEnabled(bool enabled);
        
  bool GetDepthCheckEnabled() const;
        
  void SetDepthWriteEnabled(bool enabled);
        
  bool GetDepthWriteEnabled() const;
        
  void SetDepthFunction(CompareFunction func);
 
  CompareFunction GetDepthFunction() const;
 
  void SetAlphaRejection(CompareFunction func, unsigned char value, bool alphaToCoverageEnabled=false);
 
  CompareFunction GetAlphaRejectionFunction() const;
 
        unsigned char GetAlphaRejectionValue() const;
        
  bool GetAlphaToCoverage() const;
 
  void SetColourWriteEnabled(bool state);
 
  bool GetColourWriteEnabled() const;
 
  void SetCullingMode(const bool state);
 
  bool GetCullingMode() const;
  
  void SetPointSize(Ogre::Real size);
 
  float GetPointSize();
 
  bool IsPointCloud();
 
  void SetPolygonMode(PolygonMode mode);
 
  PolygonMode GetPolygonMode();
 
  bool IsShaderGenerated();
 
  void CleanGeneratedShader();
 
  void BuildShader(bool force = false);
 
  void SetTextureUnitColorBlendModeFactor(const unsigned int& textureUnit, float factor);
 
  float GetTextureUnitColorBlendModeFactor(const unsigned int& textureUnit);
 
  void RemoveTexture(const unsigned int& textureUnit);
 
  void SetTextureByType(STexture* tex, SShaderGenerator::ShaderMapType type);
 
  std::string GetTextureUnitNameByType(SShaderGenerator::ShaderMapType type);
 
  void UpdateGeneratedPass(bool full = false);
 
  void OrderTexturesUnitsByType();
 
protected:
private:
  SPass();
 
  Ogre::TextureUnitState* GetTextureUnitState(const unsigned int& textureUnit);
 
};
 
}
 
#endif