History: Video Setting Manager

Source of version: 6 (current)

{maketoc}

!Intro
I have developed a manager that tries to encapsulate video settings by mapping them to a descriptive word. This way, you can hide all of the complex GUI settings we see in the initial config box (at least, complex to many end users of our products) behind easy to understand descriptions! It is by no means perfect and I give it here so the community can help improve it. It can be seen in action in my new release of Temple Of Blocs ([http://mangokiwi.com/index.php?option=com_content&task=view&id=1&Itemid=3|See here]).

Also, this was made and tested with Ogre 1.0.5. If someone has gotten this to work with Dagon or later releases, please let us know. TIA.

!!Features:
*refer to a bunch of video settings by a descriptive string ("great!", "decent", etc.)
*save settings to registry on a windows computer <--what is the equivalent on a Mac and on Linux?
*offers handles for menu representation, manipulation.

!The Tutorial format
This tutorial is in two parts. The first part is a walkthrough of the code. I will try to hold your hand and help you understand the workings of the Video Manager. The second part is the 2 code files I believe you will need. If you are impatient or gutsy (or both), you can skip straight to the code at the bottom.

!Part One: Tutorial Mode
Welcome to the tutorial mode. This will walk you through the code to implement a Video Settings Manager of your own.
!!How the settings are stored internally

First things first: how does the program see the settings? How does it convert between the descriptive word to the correct list of settings? How does it know which graphics adapter to use?

To begin answering all of these questions, I direct your attention to the following snippet of code:
{CODE(wrap="1", colors="c++")}STRINGPAIR configOptions;
  
  /** Low Res/Bottomline **/
  mSettingsLbl.push_back("Ugh!");
  // OpenGL
  configOptions.clear();
  configOptions["Colour Depth"]="16";
  configOptions["Display Frequency"]="60";
  configOptions["FSAA"]="0";
  configOptions["Full Screen"]="No";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="640 x 480";
  mSettings_OpenGL[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;
  // DirectX9
  configOptions.clear();
  configOptions["Anti aliasing"]="None";
  configOptions["Floating-point mode"]="Fastest";
  configOptions["Full Screen"]="No";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="640 x 480 @ 16-bit colour";
  mSettings_DX9[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;{CODE}

This is in the constructor of our Video Settings Manager and is how the descriptive word is mapped to the correct settings. Notice that we have three arrays (I am using array ''very'' loosely. These are actually maps. But similar concept). The first is __mSettingsLbl__, which is an array that holds the descriptive words for our video settings (in this case, it now contains the description 'Ugh!', which stands for poor graphics quality).

The second array, __mSettings_OpenGL__ is a string-STRINGPAIR map. What is a string pair? I have created the ''typedef'' __STRINGPAIR__ to mean __~np~std::map<Ogre::String, Ogre::String>~/np~__. In code terms, you will find in VideoSettings.h, 
{CODE(wrap="1", colors="c++")}typedef std::map<Ogre::String, Ogre::String> STRINGPAIR;{CODE}
So the __mSettings_OpenGL__ maps the descriptive word (in this case, 'Ugh!'), to the appropriate settings for if OpenGL is used. Notice the config options mapped are the same you see/get to set when the regular Ogre config box shows up and you choose OpenGL.
In a manner not too different from the OpenGL array, you can see that I populate __mSettings_DX9__ with config options for the 'Ugh!' level graphics for DirectX 9. 
This shows how to map one keyword. I now refer you to the VideoSettings constructor code, where I have defined many such descriptive word - config option pairs for OpenGL and DirectX 9.
{CODE(wrap="1", colors="c++")}VideoSettings::VideoSettings(void)
{
  STRINGPAIR configOptions;
  
  /** Low Res/Bottomline **/
  mSettingsLbl.push_back("Ugh!");
  // OpenGL
  configOptions.clear();
  configOptions["Colour Depth"]="16";
  configOptions["Display Frequency"]="60";
  configOptions["FSAA"]="0";
  configOptions["Full Screen"]="No";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="640 x 480";
  mSettings_OpenGL[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;
  // DirectX9
  configOptions.clear();
  configOptions["Anti aliasing"]="None";
  configOptions["Floating-point mode"]="Fastest";
  configOptions["Full Screen"]="No";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="640 x 480 @ 16-bit colour";
  mSettings_DX9[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;

  /** Decent windowed **/
  mSettingsLbl.push_back("Decent");
  // OpenGL
  configOptions.clear();
  configOptions["Colour Depth"]="32";
  configOptions["Display Frequency"]="60";
  configOptions["FSAA"]="4";
  configOptions["Full Screen"]="No";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="800 x 600";
  mSettings_OpenGL[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;
  // DirectX9
  configOptions.clear();
  configOptions["Anti aliasing"]="None";
  configOptions["Floating-point mode"]="Fastest";
  configOptions["Full Screen"]="No";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="800 x 600 @ 32-bit colour";
  mSettings_DX9[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;

  /** Full Screen decent **/
  mSettingsLbl.push_back("Better");
  // OpenGL
  configOptions.clear();
  configOptions["Colour Depth"]="32";
  configOptions["Display Frequency"]="60";
  configOptions["FSAA"]="4";
  configOptions["Full Screen"]="Yes";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="800 x 600";
  mSettings_OpenGL[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;
  // DirectX9
  configOptions.clear();
  configOptions["Anti aliasing"]="None";
  configOptions["Floating-point mode"]="Fastest";
  configOptions["Full Screen"]="Yes";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="800 x 600 @ 32-bit colour";
  mSettings_DX9[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;

  /** Best for 1024x768 monitors **/
  mSettingsLbl.push_back("Amazing!");
  // OpenGL
  configOptions.clear();
  configOptions["Colour Depth"]="32";
  configOptions["Display Frequency"]="60";
  configOptions["FSAA"]="4";
  configOptions["Full Screen"]="Yes";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="1024 x 768";
  mSettings_OpenGL[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;
  // DirectX9
  configOptions.clear();
  configOptions["Anti aliasing"]="None";
  configOptions["Floating-point mode"]="Fastest";
  configOptions["Full Screen"]="Yes";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="1024 x 768 @ 32-bit colour";
  mSettings_DX9[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;

  /** High Res/Topline **/
  mSettingsLbl.push_back("Mindblowing!");
  // OpenGL
  configOptions.clear();
  configOptions["Colour Depth"]="32";
  configOptions["Display Frequency"]="60";
  configOptions["FSAA"]="16";
  configOptions["Full Screen"]="Yes";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="1280 x 1024";
  mSettings_OpenGL[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;
  // DirectX9
  configOptions.clear();
  configOptions["Anti aliasing"]="None";
  configOptions["Floating-point mode"]="Fastest";
  configOptions["Full Screen"]="Yes";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="1280 x 1024 @ 32-bit colour";
  mSettings_DX9[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;

  LoadSettings();
}{CODE}
This constructor ends with LoadSettings. We will examine what LoadSettings does in the next section.

Look also to page ((RenderWindowParameters)).
!!Loading previously saved settings
So at this point, before trying to load our previously saved settings, we have populated all of the config options and descriptive words we need. It is a good idea to use the same mapping of options to descriptive word(s) as was used when you saved the settings so that you can restore the same settings. So if your user saves the settings at 'Mindblowing!' and then you load the settings so that 'Mindblowing!' is either not mapped, or mapped to something new/different, that will rub your end user the wrong way.
So keep your config options - descriptive words mapping as consistent as you can. (As you can see above, I have hard coded mine into the constructor so it is the same mapping every time--unless I change the code).

Enter __LoadSettings()__. What this function will do is drill down into the registry to find the value you saved last time your program ran (we'll talk about saving to registry later). Before we continue, peruse the code of the __LoadSettings()__ function, presented here:
{CODE(wrap="1", colors="c++")}  bool foundKey = false;
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32    
  HKEY key1, key2, key3;
  DWORD regVal = 0;
  DWORD sizeOfVal = sizeof(DWORD);
  if( RegOpenKeyEx( HKEY_LOCAL_MACHINE, "Software", 0, KEY_READ, &key1 ) == ERROR_SUCCESS )
  {
    if( RegOpenKeyEx( key1, "<<COMPANY NAME>>", 0, KEY_READ, &key2 ) == ERROR_SUCCESS )
    {
      if( RegOpenKeyEx( key2, "<<GAME NAME>>", 0, KEY_READ, &key3 ) == ERROR_SUCCESS )
      {
        if( RegQueryValueEx( key3, "Video Setting", 0, NULL, (LPBYTE)&regVal, (LPDWORD)&sizeOfVal ) == ERROR_SUCCESS )
        {
          foundKey = true;
          mCurSetting = static_cast<unsigned int> (regVal);
        }
      }
    }
  }
  RegCloseKey( key3 );
  RegCloseKey( key2 );
  RegCloseKey( key1 );
#endif
  if( !foundKey )
  {
    mCurSetting = 0;
  }
  
  if( mCurSetting >= mSettingsLbl.size() ) 
  {
    mCurSetting = static_cast<unsigned int>(mSettingsLbl.size()-1);
  }
  if( mCurSetting < 0 )
  {
    mCurSetting = 0;
  }
  mCurCycleSetting = mCurSetting;{CODE}

Note that I have cordoned off the registry loading section to Windows only versions. __If you know how to do something similar for other Operating Systems, please post that here and in the 'Saving Your Video Settings' section.__

Assuming we are developing for Windows, the above presented code drills into the windows registry to find your saved setting. According to what I learned about Registry best practices, you should access the following folder only for each Game you make that accesses registry: '{MONO()}~np~HKEY_LOCAL_MACHINE\Software\<<COMPANY NAME>>\<<GAME NAME>>~/np~{MONO} (of course, replacing COMPANY NAME and GAME NAME with your personalized info. In this GAME NAME folder in the registry you may store registry values. This is where the VideoSettings stores, and there for looks for, the "Video Setting" value. It is stored as an int, which is an index into the __mSettingsLbl__ array which we discussed in the 'How Settings Are Stored Internally' section above. Having loaded (or not loaded) the Video Settings integer, the __LoadSettings()__ function continues on to cap the int to the size of the __mSettingsLbl__ array (so when we access that index we don't get a seg_fault or index out of bounds or what have you).

We leave the __LoadSettings()__ function with an integer that represents a certain quality of video. Now how to actually load this quality to our game?

!!Setting the Video Quality
Todo: Describe how the code actually sets the video quality in Ogre.
!!Changing the Video Quality

Todo: Describe 'cycling' and the difference between changing video and setting video quality
!!Saving Your Video Settings

Todo: Describe the process of Saving to the registry
!!What the Rest of Your System Needs

Todo: Describe functionality that must be worked into the rest of the system for this code to work as it should

!Part Two: Code Mode
You will find the two files essential to implementing the Video Settings Manager below. If you need help with understanding the code, read the tutorial mode above. If you still need help, contact me. I am __admin__ at __mangokiwi.com__
!VideoSettings.h:
{CODE(wrap="1", colors="c++")}#ifndef ___VIDEOSETTINGS_H___
#define ___VIDEOSETTINGS_H___

#include "OgreSingleton.h"

/**
 * \class VideoSettings
 *
 * Handles setting the video resolution, color depth, etc. and simplifies it
 * to show the user.
 *
 * Also handles loading/saving current video settings
 *
 */

typedef std::map<Ogre::String, Ogre::String> STRINGPAIR;

class VideoSettings: public Ogre::Singleton<VideoSettings>
{
public:
  VideoSettings(void);
  ~VideoSettings(void);

  /**
   * Sets the video settings on the default render window
   *
   * \returns true if successful, else false
   * \note what to do if desired setting not found?
   *
   */
  bool SetSettings( void );

  /**
   * Saves the video settings 
   *
   * \notes currently saves to registry.  When porting to other OS, change this
   * 
   */
  void SaveSettings( void );

  /**
   * Cycles to the next video setting option
   *
   * \param cycleRight true if you want to cycle right along the options, else cycles left
   * \returns name of the new option
   *
   */
  Ogre::String CycleSettings( bool cycleRight = true );

  /** 
   * Undoes cycle changes as long as they werent pushed through
   *
   */
  void UndoCycleChanges( void );

  /**
   * Getter for the current video quality cycled to
   *
   * \returns the description of the current video quality cycled to
   *
   */
  Ogre::String getCurrentVideoQuality( void );

  /** 
   * Call this to find out if video settings need to be reset
   *
   * \returns true if video settings need to be reset, else false
   *
   */
  bool NeedVideoReset( void );

  static VideoSettings& getSingleton(void);
    static VideoSettings* getSingletonPtr(void);
protected:
  /**
   * Load the settings last set (successfully)
   *
   */
  void LoadSettings( void );

  /**
   * Applies a specific config option, first searching to see if it is available
   *
   * \params renderSystem system on which the options need to be set
   * \params optionName name of config option to set
   * \params optionVal value of config option to set
   * \returns true if the config option was available
   *
   */
  bool SetConfigOption( Ogre::RenderSystem * renderSystem, 
    const Ogre::String& optionName, const Ogre::String& optionVal );

  /// The number of the current setting
  unsigned int mCurSetting;
  /// The number of the current setting according to the user during setting cycling
  int mCurCycleSetting;
  /// The Types of settings possible (user readable)
  std::vector<Ogre::String> mSettingsLbl;
  /// The settings map to use if rendersystem is directx
  std::map<Ogre::String, STRINGPAIR > mSettings_DX9;
  /// The settings map to use if rendersystem is opengl
  std::map<Ogre::String, STRINGPAIR > mSettings_OpenGL;
};

#endif //___VIDEOSETTINGS_H___{CODE}

!VideoSettings.cpp:
{CODE(wrap="1", colors="c++")}#include "Ogre.h"
#include "videosettings.h"

#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32 
#include "windows.h"
#include "winreg.h"
#endif

template<> VideoSettings* Ogre::Singleton<VideoSettings>::ms_Singleton = 0;

VideoSettings::VideoSettings(void)
{
  STRINGPAIR configOptions;
  
  /** Low Res/Bottomline **/
  mSettingsLbl.push_back("Ugh!");
  // OpenGL
  configOptions.clear();
  configOptions["Colour Depth"]="16";
  configOptions["Display Frequency"]="60";
  configOptions["FSAA"]="0";
  configOptions["Full Screen"]="No";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="640 x 480";
  mSettings_OpenGL[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;
  // DirectX9
  configOptions.clear();
  configOptions["Anti aliasing"]="None";
  configOptions["Floating-point mode"]="Fastest";
  configOptions["Full Screen"]="No";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="640 x 480 @ 16-bit colour";
  mSettings_DX9[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;

  /** Decent windowed **/
  mSettingsLbl.push_back("Decent");
  // OpenGL
  configOptions.clear();
  configOptions["Colour Depth"]="32";
  configOptions["Display Frequency"]="60";
  configOptions["FSAA"]="4";
  configOptions["Full Screen"]="No";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="800 x 600";
  mSettings_OpenGL[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;
  // DirectX9
  configOptions.clear();
  configOptions["Anti aliasing"]="None";
  configOptions["Floating-point mode"]="Fastest";
  configOptions["Full Screen"]="No";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="800 x 600 @ 32-bit colour";
  mSettings_DX9[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;

  /** Full Screen decent **/
  mSettingsLbl.push_back("Better");
  // OpenGL
  configOptions.clear();
  configOptions["Colour Depth"]="32";
  configOptions["Display Frequency"]="60";
  configOptions["FSAA"]="4";
  configOptions["Full Screen"]="Yes";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="800 x 600";
  mSettings_OpenGL[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;
  // DirectX9
  configOptions.clear();
  configOptions["Anti aliasing"]="None";
  configOptions["Floating-point mode"]="Fastest";
  configOptions["Full Screen"]="Yes";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="800 x 600 @ 32-bit colour";
  mSettings_DX9[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;

  /** Best for 1024x768 monitors **/
  mSettingsLbl.push_back("Amazing!");
  // OpenGL
  configOptions.clear();
  configOptions["Colour Depth"]="32";
  configOptions["Display Frequency"]="60";
  configOptions["FSAA"]="4";
  configOptions["Full Screen"]="Yes";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="1024 x 768";
  mSettings_OpenGL[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;
  // DirectX9
  configOptions.clear();
  configOptions["Anti aliasing"]="None";
  configOptions["Floating-point mode"]="Fastest";
  configOptions["Full Screen"]="Yes";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="1024 x 768 @ 32-bit colour";
  mSettings_DX9[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;

  /** High Res/Topline **/
  mSettingsLbl.push_back("Mindblowing!");
  // OpenGL
  configOptions.clear();
  configOptions["Colour Depth"]="32";
  configOptions["Display Frequency"]="60";
  configOptions["FSAA"]="16";
  configOptions["Full Screen"]="Yes";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="1280 x 1024";
  mSettings_OpenGL[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;
  // DirectX9
  configOptions.clear();
  configOptions["Anti aliasing"]="None";
  configOptions["Floating-point mode"]="Fastest";
  configOptions["Full Screen"]="Yes";
  configOptions["VSync"]="Yes";
  configOptions["Video Mode"]="1280 x 1024 @ 32-bit colour";
  mSettings_DX9[ mSettingsLbl[mSettingsLbl.size()-1] ]=configOptions;

  LoadSettings();
}

VideoSettings::~VideoSettings(void)
{
}

VideoSettings* VideoSettings::getSingletonPtr(void)
{
    return ms_Singleton;
}

VideoSettings& VideoSettings::getSingleton(void)
{  
    assert(ms_Singleton);
    return *ms_Singleton;
}

void VideoSettings::LoadSettings( void )
{
  bool foundKey = false;
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32    
  HKEY key1, key2, key3;
  DWORD regVal = 0;
  DWORD sizeOfVal = sizeof(DWORD);
  if( RegOpenKeyEx( HKEY_LOCAL_MACHINE, "Software", 0, KEY_READ, &key1 ) == ERROR_SUCCESS )
  {
    if( RegOpenKeyEx( key1, "<<COMPANY NAME>>", 0, KEY_READ, &key2 ) == ERROR_SUCCESS )
    {
      if( RegOpenKeyEx( key2, "<<GAME NAME>>", 0, KEY_READ, &key3 ) == ERROR_SUCCESS )
      {
        if( RegQueryValueEx( key3, "Video Setting", 0, NULL, (LPBYTE)&regVal, (LPDWORD)&sizeOfVal ) == ERROR_SUCCESS )
        {
          foundKey = true;
          mCurSetting = static_cast<unsigned int> (regVal);
        }
      }
    }
  }
  RegCloseKey( key3 );
  RegCloseKey( key2 );
  RegCloseKey( key1 );
#endif
  if( !foundKey )
  {
    mCurSetting = 0;
  }
  
  if( mCurSetting >= mSettingsLbl.size() ) 
  {
    mCurSetting = static_cast<unsigned int>(mSettingsLbl.size()-1);
  }
  if( mCurSetting < 0 )
  {
    mCurSetting = 0;
  }
  mCurCycleSetting = mCurSetting;
}

bool VideoSettings::SetSettings( void )
{
  mCurSetting = mCurCycleSetting;
  Ogre::RenderSystemList *rsList = Ogre::Root::getSingleton().getAvailableRenderers();
  Ogre::RenderSystem *selectedRenderSystem = NULL;
  bool foundit = false;
  for( int c = 0; c<(int)rsList->size(); c++ )
  {
    selectedRenderSystem = rsList->at(c);
    Ogre::String rname = selectedRenderSystem->getName();
    if(rname.compare("Direct3D9 Rendering SubSystem")==0)
    {
      foundit=true;
      break;
    }
  }
  if(!foundit)
  {
    // didnt find it so look for open gl
    for( int c = 0; c<(int)rsList->size(); c++ )
    {
      selectedRenderSystem = rsList->at(c);
      Ogre::String rname = selectedRenderSystem->getName();
      if(rname.compare("OpenGL Rendering Subsystem")==0)
      {
        foundit=true;
        break;
      }
    }
    if( !foundit )
    {
      return false; //we didn't find it...
    }
  }

  if( selectedRenderSystem->getName().compare("OpenGL Rendering Subsystem")==0 )
  {
    STRINGPAIR settings = (mSettings_OpenGL.find( mSettingsLbl[mCurSetting] ))->second;
    for( STRINGPAIR::iterator start = settings.begin(); 
      start!=settings.end(); start++ )
    {
      SetConfigOption( selectedRenderSystem, start->first, start->second );
    }
  }
  else if( selectedRenderSystem->getName().compare("Direct3D9 Rendering SubSystem")==0 )
  {
    STRINGPAIR settings = (mSettings_DX9.find( mSettingsLbl[mCurSetting] ))->second;
    for( STRINGPAIR::iterator start = settings.begin(); 
      start!=settings.end(); start++ )
    {
      SetConfigOption( selectedRenderSystem, start->first, start->second );
    }
  }
  
  //we found it, we might as well use it!
  Ogre::Root::getSingleton().setRenderSystem(selectedRenderSystem);
 
  return true;
}

bool VideoSettings::SetConfigOption( Ogre::RenderSystem * renderSystem, 
                                    const Ogre::String& optionName, 
                                    const Ogre::String& optionVal )
{
  //retrieve the config option map
  Ogre::ConfigOptionMap comap = renderSystem->getConfigOptions();
    
  for( Ogre::ConfigOptionMap::const_iterator start = comap.begin(); start!=comap.end(); start++ )
  {
    Ogre::String mapOptionName = start->first;
    
    if( strcmp( mapOptionName.c_str(), optionName.c_str() ) == 0 )
    {
      //found our config option
      Ogre::String currentValue = start->second.currentValue;
      Ogre::StringVector possibleValues = start->second.possibleValues;
      bool foundAsPossible = false;
      for( int c=0; c<(int)possibleValues.size(); c++ )
      {
        if( strcmp( possibleValues.at(c).c_str(), optionVal.c_str() ) == 0 )
        {
          foundAsPossible = true;
          break;
        }
      }
      if( foundAsPossible )
      {
        renderSystem->setConfigOption( optionName, optionVal );
        return true;
      }
    }    
  }
  return false;
}

Ogre::String VideoSettings::CycleSettings( bool cycleRight )
{
  if( cycleRight )
  {
    if( (++mCurCycleSetting)>=(int)mSettingsLbl.size() )
    {
      mCurCycleSetting = 0;
    }
  }
  else
  {
    if( (--mCurCycleSetting)<0 )
    {
      mCurCycleSetting = (int)(mSettingsLbl.size())-1;
    }
  }
  return mSettingsLbl[mCurCycleSetting];
}

void VideoSettings::UndoCycleChanges( void )
{
  mCurCycleSetting = mCurSetting;
}

Ogre::String VideoSettings::getCurrentVideoQuality( void )
{
  if( (mCurCycleSetting < 0) || (mCurCycleSetting >= (int)mSettingsLbl.size()) )
  {
    return Ogre::StringUtil::BLANK;
  }
  return mSettingsLbl[mCurCycleSetting];
}

void VideoSettings::SaveSettings( void )
{
  if( mCurSetting == mCurCycleSetting )
  {
    //no changes
    return;
  }
  mCurSetting = mCurCycleSetting;

#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32    
  HKEY key1, key2, key3;
  int regVal = 0;
  if( RegCreateKeyEx( HKEY_LOCAL_MACHINE, "Software", 0, NULL, REG_OPTION_NON_VOLATILE, 
    KEY_CREATE_SUB_KEY, NULL, &key1, NULL ) == ERROR_SUCCESS )
  {
    if( RegCreateKeyEx( key1, "<<COMPANY NAME>>", 0, NULL, REG_OPTION_NON_VOLATILE, 
      KEY_CREATE_SUB_KEY, NULL, &key2, NULL ) == ERROR_SUCCESS )
    {
      if( RegCreateKeyEx( key2, "<<GAME NAME>>", 0, NULL, REG_OPTION_NON_VOLATILE, 
        KEY_SET_VALUE, NULL, &key3, NULL ) == ERROR_SUCCESS )
      {
        if( RegSetValueEx( key3, "Video Setting", 0, REG_DWORD, (LPBYTE)&mCurSetting, sizeof(DWORD) ) == ERROR_SUCCESS )
        {
        }
      }
    }
  }
  RegCloseKey( key3 );
  RegCloseKey( key2 );
  RegCloseKey( key1 );
#endif
}

bool VideoSettings::NeedVideoReset( void )
{
  if( mCurSetting == mCurCycleSetting )
  {
    return false;
  }
  return true;
}{CODE}

!Questions?
If you have questions, please contact me at __admin__ at __mangokiwi.com__.

by Diwant Vaidya,
[http://www.mangokiwi.com|mangokiwi.com]
Shareware games for the PC!
History: Video Setting Manager

Source of version: 6 (current)

Search by Tags

Latest Changes

Search

Online Users
