SCOLDynamicCubeMap.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/SO3DynamicCubeMap.h"
 
// Scene Graph includes
#include "SO3SceneGraph/SO3Scene.h"
 
int SO3DynamicCubeMapCreate(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3DynamicCubeMapCreate\n");
#endif
 
  int n = MMpull(m);
  int s = MMget(m, 0);
 
  // Checking parameters.
  if((s==NIL)||(n==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 name
  std::string tmpDynamicCubeMapName = MMstartstr(m, MTOP(n));
 
  // Create the object
  SDynamicCubeMap* dynamicCubeMap = 0;
  try
  {
    dynamicCubeMap = scene->CreateDynamicCubeMap(tmpDynamicCubeMapName);
        } 
  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, dynamicCubeMap) != 0))
  {
    scene->DeleteDynamicCubeMap(dynamicCubeMap);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
        OBJcreate(m, SO3OBJTYPE, SCOL_PTR dynamicCubeMap, SO3SCENETYPE, SCOL_PTR scene);
 
  return 0;
}
 
int SO3DynamicCubeMapSetTargetMaterial(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3DynamicCubeMapSetTargetMaterial\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_CUBE_MAP_ID) 
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SDynamicCubeMap* dynamicCubeMap = static_cast<SDynamicCubeMap*>(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
  {
    dynamicCubeMap->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 SO3DynamicCubeMapGetEnable(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3DynamicCubeMapGetEnable\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_CUBE_MAP_ID)   
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SDynamicCubeMap* dynamicCubeMap = static_cast<SDynamicCubeMap*>(node);
 
  int val = 0;
  if(dynamicCubeMap->GetEnable()) 
    val = 1;
 
        MMset(m, 0, ITOM(val));         
        return 0;       
}
 
int SO3DynamicCubeMapSetEnable(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3DynamicCubeMapSetEnable\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_CUBE_MAP_ID)   
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SDynamicCubeMap* dynamicCubeMap = static_cast<SDynamicCubeMap*>(node);
  
  if(b >= 1)
    dynamicCubeMap->SetEnable(true);
  else
    dynamicCubeMap->SetEnable(false);
 
        MMset(m, 0, ITOM(1));           
        return 0;       
}
 
int SO3DynamicCubeMapGetAutoUpdate(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3DynamicCubeMapGetAutoUpdate\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_CUBE_MAP_ID)   
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SDynamicCubeMap* dynamicCubeMap = static_cast<SDynamicCubeMap*>(node);
 
  int val = 0;
  if(dynamicCubeMap->GetAutoUpdate()) 
    val = 1;
 
        MMset(m, 0, ITOM(val));         
        return 0;       
}
 
int SO3DynamicCubeMapSetAutoUpdate(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3DynamicCubeMapSetAutoUpdate\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_CUBE_MAP_ID)   
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SDynamicCubeMap* dynamicCubeMap = static_cast<SDynamicCubeMap*>(node);
  
  if(b >= 1)
    dynamicCubeMap->SetAutoUpdate(true);
  else
    dynamicCubeMap->SetAutoUpdate(false);
 
        MMset(m, 0, ITOM(1));           
        return 0;       
}
 
 
int SO3DynamicCubeMapGetTextureSize(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3DynamicCubeMapGetTextureSize\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_CUBE_MAP_ID)   
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SDynamicCubeMap* dynamicCubeMap = static_cast<SDynamicCubeMap*>(node);
        MMset(m, 0, ITOM(dynamicCubeMap->GetSize()));           
        return 0;       
}
 
int SO3DynamicCubeMapSetTextureSize(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3DynamicCubeMapSetTextureSize\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_CUBE_MAP_ID)   
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SDynamicCubeMap* dynamicCubeMap = static_cast<SDynamicCubeMap*>(node);
 
  try
  {
    dynamicCubeMap->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;       
}
 
int SO3DynamicCubeMapUpdate(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3DynamicCubeMapUpdate\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_CUBE_MAP_ID)   
  {
    MMset(m, 0, NIL);   
    return 0;
  }
 
  SDynamicCubeMap* dynamicCubeMap = static_cast<SDynamicCubeMap*>(node);
 
  dynamicCubeMap->Update();
        MMset(m, 0, ITOM(1));           
        return 0;       
}
 
 
NativeDefinition natSO3CubeMap[] = {
        { "SO3DynamicCubeMapCreate",             2,  "fun [SO3_SCENE S] SO3_OBJECT",                    SO3DynamicCubeMapCreate            },
  { "SO3DynamicCubeMapSetTargetMaterial",  5,  "fun [SO3_OBJECT SO3_MATERIAL I I I] SO3_OBJECT",  SO3DynamicCubeMapSetTargetMaterial },
  { "SO3DynamicCubeMapGetEnable",          1,  "fun [SO3_OBJECT] I",                              SO3DynamicCubeMapGetEnable         },
  { "SO3DynamicCubeMapSetEnable",          2,  "fun [SO3_OBJECT I] I",                            SO3DynamicCubeMapSetEnable         },
  { "SO3DynamicCubeMapGetTextureSize",     1,  "fun [SO3_OBJECT] I",                              SO3DynamicCubeMapGetTextureSize    },
  { "SO3DynamicCubeMapSetTextureSize",     2,  "fun [SO3_OBJECT I] I",                            SO3DynamicCubeMapSetTextureSize    },
  { "SO3DynamicCubeMapGetAutoUpdate",      1,  "fun [SO3_OBJECT] I",                              SO3DynamicCubeMapGetAutoUpdate     },
  { "SO3DynamicCubeMapSetAutoUpdate",      2,  "fun [SO3_OBJECT I] I",                            SO3DynamicCubeMapSetAutoUpdate     },
  { "SO3DynamicCubeMapUpdate",             1,  "fun [SO3_OBJECT] I",                              SO3DynamicCubeMapUpdate            }
};
 
 
int SCOLloadDynamicCubeMap(mmachine m,cbmachine w)
{       
        return PKhardpak2(m, "SO3CubeMap.pkg", sizeof(natSO3CubeMap) / sizeof(natSO3CubeMap[0]), natSO3CubeMap);
}
 
int SCOLfreeDynamicCubeMap()
{
        return 0;
}