void CSoundSystem::setListenerMatrix(const NLMISC::CMatrix &m)
{
	if (_AudioMixer)
	{
		static CMatrix oldMatrix;
		if(m.getPos() != oldMatrix.getPos() || m.getJ() != oldMatrix.getJ() || m.getK() != oldMatrix.getK())
		{
			UListener *l = _AudioMixer->getListener();
			l->setPos(m.getPos());		
			l->setOrientation(m.getJ(), m.getK());
			oldMatrix = m;
		}
	}
}
Exemple #2
0
// ***************************************************************************
void					CMaterial::decompUserTexMat(uint stage, float &uTrans, float &vTrans, float &wRot, float &uScale, float &vScale)
{
	nlassert(stage < IDRV_MAT_MAXTEXTURES);
	nlassert(isUserTexMatEnabled(stage)); // must activate animated texture matrix for this stage
	CMatrix convMat; // exported v are already inverted (todo: optim this...)
	convMat.setRot(CVector::I, -CVector::J, CVector::K);
	convMat.setPos(CVector::J);

	const NLMISC::CMatrix texMat = convMat * _TexUserMat->TexMat[stage] * convMat;
	/// find the rotation around w
	NLMISC::CVector i = texMat.getI();
	NLMISC::CVector j = texMat.getJ();
	uScale = sqrtf(i.x * i.x + j.x * j.x);
	vScale = sqrtf(i.y * i.y + j.y * j.y);
	//
	i.normalize();
	//
	float angle = acosf(i.x / i.norm());
	if (i.y < 0)
	{
		angle = 2.f * (float) NLMISC::Pi - angle;
	}
	wRot = angle;

	// compute position
	CMatrix InvSR;
	InvSR.setRot(texMat.getI(), texMat.getJ(), texMat.getK());
	InvSR.invert();
	CVector half(0.5f, 0.5f, 0.f);
	CVector offset = half + InvSR * (texMat.getPos() -half);
	uTrans = - offset.x;
	vTrans = - offset.y;
}
Exemple #3
0
void CVegetableEditor::update()
{
	// Vegetable: manage collision snapping if wanted and possible
	if(_VegetableSnapToGround && _VegetableLandscape)
	{
		// get matrix from camera.
		NLMISC::CMatrix	matrix = Modules::objView().getScene()->getCam().getMatrix();

		// snap To ground.
		NLMISC::CVector pos = matrix.getPos();
		// if succes to snap to ground
		if(_VegetableCollisionEntity->snapToGround(pos))
		{
			pos.z+= _VegetableSnapHeight;
			matrix.setPos(pos);
			// reset the moveListener and the camera.
			Modules::objView().get3dMouseListener()->setMatrix(matrix);
			Modules::objView().getScene()->getCam().setMatrix(matrix);
		}
	}
}
Exemple #4
0
void CProgress::internalProgress (float value)
{
	// Get croped value
	value = getCropedValue (value);

	// can't do anything if no driver
	if (Driver == NULL)
		return;

	if (Driver->AsyncListener.isKeyPushed (KeyDOWN))
		selectTipsOfTheDay (TipsOfTheDayIndex-1);
	if (Driver->AsyncListener.isKeyPushed (KeyUP))
		selectTipsOfTheDay (TipsOfTheDayIndex+1);

	// Create camera for stereo mode
	bool stereoHMD = StereoHMD && !MainCam.empty() && (MainCam.getTransformMode() == UCamera::RotQuat);
	CVector oldPos;
	CQuat oldQuat;
	if (stereoHMD)
	{
		MainCam.getPos(oldPos);
		MainCam.getRotQuat(oldQuat);
		StereoHMD->setInterfaceMatrix(CMatrix()); // identity
		NLMISC::CQuat hmdOrient = StereoHMD->getOrientation();
		NLMISC::CMatrix camMatrix;
		camMatrix.identity();
		NLMISC::CMatrix hmdMatrix;
		hmdMatrix.setRot(hmdOrient);
		NLMISC::CMatrix posMatrix; // minimal head modeling, will be changed in the future
		posMatrix.translate(StereoHMD->getEyePosition());
		NLMISC::CMatrix mat = ((camMatrix * hmdMatrix) * posMatrix);
		MainCam.setPos(mat.getPos());
		MainCam.setRotQuat(mat.getRot());
		StereoDisplay->updateCamera(0, &MainCam);
	}
	uint i = 0;
	while ((!stereoHMD && i == 0) || (stereoHMD && StereoDisplay->nextPass()))
	{
		++i;
		if (stereoHMD)
		{
			// modify cameras for stereo display
			const CViewport &vp = StereoDisplay->getCurrentViewport();
			Driver->setViewport(vp);
			StereoDisplay->getCurrentMatrix(0, &MainCam);
			StereoDisplay->getCurrentFrustum(0, &MainCam);

			// begin current pass
			StereoDisplay->beginRenderTarget();

			nldebug("Cam pos: %f, %f, %f", MainCam.getPos().x, MainCam.getPos().y, MainCam.getPos().z);
		}

		if (!stereoHMD || StereoDisplay->wantClear())
		{
			Driver->clearBuffers(CRGBA(0, 0, 0, 0));
		}

		if (stereoHMD && StereoDisplay->wantScene())
		{
			Driver->setMatrixMode3D(MainCam);
		}

		if (!stereoHMD || StereoDisplay->wantInterface2D())
		{
			// nldebug("Draw progress 2D");

			// Font factor
			float fontFactor = 1;
			if (Driver->getWindowHeight() > 0)
				fontFactor = (float)Driver->getWindowHeight() / 600.f;
			fontFactor *= _FontFactor;

			// Set 2d view.
			Driver->setMatrixMode2D11();

			// Display the loading background.
			drawLoadingBitmap(value);

			// temporary values for conversions
			float x, y, width, height;

			for(uint i = 0; i < ClientCfg.Logos.size(); i++)
			{
				std::vector<string> res;
				explode(ClientCfg.Logos[i], std::string(":"), res);
				if(res.size()==9 && i<LogoBitmaps.size() && LogoBitmaps[i]!=NULL)
				{
					fromString(res[1], x);
					fromString(res[2], y);
					fromString(res[3], width);
					fromString(res[4], height);
					Driver->drawBitmap(x/(float)ClientCfg.Width, y/(float)ClientCfg.Height, width/(float)ClientCfg.Width, height/(float)ClientCfg.Height, *LogoBitmaps[i]);
				}
			}

			if (TextContext != NULL)
			{
				// Init the Pen.
				TextContext->setKeep800x600Ratio(false);
				TextContext->setColor(CRGBA(255,255,255));
				TextContext->setFontSize((uint)(12.f * fontFactor));
				TextContext->setHotSpot(UTextContext::TopRight);

#if !FINAL_VERSION
				// Display the Text.
				TextContext->printAt(1, 0.98f, _ProgressMessage);
#else
				if( ClientCfg.LoadingStringCount > 0 )
				{
					TextContext->printAt(1, 0.98f, _ProgressMessage);
				}
#endif // FINAL_VERSION

				// Display the build version.
				TextContext->setFontSize((uint)(12.f * fontFactor));
				TextContext->setHotSpot(UTextContext::TopRight);
				string str;
#if FINAL_VERSION
				str = "FV ";
#else
				str = "DEV ";
#endif
				str += RYZOM_VERSION;
				TextContext->printfAt(1.0f,1.0f, str.c_str());

				// Display the tips of the day.
				TextContext->setFontSize((uint)(16.f * fontFactor));
				TextContext->setHotSpot(UTextContext::MiddleTop);
				ucstring::size_type index = 0;
				ucstring::size_type end = TipsOfTheDay.find((ucchar)'\n');
				if (end == string::npos)
					end = TipsOfTheDay.size();
				float fY = ClientCfg.TipsY;
				if (!TipsOfTheDay.empty())
				{
					while (index < end)
					{
						// Get the line
						ucstring line = TipsOfTheDay.substr (index, end-index);

						// Draw the line
						TextContext->printAt(0.5f, fY, line);
						fY = nextLine (TextContext->getFontSize(), Driver->getWindowHeight(), fY);

						index=end+1;
						end = TipsOfTheDay.find((ucchar)'\n', index);
						if (end == ucstring::npos)
							end = TipsOfTheDay.size();
					}

					// More help
					TextContext->setFontSize((uint)(12.f * fontFactor));
					/* todo tips of the day uncomment
					ucstring ucstr = CI18N::get ("uiTipsEnd");
					TextContext->printAt(0.5f, fY, ucstr); */
					fY = nextLine (TextContext->getFontSize(), Driver->getWindowHeight(), fY);
					fY = nextLine (TextContext->getFontSize(), Driver->getWindowHeight(), fY);
				}



				if (!_TPReason.empty())
				{
					TextContext->setHotSpot(UTextContext::MiddleMiddle);
					TextContext->setFontSize((uint)(14.f * fontFactor));
					TextContext->printAt(0.5f, 0.5f, _TPReason);
					TextContext->setHotSpot(UTextContext::BottomLeft);
					TextContext->setColor(NLMISC::CRGBA::White);
				}



				if (!_TPCancelText.empty())
				{
					if (ClientCfg.Width != 0 && ClientCfg.Height != 0)
					{
						TextContext->setFontSize((uint)(15.f * fontFactor));
						TextContext->setHotSpot(UTextContext::BottomLeft);

						ucstring uc = CI18N::get("uiR2EDTPEscapeToInteruptLoading") + " (" + _TPCancelText + ") - " + CI18N::get("uiDelayedTPCancel");
						UTextContext::CStringInfo info = TextContext->getStringInfo(uc);
						float stringX = 0.5f - info.StringWidth/(ClientCfg.Width*2);
						TextContext->printAt(stringX, 7.f / ClientCfg.Height, uc);
					}
				}


				// Teleport help
				//fY = ClientCfg.TeleportInfoY;
				if (!ApplyTextCommands && LoadingContinent && !LoadingContinent->Indoor)
				{
					TextContext->setFontSize((uint)(13.f * fontFactor));

					// Print some more info
					uint32 day = RT.getRyzomDay();
					str = toString (CI18N::get ("uiTipsTeleport").toUtf8().c_str(),
						CI18N::get (LoadingContinent->LocalizedName).toUtf8().c_str(),
						day,
						(uint)RT.getRyzomTime(),
						CI18N::get ("uiSeason"+toStringEnum(CRyzomTime::getSeasonByDay(day))).toUtf8().c_str(),
						CI18N::get (WeatherManager.getCurrWeatherState().LocalizedName).toUtf8().c_str());
					ucstring ucstr;
					ucstr.fromUtf8 (str);
					TextContext->setHotSpot(UTextContext::MiddleBottom);
					TextContext->setColor(CRGBA(186, 179, 163, 255));
					TextContext->printAt(0.5f, 25/768.f, ucstr);
				}

				// apply text commands
				if( ApplyTextCommands )
				{
					std::vector<CClientConfig::SPrintfCommand> printfCommands = ClientCfg.PrintfCommands;
					if(FreeTrial) printfCommands = ClientCfg.PrintfCommandsFreeTrial;

					if( !printfCommands.empty() )
					{
						TextContext->setHotSpot(UTextContext::MiddleBottom);

						vector<CClientConfig::SPrintfCommand>::iterator itpc;
						for( itpc = printfCommands.begin(); itpc != printfCommands.end(); ++itpc )
						{
							float x = 0.5f;//((*itpc).X / 1024.f);
							float y = ((*itpc).Y / 768.f);
							TextContext->setColor( (*itpc).Color );
							TextContext->setFontSize( (uint)(16.f * fontFactor));

							// build the ucstr(s)
							ucstring ucstr = CI18N::get((*itpc).Text);
							vector<ucstring> vucstr;
							ucstring sep("\n");
							splitUCString(ucstr,sep,vucstr);

							// Letter size
							UTextContext::CStringInfo si = TextContext->getStringInfo(ucstring("|"));
							uint fontHeight = (uint) si.StringHeight + 2; // we add 2 pixels for the gap

							uint i;
							float newy = y;
							for( i=0; i<vucstr.size(); ++i )
							{
								TextContext->printAt(x,newy, vucstr[i]);
								newy = nextLine(fontHeight, Driver->getWindowHeight(), newy);
							}
						}
					}
				}
			}
		}

		if (stereoHMD)
		{
			StereoDisplay->endRenderTarget();
		}
	} /* stereo loop */

	if (stereoHMD)
	{
		MainCam.setPos(oldPos);
		MainCam.setRotQuat(oldQuat);
	}

	// Clamp
	clamp (value, 0.f, 1.f);

	// Set matrix
	Driver->setMatrixMode2D11 ();

	// want to receive the 'mouse down' event to deal with the 'cancel tp button'
	Driver->EventServer.addListener(EventMouseDownId,	this);

	// Update messages
	CInputHandlerManager::getInstance()->pumpEventsNoIM();

	Driver->EventServer.removeListener(EventMouseDownId,	this);

	// Exit ?
	bool activeDriver =  Driver->isActive();
	if ((UseEscapeDuringLoading && Driver->AsyncListener.isKeyPushed (KeyESCAPE)) || !activeDriver)
	{
		// Release the application
		releaseMainLoop(true);
		release();
		// Leave the application
		extern void quitCrashReport ();
		quitCrashReport ();
		exit(EXIT_SUCCESS);
	}

	if(!_TPCancelText.empty() &&  Driver->AsyncListener.isKeyPushed(KeySHIFT) && Driver->AsyncListener.isKeyPushed(KeyESCAPE))
	{
		_TPCancelFlag = true;
	}


	CBGDownloaderAccess::getInstance().update();
	// Display to screen.
	Driver->swapBuffers();

	// \todo GUIGUI : Remove this when possible.
	NetMngr.update();
	IngameDbMngr.flushObserverCalls();
	NLGUI::CDBManager::getInstance()->flushObserverCalls();

	// update system dependent progress bar
	static uint previousValue = 0;
	uint currentValue = (uint)(value*100.0f);

	if (currentValue != previousValue)
	{
		CSystemUtils::updateProgressBar(currentValue, 100);
		previousValue = currentValue;
	}
}
//******************************************************************************************************
void CStartStopParticleSystem::goPreRender()
{	
	if (!_ActiveNode) return;
	NL3D::CParticleSystem *ps = _ActiveNode->getPSPointer();
	sint currNumParticles = (sint) ps->getCurrNumParticles();
	sint maxNumParticles = (sint) ps->getMaxNumParticles();
	// if linked with scene animation, restart if animation ends
	if (m_LinkPlayToScenePlay) // is scene animation subordinated to the fx animation
	{		
		// start animation for the scene too
		if (_AnimationDLG && isRunning())
		{
			if (_LastSceneAnimFrame > _AnimationDLG->CurrentFrame) // did animation restart ?
			{			
				restartAllFX();
			}
			_LastSceneAnimFrame = _AnimationDLG->CurrentFrame;
		}
	}
	else
	if (_AutoRepeat && !m_LinkPlayToScenePlay) // auto repeat feature
	{
		if (isRunning())
		{		
			bool allFXFinished = true;
			bool fxStarted = false;
			for(uint k = 0; k < _PlayingNodes.size(); ++k)
			{
				if (_PlayingNodes[k])
				{					
					if (isRunning(_PlayingNodes[k]))
					{					
						fxStarted = true;
						if (_PlayingNodes[k]->getPSPointer()->getSystemDate() <= _PlayingNodes[k]->getPSPointer()->evalDuration())
						{												
							allFXFinished = false;
							break;						
						}
						else
						{
							if (_PlayingNodes[k]->getPSPointer()->getCurrNumParticles() != 0)
							{						
								allFXFinished = false;
								break;
							}
						}
					}
				}
			}
			if (fxStarted && allFXFinished)
			{
				restartAllFX();
			}
		}
	}
	if (_State == RunningMultiple || _State == PausedMultiple)
	{
		std::set<std::string> currAnims;
		CObjectViewer *ov = _ParticleDlg->getObjectViewer();
		for(uint k = 0; k < ov->getNumInstance(); ++k)
		{
			CInstanceInfo *ci = ov->getInstance(k);
			uint animIndex = ci->Playlist.getAnimation(0);
			if (animIndex != NL3D::CAnimationSet::NotFound)
			{			
				std::string animName = ci->AnimationSet.getAnimationName(animIndex);
				if (!animName.empty())
				{
					currAnims.insert(animName);
				}
			}
		}				
		// check fx that have a trigger anim
		for(uint k = 0; k < _PlayingNodes.size(); ++k)
		{
			if (_PlayingNodes[k])
			{							
				if (!isRunning(_PlayingNodes[k]) || !_PlayingNodes[k]->getPSModel()->hasActiveEmitters())
				{
					// see if chosen anim is currently running
					if (_PlayingNodes[k]->getTriggerAnim().empty() || currAnims.count(_PlayingNodes[k]->getTriggerAnim()))
					{
						// if the fx was shutting down, stop then restart it
						if (!_PlayingNodes[k]->getPSModel()->hasActiveEmitters())
						{
							nlassert(isRunning(_PlayingNodes[k]));
							stop(*_PlayingNodes[k]);
						}
						// yes -> trigger the fx	
						play(*_PlayingNodes[k]);
					}
					else if (!_PlayingNodes[k]->getPSPointer()->hasParticles()) // fx is being shut down, stop it when necessary
					{					
						stop(*_PlayingNodes[k]); // no more particles so stop the system
					}					
				}
				else
				{					
					if (!_PlayingNodes[k]->getTriggerAnim().empty())
					{
						if (_PlayingNodes[k]->getPSModel()->hasActiveEmitters())
						{
							// see if anim if already playing. If this is not the case then shutdown the emitters
							if (!currAnims.count(_PlayingNodes[k]->getTriggerAnim()))
							{
								_PlayingNodes[k]->getPSModel()->activateEmitters(false);
							}
						}
					}					
				}
			}
		}
	}
	if (_ActiveNode)
	{	
		// display number of particles for the currently active node
		if (currNumParticles != _LastCurrNumParticles || maxNumParticles != _LastMaxNumParticles)
		{	
			CString numParts;	
			numParts.LoadString(IDS_NUM_PARTICLES);
			numParts += CString(NLMISC::toString("%d / %d",(int) currNumParticles, (int) maxNumParticles).c_str());
			GetDlgItem(IDC_NUM_PARTICLES)->SetWindowText((LPCTSTR) numParts);
			_LastCurrNumParticles = currNumParticles;
			_LastMaxNumParticles = maxNumParticles;
		}
		// display max number of wanted faces
		NLMISC::CMatrix camMat = ps->getScene()->getCam()->getMatrix();
		sint numWantedFaces = (uint) ps->getWantedNumTris((ps->getSysMat().getPos() - camMat.getPos()).norm());
		if (numWantedFaces != _LastNumWantedFaces)
		{	
			CString numWF;
			numWF.LoadString(IDS_NUM_WANTED_FACES);
			numWF += CString(NLMISC::toString("%d",(int) numWantedFaces).c_str());
			GetDlgItem(IDC_NUM_ASKED_FACES)->SetWindowText((LPCTSTR) numWF);
			_LastNumWantedFaces = numWantedFaces;		
		}
		// display system date
		if (ps->getSystemDate() != _LastSystemDate)
		{
			_LastSystemDate = ps->getSystemDate();
			CString sysDate;	
			sysDate.LoadString(IDS_SYSTEM_DATE);
			sysDate += CString(NLMISC::toString("%.2f s",_LastSystemDate).c_str());
			GetDlgItem(IDC_SYSTEM_DATE)->SetWindowText((LPCTSTR) sysDate);
		}	
	}
	if (_ParticleDlg)
	{
		CParticleWorkspace *pws = _ParticleDlg->getParticleWorkspace();
		if (pws)
		{
			for(uint k = 0; k < pws->getNumNode(); ++k)
			{
				if (pws->getNode(k)->isLoaded())
				{				
					if (pws->getNode(k) == _ActiveNode)
					{
						pws->getNode(k)->getPSModel()->enableDisplayTools(!isRunning(pws->getNode(k)) || m_DisplayHelpers);
					}
					else
					{
						pws->getNode(k)->getPSModel()->enableDisplayTools(false);
					}
					// hide / show the node
					if (_State == RunningMultiple || _State == PausedMultiple)
					{
						if (isRunning(pws->getNode(k)))
						{
							pws->getNode(k)->getPSModel()->show();
						}
						else
						{
							pws->getNode(k)->getPSModel()->hide();
						}
					}
					else
					{
						if (pws->getNode(k) == _ActiveNode)
						{
							pws->getNode(k)->getPSModel()->show();
						}
						else
						{
							pws->getNode(k)->getPSModel()->hide();
						}
					}
				}
			}
		}
	}
}
Exemple #6
0
// ***************************************************************************
void	CVegetable::generateInstance(CVegetableInstanceGroup *ig, const NLMISC::CMatrix &posInWorld,
		const NLMISC::CRGBAF &modulateAmbientColor, const NLMISC::CRGBAF &modulateDiffuseColor, float blendDistMax,
		TVegetableWater vegetWaterState, CVegetableUV8 dlmUV) const
{
	nlassert(_Manager);


	CVector		seed= posInWorld.getPos();

	// Generate Matrix.
	// ===============

	// Generate a random Scale / Rotation matrix.
	CMatrix		randomMat;
	// setup rotation
	CVector		rot;
	rot.x= Rx.eval(seed);
	rot.y= Ry.eval(seed);
	rot.z= Rz.eval(seed);
	randomMat.setRot(rot, CMatrix::ZXY);
	// scale.
	if(Sxy.Abs!=0 || Sxy.Rand!=0 || Sz.Abs!=0 || Sz.Rand!=0)
	{
		CVector		scale;
		scale.x= scale.y= Sxy.eval(seed);
		scale.z= Sz.eval(seed);
		randomMat.scale(scale);
	}

	// Final Matrix.
	CMatrix		finalMatrix;
	finalMatrix= posInWorld * randomMat;

	// Generate Color and factor
	// ===============
	CRGBAF		materialColor(1,1,1,1);
	// evaluate gradients. If none, color not modified.
	Color.eval(seed, materialColor);
	// modulate with user
	CRGBAF		ambient, diffuse;
	if(_VegetableShape && _VegetableShape->Lighted)
	{
		ambient= modulateAmbientColor * materialColor;
		diffuse= modulateDiffuseColor * materialColor;
	}
	else
	{
		ambient= materialColor;
		diffuse= materialColor;
	}

	// Generate a bendFactor
	float	bendFactor= BendFactor.eval(seed);
	// Generate a bendPhase
	float	bendPhase= BendPhase.eval(seed);


	// Append to the vegetableManager
	// ===============
	if (_VegetableShape)
	{
		_Manager->addInstance(ig, _VegetableShape, finalMatrix, ambient, diffuse,
			bendFactor, bendPhase, BendFrequencyFactor, blendDistMax,
			(CVegetableManager::TVegetableWater)vegetWaterState, dlmUV);
	}
}