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);
        }
    }
}
Example #5
0
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;
}