Context Navigation

source: trunk/packages/vizservers/nanovis/ParticleSystem.cpp @ 2844

Last change on this file since 2844 was 2831, checked in by ldelgass, 12 years ago
Refactor texture classes, misc. cleanups, cut down on header pollution -- still need to fix header deps in Makefile.in
File size: 61.0 KB

Line
1	/* -- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -- */
2	#include "nvconf.h"
3
4	#include <time.h>
5	#include <stdlib.h>
6	#include <stdio.h>
7	#include <pthread.h>
8
9	#ifdef HAVE_OPENCV_H
10	#include <opencv/cv.h>
11	#endif
12	#ifdef HAVE_OPENCV_HIGHGUI_H
13	#include <opencv/highgui.h>
14	#endif
15
16	#include <vr3d/vr3d.h>
17	#include <vr3d/vrTexture3D.h>
18
19	#include <Cg/cgGL.h>
20
21	#include <vrutil/vrFilePath.h>
22
23	#include <vrmath/vrMatrix4x4f.h>
24	#include <vrmath/vrVector3f.h>
25	#include <vrmath/vrVector4f.h>
26
27	#include "ParticleSystem.h"
28	#include "ParticleEmitter.h"
29	#include "Trace.h"
30
31	#define USE_RGBA_ARROW
32
33	//#define TEST
34	// TEST
35	extern void*
36	LoadFlowDx(const char* fname, int& width, int& height, int& depth,
37	float& min, float& max, float& nonzero_min,
38	float& axisScaleX, float& axisScaleY, float& axisScaleZ);
39
40	extern void*
41	LoadFlowRaw(const char* fname, int width, int height, int depth,
42	float& min, float& max, float& nonzero_min,
43	float& axisScaleX, float& axisScaleY, float& axisScaleZ,
44	int skipByte, bool bigEndian);
45
46	extern void*
47	LoadProcessedFlowRaw(const char* fname, int width, int height, int depth,
48	float min, float max,
49	float& axisScaleX, float& axisScaleY, float& axisScaleZ,
50	int skipByte);
51
52	extern void
53	LoadProcessedFlowRaw(const char* fname, int width, int height, int depth,
54	float* data);
55
56	inline float randomRange(float rangeMin, float rangeMax)
57	{
58	return ((float)rand() / RAND_MAX) * (rangeMax - rangeMin) + rangeMin ;
59	}
60
61	inline int logd(int value)
62	{
63	int l;
64	for (l = 0; value >> l; l++);
65	return l - 1;
66	}
67
68	inline void swap(int& x, int& y)
69	{
70	if (x != y) {
71	x ^= y;
72	y ^= x;
73	x ^= y;
74	}
75	}
76
77	void ParticleSystem::dataLoadMain(void data)
78	{
79	ParticleSystem particleSystem = (ParticleSystem )data;
80	CircularFifo<float*, 10>& queue = particleSystem->_queue;
81
82	// TBD..
83	//float min = particleSystem->_time_series_vel_mag_min;
84	//float max = particleSystem->_time_series_vel_mag_max;
85
86	int startIndex = particleSystem->_flowFileStartIndex;
87	int endIndex = particleSystem->_flowFileEndIndex;
88
89	int curIndex = startIndex;
90	int flowWidth = particleSystem->_flowWidth;
91	int flowHeight = particleSystem->_flowHeight;
92	int flowDepth = particleSystem->_flowDepth;
93
94	const char* fileNameFormat = particleSystem->_fileNameFormat.c_str();
95	char buff[256];
96
97	bool done = false;
98	while (!done) {
99	if (curIndex > endIndex) {
100	curIndex = startIndex;
101	}
102
103	if (!queue.isFull()) {
104	int tail = queue.tailIndex();
105	if (tail != -1) {
106	sprintf(buff, fileNameFormat, curIndex);
107	//std::string path = vrFilePath::getInstance()->getPath(buff);
108	#ifdef WANT_TRACE
109	float t = clock() /(float) CLOCKS_PER_SEC;
110	#endif
111	LoadProcessedFlowRaw(buff, flowWidth, flowHeight, flowDepth, queue.array[tail]);
112	#ifdef WANT_TRACE
113	float ti = clock() / (float) CLOCKS_PER_SEC;
114	TRACE("LoadProcessedFlowRaw time: %f\n", ti - t);
115	#endif
116	queue.push();
117	TRACE("%d loaded\n", curIndex);
118	++curIndex;
119	}
120	}
121	}
122
123	return 0;
124	}
125
126	CGcontext ParticleSystem::_context = 0;
127
128	unsigned int SpotTexID = 0;
129
130	void MakeSphereTexture()
131	{
132	const int DIM = 128;
133	const int DIM2 = 63;
134	//const float TEX_SCALE = 6.0;
135
136	glGenTextures(1, (GLuint *)&SpotTexID);
137	glBindTexture(GL_TEXTURE_2D, SpotTexID);
138
139	float col[4] = {1.f, 1.f, 1.f, 1.f};
140	glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, col);
141	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
142
143	float img = new float[DIMDIM];
144
145	vrVector3f light(1,1,3);
146	light.normalize();
147
148	for (int y = 0; y < DIM; y++) {
149	for (int x = 0; x < DIM; x++) {
150	// Clamping the edges to zero allows Nvidia's blend optimizations to do their thing.
151	if (x == 0 \|\| x == DIM-1 \|\| y == 0 \|\| y == DIM-1) {
152	img[y*DIM+x] = 0;
153	} else {
154	vrVector3f p(x, y, 0);
155	p = p - vrVector3f(DIM2, DIM2, 0);
156	float len = p.length();
157	float z = sqrt(DIM2DIM2 - lenlen);
158	p.z = z;
159	if (len >= DIM2) {
160	img[y*DIM+x] = 0.0;
161	continue;
162	}
163
164	p.normalize();
165	float v = p.dot(light);
166	if(v < 0) v = 0;
167
168	img[y*DIM+x] = v;
169	}
170	}
171	}
172
173	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
174	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
175	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
176	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
177
178	gluBuild2DMipmaps(GL_TEXTURE_2D, GL_ALPHA16, DIM, DIM, GL_ALPHA, GL_FLOAT, img);
179	}
180
181	//extern void algorithm_test(vrVector4f* data, int flowWidth, int flowHeight, int flowDepth);
182	//extern std::vector<vrVector3f>* find_critical_points(vrVector4f* data, int flowWidth, int flowHeight, int flowDepth);
183	ParticleSystem::ParticleSystem(int width, int height,
184	const std::string& fileName,
185	int fieldWidth, int fieldHeight, int fieldDepth,
186	bool timeVaryingData,
187	int flowFileStartIndex, int flowFileEndIndex) :
188	_width(width),
189	_height(height)
190	{
191	////////////////////////////////
192	// TIME-VARYING SERIES
193	_isTimeVaryingField = timeVaryingData;
194	_flowFileStartIndex = flowFileStartIndex;
195	_flowFileEndIndex = flowFileEndIndex;
196	_userDefinedParticleMaxCount = width * height;
197
198	_skipByte = 0;
199
200	_screenWidth = _screenHeight = 1;
201	_fov = 60.0f;
202
203	_particleMaxCount = _width * _height;
204
205	_pointSize = 10.0f;
206	_camx = 0.0f;
207	_camy = 0.0f;
208	_camz = 0.0f;
209
210	_scalex = _scaley = _scalez = 1.0f;
211	_currentSortIndex = 0;
212	_destSortIndex = 1;
213
214	_currentPosIndex = 0;
215	_destPosIndex = 1;
216
217	_currentSortPass = 0;
218	// TBD
219	//_sortPassesPerFrame = 5;
220	_sortPassesPerFrame = 4;
221	_maxSortPasses = 0;
222
223	_sortBegin = 0;
224	_sortEnd = _sortPassesPerFrame;
225	_currentTime = 0;
226	_sortEnabled = false;
227	_glyphEnabled = false;
228	_advectionEnabled = false;
229	_streamlineEnabled = false;
230	_particles = new Particle[_particleMaxCount];
231	memset(_particles, 0, sizeof(Particle) * _particleMaxCount);
232
233	_colorBuffer = new color4[_particleMaxCount];
234	memset(_colorBuffer, 0, sizeof(color4) * _particleMaxCount);
235
236	_positionBuffer = new vrVector3f[_particleMaxCount];
237	_vertices = new RenderVertexArray(_particleMaxCount, 3, GL_FLOAT);
238
239	srand(time(0));
240
241	/*
242	// TBD..
243	glGenBuffersARB(1, &_colorBufferID);
244	glBindBufferARB(GL_ARRAY_BUFFER, _colorBufferID);
245	glBufferDataARB(GL_ARRAY_BUFFER, _width * _height * 4, _colorBuffer, GL_STREAM_DRAW_ARB); // undefined data
246	glBindBufferARB(GL_ARRAY_BUFFER, 0);
247	*/
248
249	_flowWidth = fieldWidth;
250	_flowHeight = fieldHeight;
251	_flowDepth = fieldDepth;
252
253	float min, max, nonzero_min, axisScaleX, axisScaleY, axisScaleZ;
254	int index = fileName.rfind('.');
255	std::string ext = fileName.substr(index + 1, fileName.size() - (index + 1));
256	float *data = 0;
257
258	if (this->isTimeVaryingField()) {
259	axisScaleX = _flowWidth;
260	axisScaleY = _flowHeight;
261	axisScaleZ = _flowDepth;
262	_fileNameFormat = fileName;
263	for (int i = 0; i < CircularFifo<float*, 10>::Capacity; ++i) {
264	_queue.array[i] = new float[_flowWidth * _flowHeight * _flowDepth * 4];
265	}
266
267	// INSOO
268	// TBD
269	min = 0;
270	max = 234.99;
271	} else {
272	if (ext == "dx") {
273	data = (float*) LoadFlowDx(fileName.c_str(), _flowWidth, _flowHeight, _flowDepth, min, max, nonzero_min, axisScaleX, axisScaleY, axisScaleZ);
274	} else if (ext == "raw") {
275	data = (float*) LoadFlowRaw(fileName.c_str(), _flowWidth, _flowHeight, _flowDepth, min, max, nonzero_min, axisScaleX, axisScaleY, axisScaleZ, 0, false);
276	//data = (float*) LoadProcessedFlowRaw(fileName.c_str(), _flowWidth, _flowHeight, _flowDepth, min, max, axisScaleX, axisScaleY, axisScaleZ);
277	#ifdef notdef
278	} else if (ext == "raws") {
279	data = (float) LoadFlowRaw(fileName.c_str(), _flowWidth, _flowHeight, _flowDepth, min, max, nonzero_min, axisScaleX, axisScaleY, axisScaleZ, 5 sizeof(int), true);
280	} else if (ext == "data") {
281	data = (float*) LoadFlowRaw(fileName.c_str(), _flowWidth, _flowHeight, _flowDepth, min, max, nonzero_min, axisScaleX, axisScaleY, axisScaleZ, 0, true);
282	#endif
283	}
284	//_criticalPoints = find_critical_points((vrVector4f*) data, _flowWidth, _flowHeight, _flowDepth);
285	//algorithm_test((vrVector4f*) data, _flowWidth, _flowHeight, _flowDepth);
286	}
287
288	_scalex = 1;
289	_scaley = axisScaleY / axisScaleX;
290	_scalez = axisScaleZ / axisScaleX;
291	_maxVelocityScale = max;
292
293	if (!this->isTimeVaryingField()) {
294	vrTexture3D* flow = new vrTexture3D();
295	flow->setMinFilter(TF_LINEAR);
296	flow->setMagFilter(TF_LINEAR);
297	flow->setPixels(CF_RGBA, DT_FLOAT, _flowWidth, _flowHeight, _flowDepth, data);
298	this->_curVectorFieldID = flow->getGraphicsObjectID();
299	_vectorFieldIDs.push_back(_curVectorFieldID);
300	} else {
301	for (int i = 0; i < 3; ++i) {
302	vrTexture3D* flow = new vrTexture3D();
303	flow->setMinFilter(TF_LINEAR);
304	flow->setMagFilter(TF_LINEAR);
305	flow->setPixels(CF_RGBA, DT_FLOAT, _flowWidth, _flowHeight, _flowDepth, data);
306	_vectorFields.push_back(flow);
307	_vectorFieldIDs.push_back(flow->getGraphicsObjectID());
308	}
309	this->_curVectorFieldID = _vectorFieldIDs[0];
310	}
311
312	_arrows = new vrTexture2D();
313	_arrows->setWrapS(TW_MIRROR);
314	_arrows->setWrapT(TW_MIRROR);
315
316	#ifndef USE_RGBA_ARROW
317	IplImage* pTextureImage = cvLoadImage("arrows_flip2.png");
318	_arrows->setPixels(CF_RGB, DT_UBYTE, pTextureImage->width, pTextureImage->height, pTextureImage->imageData);
319	#else
320	#ifdef notdef
321	// TBD..
322	std::string path = vrFilePath::getInstance()->getPath("arrows_red_bg.bmp");
323	AUX_RGBImageRec *pTextureImage = auxDIBImageLoad(path.c_str());
324	unsigned char* pixels = new unsigned char [pTextureImage->sizeX * pTextureImage->sizeY * sizeof(unsigned char) * 4];
325	unsigned char* srcPixels = pTextureImage->data;
326	unsigned char* dstPixels = pixels;
327	for (int i = 0; i < pTextureImage->sizeX * pTextureImage->sizeY; ++i) {
328	dstPixels = srcPixels; ++srcPixels;
329	(dstPixels + 1) = srcPixels; ++srcPixels;
330	(dstPixels + 2) = srcPixels; ++srcPixels;
331
332	if ((dstPixels > 127) && ((dstPixels + 1) < 127) && (*(dstPixels + 2) < 127)) {
333	*(dstPixels + 3) = 0;
334	} else {
335	*(dstPixels + 3) = 255;
336	}
337
338	dstPixels += 4;
339	}
340
341	_arrows->setPixels(CF_RGBA, DT_UBYTE, pTextureImage->sizeX, pTextureImage->sizeY, (void*) pixels);
342	#endif
343
344	#endif // USE_RGBA_ARROW
345
346	#ifdef TEST
347	MakeSphereTexture();
348	#endif
349
350	glGenBuffersARB(1, &_particleInfoBufferID);
351	glBindBufferARB(GL_ARRAY_BUFFER_ARB, _particleInfoBufferID);
352	glBufferDataARB(GL_ARRAY_BUFFER_ARB, _particleMaxCount * 4 * sizeof(float), 0, GL_DYNAMIC_DRAW);
353	glVertexAttribPointerARB(8, 4, GL_FLOAT, GL_FALSE, 0, 0); // 8 = texcoord0
354	glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
355
356	// TBD..
357	initStreamlines(_width, _height);
358	initInitPosTex();
359
360	initShaders();
361	createRenderTargets();
362	createSortRenderTargets();
363	createStreamlineRenderTargets();
364
365	if (this->isTimeVaryingField()) {
366	pthread_t _threads;
367	pthread_attr_t pthread_custom_attr;
368	pthread_attr_init(&pthread_custom_attr);
369	pthread_create(&_threads, &pthread_custom_attr, dataLoadMain, (void *) this);
370	}
371	}
372
373	void ParticleSystem::initInitPosTex()
374	{
375	glGenFramebuffersEXT(1, &_initPos_fbo);
376	glGenTextures(1, &_initPosTex);
377
378	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _initPos_fbo);
379
380	glViewport(0, 0, _width, _height);
381	glMatrixMode(GL_PROJECTION);
382	glLoadIdentity();
383	glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
384	glMatrixMode(GL_MODELVIEW);
385	glLoadIdentity();
386
387	glBindTexture(GL_TEXTURE_RECTANGLE_NV, _initPosTex);
388	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
389	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
390	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
391	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
392	glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RGB_NV,
393	_width, _height, 0, GL_RGB, GL_FLOAT, NULL);
394	glBindTexture(GL_TEXTURE_RECTANGLE_NV, 0);
395
396	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
397	GL_TEXTURE_RECTANGLE_NV, _initPosTex, 0);
398
399	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
400	}
401
402	void ParticleSystem::initStreamlines(int width, int height)
403	{
404	_atlas_x = 32;
405	_atlas_y = 32;
406
407	_atlasWidth = width * _atlas_x;
408	_atlasHeight = height * _atlas_y;
409	_maxAtlasCount = _atlas_x * _atlas_y;
410
411	_stepSizeStreamline = 1;
412	_curStepCount = 0;
413	_particleCount = width * height;
414
415	_currentStreamlineOffset = 0;
416	_currentStreamlineIndex = 0;
417	_streamVertices = new RenderVertexArray(_atlasWidth_atlasHeight 2, 3, GL_FLOAT);
418
419	_maxIndexBufferSize = _width * _height * _atlas_x * _atlas_y;
420	_indexBuffer = new unsigned int[_maxIndexBufferSize * 2];
421	unsigned int* pindex = _indexBuffer;
422	int ax, ay, old_ax = 0, old_ay = 0;
423	for (unsigned int i = 1; i < _maxAtlasCount; ++i) {
424	ax = (i % _atlas_x) * width;
425	ay = (i / _atlas_x) * height;
426
427	for (int y = 0; y < height ; ++y) {
428	for (int x = 0; x < width; ++x) {
429	pindex = (old_ay + y) _atlasWidth + old_ax + x; ++pindex;
430	pindex = (ay + y) _atlasWidth + ax + x; ++pindex;
431	}
432	}
433
434	old_ax = ax;
435	old_ay = ay;
436	}
437	}
438
439	void ParticleSystem::callbackForCgError()
440	{
441	CGerror lastError = cgGetError();
442	if (lastError) {
443	const char *listing = cgGetLastListing(_context);
444	ERROR("\n---------------------------------------------------\n");
445	ERROR("%s\n\n", cgGetErrorString(lastError));
446	ERROR("%s\n", listing);
447	ERROR("-----------------------------------------------------\n");
448	ERROR("Cg error, exiting...\n");
449
450	cgDestroyContext(_context);
451	getchar();
452	exit(-1);
453	}
454	}
455
456	void ParticleSystem::initShaders()
457	{
458	// TBD...
459	_context = cgCreateContext();
460	cgSetErrorCallback(callbackForCgError);
461
462	std::string path = vrFilePath::getInstance()->getPath("distance.cg");
463	_distanceInitFP =
464	cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
465	CG_PROFILE_FP30, "initSortIndex", NULL);
466	cgGLLoadProgram(_distanceInitFP);
467
468	_distanceSortFP =
469	cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
470	CG_PROFILE_FP30, "computeDistance", NULL);
471	_viewPosParam = cgGetNamedParameter(_distanceSortFP, "viewerPosition");
472	cgGLLoadProgram(_distanceSortFP);
473
474	_distanceSortLookupFP =
475	cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
476	CG_PROFILE_FP30, "lookupPosition", NULL);
477	cgGLLoadProgram(_distanceSortLookupFP);
478
479	path = vrFilePath::getInstance()->getPath("mergesort.cg");
480	_sortRecursionFP =
481	cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
482	CG_PROFILE_FP30, "mergeSortRecursion", NULL);
483	cgGLLoadProgram(_sortRecursionFP);
484
485	_srSizeParam = cgGetNamedParameter(_sortRecursionFP, "_Size");
486	_srStepParam = cgGetNamedParameter(_sortRecursionFP, "_Step");
487	_srCountParam = cgGetNamedParameter(_sortRecursionFP, "_Count");
488
489	_sortEndFP =
490	cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
491	CG_PROFILE_FP30, "mergeSortEnd", NULL);
492	cgGLLoadProgram(_sortEndFP);
493
494	_seSizeParam = cgGetNamedParameter(_sortEndFP, "size");
495	_seStepParam = cgGetNamedParameter(_sortEndFP, "step");
496
497	path = vrFilePath::getInstance()->getPath("passthrough.cg");
498	_passthroughFP =
499	cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
500	CG_PROFILE_FP30, "main", NULL);
501	cgGLLoadProgram(_passthroughFP);
502
503	_scaleParam = cgGetNamedParameter(_passthroughFP, "scale");
504	_biasParam = cgGetNamedParameter(_passthroughFP, "bias");
505
506	path = vrFilePath::getInstance()->getPath("moveparticles.cg");
507	_moveParticlesFP =
508	cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
509	CG_PROFILE_FP30, "main", NULL);
510	cgGLLoadProgram(_moveParticlesFP);
511	_mpTimeScale = cgGetNamedParameter(_moveParticlesFP, "timeStep");
512	_mpVectorField = cgGetNamedParameter(_moveParticlesFP, "vfield");
513	_mpUseInitTex= cgGetNamedParameter(_moveParticlesFP, "useInitPos");
514	_mpCurrentTime= cgGetNamedParameter(_moveParticlesFP, "currentTime");
515	_mpMaxScale = cgGetNamedParameter(_moveParticlesFP, "maxScale");
516	_mpScale= cgGetNamedParameter(_moveParticlesFP, "scale");
517
518	path = vrFilePath::getInstance()->getPath("particlevp.cg");
519	_particleVP =
520	cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
521	CG_PROFILE_VP40, "vpmain", NULL);
522	cgGLLoadProgram(_particleVP);
523	_mvpParticleParam = cgGetNamedParameter(_particleVP, "mvp");
524	_mvParticleParam = cgGetNamedParameter(_particleVP, "modelview");
525	_mvTanHalfFOVParam = cgGetNamedParameter(_particleVP, "tanHalfFOV");
526	_mvCurrentTimeParam = cgGetNamedParameter(_particleVP, "currentTime");
527
528	path = vrFilePath::getInstance()->getPath("particlefp.cg");
529	_particleFP =
530	cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
531	CG_PROFILE_FP40, "fpmain", NULL);
532	cgGLLoadProgram(_particleFP);
533	_vectorParticleParam = cgGetNamedParameter(_particleVP, "vfield");
534
535	path = vrFilePath::getInstance()->getPath("moveparticles.cg");
536	_initParticlePosFP =
537	cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
538	CG_PROFILE_FP30, "initParticlePosMain", NULL);
539	cgGLLoadProgram(_initParticlePosFP);
540	_ipVectorFieldParam = cgGetNamedParameter(_moveParticlesFP, "vfield");
541	}
542
543	void ParticleSystem::passThoughPositions()
544	{
545	cgGLBindProgram(_passthroughFP);
546	cgGLEnableProfile(CG_PROFILE_FP30);
547
548	cgGLSetParameter4f(_scaleParam, 1.0, 1.0, 1.0, 1.0);
549	cgGLSetParameter4f(_biasParam, 0.0, 0.0, 0.0, 0.0);
550
551	glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RGB_NV,
552	_width, _height, 0, GL_RGB, GL_FLOAT, (GLfloat *) _positionBuffer);
553
554	drawQuad();
555
556	cgGLDisableProfile(CG_PROFILE_FP30);
557	}
558
559	void ParticleSystem::resetStreamlines()
560	{
561	_currentStreamlineIndex = 0;
562	_currentStreamlineOffset = 0;
563	_curStepCount = 0;
564	}
565
566	void ParticleSystem::reset()
567	{
568	_currentTime = 0.0f;
569	_sortBegin = 0;
570	_sortEnd = _sortPassesPerFrame;
571
572	glPushAttrib(GL_VIEWPORT_BIT);
573	glMatrixMode(GL_PROJECTION);
574	glPushMatrix();
575	glMatrixMode(GL_MODELVIEW);
576
577	resetStreamlines();
578
579	unsigned int maxsize = _userDefinedParticleMaxCount;
580
581	while (!_availableIndices.empty())
582	_availableIndices.pop();
583	while (!_activeParticles.empty())
584	_activeParticles.pop();
585
586	_activeParticles.reserve(maxsize);
587	_availableIndices.reserve(maxsize);
588
589	for (unsigned int i = 0; i < maxsize; i++)
590	_availableIndices.push(i);
591
592	for (int i = 0; i < _particleMaxCount; i++) {
593	_particles[i].timeOfBirth = -1.0f;
594	_particles[i].lifeTime = 0.0f;
595	_particles[i].attributeType = 0.0f;
596	_particles[i].index = (float)i;
597	}
598
599	glBindBufferARB(GL_ARRAY_BUFFER_ARB, _particleInfoBufferID);
600	Particle* pinfo = (Particle*) glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY_ARB);
601
602	for (int i = 0; i < _particleMaxCount; i++) {
603	pinfo[i] = _particles[i];
604	}
605
606	glUnmapBufferARB(GL_ARRAY_BUFFER_ARB);
607
608	// POSITION
609	memset(_positionBuffer, 0, sizeof(vrVector3f) * _width * _height);
610	for (int y = 0; y < _height; y++) {
611	for (int x = 0; x < _width; x++) {
612	_positionBuffer[_width * y + x].x = (float)rand() / (float) RAND_MAX;
613	//_positionBuffer[_width * y + x].x = 0.9;
614	_positionBuffer[_width * y + x].y = (float)rand() / (float) RAND_MAX;
615	_positionBuffer[_width * y + x].z = (float)rand() / (float) RAND_MAX;
616	}
617	}
618
619	glBindTexture(GL_TEXTURE_RECTANGLE_NV, _initPosTex);
620	glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RGB_NV,
621	_width, _height, 0, GL_RGB, GL_FLOAT, (float*)_positionBuffer);
622	glBindTexture(GL_TEXTURE_RECTANGLE_NV, 0);
623
624	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_currentPosIndex]);
625	glViewport(0, 0, _width, _height);
626	glMatrixMode(GL_PROJECTION);
627	glLoadIdentity();
628	glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
629	glMatrixMode(GL_MODELVIEW);
630	glLoadIdentity();
631	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
632	passThoughPositions();
633	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
634
635	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, velocity_fbo[_currentPosIndex]);
636	glViewport(0, 0, _width, _height);
637	glMatrixMode(GL_PROJECTION);
638	glLoadIdentity();
639	glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
640	glMatrixMode(GL_MODELVIEW);
641	glLoadIdentity();
642	glClearColor(0, 0, 0, 0);
643	glClear(GL_COLOR_BUFFER_BIT);
644	// TBD..
645	// velocity
646	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
647
648
649	/// TBD...
650	//DeathTimePBuffer->BeginCapture();
651	//glClear(GL_COLOR_BUFFER_BIT);
652	//DeathTimePBuffer->EndCapture();
653
654	if (_sortEnabled) {
655	glDisable(GL_BLEND);
656	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_currentSortIndex]);
657	glViewport(0, 0, _width, _height);
658	glMatrixMode(GL_PROJECTION);
659	glLoadIdentity();
660	glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
661	glMatrixMode(GL_MODELVIEW);
662	glLoadIdentity();
663
664	cgGLBindProgram(_distanceInitFP);
665	cgGLEnableProfile(CG_PROFILE_FP30);
666
667	drawQuad();
668
669	cgGLDisableProfile(CG_PROFILE_FP30);
670	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
671
672	_currentSortPass = 0;
673	this->_maxSortPasses = 100000;
674	}
675
676	glMatrixMode(GL_PROJECTION);
677	glPopMatrix();
678	glMatrixMode(GL_MODELVIEW);
679	glPopAttrib();
680	}
681
682	void ParticleSystem::createRenderTargets()
683	{
684	glGenFramebuffersEXT(2, psys_fbo);
685	glGenTextures(2, psys_tex);
686
687	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[0]);
688
689	glViewport(0, 0, _width, _height);
690	glMatrixMode(GL_PROJECTION);
691	glLoadIdentity();
692	glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
693	glMatrixMode(GL_MODELVIEW);
694	glLoadIdentity();
695
696	glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[0]);
697	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
698	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
699	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
700	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
701
702	glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RGBA32_NV,
703	_width, _height, 0, GL_RGBA, GL_FLOAT, NULL);
704
705	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
706	GL_TEXTURE_RECTANGLE_NV, psys_tex[0], 0);
707
708	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[1]);
709
710	glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[1]);
711	glViewport(0, 0, _width, _height);
712	glMatrixMode(GL_PROJECTION);
713	glLoadIdentity();
714	glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
715	glMatrixMode(GL_MODELVIEW);
716	glLoadIdentity();
717
718	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
719	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
720	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
721	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
722
723	glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RGBA32_NV,
724	_width, _height, 0, GL_RGBA, GL_FLOAT, NULL);
725
726	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
727	GL_TEXTURE_RECTANGLE_NV, psys_tex[1], 0);
728
729	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
730	}
731
732	//#define ATLAS_TEXTURE_TARGET GL_TEXTURE_RECTANGLE_NV
733	//#define ATLAS_INTERNAL_TYPE GL_FLOAT_RGBA32_NV
734	#define ATLAS_TEXTURE_TARGET GL_TEXTURE_2D
735	#define ATLAS_INTERNAL_TYPE GL_RGBA
736
737	void ParticleSystem::createStreamlineRenderTargets()
738	{
739	glGenFramebuffersEXT(1, &_atlas_fbo);
740	glGenTextures(1, &_atlas_tex);
741	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _atlas_fbo);
742	glViewport(0, 0, _atlasWidth, _atlasHeight);
743	glMatrixMode(GL_PROJECTION);
744	glLoadIdentity();
745	glOrtho(0, _atlasWidth, 0, _atlasHeight, -10.0f, 10.0f);
746	glMatrixMode(GL_MODELVIEW);
747	glLoadIdentity();
748
749	glBindTexture(ATLAS_TEXTURE_TARGET, _atlas_tex);
750	glTexParameterf(ATLAS_TEXTURE_TARGET, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
751	glTexParameterf(ATLAS_TEXTURE_TARGET, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
752	//glTexParameteri(ATLAS_TEXTURE_TARGET, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
753	//glTexParameteri(ATLAS_TEXTURE_TARGET, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
754
755	glTexImage2D(ATLAS_TEXTURE_TARGET, 0, ATLAS_INTERNAL_TYPE,
756	_atlasWidth, _atlasHeight, 0, GL_RGBA, GL_FLOAT, NULL);
757
758	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
759	ATLAS_TEXTURE_TARGET, _atlas_tex, 0);
760
761	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
762	}
763
764	//#define SORT_TEXTURE_FORMAT GL_LUMINANCE_ALPHA
765	//#define SORT_TEXTURE_INNER_FORMAT GL_LUMINANCE_ALPHA_FLOAT32_ATI
766	#define SORT_TEXTURE_FORMAT GL_RGB
767	#define SORT_TEXTURE_INNER_FORMAT GL_FLOAT_RGB32_NV
768
769	void ParticleSystem::createSortRenderTargets()
770	{
771	glGenFramebuffersEXT(2, sort_fbo);
772	glGenTextures(2, sort_tex);
773
774	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[0]);
775	glViewport(0, 0, _width, _height);
776	glMatrixMode(GL_PROJECTION);
777	glLoadIdentity();
778	glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
779	glMatrixMode(GL_MODELVIEW);
780	glLoadIdentity();
781
782	glBindTexture(GL_TEXTURE_RECTANGLE_NV, sort_tex[0]);
783	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
784	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
785	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
786	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
787	glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, SORT_TEXTURE_INNER_FORMAT,
788	_width, _height, 0, SORT_TEXTURE_FORMAT, GL_FLOAT, NULL);
789
790	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
791	GL_TEXTURE_RECTANGLE_NV, sort_tex[0], 0);
792
793	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[1]);
794	glViewport(0, 0, _width, _height);
795	glMatrixMode(GL_PROJECTION);
796	glLoadIdentity();
797	glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
798	glMatrixMode(GL_MODELVIEW);
799	glLoadIdentity();
800
801	glBindTexture(GL_TEXTURE_RECTANGLE_NV, sort_tex[1]);
802	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
803	glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
804	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
805	glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
806	glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, SORT_TEXTURE_INNER_FORMAT,
807	_width, _height, 0, SORT_TEXTURE_FORMAT, GL_FLOAT, NULL);
808
809	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
810	GL_TEXTURE_RECTANGLE_NV, sort_tex[1], 0);
811
812	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
813	}
814
815	ParticleSystem::~ParticleSystem()
816	{
817	std::vector<ParticleEmitter*>::iterator iter;
818	for (iter = _emitters.begin(); iter != _emitters.end(); ++iter)
819	delete (*iter);
820
821	// Particle Position
822	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[0]);
823	glDeleteTextures(1, psys_tex);
824	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[1]);
825	glDeleteTextures(1, psys_tex+1);
826	glDeleteFramebuffersEXT(2, psys_fbo);
827
828	// Sort
829	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[0]);
830	glDeleteTextures(1, sort_tex);
831	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[1]);
832	glDeleteTextures(1, sort_tex+1);
833	glDeleteFramebuffersEXT(2, sort_fbo);
834
835	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, velocity_fbo[0]);
836	glDeleteTextures(1, velocity_tex);
837	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, velocity_fbo[1]);
838	glDeleteTextures(1, velocity_tex+1);
839	glDeleteFramebuffersEXT(2, velocity_fbo);
840
841	if (_vertices) delete _vertices;
842
843	delete [] _particles;
844	delete [] _positionBuffer;
845	delete [] _colorBuffer;
846
847	if (_arrows) delete _arrows;
848
849	// STREAM LINE
850	if (_streamVertices) delete _streamVertices;
851	if (_indexBuffer) delete _indexBuffer;
852
853	cgDestroyProgram(_distanceInitFP);
854
855	cgDestroyParameter(_viewPosParam);
856	cgDestroyProgram(_distanceSortFP);
857
858	cgDestroyProgram(_distanceSortLookupFP);
859
860	cgDestroyParameter(_scaleParam);
861	cgDestroyParameter(_biasParam);
862	cgDestroyProgram(_passthroughFP);
863
864	cgDestroyParameter(_srSizeParam);
865	cgDestroyParameter(_srStepParam);
866	cgDestroyParameter(_srCountParam);
867
868	cgDestroyProgram(_sortRecursionFP);
869
870	cgDestroyParameter(_seSizeParam);
871	cgDestroyParameter(_seStepParam);
872	cgDestroyProgram(_sortEndFP);
873
874	cgDestroyParameter(_mpTimeScale);
875	cgDestroyParameter(_mpVectorField);
876	cgDestroyParameter(_mpUseInitTex);
877	cgDestroyParameter(_mpCurrentTime);
878	cgDestroyProgram(_moveParticlesFP);
879
880	cgDestroyParameter(_ipVectorFieldParam);
881	cgDestroyProgram(_initParticlePosFP);
882
883	cgDestroyParameter(_mvpParticleParam);
884	cgDestroyParameter(_mvParticleParam);
885	cgDestroyParameter(_mvTanHalfFOVParam);
886	cgDestroyParameter(_mvCurrentTimeParam);
887	cgDestroyProgram(_particleFP);
888
889	cgDestroyParameter(_vectorParticleParam);
890	cgDestroyProgram(_particleVP);
891	}
892
893	bool ParticleSystem::isEnabled(EnableEnum enabled)
894	{
895	switch (enabled) {
896	case PS_SORT :
897	return _sortEnabled;
898	break;
899	case PS_GLYPH :
900	return _glyphEnabled;
901	break;
902	case PS_DRAW_BBOX :
903	return _drawBBoxEnabled;
904	break;
905	case PS_ADVECTION :
906	return _advectionEnabled;
907	case PS_STREAMLINE :
908	return _streamlineEnabled;
909	}
910	return false;
911	}
912
913	void ParticleSystem::enable(EnableEnum enabled)
914	{
915	switch (enabled) {
916	case PS_SORT :
917	_sortEnabled = true;
918	break;
919	case PS_GLYPH :
920	_glyphEnabled = true;
921	break;
922	case PS_DRAW_BBOX :
923	_drawBBoxEnabled = true;
924	break;
925	case PS_ADVECTION :
926	_advectionEnabled = true;
927	break;
928	case PS_STREAMLINE :
929	_streamlineEnabled = true;
930	break;
931	}
932	}
933
934	void ParticleSystem::disable(EnableEnum enabled)
935	{
936	switch (enabled) {
937	case PS_SORT :
938	_sortEnabled = false;
939	break;
940	case PS_GLYPH :
941	_glyphEnabled = false;
942	break;
943	case PS_DRAW_BBOX :
944	_drawBBoxEnabled = false;
945	break;
946	case PS_ADVECTION :
947	_advectionEnabled = false;
948	break;
949	case PS_STREAMLINE :
950	_streamlineEnabled = false;
951	break;
952	}
953	}
954
955	void ParticleSystem::advectStreamlines()
956	{
957	glDisable(GL_BLEND);
958	glDisable(GL_DEPTH_TEST);
959
960	//glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
961	//glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
962
963	glPushAttrib(GL_VIEWPORT_BIT);
964	glViewport(0, 0, _width, _height);
965	glMatrixMode(GL_PROJECTION);
966	glPushMatrix();
967	glLoadIdentity();
968	glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
969	glMatrixMode(GL_MODELVIEW);
970	glPushMatrix();
971	glLoadIdentity();
972
973	glEnable(GL_TEXTURE_RECTANGLE_NV);
974
975	cgGLBindProgram(_moveParticlesFP);
976	cgGLEnableProfile(CG_PROFILE_FP30);
977	cgGLSetParameter1f(_mpTimeScale, 0.005);
978	cgGLSetParameter1f(_mpUseInitTex, 1.0);
979	cgGLSetParameter1f(_mpCurrentTime, _currentTime);
980	cgGLSetParameter3f(_mpScale, _scalex, _scaley, _scalez);
981	cgGLSetParameter1f(_mpMaxScale, _maxVelocityScale);
982	cgGLSetTextureParameter(_mpVectorField, _curVectorFieldID);
983	cgGLEnableTextureParameter(_mpVectorField);
984
985	for (int i = 0; i < _stepSizeStreamline; ++i) {
986	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
987	glClear(GL_COLOR_BUFFER_BIT);
988	glActiveTextureARB(GL_TEXTURE0_ARB);
989	glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_currentPosIndex]);
990	glActiveTextureARB(GL_TEXTURE1_ARB);
991	glBindTexture(GL_TEXTURE_RECTANGLE_NV, _initPosTex);
992	drawQuad();
993	swap(_currentPosIndex, _destPosIndex);
994	}
995
996	cgGLDisableTextureParameter(_mpVectorField);
997	glDisable(GL_TEXTURE_RECTANGLE_NV);
998	cgGLDisableProfile(CG_PROFILE_FP30);
999
1000	glMatrixMode(GL_PROJECTION);
1001	glPopMatrix();
1002	glMatrixMode(GL_MODELVIEW);
1003	glPopMatrix();
1004	glPopAttrib();
1005	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
1006
1007	if (_currentStreamlineIndex < _maxAtlasCount) {
1008	int xoffset = (_currentStreamlineIndex % _atlas_x) * _width;
1009	int yoffset = (_currentStreamlineIndex / _atlas_x) * _height;
1010
1011	glActiveTextureARB(GL_TEXTURE0_ARB);
1012	glEnable(ATLAS_TEXTURE_TARGET);
1013	glBindTexture(ATLAS_TEXTURE_TARGET, _atlas_tex);
1014
1015	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
1016	//glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_currentPosIndex]);
1017	glCopyTexSubImage2D(ATLAS_TEXTURE_TARGET, 0, xoffset, yoffset,
1018	0, 0, _width, _height);
1019	glActiveTextureARB(GL_TEXTURE0_ARB);
1020	glBindTexture(ATLAS_TEXTURE_TARGET, 0);
1021	glDisable(ATLAS_TEXTURE_TARGET);
1022
1023	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _atlas_fbo);
1024	_streamVertices->Read(_atlasWidth, _atlasHeight);
1025	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
1026	_currentStreamlineIndex++;
1027
1028	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
1029	}
1030	}
1031
1032	bool ParticleSystem::advect(float deltaT, float camx, float camy, float camz)
1033	{
1034	static bool firstLoad = true;
1035	if (this->isTimeVaryingField()) {
1036	static float oldTime = vrGetTimeStamp();
1037	#ifdef WANT_TRACE
1038	static int index = 0;
1039	#endif
1040	float time = vrGetTimeStamp();
1041	if ((time - oldTime) > 2.0) {
1042	if (!_queue.isEmpty()) {
1043	float* data = 0;
1044	if (_queue.top(data)) {
1045	#ifdef WANT_TRACE
1046	float t = clock() /(float) CLOCKS_PER_SEC;
1047	#endif
1048	_vectorFields[0]->updatePixels(data);
1049	#ifdef WANT_TRACE
1050	float ti = clock() / (float) CLOCKS_PER_SEC;
1051	TRACE("updatePixels time: %f\n", ti - t);
1052	#endif
1053	_queue.pop();
1054	oldTime = time;
1055
1056	firstLoad = false;
1057	TRACE("%d bound\n", index++);
1058	}
1059	}
1060	}
1061	if (firstLoad) return false;
1062	}
1063
1064	if (!_advectionEnabled) return true;
1065	if (this->_streamlineEnabled) {
1066	advectStreamlines();
1067	_currentTime += deltaT;
1068	} else {
1069	_camx = camx;
1070	_camy = camy;
1071	_camz = camz;
1072
1073	glDisable(GL_BLEND);
1074	glDisable(GL_DEPTH_TEST);
1075
1076	glPushAttrib(GL_VIEWPORT_BIT);
1077	glViewport(0, 0, _width, _height);
1078	glMatrixMode(GL_PROJECTION);
1079	glPushMatrix();
1080	glLoadIdentity();
1081	glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
1082	glMatrixMode(GL_MODELVIEW);
1083	glPushMatrix();
1084	glLoadIdentity();
1085
1086	glEnable(GL_TEXTURE_RECTANGLE_NV);
1087
1088	cgGLBindProgram(_moveParticlesFP);
1089	cgGLEnableProfile(CG_PROFILE_FP30);
1090
1091	// INSOO
1092	// TIME SCALE
1093
1094	cgGLSetParameter1f(_mpTimeScale, 0.005);
1095
1096	//////////////////////////////////////////////////////
1097	// UPDATE POS
1098	cgGLSetTextureParameter(_mpVectorField, _curVectorFieldID);
1099	cgGLEnableTextureParameter(_mpVectorField);
1100	cgGLSetParameter3f(_mpScale, _scalex, _scaley, _scalez);
1101	cgGLSetParameter1f(_mpMaxScale, _maxVelocityScale);
1102	for (int i = 0; i < _stepSizeStreamline; ++i) {
1103	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
1104	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
1105	glActiveTextureARB(GL_TEXTURE0_ARB);
1106	glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_currentPosIndex]);
1107	glActiveTextureARB(GL_TEXTURE1_ARB);
1108	glBindTexture(GL_TEXTURE_RECTANGLE_NV, _initPosTex);
1109	drawQuad();
1110	swap(_currentPosIndex, _destPosIndex);
1111	}
1112	cgGLDisableTextureParameter(_mpVectorField);
1113
1114	glActiveTextureARB(GL_TEXTURE1_ARB);
1115	glDisable(GL_TEXTURE_RECTANGLE_NV);
1116	glActiveTextureARB(GL_TEXTURE0_ARB);
1117	glDisable(GL_TEXTURE_RECTANGLE_NV);
1118
1119	glDisable(GL_TEXTURE_RECTANGLE_NV);
1120	cgGLDisableProfile(CG_PROFILE_FP30);
1121
1122	glMatrixMode(GL_PROJECTION);
1123	glPopMatrix();
1124	glMatrixMode(GL_MODELVIEW);
1125	glPopMatrix();
1126	glPopAttrib();
1127	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
1128
1129	if (_sortEnabled) {
1130	sort();
1131
1132	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
1133	_vertices->Read(_width, _height);
1134	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
1135	} else {
1136	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_currentPosIndex]);
1137	_vertices->Read(_width, _height);
1138	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
1139	}
1140
1141	// NEW PARTICLES
1142	for (unsigned int i = 0; i < _emitters.size(); ++i) {
1143	// TBD..
1144	unsigned int numOfNewParticles = (unsigned int)(randomRange(_emitters[i]->_minNumOfNewParticles, _emitters[i]->_maxNumOfNewParticles) * deltaT);
1145	for (unsigned int k = 0; k < numOfNewParticles; ++k) {
1146	vrVector3f position = _emitters[i]->_position;
1147	position += _emitters[i]->_maxPositionOffset *
1148	vrVector3f(randomRange(-1.0f, 1.0f), randomRange(-1.0f, 1.0f), randomRange(-1.0f, 1.0f));
1149
1150	float lifetime = randomRange(_emitters[i]->_minLifeTime, _emitters[i]->_maxLifeTime);
1151
1152	// TBD..
1153	allocateParticle(position, vrVector3f(0.0f, 0.0f, 0.0f), lifetime, 1 - (float) k / numOfNewParticles);
1154	}
1155	}
1156
1157	initNewParticles();
1158
1159	_currentTime += deltaT;
1160
1161	cleanUpParticles();
1162	}
1163
1164	return true;
1165	}
1166
1167	void ParticleSystem::allocateParticle(const vrVector3f& position, const vrVector3f& velocity,
1168	float lifeTime, float initTimeStep)
1169	{
1170	if (_availableIndices.empty()) {
1171	return;
1172	}
1173
1174	int index = _availableIndices.top();
1175	_availableIndices.pop();
1176
1177	ActiveParticle p;
1178	p.index = index;
1179	p.timeOfDeath = _currentTime + lifeTime;
1180	_activeParticles.push(p);
1181
1182	NewParticle newParticle;
1183	newParticle.index = index;
1184	newParticle.position = position;
1185	newParticle.velocity = velocity;
1186	newParticle.timeOfDeath = p.timeOfDeath;
1187	newParticle.initTimeStep = initTimeStep;
1188
1189	_newParticles.push_back(newParticle);
1190
1191	_particles[index].timeOfBirth = _currentTime;
1192	_particles[index].lifeTime = lifeTime;
1193	}
1194
1195	void ParticleSystem::initNewParticles()
1196	{
1197	/////////////////////////////
1198	// INIT NEW PARTICLE
1199	glBindBufferARB(GL_ARRAY_BUFFER_ARB, _particleInfoBufferID);
1200	Particle* pinfo = (Particle*) glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY_ARB);
1201
1202	std::vector<NewParticle>::iterator iter;
1203	for (iter = _newParticles.begin(); iter != _newParticles.end(); ++iter) {
1204	pinfo[iter->index] = _particles[iter->index];
1205	}
1206
1207	glUnmapBufferARB(GL_ARRAY_BUFFER_ARB);
1208
1209	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_currentPosIndex]);
1210
1211	glPushAttrib(GL_VIEWPORT_BIT);
1212	glViewport(0, 0, _width, _height);
1213	glMatrixMode(GL_PROJECTION);
1214	glPushMatrix();
1215	glLoadIdentity();
1216	glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
1217	glMatrixMode(GL_MODELVIEW);
1218	glPushMatrix();
1219	glLoadIdentity();
1220
1221	cgGLBindProgram(_initParticlePosFP);
1222	cgGLEnableProfile(CG_PROFILE_FP30);
1223	cgGLSetTextureParameter(_ipVectorFieldParam, _curVectorFieldID);
1224	cgGLEnableTextureParameter(_ipVectorFieldParam);
1225	// TBD..
1226	//glActiveTextureARB(GL_TEXTURE0_ARB);
1227	//VelocityPBuffers[VelocityCurrent]->Bind();
1228
1229	glActiveTextureARB(GL_TEXTURE0_ARB);
1230	glEnable(GL_TEXTURE_RECTANGLE_NV);
1231	glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_destPosIndex]);
1232
1233	glBegin(GL_POINTS);
1234	for (iter = _newParticles.begin(); iter != _newParticles.end(); iter++) {
1235	//TRACE("[%d] %f %f %f\n", iter->index, iter->position.x,iter->position.y,iter->position.z);
1236	glMultiTexCoord3f(GL_TEXTURE0, iter->position.x,iter->position.y,iter->position.z);
1237
1238	// TBD..
1239	//glMultiTexCoord2f(GL_TEXTURE1_ARB, (float)(i->Index % Width), (float)(i->Index / Height));
1240	//glMultiTexCoord1f(GL_TEXTURE2_ARB, iter->initTimeStep);
1241
1242	glVertex2f((float)(iter->index % _width),
1243	(float)(iter->index / _height) + 1/* + offsetY/ / + offsetY shouldn't be */);
1244	//TRACE("%f %f\n", (float) (iter->index % _width), (float)(iter->index / _width));
1245	}
1246	glEnd();
1247
1248	glDisable(GL_TEXTURE_RECTANGLE_NV);
1249	cgGLDisableTextureParameter(_ipVectorFieldParam);
1250	cgGLDisableProfile(CG_PROFILE_FP30);
1251
1252	glMatrixMode(GL_PROJECTION);
1253	glPopMatrix();
1254	glMatrixMode(GL_MODELVIEW);
1255	glPopMatrix();
1256	glPopAttrib();
1257
1258	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
1259
1260	// INIT NEW END
1261	/////////////////////////////
1262	#if 1
1263	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _initPos_fbo);
1264	glPushAttrib(GL_VIEWPORT_BIT);
1265	glViewport(0, 0, _width, _height);
1266	glMatrixMode(GL_PROJECTION);
1267	glPushMatrix();
1268	glLoadIdentity();
1269	glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
1270	glMatrixMode(GL_MODELVIEW);
1271	glPushMatrix();
1272	glLoadIdentity();
1273
1274	cgGLBindProgram(_initParticlePosFP);
1275	cgGLEnableProfile(CG_PROFILE_FP30);
1276	cgGLSetTextureParameter(_ipVectorFieldParam, _curVectorFieldID);
1277	cgGLEnableTextureParameter(_ipVectorFieldParam);
1278	// TBD..
1279	//glActiveTextureARB(GL_TEXTURE0_ARB);
1280	//VelocityPBuffers[VelocityCurrent]->Bind();
1281
1282	glActiveTextureARB(GL_TEXTURE0_ARB);
1283	glEnable(GL_TEXTURE_RECTANGLE_NV);
1284	//glBindTexture(GL_TEXTURE_RECTANGLE_NV, _initPosTex);
1285	glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_destPosIndex]);
1286
1287	glBegin(GL_POINTS);
1288	for (iter = _newParticles.begin(); iter != _newParticles.end(); iter++) {
1289	//TRACE("[%d] %f %f %f\n", iter->index, iter->position.x,iter->position.y,iter->position.z);
1290	glMultiTexCoord3f(GL_TEXTURE0, iter->position.x,iter->position.y,iter->position.z);
1291
1292	// TBD..
1293	//glMultiTexCoord2f(GL_TEXTURE1_ARB, (float)(i->Index % Width), (float)(i->Index / Height));
1294	//glMultiTexCoord1f(GL_TEXTURE2_ARB, iter->initTimeStep);
1295
1296	glVertex2f((float)(iter->index % _width),
1297	(float)(iter->index / _height) + 1/* + offsetY/ / + offsetY shouldn't be */);
1298	//TRACE("%f %f\n", (float) (iter->index % _width), (float)(iter->index / _width));
1299	}
1300	glEnd();
1301
1302	glDisable(GL_TEXTURE_RECTANGLE_NV);
1303	cgGLDisableTextureParameter(_ipVectorFieldParam);
1304	cgGLDisableProfile(CG_PROFILE_FP30);
1305
1306	glMatrixMode(GL_PROJECTION);
1307	glPopMatrix();
1308	glMatrixMode(GL_MODELVIEW);
1309	glPopMatrix();
1310	glPopAttrib();
1311
1312	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
1313	#endif
1314
1315	// Free array.
1316	_newParticles.clear();
1317	}
1318
1319	void ParticleSystem::cleanUpParticles()
1320	{
1321	if (! _activeParticles.empty()) {
1322	while (_activeParticles.top().timeOfDeath < _currentTime) {
1323	unsigned int i = _activeParticles.top().index;
1324	_activeParticles.pop();
1325	_availableIndices.push(i);
1326	//_usedIndices[i] = false;
1327
1328	//if (i >= _maxUsedIndex)
1329	// while (!_usedIndices[_maxUsedIndex])
1330	// _maxUsedIndex--;
1331	}
1332	}
1333	}
1334
1335	void ParticleSystem::sort()
1336	{
1337	///////////////////////////////////////////////////////////
1338	// BEGIN - COMPUTE DISTANCE
1339	vrVector3f pos;
1340	vrMatrix4x4f mat;
1341	glPushMatrix();
1342	glLoadIdentity();
1343	glScalef(_scalex, _scaley, _scalez);
1344	glTranslatef(-0.5f, -0.5f, -0.5f);
1345	glGetFloatv(GL_MODELVIEW_MATRIX, mat.get());
1346	glPopMatrix();
1347	mat.invert();
1348	mat.getTranslation(pos);
1349
1350	cgGLBindProgram(_distanceSortFP);
1351	cgGLEnableProfile(CG_PROFILE_FP30);
1352
1353	glActiveTextureARB(GL_TEXTURE0_ARB);
1354	glEnable(GL_TEXTURE_RECTANGLE_NV);
1355	glBindTexture(GL_TEXTURE_RECTANGLE_NV, sort_tex[_currentSortIndex]);
1356
1357	glActiveTextureARB(GL_TEXTURE1_ARB);
1358	glEnable(GL_TEXTURE_RECTANGLE_NV);
1359	glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_currentPosIndex]);
1360
1361	cgGLSetParameter3f(_viewPosParam, pos.x, pos.y, pos.z);
1362
1363	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_destSortIndex]);
1364	glPushAttrib(GL_VIEWPORT_BIT);
1365	glViewport(0, 0, _width, _height);
1366	glMatrixMode(GL_PROJECTION);
1367	glPushMatrix();
1368	glLoadIdentity();
1369	glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
1370	glMatrixMode(GL_MODELVIEW);
1371	glPushMatrix();
1372	glLoadIdentity();
1373
1374	drawQuad();
1375
1376	cgGLDisableProfile(CG_PROFILE_FP30);
1377
1378	glMatrixMode(GL_PROJECTION);
1379	glPopMatrix();
1380	glMatrixMode(GL_MODELVIEW);
1381	glPopMatrix();
1382	glPopAttrib();
1383	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
1384
1385	// _DEBUG
1386	/*
1387	{
1388	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_destSortIndex]);
1389	static float debug[256];
1390	glReadPixels(0, 0, _width, _height, GL_RGB, GL_FLOAT, (float*)debug);
1391	TRACE("[%d]", _currentSortIndex);
1392	for (int i = 0; i < _width * _height * 3; i += 3)
1393	TRACE("%.2f, %.2f, %.2f\n", debug[i], debug[i+1], debug[i+2]);
1394	TRACE("\n");
1395	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
1396	}
1397	*/
1398
1399	// _DEBUG
1400	/*
1401	{
1402	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_currentPosIndex]);
1403	static float debug[256];
1404	glReadPixels(0, 0, _width, _height, GL_RGB, GL_FLOAT, (float*)debug);
1405	TRACE("\n");
1406	TRACE("currentPos[%d]", _currentPosIndex);
1407	for (int i = 0; i < _width * _height * 3; i += 3)
1408	TRACE("%.2f, %.2f, %.2f\n", debug[i], debug[i+1], debug[i+2]);
1409	TRACE("\n");
1410	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
1411	}
1412	*/
1413
1414	// compute distance
1415	swap(_currentSortIndex, _destSortIndex);
1416
1417	// END - COMPUTE DISTANCE
1418	///////////////////////////////////////////////////////////
1419
1420	///////////////////////////////////////////////////////////
1421	// BEGIN - MERGE SORT
1422	_currentSortPass = 0;
1423
1424	int logdSize = logd(_particleMaxCount);
1425	_maxSortPasses = (logdSize + 1) * logdSize / 2;
1426
1427	_sortBegin = _sortEnd;
1428	_sortEnd = (_sortBegin + _sortPassesPerFrame) % _maxSortPasses;
1429
1430	cgGLSetParameter2f(_srSizeParam, (float)_width, (float)_height);
1431	cgGLSetParameter2f(_seSizeParam, (float)_width, (float)_height);
1432
1433	mergeSort(this->_particleMaxCount);
1434
1435	// _DEBUG
1436	/*
1437	{
1438	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_currentSortIndex]);
1439	static float debug[256];
1440	glReadPixels(0, 0, _width, _height, GL_RGB, GL_FLOAT, (float*)debug);
1441	TRACE("\n");
1442	TRACE("[%d]", _currentSortIndex);
1443	for (int i = 0; i < _width * _height * 3; i += 3)
1444	TRACE("%.2f, %.2f, %.2f\n", debug[i], debug[i+1], debug[i+2]);
1445	TRACE("\n");
1446	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
1447	}
1448	*/
1449
1450	// END - MERGE SORT
1451	///////////////////////////////////////////////////////////
1452
1453	///////////////////////////////////////////////////////////
1454	// POSITION LOOKUP
1455	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
1456	cgGLBindProgram(_distanceSortLookupFP);
1457	cgGLEnableProfile(CG_PROFILE_FP30);
1458
1459	glActiveTextureARB(GL_TEXTURE0_ARB);
1460	glBindTexture(GL_TEXTURE_RECTANGLE_NV, sort_tex[_currentSortIndex]);
1461
1462	glActiveTextureARB(GL_TEXTURE1_ARB);
1463	glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_currentPosIndex]);
1464
1465	glPushAttrib(GL_VIEWPORT_BIT);
1466	glViewport(0, 0, _width, _height);
1467	glMatrixMode(GL_PROJECTION);
1468	glPushMatrix();
1469	glLoadIdentity();
1470	glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
1471	glMatrixMode(GL_MODELVIEW);
1472	glPushMatrix();
1473	glLoadIdentity();
1474
1475	drawQuad();
1476
1477	glMatrixMode(GL_PROJECTION);
1478	glPopMatrix();
1479	glMatrixMode(GL_MODELVIEW);
1480	glPopMatrix();
1481	glPopAttrib();
1482
1483	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
1484	cgGLDisableProfile(CG_PROFILE_FP30);
1485
1486	// POSITION LOOKUP
1487	///////////////////////////////////////////////////////////
1488	glActiveTextureARB(GL_TEXTURE1_ARB);
1489	glDisable(GL_TEXTURE_RECTANGLE_NV);
1490
1491	glActiveTextureARB(GL_TEXTURE0_ARB);
1492	glDisable(GL_TEXTURE_RECTANGLE_NV);
1493
1494	// _DEBUG
1495	/*
1496	{
1497	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
1498	static float debug[256];
1499	glReadPixels(0, 0, _width, _height, GL_RGB, GL_FLOAT, (float*)debug);
1500	TRACE("\n");
1501	TRACE("[%d]", _currentSortIndex);
1502	for (int i = 0; i < _width * _height * 3; i += 3)
1503	TRACE("%.2f, %.2f, %.2f\n", debug[i], debug[i+1], debug[i+2]);
1504	TRACE("\n");
1505	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
1506	}
1507	*/
1508	}
1509
1510	void ParticleSystem::mergeSort(int count)
1511	{
1512	if (count > 1) {
1513	mergeSort(count >> 1);
1514	merge(count, 1);
1515	}
1516	}
1517
1518	void ParticleSystem::merge(int count, int step)
1519	{
1520	if (count > 2) {
1521	merge(count >> 1, step << 1);
1522
1523	++_currentSortPass;
1524
1525	if (_sortBegin < _sortEnd) {
1526	if (_currentSortPass < _sortBegin \|\| _currentSortPass >= _sortEnd)
1527	return;
1528	} else {
1529	if (_currentSortPass < _sortBegin && _currentSortPass >= _sortEnd)
1530	return;
1531	}
1532
1533	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_destSortIndex]);
1534	cgGLBindProgram(_sortRecursionFP);
1535	cgGLEnableProfile(CG_PROFILE_FP30);
1536
1537	glActiveTextureARB(GL_TEXTURE0_ARB);
1538	glBindTexture(GL_TEXTURE_RECTANGLE_NV , sort_tex[_currentSortIndex]);
1539
1540	cgGLSetParameter1f(_srStepParam, (float)step);
1541	cgGLSetParameter1f(_srCountParam, (float)count);
1542
1543	glPushAttrib(GL_VIEWPORT_BIT);
1544	glViewport(0, 0, _width, _height);
1545	glMatrixMode(GL_PROJECTION);
1546	glPushMatrix();
1547	glLoadIdentity();
1548	glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
1549	glMatrixMode(GL_MODELVIEW);
1550	glPushMatrix();
1551	glLoadIdentity();
1552
1553	drawQuad();
1554
1555	glMatrixMode(GL_PROJECTION);
1556	glPopMatrix();
1557	glMatrixMode(GL_MODELVIEW);
1558	glPopMatrix();
1559	glPopAttrib();
1560
1561	cgGLDisableProfile(CG_PROFILE_FP30);
1562
1563	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
1564	glBindTexture(GL_TEXTURE_RECTANGLE_NV , 0);
1565	} else {
1566	_currentSortPass++;
1567
1568	if (_sortBegin < _sortEnd) {
1569	if (_currentSortPass < _sortBegin \|\| _currentSortPass >= _sortEnd)
1570	return;
1571	} else {
1572	if (_currentSortPass < _sortBegin && _currentSortPass >= _sortEnd)
1573	return;
1574	}
1575
1576	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_destSortIndex]);
1577	cgGLBindProgram(_sortEndFP);
1578	cgGLEnableProfile(CG_PROFILE_FP30);
1579
1580	glActiveTextureARB(GL_TEXTURE0_ARB);
1581	glBindTexture(GL_TEXTURE_RECTANGLE_NV , sort_tex[_currentSortIndex]);
1582
1583	cgGLSetParameter1f(_seStepParam, (float)step);
1584
1585	glPushAttrib(GL_VIEWPORT_BIT);
1586	glViewport(0, 0, _width, _height);
1587	glMatrixMode(GL_PROJECTION);
1588	glPushMatrix();
1589	glLoadIdentity();
1590	glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
1591	glMatrixMode(GL_MODELVIEW);
1592	glPushMatrix();
1593	glLoadIdentity();
1594
1595	drawQuad();
1596
1597	glMatrixMode(GL_PROJECTION);
1598	glPopMatrix();
1599	glMatrixMode(GL_MODELVIEW);
1600	glPopMatrix();
1601	glPopAttrib();
1602
1603	cgGLDisableProfile(CG_PROFILE_FP30);
1604
1605	glBindTexture(GL_TEXTURE_RECTANGLE_NV , 0);
1606	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
1607	}
1608
1609	swap(_currentSortIndex, _destSortIndex);
1610	}
1611
1612	void ParticleSystem::renderStreamlines()
1613	{
1614	if (_currentStreamlineIndex > 2) {
1615	glPushMatrix();
1616	glScalef(_scalex, _scaley, _scalez);
1617	glTranslatef(-0.5f, -0.5f, -0.5f);
1618
1619	if (_drawBBoxEnabled) drawUnitBox();
1620
1621	glColor3f(1.0f, 0.0f, 0.0f);
1622	glEnableClientState(GL_VERTEX_ARRAY);
1623	//glEnableClientState(GL_COLOR_ARRAY);
1624
1625	_streamVertices->SetPointer(0);
1626	//glColorPointer(4, GL_FLOAT, 0, 0);
1627
1628	::glDrawElements(GL_LINES, _particleCount * 2 * (_currentStreamlineIndex - 1),
1629	GL_UNSIGNED_INT, _indexBuffer);
1630	glDisableClientState(GL_VERTEX_ARRAY);
1631	glPopMatrix();
1632	}
1633	}
1634
1635	void ParticleSystem::render()
1636	{
1637	glPushMatrix();
1638
1639	if (_streamlineEnabled) {
1640	renderStreamlines();
1641	} else {
1642	glScalef(_scalex, _scaley, _scalez);
1643	glTranslatef(-0.5f, -0.5f, -0.5f);
1644	if (_glyphEnabled) {
1645	if (_drawBBoxEnabled) drawUnitBox();
1646	glColor3f(1, 1, 1);
1647	glDepthMask(GL_FALSE);
1648	glEnable(GL_BLEND);
1649
1650	#ifndef USE_RGBA_ARROW
1651	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
1652	#else
1653	glEnable(GL_ALPHA_TEST);
1654	//glAlphaFunc(GL_GEQUAL, 0.5);
1655	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1656	#endif
1657	glEnable(GL_POINT_SPRITE_NV);
1658	glPointSize(_pointSize);
1659
1660	glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
1661
1662	#ifndef TEST
1663	_arrows->bind(0);
1664	glEnable(GL_TEXTURE_2D);
1665	//glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 60.0f );
1666	glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 0.0f );
1667
1668	glPointParameterfARB( GL_POINT_SIZE_MIN_ARB, 1.0f);
1669	glPointParameterfARB( GL_POINT_SIZE_MAX_ARB, 100.0f);
1670	glTexEnvf( GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE );
1671
1672	cgGLBindProgram(_particleVP);
1673	cgGLBindProgram(_particleFP);
1674	cgGLEnableProfile(CG_PROFILE_VP40);
1675	cgGLEnableProfile(CG_PROFILE_FP40);
1676
1677	cgSetParameter1f(_mvCurrentTimeParam, _currentTime);
1678	//TRACE("%f %f, %f %d\n", _fov, tan(_fov), tan(_fov / 2.0), _screenHeight);
1679	//cgSetParameter1f(_mvTanHalfFOVParam, -tan(_fov * PI / 180 * 0.5) * _screenHeight * 0.5);
1680	//float v = tan(_fov * PI / 180 * 0.5) * _screenHeight * 0.5;
1681	cgSetParameter1f(_mvTanHalfFOVParam, tan(_fov * PI / 180 * 0.5) * _screenHeight * 0.5);
1682	//cgSetParameter1f(_mvTanHalfFOVParam, _screenHeight * 0.5 / tan(_fov * PI / 180 * 0.5));
1683
1684	cgGLSetStateMatrixParameter(_mvpParticleParam,
1685	CG_GL_MODELVIEW_PROJECTION_MATRIX,
1686	CG_GL_MATRIX_IDENTITY);
1687	cgGLSetStateMatrixParameter(_mvParticleParam,
1688	CG_GL_MODELVIEW_MATRIX,
1689	CG_GL_MATRIX_IDENTITY);
1690
1691	// TBD..
1692	glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
1693	glEnableVertexAttribArrayARB(8);
1694	glEnableClientState(GL_VERTEX_ARRAY);
1695	//glEnableClientState(GL_COLOR_ARRAY);
1696	_vertices->SetPointer(0);
1697	//glBindBufferARB(GL_ARRAY_BUFFER, _colorBufferID);
1698	//glColorPointer(4, GL_FLOAT, 0, 0);
1699	//glBindBufferARB(GL_ARRAY_BUFFER, 0);
1700
1701	// TBD...
1702	glDrawArrays(GL_POINTS, 0, this->_particleMaxCount);
1703	glPointSize(1);
1704
1705	glDisableClientState(GL_VERTEX_ARRAY);
1706	//glDisableClientState(GL_COLOR_ARRAY);
1707
1708	// TBD...
1709	::glDisableVertexAttribArray(8);
1710	glPopClientAttrib();
1711
1712	cgGLDisableProfile(CG_PROFILE_VP40);
1713	cgGLDisableProfile(CG_PROFILE_FP40);
1714
1715	glDepthMask(GL_TRUE);
1716
1717	glDisable(GL_POINT_SPRITE_NV);
1718	glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
1719
1720	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1721	glDisable(GL_BLEND);
1722	#else
1723	glBindTexture(GL_TEXTURE_2D, ::SpotTexID);
1724	glEnable(GL_TEXTURE_2D);
1725	//glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 60.0f );
1726	glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 0.0f );
1727
1728	glPointParameterfARB( GL_POINT_SIZE_MIN_ARB, 1.0f);
1729	glPointParameterfARB( GL_POINT_SIZE_MAX_ARB, 100.0f);
1730	glTexEnvf( GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE );
1731
1732	glEnableClientState(GL_VERTEX_ARRAY);
1733	//glEnableClientState(GL_COLOR_ARRAY);
1734	_vertices->SetPointer(0);
1735	//glBindBufferARB(GL_ARRAY_BUFFER, _colorBufferID);
1736	//glColorPointer(4, GL_FLOAT, 0, 0);
1737	//glBindBufferARB(GL_ARRAY_BUFFER, 0);
1738
1739	// TBD...
1740	glDrawArrays(GL_POINTS, 0, this->_particleMaxCount);
1741	glPointSize(1);
1742	glDrawArrays(GL_POINTS, 0, this->_particleMaxCount);
1743
1744	glDisableClientState(GL_VERTEX_ARRAY);
1745
1746	glDepthMask(GL_TRUE);
1747
1748	glDisable(GL_POINT_SPRITE_NV);
1749	glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
1750
1751	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1752	glDisable(GL_BLEND);
1753	#endif
1754	} else {
1755	if (_drawBBoxEnabled) drawUnitBox();
1756
1757	glColor3f(1, 1, 1);
1758	glEnableClientState(GL_VERTEX_ARRAY);
1759	//glEnableClientState(GL_COLOR_ARRAY);
1760	glPointSize(10);
1761	_vertices->SetPointer(0);
1762	//glBindBufferARB(GL_ARRAY_BUFFER, _colorBufferID);
1763	//glColorPointer(4, GL_FLOAT, 0, 0);
1764	//glBindBufferARB(GL_ARRAY_BUFFER, 0);
1765	glDrawArrays(GL_POINTS, 0, _particleMaxCount);
1766
1767	glPointSize(1);
1768	_vertices->SetPointer(0);
1769	//glBindBufferARB(GL_ARRAY_BUFFER, _colorBufferID);
1770	//glColorPointer(4, GL_FLOAT, 0, 0);
1771	//glBindBufferARB(GL_ARRAY_BUFFER, 0);
1772	glDrawArrays(GL_POINTS, 0, _particleMaxCount);
1773
1774	glDisableClientState(GL_VERTEX_ARRAY);
1775	}
1776
1777	#ifdef notdef
1778	if (_criticalPoints && _criticalPoints->size()) {
1779	std::vector<vrVector3f>::iterator iter;
1780	glColor4f(1, 1, 1, 1);
1781	glPointSize(10);
1782	glBegin(GL_POINTS);
1783	for (iter = _criticalPoints->begin(); iter != _criticalPoints->end(); ++iter) {
1784	glVertex3f((iter).x, (iter).y, (*iter).z);
1785	}
1786	glEnd();
1787	glPointSize(1);
1788	}
1789	#endif
1790	}
1791
1792	glPopMatrix();
1793	}
1794
1795	void ParticleSystem::drawQuad(int x1, int y1, int x2, int y2)
1796	{
1797	glBegin(GL_QUADS);
1798
1799	glTexCoord2f(x1, y1);
1800	glVertex2f(x1, y1);
1801
1802	glTexCoord2f(x2, y1);
1803	glVertex2f(x2, y1);
1804
1805	glTexCoord2f(x2, y2);
1806	glVertex2f(x2, y2);
1807
1808	glTexCoord2f(x1, y2);
1809	glVertex2f(x1, y2);
1810
1811	glEnd();
1812	}
1813
1814	void ParticleSystem::drawQuad()
1815	{
1816	glBegin(GL_QUADS);
1817
1818	glTexCoord2f(0, 0);
1819	glVertex2f(0, 0);
1820
1821	glTexCoord2f((float)_width, 0);
1822	glVertex2f((float)_width, 0);
1823
1824	glTexCoord2f((float)_width, (float)_height);
1825	glVertex2f((float)_width, (float)_height);
1826
1827	glTexCoord2f(0, (float)_height);
1828	glVertex2f(0, (float)_height);
1829
1830	glEnd();
1831	}
1832
1833	void ParticleSystem::addEmitter(ParticleEmitter* emitter)
1834	{
1835	_emitters.push_back(emitter);
1836	}
1837
1838	void ParticleSystem::removeEmitter(int index)
1839	{
1840	// TBD...
1841	}
1842
1843	void ParticleSystem::removeAllEmitters()
1844	{
1845	std::vector<ParticleEmitter*>::iterator iter;
1846	for (iter = _emitters.begin(); iter != _emitters.end(); ++iter) {
1847	delete *iter;
1848	}
1849	_emitters.clear();
1850	}
1851
1852	void ParticleSystem::drawUnitBox()
1853	{
1854	float x0 = 0.0f, y0 = 0.0f, z0 = 0.0f;
1855	float x1 = 1.0f, y1 = 1.0f, z1 = 1.0f;
1856	float r = 1.0f, g = 1.0f, b = 0.0f;
1857	float line_width = 2.0f;
1858	glEnable(GL_DEPTH_TEST);
1859	glDisable(GL_TEXTURE_2D);
1860	glEnable(GL_BLEND);
1861
1862	glColor4d(r, g, b, 1.0);
1863	glLineWidth(line_width);
1864
1865	glBegin(GL_LINE_LOOP);
1866	{
1867	glVertex3d(x0, y0, z0);
1868	glVertex3d(x1, y0, z0);
1869	glVertex3d(x1, y1, z0);
1870	glVertex3d(x0, y1, z0);
1871	}
1872	glEnd();
1873
1874	glBegin(GL_LINE_LOOP);
1875	{
1876	glVertex3d(x0, y0, z1);
1877	glVertex3d(x1, y0, z1);
1878	glVertex3d(x1, y1, z1);
1879	glVertex3d(x0, y1, z1);
1880	}
1881	glEnd();
1882
1883	glBegin(GL_LINE_LOOP);
1884	{
1885	glVertex3d(x0, y0, z0);
1886	glVertex3d(x0, y0, z1);
1887	glVertex3d(x0, y1, z1);
1888	glVertex3d(x0, y1, z0);
1889	}
1890	glEnd();
1891
1892	glBegin(GL_LINE_LOOP);
1893	{
1894	glVertex3d(x1, y0, z0);
1895	glVertex3d(x1, y0, z1);
1896	glVertex3d(x1, y1, z1);
1897	glVertex3d(x1, y1, z0);
1898	}
1899	glEnd();
1900	glLineWidth(1.0f);
1901	}
1902
1903	void ParticleSystem::setUserDefinedNumOfParticles(int numParticles)
1904	{
1905	if (numParticles < _particleMaxCount)
1906	_userDefinedParticleMaxCount = numParticles;
1907	else
1908	_userDefinedParticleMaxCount = _particleMaxCount;
1909	reset();
1910	}

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

Download in other formats: