void GraphicsSystem::SetProperties( Properties::Array Properties ) { ASSERT( m_bInitialized ); // // Read in the properties. // for ( Properties::Iterator it=Properties.begin(); it != Properties.end(); it++ ) { if ( it->GetFlags() & Properties::Flags::Valid ) { std::string sName = it->GetName(); if ( sName == sm_kapszPropertyNames[ Property_Resolution ] ) { u32 Width = static_cast<u32>(it->GetInt32( 0 )); u32 Height = static_cast<u32>(it->GetInt32( 1 )); //m_pRenderWindow->resize( Width, Height ); } else { ASSERT( False ); } // // Set this property to invalid since it's already been read. // it->ClearFlag( Properties::Flags::Valid ); } } }
void InputObject::GetProperties( Properties::Array& Properties ) { // // Get the index of our first item. // i32 iProperty = static_cast<i32>(Properties.size()); // // Add all the properties. // Properties.reserve( Properties.size() + Property_Count ); for ( i32 i=0; i < Property_Count; i++ ) { Properties.push_back( sm_kaDefaultProperties[ i ] ); } // // Modify the default values. // Properties[iProperty + Property_FKey].SetValue(0, m_nFunctionKey); }
void GeometryObject::GetProperties( Properties::Array& Properties ) { // // Get the index of our first item. // i32 iProperty = static_cast<i32>(Properties.size()); // // Add all the properties. // Properties.reserve( Properties.size() + Property_Count ); for ( i32 i=0; i < Property_Count; i++ ) { Properties.push_back( sm_kaDefaultProperties[ i ] ); } // // Modify the default values. // Properties[ iProperty+Property_Position ].SetValue( m_Position ); Properties[ iProperty+Property_Orientation ].SetValue( m_Orientation ); Properties[ iProperty+Property_Scale ].SetValue( m_Scale ); }
void InputObject::SetProperties( Properties::Array Properties ) { ASSERT( m_bInitialized ); Error Err; Err = Errors::Failure; // // Read in the properties. // for ( Properties::Iterator it=Properties.begin(); it != Properties.end(); it++ ) { if ( it->GetFlags() & Properties::Flags::Valid ) { std::string sName = it->GetName(); if ( sName == sm_kapszPropertyNames[Property_FKey] ) { m_nFunctionKey = it->GetInt32(0); } else if ( sName == sm_kapszPropertyNames[Property_Orientation] ) { m_Yaw = it->GetFloat32(0); m_Pitch = it->GetFloat32(1); m_Roll = it->GetFloat32(2); m_Orientation.x = m_Yaw; m_Orientation.y = m_Pitch; m_Orientation.z = 0; m_Orientation.w = 0; PostChanges(System::Changes::Geometry::Orientation); } else { ASSERT(False); } // // Set this property to invalid since it's already been read. // it->ClearFlag(Properties::Flags::Valid); } } }
void OGREGraphicsObjectCamera::GetProperties( Properties::Array& Properties ) { // // Get the index of our first item. // i32 iProperty = static_cast<i32>(Properties.size()); // // Add all the properties. // Properties.reserve( Properties.size() + Property_Count ); for (auto & property : sm_kaDefaultProperties) { Properties.push_back( property ); } // // Set the enum options string array. // Properties[ iProperty+Property_PolygonMode ].SetEnumOptions( sm_kapszPolygonModeEnumOptions ); // // Modify the default values. // if ( m_pCamera != nullptr ) { Properties[ iProperty+Property_FOVy ].SetValue( 0, m_pCamera->getFOVy().valueRadians() ); Properties[ iProperty+Property_ClipDistances ].SetValue( 0, m_pCamera->getNearClipDistance() ); Properties[ iProperty+Property_ClipDistances ].SetValue( 1, m_pCamera->getFarClipDistance() ); Ogre::Vector3 Position = m_pCamera->getPosition(); Properties[ iProperty+Property_Position ].SetValue( 0, Position.x ); Properties[ iProperty+Property_Position ].SetValue( 1, Position.y ); Properties[ iProperty+Property_Position ].SetValue( 2, Position.z ); Properties[ iProperty+Property_PolygonMode ].SetValue( 0, m_PolygonMode ); } }
void GraphicsSystem::GetProperties( Properties::Array& Properties ) { // // Get the index of our first item. // i32 iProperty = static_cast<i32>(Properties.size()); // // Add all the properties. // Properties.reserve( Properties.size() + Property_Count ); for ( i32 i=0; i < Property_Count; i++ ) { Properties.push_back( sm_kaDefaultProperties[ i ] ); } }
void GeometryObject::SetProperties( Properties::Array Properties ) { ASSERT( m_bInitialized ); // // Read in the properties. // for ( Properties::Iterator it=Properties.begin(); it != Properties.end(); it++ ) { std::string sName = it->GetName(); if ( it->GetFlags() & Properties::Flags::Valid ) { if ( sName == sm_kapszPropertyNames[ Property_Position ] ) { m_Position = it->GetVector3(); PostChanges( System::Changes::Geometry::Position ); } else if ( sName == sm_kapszPropertyNames[ Property_Orientation ] ) { m_Orientation = it->GetQuaternion(); PostChanges( System::Changes::Geometry::Orientation ); } else if ( sName == sm_kapszPropertyNames[ Property_Scale ] ) { m_Scale = it->GetVector3(); PostChanges( System::Changes::Geometry::Scale ); } else { ASSERT( False ); } // // Set this property to invalid since it's already been read. // it->ClearFlag( Properties::Flags::Valid ); } } }
Error GraphicsSystem::Initialize( Properties::Array Properties ) { ASSERT( !m_bInitialized ); // Read in the properties required to initialize Ogre. // char szWindowName[ 256 ] = "Window"; u32 Width = 1280; u32 Height = 1024; Bool bFullScreen = False; Bool bVerticalSync = True; std::string dFSAAType = "0"; //D3DMULTISAMPLE_NONE; std::string dFSAAQuality = "0"; for ( Properties::Iterator it=Properties.begin(); it != Properties.end(); it++ ) { // // Make sure this property is valid. // if ( it->GetFlags() & Properties::Flags::Valid ) { std::string sName = it->GetName(); if ( sName == sm_kapszPropertyNames[ Property_ResourceLocation ] ) { pcstr pszName = it->GetStringPtr( 0 ); pcstr pszLocationType = it->GetStringPtr( 1 ); pcstr pszResourceGroup = it->GetStringPtr( 2 ); Bool bRecursive = it->GetBool( 3 ); /*m_pResourceGroupManager->addResourceLocation( pszName, pszLocationType, pszResourceGroup, (bRecursive == True) ); m_pResourceGroupManager->loadResourceGroup( pszResourceGroup );*/ } else if ( sName == sm_kapszPropertyNames[ Property_WindowName ] ) { strcpy_s( szWindowName, sizeof szWindowName, it->GetStringPtr( 0 ) ); } else if ( sName == sm_kapszPropertyNames[ Property_Resolution ] ) { Width = static_cast<u32>(it->GetInt32( 0 )); Height = static_cast<u32>(it->GetInt32( 1 )); } else if ( sName == sm_kapszPropertyNames[ Property_ShadowTextureCount ] ) { m_uShadowTextureCount = static_cast<u16>(it->GetInt32( 0 )); } else if ( sName == sm_kapszPropertyNames[ Property_ShadowTextureSize ] ) { m_uShadowTextureSize = static_cast<u16>(it->GetInt32( 0 )); } else if ( sName == sm_kapszPropertyNames[ Property_FullScreen ] ) { bFullScreen = it->GetBool( 0 ); } else if ( sName == sm_kapszPropertyNames[ Property_VerticalSync ] ) { bVerticalSync = it->GetBool( 0 ); } else if ( sName == sm_kapszPropertyNames[ Property_FSAntiAliasing ] ) { dFSAAType = it->GetString( 0 ); dFSAAQuality = it->GetString( 1 ); } // // Set this property to invalid since it's already been read. // it->ClearFlag( Properties::Flags::Valid ); } } // // Command line overrides // { USES_CONVERSION; WCHAR** argv; int argc, iArg; argv = CommandLineToArgvW( GetCommandLineW(), &argc); for(iArg=0; iArg<argc; iArg++) { switch (*argv[iArg]) { case '-': case '/': { if (0==_wcsicmp(argv[iArg]+1, L"windowed" )) bFullScreen = False; } break; default: { } } } LocalFree(argv); } // // Intialize the render system and render window. // // Setup the Full-screen Anti-Aliasing mode std::map<std::string, std::string> params; params[ "FSAA" ] = dFSAAType; params[ "FSAAQuality" ] = dFSAAQuality; m_bInitialized = True; // // Set the remaining properties. // SetProperties( Properties ); return Errors::Success; }
void GraphicsScene::SetProperties( Properties::Array Properties ) { ASSERT( m_bInitialized ); // // Read in the properties. // for ( Properties::Iterator it=Properties.begin(); it != Properties.end(); it++ ) { if ( it->GetFlags() & Properties::Flags::Valid ) { std::string sName = it->GetName(); if ( sName == sm_kapszPropertyNames[ Property_AmbientLight ] ) { // // Set the scene's ambient light. // ColourValue AmbientLight; AmbientLight.a = 1.0f; AmbientLight.r = it->GetColor3().r; AmbientLight.g = it->GetColor3().g; AmbientLight.b = it->GetColor3().b; } else if ( sName == sm_kapszPropertyNames[ Property_Shadows ] ) { // // Enable/disable shadows. // } else if ( sName == sm_kapszPropertyNames[ Property_ShadowColor ] ) { // // Set the scene's shadow color. // ColourValue ShadowColor; ShadowColor = ColourValue( it->GetColor3().r, it->GetColor3().g, it->GetColor3().b ); } else if ( sName == sm_kapszPropertyNames[ Property_DrawBoundingBox ] ) { // // Enable/disable the drawing of Object BoundingBoxes. // } else { ASSERT( False ); } // // Set this property to invalid since it's already been read. // it->ClearFlag( Properties::Flags::Valid ); } } }
Error GraphicsScene::Initialize( Properties::Array Properties ) { Error Err = Errors::Success; ASSERT( !m_bInitialized ); m_pTask = new GraphicsTask( this ); ASSERT( m_pTask != NULL ); // // Set this set as initialized. // m_bInitialized = True; // // Read the properties. // for ( Properties::Iterator it=Properties.begin(); it != Properties.end(); it++ ) { if ( it->GetFlags() & Properties::Flags::Valid && it->GetFlags() & Properties::Flags::InitOnly) { std::string sName = it->GetName(); if ( sName == sm_kapszPropertyNames[ Property_ResourceLocation ] ) { pcstr pszName = it->GetStringPtr( 0 ); pcstr pszLocationType = it->GetStringPtr( 1 ); pcstr pszResourceGroup = it->GetStringPtr( 2 ); Bool bRecursive = it->GetBool( 3 ); } else if ( sName == sm_kapszPropertyNames[ Property_DelResourceLocation ] ) { pcstr pszName = it->GetStringPtr( 0 ); pcstr pszResourceGroup = it->GetStringPtr( 1 ); } else if ( sName == sm_kapszPropertyNames[ Property_UseStaticGeom ] ) { m_bUseStaticGeom = it->GetBool( 0 ); } else if ( sName == sm_kapszPropertyNames[ Property_UseInstancedGeom ] ) { m_bUseInstancedGeom = it->GetBool( 0 ); } else if ( sName == sm_kapszPropertyNames[ Property_FogColor ] ) { m_FogColor.r = it->GetColor3().r; m_FogColor.g = it->GetColor3().g; m_FogColor.b = it->GetColor3().b; } else if ( sName == sm_kapszPropertyNames[ Property_Fog ] ) { i32 mode = it->GetInt32(0); switch ( mode ) { case 1: m_FogMode = ::FOG_EXP; break; case 2: m_FogMode = ::FOG_EXP2; break; case 3: m_FogMode = ::FOG_LINEAR; break; default: m_FogMode = ::FOG_NONE; break; } m_ExpDensity = it->GetFloat32(1); m_LinearStart = it->GetFloat32(2); m_LinearEnd = it->GetFloat32(3); } else if ( sName == sm_kapszPropertyNames[ Property_Font ] ) { //------------------------------------------------------------------------- // Here is where we load the "default" font into the resource system. We don't need // to keep any references to the resource around as it will be accessed by name by anyone // who needs the resource. // std::string sPath = it->GetString(0); std::string sFile = it->GetString(1); } // // Load the paged geometry information. This is broken up between three areas. Here, the camera, // and the individual layers in ObjectPagedGeometryLayer.cpp. Here, we initialize the system and // load general information that will be shared between all layers. In ObjectCamera the camera // needs to be associated with PagedGeometry. There can be multiple layers (e.g. grass, rocks, flowers) // so they are taken care of as their own objects. // else if ( sName == sm_kapszPropertyNames[ Property_PagedGeometry ] ) { // Terrain Setting } else { ASSERT( False ); } // // Set this property to invalid since it's already been read. // it->ClearFlag( Properties::Flags::Valid ); } } // // Intialize any resource groups added by the scene // // // Set the properties for this scene. // SetProperties( Properties ); // // Set some of the shadow properties even though shadows might be disabled. // // Shadow Setting //------------------------------------------------------------------------- // This is where we "create" the overlay manager by retrieving its pointer. We // also create one overlay which is currently the only one in the system. All // overlay elements are currently attached to it. // //------------------------------------------------------------------------- // Here we set the fog properties for the scene // return Err; }