SCOLLight.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/SO3Light.h"
#include "SO3SceneGraph/SO3Scene.h"
 
int SO3LightCreate(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightCreate\n");
#endif
 
  int name = 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;
  }
 
  // Create Node
  std::string tmpLightName(MMstartstr(m,MTOP(name)));
  SLight* light = 0;
 
  try
        {
    light = scene->CreateLight(tmpLightName);
  }
        catch(Ogre::Exception &e)
        { 
                MMechostr(MSKDEBUG,"An exception has occurred : %s\n",e.what());
                MMset(m, 0, NIL);               
                return 0;       
        }
 
  // remove last param
  MMpull(m);
  return createObject(m, light, scene);
}
 
 
int SO3LightSetType(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightSetType\n");
#endif
 
  int type = MMpull(m);
  int l = MMget(m, 0);
  if ((type==NIL)||(l==NIL))
  {
    MMechostr(MSKDEBUG, "l==NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
  
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  light->SetType(static_cast <SLight::LightType> (MTOI(type)));
 
  MMset(m, 0, ITOM(1));
 
  return 0;
}
 
 
int SO3LightGetType(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightGetType\n");
#endif
 
  int l = MMget(m, 0);
  if(l==NIL)
  {
    MMechostr(MSKDEBUG, "l==NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  int type = static_cast <int> (light->GetType());
  MMset(m, 0, ITOM(type));
  return 0;
}
 
 
int SO3LightSetDiffuseColor(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightSetDiffuseColor\n");
#endif
 
  int diffuse = MMpull(m);
  int l = MMget(m, 0);
  if ((l==NIL)||(diffuse==NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  light->SetDiffuseColour(MTOI(diffuse));
  MMset(m, 0, ITOM(1));
 
  return 0;
}
 
int SO3LightGetDiffuseColor(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightGetDiffuseColor\n");
#endif
 
  int l = MMget(m, 0);
  if (l==NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
  int val = light->GetDiffuseColour();
  MMset(m, 0, ITOM(val));
  return 0;
}
 
 
int SO3LightSetPowerScale(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightSetPowerScale\n");
#endif
 
  int pow = MMpull(m);
  int l = MMget(m, 0);
  if ((l==NIL)||(pow==NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  light->SetPowerScale(MTOF(pow));
  MMset(m, 0, ITOM(1));
 
  return 0;
}
 
 
int SO3LightSetShadowFarDistance(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightSetShadowFarDistance\n");
#endif
 
  int d = MMpull(m);
  int l = MMget(m, 0);
  if ((l==NIL)||(d==NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  light->SetShadowFarDistance(MTOF(d));
  MMset(m, 0, ITOM(1));
 
  return 0;
}
 
 
int SO3LightGetPowerScale(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightGetPowerScale\n");
#endif
 
  int l = MMget(m, 0);
  if (l==NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  float pow = light->GetPowerScale();
  MMset(m, 0, FTOM(pow));
 
  return 0;
}
 
 
int SO3LightGetShadowFarDistance(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightGetShadowFarDistance\n");
#endif
 
  int l = MMget(m, 0);
  if (l==NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  float d = light->GetShadowFarDistance();
  MMset(m, 0, FTOM(d));
 
  return 0;
}
 
 
int SO3LightSetVisible(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightSetVisible\n");
#endif
 
  int v = MTOI(MMpull(m));
  int l = MMget(m, 0);
  if (l==NIL)
  {
    MMset(m, 0, 0);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  if (v==0)
    light->SetVisible(false);
  else
    light->SetVisible(true);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3LightGetVisible(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightGetVisible\n");
#endif
 
  int l = MMget(m, 0);
  if (l==NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  int val = 0;
 
  if (light->GetVisible())
    val = 1;
 
  MMset(m, 0, ITOM(val));
 
  return 0;
}
 
 
int SO3LightSetVolumetric(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightSetVolumetric\n");
#endif
 
  int v = MTOI(MMpull(m));
  int l = MMget(m, 0);
  if (l==NIL)
  {
    MMset(m, 0, 0);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  if (v==0)
    light->SetVolumetric(false);
  else
    light->SetVolumetric(true);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3LightGetVolumetric(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightGetVolumetric\n");
#endif
 
  int l = MMget(m, 0);
  if (l==NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  int val = 0;
 
  if (light->GetVolumetric())
    val = 1;
 
  MMset(m, 0, ITOM(val));
 
  return 0;
}
 
 
int SO3LightSetAttenuation(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightSetAttenuation\n");
#endif
 
  int param = MMpull(m);
  int l = MMget(m, 0);
  if ((l==NIL)||(param==NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  light->SetAttenuation(MTOF(MMfetch(m, MTOI(param), 0)),
                        MTOF(MMfetch(m, MTOI(param), 1)),
                        MTOF(MMfetch(m, MTOI(param), 2)),
                        MTOF(MMfetch(m, MTOI(param), 3)));
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3LightSetAttenuationAuto(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightSetAttenuationAuto\n");
#endif
 
  int irange = MMpull(m);
  int l = MMget(m, 0);
  if ((irange == NIL) || (l == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
  light->SetAttenuation(MTOF(irange));
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
 
int SO3LightGetAttenuation(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightGetAttenuation\n");
#endif
 
  int l = MMget(m, 0);
  if (l==NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  Ogre::Vector4 attenuation = light->GetAttenuation();
 
  int tuple = MMmalloc(m, 4, TYPETAB);
  if (tuple==NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM(attenuation.x));
  MMstore(m, tuple, 1, FTOM(attenuation.y));
  MMstore(m, tuple, 2, FTOM(attenuation.z));
  MMstore(m, tuple, 3, FTOM(attenuation.w));
  MMset(m, 0, PTOM(tuple));
 
  return 0;
}
 
 
int SO3LightSetSpecularColor(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightSetSpecularColor\n");
#endif
 
  int specular = MMpull(m);
  int l = MMget(m, 0);
  if ((l==NIL)||(specular==NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  light->SetSpecularColour(MTOI(specular));
 
  MMset(m, 0, ITOM(1));
 
  return 0;
}
 
 
int SO3LightGetSpecularColor(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightGetSpecularColor\n");
#endif
 
  int l = MMget(m, 0);
  if (l==NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  int val = light->GetSpecularColour();
  MMset(m, 0, ITOM(val));
 
  return 0;
}
 
 
int SO3LightSetSpotFallOff(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightSetSpotFallOff\n");
#endif
 
  int fal = MMpull(m);
  int l = MMget(m, 0);
  if ((l==NIL)||(fal==NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
  
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  light->SetSpotlightFalloff(MTOF(fal));
  MMset(m, 0, ITOM(1));
 
  return 0;
}
 
 
int SO3LightGetSpotFallOff(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightGetSpotFallOff\n");
#endif
 
  int l = MMget(m, 0);
  if (l==NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  float f = light->GetSpotlightFalloff();
  MMset(m, 0, FTOM(f));
 
  return 0;
}
 
 
int SO3LightSetSpotInnerAngle(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightSetSpotInnerAngle\n");
#endif
 
  int ang = MMpull(m);
  int l = MMget(m, 0);
  if ((l==NIL)||(ang==NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  light->SetSpotlightInnerAngle(MTOF(ang));
 
  MMset(m, 0, ITOM(1));
 
  return 0;
}
 
 
int SO3LightSetSpotOuterAngle(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightSetSpotOuterAngle\n");
#endif
 
  int ang = MMpull(m);
  int l = MMget(m, 0);
  if ((l==NIL)||(ang==NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  light->SetSpotlightOuterAngle(MTOF(ang));
 
  MMset(m, 0, ITOM(1));
 
  return 0;
}
 
 
int SO3LightSetSpotRange(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightSetSpotRange\n");
#endif
 
  int param = MMpull(m);
  int l = MMget(m, 0);
  if ((l==NIL)||(param==NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
  
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  if((MMfetch(m,MTOP(param),0)==NIL) || (MMfetch(m,MTOP(param),1)==NIL) || (MMfetch(m,MTOP(param),2)==NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
  
  light->SetSpotlightInnerAngle(MTOF(MMfetch(m, MTOP(param), 0)));
  light->SetSpotlightOuterAngle(MTOF(MMfetch(m, MTOP(param), 1)));
  light->SetSpotlightFalloff(MTOF(MMfetch(m, MTOP(param), 2)));
 
  MMset(m, 0, ITOM(1));
 
  return 0;
}
 
 
int SO3LightGetSpotInnerAngle(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightGetSpotInnerAngle\n");
#endif
 
  int l = MMget(m, 0);
  if (l==NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  float inner = light->GetSpotlightInnerAngle();
  MMset(m, 0, FTOM(inner));
 
  return 0;
}
 
 
int SO3LightGetSpotOuterAngle(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightGetSpotOuterAngle\n");
#endif
 
  int l = MMget(m, 0);
  if (l==NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
 
  float f = light->GetSpotlightOuterAngle();
  MMset(m, 0, FTOM(f));
 
  return 0;
}
 
 
int SO3LightSetSourceSize(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightSetSourceSize\n");
#endif
 
  int param = MMpull(m);
  int l = MMget(m, 0);
  if ((l == NIL) || (param == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
  if (node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
  if ((MMfetch(m, MTOP(param), 0) == NIL) || (MMfetch(m, MTOP(param), 1) == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  light->SetSourceSize(MTOF(MMfetch(m, MTOP(param), 0)), MTOF(MMfetch(m, MTOP(param), 1)));
  MMset(m, 0, ITOM(1));
 
  return 0;
}
 
 
int SO3LightGetSourceSize(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3LightGetSourceSize\n");
#endif
 
  int l = MMget(m, 0);
  if (l == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
  if (node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SLight* light = static_cast<SLight*>(node);
  Ogre::Vector2f src = light->GetSourceSize();
 
  int tuple = MMmalloc(m, 2, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM(src.x));
  MMstore(m, tuple, 1, FTOM(src.y));
  MMset(m, 0, PTOM(tuple));
 
  return 0;
}
 
 
NativeDefinition natSO3Light[] = {
  { "SO3LightCreate",               2, "fun [SO3_SCENE S] SO3_OBJECT", SO3LightCreate               },
  { "SO3LightSetType",              2, "fun [SO3_OBJECT I] I",         SO3LightSetType              },
  { "SO3LightGetType",              1, "fun [SO3_OBJECT] I",           SO3LightGetType              },
  { "SO3LightSetDiffuseColor",      2, "fun [SO3_OBJECT I] I",         SO3LightSetDiffuseColor      },
  { "SO3LightGetDiffuseColor",      1, "fun [SO3_OBJECT] I",           SO3LightGetDiffuseColor      },
  { "SO3LightSetPowerScale",        2, "fun [SO3_OBJECT F] I",         SO3LightSetPowerScale        },
  { "SO3LightSetShadowFarDistance", 2, "fun [SO3_OBJECT F] I",         SO3LightSetShadowFarDistance },
  { "SO3LightGetPowerScale",        1, "fun [SO3_OBJECT] F",           SO3LightGetPowerScale        },
  { "SO3LightGetShadowFarDistance", 1, "fun [SO3_OBJECT] F",           SO3LightGetShadowFarDistance },
  { "SO3LightSetVisible",           2, "fun [SO3_OBJECT I] I",         SO3LightSetVisible           },
  { "SO3LightGetVisible",           1, "fun [SO3_OBJECT] I",           SO3LightGetVisible           },
  { "SO3LightSetAttenuation",       2, "fun [SO3_OBJECT [F F F F]] I", SO3LightSetAttenuation       },
  { "SO3LightSetAttenuationAuto",   2, "fun [SO3_OBJECT F] I",         SO3LightSetAttenuationAuto   },
  { "SO3LightGetAttenuation",       1, "fun [SO3_OBJECT] [F F F F]",   SO3LightGetAttenuation       },
  { "SO3LightSetSpecularColor",     2, "fun [SO3_OBJECT I] I",         SO3LightSetSpecularColor     },
  { "SO3LightGetSpecularColor",     1, "fun [SO3_OBJECT] I",           SO3LightGetSpecularColor     },
  { "SO3LightSetSpotFallOff",       2, "fun [SO3_OBJECT F] I",         SO3LightSetSpotFallOff       },
  { "SO3LightGetSpotFallOff",       1, "fun [SO3_OBJECT] F",           SO3LightGetSpotFallOff       },
  { "SO3LightSetSpotInnerAngle",    2, "fun [SO3_OBJECT F] I",         SO3LightSetSpotInnerAngle    },
  { "SO3LightSetSpotOuterAngle",    2, "fun [SO3_OBJECT F] I",         SO3LightSetSpotOuterAngle    },
  { "SO3LightGetSpotInnerAngle",    1, "fun [SO3_OBJECT] F",           SO3LightGetSpotInnerAngle    },
  { "SO3LightGetSpotOuterAngle",    1, "fun [SO3_OBJECT] F",           SO3LightGetSpotOuterAngle    },
  { "SO3LightSetSpotRange",         2, "fun [SO3_OBJECT [F F F]] I",   SO3LightSetSpotRange         },
  { "SO3LightSetSourceSize",        2, "fun [SO3_OBJECT [F F]] I",     SO3LightSetSourceSize        },
  { "SO3LightGetSourceSize",        1, "fun [SO3_OBJECT] [F F]",       SO3LightGetSourceSize        },
  { "SO3LightSetVolumetric",        2, "fun [SO3_OBJECT I] I",         SO3LightSetVolumetric        },
  { "SO3LightGetVolumetric",        1, "fun [SO3_OBJECT] I",           SO3LightGetVolumetric        }
};
 
 
int SCOLloadLight(mmachine m,cbmachine w)
{
  return PKhardpak2(m, "SO3Light.pkg", sizeof(natSO3Light) / sizeof(natSO3Light[0]), natSO3Light);
}
 
 
int SCOLfreeLight()
{
  return 0;
}