soc-2008-mxcurioni: merge-repair with trunk rev 15456
[blender.git] / source / blender / freestyle / intern / rendering / GLDebugRenderer.cpp
1
2 //
3 //  Copyright (C) : Please refer to the COPYRIGHT file distributed 
4 //   with this source distribution. 
5 //
6 //  This program is free software; you can redistribute it and/or
7 //  modify it under the terms of the GNU General Public License
8 //  as published by the Free Software Foundation; either version 2
9 //  of the License, or (at your option) any later version.
10 //
11 //  This program is distributed in the hope that it will be useful,
12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 //  GNU General Public License for more details.
15 //
16 //  You should have received a copy of the GNU General Public License
17 //  along with this program; if not, write to the Free Software
18 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19 //
20 ///////////////////////////////////////////////////////////////////////////////
21
22 #include <stdio.h>
23 #include "../scene_graph/VertexRep.h"
24 #include "../scene_graph/NodeShape.h"
25 #include "../scene_graph/IndexedFaceSet.h"
26 #include "../scene_graph/LineRep.h"
27 #include "../geometry/Grid.h"
28
29 #include "GLDebugRenderer.h"
30
31 #ifdef __MACH__
32 #include <GLUT/glut.h>
33 #else
34 #include <GL/glut.h>
35 #endif
36
37 void GLDebugRenderer::visitIndexedFaceSet(IndexedFaceSet& iFaceSet)  
38 {
39   unsigned int fIndex = 0;
40   
41   const real * vertices = iFaceSet.vertices();
42   const real * normals = iFaceSet.normals();
43   const Material *const* materials = (const Material**)iFaceSet.materials();
44   const unsigned *vindices = iFaceSet.vindices();
45   const unsigned *nindices = iFaceSet.nindices();
46   const unsigned *mindices = iFaceSet.mindices();
47   const unsigned numfaces = iFaceSet.numFaces();
48   const unsigned *numVertexPerFace = iFaceSet.numVertexPerFaces();
49   const IndexedFaceSet::TRIANGLES_STYLE * faceStyle = iFaceSet.trianglesStyle();  
50
51   const unsigned *pvi = vindices;
52   const unsigned *pni = nindices;
53   const unsigned* pmi = mindices;
54
55   for(fIndex=0; fIndex<numfaces; fIndex++)
56   {
57     switch(faceStyle[fIndex])
58     {
59     case IndexedFaceSet::TRIANGLE_STRIP:
60       RenderTriangleStrip(vertices, normals, materials, pvi, pni, pmi, numVertexPerFace[fIndex]);
61       break;
62     case IndexedFaceSet::TRIANGLE_FAN:
63       RenderTriangleFan(vertices, normals, materials, pvi, pni, pmi, numVertexPerFace[fIndex]);
64       break;
65     case IndexedFaceSet::TRIANGLES:
66       RenderTriangles(vertices, normals, materials, pvi, pni, pmi, numVertexPerFace[fIndex]);
67       break;
68     }
69     pvi += numVertexPerFace[fIndex];
70     pni += numVertexPerFace[fIndex];
71     pmi += numVertexPerFace[fIndex];
72   }
73 }
74
75 void GLDebugRenderer::visitNodeShape(NodeShape& iShapeNode) 
76 {
77   // Gets the bbox size:
78   real minY = iShapeNode.bbox().getMin()[1];
79   real maxY = iShapeNode.bbox().getMax()[1];
80   
81   // sets the text size:
82   _bboxSize = fabs((maxY-minY)); ///1000.f;
83 }
84
85 void GLDebugRenderer::visitLineRep(LineRep& iLine) 
86
87
88   glColor3f(0,0,0);
89
90   GLRenderer::visitLineRep(iLine);
91 }
92
93 void GLDebugRenderer::visitOrientedLineRep(OrientedLineRep& iLine) 
94 {
95   GLRenderer::visitOrientedLineRep(iLine);
96 }
97
98 void GLDebugRenderer::visitVertexRep(VertexRep& iVertex) 
99 {
100   glPointSize(3.0);
101
102   GLRenderer::visitVertexRep(iVertex);
103 }
104
105
106 void GLDebugRenderer::renderBitmapString(real x, 
107                                          real y, 
108                                          real z, 
109                                          void *font, 
110                                          char *string,
111                                          float size) 
112 {  
113   char *c;
114   
115   glPushMatrix();
116   glTranslater(x, y,z);
117   real textSize = min(_bboxSize/10.0, _minEdgeSize/2.0);
118   // adjust the text size so as it 
119   // is acceptable giving the bbox size:
120   while(_bboxSize/textSize>1000)
121     textSize *= 10.0;
122
123   glScalef(size, size, size);
124   glScalef(textSize/200.0, textSize/200.0, textSize/200.0);
125   for (c=string; *c != '\0'; c++) 
126   {
127     //soc glutStrokeCharacter(font, *c);
128   }
129   glPopMatrix();
130 }
131
132 void GLDebugRenderer::RenderTriangleStrip(const real *iVertices, 
133                                           const real *iNormals,
134                                           const Material *const* iMaterials, 
135                                           const unsigned* iVIndices, 
136                                           const unsigned* iNIndices,
137                                           const unsigned* iMIndices,
138                                           const unsigned iNVertices) 
139 {
140   //  glBegin(GL_TRIANGLE_STRIP);
141   //  for(unsigned int i=0; i<iNVertices; i++)
142   //  {
143   //    glNormal3r(iNormals[iNIndices[i]], 
144   //               iNormals[iNIndices[i]+1],
145   //               iNormals[iNIndices[i]+2]);
146   //
147   //    glVertex3r( iVertices[iVIndices[i]], 
148   //                iVertices[iVIndices[i]+1],
149   //                iVertices[iVIndices[i]+2]);
150   //  }
151   //  glEnd();
152 }
153
154 void GLDebugRenderer::RenderTriangleFan(const real *iVertices, 
155                                         const real *iNormals,
156                                         const Material *const* iMaterials, 
157                                         const unsigned* iVIndices, 
158                                         const unsigned* iNIndices,
159                                         const unsigned* iMIndices,
160                                         const unsigned iNVertices)  
161 {
162   //  glBegin(GL_TRIANGLE_FAN);
163   //  for(unsigned int i=0; i<iNVertices; i++)
164   //  {
165   //    glNormal3r(iNormals[iNIndices[i]], 
166   //               iNormals[iNIndices[i]+1],
167   //               iNormals[iNIndices[i]+2]);
168   //
169   //    glVertex3r( iVertices[iVIndices[i]], 
170   //                iVertices[iVIndices[i]+1],
171   //                iVertices[iVIndices[i]+2]);
172   //  }
173   //  glEnd();
174 }
175
176 void GLDebugRenderer::RenderTriangles(const real *iVertices, 
177                                       const real *iNormals,
178                                       const Material *const* iMaterials, 
179                                       const unsigned* iVIndices, 
180                                       const unsigned* iNIndices,
181                                       const unsigned* iMIndices,
182                                       const unsigned iNVertices)  
183 {
184   //  // Renders the normals:
185   //  glBegin(GL_LINES);
186   //  for(unsigned int i=0; i<iNVertices; i++)
187   //  { 
188   //    glVertex3r( iVertices[iVIndices[i]], 
189   //      iVertices[iVIndices[i]+1],
190   //      iVertices[iVIndices[i]+2]);
191   //    
192   //    glVertex3r(iVertices[iVIndices[i]] + iNormals[iNIndices[i]]/10.f, 
193   //      iVertices[iVIndices[i]+1] + iNormals[iNIndices[i]+1]/10.f,
194   //      iVertices[iVIndices[i]+2] + iNormals[iNIndices[i]+2]/10.f);
195   //  }
196   //  glEnd();
197 }