Context Navigation

source: OGRE/trunk/ogrenew/Samples/Grass/src/Grass.cpp @ 657

Revision 657, 13.5 KB checked in by mattausch, 19 years ago (diff)
added ogre dependencies and patched ogre sources

Rev	Line
[657]	1	/*
	2	-----------------------------------------------------------------------------
	3	This source file is part of OGRE
	4	(Object-oriented Graphics Rendering Engine)
	5	For the latest info, see http://www.ogre3d.org/
	6
	7	Copyright (c) 2000-2005 The OGRE Team
	8	Also see acknowledgements in Readme.html
	9
	10	You may use this sample code for anything you like, it is not covered by the
	11	LGPL like the rest of the engine.
	12	-----------------------------------------------------------------------------
	13	*/
	14
	15	/**
	16	\file
	17	Grass.cpp
	18	\brief
	19	Specialisation of OGRE's framework application to show the
	20	use of the StaticGeometry class to create 'baked' instances of
	21	many meshes, to create effects like grass efficiently.
	22	**/
	23
	24	#include "ExampleApplication.h"
	25
	26	#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
	27	#define WIN32_LEAN_AND_MEAN
	28	#include "windows.h"
	29	#endif
	30
	31
	32	#define KEY_PRESSED(_key,_timeDelay, _macro) \
	33	{ \
	34	if (mInputDevice->isKeyDown(_key) && timeDelay <= 0) \
	35	{ \
	36	timeDelay = _timeDelay; \
	37	_macro ; \
	38	} \
	39	}
	40
	41	#define GRASS_HEIGHT 300
	42	#define GRASS_WIDTH 250
	43	#define GRASS_MESH_NAME "grassblades"
	44	#define GRASS_MATERIAL "Examples/GrassBlades"
	45	#define OFFSET_PARAM 999
	46
	47	Light* mLight;
	48	SceneNode* mLightNode = 0;
	49	AnimationState* mAnimState = 0;
	50	ColourValue mMinLightColour(0.5, 0.1, 0.0);
	51	ColourValue mMaxLightColour(1.0, 0.6, 0.0);
	52	Real mMinFlareSize = 40;
	53	Real mMaxFlareSize = 80;
	54	StaticGeometry* mStaticGeom;
	55
	56
	57	/** This class 'wibbles' the light and billboard */
	58	class LightWibbler : public ControllerValue<Real>
	59	{
	60	protected:
	61	Light* mLight;
	62	Billboard* mBillboard;
	63	ColourValue mColourRange;
	64	ColourValue mHalfColour;
	65	Real mMinSize;
	66	Real mSizeRange;
	67	Real intensity;
	68	public:
	69	LightWibbler(Light* light, Billboard* billboard, const ColourValue& minColour,
	70	const ColourValue& maxColour, Real minSize, Real maxSize)
	71	{
	72	mLight = light;
	73	mBillboard = billboard;
	74	mColourRange.r = (maxColour.r - minColour.r) * 0.5;
	75	mColourRange.g = (maxColour.g - minColour.g) * 0.5;
	76	mColourRange.b = (maxColour.b - minColour.b) * 0.5;
	77	mHalfColour = minColour + mColourRange;
	78	mMinSize = minSize;
	79	mSizeRange = maxSize - minSize;
	80	}
	81
	82	virtual Real getValue (void) const
	83	{
	84	return intensity;
	85	}
	86
	87	virtual void setValue (Real value)
	88	{
	89	intensity = value;
	90
	91	ColourValue newColour;
	92
	93	// Attenuate the brightness of the light
	94	newColour.r = mHalfColour.r + (mColourRange.r * intensity);
	95	newColour.g = mHalfColour.g + (mColourRange.g * intensity);
	96	newColour.b = mHalfColour.b + (mColourRange.b * intensity);
	97
	98	mLight->setDiffuseColour(newColour);
	99	mBillboard->setColour(newColour);
	100	// set billboard size
	101	Real newSize = mMinSize + (intensity * mSizeRange);
	102	mBillboard->setDimensions(newSize, newSize);
	103
	104	}
	105	};
	106
	107	class GrassListener : public ExampleFrameListener
	108	{
	109	protected:
	110	SceneManager* mSceneManager;
	111	bool mShowBBs;
	112	public:
	113	GrassListener(RenderWindow* win, Camera* cam, SceneManager* sceneManager)
	114	: ExampleFrameListener(win, cam),
	115	mSceneManager(sceneManager), mShowBBs(false)
	116	{
	117	}
	118
	119
	120	void waveGrass(Real timeElapsed)
	121	{
	122	static Real xinc = Math::PI * 0.4;
	123	static Real zinc = Math::PI * 0.55;
	124	static Real xpos = Math::RangeRandom(-Math::PI, Math::PI);
	125	static Real zpos = Math::RangeRandom(-Math::PI, Math::PI);
	126
	127	xpos += xinc * timeElapsed;
	128	zpos += zinc * timeElapsed;
	129
	130	// Update vertex program parameters by binding a value to each renderable
	131	static Vector4 offset(0,0,0,0);
	132
	133	StaticGeometry::RegionIterator rit = mStaticGeom->getRegionIterator();
	134	while (rit.hasMoreElements())
	135	{
	136	StaticGeometry::Region* reg = rit.getNext();
	137
	138	// a little randomness
	139	xpos += reg->getCentre().x * 0.001;
	140	zpos += reg->getCentre().z * 0.001;
	141	offset.x = Math::Sin(xpos) * 0.05;
	142	offset.z = Math::Sin(zpos) * 0.05;
	143
	144	StaticGeometry::Region::LODIterator lodit = reg->getLODIterator();
	145	while (lodit.hasMoreElements())
	146	{
	147	StaticGeometry::LODBucket* lod = lodit.getNext();
	148	StaticGeometry::LODBucket::MaterialIterator matit =
	149	lod->getMaterialIterator();
	150	while (matit.hasMoreElements())
	151	{
	152	StaticGeometry::MaterialBucket* mat = matit.getNext();
	153	StaticGeometry::MaterialBucket::GeometryIterator geomit =
	154	mat->getGeometryIterator();
	155	while (geomit.hasMoreElements())
	156	{
	157	StaticGeometry::GeometryBucket* geom = geomit.getNext();
	158	geom->setCustomParameter(OFFSET_PARAM, offset);
	159
	160	}
	161	}
	162	}
	163	}
	164
	165	}
	166
	167	bool frameStarted(const FrameEvent& evt)
	168	{
	169	bool ok = ExampleFrameListener::frameStarted(evt);
	170
	171	static Real timeDelay = 0;
	172	timeDelay -= evt.timeSinceLastFrame;
	173
	174	if (mAnimState)
	175	mAnimState->addTime(evt.timeSinceLastFrame);
	176
	177	KEY_PRESSED(KC_B, 1,
	178	mShowBBs = !mShowBBs;
	179	mSceneManager->showBoundingBoxes(mShowBBs);
	180	)
	181
	182	waveGrass(evt.timeSinceLastFrame);
	183
	184	return ok;
	185	}
	186
	187
	188
	189
	190	};
	191
	192
	193
	194	class Grass_Application : public ExampleApplication
	195	{
	196	public:
	197	Grass_Application() {}
	198
	199	protected:
	200	SceneNode *mpObjsNode; // the node wich will hold our entities
	201
	202	void createGrassMesh()
	203	{
	204	// Each grass section is 3 planes at 60 degrees to each other
	205	// Normals point straight up to simulate correct lighting
	206	MeshPtr msh = MeshManager::getSingleton().createManual(GRASS_MESH_NAME,
	207	ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
	208	SubMesh* sm = msh->createSubMesh();
	209	sm->useSharedVertices = false;
	210	sm->vertexData = new VertexData();
	211	sm->vertexData->vertexStart = 0;
	212	sm->vertexData->vertexCount = 12;
	213	VertexDeclaration* dcl = sm->vertexData->vertexDeclaration;
	214	size_t offset = 0;
	215	dcl->addElement(0, offset, VET_FLOAT3, VES_POSITION);
	216	offset += VertexElement::getTypeSize(VET_FLOAT3);
	217	dcl->addElement(0, offset, VET_FLOAT3, VES_NORMAL);
	218	offset += VertexElement::getTypeSize(VET_FLOAT3);
	219	dcl->addElement(0, offset, VET_FLOAT2, VES_TEXTURE_COORDINATES);
	220	offset += VertexElement::getTypeSize(VET_FLOAT2);
	221
	222	HardwareVertexBufferSharedPtr vbuf = HardwareBufferManager::getSingleton()
	223	.createVertexBuffer(
	224	offset, 12, HardwareBuffer::HBU_STATIC_WRITE_ONLY);
	225	float* pReal = static_cast<float*>(vbuf->lock(HardwareBuffer::HBL_DISCARD));
	226	Vector3 baseVec(GRASS_WIDTH/2, 0, 0);
	227	Vector3 vec = baseVec;
	228	Quaternion rot;
	229	rot.FromAngleAxis(Degree(60), Vector3::UNIT_Y);
	230	int i;
	231	for (i = 0; i < 3; ++i)
	232	{
	233	// position
	234	*pReal++ = -vec.x;
	235	*pReal++ = GRASS_HEIGHT;
	236	*pReal++ = -vec.z;
	237	// normal
	238	*pReal++ = 0;
	239	*pReal++ = 1;
	240	*pReal++ = 0;
	241	// uv
	242	*pReal++ = 0;
	243	*pReal++ = 0;
	244
	245	// position
	246	*pReal++ = vec.x;
	247	*pReal++ = GRASS_HEIGHT;
	248	*pReal++ = vec.z;
	249	// normal
	250	*pReal++ = 0;
	251	*pReal++ = 1;
	252	*pReal++ = 0;
	253	// uv
	254	*pReal++ = 1;
	255	*pReal++ = 0;
	256
	257	// position
	258	*pReal++ = -vec.x;
	259	*pReal++ = 0;
	260	*pReal++ = -vec.z;
	261	// normal
	262	*pReal++ = 0;
	263	*pReal++ = 1;
	264	*pReal++ = 0;
	265	// uv
	266	*pReal++ = 0;
	267	*pReal++ = 1;
	268
	269	// position
	270	*pReal++ = vec.x;
	271	*pReal++ = 0;
	272	*pReal++ = vec.z;
	273	// normal
	274	*pReal++ = 0;
	275	*pReal++ = 1;
	276	*pReal++ = 0;
	277	// uv
	278	*pReal++ = 1;
	279	*pReal++ = 1;
	280
	281	vec = rot * vec;
	282	}
	283	vbuf->unlock();
	284	sm->vertexData->vertexBufferBinding->setBinding(0, vbuf);
	285	sm->indexData->indexCount = 6*3;
	286	sm->indexData->indexBuffer = HardwareBufferManager::getSingleton()
	287	.createIndexBuffer(HardwareIndexBuffer::IT_16BIT, 6*3,
	288	HardwareBuffer::HBU_STATIC_WRITE_ONLY);
	289	uint16* pI = static_cast<uint16*>(
	290	sm->indexData->indexBuffer->lock(HardwareBuffer::HBL_DISCARD));
	291	for (i = 0; i < 3; ++i)
	292	{
	293	int off = i*4;
	294	*pI++ = 0 + off;
	295	*pI++ = 3 + off;
	296	*pI++ = 1 + off;
	297
	298	*pI++ = 0 + off;
	299	*pI++ = 2 + off;
	300	*pI++ = 3 + off;
	301	}
	302
	303	sm->indexData->indexBuffer->unlock();
	304
	305	sm->setMaterialName(GRASS_MATERIAL);
	306	msh->load();
	307
	308	}
	309
	310	void setupLighting()
	311	{
	312	// Set ambient light
	313	mSceneMgr->setAmbientLight(ColourValue(0.2, 0.2, 0.2));
	314	// Point light, movable, reddish
	315	mLight = mSceneMgr->createLight("Light2");
	316	mLight->setDiffuseColour(mMinLightColour);
	317	mLight->setSpecularColour(1, 1, 1);
	318	mLight->setAttenuation(8000,1,0.0005,0);
	319
	320	// Create light node
	321	mLightNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(
	322	"MovingLightNode");
	323	mLightNode->attachObject(mLight);
	324	// create billboard set
	325	BillboardSet* bbs = mSceneMgr->createBillboardSet("lightbbs", 1);
	326	bbs->setMaterialName("Examples/Flare");
	327	Billboard* bb = bbs->createBillboard(0,0,0,mMinLightColour);
	328	// attach
	329	mLightNode->attachObject(bbs);
	330
	331	// create controller, after this is will get updated on its own
	332	ControllerFunctionRealPtr func = ControllerFunctionRealPtr(
	333	new WaveformControllerFunction(Ogre::WFT_SINE, 0.0, 0.5));
	334	ControllerManager& contMgr = ControllerManager::getSingleton();
	335	ControllerValueRealPtr val = ControllerValueRealPtr(
	336	new LightWibbler(mLight, bb, mMinLightColour, mMaxLightColour,
	337	mMinFlareSize, mMaxFlareSize));
	338	Controller<Real>* controller = contMgr.createController(
	339	contMgr.getFrameTimeSource(), val, func);
	340
	341	//mLight->setPosition(Vector3(300,250,-300));
	342	mLightNode->setPosition(Vector3(300,250,-300));
	343
	344
	345	// Create a track for the light
	346	Animation* anim = mSceneMgr->createAnimation("LightTrack", 20);
	347	// Spline it for nice curves
	348	anim->setInterpolationMode(Animation::IM_SPLINE);
	349	// Create a track to animate the camera's node
	350	AnimationTrack* track = anim->createTrack(0, mLightNode);
	351	// Setup keyframes
	352	KeyFrame* key = track->createKeyFrame(0); // A startposition
	353	key->setTranslate(Vector3(300,550,-300));
	354	key = track->createKeyFrame(2);//B
	355	key->setTranslate(Vector3(150,600,-250));
	356	key = track->createKeyFrame(4);//C
	357	key->setTranslate(Vector3(-150,650,-100));
	358	key = track->createKeyFrame(6);//D
	359	key->setTranslate(Vector3(-400,500,-200));
	360	key = track->createKeyFrame(8);//E
	361	key->setTranslate(Vector3(-200,500,-400));
	362	key = track->createKeyFrame(10);//F
	363	key->setTranslate(Vector3(-100,450,-200));
	364	key = track->createKeyFrame(12);//G
	365	key->setTranslate(Vector3(-100,400,180));
	366	key = track->createKeyFrame(14);//H
	367	key->setTranslate(Vector3(0,250,600));
	368	key = track->createKeyFrame(16);//I
	369	key->setTranslate(Vector3(100,650,100));
	370	key = track->createKeyFrame(18);//J
	371	key->setTranslate(Vector3(250,600,0));
	372	key = track->createKeyFrame(20);//K == A
	373	key->setTranslate(Vector3(300,550,-300));
	374	// Create a new animation state to track this
	375	mAnimState = mSceneMgr->createAnimationState("LightTrack");
	376	mAnimState->setEnabled(true);
	377	}
	378
	379	void createScene(void)
	380	{
	381
	382	mSceneMgr->setSkyBox(true, "Examples/SpaceSkyBox");
	383
	384	setupLighting();
	385
	386
	387	Plane plane;
	388	plane.normal = Vector3::UNIT_Y;
	389	plane.d = 0;
	390	MeshManager::getSingleton().createPlane("Myplane",
	391	ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane,
	392	14500,14500,10,10,true,1,50,50,Vector3::UNIT_Z);
	393	Entity* pPlaneEnt = mSceneMgr->createEntity( "plane", "Myplane" );
	394	pPlaneEnt->setMaterialName("Examples/GrassFloor");
	395	pPlaneEnt->setCastShadows(false);
	396	mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(pPlaneEnt);
	397
	398	Vector3 minV(-2000,0,-2000);
	399	Vector3 maxV(2000,0,2000);
	400
	401
	402	createGrassMesh();
	403
	404	Entity* e = mSceneMgr->createEntity("1", GRASS_MESH_NAME);
	405
	406	StaticGeometry* s = mSceneMgr->createStaticGeometry("bing");
	407	s->setRegionDimensions(Vector3(1000,1000,1000));
	408	// Set the region origin so the centre is at 0 world
	409	s->setOrigin(Vector3(-500, 500, -500));
	410
	411	for (int x = -1950; x < 1950; x += 150)
	412	{
	413	for (int z = -1950; z < 1950; z += 150)
	414	{
	415	Vector3 pos(
	416	x + Math::RangeRandom(-25, 25),
	417	0,
	418	z + Math::RangeRandom(-25, 25));
	419	Quaternion orientation;
	420	orientation.FromAngleAxis(
	421	Degree(Math::RangeRandom(0, 359)),
	422	Vector3::UNIT_Y);
	423	Vector3 scale(
	424	1, Math::RangeRandom(0.85, 1.15), 1);
	425	s->addEntity(e, pos, orientation, scale);
	426	}
	427
	428	}
	429
	430	s->build();
	431	mStaticGeom = s;
	432
	433	// Put an Ogre head in the middle
	434	MeshPtr m = MeshManager::getSingleton().load("ogrehead.mesh",
	435	ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
	436	unsigned short src, dest;
	437	if (!m->suggestTangentVectorBuildParams(src, dest))
	438	{
	439	m->buildTangentVectors(src, dest);
	440	}
	441	e = mSceneMgr->createEntity("head", "ogrehead.mesh");
	442	e->setMaterialName("Examples/OffsetMapping/Specular");
	443	SceneNode* headNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
	444	headNode->attachObject(e);
	445	headNode->setScale(7,7,7);
	446	headNode->setPosition(0,200,0);
	447	e->setNormaliseNormals(true);
	448	mCamera->move(Vector3(0,350,0));
	449	}
	450
	451	// Create new frame listener
	452	void createFrameListener(void)
	453	{
	454	mFrameListener= new GrassListener(mWindow, mCamera, mSceneMgr);
	455	mRoot->addFrameListener(mFrameListener);
	456	}
	457	};
	458
	459	#ifdef __cplusplus
	460	extern "C" {
	461	#endif
	462
	463	#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
	464	INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT )
	465	#else
	466	int main(int argc, char **argv)
	467	#endif
	468	{
	469	// Create application object
	470	Grass_Application app;
	471
	472	try {
	473	app.go();
	474	} catch( Exception& e ) {
	475	#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
	476	MessageBox( NULL, e.getFullDescription().c_str(), "An exception has occured!", MB_OK \| MB_ICONERROR \| MB_TASKMODAL);
	477	#else
	478	std::cerr << "An exception has occured: " << e.getFullDescription();
	479	#endif
	480	}
	481
	482	return 0;
	483	}
	484
	485	#ifdef __cplusplus
	486	}
	487	#endif
	488

Note: See TracBrowser for help on using the repository browser.

Download in other formats: