random_racer/src/MeshBeautifier.cpp

Go to the documentation of this file.

#include <math.h>
#include <assert.h>
#include <sstream>

#include <vrs/callback.h>
#include <vrs/material.h>
#include <vrs/opengl/imagetexture2dgl.h>
#include <vrs/opengl/texenvgl.h>
#include <vrs/opengl/texture2dgl.h>
#include <vrs/scaling.h>
#include <vrs/sg/scenething.h>
#include <vrs/facestyle.h>

#include "Console.h"
#include "ResourceManager.h"
#include "VRSTerrainLoader.h"

#include "MeshBeautifier.h"

using namespace VRS;


namespace random_racer
{

MeshBeautifier::MeshBeautifier(
    VRSTerrainLoader* p_loader, int p_minHeight, int p_maxHeight)
{
    assert( p_minHeight < p_maxHeight );

    m_minHeight = p_minHeight;
    m_maxHeight = p_maxHeight;
    
    m_absHeight = calculateAbsHeight(p_minHeight, p_maxHeight);
    
    m_loader = p_loader;
    m_newTexture = false;
    m_debug = false;
    m_removed = false;
    m_grid = false;
    
    m_faceStyle = new FaceStyle(FaceStyle::Outlined, FaceStyle::Outlined);
    
    m_gradientImage =
            ResourceManager::get()->loadImage("texture/gradient_grass.rgb");
    m_imageGradientWidth = m_gradientImage->width();
    
    m_texture = ResourceManager::get()->loadTexture2D("texture/grass.jpg", 
                                                      true, false);
    m_texture->setWrap(TextureGL::REPEAT);
    m_texture->setFilter(TextureGL::TRILINEAR);
    m_texture->setMatrix(Scaling(Vector(0.2,0.2,1)).matrix());

    m_textureTemp = ResourceManager::get()->loadTexture2D("texture/mud.jpg", 
        true, false);
    m_textureTemp->setWrap(TextureGL::REPEAT);
    m_textureTemp->setFilter(TextureGL::TRILINEAR);
    m_textureTemp->setMatrix(Scaling(Vector(0.2,0.2,1)).matrix());

    Console::get()->registerCommand("ter_texture",
        new MethodCallback1<MeshBeautifier, const std::string&>(
            this, &MeshBeautifier::terLoadTextureCommand));
}

MeshBeautifier::~MeshBeautifier()
{
}

unsigned int 
MeshBeautifier::calculateAbsHeight(int p_minHeight, int p_maxHeight)
{
    if(p_minHeight <= 0 && p_maxHeight > 0)
        return (p_maxHeight + abs(p_minHeight));
    if(p_minHeight > 0 && p_maxHeight > 0 || p_minHeight < 0 && p_maxHeight < 0)
        return (p_maxHeight - p_minHeight);    
    else
        return 0;
}

void
MeshBeautifier::initializeSceneThing(SO<SceneThing> p_thing)
{
    // store the SceneThing
    m_thing = p_thing;
    
    // Material
    p_thing->append(new Material(1.0, 1.0, 0.0));
    
    // Texture Env.
    p_thing->append(new TexEnvGL(TexEnvGL::Modulate, Color(0)));
    
    // a nice texture
    p_thing->append(m_texture);
}

void
MeshBeautifier::terLoadTextureCommand(const std::string& p_string)
{
    if(p_string.empty())
    {
        std::ostringstream s, t, u;
        s << "Try sand, grass and mud for some nice Textures";
        t << "To see the Grid of the Mesh type grid"; 
        u << "To see just the Mesh without any Textures try debug";

        Console::get()->addLine(s.str());
        Console::get()->addLine(t.str());
        Console::get()->addLine(u.str());
    }
    else if(p_string != "debug" && p_string != "grid")
    {
        m_debug = false;
        m_grid = false;
        
        m_textureTemp = ResourceManager::get()->loadTexture2D(
                "texture/" + p_string + ".jpg", true, true);
            
        if(m_textureTemp != NULL)
        {   
            m_textureTemp->setWrap(TextureGL::REPEAT);
            m_textureTemp->setFilter(TextureGL::TRILINEAR);
            m_textureTemp->setMatrix(Scaling(Vector(0.2,0.2,1)).matrix());
                     
            m_newTexture = true;

            m_gradientImage = ResourceManager::get()->loadImage(
                    "texture/gradient_"+p_string+".rgb");
            m_imageGradientWidth = m_gradientImage->width();
            
            m_loader->beautifyMesh();
        }
        else
            Console::get()->addLine("Invalid Texturename");
    } 
    else
    {
        m_grid = false;
        
        if(p_string == "grid")
            m_grid = true;
        
        m_removed = true;
        m_debug = true;
        m_loader->beautifyMesh();
    }
}

} // namespace random_racer

---