Context Navigation

source: GTP/trunk/Lib/Geom/shared/GeoTool/src/GeoMeshView.cpp @ 980

Revision 980, 26.8 KB checked in by gumbau, 18 years ago (diff)

Line
1	#include "GeoMeshView.h"
2	#include <VertexData.h>
3
4	using namespace Geometry;
5	using namespace std;
6
7	//---------------------------------------------------------------------------
8	// Hanle events.
9	//---------------------------------------------------------------------------
10	int GeoMeshView::handle(int event)
11	{
12	int key;
13	int button;
14	int x;
15	int y;
16
17	if (geoMesh != NULL)
18	{
19	draw();
20	}
21
22	switch(event)
23	{
24	case fltk::KEY:
25	case fltk::PUSH:
26
27	button = fltk::event_key();
28	mMouseX = fltk::event_x();
29	mMouseY = fltk::event_y();
30
31	return 1;
32
33	case fltk::DRAG:
34
35	button = fltk::event_state();
36	x = fltk::event_x();
37	y = fltk::event_y();
38
39	switch (button)
40	{
41	// Button 1 Pushed.
42	case 0x01100000:
43
44	if (x > mMouseX)
45	{
46	if (mPan)
47	{
48	xshift = xshift + (x - mMouseX);
49	}
50	else
51	{
52	hAng = hAng + (x - mMouseX);
53	}
54	}
55	else
56	{
57	if (x < mMouseX)
58	{
59	if (mPan)
60	{
61	xshift = xshift - (mMouseX - x);
62	}
63	else
64	{
65	hAng = hAng - (mMouseX - x);
66	}
67	}
68	}
69
70	if (y > mMouseY)
71	{
72	if (mPan)
73	{
74	yshift = yshift - (y - mMouseY);
75	}
76	else
77	{
78	vAng = vAng + (y - mMouseY);
79	}
80	}
81	else
82	{
83	if (y < mMouseY)
84	{
85	if (mPan)
86	{
87	yshift = yshift + (mMouseY - y);
88	}
89	else
90	{
91	vAng = vAng - (mMouseY - y);
92	}
93	}
94	}
95
96	hAng = float(int(hAng) % 360);
97	vAng = float(int(vAng) % 360);
98
99	mMouseX = x;
100	mMouseY = y;
101
102	draw();
103
104	return 1;
105
106	case 0x04100000:
107
108	if (y > mSizeY)
109	{
110	size++;
111	}
112	else
113	{
114	if (y < mSizeY)
115	{
116	size--;
117	}
118	}
119
120	mSizeY = y;
121
122	draw();
123
124	return 1;
125
126	}
127
128	case fltk::MOUSEWHEEL:
129
130	size = size + fltk::event_dy();
131	draw();
132	return 1;
133	}
134
135	return fltk::GlWindow::handle(event);
136	}
137
138	//---------------------------------------------------------------------------
139	// Get the number of frames per second.
140	//---------------------------------------------------------------------------
141	size_t GeoMeshView::getFPS()
142	{
143	return mFPS;
144	}
145
146	//---------------------------------------------------------------------------
147	// Calculate the number of frames per second.
148	//---------------------------------------------------------------------------
149	void GeoMeshView::calcFPS()
150	{
151	double duration;
152	clock_t finish_time;
153
154	// Gets the time.
155	finish_time = clock();
156
157	// Calc the duration respect the start time.
158	duration = (double)((finish_time - mStartTime) / CLOCKS_PER_SEC);
159
160	// Increments the number of frames per second.
161	mFPS++;
162
163	// If a second have passed.
164	if (duration >= 1.0)
165	{
166	// Repaint the FPS.
167	mGeoMeshViewUI->refreshFPS(mFPS);
168
169	mFPS = 0;
170	mStartTime = clock();
171	}
172	}
173
174	//---------------------------------------------------------------------------
175	// Enable color strips.
176	//---------------------------------------------------------------------------
177	void GeoMeshView::enableColorStrips()
178	{
179	colorStripsFlag = true;
180	}
181
182	//---------------------------------------------------------------------------
183	// Disable color strips.
184	//---------------------------------------------------------------------------
185	void GeoMeshView::disableColorStrips()
186	{
187	colorStripsFlag = false;
188	}
189
190	//---------------------------------------------------------------------------
191	// Gets the color strips state.
192	//---------------------------------------------------------------------------
193	bool GeoMeshView::getColorStrips()
194	{
195	return colorStripsFlag;
196	}
197
198	//---------------------------------------------------------------------------
199	// JGA
200	// Set the color to the submesh sumbmeshIndex
201	//---------------------------------------------------------------------------
202	void GeoMeshView::setSubMeshSelected(int submeshIndex)
203	{
204	mSubMeshSelected = submeshIndex;
205	}
206
207	//---------------------------------------------------------------------------
208	// Sets the leaves submesh index.
209	//---------------------------------------------------------------------------
210	void GeoMeshView::setLeavesSubMesh(int submeshIndex)
211	{
212	leavesSubMesh = submeshIndex;
213	}
214
215	//---------------------------------------------------------------------------
216	// Gets the leaves submesh index.
217	//---------------------------------------------------------------------------
218	int GeoMeshView::getLeavesSubMesh()
219	{
220	return leavesSubMesh;
221	}
222
223	//---------------------------------------------------------------------------
224	// Set the list of strip colors.
225	//---------------------------------------------------------------------------
226	void GeoMeshView::setStripColors()
227	{
228	SubMesh *geosubmesh;
229
230	// Free memory of the strip colors array.
231	for (int submesh = 0; submesh < mStripColorsCount; submesh++)
232	{
233	delete []mStripColors[submesh];
234	}
235
236	delete []mStripColors;
237
238	// Initialize the Colors array.
239	mStripColors = new ColorElement*[geoMesh->mSubMeshCount];
240
241	// Count the total number of strips y the submeshes.
242	for (int submesh = 0; submesh < geoMesh->mSubMeshCount; submesh++)
243	{
244	// Gets the actual submesh.
245	geosubmesh = &geoMesh->mSubMesh[submesh];
246
247	if (geosubmesh->mType == GEO_TRIANGLE_STRIPS)
248	{
249	mStripColors[submesh] = new ColorElement[geosubmesh->mStripCount];
250	}
251	else
252	{
253	mStripColors[submesh] = NULL;
254	}
255	}
256
257
258	// Sets random colors to each strip.
259	for (int submesh = 0; submesh < geoMesh->mSubMeshCount; submesh++)
260	{
261	// Gets the actual submesh.
262	geosubmesh = &geoMesh->mSubMesh[submesh];
263
264	if (geosubmesh->mType == GEO_TRIANGLE_STRIPS)
265	{
266	for (int strip = 0; strip < geosubmesh->mStripCount; strip++)
267	{
268	mStripColors[submesh][strip].r = rand()/((float)RAND_MAX);
269	mStripColors[submesh][strip].g = rand()/((float)RAND_MAX);
270	mStripColors[submesh][strip].b = rand()/((float)RAND_MAX);
271	}
272	}
273	}
274
275	// Sets the submesh count.
276	mStripColorsCount = geoMesh->mSubMeshCount;
277	}
278
279	/*
280	//---------------------------------------------------------------------------
281	// Get the bounding box of the object.
282	//---------------------------------------------------------------------------
283	GeometryBounds GeoMeshView::getBoundingBox()
284	{
285	SubMesh *geosubmesh;
286	Index position;
287	Vector3 vector3;
288	GeometryBounds bounds;
289	float x,y,z;
290	float xMin,yMin,zMin;
291	float xMax,yMax,zMax;
292
293	// For each submesh.
294	for (int submesh = 0; submesh < geoMesh->mSubMeshCount; submesh++)
295	{
296	// Gets the actual submesh.
297	geosubmesh = &geoMesh->mSubMesh[submesh];
298
299	// For each index of the strip.
300	for (int index = 0; index < geosubmesh->mIndexCount; index++)
301	{
302	position = geosubmesh->mIndex[index];
303
304	// Gets the vertex coordinates.
305	vector3 = geosubmesh->mVertexBuffer->mPosition[position];
306
307	x = vector3[0];
308	y = vector3[1];
309	z = vector3[2];
310
311	// If is the first iteation.
312	if ((submesh == 0) && (index == 0))
313	{
314	xMin = xMax = x;
315	yMin = yMax = y;
316	zMin = zMax = z;
317	}
318	else
319	{
320	if (x < xMin)
321	{
322	xMin = x;
323	}
324	else if (x > xMax)
325	{
326	xMax = x;
327	}
328
329	if (y < yMin)
330	{
331	yMin = y;
332	}
333	else if (y > yMax)
334	{
335	yMax = y;
336	}
337
338	if (z < zMin)
339	{
340	zMin = z;
341	}
342	else if (z > zMax)
343	{
344	zMax = z;
345	}
346	}
347	}
348	}
349
350	xMed = (xMax + xMin) / 2;
351	yMed = (yMax + yMin) / 2;
352	zMed = (zMax + zMin) / 2;
353
354
355	if ((xMax - xMin) > (yMax - yMin))
356	{
357	if ((xMax - xMin) > (zMax - zMin))
358	{
359	mScaleFactor = xMax - xMin;
360	}
361	else
362	{
363	mScaleFactor = zMax - zMin;
364	}
365	}
366	else
367	{
368	if ((yMax - yMin) > (zMax - zMin))
369	{
370	mScaleFactor = yMax - yMin;
371	}
372	else
373	{
374	mScaleFactor = zMax - zMin;
375	}
376	}
377
378	// Set the bounds.
379	bounds.minx = xMin;
380	bounds.miny = yMin;
381	bounds.minz = zMin;
382	bounds.maxx = xMax;
383	bounds.maxy = yMax;
384	bounds.maxz = zMax;
385	bounds.radius = mScaleFactor;
386
387	return bounds;
388	}
389	*/
390
391	//---------------------------------------------------------------------------
392	// Constructor.
393	//---------------------------------------------------------------------------
394	GeoMeshView::GeoMeshView( int x,
395	int y,
396	int w,
397	int h,
398	const char *l,
399	GeoMeshViewUI *geoMeshViewUI)
400	: fltk::GlWindow(x,y,w,h,l)
401	{
402	mStripColors = NULL;
403	mSharedPosArray = NULL;
404	mSharedNorArray = NULL;
405	mPosArray = NULL;
406	mNorArray = NULL;
407	mIndexArray = NULL;
408	vAng = 0.0;
409	hAng = 0.0;
410	size = 0.0;
411	mSizeY = 0;
412	xshift = 0.0;
413	yshift = 0.0;
414	geoMesh = 0;
415	mRotate = true;
416	mPan = false;
417	mLodStrip = false;
418	mLodTree = false;
419	mIdVisualList = 0;
420	mSubMeshCount = 0;
421	mStripColorsCount = 0;
422
423	// Initialize the model view.
424	deactiveWire();
425	deactiveSolid();
426	activeRotate();
427	deactiveCW();
428	activeCCW();
429
430	// Init start time for FPS.
431	mStartTime = clock();
432
433	// Cross Reference.
434	mGeoMeshViewUI = geoMeshViewUI;
435	}
436
437	// The color used for the edges of the bounding cube.
438	#define CUBECOLOR 255,255,255,255
439
440	/* Draw a colored cube */
441	#define ALPHA 0.5
442
443	//---------------------------------------------------------------------------
444	// Sets the Mesh to display.
445	//---------------------------------------------------------------------------
446	void GeoMeshView::setMesh(Mesh *geomesh)
447	{
448	GLfloat color_blanco[] = {1.0f,1.0f,1.0f,1.0f};
449
450	this->geoMesh = geomesh;
451	mSubMeshSelected = -1;
452	leavesSubMesh = -1;
453	mScaleFactor = geomesh->mMeshBounds.scaleFactor;
454
455	// Refresh vertices to the vertex array.
456	refreshVertices(geomesh);
457
458	glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,color_blanco);
459	}
460
461	//---------------------------------------------------------------------------
462	// Refresh vertices to the vertex array.
463	//---------------------------------------------------------------------------
464	void GeoMeshView::refreshVertices(Mesh *geomesh)
465	{
466	SubMesh *geosubmesh;
467	VertexBuffer *vertex_buffer;
468
469	// If the vertex array exists.
470	if (mSubMeshCount > 0)
471	{
472	for (int submesh = 0; submesh < mSubMeshCount; submesh++)
473	{
474	delete [] mPosArray[submesh];
475	delete [] mNorArray[submesh];
476	delete [] mIndexArray[submesh];
477	}
478
479	delete [] mSharedPosArray;
480	delete [] mSharedNorArray;
481	delete [] mPosArray;
482	delete [] mNorArray;
483	delete [] mIndexArray;
484	}
485
486	// If there is shared vertex.
487	if (geomesh->mVertexBuffer != NULL)
488	{
489	vertex_buffer = geomesh->mVertexBuffer;
490
491	// Allocate memory.
492	mSharedPosArray = new GLfloat[vertex_buffer->mVertexCount * 3];
493	mSharedNorArray = new GLfloat[vertex_buffer->mVertexCount * 3];
494
495	for (int vertex = 0; vertex < vertex_buffer->mVertexCount; vertex++)
496	{
497	mSharedPosArray[3 * vertex] = vertex_buffer->mPosition[vertex].x;
498	mSharedPosArray[(3 * vertex) + 1] = vertex_buffer->mPosition[vertex].y;
499	mSharedPosArray[(3 * vertex) + 2] = vertex_buffer->mPosition[vertex].z;
500
501	mSharedNorArray[3 * vertex] = vertex_buffer->mNormal[vertex].x;
502	mSharedNorArray[(3 * vertex) + 1] = vertex_buffer->mNormal[vertex].y;
503	mSharedNorArray[(3 * vertex) + 2] = vertex_buffer->mNormal[vertex].z;
504	}
505	}
506
507	// Build the arrays of vertices and indices.
508	mPosArray = new GLfloat*[geomesh->mSubMeshCount];
509	mNorArray = new GLfloat*[geomesh->mSubMeshCount];
510	mIndexArray = new GLuint*[geomesh->mSubMeshCount];
511
512	// For each submesh.
513	for (int submesh = 0; submesh < geomesh->mSubMeshCount; submesh++)
514	{
515	// Gets the actual submesh.
516	geosubmesh = &geomesh->mSubMesh[submesh];
517
518	// Allocate memory for index array of the actual submesh.
519	mIndexArray[submesh] = new GLuint[geosubmesh->mIndexCount];
520
521	// Gets the indices of the actual submesh.
522	for (int index = 0; index < geosubmesh->mIndexCount; index++)
523	{
524	mIndexArray[submesh][index] = geosubmesh->mIndex[index];
525	}
526
527	// If the submesh is NOT shared vertex.
528	if (!geosubmesh->mSharedVertexBuffer)
529	{
530	vertex_buffer = geosubmesh->mVertexBuffer;
531
532	// Allocate memory for vertices of the actual submesh.
533	mPosArray[submesh] = new GLfloat[vertex_buffer->mVertexCount * 3];
534	mNorArray[submesh] = new GLfloat[vertex_buffer->mVertexCount * 3];
535
536	// For each one of the vertex.
537	for (int vertex = 0; vertex < vertex_buffer->mVertexCount; vertex++)
538	{
539	mPosArray[submesh][3 * vertex] = vertex_buffer->mPosition[vertex].x;
540	mPosArray[submesh][(3 * vertex) + 1] = vertex_buffer->mPosition[vertex].y;
541	mPosArray[submesh][(3 * vertex) + 2] = vertex_buffer->mPosition[vertex].z;
542
543	mNorArray[submesh][3 * vertex] = vertex_buffer->mNormal[vertex].x;
544	mNorArray[submesh][(3 * vertex) + 1] = vertex_buffer->mNormal[vertex].y;
545	mNorArray[submesh][(3 * vertex) + 2] = vertex_buffer->mNormal[vertex].z;
546	}// End for each vertex.
547	}
548	// If the submesh is shared vertex.
549	else
550	{
551	mPosArray[submesh] = NULL;
552	mNorArray[submesh] = NULL;
553	}
554
555	}// End for each submesh.
556
557	mSubMeshCount = geoMesh->mSubMeshCount;
558	}
559
560	//---------------------------------------------------------------------------
561	// Gets the triangle count of the current lod.
562	//---------------------------------------------------------------------------
563	size_t GeoMeshView::getLodStripsTriangleCount()
564	{
565	size_t triangle_count;
566
567	// Initialize triangle count.
568	triangle_count = 0;
569
570	// For each strip.
571	for (int strip = 0; strip < lodStripsLib->GetStripCount(); strip++)
572	{
573	triangle_count += lodStripsLib->mStrips[strip].size() - 2;
574	}
575
576	return triangle_count;
577	}
578
579	//---------------------------------------------------------------------------
580	// Repaint the Mesh.
581	//---------------------------------------------------------------------------
582	void GeoMeshView::drawGeoMesh(bool paintWire)
583	{
584	SubMesh *geosubmesh;
585	bool submesh_selected;
586
587	if (geoMesh)
588	{
589	if (mLodStrip)
590	{
591	drawLodStrip();
592	}
593	else if (mLodTree)
594	{
595	drawLodTree();
596	}
597	else
598	{
599	for (int submesh = 0; submesh < geoMesh->mSubMeshCount; submesh++)
600	{
601	// Gets the actual submesh.
602	geosubmesh = &geoMesh->mSubMesh[submesh];
603
604	if (geosubmesh->mType == GEO_TRIANGLE_LIST)
605	{
606	if (mSubMeshSelected == submesh)
607	{
608	submesh_selected = true;
609	}
610	else
611	{
612	submesh_selected = false;
613	}
614
615	// Draw the actual submesh in triangle list.
616	drawTriangleList(submesh,submesh_selected,paintWire);
617	}
618	else
619	{
620	// Draw the actual submesh in triangle strip.
621	drawTriangleStrip(submesh);
622	}
623	}
624	}
625	}
626	}// End drawGeoMesh.
627
628	//---------------------------------------------------------------------------
629	// Paint eah strip separately.
630	//---------------------------------------------------------------------------
631	void GeoMeshView::drawTriangleStrip(int submesh)
632	{
633	SubMesh *geosubmesh;
634	Index position;
635	Vector3 vector3;
636	float x,y,z;
637	float r,g,b;
638	Index *index;
639	Index *indexBegin;
640	Index *indexEnd;
641	int color_index;
642
643	color_index = 0;
644
645	// Gets the actual submesh.
646	geosubmesh = &geoMesh->mSubMesh[submesh];
647
648	// For each one of the strips.
649	for (int strip = 0; strip < geosubmesh->mStripCount; strip++)
650	{
651	// Paint the current strip.
652	glBegin(GL_TRIANGLE_STRIP);
653
654	// First index of the strip.
655	indexBegin = geosubmesh->mStrip[strip];
656
657	// If the strips is not the first.
658	//if (strip != 0)
659	//{
660	// indexBegin++;
661	//}
662
663	// If is the final strip
664	if (strip == (geosubmesh->mStripCount - 1))
665	{
666	// The end of the index array.
667	indexEnd = &geosubmesh->mIndex[geosubmesh->mIndexCount];
668	}
669	else
670	{
671	// The beginning of the next strip.
672	indexEnd = geosubmesh->mStrip[strip + 1];
673
674	// Remove degenerated
675	//indexEnd--;
676	}
677
678	int i;
679	i = 0;
680
681	if (getColorStrips())
682	{
683	// Gets the color of the strip.
684	r = mStripColors[submesh][color_index].r;
685	g = mStripColors[submesh][color_index].g;
686	b = mStripColors[submesh][color_index].b;
687
688	// Change to the next color.
689	color_index++;
690
691	// Paint a new color.
692	glColor3f(r,g,b);
693	}
694
695	// For each index of the strip.
696	for (index = indexBegin; index < indexEnd; index++)
697	{
698	position = indexBegin[i];
699
700	// Gets the vertex normal.
701	vector3 = geosubmesh->mVertexBuffer->mNormal[position];
702
703	x = vector3[0];
704	y = vector3[1];
705	z = vector3[2];
706
707	// Sets the vertex normal.
708	glNormal3f(x,y,z);
709
710	// Gets the vertex coordinates.
711	vector3 = geosubmesh->mVertexBuffer->mPosition[position];
712
713	x = vector3[0];
714	y = vector3[1];
715	z = vector3[2];
716
717
718	// Sets the vertex position.
719	glVertex3f(x,y,z);
720
721	// Increments i.
722	i++;
723	}
724
725	glEnd();
726
727	}
728
729	}//End drawTriangleStrip.
730
731	//---------------------------------------------------------------------------
732	// Paint the array of idices.
733	//---------------------------------------------------------------------------
734	void GeoMeshView::drawTriangleList( int submesh,
735	bool selectedSubMesh,
736	bool paintWire)
737	{
738	SubMesh *geosubmesh;
739	Index position;
740	Vector3 vector3;
741	float x,y,z;
742	int idx_offset;
743	int vrt_offset;
744
745	// Index offset.
746	idx_offset = 0;
747
748	// Vertex offset.
749	vrt_offset = 0;
750
751	// Gets the actual submesh.
752	geosubmesh = &geoMesh->mSubMesh[submesh];
753
754	// If wire is not selected.
755	if (!paintWire)
756	{
757	// If a mesh is selected.
758	if (selectedSubMesh)
759	{
760	glColor3d(1.0,0.0,0.0);
761	GLfloat red[] = {1.0f,0.0f,0.0f,1.0f};
762	glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,red);
763	}
764	// If is a tree.
765	else if (leavesSubMesh >= 0)
766	{
767	glColor3d(1.0, 0.5, 0.5);
768	GLfloat brown[] = {1.0f,0.5f,0.5f,1.0f};
769	glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,brown);
770
771	// For each index of the strip.
772	if (submesh == leavesSubMesh)
773	{
774	glColor3d(0.0,1.0,0.0);
775	GLfloat green[] = {0.0f,1.0f,0.0f,1.0f};
776	glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,green);
777	}
778	}
779	// If is NOT a tree.
780	else
781	{
782	// Set white color to the object.
783	glColor3d(1.0, 1.0, 1.0);
784	GLfloat white[] = {1.0f,1.0f,1.0f,1.0f};
785	glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,white);
786	}
787	}
788
789	// Enable arrays.
790	glEnableClientState(GL_VERTEX_ARRAY);
791	glEnableClientState(GL_NORMAL_ARRAY);
792
793	// If the submesh is shared vertex.
794	if (geosubmesh->mSharedVertexBuffer)
795	{
796	glVertexPointer(3, GL_FLOAT, 0, mSharedPosArray);
797	glNormalPointer(GL_FLOAT, 0, mSharedNorArray);
798	}
799	else
800	{
801	glVertexPointer(3, GL_FLOAT, 0, mPosArray[submesh]);
802	glNormalPointer(GL_FLOAT, 0, mNorArray[submesh]);
803	}
804
805	glDrawElements( GL_TRIANGLES,
806	geosubmesh->mIndexCount,
807	GL_UNSIGNED_INT,
808	mIndexArray[submesh]);
809
810	}//End drawTriangleList
811
812	//---------------------------------------------------------------------------
813	// Paint lodstrip object.
814	//---------------------------------------------------------------------------
815	void GeoMeshView::drawLodStrip()
816	{
817	SubMesh *geosubmesh;
818	Index position;
819	Vector3 vector3;
820	float x,y,z;
821	float r,g,b;
822	int color_index;
823	int current_strip;
824
825	// Initialize current strip.
826	current_strip = 0;
827
828	// For each submesh.
829	for (int submesh = 0; submesh < geoMesh->mSubMeshCount; submesh++)
830	{
831
832	color_index = 0;
833
834	// Gets the actual submesh.
835	geosubmesh = &geoMesh->mSubMesh[submesh];
836
837	// For each one of the strips.
838	for (int strip = 0; strip < geosubmesh->mStripCount; strip++)
839	{
840	// Paint the current strip.
841	glBegin(GL_TRIANGLE_STRIP);
842
843	if (getColorStrips())
844	{
845	// Gets the color of the strip.
846	r = mStripColors[submesh][color_index].r;
847	g = mStripColors[submesh][color_index].g;
848	b = mStripColors[submesh][color_index].b;
849
850	// Change to the next color.
851	color_index++;
852
853	// Paint a new color.
854	glColor3f(r,g,b);
855	}
856
857	// For each index of the strip.
858	for (int index = 0; index < lodStripsLib->mStrips[current_strip].size(); index++)
859	{
860	position = lodStripsLib->mStrips[current_strip][index];
861
862	// Gets the vertex normal.
863	vector3 = geosubmesh->mVertexBuffer->mNormal[position];
864
865	x = vector3[0];
866	y = vector3[1];
867	z = vector3[2];
868
869	// Sets the vertex normal.
870	glNormal3f(x,y,z);
871
872	// Gets the vertex coordinates.
873	vector3 = geosubmesh->mVertexBuffer->mPosition[position];
874
875	x = vector3[0];
876	y = vector3[1];
877	z = vector3[2];
878
879	// Sets the vertex position.
880	glVertex3f(x,y,z);
881	}
882
883	// Increments current strip.
884	current_strip++;
885
886	// A strip is generated.
887	glEnd();
888
889	}
890	}
891
892	}//End drawTriangleStrip.
893
894
895	//---------------------------------------------------------------------------
896	// Paint lodtree object.
897	//---------------------------------------------------------------------------
898	void GeoMeshView::drawLodTree()
899	{
900	SubMesh *geosubmesh;
901	Index position;
902	Vector3 vector3;
903	float x,y,z;
904	float r,g,b;
905	int color_index;
906	int current_strip;
907
908	// Initialize current strip.
909	current_strip = 0;
910
911
912	// DRAW THE TRUNK AS A LODSTRIP OBJECT
913
914	// For each submesh.
915	for (int submesh = 0; submesh < geoMesh->mSubMeshCount; submesh++)
916	{
917
918	color_index = 0;
919
920	// Gets the actual submesh.
921	geosubmesh = &geoMesh->mSubMesh[submesh];
922
923	// For each one of the strips.
924	for (int strip = 0; strip < geosubmesh->mStripCount; strip++)
925	{
926	// Paint the current strip.
927	glBegin(GL_TRIANGLE_STRIP);
928
929	if (getColorStrips())
930	{
931	// Gets the color of the strip.
932	r = mStripColors[submesh][color_index].r;
933	g = mStripColors[submesh][color_index].g;
934	b = mStripColors[submesh][color_index].b;
935
936	// Change to the next color.
937	color_index++;
938
939	// Paint a new color.
940	glColor3f(r,g,b);
941	}
942
943	// For each index of the strip.
944	for (int index = 0; index < lodTreeLib->GetStrip(current_strip).size(); index++)
945	{
946	position = lodTreeLib->GetStrip(current_strip)[index];
947
948	// Gets the vertex normal.
949	vector3 = geosubmesh->mVertexBuffer->mNormal[position];
950
951	x = vector3[0];
952	y = vector3[1];
953	z = vector3[2];
954
955	// Sets the vertex normal.
956	glNormal3f(x,y,z);
957
958	// Gets the vertex coordinates.
959	vector3 = geosubmesh->mVertexBuffer->mPosition[position];
960
961	x = vector3[0];
962	y = vector3[1];
963	z = vector3[2];
964
965	// Sets the vertex position.
966	glVertex3f(x,y,z);
967	}
968
969	// Increments current strip.
970	current_strip++;
971
972	// A strip is generated.
973	glEnd();
974
975	}
976	}
977
978	// DRAW THE LEAVES AS A TRIANGLE SOUP
979	glColor3f(0,1,1);
980	glDisable(GL_LIGHTING);
981	glBegin(GL_TRIANGLES);
982	const Geometry::VertexData *foliage_verts = lodTreeLib->Get_Foliage_VertexData();
983	const Geometry::IndexData *foliage_inds = lodTreeLib->CurrentLOD_Foliage_Indices();
984	for (int j=0; j<lodTreeLib->CurrentLOD_Foliage_IndexCount(); j++)
985	{
986	float vx,vy,vz;
987	foliage_verts->GetVertexCoord(foliage_inds->GetIndex(j),vx,vy,vz);
988	glVertex3f(vx,vy,vz);
989	}
990	glEnd();
991
992	glEnable(GL_LIGHTING);
993	glColor3f(1,1,1);
994
995	}//End drawTriangleStrip.
996
997
998
999	//---------------------------------------------------------------------------
1000	// Sets the lodstripslibrary object.
1001	//---------------------------------------------------------------------------
1002	void GeoMeshView::setLodStripsLibrary(LodStripsLibrary *lodstrips)
1003	{
1004	lodStripsLib = lodstrips;
1005	activeLodStrip();
1006	}
1007
1008	//---------------------------------------------------------------------------
1009	// Sets the lodtreeslibrary object.
1010	//---------------------------------------------------------------------------
1011	void GeoMeshView::setLodTreesLibrary(LodTreeLibrary *lodtrees)
1012	{
1013	lodTreeLib = lodtrees;
1014	activeLodTree();
1015	}
1016
1017	//---------------------------------------------------------------------------
1018	// Change de Level of detail of the object.
1019	//---------------------------------------------------------------------------
1020	void GeoMeshView::GoToLod_LodStrip(unsigned int lod)
1021	{
1022	if (mLodStrip)
1023	lodStripsLib->GoToLod(lod);
1024	if (mLodTree)
1025	lodTreeLib->GoToTrunkLod(lod);
1026	draw();
1027	}
1028
1029	//---------------------------------------------------------------------------
1030	// Change de Level of detail of the object.
1031	//---------------------------------------------------------------------------
1032	void GeoMeshView::GoToLod_LodTree(unsigned int lod)
1033	{
1034	if (mLodTree)
1035	lodTreeLib->GoToFoliageLod(lod);
1036	draw();
1037	}
1038
1039
1040	//---------------------------------------------------------------------------
1041	// Draw the object in the window.
1042	//---------------------------------------------------------------------------
1043	void GeoMeshView::draw()
1044	{
1045	glMatrixMode(GL_PROJECTION);
1046	glLoadIdentity();
1047
1048	glEnable(GL_LIGHTING);
1049
1050	// Frustrum.
1051	glViewport(0,0,w(),h());
1052	gluPerspective(60,(float)w()/(float)h(),0.1,1000);
1053
1054	glMatrixMode(GL_MODELVIEW);
1055	glLoadIdentity();
1056
1057	glEnable(GL_BLEND);
1058	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1059
1060	GLfloat light_ambient[] = {0.3,0.3,0.3,1.0};
1061	GLfloat luzpos[] = {0.0,0.0,1.0,0.0};
1062	GLfloat luzcolor[] = {1.0,1.0,1.0,1.0};
1063
1064	// glLightModelfv(GL_LIGHT_MODEL_AMBIENT, light_ambient);
1065	glEnable(GL_LIGHT0);
1066	glLightfv(GL_LIGHT0, GL_POSITION, luzpos);
1067	glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
1068	glLightfv(GL_LIGHT0, GL_DIFFUSE, luzcolor);
1069	glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 1);
1070	glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0);
1071	glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0);
1072
1073	glEnable (GL_POLYGON_OFFSET_LINE);
1074	glPolygonOffset(-1,-1);
1075	glEnable(GL_DEPTH_TEST);
1076	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
1077
1078	gluLookAt(0,0,2/mScaleFactor/ + size * 0.25, 0,0,0, 0,1,0);
1079
1080	glTranslatef(xshift,yshift,0);
1081	glRotatef(hAng,0,1,0);
1082	glRotatef(vAng,1,0,0);
1083	//glTranslatef(-xMed,-yMed,-zMed);
1084
1085	// Set white color to the object.
1086	glColor3d(1.0, 1.0, 1.0);
1087	GLfloat color_blanco[] = {1.0f,1.0f,1.0f,1.0f};
1088	glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,color_blanco);
1089
1090	glClearColor(0,0,0,0);
1091
1092	if (mCW)
1093	{
1094	glFrontFace(GL_CW);
1095	glEnable(GL_CULL_FACE);
1096	}
1097	else
1098	{
1099	if (mCCW)
1100	{
1101	glFrontFace(GL_CCW);
1102	glEnable(GL_CULL_FACE);
1103	}
1104	else
1105	{
1106	glDisable(GL_CULL_FACE);
1107	}
1108	}
1109
1110	if (mSolid)
1111	{
1112	enableColorStrips();
1113	glDisable(GL_LIGHTING);
1114	glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1115	drawGeoMesh(false);
1116	}
1117	else
1118	{
1119	glEnable(GL_LIGHTING);
1120	}
1121
1122	if (mWire)
1123	{
1124	disableColorStrips();
1125	glDisable(GL_LIGHTING);
1126	glColor3d(0.0, 0.0, 1.0);
1127	glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
1128	drawGeoMesh(true);
1129	}
1130	else
1131	{
1132	if (!mSolid)
1133	{
1134	enableColorStrips();
1135	glEnable(GL_LIGHTING);
1136	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1137	drawGeoMesh(false);
1138	}
1139	}
1140
1141	swap_buffers();
1142
1143	// Calculate the FPS.
1144	calcFPS();
1145	}
1146

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

Download in other formats: