MercuryMaterial.cpp

Go to the documentation of this file.

#include "global.h"
#include "MercuryDisplay.h"
#include "MercuryMaterial.h"
#include "MercuryINI.h"
#include "MercuryTextureManager.h"
#include "MercuryLog.h"

#define MC_SHADERCHECK 0

MercuryMaterial::~MercuryMaterial()
{
    ClearTextures();
    if (m_iGLSLShaderID != -1)
        DISPLAY->DestroyShaderProgram(m_iGLSLShaderID);
}

MercuryMaterial::MercuryMaterial()
{
    m_shininess = 0;
    m_alpha = 0;
    m_iGLSLShaderID = -1;
    m_bHasRegistered = false;
}

void MercuryMaterial::AddTexture(MercuryTexture* texture)
{
    ASSERT(texture->IsInitalized());
    m_textures.push_back(texture);
}

void MercuryMaterial::Message( int Message, PStack & data, const MString & name )
{
    if ( Message == MC_SHADERCHECK )
    {
        MercuryFile * fx = FILEMAN.Open( m_GLSLFragmentFile );
        if( fx ) {
            unsigned thisTime = fx->GetModTime();
            if( m_iGLSLFragTime != thisTime )
            {
                BuildShader();
                m_iGLSLFragTime = thisTime;
            }
            SAFE_DELETE( fx );
        }
        fx = FILEMAN.Open( m_GLSLVertexFile );
        if( fx ) {
            unsigned thisTime = fx->GetModTime();
            if( m_iGLSLVertTime != thisTime )
            {
                BuildShader();
                m_iGLSLVertTime = thisTime;
            }
            SAFE_DELETE( fx );
        }
        //repost the check shader message
        MESSAGEMAN->PostSystemMessage( ssprintf( "Material%pCheck", this ), PStack(), PREFSMAN->GetValueF( "Options", "CheckGLSL", -1, true ) );
    }
}

void MercuryMaterial::BuildShader()
{
    MString sFragment, sVertex;
    LOG.Info("Loading shader programs: " + m_GLSLVertexFile + ", " + m_GLSLVertexFile);
    FileToMString( m_GLSLFragmentFile, sFragment );
    FileToMString( m_GLSLVertexFile, sVertex );

    //Destroy the previous shader if one exists
    if (m_iGLSLShaderID != -1)
        DISPLAY->DestroyShaderProgram(m_iGLSLShaderID);
    m_iGLSLShaderID = DISPLAY->CompileShader( sVertex, sFragment );
}

bool MercuryMaterial::LoadMaterial(const MString& filename, const MString& path)
{
    MercuryINI f;

    int version = 0;
    unsigned int numTextures = 0;
    m_completePath = path + filename;

    //try loading an image if the path does not end in ini which indicates
    //a material file
    if ( m_completePath.compare( m_completePath.length() - 3, 3, "ini" ) != 0 )
    {
        ClearTextures();
        MercuryTexture* texture = MercuryTextureManager::CreateTexture(m_completePath);
        if (texture)
        {
            AddTexture(texture);
            return true;
        }
//      LOG.Log("Material file not an .ini:" + completePath);
        return false;
    }

    //continue the load process assuming a material ini file
    if (!f.Open(m_completePath))
    {
        LOG.Log("Unable to open INI:" + m_completePath);
        return false;
    }

    version = f.GetValueI("Material", "Version");

    switch (version)
    {
    case 3:
    case 2:
        //version 2
        m_diffuse.FromString(f.GetValueS("Material", "Diffuse"));
        m_ambient.FromString(f.GetValueS("Material", "Ambient"));
        m_specular.FromString(f.GetValueS("Material", "Specular"));
        m_emissive.FromString(f.GetValueS("Material", "Emissive"));
        m_shininess = f.GetValueF("Material", "Shine" );
    case 1:
        //version 1
        m_name = f.GetValueS("Material", "Name");
        numTextures = f.GetValueI("Material", "NumTextures");
        ClearTextures();
        for (unsigned int i = 0; i < numTextures; ++i)
        {
            MercuryTexture* t;
            MString tpath;
            MString mapping;
            MercuryPoint p;
            MString tmp;

            tpath = path + f.GetValueS("Material", ssprintf("Texture%d", i+1));

            if ( tpath.empty() )
                continue;

            t = MercuryTextureManager::CreateTexture(tpath);
            if (!t)
            {
                LOG.Log("Unable to load image: " + tpath);
                continue;
            }

            mapping = f.GetValueS("Material", ssprintf("Texture%dMapping", i+1));
            if (mapping.empty())
                mapping = "standard";

            t->SetMapMode(f.GetValueI("Material", ssprintf("Texture%dMapMode", i+1)));

            tmp = f.GetValueS("Material", ssprintf("Texture%dScaleXYZ", i+1));  
            if (tmp.empty())
                p.x = p.y = p.z = 1;
            else
                sscanf(f.GetValueS("Material", ssprintf("Texture%dScaleXYZ", i+1)), "%f,%f,%f", &p.x, &p.y, &p.z);
            t->SetScale(p);

            tmp = f.GetValueS("Material", ssprintf("Texture%dOffsetXYZ", i+1)); 
            if (tmp.empty())
                p.x = p.y = p.z = 0;
            else
                sscanf(tmp, "%f,%f,%f", &p.x, &p.y, &p.z);
            t->SetPosition(p);

            tmp = f.GetValueS("Material", ssprintf("Texture%dRotXYZ", i+1));    
            if (tmp.empty())
                p.x = p.y = p.z = 0;
            else
                sscanf(tmp, "%f,%f,%f", &p.x, &p.y, &p.z);
            t->SetRot(p);

            AddTexture(t);

            //Make this much better when textures actually have more than 2
            //ways of mapping
            if (mapping == "standard")
                t->SetMapping(STANDARD);
            else if(mapping == "sphere")
                t->SetMapping(SPHERE);
            else if (mapping == "cube")
                t->SetMapping(CUBE);
            else if (mapping == "dot3")
                t->SetMapping(DOT3);
        }
    }

    m_GLSLFragmentFile = f.GetValueS("Material", "GLSLFragmentFile");
    m_GLSLVertexFile = f.GetValueS("Material", "GLSLVertexFile");

    if( !m_GLSLFragmentFile.empty() && !m_GLSLVertexFile.empty() )
    {
        if( FileExists( m_GLSLFragmentFile ) && FileExists( m_GLSLVertexFile ) )
        {
            BuildShader();

            if( PREFSMAN->GetValueF( "Options", "CheckGLSL", -1, true ) > 0 )
            {
                MercuryFile * fx = FILEMAN.Open( m_GLSLFragmentFile );

                //Get the time the shader file was last modified. We can monitor this in
                //realtime and reload as needed.
                if( fx ) {
                    m_iGLSLFragTime = fx->GetModTime();
                    SAFE_DELETE( fx );
                }

                fx = FILEMAN.Open( m_GLSLVertexFile );
                if( fx ) {
                    m_iGLSLVertTime = fx->GetModTime();
                    SAFE_DELETE( fx );
                }
                if ( !m_bHasRegistered )
                {
                    //Register shader timestamp check
                    RegisterMessage( MC_SHADERCHECK, ssprintf( "Material%pCheck", this ) );
                    MESSAGEMAN->PostSystemMessage( ssprintf( "Material%pCheck", this ), PStack(), PREFSMAN->GetValueF( "Options", "CheckGLSL", -1, true ) );
                    m_bHasRegistered = true;
                }
            }
        }
        else
        {
            LOG.Warn( "Could not find shader(s) in: " + m_completePath );
            m_iGLSLShaderID = -1;
        }
    }
    else
        m_iGLSLShaderID = -1;

    //Load Uniform values from INI
    if( m_iGLSLShaderID != -1 )
    {
        MString sAllParams = f.GetValueS( "Material", "GLSLUniforms" );
        SplitStrings( sAllParams, m_vUniformNames, ",", " ", 1, 1 );
        m_vUniformValues.resize( m_vUniformNames.size() );
        for( unsigned i = 0; i < m_vUniformNames.size(); i++ )
        {
            MString sVal = m_vUniformNames[i];
            //Get Type
            MString sTyp = f.GetValueS( "Material", "U" + sVal + "Type" );
            MString sDat = f.GetValueS( "Material", "U" + sVal );

            MVector< MString > vDat;
            SplitStrings( sDat, vDat, ",", " ", 1, 1 );

            if( sTyp == "int" )
            {
                for( unsigned j = 0; j < vDat.size(); j++ )
                    m_vUniformValues[i].PushItemBack( PSElement( atoi( vDat[j] ) ) );
            }
            else
            {
                for( unsigned j = 0; j < vDat.size(); j++ )
                    m_vUniformValues[i].PushItemBack( PSElement( (float)atof( vDat[j] ) ) );
            }
        }
    }
    return true;
}

void MercuryMaterial::ClearTextures()
{
    m_textures.clear();
}

const MercuryMaterial& MercuryMaterial::operator=(const MercuryMaterial& m)
{
    m_ambient = m.m_ambient;
    m_diffuse = m.m_diffuse;
    m_specular = m.m_specular;
    m_emissive = m.m_emissive;
    m_shininess = m.m_shininess;
    m_alpha = m.m_alpha;

    m_textures = m.m_textures;

    return *this;
}

const MercuryMaterial MercuryMaterial::operator*(const MercuryMaterial& m)
{
    MercuryMaterial r;
    r.m_ambient = m_ambient * m.m_ambient;
    r.m_diffuse = m_diffuse * m.m_diffuse;
    r.m_specular = m_specular * m.m_specular;
    r.m_emissive = m_emissive * m.m_emissive;
    r.m_shininess = m_shininess * m.m_shininess;
    r.m_alpha = m_alpha * m.m_alpha;
    return r;
}

const MercuryMaterial& MercuryMaterial::operator*=(const MercuryMaterial& m)
{
    m_ambient *= m.m_ambient;
    m_diffuse *= m.m_diffuse;
    m_specular *= m.m_specular;
    m_emissive *= m.m_emissive;
    m_shininess *= m.m_shininess;
    return *this;
}

/* 
 * Copyright (c) 2005-2006, Joshua Allen
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by