SCOLLighting.cpp

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
 
-----------------------------------------------------------------------------
*/
 
 
#include "SCOLPack/SO3SCOL.h"
 
// Scene Graph includes
#include "SO3SceneGraph/SO3Scene.h"
 
 
// Pass Shadow Technique
# define SO3_SHADOWTYPE_NONE                                                                                0
# define SO3_SHADOWDETAILTYPE_ADDITIVE                                                              1
# define SO3_SHADOWDETAILTYPE_MODULATIVE                                                            2
# define SO3_SHADOWDETAILTYPE_INTEGRATED                                                            4
# define SO3_SHADOWDETAILTYPE_STENCIL                                                               16
# define SO3_SHADOWDETAILTYPE_TEXTURE                                                               32
# define SO3_SHADOWTYPE_STENCIL_MODULATIVE                                                  18
# define SO3_SHADOWTYPE_STENCIL_ADDITIVE                                                            17
# define SO3_SHADOWTYPE_TEXTURE_MODULATIVE                                                  34
# define SO3_SHADOWTYPE_TEXTURE_ADDITIVE                                                            33
# define SO3_SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED             37
# define SO3_SHADOWTYPE_TEXTURE_MODULATIVE_INTEGRATED           38
 
// Shadow Texture Camera Setup
# define SO3_DEFAULT_SHADOW_CAMERA                                                              0
# define SO3_FOCUSED_SHADOW_CAMERA                                                              1
# define SO3_PLANE_SHADOW_CAMERA                                                                  2
# define SO3_LISPSM_SHADOW_CAMERA                                                                 3
 
 
int SO3SceneSetShadowColor(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ShadowSetColor\n");
#endif
 
  int color = MTOI(MMpull(m));
  int s = MMget(m, 0);
  if ((s == NIL) || (color == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SShadowManager* currentShadow = scene->GetShadowManager();
  if (currentShadow)
    currentShadow->SetColour(color);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneGetShadowColor(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ShadowGetColor\n");
#endif
 
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int val = 0;
  SShadowManager* currentShadow = scene->GetShadowManager();
  if (currentShadow)
    val = currentShadow->GetColour();
 
  MMset(m, 0, ITOM(val));
  return 0;
}
 
 
int SO3SceneSetSelfShadowTexture(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ShadowSetSelfShadow\n");
#endif
 
  int state = MMpull(m);
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SShadowManager* currentShadow = scene->GetShadowManager();
  if (currentShadow)
    if (MTOI(state) == 1)
      currentShadow->SetSelfShadow(true);
    else
      currentShadow->SetSelfShadow(false);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneGetSelfShadowTexture(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ShadowGetSelfShadow\n");
#endif
 
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int val = 0;
  SShadowManager* currentShadow = scene->GetShadowManager();
  if (currentShadow)
    if (currentShadow->GetSelfShadow())
      val = 1;
 
  MMset(m, 0, ITOM(val));
  return 0;
}
 
 
int SO3SceneSetShadowTextureSize(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ShadowSetTextureSize\n");
#endif
 
  int val = MMpull(m);
  int s = MMget(m, 0);
  if ((s == NIL) || (val == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    SShadowManager* currentShadow = scene->GetShadowManager();
    if (currentShadow)
      currentShadow->SetTextureSize(MTOI(val));
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneGetShadowTextureSize(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ShadowGetTextureSize\n");
#endif
 
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SShadowManager* currentShadow = scene->GetShadowManager();
  if (currentShadow)
  {
    int val = currentShadow->GetTextureSize();
    MMset(m, 0, ITOM(val));
  }
  else
    MMset(m, 0, NIL);
 
  return 0;
}
 
 
int SO3SceneSetShadowPreset(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneSetShadowPreset\n");
#endif
 
  int val = MTOI(MMpull(m));
  int s = MMget(m, 0);
  if ((val == NIL) || (s == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  try
  {
    //disable stencil
    if (val == SShadowManager::SO3_SHADOWS_STENCIL)
      val = SShadowManager::SO3_SHADOWS_NONE;
 
    scene->SetShadowType(static_cast <SShadowManager::ShadowType> (val));
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneGetShadowPreset(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneGetShadowPreset\n");
#endif
 
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(scene->GetShadowType()));
  return 0;
}
 
 
int SO3SceneGetShadowLightingTechnique(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneGetShadowLightingTechnique\n");
#endif
 
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SShadowManager* currentShadow = scene->GetShadowManager();
  if (currentShadow)
    MMset(m, 0, ITOM(currentShadow->GetLightingTechnique()));
  else
    MMset(m, 0, NIL);
 
  return 0;
}
 
 
int SO3SceneSetShadowLightingTechnique(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneSetShadowLightingTechnique\n");
#endif
 
  int tec = MTOI(MMpull(m));
  int s = MMget(m, 0);
  if ((s == NIL) || (tec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SShadowManager* currentShadow = scene->GetShadowManager();
  if (currentShadow)
    currentShadow->SetLightingTechnique(static_cast <SShadowManager::ShadowLightingType> (tec));
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneSetShadowQuality(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneSetShadowQuality\n");
#endif
 
  int val = MTOI(MMpull(m));
  int s = MMget(m, 0);
  if ((val == NIL) || (s == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  try
  {
    scene->SetShadowQuality(static_cast <SShadowManager::ShadowQuality> (val));
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneGetShadowQuality(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneGetShadowQuality\n");
#endif
 
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(scene->GetShadowQuality()));
  return 0;
}
 
 
int SO3SceneSetShadowTextureCount(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneSetShadowTextureCount\n");
#endif
 
  int val = MTOI(MMpull(m));
  int s = MMget(m, 0);
  if ((s == NIL) || (val == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  try
  {
    scene->O3SceneManager->setShadowTextureCount(val);
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3SceneSetDefaultShadowCamera(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneSetDefaultShadowCamera\n");
#endif
 
  int s = MMget(m, 0);
  if ((s == NIL))
  {
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  scene->SetShadowType(SShadowManager::SO3_SHADOWS_NONE);
  
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneSetFocusedShadowCamera(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneSetFocusedShadowCamera\n");
#endif
 
  int s = MMget(m, 0);
  if ((s == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  try
  {
    scene->O3SceneManager->setShadowCameraSetup(Ogre::ShadowCameraSetupPtr(OGRE_NEW Ogre::FocusedShadowCameraSetup()));
    //scene->shadowCameraSetup = SO3_FOCUSED_SHADOW_CAMERA;
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneSetLISPSMShadowCamera(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneSetLISPSMShadowCamera\n");
#endif
 
  int s = MMget(m, 0);
  if ((s == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  try
  {
    scene->O3SceneManager->setShadowCameraSetup(Ogre::ShadowCameraSetupPtr(OGRE_NEW Ogre::LiSPSMShadowCameraSetup()));
    //scene->shadowCameraSetup = SO3_LISPSM_SHADOW_CAMERA;
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneSetPlaneShadowCamera(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneSetPlaneShadowCamera\n");
#endif
 
  int d = MMpull(m);
  int vec = MTOP(MMpull(m));
  int s = MMget(m, 0);
  if ((s == NIL) || (d == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  try
  {
    // TODO memory leak here?
    Ogre::MovablePlane* plane = OGRE_NEW Ogre::MovablePlane("PlaneShadowCamera");
    Ogre::Vector3 vecteur;
    if (vec == NIL)
    {
      vecteur.NEGATIVE_UNIT_Y;
    }
    else
    {
      vecteur.x = MTOF(MMfetch(m, vec, 0));
      vecteur.y = MTOF(MMfetch(m, vec, 1));
      vecteur.z = MTOF(MMfetch(m, vec, 2));
    }
    plane->d = MTOF(d);
    plane->normal = vecteur;
 
    //scene->O3SceneManager->setShadowCameraSetup(Ogre::ShadowCameraSetupPtr(OGRE_NEW Ogre::PlaneOptimalShadowCameraSetup(plane)));
    //scene->shadowCameraSetup = SO3_PLANE_SHADOW_CAMERA;
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneSetShadowDirectionalLightExtrusionDistance(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneSetShadowDirectionalLightExtrusionDistance\n");
#endif
 
  int val = MMpull(m);
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float extr = (val == NIL) ? 0.0f : MTOF(val);
 
  SShadowManager* currentShadow = scene->GetShadowManager();
  if (currentShadow)
    currentShadow->SetShadowDirectionalLightExtrusionDistance(extr);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneSetShadowFarDistance(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneSetShadowFarDistance\n");
#endif
 
  int val = MMpull(m);
  int s = MMget(m, 0);
  if ((s == NIL) || (val == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SShadowManager* currentShadow = scene->GetShadowManager();
  if (currentShadow)
    currentShadow->SetShadowFarDistance(MTOF(val));
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneSetShadowTextureFadeStart(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneSetShadowTextureFadeStart\n");
#endif
 
  int val = MMpull(m);
  int s = MMget(m, 0);
  if ((s == NIL) || (val == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SShadowManager* currentShadow = scene->GetShadowManager();
  if (currentShadow)
    currentShadow->SetShadowFadeStart(MTOF(val));
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneGetShadowTextureFadeStart(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneGetShadowTextureFadeStart\n");
#endif
 
  int s = MMget(m, 0);
  if ((s == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SShadowManager* currentShadow = scene->GetShadowManager();
  if (currentShadow)
    MMset(m, 0, FTOM(currentShadow->GetShadowFadeStart()));
  else
    MMset(m, 0, NIL);
 
  return 0;
}
 
 
int SO3SceneSetShadowTextureFadeEnd(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneSetShadowTextureFadeEnd\n");
#endif
 
  int val = MMpull(m);
  int s = MMget(m, 0);
  if ((s == NIL) || (val == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SShadowManager* currentShadow = scene->GetShadowManager();
  if (currentShadow)
    currentShadow->SetShadowFadeEnd(MTOF(val));
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneGetShadowTextureFadeEnd(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneGetShadowTextureFadeEnd\n");
#endif
 
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SShadowManager* currentShadow = scene->GetShadowManager();
  if (currentShadow)
    MMset(m, 0, FTOM(currentShadow->GetShadowFadeEnd()));
  else
    MMset(m, 0, NIL);
 
  return 0;
}
 
 
int SO3SceneGetShadowTechnique(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneGetShadowTechnique\n");
#endif
 
  int s = MMget(m, 0);
  if ((s == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  if (scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWTYPE_NONE)
    MMset(m, 0, ITOM(SO3_SHADOWTYPE_NONE));
  else if (scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWDETAILTYPE_ADDITIVE)
    MMset(m, 0, ITOM(SO3_SHADOWDETAILTYPE_ADDITIVE));
  else if (scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWDETAILTYPE_MODULATIVE)
    MMset(m, 0, ITOM(SO3_SHADOWDETAILTYPE_MODULATIVE));
  else if (scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWDETAILTYPE_STENCIL)
    MMset(m, 0, ITOM(SO3_SHADOWDETAILTYPE_STENCIL));
  else if (scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWDETAILTYPE_TEXTURE)
    MMset(m, 0, ITOM(SO3_SHADOWDETAILTYPE_TEXTURE));
  else if (scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWTYPE_STENCIL_MODULATIVE)
    MMset(m, 0, ITOM(SO3_SHADOWTYPE_STENCIL_MODULATIVE));
  else if (scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWTYPE_STENCIL_ADDITIVE)
    MMset(m, 0, ITOM(SO3_SHADOWTYPE_STENCIL_ADDITIVE));
  else if (scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWTYPE_TEXTURE_MODULATIVE)
    MMset(m, 0, ITOM(SO3_SHADOWTYPE_TEXTURE_MODULATIVE));
  else if (scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWTYPE_TEXTURE_ADDITIVE)
    MMset(m, 0, ITOM(SO3_SHADOWTYPE_TEXTURE_ADDITIVE));
  else if (scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED)
    MMset(m, 0, ITOM(SO3_SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED));
  else if (scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWDETAILTYPE_ADDITIVE)
    MMset(m, 0, ITOM(SO3_SHADOWDETAILTYPE_ADDITIVE));
  else if (scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWTYPE_TEXTURE_MODULATIVE_INTEGRATED)
    MMset(m, 0, ITOM(SO3_SHADOWTYPE_TEXTURE_MODULATIVE_INTEGRATED));
  else
    MMset(m, 0, NIL);
  return 0;
}
 
 
int SO3SceneSetShadowDirLightTextureOffset(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneSetShadowDirLightTextureOffset\n");
#endif
 
  int val = MMpull(m);
  int s = MMget(m, 0);
  if ((s == NIL) || (val == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  scene->O3SceneManager->setShadowDirLightTextureOffset(MTOF(val));
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneGetShadowCameraSetup(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneGetShadowCameraSetup\n");
#endif
 
  int s = MMget(m, 0);
  if ((s == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  int val = 0;//scene->shadowCameraSetup;
  MMset(m, 0, ITOM(val));
  return 0;
}
 
 
int SO3SceneGetShadowDirectionalLightExtrusionDistance(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneGetShadowDirectionalLightExtrusionDistance\n");
#endif
 
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SShadowManager* currentShadow = scene->GetShadowManager();
  if (currentShadow)
  {
    float val = currentShadow->GetShadowDirectionalLightExtrusionDistance();
    MMset(m, 0, FTOM(val));
  }
  else
  {
    MMset(m, 0, NIL);
  }
 
  return 0;
}
 
 
int SO3SceneGetShadowFarDistance(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneGetShadowFarDistance\n");
#endif
 
  int s = MMget(m, 0);
  if ((s == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SShadowManager* currentShadow = scene->GetShadowManager();
  if (currentShadow)
    MMset(m, 0, FTOM(currentShadow->GetShadowFarDistance()));
  else
    MMset(m, 0, NIL);
 
  return 0;
}
 
 
int SO3SceneGetShadowDirLightTextureOffset(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneGetShadowDirLightTextureOffset\n");
#endif
 
  int s = MMget(m, 0);
  if ((s == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  float val = scene->O3SceneManager->getShadowDirLightTextureOffset();
 
  MMset(m, 0, FTOM(val));
  return 0;
}
 
 
int SO3SceneGetShadowTextureCount(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneGetShadowTextureCount\n");
#endif
 
  int s = MMget(m, 0);
  if ((s == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  int val = (int)scene->O3SceneManager->getShadowTextureConfigList().size();
  MMset(m, 0, ITOM(val));
  return 0;
}
 
 
int SO3SceneSetShadowTechnique(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneSetShadowTechnique\n");
#endif
 
  int tec = MTOI(MMpull(m));
  int s = MMget(m, 0);
  if ((s == NIL) || (tec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
 
  //TODO TEST
  // To avoid Rendering Problem Disable the possibility to set Stencil Based Shadow when scene has Texture Unit States with content_type shadow
  /*
  if(((Ogre::ShadowTechnique)tec==SO3_SHADOWTYPE_STENCIL_ADDITIVE ||(Ogre::ShadowTechnique)tec==SO3_SHADOWTYPE_STENCIL_MODULATIVE||(Ogre::ShadowTechnique)tec==SO3_SHADOWTYPE_NONE))
  {
    Ogre::ResourceManager::ResourceMapIterator it = scene->O3MaterialManager->getResourceIterator();
    while(it.hasMoreElements())
    {
      Ogre::MaterialPtr curMat = it.getNext();
      for(int i=0;i<curMat->getNumTechniques();i++)
        for(int j=0;j<curMat->getTechnique(i)->getNumPasses();j++)
          for(int k=0;k<curMat->getTechnique(i)->getPass(j)->getNumTextureUnitStates();k++)
            if(curMat->getTechnique(i)->getPass(j)->getTextureUnitState(k)->getContentType()==Ogre::TextureUnitState::CONTENT_SHADOW)
            {
              curMat->getTechnique(i)->getPass(j)->removeTextureUnitState(k);
              Ogre::LogManager::getSingleton().logMessage("Reset material : " + curMat->getName() + " cause it used a shadow map texture integrated \n ", Ogre::LML_CRITICAL,true) ;
              curMat->_notifyNeedsRecompile();
            }
    }
  }*/
 
  //disable stencil
  if (((Ogre::ShadowTechnique)tec == SO3_SHADOWTYPE_STENCIL_ADDITIVE || (Ogre::ShadowTechnique)tec == SO3_SHADOWTYPE_STENCIL_MODULATIVE))
    tec = SO3_SHADOWTYPE_NONE;
 
  scene->O3SceneManager->setShadowTechnique((Ogre::ShadowTechnique)tec);
 
  /*if(((Ogre::ShadowTechnique)tec==SO3_SHADOWTYPE_STENCIL_ADDITIVE ||(Ogre::ShadowTechnique)tec==SO3_SHADOWTYPE_STENCIL_MODULATIVE||(Ogre::ShadowTechnique)tec==SO3_SHADOWTYPE_NONE))
    //TODO test opengl and set to FLOAT16
    scene->O3SceneManager->setShadowTexturePixelFormat(Ogre::PF_FLOAT32_R);
  else
    scene->O3SceneManager->setShadowTexturePixelFormat(Ogre::PF_X8R8G8B8);
  */
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneSetShadowCaster(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneSetShadowCaster\n");
#endif
 
  int c = MMpull(m);
  int s = MMget(m, 0);
  if ((s == NIL) || (c == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  try
  {
    Ogre::MaterialPtr mCaster;
    mCaster.reset();
    mCaster = scene->O3MaterialManager->getByName(MMstartstr(m, MTOP(c)));
    if (!mCaster)
    {
      MMset(m, 0, NIL);
      return 0;
    }
    scene->O3SceneManager->setShadowTextureCasterMaterial(mCaster);
    scene->materialCaster = mCaster;
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneSetShadowReceiver(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneSetShadowReceiver\n");
#endif
 
  int r = MMpull(m);
  int s = MMget(m, 0);
  if ((s == NIL) || (r == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  try
  {
    Ogre::MaterialPtr mReceiver;
    mReceiver.reset();
 
    mReceiver = scene->O3MaterialManager->getByName(MMstartstr(m, MTOP(r)));
    if (!mReceiver)
    {
      MMset(m, 0, NIL);
      return 0;
    }
    scene->O3SceneManager->setShadowTextureReceiverMaterial(mReceiver);
    scene->materialReceiver = mReceiver;
 
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3SceneGetShadowCaster(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneGetShadowCaster\n");
#endif
 
  int s = MMpull(m);
  if ((s == NIL))
  {
    MMpush(m, NIL);
    return 0;
  }
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  try
  {
    if (!scene->materialCaster)
    {
      MMpush(m, NIL);
      return 0;
    }
 
    return Mpushstrbloc(m, (char*)(scene->materialCaster->getName().c_str()));
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMpush(m, NIL);
    return 0;
  }
  return 0;
}
 
 
int SO3SceneGetShadowReceiver(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneGetShadowReceiver\n");
#endif
 
  int s = MMpull(m);
  if (s == NIL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  try
  {
    if (!scene->materialReceiver)
    {
      MMpush(m, NIL);
      return 0;
    }
    return Mpushstrbloc(m, (char*)(scene->materialReceiver->getName().c_str()));
 
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMpush(m, NIL);
    return 0;
  }
  return 0;
}
 
 
NativeDefinition natSO3Lighting[] = {
  { "SO3_SHADOWTYPE_NONE",                                   TYPVAR, "I",                           SCOL_TYPTYPE(SO3_SHADOWTYPE_NONE) },
  { "SO3_SHADOWDETAILTYPE_ADDITIVE",                         TYPVAR, "I",                           SCOL_TYPTYPE(SO3_SHADOWDETAILTYPE_ADDITIVE) },
  { "SO3_SHADOWDETAILTYPE_MODULATIVE",                       TYPVAR, "I",                           SCOL_TYPTYPE(SO3_SHADOWDETAILTYPE_MODULATIVE) },
  { "SO3_SHADOWDETAILTYPE_INTEGRATED",                       TYPVAR, "I",                           SCOL_TYPTYPE(SO3_SHADOWDETAILTYPE_INTEGRATED) },
  { "SO3_SHADOWDETAILTYPE_STENCIL",                          TYPVAR, "I",                           SCOL_TYPTYPE(SO3_SHADOWDETAILTYPE_STENCIL) },
  { "SO3_SHADOWDETAILTYPE_TEXTURE",                          TYPVAR, "I",                           SCOL_TYPTYPE(SO3_SHADOWDETAILTYPE_TEXTURE) },
  { "SO3_SHADOWTYPE_STENCIL_MODULATIVE",                     TYPVAR, "I",                           SCOL_TYPTYPE(SO3_SHADOWTYPE_STENCIL_MODULATIVE) },
  { "SO3_SHADOWTYPE_STENCIL_ADDITIVE",                       TYPVAR, "I",                           SCOL_TYPTYPE(SO3_SHADOWTYPE_STENCIL_ADDITIVE) },
  { "SO3_SHADOWTYPE_TEXTURE_MODULATIVE",                     TYPVAR, "I",                           SCOL_TYPTYPE(SO3_SHADOWTYPE_TEXTURE_MODULATIVE) },
  { "SO3_SHADOWTYPE_TEXTURE_ADDITIVE",                       TYPVAR, "I",                           SCOL_TYPTYPE(SO3_SHADOWTYPE_TEXTURE_ADDITIVE) },
  { "SO3_SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED",            TYPVAR, "I",                           SCOL_TYPTYPE(SO3_SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED) },
  { "SO3_SHADOWTYPE_TEXTURE_MODULATIVE_INTEGRATED",          TYPVAR, "I",                           SCOL_TYPTYPE(SO3_SHADOWTYPE_TEXTURE_MODULATIVE_INTEGRATED) },
  { "SO3_DEFAULT_SHADOW_CAMERA",                             TYPVAR, "I",                           SCOL_TYPTYPE(SO3_DEFAULT_SHADOW_CAMERA) },
  { "SO3_FOCUSED_SHADOW_CAMERA",                             TYPVAR, "I",                           SCOL_TYPTYPE(SO3_FOCUSED_SHADOW_CAMERA) },
  { "SO3_PLANE_SHADOW_CAMERA",                               TYPVAR, "I",                           SCOL_TYPTYPE(SO3_PLANE_SHADOW_CAMERA) },
  { "SO3_LISPSM_SHADOW_CAMERA",                              TYPVAR, "I",                           SCOL_TYPTYPE(SO3_LISPSM_SHADOW_CAMERA) },
  { "SO3_SHADOWS_PRESET_NONE",                               TYPVAR, "I",                           SCOL_TYPTYPE(SShadowManager::SO3_SHADOWS_NONE) },
  { "SO3_SHADOWS_PRESET_STENCIL",                            TYPVAR, "I",                           SCOL_TYPTYPE(SShadowManager::SO3_SHADOWS_STENCIL) },
  { "SO3_SHADOWS_PRESET_LISPSM",                             TYPVAR, "I",                           SCOL_TYPTYPE(SShadowManager::SO3_SHADOWS_LISPSM) },
  { "SO3_SHADOWS_PRESET_CSM",                                TYPVAR, "I",                           SCOL_TYPTYPE(SShadowManager::SO3_SHADOWS_CSM) },
  { "SO3_SHADOWS_PRESET_PSSM",                               TYPVAR, "I",                           SCOL_TYPTYPE(SShadowManager::SO3_SHADOWS_PSSM) },
  { "SO3_SHADOWS_PRESET_DEFERRED",                           TYPVAR, "I",                           SCOL_TYPTYPE(SShadowManager::SO3_SHADOWS_DEFERRED) },
  { "SO3_ADDITIVE_SHADOWS_PRESET_TECHNIQUE",                 TYPVAR, "I",                           SCOL_TYPTYPE(SShadowManager::SO3_ADDITIVE_SHADOWS_LIGHTING) },
  { "SO3_MODULATIVE_SHADOWS_PRESET_TECHNIQUE",               TYPVAR, "I",                           SCOL_TYPTYPE(SShadowManager::SO3_MODULATIVE_SHADOWS_LIGHTING) },
  { "SO3_SHADOWS_QUALITY_VERYLOW",                           TYPVAR, "I",                           SCOL_TYPTYPE(SShadowManager::SO3_SHADOWS_QUALITY_VERYLOW) },
  { "SO3_SHADOWS_QUALITY_LOW",                               TYPVAR, "I",                           SCOL_TYPTYPE(SShadowManager::SO3_SHADOWS_QUALITY_LOW) },
  { "SO3_SHADOWS_QUALITY_MEDIUM",                            TYPVAR, "I",                           SCOL_TYPTYPE(SShadowManager::SO3_SHADOWS_QUALITY_MEDIUM) },
  { "SO3_SHADOWS_QUALITY_HIGH",                              TYPVAR, "I",                           SCOL_TYPTYPE(SShadowManager::SO3_SHADOWS_QUALITY_HIGH) },
  { "SO3_SHADOWS_QUALITY_VERYHIGH",                          TYPVAR, "I",                           SCOL_TYPTYPE(SShadowManager::SO3_SHADOWS_QUALITY_VERYHIGH) },
  { "SO3SceneSetShadowColor",                                2,                 "fun [SO3_SCENE I] I",                           SO3SceneSetShadowColor },
  { "SO3SceneGetShadowColor",                                1,                 "fun [SO3_SCENE] I",                                     SO3SceneGetShadowColor },
  { "SO3SceneSetSelfShadowTexture",                          2,                 "fun [SO3_SCENE I] I",                           SO3SceneSetSelfShadowTexture },
  { "SO3SceneSetShadowTextureCount",                         2,                 "fun [SO3_SCENE I] I",                           SO3SceneSetShadowTextureCount },
  { "SO3SceneSetShadowTextureSize",                          2,                 "fun [SO3_SCENE I] I",                           SO3SceneSetShadowTextureSize },
  { "SO3SceneGetShadowTextureSize",                          1,      "fun [SO3_SCENE] I",                                        SO3SceneGetShadowTextureSize },
  { "SO3SceneSetDefaultShadowCamera",                        1,                 "fun [SO3_SCENE] I",                                     SO3SceneSetDefaultShadowCamera },
  { "SO3SceneSetFocusedShadowCamera",                        1,                 "fun [SO3_SCENE] I",                                     SO3SceneSetFocusedShadowCamera },
  { "SO3SceneSetLISPSMShadowCamera",                         1,                 "fun [SO3_SCENE] I",                                     SO3SceneSetLISPSMShadowCamera },
  { "SO3SceneSetPlaneShadowCamera",                          3,                 "fun [SO3_SCENE [F F F] F] I", SO3SceneSetPlaneShadowCamera },
  { "SO3SceneSetShadowDirectionalLightExtrusionDistance",    2,                 "fun [SO3_SCENE F] I",                           SO3SceneSetShadowDirectionalLightExtrusionDistance },
  { "SO3SceneSetShadowFarDistance",                          2,                 "fun [SO3_SCENE F] I",                           SO3SceneSetShadowFarDistance },
  { "SO3SceneSetShadowTextureFadeStart",                     2,                 "fun [SO3_SCENE F] I",                           SO3SceneSetShadowTextureFadeStart },
  { "SO3SceneGetShadowTextureFadeStart",                     1,                 "fun [SO3_SCENE] F",                             SO3SceneGetShadowTextureFadeStart },
  { "SO3SceneGetShadowTechnique",                            1,                 "fun [SO3_SCENE] I",                                     SO3SceneGetShadowTechnique },
  { "SO3SceneSetShadowTextureFadeEnd",                       2,                 "fun [SO3_SCENE F] I",                           SO3SceneSetShadowTextureFadeEnd },
  { "SO3SceneGetShadowTextureFadeEnd",                       1,                 "fun [SO3_SCENE] F",                             SO3SceneGetShadowTextureFadeEnd },
  { "SO3SceneSetShadowDirLightTextureOffset",                2,                 "fun [SO3_SCENE F] I",                           SO3SceneSetShadowDirLightTextureOffset },
  { "SO3SceneGetSelfShadowTexture",                          1,                 "fun [SO3_SCENE] I",                                     SO3SceneGetSelfShadowTexture },
  { "SO3SceneGetShadowCameraSetup",                          1,                 "fun [SO3_SCENE] I",                                     SO3SceneGetShadowCameraSetup },
  { "SO3SceneGetShadowDirectionalLightExtrusionDistance",    1,                 "fun [SO3_SCENE] F",                                     SO3SceneGetShadowDirectionalLightExtrusionDistance },
  { "SO3SceneGetShadowFarDistance",                          1,                 "fun [SO3_SCENE] F",                                     SO3SceneGetShadowFarDistance },
  { "SO3SceneGetShadowDirLightTextureOffset",                1,                 "fun [SO3_SCENE] F",                                     SO3SceneGetShadowDirLightTextureOffset },
  { "SO3SceneGetShadowTextureCount",                         1,                 "fun [SO3_SCENE] I",                                     SO3SceneGetShadowTextureCount },
  { "SO3SceneSetShadowTechnique",                            2,                 "fun [SO3_SCENE I] I",                           SO3SceneSetShadowTechnique },
  { "SO3SceneSetShadowCaster",                               2,                 "fun [SO3_SCENE S] I",                           SO3SceneSetShadowCaster },
  { "SO3SceneSetShadowReceiver",                             2,                 "fun [SO3_SCENE S] I",                           SO3SceneSetShadowReceiver },
  { "SO3SceneGetShadowCaster",                               1,                 "fun [SO3_SCENE] S",                                     SO3SceneGetShadowCaster },
  { "SO3SceneGetShadowReceiver",                             1,      "fun [SO3_SCENE] S",                                        SO3SceneGetShadowReceiver },
  { "SO3SceneGetShadowPreset",                               1,      "fun [SO3_SCENE] I",                SO3SceneGetShadowPreset },
  { "SO3SceneSetShadowPreset",                               2,      "fun [SO3_SCENE I] I",            SO3SceneSetShadowPreset },
  { "SO3SceneGetShadowLightingTechnique",                    1,      "fun [SO3_SCENE] I",                SO3SceneGetShadowLightingTechnique },
  { "SO3SceneSetShadowLightingTechnique",                    2,      "fun [SO3_SCENE I] I",         SO3SceneSetShadowLightingTechnique },
  { "SO3SceneGetShadowQuality",                              1,      "fun [SO3_SCENE] I",                SO3SceneGetShadowQuality },
  { "SO3SceneSetShadowQuality",                              2,      "fun [SO3_SCENE I] I",         SO3SceneSetShadowQuality }
};
 
 
int SCOLloadLighting(mmachine m, cbmachine w)
{
  return PKhardpak2(m, "SO3Lighting.pkg", sizeof(natSO3Lighting) / sizeof(natSO3Lighting[0]), natSO3Lighting);
}
 
 
int SCOLfreeLighting()
{
  return 0;
}