simgear/scene/material/mat.cxx

   1 // mat.cxx -- class to handle material properties
   2 //
   3 // Written by Curtis Olson, started May 1998.
   4 //
   5 // Copyright (C) 1998 - 2000  Curtis L. Olson  - curt@flightgear.org
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License as
   9 // published by the Free Software Foundation; either version 2 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 //
  21 // $Id$
  22
  23
  24 #ifdef HAVE_CONFIG_H
  25 #  include <simgear_config.h>
  26 #endif
  27
  28 #include <simgear/compiler.h>
  29
  30 #include <map>
  31 SG_USING_STD(map);
  32
  33 #include <simgear/compiler.h>
  34
  35 #ifdef SG_MATH_EXCEPTION_CLASH
  36 #  include <math.h>
  37 #endif
  38
  39 #include <simgear/debug/logstream.hxx>
  40 #include <simgear/math/sg_random.h>
  41 #include <simgear/misc/sg_path.hxx>
  42 #include <simgear/misc/sgstream.hxx>
  43
  44 #include "mat.hxx"
  45
  46 \f
  47 ////////////////////////////////////////////////////////////////////////
  48 // Local static functions.
  49 ////////////////////////////////////////////////////////////////////////
  50
  51 /**
  52  * Internal method to test whether a file exists.
  53  *
  54  * TODO: this should be moved to a SimGear library of local file
  55  * functions.
  56  */
  57 static inline bool
  58 local_file_exists( const string& path ) {
  59     sg_gzifstream in( path );
  60     if ( ! in.is_open() ) {
  61         return false;
  62     } else {
  63         return true;
  64     }
  65 }
  66
  67
  68 \f
  69 ////////////////////////////////////////////////////////////////////////
  70 // Constructors and destructor.
  71 ////////////////////////////////////////////////////////////////////////
  72
  73
  74 SGMaterial::SGMaterial( const string &fg_root, const SGPropertyNode *props )
  75 {
  76     init();
  77     read_properties( fg_root, props );
  78     build_ssg_state( false );
  79 }
  80
  81 SGMaterial::SGMaterial( const string &texpath )
  82 {
  83     init();
  84     texture_path = texpath;
  85     build_ssg_state( true );
  86 }
  87
  88 SGMaterial::SGMaterial( ssgSimpleState *s )
  89 {
  90     init();
  91     set_ssg_state( s );
  92 }
  93
  94 SGMaterial::~SGMaterial (void)
  95 {
  96   for (unsigned int i = 0; i < object_groups.size(); i++) {
  97     delete object_groups[i];
  98     object_groups[i] = 0;
  99   }
 100 }
 101
 102
 103 \f
 104 ////////////////////////////////////////////////////////////////////////
 105 // Public methods.
 106 ////////////////////////////////////////////////////////////////////////
 107
 108 void
 109 SGMaterial::read_properties( const string &fg_root, const SGPropertyNode * props )
 110 {
 111                                 // Get the path to the texture
 112   string tname = props->getStringValue("texture", "unknown.rgb");
 113   SGPath tpath( fg_root );
 114   tpath.append("Textures.high");
 115   tpath.append(tname);
 116   if (!local_file_exists(tpath.str())) {
 117     tpath = SGPath( fg_root );
 118     tpath.append("Textures");
 119     tpath.append(tname);
 120   }
 121   texture_path = tpath.str();
 122
 123   xsize = props->getDoubleValue("xsize", 0.0);
 124   ysize = props->getDoubleValue("ysize", 0.0);
 125   wrapu = props->getBoolValue("wrapu", true);
 126   wrapv = props->getBoolValue("wrapv", true);
 127   mipmap = props->getBoolValue("mipmap", true);
 128   light_coverage = props->getDoubleValue("light-coverage", 0.0);
 129
 130   // Taken from default values as used in ac3d
 131   ambient[0] = props->getDoubleValue("ambient/r", 0.2);
 132   ambient[1] = props->getDoubleValue("ambient/g", 0.2);
 133   ambient[2] = props->getDoubleValue("ambient/b", 0.2);
 134   ambient[3] = props->getDoubleValue("ambient/a", 1.0);
 135
 136   diffuse[0] = props->getDoubleValue("diffuse/r", 0.8);
 137   diffuse[1] = props->getDoubleValue("diffuse/g", 0.8);
 138   diffuse[2] = props->getDoubleValue("diffuse/b", 0.8);
 139   diffuse[3] = props->getDoubleValue("diffuse/a", 1.0);
 140
 141   specular[0] = props->getDoubleValue("specular/r", 0.0);
 142   specular[1] = props->getDoubleValue("specular/g", 0.0);
 143   specular[2] = props->getDoubleValue("specular/b", 0.0);
 144   specular[3] = props->getDoubleValue("specular/a", 1.0);
 145
 146   emission[0] = props->getDoubleValue("emissive/r", 0.0);
 147   emission[1] = props->getDoubleValue("emissive/g", 0.0);
 148   emission[2] = props->getDoubleValue("emissive/b", 0.0);
 149   emission[3] = props->getDoubleValue("emissive/a", 1.0);
 150
 151   shininess = props->getDoubleValue("shininess", 1.0);
 152
 153   vector<SGPropertyNode_ptr> object_group_nodes =
 154     ((SGPropertyNode *)props)->getChildren("object-group");
 155   for (unsigned int i = 0; i < object_group_nodes.size(); i++)
 156     object_groups.push_back(new SGMatModelGroup(object_group_nodes[i]));
 157 }
 158
 159
 160 \f
 161 ////////////////////////////////////////////////////////////////////////
 162 // Private methods.
 163 ////////////////////////////////////////////////////////////////////////
 164
 165 void
 166 SGMaterial::init ()
 167 {
 168     texture_path = "";
 169     state = NULL;
 170     xsize = 0;
 171     ysize = 0;
 172     wrapu = true;
 173     wrapv = true;
 174     mipmap = true;
 175     light_coverage = 0.0;
 176     texture_loaded = false;
 177     refcount = 0;
 178     shininess = 1.0;
 179     for (int i = 0; i < 4; i++) {
 180         ambient[i]  = (i < 3) ? 0.2 : 1.0;
 181         specular[i] = (i < 3) ? 0.0 : 1.0;
 182         diffuse[i]  = (i < 3) ? 0.8 : 1.0;
 183         emission[i] = (i < 3) ? 0.0 : 1.0;
 184     }
 185 }
 186
 187 bool
 188 SGMaterial::load_texture ()
 189 {
 190     if ( texture_loaded ) {
 191         return false;
 192     } else {
 193         SG_LOG( SG_GENERAL, SG_INFO, "Loading deferred texture "
 194                 << texture_path );
 195         state->setTexture( (char *)texture_path.c_str(), wrapu, wrapv, mipmap );
 196         texture_loaded = true;
 197         return true;
 198     }
 199 }
 200
 201
 202 void
 203 SGMaterial::build_ssg_state( bool defer_tex_load )
 204 {
 205     GLenum shade_model = GL_SMOOTH;
 206
 207     state = new ssgSimpleState();
 208     state->ref();
 209
 210     // Set up the textured state
 211     state->setShadeModel( shade_model );
 212     state->enable( GL_LIGHTING );
 213     state->enable ( GL_CULL_FACE ) ;
 214     state->enable( GL_TEXTURE_2D );
 215     state->disable( GL_BLEND );
 216     state->disable( GL_ALPHA_TEST );
 217     if ( !defer_tex_load ) {
 218         SG_LOG(SG_INPUT, SG_INFO, "    " << texture_path );
 219         state->setTexture( (char *)texture_path.c_str(), wrapu, wrapv );
 220         texture_loaded = true;
 221     } else {
 222         texture_loaded = false;
 223     }
 224     state->enable( GL_COLOR_MATERIAL );
 225     state->setMaterial ( GL_AMBIENT,
 226                             ambient[0], ambient[1],
 227                             ambient[2], ambient[3] ) ;
 228     state->setMaterial ( GL_DIFFUSE,
 229                             diffuse[0], diffuse[1],
 230                             diffuse[2], diffuse[3] ) ;
 231     state->setMaterial ( GL_SPECULAR,
 232                             specular[0], specular[1],
 233                             specular[2], specular[3] ) ;
 234     state->setMaterial ( GL_EMISSION,
 235                             emission[0], emission[1],
 236                             emission[2], emission[3] ) ;
 237     state->setShininess ( shininess );
 238 }
 239
 240
 241 void SGMaterial::set_ssg_state( ssgSimpleState *s )
 242 {
 243     state = s;
 244     state->ref();
 245     texture_loaded = true;
 246 }
 247
 248 // end of mat.cxx