From 192e9c058a7807e5bbcfd126ed260d5446f90434 Mon Sep 17 00:00:00 2001 From: dfighter1985 Date: Mon, 15 Jul 2013 05:12:38 +0200 Subject: [PATCH] More work on the Variant type. Also modified material editor to use it. --HG-- branch : gsoc2013-dfighter --- code/nel/include/nel/3d/dynamic_material.h | 2 +- code/nel/include/nel/misc/variant.h | 109 ++++++ code/nel/src/misc/variant.cpp | 320 ++++++++++++++++++ .../material_editor/nel3d_interface.cpp | 35 +- 4 files changed, 461 insertions(+), 5 deletions(-) create mode 100644 code/nel/include/nel/misc/variant.h create mode 100644 code/nel/src/misc/variant.cpp diff --git a/code/nel/include/nel/3d/dynamic_material.h b/code/nel/include/nel/3d/dynamic_material.h index 583f69c06..4e07443d3 100644 --- a/code/nel/include/nel/3d/dynamic_material.h +++ b/code/nel/include/nel/3d/dynamic_material.h @@ -44,7 +44,7 @@ namespace NL3D std::string label; uint8 type; - NLMISC::Variant value; + NLMISC::CVariant value; void serial( NLMISC::IStream &f ); }; diff --git a/code/nel/include/nel/misc/variant.h b/code/nel/include/nel/misc/variant.h new file mode 100644 index 000000000..5c617f5d1 --- /dev/null +++ b/code/nel/include/nel/misc/variant.h @@ -0,0 +1,109 @@ +// NeL - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 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 Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + + +#ifndef NLVARIANT_H +#define NLVARIANT_H + +#include "nel/misc/stream.h" +#include + +#define VARIANT_VVAL_END 16 + +namespace NLMISC +{ + class CVariant : public IStreamable + { + public: + + enum EVarType + { + Float, + Double, + Int, + UInt, + String, + Vector4, + Matrix4 + }; + + CVariant(); + ~CVariant(); + + std::string getClassName(){ return "CVariant"; } + + void serial( IStream &f ); + + void setDouble( double d ){ + type = Double; + uvalue.dval = d; + } + + void setFloat( float f ){ + type = Float; + uvalue.fval = f; + } + + void setInt( int i ){ + type = Int; + uvalue.ival = i; + } + + void setUInt( unsigned int u ){ + type = UInt; + uvalue.uval = u; + } + + void setString( const std::string &s ){ + type = String; + sval = s; + } + + void setVector4( const float *v ); + void setMatrix4( const float *m ); + + double toDouble() const{ return uvalue.dval; } + float toFloat() const{ return uvalue.fval; } + int toInt() const{ return uvalue.ival; } + unsigned int toUInt() const{ return uvalue.uval; } + std::string toString() const{ return sval; } + void getVector4( float *v ) const; + void getMatrix4( float *m ) const; + + bool valueAsString( std::string &s ) const; + void fromString( const std::string &s, EVarType t ); + + EVarType getType() const{ return type; } + + private: + + union{ + double dval; + float fval; + int ival; + unsigned int uval; + float vval[ VARIANT_VVAL_END ]; + }uvalue; + + std::string sval; + + EVarType type; + }; +} + + +#endif + diff --git a/code/nel/src/misc/variant.cpp b/code/nel/src/misc/variant.cpp new file mode 100644 index 000000000..b227ff3db --- /dev/null +++ b/code/nel/src/misc/variant.cpp @@ -0,0 +1,320 @@ +// NeL - MMORPG Framework +// Copyright (C) 2010 Winch Gate Property Limited +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 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 Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + + +#include "nel/misc/variant.h" +#include + + +namespace NLMISC +{ + CVariant::CVariant() + { + std::fill( uvalue.vval, uvalue.vval + VARIANT_VVAL_END, 0.0f ); + type = String; + } + + CVariant::~CVariant() + { + } + + void CVariant::serial( IStream &f ) + { + uint v = f.serialVersion( 1 ); + + f.xmlPush( "type" ); + + if( !f.isReading() ) + { + uint t = type; + f.serial( t ); + } + else + { + uint t; + f.serial( t ); + type = EVarType( t ); + } + + f.xmlPop(); + + f.xmlPush( "value" ); + + switch( type ) + { + case Double: + { + f.serial( uvalue.dval ); + break; + } + + case Float: + { + f.serial( uvalue.fval ); + break; + } + + case Int: + { + f.serial( uvalue.ival ); + break; + } + + case UInt: + { + f.serial( uvalue.uval ); + break; + } + + case String: + { + f.serial( sval ); + break; + } + + } + + + if( !f.isReading() ) + { + switch( type ) + { + case Vector4: + { + float fval; + for( int i = 0; i < 4; i++ ) + { + fval = uvalue.vval[ i ]; + f.serial( fval ); + } + break; + } + + case Matrix4: + { + float fval; + for( int i = 0; i < 16; i++ ) + { + fval = uvalue.vval[ i ]; + f.serial( fval ); + } + break; + } + } + + } + else + { + switch( type ) + { + + case Vector4: + { + float fval; + for( int i = 0; i < 4; i++ ) + { + f.serial( fval ); + uvalue.vval[ i ] = fval; + } + break; + } + + case Matrix4: + { + float fval; + for( int i = 0; i < 16; i++ ) + { + f.serial( fval ); + uvalue.vval[ i ] = fval; + } + break; + } + } + } + + f.xmlPop(); + } + + void CVariant::setVector4( const float *v ) + { + for( int i = 0; i < 4; i++ ) + uvalue.vval[ i ] = v[ i ]; + type = Vector4; + } + + void CVariant::setMatrix4( const float *m ) + { + for( int i = 0; i < 16; i++ ) + uvalue.vval[ i ] = m[ i ]; + type = Matrix4; + } + + void CVariant::getVector4( float *v ) const + { + for( int i = 0; i < 4; i++ ) + v[ i ] = uvalue.vval[ i ]; + } + + void CVariant::getMatrix4( float *m ) const + { + for( int i = 0; i < 16; i++ ) + m[ i ] = uvalue.vval[ i ]; + } + + bool CVariant::valueAsString( std::string &s ) const + { + std::stringstream ss; + + switch( type ) + { + case Double: + { + ss << uvalue.dval; + s = ss.str(); + break; + } + + case Float: + { + ss << uvalue.fval; + s = ss.str(); + break; + } + + case Int: + { + ss << uvalue.ival; + s = ss.str(); + break; + } + + case UInt: + { + ss << uvalue.uval; + s = ss.str(); + break; + } + + case String: + { + s = sval; + break; + } + + case Vector4: + { + for( int i = 0; i < 4; i++ ) + ss << uvalue.vval[ i ] << " "; + s = ss.str(); + s.resize( s.size() - 1 ); + break; + } + + case Matrix4: + { + for( int i = 0; i < 16; i++ ) + ss << uvalue.vval[ i ] << " "; + s = ss.str(); + s.resize( s.size() - 1 ); + break; + } + + default: + { + return false; + break; + } + } + + return true; + } + + + void CVariant::fromString( const std::string &s, EVarType t ) + { + if( s.empty() ) + return; + + switch( t ) + { + case Double: + { + uvalue.dval = strtod( s.c_str(), NULL ); + break; + } + + case Float: + { + uvalue.fval = strtod( s.c_str(), NULL ); + break; + } + + case Int: + { + uvalue.ival = strtod( s.c_str(), NULL ); + break; + } + + case UInt: + { + uvalue.uval = strtod( s.c_str(), NULL ); + break; + } + + case String: + { + sval = s; + break; + } + + case Vector4: + { + std::fill( uvalue.vval, uvalue.vval + VARIANT_VVAL_END, 0.0 ); + std::stringstream ss = s; + + for( int i = 0; i < 4; i++ ) + { + ss >> uvalue.vval[ i ]; + if( !ss.good() ) + break; + } + + break; + } + + case Matrix4: + { + std::fill( uvalue.vval, uvalue.vval + VARIANT_VVAL_END, 0.0 ); + std::stringstream ss = s; + + for( int i = 0; i < 4; i++ ) + { + ss >> uvalue.vval[ i ]; + if( !ss.good() ) + break; + } + break; + } + } + + type = t; + + } + +} + + + diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/material_editor/nel3d_interface.cpp b/code/nel/tools/3d/object_viewer_qt/src/plugins/material_editor/nel3d_interface.cpp index be291b874..013bf9db7 100644 --- a/code/nel/tools/3d/object_viewer_qt/src/plugins/material_editor/nel3d_interface.cpp +++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/material_editor/nel3d_interface.cpp @@ -47,6 +47,33 @@ namespace MaterialEditor "Texture" }; + const NLMISC::CVariant::EVarType evartypes[] = + { + NLMISC::CVariant::Vector4, + NLMISC::CVariant::Vector4, + NLMISC::CVariant::Float, + NLMISC::CVariant::Double, + NLMISC::CVariant::Int, + NLMISC::CVariant::UInt, + NLMISC::CVariant::Matrix4, + NLMISC::CVariant::String + }; + + NLMISC::CVariant::EVarType toEVarType( uint8 t ) + { + NLMISC::CVariant::EVarType rt = NLMISC::CVariant::Float; + + unsigned long s = sizeof( evartypes ) / sizeof( NLMISC::CVariant::EVarType ); + + if( t >= s ) + return rt; + else + rt = evartypes[ t ]; + + return rt; + + } + std::string SMatProp::typeIdToString( unsigned char id ) { if( id >= EType_count ) @@ -74,7 +101,7 @@ namespace MaterialEditor prop.id = p.prop; prop.label = p.label; prop.type = p.type; - prop.value = p.value; + p.value.valueAsString( prop.value ); v.push_back( prop ); } @@ -91,7 +118,7 @@ namespace MaterialEditor p.prop = itr->id; p.label = itr->label; p.type = itr->type; - p.value = itr->value; + p.value.fromString( itr->value, toEVarType( p.type ) ); pass->addProperty( p ); @@ -137,7 +164,7 @@ namespace MaterialEditor p.id = prop->prop; p.label = prop->label; p.type = prop->type; - p.value = prop->value; + prop->value.valueAsString( p.value ); return true; } @@ -148,7 +175,7 @@ namespace MaterialEditor prop.prop = p.id; prop.label = p.label; prop.type = p.type; - prop.value = p.value; + prop.value.fromString( p.value, toEVarType( prop.type ) ); return pass->changeProperty( prop.prop, prop ); }