//---------------------------------------------------------------------------
void TutorialApplication::createScene()
{
	mSceneMgr->setAmbientLight(Ogre::ColourValue(.2f, .2f, .2f));

	Ogre::Entity* tudorEntity = mSceneMgr->createEntity("tudorhouse.mesh");
	Ogre::SceneNode* node = mSceneMgr->getRootSceneNode()->createChildSceneNode(
		"Node");
	node->attachObject(tudorEntity);

	Ogre::Light* light = mSceneMgr->createLight("Light1");
	light->setType(Ogre::Light::LT_POINT);
	light->setPosition(Ogre::Vector3(250, 150, 250));
	light->setDiffuseColour(Ogre::ColourValue::White);
	light->setSpecularColour(Ogre::ColourValue::White);

	node = mSceneMgr->getRootSceneNode()->createChildSceneNode(
		"CamNode1", Ogre::Vector3(1200, -370, 0));
	node->yaw(Ogre::Degree(90));

	mCamNode = node;
	node->attachObject(mCamera);

	node = mSceneMgr->getRootSceneNode()->createChildSceneNode(
		"CamNode2", Ogre::Vector3(-500, -370, 1000));
	node->yaw(Ogre::Degree(-30));

}
Esempio n. 2
0
void DemoState::onStart()
{
    //shared_ptr<Grid> grid = make_shared<Grid>(1000.0f, 10.0f);
    GameManager::getSingleton().addObject(make_shared<HeadsUpDisplay>());
    GameManager::getSingleton().addObject(make_shared<OverheadCameraMan>());
    GameManager::getSingleton().addObject(make_shared<Background>());
    //GameManager::getSingleton().addObject(grid);

    /*
    GameManager::getSingleton().addObject(make_shared<Ship>());
    GameManager::getSingleton().addObject(make_shared<Ship>());
    GameManager::getSingleton().addObject(make_shared<Ship>());
    shared_ptr<Planet> planet = make_shared<Planet>();
    planet->setPosition(Ogre::Vector3(10, 0, 0));
    GameManager::getSingleton().addObject(planet);
    */

    shared_ptr<AsteroidField> asteroidField = make_shared<AsteroidField>();
    asteroidField->setPosition(Ogre::Vector3(10, 0, 0));
    GameManager::getSingleton().addObject(asteroidField);

    getScene()->setAmbientLight(Ogre::ColourValue(0.2f, 0.2f, 0.3f));
    Ogre::Light* light = getScene()->createLight("MainLight");
    light->setPosition(20, 80, 50);

}
Esempio n. 3
0
void Application::setupScene()
{
    mOgreScene = Ogre::Root::getSingleton().createSceneManager("OctreeSceneManager");
    mOgreScene->setAmbientLight(Ogre::ColourValue::Black);

    mOgreCamera = mOgreScene->createCamera("Camera");
	mOgreCamera->setNearClipDistance(0.1f);
	mOgreCamera->setFarClipDistance(1000.0f);

	Ogre::Viewport* viewport = mOgreWindow->addViewport(mOgreCamera);
    mOgreCamera->setAspectRatio(Ogre::Real(viewport->getActualWidth()) / Ogre::Real(viewport->getActualHeight()));
    mOgreCamera->setPosition(0, 0, 0);

    mOgreFloor = mOgreScene->createEntity("Floor", "plocha.mesh");
    mOgreScene->getRootSceneNode()->attachObject(mOgreFloor);

    Ogre::Light* light = mOgreScene->createLight("Light");
    light->setType(Ogre::Light::LT_POINT);
    
    mOgreChopterNode = mOgreScene->getRootSceneNode()->createChildSceneNode("ChopterNode");
    mOgreChopterNode->setPosition(0, 20, 0);
    mOgreChopterNode->attachObject(mOgreCamera);
    mOgreChopterNode->attachObject(light);
    mOgreChopterNode->setFixedYawAxis(true);
}
Esempio n. 4
0
void GameState::enter() {
  OgreFramework::getSingletonPtr()->m_pLog->logMessage("Entering GameState...");
 
  m_pSceneMgr = OgreFramework::getSingletonPtr()->m_pRoot->createSceneManager(ST_GENERIC, "GameSceneMgr");
  m_pSceneMgr->setAmbientLight(Ogre::ColourValue(0.4f, 0.4f, 0.4f));
  m_pSceneMgr->setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_ADDITIVE);
  Ogre::Light* dirLight = m_pSceneMgr->createLight("dirLight");
  dirLight->setType(Ogre::Light::LT_DIRECTIONAL);
  dirLight->setDiffuseColour(Ogre::ColourValue(0.4f, 0.4f, 0.4f));
  dirLight->setSpecularColour(Ogre::ColourValue(0.4f, 0.4f, 0.4f));
  dirLight->setDirection(Ogre::Vector3(0, -1, 0));
 
  m_pCamera = m_pSceneMgr->createCamera("GameCam");
  m_pCamera->setPosition(Vector3(0, 15, -300));
  m_pCamera->lookAt(Vector3(0, 15, 0));
  m_pCamera->setNearClipDistance(1);
 
  m_pCamera->setAspectRatio(Real(OgreFramework::getSingletonPtr()->m_pViewport->getActualWidth()) / Real(OgreFramework::getSingletonPtr()->m_pViewport->getActualHeight()));

  limit = 0.0;

  OgreFramework::getSingletonPtr()->m_pViewport->setCamera(m_pCamera);

  // create an imageset for the face portrait
  CEGUI::ImagesetManager *im = &(CEGUI::ImagesetManager::getSingleton());
  CEGUI::NamedXMLResourceManager<CEGUI::Imageset, CEGUI::Imageset_xmlHandler> *castedIm = NULL;
  castedIm = (CEGUI::NamedXMLResourceManager<CEGUI::Imageset, CEGUI::Imageset_xmlHandler>*) im;
  castedIm->create( "Face.imageset" );

  // hide cursor
  CEGUI::MouseCursor::getSingleton().hide();

  createScene();
}
Esempio n. 5
0
Star::Star(int temperature, double radius, Ogre::SceneNode *systemNode, Ogre::SceneManager *sceneMgr, int x, int y) {
	kelvin = temperature;
	radius = radius;
	int rand2 = rand()%1000;
	double colorEvener = 0.35;

	std::string starNodeName = "Star" + Ogre::StringConverter::toString(temperature) + Ogre::StringConverter::toString(rand2);
	std::string starParticleName = "starParticle" + Ogre::StringConverter::toString(temperature) + Ogre::StringConverter::toString(rand2);
	std::string starParticleNodeName = "starParticleNode" + Ogre::StringConverter::toString(temperature) + Ogre::StringConverter::toString(rand2);

	starNode = systemNode->createChildSceneNode(starNodeName, Ogre::Vector3(0,0,0));

	//Particle Gen
	Ogre::ParticleSystem* starParticle = sceneMgr->createParticleSystem(starParticleName, "StarWhite");
	Ogre::SceneNode* particleNode = systemNode->createChildSceneNode(starParticleNodeName,Ogre::Vector3((-0.5+x),(0+y),0.5));
	particleNode->attachObject(starParticle);
	setColor(color);
	starParticle->getEmitter(0)->setColour(Ogre::ColourValue(color[0]*colorEvener,color[1]*colorEvener,color[2]*colorEvener,color[3]));

	//Light Gen
	Ogre::SceneNode* lightNode = NULL;
	Ogre::Light* lightPoint = sceneMgr->createLight();
	lightPoint->setType(Ogre::Light::LT_POINT);
	lightPoint->setDiffuseColour(color[0], color[1], color[2]);
	lightPoint->setSpecularColour(color[0], color[1], color[2]);

	lightNode = systemNode->createChildSceneNode();
	lightNode->attachObject(lightPoint);
	

	//Rotation
	starRotationDegree = 1.0;
}
Esempio n. 6
0
LUA_DEFINE_FUNCTION(LightsManager, getLightPosition)
{
	//
	// Pass it to Lua script
	//
	/* get number of arguments */
	int n = lua_gettop(L);

	// n should be 1

	/* get the first argument (the light name) */
	Ogre::String lightName = lua_tostring(L, 1);

	//
	// Retrieve light position
	//
	Ogre::Light* light = LightsManager::getSingleton().getLight(lightName);

	Vector3 position = light->getPosition();

	/* push the X */
	lua_pushnumber(L, position.x);
	/* push the Y */
	lua_pushnumber(L, position.y);
	/* push the Z */
	lua_pushnumber(L, position.z);

	/* return the number of results */
	return 3;
}
Esempio n. 7
0
void StandLatas::enter() {

  _loadingShoot =false;
  _timeLoadingShoot =0;

  reacomodateCamera();
  _numCans=0;
  drawCans();
  
  _crosshair = unique_ptr<Crosshair>(new Crosshair(_sceneMgr,_camera));
  _crosshair.get()->createCrossHairManual("circle-01.png");
  _rayScnQuery =_sceneMgr->createRayQuery(Ogre::Ray(), 0);
  _ballStack = _sceneMgr->createSceneNode("ballStack");
  _sceneMgr->getRootSceneNode()->addChild(_ballStack);
  drawHud();
   Carrusel c;
   c.go();
    _timeWithoutBalls=0;
    _puntos=0;

    Ogre::Light* light = _sceneMgr->createLight("LightStandLatas");
    light->setType(Ogre::Light::LT_DIRECTIONAL);
    light->setDirection(Ogre::Vector3(0,0,-1));
    light->setPosition(_cameraNode->getPosition());
    light->setCastShadows(true);

    




}
//-------------------------------------------------------------------------------------   
void GameApplication::createScene() {
	// Create your scene here...	

	//set ambient light
	Ogre::Light* light = mSceneMgr->createLight("MainLight");
	light->setPosition(15,15,3);

	//create the puckManager singleton
	PuckManager::instance(mSceneMgr, 10);

	//create the shuffleboard singleton
	Shuffleboard::instance(mSceneMgr);

	//mPuck = PuckManager::instance()->getNextPuck();

	/*	we should only create a puck when SPACE key is pressed
	//This gives us the correct x,y,z position for the puck launch at the top of the shuffleboard
	Ogre::Real centreX = ( GameConstants::MAX_X - GameConstants::MIN_X ) / 2 + GameConstants::MIN_X; 
 	Ogre::Vector3 launchPos( centreX, GameConstants::LAUNCH_Y, GameConstants::LAUNCH_Z );
	
	mPuck->activate(launchPos);
	mPuck->applyForce(Ogre::Real(7));*/

	mGui3D = new Gui3D::Gui3D(&mMyPurplePanelColors);
	Ogre::Viewport *viewport = mWindow->getViewport(0);
	mGui3D->createScreen(viewport, "purple", "mainScreen");
	createGamePanel();

	mCurrentTime = 0;
}
Esempio n. 9
0
void CEditor::Create( HWND hWnd,int width,int height )
{
	GetCurrentDirectory(MAX_PATH, mCurDir);

	mpEntityMgr = new CEntityManager;
	mpPhysicsMgr = new CPhysicsManager;

	Ogre::NameValuePairList parms;
	parms["externalWindowHandle"] = Ogre::StringConverter::toString((long)hWnd);
	mRenderWindow = mRoot->createRenderWindow("TerrainEditor", width, height, false, &parms);
	mhWnd = hWnd;
	mSceneManager = mRoot->createSceneManager(Ogre::ST_GENERIC, "MainScene");

	// Create the camera
	mCamera = mSceneManager->createCamera("PlayerCam");

	mCamera->setPosition(mTerrainPos + Ogre::Vector3(200, 400, 0));
	mCamera->lookAt(Ogre::Vector3(0, 50, 0));
	mCamera->setNearClipDistance(1);
	mCamera->setFarClipDistance(12000);

	mViewport = mRenderWindow->addViewport(mCamera);
	mViewport->setBackgroundColour(Ogre::ColourValue(0.5f,0.5f,0.5f));

	//SetupInput();
	loadResources();

	mGuiMgr = new OgreBites::GuiManager("BrowserControls", mRenderWindow, this);
	//mGuiMgr->showBackdrop("SdkTrays/Bands");
	mGuiMgr->getTrayContainer(OgreBites::TL_NONE)->hide();

	Ogre::MaterialManager::getSingleton().setDefaultTextureFiltering(Ogre::TFO_ANISOTROPIC);
	Ogre::MaterialManager::getSingleton().setDefaultAnisotropy(7);

	mTerrainGlobals = OGRE_NEW Ogre::TerrainGlobalOptions();

	Ogre::Light* l = mSceneManager->createLight("terrainLight");
	l->setType(Ogre::Light::LT_DIRECTIONAL);
	Ogre::Vector3 lightdir(0.1f, -0.3f, 0.1f);
	lightdir.normalise();
	l->setDirection(lightdir);
	l->setDiffuseColour(Ogre::ColourValue::White);
	l->setSpecularColour(Ogre::ColourValue(0.4f, 0.4f, 0.4f));
	mTerrainLight = l;
	mSceneManager->setAmbientLight(Ogre::ColourValue(0.2f, 0.2f, 0.2f));

	Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
	mRoot->addFrameListener(this);

	mGuiMgr->showFrameStats(OgreBites::TL_TOPRIGHT);

	mpEntityMgr->Create();
	mpPhysicsMgr->Create();

	// Alter the camera aspect ratio to match the viewport
	mCamera->setAspectRatio(
		Ogre::Real(mViewport->getActualWidth()) / Ogre::Real(mViewport->getActualHeight()));

	SetEditTool(NULL);
}
Esempio n. 10
0
    //--------------------------------------------------------------------------
    void
    Utility::initComponents()
    {
        Application::initComponents();
        Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();

        Ogre::Root         *root( getRoot() );

        m_scene_manager = root->createSceneManager( Ogre::ST_GENERIC, "Scene" );
        m_scene_manager->clearScene();
        m_scene_manager->setAmbientLight( Ogre::ColourValue( 0.5, 0.5, 0.5 ) );
        Ogre::Light* directionalLight = m_scene_manager->createLight("directionalLight");
        directionalLight->setType( Ogre::Light::LT_DIRECTIONAL );
        directionalLight->setDiffuseColour( Ogre::ColourValue( 0.5, 0.5, 0.5) );
        directionalLight->setSpecularColour( Ogre::ColourValue( 0.5, 0.5, 0.5) );
        directionalLight->setDirection( Ogre::Vector3( 0, 0, -1 ) );

        m_camera = m_scene_manager->createCamera( "Camera" );
        m_camera->setNearClipDistance( 0.01f );
        m_camera->setPosition( 0, 5, 10 );
        m_camera->lookAt( 0, 0, 0 );

        Ogre::RenderWindow *window( getRenderWindow() );
        m_viewport = window->addViewport( m_camera );
        m_viewport->setBackgroundColour( Ogre::ColourValue( 0.0f, 0.4f, 0.0f ) );
        m_camera->setAspectRatio( Ogre::Real( m_viewport->getActualWidth() ) / Ogre::Real( m_viewport->getActualHeight() ) );

        m_frame_listener = new DisplayFrameListener( window );
        m_frame_listener->setCamera( m_camera );
        root->addFrameListener( m_frame_listener );
    }
Esempio n. 11
0
// insert a light related to the most recent insertBegin call.
void InteriorCellRender::insertLight(float r, float g, float b, float radius)
{
  assert (insert);

  Ogre::Light *light = scene.getMgr()->createLight();
  light->setDiffuseColour (r, g, b);

  float cval=0.0f, lval=0.0f, qval=0.0f;

  if(lightConst)
    cval = lightConstValue;
  if(!lightOutQuadInLin)
  {
    if(lightLinear)
      radius *= lightLinearRadiusMult;
    if(lightQuadratic)
      radius *= lightQuadraticRadiusMult;

    if(lightLinear)
      lval = lightLinearValue / pow(radius, lightLinearMethod);
    if(lightQuadratic)
      qval = lightQuadraticValue / pow(radius, lightQuadraticMethod);
  }
  else
  {
    // FIXME:
    // Do quadratic or linear, depending if we're in an exterior or interior
    // cell, respectively. Ignore lightLinear and lightQuadratic.
  }

  light->setAttenuation(10*radius, cval, lval, qval);

  insert->attachObject(light);
}
//-------------------------------------------------------------------------------------
void HelloOGRE::createScene(void)
{
	using namespace Ogre;
	Ogre::Entity* ogreHead = mSceneMgr->createEntity("Head", "7.mesh");
	
	//Ogre::Entity* cube = mSceneMgr->createEntity("cube","abc.mesh");

	Ogre::SceneNode* headNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("Head");
	headNode->attachObject(ogreHead);
	

	ManualObject * axis = mSceneMgr->createManualObject("Axis");
	axis->begin("line",Ogre::RenderOperation::OperationType::OT_LINE_LIST);
	
	axis->position(0.0f,0.0f,0.0f);
	axis->position(20.0f,0.0f,0.0f);
	axis->end();
	headNode->attachObject(axis);
	// Set ambient light
	mSceneMgr->setAmbientLight(Ogre::ColourValue(1.0,0.5, 0.0));

	mSceneMgr->setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_ADDITIVE);
	mSceneMgr->setSkyDome(true,"Examples/Rockwall");
	//mSceneMgr->setSkyPlane(true,"Example/"
	
	// Create a light
	Ogre::Light* l = mSceneMgr->createLight("MainLight");
	l->setDiffuseColour(0.0f,1.0f,0.0f);
	
	l->setPosition(20,80,50);
	l->setDirection(0.0,0.0,0.0);
}
Esempio n. 13
0
void MyApp::createScene()
{
    // Setup shadows.
    if (mUseShadows)
    {
        mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_ADDITIVE);
    }
    else
    {
        mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
    }

    // Set the ambient light level.
    mSceneMgr->setAmbientLight(ColourValue(0.3, 0.3, 0.3));

    // Create a light source.
    Ogre::Light* light = mSceneMgr->createLight("light0");
    light->setType(Ogre::Light::LT_POINT);
    light->setDiffuseColour(1.0, 1.0, 1.0);
    light->setSpecularColour(1.0, 1.0, 1.0);
    light->setPosition(100.0, 300.0, 100.0);

    // Setup the initial camera position.
    mPhysicalCamera->setPosition(opal::Point3r(0, 30, 50));
    mPhysicalCamera->lookAt(opal::Point3r(0, 0, 0));

    // Load models, create physical objects, etc. here.
}
Esempio n. 14
0
void AWGraphics::SceneDirector::createPlayer()
{
    // Add player entity to the scene
    Ogre::Entity* ogreEntity = mSceneMgr->createEntity("ogrehead.mesh");

    Ogre::SceneNode* parentNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
    Ogre::SceneNode* ogreNode = parentNode->createChildSceneNode();
    ogreNode->attachObject(ogreEntity);
    ogreNode->rotate(Ogre::Vector3(0.0, 1.0, 0.0), Ogre::Radian(Ogre::Degree(180)));
    ogreNode->setPosition(0, 80, 0);

    mPlayerNode = parentNode;

    // Initialize and add a light
    mSceneMgr->setAmbientLight(Ogre::ColourValue(.5, .5, .5));

    Ogre::Light* light = mSceneMgr->createLight("MainLight");
    light->setType(Ogre::Light::LT_DIRECTIONAL);
    light->setDirection(Ogre::Vector3(0, -1, 1));

    /*// Directional light
    Ogre::Light* directionalLight = mSceneMgr->createLight("DirectionalLight");
    directionalLight->setType(Ogre::Light::LT_DIRECTIONAL);

    directionalLight->setDiffuseColour(Ogre::ColourValue(.8, .6, .2));
    directionalLight->setSpecularColour(Ogre::ColourValue(.8, .6, .2));
    */

    // Add skydome
    mSceneMgr->setSkyDome(true, "CloudySky", 5, 8); // cannot find... :(
}
Esempio n. 15
0
void TutorialApplication::createScene(void)
{
    //create primary entity
    ent = mSceneMgr->createEntity("foo",inputfile);
    
    //this entity is for testing only
    //Ogre::Entity* ent2 = mSceneMgr->createEntity("Ogrehead2","ogrehead.mesh");
    
    //cretae node to which .mesh entity will be attached
    node = mSceneMgr->getRootSceneNode()->createChildSceneNode("Node1");
    node->setPosition(10,0,0);
    node->attachObject(ent);
    

    //Ogre::SceneNode* camnode = node->createChildSceneNode("Node2",Ogre::Vector3(80,0,0));
    //camnode->attachObject(ent2);
    //camnode->attachObject(cam1);
    //camnode->attachObject(mCamera);
    
    mSceneMgr->setAmbientLight(Ogre::ColourValue(1,1,1));
    
    Ogre::Light* light = mSceneMgr->createLight("mainlight");
    light->setDiffuseColour(Ogre::ColourValue::White);
    light->setPosition(10,100,0);
    mCamera->setAutoTracking(true, node);

}
Esempio n. 16
0
void Hundir::createScene() {

    Ogre::Entity* inicio = _sceneManager->createEntity("Inicio.mesh");
    Ogre::SceneNode* ninicio = _sceneManager->createSceneNode("ninicio");
    _sceneManager->getRootSceneNode()->addChild(ninicio);
    ninicio->attachObject(inicio);
    ninicio->yaw(Ogre::Degree(-15));
    ninicio->pitch(Ogre::Degree(50));
    ninicio->roll(Ogre::Degree(90));
    ninicio->setScale(1,1.5,1.2);
    ninicio->setPosition(0,0,-2);

    /* Sombras */
    _sceneManager->setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_MODULATIVE);
    _sceneManager->setShadowColour(Ogre::ColourValue(0.5, 0.5, 0.5) );
    _sceneManager->setAmbientLight(Ogre::ColourValue(0.9, 0.9, 0.9));
    _sceneManager->setShadowTextureCount(2);
    _sceneManager->setShadowTextureSize(512);
    /* Iluminacion */
    Ogre::Light *light = _sceneManager->createLight("Light");
    light->setType(Ogre::Light::LT_SPOTLIGHT);
    light->setDirection(Ogre::Vector3(0,-1,0));
    light->setSpotlightInnerAngle(Ogre::Degree(25.0f));
    light->setSpotlightOuterAngle(Ogre::Degree(200.0f));
    light->setPosition(0, 150, 0);
    light->setSpecularColour(1, 1, 1);
    light->setDiffuseColour(1, 1, 1);
    light->setSpotlightFalloff(5.0f);
    light->setCastShadows(true);
}
Esempio n. 17
0
//--------------------------------
// C++ Methods called FROM Lua
//--------------------------------
LUA_DEFINE_FUNCTION(LightsManager, getLightDiffuseColor)
{
	//
	// Pass it to Lua script
	//
	/* get number of arguments */
	int n = lua_gettop(L);

	// n should be 1

	/* get the first argument (the light name) */
	Ogre::String lightName = lua_tostring(L, 1);

	//
	// Retrieve light color
	//
	Ogre::Light* light = LightsManager::getSingleton().getLight(lightName);

	ColourValue color = light->getDiffuseColour();

	/* push the Red */
	lua_pushnumber(L, color.r);
	/* push the Green */
	lua_pushnumber(L, color.g);
	/* push the Blue */
	lua_pushnumber(L, color.b);

	/* return the number of results */
	return 3;
}
Esempio n. 18
0
	void RenderBoxScene::createScene()
	{
		// создае?новы?сцен менеджер
		mScene = Ogre::Root::getSingleton().createSceneManager(Ogre::ST_GENERIC, MyGUI::utility::toString(this, "_SceneManagerRenderBox"));

		// создае?но??которуму буде?вс¤ку?др¤нь атачит?
		mNode = mScene->getRootSceneNode()->createChildSceneNode();

		mScene->setAmbientLight(Ogre::ColourValue(0.8, 0.8, 0.8));

		// главны?источник свет?
		Ogre::Vector3 dir(-1, -1, 0.5);
		dir.normalise();
		Ogre::Light * light = mScene->createLight(MyGUI::utility::toString(this, "_LightRenderBox"));
		light->setType(Ogre::Light::LT_DIRECTIONAL);
		light->setDirection(dir);

		std::string camera(MyGUI::utility::toString(this, "_CameraRenderBox"));
		mCamera = mScene->createCamera(camera);
		mCamera->setNearClipDistance(1);

		mCameraNode = mScene->getRootSceneNode()->createChildSceneNode(camera);
		mCameraNode->attachObject(mCamera);

		if (mCanvas->getHeight() == 0)
			mCamera->setAspectRatio(1);
		else
			mCamera->setAspectRatio( float(mCanvas->getWidth()) / float(mCanvas->getHeight()) );

		setViewport(mCamera);
	}
Esempio n. 19
0
LUA_DEFINE_FUNCTION(LightsManager, setLightPosition)
{
	//
	// Pass it to Lua script
	//
	/* get number of arguments */
	int n = lua_gettop(L);

	// n should be 4

	/* get the color arguments */
	//if(!lua_isnumber(L,0))
	//{
	//lua_pushstring(L,"Incorrect argument to 'red' component");
	//lua_error(L);
	//}

	Ogre::String lightName = lua_tostring(L, 1);
	Ogre::Real x = lua_tonumber(L, 2);
	Ogre::Real y = lua_tonumber(L, 3);
	Ogre::Real z = lua_tonumber(L, 4);

	//
	// Retrieve light color
	//
	Ogre::Light* light = LightsManager::getSingleton().getLight(lightName);

	light->setPosition(x,y,z);

	/* return the number of results */
	return 0;
}
Esempio n. 20
0
void QOgreWindow::createScene()
{
    // Put anything in here, I'll just put a plane and a dragon here for testing purposes. Go crazy.

    // Plane
    Ogre::Plane plane(Ogre::Vector3::UNIT_Y, 0);

    Ogre::MeshManager::getSingleton().createPlane(
                "ground",
                Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
                plane,
                1500,1500,20,20,
                true,
                1,5,5,
                Ogre::Vector3::UNIT_Z);

    Ogre::Entity* ground = oSceneMgr->createEntity("ground");
    oSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(ground);
    ground->setCastShadows(false);
    ground->setMaterialName("Examples/Rockwall");

    // Dragon Mesh
    oSceneMgr->setAmbientLight(Ogre::ColourValue(0.5,0.5,0.5));
    Ogre::Entity* ogreHead = oSceneMgr->createEntity("Icosphere.mesh");
    Ogre::SceneNode* node = oSceneMgr->getRootSceneNode()->createChildSceneNode();

    node->attachObject(ogreHead);
    node->setPosition(0.0,70.0,0.0);

    Ogre::Light* light = oSceneMgr->createLight("MainLight");
    light->setPosition(20, 80, 50);
}
Esempio n. 21
0
void MainApplication::createScene(void)
{
    mSceneMgr->setAmbientLight(Ogre::ColourValue(0.25, 0.25, 0.25));

    // add the ninja
    ent = mSceneMgr->createEntity("Ninja", "ogrehead.mesh");
    node = mSceneMgr->getRootSceneNode()->createChildSceneNode("NinjaNode", Ogre::Vector3(0.0f, 0.0f, 25.0f));
    node->attachObject(ent);
    node->yaw(Ogre::Degree(90));
    node -> setPosition(Ogre::Vector3(0, 0, -500));

    Ogre::SceneNode *sceneNode = mSceneMgr -> getRootSceneNode() -> createChildSceneNode("CanNode", Ogre::Vector3(0, 0, 500));
    sceneNode = sceneNode -> createChildSceneNode("Pitchnode");
    sceneNode -> attachObject(mCamera);

    // create the light
    Ogre::Light *light = mSceneMgr->createLight("Light1");
    light->setType(Ogre::Light::LT_POINT);
    light->setPosition(Ogre::Vector3(250, 150, 250));
    light->setDiffuseColour(Ogre::ColourValue::White);
    light->setSpecularColour(Ogre::ColourValue::White);

    
   // Create the scene node
    //node = mSceneMgr->getRootSceneNode()->createChildSceneNode("CamNode1", Ogre::Vector3(-400, 200, 400));

    // Make it look towards the ninja
    //node -> setPosition(Ogre::Vector3(0,0,1000));

    // Create the pitch node
    //node = node->createChildSceneNode("PitchNode1");
    //node->attachObject(mCamera);
}
Esempio n. 22
0
void Sample::setupScene()
{
    mSceneMgr->setSkyBox(true, "spaceSkyBox");

    // Set the scene's ambient light
    mSceneMgr->setAmbientLight(Ogre::ColourValue(0.5f, 0.5f, 0.5f));

    Ogre::Entity* pEntity = mSceneMgr->createEntity("SinbadInstance", "Sinbad.mesh");
    Ogre::SceneNode* pNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
    pNode->attachObject(pEntity);
    pNode->setScale(Ogre::Vector3(3.0f));

    mDance = pEntity->getAnimationState("Dance");
    mDance->setEnabled(true);
    mDance->setLoop(true);
    mDance->setTimePosition(0);

    Ogre::Light* pDirLight = mSceneMgr->createLight();
    pDirLight->setDirection(Ogre::Vector3(0,-1,0));
    pDirLight->setType(Ogre::Light::LT_DIRECTIONAL);
    pNode->attachObject(pDirLight);

    mCamera->setNearClipDistance(1.0f);
    mCamera->setFarClipDistance(100000.0f);
    mCamera->setPosition(0,0,30.0f);
    mCamera->lookAt(0,0,0);
    mCamera->setAutoAspectRatio(true);

    Ogre::Viewport* vp = mWindow->addViewport(mCamera);
    vp->setBackgroundColour(Ogre::ColourValue(1,0,0));
}
Esempio n. 23
0
    SceneWidget::SceneWidget(QWidget *parent)
        : QWidget(parent)
        , mWindow(NULL)
        , mCamera(NULL)
        , mSceneMgr(NULL)
    {
        setAttribute(Qt::WA_PaintOnScreen);
        setAttribute(Qt::WA_NoSystemBackground);

        mSceneMgr = Ogre::Root::getSingleton().createSceneManager(Ogre::ST_GENERIC);

        // Throw in a random color just to make sure multiple scenes work
        Ogre::Real r = Ogre::Math::RangeRandom(0, 1);
        Ogre::Real g = Ogre::Math::RangeRandom(0, 1);
        Ogre::Real b = Ogre::Math::RangeRandom(0, 1);
        mSceneMgr->setAmbientLight(Ogre::ColourValue(r,g,b,1));

        Ogre::Light* l = mSceneMgr->createLight();
        l->setType (Ogre::Light::LT_DIRECTIONAL);
        l->setDirection (Ogre::Vector3(-0.4, -0.7, 0.3));
        l->setDiffuseColour (Ogre::ColourValue(0.7,0.7,0.7));

        mCamera = mSceneMgr->createCamera("foo");

        Ogre::Entity* ent = mSceneMgr->createEntity("cube", Ogre::SceneManager::PT_CUBE);
        ent->setMaterialName("BaseWhite");

        mSceneMgr->getRootSceneNode()->attachObject(ent);

        mCamera->setPosition(300,300,300);
        mCamera->lookAt(0,0,0);
        mCamera->setNearClipDistance(0.1);
        mCamera->setFarClipDistance(3000);
    }
Esempio n. 24
0
//-------------------------------------------------------------------------------------
TinyOgre::TinyOgre(void)
{

  OgreRoot = new Ogre::Root();

  if(OgreRoot->restoreConfig() || OgreRoot->showConfigDialog())
    Window = OgreRoot->initialise(true, "TinyOgre Render Window"); //koniecznie tuż pod konstruktorem root!
  else
      throw -1;

  SceneMgr = OgreRoot->createSceneManager(Ogre::ST_GENERIC);
  SceneMgr->setAmbientLight(Ogre::ColourValue(0.4, 0.4, 0.4));
  Ogre::Light* l = SceneMgr->createLight("MainLight");
  l->setPosition(20,-80,50);

  Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Suzanne", "FileSystem");
  Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();

  Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);//Ponoć niektóre API to omijają, więc warto dodać
  
  Camera = SceneMgr->createCamera("PlayerCam");
  Camera->setPosition(Ogre::Vector3(10,-50,10));
  Camera->setOrientation(Ogre::Quaternion(1,1,0,0));
  Camera->setNearClipDistance(0.1);

  Ogre::Viewport* vp = Window->addViewport(Camera);
  vp->setBackgroundColour(Ogre::ColourValue(0,0,0));
  Camera->setAspectRatio(Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight()));
}
Esempio n. 25
0
//-------------------------------------------------------------------------------------
void TutorialApplication::createScene(void)
{
    // create your scene here :)

	// Set the scene's ambient light
    mSceneMgr->setAmbientLight(Ogre::ColourValue(0.5f, 0.5f, 0.5f));
 
    Ogre::Entity* ogreHead = mSceneMgr->createEntity("Head", "ogrehead.mesh");
	Ogre::SceneNode* headNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("HeadNode");
	headNode->attachObject(ogreHead);
	 
	headNode->yaw( Ogre::Degree( -90 ) );
 
	Ogre::Entity* ogreHead2 = mSceneMgr->createEntity( "Head2", "ogrehead.mesh" );
	Ogre::SceneNode* headNode2 = mSceneMgr->getRootSceneNode()->createChildSceneNode( "HeadNode2", Ogre::Vector3( 100, 0, 0 ) );
	headNode2->attachObject( ogreHead2 );
 
	headNode2->pitch( Ogre::Degree( -90 ) );
 
	Ogre::Entity* ogreHead3 = mSceneMgr->createEntity( "Head3", "ogrehead.mesh" );
	Ogre::SceneNode* headNode3 = mSceneMgr->getRootSceneNode()->createChildSceneNode( "HeadNode3", Ogre::Vector3( 200, 0, 0 ) );
	headNode3->attachObject( ogreHead3 );
 
	headNode3->roll( Ogre::Degree( -90 ) );

    // Create a Light and set its position
    Ogre::Light* light = mSceneMgr->createLight("MainLight");
    light->setPosition(20.0f, 80.0f, 50.0f);
}
Esempio n. 26
0
//-------------------------------------------------------------------------------------
void UndeadLand::createScene(void)
{
  mCamera->setPosition(Ogre::Vector3(1683, 50, 2116));
  mCamera->lookAt(Ogre::Vector3(1963, 50, 1660));
  mCamera->setNearClipDistance(0.1);
  mCamera->setFarClipDistance(50000);

  if( mRoot->getRenderSystem()->getCapabilities()->hasCapability( Ogre::RSC_INFINITE_FAR_PLANE ) )
    mCamera->setFarClipDistance(0);
    
  Ogre::Vector3 lightdir(0.55, -0.3, 0.75);
  lightdir.normalise();

  Ogre::Light* light = mSceneMgr->createLight("tstLight");
  light->setType(Ogre::Light::LT_DIRECTIONAL);
  light->setDirection(lightdir);
  light->setDiffuseColour(Ogre::ColourValue::White);
  light->setSpecularColour(Ogre::ColourValue(0.4, 0.4, 0.4));

  mSceneMgr->setAmbientLight(Ogre::ColourValue(0.5, 0.5, 0.5));
  
  if( soundeng ) {
    //soundeng->play2D( "dist/media/sounds/Pong_Beat_100_bpm_www.loopartists.com.wav", true );
    soundeng->play2D( "dist/media/sounds/looperman-loop-00500098-00050813-shortbusmusic-piano-in-bm7-a-e.wav", true );
  }

  terrain = new TerrainEngine( "this is a ridiculously long string", mRoot, mSceneMgr, mCamera, light );
}
Esempio n. 27
0
void QOgrePointLightWidget::updateInfo()
{
    Ogre::Light *l = mSceneMgr->getLight(name);
    QOgreLightWidget::updateInfo();
    const Ogre::Vector3 &n = l->getPosition();
    for (unsigned int i=0; i<3; ++i) position[i]->setValue(n[i]);
}
Esempio n. 28
0
void Simulation::createScene() {
    // Set the scene's ambient light
    mSceneMgr->setAmbientLight(Ogre::ColourValue(0.5f, 0.5f, 0.5f));

    // Set up camera
    // Position it at 500 in Z direction
    mCamera->setPosition(Ogre::Vector3(100, 100, 80));
    // Look back along -Z
    mCamera->lookAt(Ogre::Vector3(0,0,-300));
    mCamera->setNearClipDistance(5);

    // Set up world
    mWorld = new World(mSceneMgr);

	// Create a Light and set its position
    Ogre::Light* light = mSceneMgr->createLight("MainLight");
    light->setPosition(20.0f, 80.0f, 50.0f);

    // Set up GUI
    mHud = CEGUI::WindowManager::getSingleton().loadLayoutFromFile("hud.layout");
    mRootWindow->addChild(mHud);

    mRootWindow->getChild("Sidebar/QuitButton")->subscribeEvent(CEGUI::PushButton::EventClicked, CEGUI::Event::Subscriber(&Simulation::quitEvent, this));
    mRootWindow->getChild("Sidebar/ResetButton")->subscribeEvent(CEGUI::PushButton::EventClicked, CEGUI::Event::Subscriber(&Simulation::resetEvent, this));
    mRootWindow->getChild("Sidebar/EnvGroupBox/TempSpinner")->subscribeEvent(CEGUI::Spinner::EventValueChanged, CEGUI::SubscriberSlot(&Simulation::tempChangedEvent, this));
    mRootWindow->getChild("Sidebar/EnvGroupBox/PhSpinner")->subscribeEvent(CEGUI::Spinner::EventValueChanged, CEGUI::SubscriberSlot(&Simulation::phChangedEvent, this));
    mRootWindow->getChild("Sidebar/EnvGroupBox/ACellsSpinner")->subscribeEvent(CEGUI::Spinner::EventValueChanged, CEGUI::SubscriberSlot(&Simulation::numCellsChangedEvent, this));
    mRootWindow->getChild("Sidebar/EnvGroupBox/ACellsSpinner")->subscribeEvent(CEGUI::Spinner::EventValueChanged, CEGUI::SubscriberSlot(&Simulation::numCellsChangedEvent, this));
    mRootWindow->getChild("Sidebar/EnvGroupBox/ACellsSpinner")->subscribeEvent(CEGUI::Spinner::EventValueChanged, CEGUI::SubscriberSlot(&Simulation::numCellsChangedEvent, this));

    static_cast<CEGUI::Spinner*>(mRootWindow->getChild("Sidebar/EnvGroupBox/TempSpinner"))->setCurrentValue((double)mWorld->getTemperature());
    static_cast<CEGUI::Spinner*>(mRootWindow->getChild("Sidebar/EnvGroupBox/PhSpinner"))->setCurrentValue((double)mWorld->getPH());
}
Esempio n. 29
0
void InputBufferSample::createScene()
{
	mSceneMgr->setAmbientLight(Ogre::ColourValue(.2, .2, .2));

	Ogre::Entity* tudorEntity = mSceneMgr->createEntity("tudorhouse.mesh");
	Ogre::SceneNode* node = mSceneMgr->getRootSceneNode()->createChildSceneNode(
		"TudorNode");
	node->attachObject(tudorEntity);

	Ogre::Light* light = mSceneMgr->createLight("Light1");
	light->setType(Ogre::Light::LT_POINT);
	light->setPosition(Ogre::Vector3(300, 150, 0));
	light->setDiffuseColour(Ogre::ColourValue::White);
	light->setSpecularColour(Ogre::ColourValue::White);

	mCamera->setPosition(Ogre::Vector3(1, 1, 1));
	mCamera->lookAt(Ogre::Vector3(0, 0, 0));

	node = mSceneMgr->getRootSceneNode()->createChildSceneNode(
		"CamNode1", Ogre::Vector3(1000, 1000, 1000));

	mCamNode = node;
	node->attachObject(mCamera);

	node = mSceneMgr->getRootSceneNode()->createChildSceneNode(
		"CamNode2", Ogre::Vector3(500, 500, 500));
}
//-------------------------------------------------------------------------------------
void TutorialApplication::createScene(void)
{
	mSceneMgr->setAmbientLight(Ogre::ColourValue(0.25, 0.25, 0.25));

    // add the ninja
	Ogre::Entity *ent = mSceneMgr->createEntity("Ninja", "ninja.mesh");
    Ogre::SceneNode *node = mSceneMgr->getRootSceneNode()->createChildSceneNode("NinjaNode");
    node->attachObject(ent);

    // create the light
    Ogre::Light *light = mSceneMgr->createLight("Light1");
    light->setType(Ogre::Light::LT_POINT);
    light->setPosition(Ogre::Vector3(250, 150, 250));
    light->setDiffuseColour(Ogre::ColourValue::White);
    light->setSpecularColour(Ogre::ColourValue::White);

   // Create the scene node
    node = mSceneMgr->getRootSceneNode()->createChildSceneNode("CamNode1", Ogre::Vector3(-400, 200, 400));

    // Make it look towards the ninja
    node->yaw(Ogre::Degree(-45));

    // Create the pitch node
    node = node->createChildSceneNode("PitchNode1");
    node->attachObject(mCamera);

    // create the second camera node/pitch node
    node = mSceneMgr->getRootSceneNode()->createChildSceneNode("CamNode2", Ogre::Vector3(0, 200, 400));
    node = node->createChildSceneNode("PitchNode2");
}