SCOLDynamicReflectionMap.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"
 
// Material includes
#include "SO3Material/SO3DynamicReflectionMap.h"
 
// Scene Graph includes
#include "SO3SceneGraph/SO3Scene.h"
 
int SO3DynamicReflectionMapCreate(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3DynamicReflectionMapCreate\n");
#endif
 
  int n  = MMpull(m);
  int vp = MMpull(m);
  int s  = MMget(m, 0);
 
  // Checking parameters.
  if((s==NIL)||(n==NIL)||(vp==NIL))
  { 
    MMset(m, 0, NIL);   
    return 0;   
  }
  
  // Get the SScene pointer
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if(scene==NULL)       
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  //get the viewport
  SViewPort* viewport = MMgetPointer<SViewPort*>(m, MTOP(vp));
  if(viewport==NULL)    
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  // Get the name
  std::string tmpDynamicReflectionMapName = MMstartstr(m, MTOP(n));
 
  // Create the object
  SDynamicReflectionMap* dynamicReflectionMap = 0;
  try
  {
    dynamicReflectionMap = scene->CreateDynamicReflectionMap(viewport, tmpDynamicReflectionMapName);
        } 
        catch(Ogre::Exception &e)
        { 
                MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
                MMset(m,0,NIL);         
                return 0;       
  }
 
  //get scene scol object
  int p = OBJfindTH(m, SO3SCENETYPE, SCOL_PTR scene);
  // push channel
  MMset(m, 0, MMfetch(m, p, OFFOBJCHN));
 
  if ((MMpushPointer(m, dynamicReflectionMap) != 0))
  {
    scene->DeleteDynamicReflectionMap(dynamicReflectionMap);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
        OBJcreate(m, SO3OBJTYPE, SCOL_PTR dynamicReflectionMap, SO3SCENETYPE, SCOL_PTR scene);
 
  return 0;
}
 
int SO3DynamicReflectionMapSetTargetMaterial(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3DynamicReflectionMapSetTargetMaterial\n");
#endif
 
  int textureUnit = MMpull(m);
  int pass        = MMpull(m);
  int technique   = MMpull(m);
  int mat         = MMpull(m);
  int dcm         = MMget(m, 0);
 
  // Checking parameters.
  if((dcm==NIL)||(mat==NIL)||(technique==NIL)||(pass==NIL)||(textureUnit==NIL))
  { 
    MMset(m, 0, NIL);   
    return 0;   
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(dcm));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if(node->GetNodeType()!=SNode::DYNAMIC_REFLECTION_MAP_ID)     
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SDynamicReflectionMap* dynamicReflectionMap = static_cast<SDynamicReflectionMap*>(node);
 
  // Get the targeted SMaterial pointer
  SMaterial* material = MMgetPointer<SMaterial*>(m, MTOP(mat));
  if(material == NULL)
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  // Get other parameters
  technique   = MTOI(technique);
  pass        = MTOI(pass);
  textureUnit = MTOI(textureUnit);
 
  try
  {
    dynamicReflectionMap->SetMaterial(material, technique, pass, textureUnit);
    MMset(m, 0, ITOM(1));               
  }
  catch(Ogre::Exception& e)
  {
    MMechostr(MSKRUNTIME, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
  }
  return 0;
}
 
int SO3DynamicReflectionMapGetEnable(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3DynamicReflectionMapGetEnable\n");
#endif
 
        int dcm = MMget(m, 0);
        if(dcm==NIL)            
  {
    MMset(m,0,NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(dcm));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if(node->GetNodeType()!=SNode::DYNAMIC_REFLECTION_MAP_ID)     
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SDynamicReflectionMap* dynamicReflectionMap = static_cast<SDynamicReflectionMap*>(node);
 
  int val = 0;
  if(dynamicReflectionMap->GetEnable()) 
    val = 1;
 
        MMset(m, 0, ITOM(val));         
        return 0;       
}
 
int SO3DynamicReflectionMapSetEnable(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3DynamicReflectionMapSetEnable\n");
#endif
 
        int b   = MTOI(MMpull(m));
        int dcm = MMget(m, 0);
        if((dcm==NIL)||(b==NIL))
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(dcm));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if(node->GetNodeType()!=SNode::DYNAMIC_REFLECTION_MAP_ID)     
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SDynamicReflectionMap* dynamicReflectionMap = static_cast<SDynamicReflectionMap*>(node);
  
  if(b >= 1)
    dynamicReflectionMap->SetEnable(true);
  else
    dynamicReflectionMap->SetEnable(false);
 
        MMset(m, 0, ITOM(1));           
        return 0;       
}
 
int SO3DynamicReflectionMapGetRevertClipPlane(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3DynamicReflectionMapGetRevertClipPlane\n");
#endif
 
        int dcm = MMget(m, 0);
        if(dcm==NIL)            
  {
    MMset(m,0,NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(dcm));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if(node->GetNodeType()!=SNode::DYNAMIC_REFLECTION_MAP_ID)     
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SDynamicReflectionMap* dynamicReflectionMap = static_cast<SDynamicReflectionMap*>(node);
 
  int val = 0;
  if(dynamicReflectionMap->GetRevertClipPlane()) 
    val = 1;
 
        MMset(m, 0, ITOM(val));         
        return 0;       
}
 
int SO3DynamicReflectionMapSetRevertClipPlane(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3DynamicReflectionMapSetRevertClipPlane\n");
#endif
 
        int b   = MTOI(MMpull(m));
        int dcm = MMget(m, 0);
        if(dcm==NIL)
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(dcm));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if(node->GetNodeType()!=SNode::DYNAMIC_REFLECTION_MAP_ID)     
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SDynamicReflectionMap* dynamicReflectionMap = static_cast<SDynamicReflectionMap*>(node);
  
  if(b >= 1)
    dynamicReflectionMap->SetRevertClipPlane(true);
  else
    dynamicReflectionMap->SetRevertClipPlane(false);
 
        MMset(m, 0, ITOM(1));           
        return 0;       
}
 
 
int SO3DynamicReflectionMapGetTextureSize(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3DynamicReflectionMapGetTextureSize\n");
#endif
 
        int dcm = MMget(m, 0);
        if(dcm==NIL)            
  {
    MMset(m,0,NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(dcm));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if(node->GetNodeType()!=SNode::DYNAMIC_REFLECTION_MAP_ID)     
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SDynamicReflectionMap* dynamicReflectionMap = static_cast<SDynamicReflectionMap*>(node);
        MMset(m, 0, ITOM(dynamicReflectionMap->GetSize()));             
        return 0;       
}
 
int SO3DynamicReflectionMapSetTextureSize(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3DynamicReflectionMapSetTextureSize\n");
#endif
 
        int b   = MMpull(m);
        int dcm = MMget(m, 0);
        if((dcm==NIL)||(b==NIL))
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(dcm));
        if(node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if(node->GetNodeType()!=SNode::DYNAMIC_REFLECTION_MAP_ID)     
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SDynamicReflectionMap* dynamicReflectionMap = static_cast<SDynamicReflectionMap*>(node);
 
  try
  {
    dynamicReflectionMap->SetSize(MTOI(b));
    MMset(m, 0, ITOM(1));               
  }
  catch(Ogre::Exception& e)
  {
    MMechostr(MSKRUNTIME, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
  }
        return 0;       
}
 
 
NativeDefinition natSO3RefMap[] = {
        { "SO3DynamicReflectionMapCreate",             3,  "fun [SO3_SCENE SO3_VIEWPORT S] SO3_OBJECT",      SO3DynamicReflectionMapCreate,             },
  { "SO3DynamicReflectionMapSetTargetMaterial",  5,  "fun [SO3_OBJECT SO3_MATERIAL I I I] SO3_OBJECT", SO3DynamicReflectionMapSetTargetMaterial,  },
  { "SO3DynamicReflectionMapGetEnable",          1,  "fun [SO3_OBJECT] I",                             SO3DynamicReflectionMapGetEnable,          },
  { "SO3DynamicReflectionMapSetEnable",          2,  "fun [SO3_OBJECT I] I",                           SO3DynamicReflectionMapSetEnable,          },
  { "SO3DynamicReflectionMapGetTextureSize",     1,  "fun [SO3_OBJECT] I",                             SO3DynamicReflectionMapGetTextureSize,     },
  { "SO3DynamicReflectionMapSetTextureSize",     2,  "fun [SO3_OBJECT I] I",                           SO3DynamicReflectionMapSetTextureSize,     },
  { "SO3DynamicReflectionMapGetRevertClipPlane", 1,  "fun [SO3_OBJECT] I",                             SO3DynamicReflectionMapGetRevertClipPlane, },
  { "SO3DynamicReflectionMapSetRevertClipPlane", 2,  "fun [SO3_OBJECT I] I",                           SO3DynamicReflectionMapSetRevertClipPlane, }
};
 
 
int SCOLloadDynamicReflectionMap(mmachine m,cbmachine w)
{       
        return PKhardpak2(m, "SO3RefMap.pkg", sizeof(natSO3RefMap) / sizeof(natSO3RefMap[0]), natSO3RefMap);
}
 
int SCOLfreeDynamicReflectionMap()
{
        return 0;
}