Création d'un compte pour un collaborateur extérieur au laboratoire depuis l'intranet ICube : https://intranet.icube.unistra.fr/fr/labs/member/profile

clipping.cpp 36.5 KB
Newer Older
1
2
3
/*******************************************************************************
* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps  *
* version 0.1                                                                  *
4
* Copyright (C) 2009-2012, IGG Team, LSIIT, University of Strasbourg           *
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
*                                                                              *
* This library is free software; you can redistribute it and/or modify it      *
* under the terms of the GNU Lesser General Public License as published by the *
* Free Software Foundation; either version 2.1 of the License, or (at your     *
* option) any later version.                                                   *
*                                                                              *
* This library is distributed  in the hope that it will be useful, but WITHOUT *
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or        *
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License  *
* for more details.                                                            *
*                                                                              *
* You should have received a copy of the GNU Lesser General Public License     *
* along with this library; if not, write to the Free Software Foundation,      *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.           *
*                                                                              *
20
* Web site: http://cgogn.unistra.fr/                                           *
21
22
23
24
* Contact information: cgogn@unistra.fr                                        *
*                                                                              *
*******************************************************************************/

25
#include "clipping.h"
Thery Sylvain's avatar
Thery Sylvain committed
26
#include "Utils/vbo.h"
27
28
#include "Utils/static_assert.h"

29
30
31
32
/*******************************************************************************
 *														MISCELLANOUS
 *******************************************************************************/

33
void computeBasisFromVector(const Geom::Vec3f& inVec1, Geom::Vec3f& vec2, Geom::Vec3f& vec3)
34
{
35
	const float epsilon = 0.000001f;
36
37

	// Check if the given vector length is acceptable
38
	if (inVec1.norm() < epsilon)
39
40
41
42
43
44
45
		return;

	// First take a non colinear second vector to cross product with vec1
	// (by default (0.0, 0.0, 1.0)
	Geom::Vec3f tempVec (0.0, 0.0, 1.0);

	// Construct second vector, check other vectors non colinearity at the same time
46
47
	vec2 = inVec1 ^ tempVec;
	float sinAngle = vec2.norm() / (inVec1.norm()*tempVec.norm());
48
49
50
	if (sinAngle < epsilon) // f:x->sin(x) ~ f:x->x when x ~ 0
	{
		tempVec = Geom::Vec3f (1.0, 0.0, 0.0);
51
		vec2 = inVec1 ^ tempVec;
52
53
	}

54
55
56
	// Normalize second vector
	vec2.normalize();

57
	// Get third vector
58
59
60
61
62
63
	vec3 = inVec1 ^ vec2;

	// Normalize third vector
	vec3.normalize();

}
64

65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
void Clipping::updatePickables()
{
	for (size_t i = 0; i < m_pickablePlanes.size(); i++)
	{
		unsigned int id = m_pickablePlanes[i]->id();
		Geom::Vec3f pos = m_shader->getClipPlaneParamsOrigin(id);
		Geom::Vec3f vec1, vec2, vec3;
		vec1 = m_shader->getClipPlaneParamsNormal(id);
		computeBasisFromVector(vec1, vec2, vec3);
		glm::mat4& transfoMat = m_pickablePlanes[i]->transfo();
		for (int j = 0; j < 3; j++)
		{
			transfoMat[0][j] = vec2[j];
			transfoMat[1][j] = vec3[j];
			transfoMat[2][j] = vec1[j];
			transfoMat[3][j] = pos[j];
		}
82
83
84
85
		transfoMat[0][3] = 0.0;
		transfoMat[1][3] = 0.0;
		transfoMat[2][3] = 0.0;
		transfoMat[3][3] = 1.0;
86
87
88
89
	}
	for (size_t i = 0; i < m_pickableSpheres.size(); i++)
	{
		unsigned int id = m_pickableSpheres[i]->id();
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
		Geom::Vec3f pos = m_shader->getClipSphereParamsCenter(id);
		float radius = m_shader->getClipSphereParamsRadius(id);
		Geom::Vec3f vec1 (radius, 0.0, 0.0);
		Geom::Vec3f vec2 (0.0, radius, 0.0);
		Geom::Vec3f vec3 (0.0, 0.0, radius);
		glm::mat4& transfoMat = m_pickableSpheres[i]->transfo();
		for (int j = 0; j < 3; j++)
		{
			transfoMat[0][j] = vec2[j];
			transfoMat[1][j] = vec3[j];
			transfoMat[2][j] = vec1[j];
			transfoMat[3][j] = pos[j];
		}
		transfoMat[0][3] = 0.0;
		transfoMat[1][3] = 0.0;
		transfoMat[2][3] = 0.0;
		transfoMat[3][3] = 1.0;
107
	}
108
109
}

110
111
112
113
/*******************************************************************************
 *														SLOTS
 *******************************************************************************/

114
void Clipping::slot_drawTopo(bool b)
115
116
117
118
119
{
	m_drawTopo = b;
	updateGL();
}

120
void Clipping::slot_drawVertices(bool b)
121
122
123
124
125
{
	m_drawVertices = b;
	updateGL();
}

126
void Clipping::slot_drawLines(bool b)
127
128
129
130
131
{
	m_drawLines = b;
	updateGL();
}

132
void Clipping::slot_drawFaces(bool b)
133
134
135
136
137
{
	m_drawFaces = b;
	updateGL();
}

138
void Clipping::slot_explodTopoPhi1(double c)
139
140
{
	m_coeffTopoExplod[0] = (float)c;
141
	m_render_topo->updateData(myMap, position, m_coeffTopoExplod[0], m_coeffTopoExplod[1], m_coeffTopoExplod[2]);
142
143
144
	updateGL();
}

145
void Clipping::slot_explodTopoPhi2(double c)
146
147
{
	m_coeffTopoExplod[1] = (float)c;
148
	m_render_topo->updateData(myMap, position, m_coeffTopoExplod[0], m_coeffTopoExplod[1], m_coeffTopoExplod[2]);
149
150
151
	updateGL();
}

152
void Clipping::slot_explodTopoPhi3(double c)
153
154
{
	m_coeffTopoExplod[2] = (float)c;
155
	m_render_topo->updateData(myMap, position, m_coeffTopoExplod[0], m_coeffTopoExplod[1], m_coeffTopoExplod[2]);
156
157
158
	updateGL();
}

159
void Clipping::slot_pushButton_addPlane()
160
{
Maire Nicolas's avatar
Maire Nicolas committed
161
162
163
164
	// Check if no animation is active
	if (m_lastAnimatedClippingPreset != NULL)
		return;

165
	// Create clipping and pickable objects
166
	unsigned int newPlaneId = m_shader->addClipPlane();
167
	Utils::Pickable* pickable = new Utils::Pickable(m_planeDrawable, newPlaneId);
Maire Nicolas's avatar
Maire Nicolas committed
168
	m_pickablePlanes.push_back(pickable);
169

170
171
	// Set params
	m_shader->setClipPlaneParamsOrigin(newPlaneId, m_bb.center());
172
	pickable->translate(m_bb.center());
173
	pickable->scale(Geom::Vec3f(m_bb.maxSize()*0.5));
174

175
	// Update shader sources edits
176
177
178
179
180
181
	dock.vertexEdit->setPlainText(QString(m_shader->getVertexShaderSrc()));
	dock.fragmentEdit->setPlainText(QString(m_shader->getFragmentShaderSrc()));

	updateGLMatrices();
}

182
void Clipping::slot_spinBox_GridResolution(int i)
183
{
184
	m_planeDrawable->updatePrecisionDrawing(i);
185
186
187
	updateGL();
}

188
void Clipping::slot_pushButton_changePlanesColor()
189
{
Sylvain Thery's avatar
Sylvain Thery committed
190
	QColor NewColor = QColorDialog::getColor();
191
192
193
194
195

	int r, g, b;
	NewColor.getRgb(&r, &g, &b);

	m_planeDrawable->setColor(Geom::Vec4f((float)r/255.0, (float)g/255.0, (float)b/255.0, 1.0));
196
197
}

198
void Clipping::slot_pushButton_addSphere()
199
{
Maire Nicolas's avatar
Maire Nicolas committed
200
201
202
203
	// Check if no animation is active
	if (m_lastAnimatedClippingPreset != NULL)
		return;

204
	// Create clipping and pickable objects
205
	unsigned int newSphereId = m_shader->addClipSphere();
206
	Utils::Pickable* pickable = new Utils::Pickable(m_sphereDrawable, newSphereId);
Maire Nicolas's avatar
Maire Nicolas committed
207
	m_pickableSpheres.push_back(pickable);
208

209
210
	// Set params
	m_shader->setClipSphereParamsCenter(newSphereId, m_bb.center());
211
	m_shader->setClipSphereParamsRadius(newSphereId, (m_bb.maxSize())*0.5);
212
	pickable->translate(m_bb.center());
213
	pickable->scale(Geom::Vec3f(m_bb.maxSize()*0.5));
214

215
	// Update shader sources edits
216
217
218
219
220
221
	dock.vertexEdit->setPlainText(QString(m_shader->getVertexShaderSrc()));
	dock.fragmentEdit->setPlainText(QString(m_shader->getFragmentShaderSrc()));

	updateGLMatrices();
}

222
void Clipping::slot_spinBox_SphereResolution(int i)
223
{
224
	m_sphereDrawable->updatePrecisionDrawing(i);
225
226
227
	updateGL();
}

228
void Clipping::slot_pushButton_changeSpheresColor()
229
{
230
	QColor NewColor = QColorDialog::getColor();
231

232
233
234
235
236

	int r, g, b;
	NewColor.getRgb(&r, &g, &b);

	m_sphereDrawable->setColor(Geom::Vec4f((float)r/255.0, (float)g/255.0, (float)b/255.0, 1.0));
237
238
}

239
void Clipping::slot_doubleSpinBox_ColorAttenuationFactor(double c)
240
{
241
	m_shader->setClipColorAttenuationFactorAbsolute((float)c);
242
243
244
	updateGL();
}

245
void Clipping::slot_radioButton_ClippingMode(bool b)
246
{
247
	if (b)
248
		m_shader->setClipMode(Utils::ClippingShader::CLIPPING_MODE_AND);
249
	else
250
251
252
253
254
255
256
257
		m_shader->setClipMode(Utils::ClippingShader::CLIPPING_MODE_OR);

	dock.vertexEdit->setPlainText(QString(m_shader->getVertexShaderSrc()));
	dock.fragmentEdit->setPlainText(QString(m_shader->getFragmentShaderSrc()));

	updateGLMatrices();
}

258
259
260
261
262
263
264
265
266
267
268
269
270
void Clipping::slot_radioButton_ColorAttenuationMode(bool b)
{
	if (b)
		m_shader->setClipColorAttenuationMode(Utils::ClippingShader::COLOR_ATTENUATION_MODE_LINEAR);
	else
		m_shader->setClipColorAttenuationMode(Utils::ClippingShader::COLOR_ATTENUATION_MODE_QUADRATIC);

	dock.vertexEdit->setPlainText(QString(m_shader->getVertexShaderSrc()));
	dock.fragmentEdit->setPlainText(QString(m_shader->getFragmentShaderSrc()));

	updateGLMatrices();
}

271
void Clipping::slot_pushButton_deleteSelectedObject()
272
{
Maire Nicolas's avatar
Maire Nicolas committed
273
274
275
276
	// Check if no animation is active
	if (m_lastAnimatedClippingPreset != NULL)
		return;

277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
	if (m_lastPickedObject)
	{
		// Delete clipping object
		if (m_lastPickedObject->checkType<Utils::Grid>())
			m_shader->deleteClipPlane(m_lastPickedObject->id());
		else if (m_lastPickedObject->checkType<Utils::Sphere>())
			m_shader->deleteClipSphere(m_lastPickedObject->id());

		// Delete pickable
		if (m_lastPickedObject->checkType<Utils::Grid>())
		{
			for (size_t i = 0; i < m_pickablePlanes.size(); i++)
			{
				if (m_pickablePlanes[i] == m_lastPickedObject)
				{
					delete m_pickablePlanes[i];
					m_pickablePlanes.erase(m_pickablePlanes.begin() + i);
				}
			}
		}
		else if (m_lastPickedObject->checkType<Utils::Sphere>())
		{
			for (size_t i = 0; i < m_pickableSpheres.size(); i++)
			{
				if (m_pickableSpheres[i] == m_lastPickedObject)
				{
					delete m_pickableSpheres[i];
					m_pickableSpheres.erase(m_pickableSpheres.begin() + i);
				}
			}
		}
		m_lastPickedObject = NULL;
309
310
		m_frameManipulator->highlight(m_frameManipulatorPickedAxis);
		m_frameManipulatorPickedAxis = 0;
311
312
313
314
315
316
317
318
319
320

		// Update shader sources edits
		dock.vertexEdit->setPlainText(QString(m_shader->getVertexShaderSrc()));
		dock.fragmentEdit->setPlainText(QString(m_shader->getFragmentShaderSrc()));

		updateGLMatrices();

	}
}

321
void Clipping::slot_pushButton_applyStaticClippingPreset()
322
{
Maire Nicolas's avatar
Maire Nicolas committed
323
324
325
326
	// Check if no animation is active
	if (m_lastAnimatedClippingPreset != NULL)
		return;

327
328
	// Create and apply preset
	Utils::ClippingPreset *preset = NULL;
329
	switch (dock.comboBox_StaticClippingPresets->currentIndex())
330
331
	{
		case 0 : // Dual planes
Maire Nicolas's avatar
Maire Nicolas committed
332
	 	{
333
334
		 	using namespace CGoGN::Utils::QT;

335
336
337
338
		 	float centerX = m_bb.center()[0];
		 	float centerY = m_bb.center()[1];
		 	float centerZ = m_bb.center()[2];
		 	float size = m_bb.maxSize()*0.75f;
339
340
		 	int axis = 0;
		 	bool facing = false;
341
342
343
344
		 	if (inputValues(VarFloat(centerX - 100.0f, centerX + 100.0f, centerX, "Center X",
		 					VarFloat(centerY - 100.0f, centerY + 100.0f, centerY, "Center Y",
		 					VarFloat(centerZ - 100.0f, centerZ + 100.0f, centerZ, "Center Z",
		 					VarFloat(size - 100.0f, size + 100.0f, size, "Size",
345
346
347
		 					VarSlider(0, 2, axis, "Axis",
		 					VarBool(facing, "Facing"
		 				)))))), "Preset Setup"))
348
		 		preset = Utils::ClippingPreset::CreateDualPlanesPreset(Geom::Vec3f(centerX, centerY, centerZ), size, axis, facing);
Maire Nicolas's avatar
Maire Nicolas committed
349
350
	 	}
		break;
351
352

		case 1 : // Cube
Maire Nicolas's avatar
Maire Nicolas committed
353
	 	{
354
355
		 	using namespace CGoGN::Utils::QT;

356
357
358
359
		 	float centerX = m_bb.center()[0];
		 	float centerY = m_bb.center()[1];
		 	float centerZ = m_bb.center()[2];
		 	float size = m_bb.maxSize()*0.75f;
360
		 	bool facing = false;
361
362
363
364
		 	if (inputValues(VarFloat(centerX - 100.0f, centerX + 100.0f, centerX, "Center X",
		 					VarFloat(centerY - 100.0f, centerY + 100.0f, centerY, "Center Y",
		 					VarFloat(centerZ - 100.0f, centerZ + 100.0f, centerZ, "Center Z",
		 					VarFloat(size - 100.0f, size + 100.0f, size, "Size",
365
366
		 					VarBool(facing, "Facing"
		 				))))), "Preset Setup"))
367
		 		preset = Utils::ClippingPreset::CreateCubePreset(Geom::Vec3f(centerX, centerY, centerZ), size, facing);
Maire Nicolas's avatar
Maire Nicolas committed
368
369
	 	}
		break;
370
371

		case 2 : // Tube
Maire Nicolas's avatar
Maire Nicolas committed
372
	 	{
373
374
		 	using namespace CGoGN::Utils::QT;

375
376
377
378
		 	float centerX = m_bb.center()[0];
		 	float centerY = m_bb.center()[1];
		 	float centerZ = m_bb.center()[2];
		 	float size = m_bb.maxSize()*0.75f;
379
380
381
		 	int axis = 0;
		 	int precision = 1;
		 	bool facing = false;
382
383
384
385
		 	if (inputValues(VarFloat(centerX - 100.0f, centerX + 100.0f, centerX, "Center X",
		 					VarFloat(centerY - 100.0f, centerY + 100.0f, centerY, "Center Y",
		 					VarFloat(centerZ - 100.0f, centerZ + 100.0f, centerZ, "Center Z",
		 					VarFloat(size - 100.0f, size + 100.0f, size, "Size",
386
387
388
389
		 					VarSlider(0, 2, axis, "Axis",
		 					VarSlider(1, 30, precision, "Precision",
		 					VarBool(facing, "Facing"
		 				))))))), "Preset Setup"))
390
		 		preset = Utils::ClippingPreset::CreateTubePreset(Geom::Vec3f(centerX, centerY, centerZ), size, axis, precision, facing);
Maire Nicolas's avatar
Maire Nicolas committed
391
392
	 	}
		break;
393
394

		case 3 : // Molecule
Maire Nicolas's avatar
Maire Nicolas committed
395
	 	{
396
397
		 	using namespace CGoGN::Utils::QT;

398
399
400
401
402
		 	float centerX = m_bb.center()[0];
		 	float centerY = m_bb.center()[1];
		 	float centerZ = m_bb.center()[2];
		 	float size = m_bb.maxSize()*0.75f;
		 	float atomsRadiuses = m_bb.maxSize()*0.25f;
403
		 	bool orClipping = true;
404
405
406
407
408
		 	if (inputValues(VarFloat(centerX - 100.0f, centerX + 100.0f, centerX, "Center X",
		 					VarFloat(centerY - 100.0f, centerY + 100.0f, centerY, "Center Y",
		 					VarFloat(centerZ - 100.0f, centerZ + 100.0f, centerZ, "Center Z",
		 					VarFloat(size - 100.0f, size + 100.0f, size, "Size",
		 					VarFloat(atomsRadiuses - 100.0f, atomsRadiuses + 100.0f, atomsRadiuses, "Atoms radiuses",
409
410
		 					VarBool(orClipping, "OR clipping mode"
		 				)))))), "Preset Setup"))
411
		 		preset = Utils::ClippingPreset::CreateMoleculePreset(Geom::Vec3f(centerX, centerY, centerZ), size, atomsRadiuses, orClipping);
Maire Nicolas's avatar
Maire Nicolas committed
412
413
	 	}
		break;
414
	}
415
416
417
418

	if (preset == NULL)
		return;

419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
	std::vector<unsigned int> planesIds;
	std::vector<unsigned int> spheresIds;
	preset->apply(m_shader, &planesIds, &spheresIds);
	delete preset;

	// Cleanup of pickables before adding new ones
	m_lastPickedObject = NULL;
	for (size_t i = 0; i < m_pickablePlanes.size(); i++)
		delete m_pickablePlanes[i];
	m_pickablePlanes.resize(0);
	for (size_t i = 0; i < m_pickableSpheres.size(); i++)
		delete m_pickableSpheres[i];
	m_pickableSpheres.resize(0);

	// Add new pickable objects
	for (size_t i = 0; i < planesIds.size(); i++)
	{
		Utils::Pickable* pickable = new Utils::Pickable(m_planeDrawable, planesIds[i]);
		m_pickablePlanes.push_back(pickable);
	}
	for (size_t i = 0; i < spheresIds.size(); i++)
	{
		Utils::Pickable* pickable = new Utils::Pickable(m_sphereDrawable, spheresIds[i]);
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
		m_pickableSpheres.push_back(pickable);
	}
	updatePickables();

	// Update shader sources edits
	dock.vertexEdit->setPlainText(QString(m_shader->getVertexShaderSrc()));
	dock.fragmentEdit->setPlainText(QString(m_shader->getFragmentShaderSrc()));

	// Update clipping parameters in interface
	Utils::ClippingShader::clippingMode clipMode = m_shader->getClipMode();
	if (clipMode == Utils::ClippingShader::CLIPPING_MODE_AND)
		dock.radioButton_ClippingModeAnd->setChecked(true);
	else if (clipMode == Utils::ClippingShader::CLIPPING_MODE_OR)
		dock.radioButton_ClippingModeOr->setChecked(true);


	updateGLMatrices();
}

void Clipping::slot_pushButton_applyAnimatedClippingPreset()
{
Maire Nicolas's avatar
Maire Nicolas committed
463
464
465
466
	// Check if no animation is active
	if (m_lastAnimatedClippingPreset != NULL)
		return;

467
468
469
470
471
	// Create and apply preset
	Utils::ClippingPresetAnimated *animatedPreset = NULL;
	switch (dock.comboBox_AnimatedClippingPresets->currentIndex())
	{
		case 0 : // Moving Dual planes
Maire Nicolas's avatar
Maire Nicolas committed
472
	 	{
473
474
475
		 	Utils::ClippingPresetAnimatedDualPlanes *preset = NULL;
		 	using namespace CGoGN::Utils::QT;

Maire Nicolas's avatar
Maire Nicolas committed
476
		 	float centerStartX = m_bb.center()[0] - m_bb.size(0)*0.75f;
477
478
		 	float centerStartY = m_bb.center()[1];
		 	float centerStartZ = m_bb.center()[2];
Maire Nicolas's avatar
Maire Nicolas committed
479
		 	float centerEndX = m_bb.center()[0] + m_bb.size(0)*0.75f;
480
481
482
		 	float centerEndY = m_bb.center()[1];
		 	float centerEndZ = m_bb.center()[2];
		 	float size = m_bb.maxSize()*0.1f;
483
484
		 	int axis = 0;
		 	bool facing = false;
485
		 	bool zigzag = false;
486
487
488
489
490
491
492
		 	if (inputValues(VarFloat(centerStartX - 100.0f, centerStartX + 100.0f, centerStartX, "Center Start X",
		 					VarFloat(centerStartY - 100.0f, centerStartY + 100.0f, centerStartY, "Center Start Y",
		 					VarFloat(centerStartZ - 100.0f, centerStartZ + 100.0f, centerStartZ, "Center Start Z",
		 					VarFloat(centerEndX - 100.0f, centerEndX + 100.0f, centerEndX, "Center End X",
		 					VarFloat(centerEndY - 100.0f, centerEndY + 100.0f, centerEndY, "Center End Y",
		 					VarFloat(centerEndZ - 100.0f, centerEndZ + 100.0f, centerEndZ, "Center End Z",
		 					VarFloat(size - 100.0f, size + 100.0f, size, "Size",
493
		 					VarSlider(0, 2, axis, "Axis",
494
495
496
		 					VarBool(facing, "Facing",
		 					VarBool(zigzag, "Zigzag"
		 				)))))))))), "Preset Setup"))
497
		 		preset = new Utils::ClippingPresetAnimatedDualPlanes(
498
499
		 				Geom::Vec3f(centerStartX, centerStartY, centerStartZ), Geom::Vec3f(centerEndX, centerEndY, centerEndZ),
		 				size, axis, facing, zigzag);
500

501
		 	animatedPreset = preset;
Maire Nicolas's avatar
Maire Nicolas committed
502
503
	 	}
		break;
504

Maire Nicolas's avatar
Maire Nicolas committed
505
506
507
508
509
		case 1 : // Rotating Plane
	 	{
		 	Utils::ClippingPresetAnimatedRotatingPlane *preset = NULL;
		 	using namespace CGoGN::Utils::QT;

510
511
512
		 	float centerX = m_bb.center()[0];
		 	float centerY = m_bb.center()[1];
		 	float centerZ = m_bb.center()[2];
Maire Nicolas's avatar
Maire Nicolas committed
513
		 	int axis = 0;
514
515
516
		 	if (inputValues(VarFloat(centerX - 100.0f, centerX + 100.0f, centerX, "Center X",
		 					VarFloat(centerY - 100.0f, centerY + 100.0f, centerY, "Center Y",
		 					VarFloat(centerZ - 100.0f, centerZ + 100.0f, centerZ, "Center Z",
Maire Nicolas's avatar
Maire Nicolas committed
517
518
519
		 					VarSlider(0, 2, axis, "Axis"
		 				)))), "Preset Setup"))
		 		preset = new Utils::ClippingPresetAnimatedRotatingPlane(
520
		 				Geom::Vec3f(centerX, centerY, centerZ), axis);
Maire Nicolas's avatar
Maire Nicolas committed
521
522
523
524

		 	animatedPreset = preset;
	 	}
		break;
525

526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
		case 2 : // Scaled Sphere
	 	{
		 	Utils::ClippingPresetAnimatedScaledSphere *preset = NULL;
		 	using namespace CGoGN::Utils::QT;

		 	float centerX = m_bb.center()[0];
		 	float centerY = m_bb.center()[1];
		 	float centerZ = m_bb.center()[2];
		 	float radiusStart = m_bb.maxSize()*0.1f;
		 	float radiusEnd = m_bb.maxSize()*1.0f;
		 	bool zigzag = false;
		 	if (inputValues(VarFloat(centerX - 100.0f, centerX + 100.0f, centerX, "Center X",
		 					VarFloat(centerY - 100.0f, centerY + 100.0f, centerY, "Center Y",
		 					VarFloat(centerZ - 100.0f, centerZ + 100.0f, centerZ, "Center Z",
		 					VarFloat(-radiusEnd*4.0f, radiusEnd*4.0f, radiusStart, "Radius Start",
		 					VarFloat(-radiusEnd*4.0f, radiusEnd*4.0f, radiusEnd, "Radius End",
		 					VarBool(zigzag, "Zigzag"
		 				)))))), "Preset Setup"))
		 		preset = new Utils::ClippingPresetAnimatedScaledSphere(
		 				Geom::Vec3f(centerX, centerY, centerZ), radiusStart, radiusEnd, zigzag);

		 	animatedPreset = preset;
	 	}
		break;

		case 3 : // Spheres Cube Collision
	 	{
		 	Utils::ClippingPresetAnimatedSpheresCubeCollision *preset = NULL;
		 	using namespace CGoGN::Utils::QT;

		 	float centerX = m_bb.center()[0];
		 	float centerY = m_bb.center()[1];
		 	float centerZ = m_bb.center()[2];
		 	float size = m_bb.maxSize()*1.0f;
		 	int spheresCount = 5;
		 	float radius = m_bb.maxSize()*0.2f;
		 	if (inputValues(VarFloat(centerX - 100.0f, centerX + 100.0f, centerX, "Center X",
		 					VarFloat(centerY - 100.0f, centerY + 100.0f, centerY, "Center Y",
		 					VarFloat(centerZ - 100.0f, centerZ + 100.0f, centerZ, "Center Z",
		 					VarFloat(-size*4.0f, size*4.0f, size, "Cube Size",
		 					VarSlider(1, 20, spheresCount, "Spheres Count",
		 					VarFloat(-radius*4.0f, radius*4.0f, radius, "Spheres Radius"
		 				)))))), "Preset Setup"))
		 	{
		 		preset = new Utils::ClippingPresetAnimatedSpheresCubeCollision(
		 				Geom::Vec3f(centerX, centerY, centerZ), size, spheresCount, radius);
		 	}

		 	animatedPreset = preset;
	 	}
		break;
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
	}

	if (animatedPreset == NULL)
		return;

	std::vector<unsigned int> planesIds;
	std::vector<unsigned int> spheresIds;
	animatedPreset->apply(m_shader, &planesIds, &spheresIds);

	// Cleanup of pickables before adding new ones
	m_lastPickedObject = NULL;
	for (size_t i = 0; i < m_pickablePlanes.size(); i++)
		delete m_pickablePlanes[i];
	m_pickablePlanes.resize(0);
	for (size_t i = 0; i < m_pickableSpheres.size(); i++)
		delete m_pickableSpheres[i];
	m_pickableSpheres.resize(0);

	// Add new pickable objects
	for (size_t i = 0; i < planesIds.size(); i++)
	{
		Utils::Pickable* pickable = new Utils::Pickable(m_planeDrawable, planesIds[i]);
		m_pickablePlanes.push_back(pickable);
	}
	for (size_t i = 0; i < spheresIds.size(); i++)
	{
		Utils::Pickable* pickable = new Utils::Pickable(m_sphereDrawable, spheresIds[i]);
604
		m_pickableSpheres.push_back(pickable);
605
	}
606
	updatePickables();
607
608
609
610
611
612
613
614
615
616
617
618

	// Update shader sources edits
	dock.vertexEdit->setPlainText(QString(m_shader->getVertexShaderSrc()));
	dock.fragmentEdit->setPlainText(QString(m_shader->getFragmentShaderSrc()));

	// Update clipping parameters in interface
	Utils::ClippingShader::clippingMode clipMode = m_shader->getClipMode();
	if (clipMode == Utils::ClippingShader::CLIPPING_MODE_AND)
		dock.radioButton_ClippingModeAnd->setChecked(true);
	else if (clipMode == Utils::ClippingShader::CLIPPING_MODE_OR)
		dock.radioButton_ClippingModeOr->setChecked(true);

619
620
621
	// Set on animated mode
	m_lastAnimatedClippingPreset = animatedPreset;
	m_timer->start(1000.0f/60.0f);
622
623
	m_lastAnimatedClippingPreset->setAnimationSpeedFactor((float)dock.doubleSpinBox_AnimatedClippingPresetSpeed->value());
	slot_setAnimationState(true);
624

625
626
627
628

	updateGLMatrices();
}

629
630
631
632
633
634
635
void Clipping::slot_pushButton_StopAnimation()
{
	if (m_lastAnimatedClippingPreset != NULL)
	{
		delete m_lastAnimatedClippingPreset;
		m_lastAnimatedClippingPreset = NULL;
	}
636
	slot_setAnimationState(false);
637
638
639
640
641
642
643
644
}

void Clipping::slot_doubleSpinBox_AnimatedClippingPresetSpeed(double c)
{
	if (m_lastAnimatedClippingPreset != NULL)
		m_lastAnimatedClippingPreset->setAnimationSpeedFactor((float)c);
}

645
646
647
648
649
650
651
652
void Clipping::slot_setAnimationState(bool state)
{
	dock.pushButton_addPlane->setEnabled(!state);
	dock.pushButton_addSphere->setEnabled(!state);
	dock.PushButton_ApplyStaticClippingPreset->setEnabled(!state);
	dock.PushButton_ApplyAnimatedClippingPreset->setEnabled(!state);
}

653
654
655
656
657
658
659
660
661
662
663
664
665
666
void Clipping::slot_animationTimer()
{
	if (m_lastAnimatedClippingPreset == NULL)
	{
		m_timer->stop();
		return;
	}

	m_lastAnimatedClippingPreset->step(1);
	updatePickables();

	updateGL();
}

667
void Clipping::button_compile()
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
{
	QString st1 = dynamic_cast<Utils::QT::uiDockInterface*>(dockWidget())->vertexEdit->toPlainText();
	QString st2 = dynamic_cast<Utils::QT::uiDockInterface*>(dockWidget())->fragmentEdit->toPlainText();

	m_shader->reloadVertexShaderFromMemory(st1.toStdString().c_str());
	m_shader->reloadFragmentShaderFromMemory(st2.toStdString().c_str());

	m_shader->recompile();
	updateGLMatrices();
}

/*******************************************************************************
 *														Init Functions
 *******************************************************************************/

683
Clipping::Clipping():
684
685
686
687
688
689
690
	m_drawVertices(false),
	m_drawLines(true),
	m_drawFaces(true),
	m_drawTopo(false),
	m_render(NULL),
	m_render_topo(NULL),
	m_positionVBO(NULL),
691
692
693
	m_shader(NULL),
	m_timer(NULL),
	m_lastAnimatedClippingPreset(NULL)
694
695
696
697
{
	m_coeffTopoExplod = Geom::Vec3f(0.9,0.9,0.9);
}

698
void Clipping::initGUI()
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
{
	CGoGNStream::allToConsole(this) ;
	CGoGNStream::allToStd(true) ;

	setDock(&dock);

	dock.setWindowFlags(Qt::WindowMinimizeButtonHint);

	setCallBack(dock.checkBox_vertices, SIGNAL(toggled(bool)), SLOT(slot_drawVertices(bool)));
	setCallBack(dock.checkBox_lines, SIGNAL(toggled(bool)), SLOT(slot_drawLines(bool)));
	setCallBack(dock.checkBox_faces, SIGNAL(toggled(bool)), SLOT(slot_drawFaces(bool)));
	setCallBack(dock.groupBox_topo, SIGNAL(toggled(bool)), SLOT(slot_drawTopo(bool)));

	setCallBack(dock.explod_phi1, SIGNAL(valueChanged(double)), SLOT(slot_explodTopoPhi1(double)));
	setCallBack(dock.explod_phi2, SIGNAL(valueChanged(double)), SLOT(slot_explodTopoPhi2(double)));
	setCallBack(dock.explod_phi3, SIGNAL(valueChanged(double)), SLOT(slot_explodTopoPhi3(double)));

	setCallBack(dock.pushButton_addPlane, SIGNAL(clicked()), SLOT(slot_pushButton_addPlane()));

718
	setCallBack(dock.spinBox_GridResolution, SIGNAL(valueChanged(int)), SLOT(slot_spinBox_GridResolution(int)));
719
	setCallBack(dock.pushButton_changePlanesColor, SIGNAL(clicked()), SLOT(slot_pushButton_changePlanesColor()));
720

721
	setCallBack(dock.compileButton, SIGNAL(clicked()), SLOT(button_compile()));
722
723
724
725

	dock.vertexEdit->setPlainText(QString(m_shader->getVertexShaderSrc()));
	dock.fragmentEdit->setPlainText(QString(m_shader->getFragmentShaderSrc()));

726
727
728
	unsigned int planesPrecision1, planesPrecision2;
	m_planeDrawable->getPrecisionDrawing(planesPrecision1, planesPrecision2);
	dock.spinBox_GridResolution->setValue(planesPrecision1);
729
730
731

	setCallBack(dock.pushButton_addSphere, SIGNAL(clicked()), SLOT(slot_pushButton_addSphere()));

732
	setCallBack(dock.spinBox_SphereResolution, SIGNAL(valueChanged(int)), SLOT(slot_spinBox_SphereResolution(int)));
733
	setCallBack(dock.pushButton_changeSpheresColor, SIGNAL(clicked()), SLOT(slot_pushButton_changeSpheresColor()));
734

735
736
	unsigned int spheresPrecision1, spheresPrecision2;
	m_sphereDrawable->getPrecisionDrawing(spheresPrecision1, spheresPrecision2);
737
	dock.spinBox_SphereResolution->setValue(spheresPrecision1);
738
739

	setCallBack(dock.doubleSpinBox_ColorAttenuationFactor, SIGNAL(valueChanged(double)), SLOT(slot_doubleSpinBox_ColorAttenuationFactor(double)));
740
741
	setCallBack(dock.radioButton_ClippingModeAnd, SIGNAL(toggled(bool)), SLOT(slot_radioButton_ClippingMode(bool)));
	setCallBack(dock.radioButton_ColorAttenuationModeLinear, SIGNAL(toggled(bool)), SLOT(slot_radioButton_ColorAttenuationMode(bool)));
742
743
744
745

	dock.doubleSpinBox_ColorAttenuationFactor->setValue(m_shader->getClipColorAttenuationFactor());
	Utils::ClippingShader::clippingMode clipMode = m_shader->getClipMode();
	if (clipMode == Utils::ClippingShader::CLIPPING_MODE_AND)
746
		dock.radioButton_ClippingModeAnd->setChecked(true);
747
	else if (clipMode == Utils::ClippingShader::CLIPPING_MODE_OR)
748
749
750
751
752
753
		dock.radioButton_ClippingModeOr->setChecked(true);
	Utils::ClippingShader::colorAttenuationMode colorAttMode = m_shader->getClipColorAttenuationMode();
	if (colorAttMode == Utils::ClippingShader::COLOR_ATTENUATION_MODE_LINEAR)
		dock.radioButton_ColorAttenuationModeLinear->setChecked(true);
	else if (colorAttMode == Utils::ClippingShader::COLOR_ATTENUATION_MODE_QUADRATIC)
		dock.radioButton_ColorAttenuationModeQuadratic->setChecked(true);
754

755
756
757
758
759
760
761
762
763
764
	setCallBack(dock.PushButton_ApplyStaticClippingPreset, SIGNAL(clicked()), SLOT(slot_pushButton_applyStaticClippingPreset()));

	dock.comboBox_StaticClippingPresets->addItem("Dual Planes");
	dock.comboBox_StaticClippingPresets->addItem("Cube");
	dock.comboBox_StaticClippingPresets->addItem("Tube");
	dock.comboBox_StaticClippingPresets->addItem("Molecule");

	setCallBack(dock.PushButton_ApplyAnimatedClippingPreset, SIGNAL(clicked()), SLOT(slot_pushButton_applyAnimatedClippingPreset()));

	dock.comboBox_AnimatedClippingPresets->addItem("Moving Dual Planes");
Maire Nicolas's avatar
Maire Nicolas committed
765
	dock.comboBox_AnimatedClippingPresets->addItem("Rotating Plane");
766
767
	dock.comboBox_AnimatedClippingPresets->addItem("Scaled Sphere");
	dock.comboBox_AnimatedClippingPresets->addItem("Spheres Cube Collision");
768
769
770

	setCallBack(dock.pushButton_StopAnimation, SIGNAL(clicked()), SLOT(slot_pushButton_StopAnimation()));
	setCallBack(dock.doubleSpinBox_AnimatedClippingPresetSpeed, SIGNAL(valueChanged(double)), SLOT(slot_doubleSpinBox_AnimatedClippingPresetSpeed(double)));
771

772
773
774
	// timer used for animation
	m_timer = new QTimer( this );
	setCallBack( m_timer, SIGNAL(timeout()), SLOT(slot_animationTimer()) );
775
776
}

777
void Clipping::cb_Open()
778
779
780
781
782
783
784
785
{
	std::string filters("all (*.*)") ;
	std::string filename = selectFile("Open Mesh", "", filters) ;

	importMesh(filename) ;
	updateGL() ;
}

786
void Clipping::importMesh(std::string& filename)
787
788
789
{
	std::vector<std::string> attrNames ;

790
791
	size_t pos = filename.rfind(".");    // position of "." in filename
	std::string extension = filename.substr(pos);
792

793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
    if(extension == std::string(".map"))
    {
        if(!myMap.loadMapBin(filename))
        {
            CGoGNerr << "could not import " << filename << CGoGNendl ;
            return;
        }
        else
            position = myMap.getAttribute<VEC3, VERTEX>("position") ;
    }
    else
    {
        if(!Algo::Volume::Import::importMesh<PFP>(myMap, filename, attrNames))
        {
            std::cerr << "could not import " << filename << std::endl ;
            return ;
        }
        else
            position = myMap.getAttribute<PFP::VEC3,VERTEX>(attrNames[0]) ;
    }

Sylvain Thery's avatar
Sylvain Thery committed
814

815
816
	updateVBOprimitives(Algo::Render::GL2::TRIANGLES | Algo::Render::GL2::LINES | Algo::Render::GL2::POINTS) ;

817
	m_render_topo->updateData(myMap, position, m_coeffTopoExplod[0], m_coeffTopoExplod[1], m_coeffTopoExplod[2]);
818
819
820
821
822
823
824
825
826
827
828
829

	m_bb = Algo::Geometry::computeBoundingBox<PFP>(myMap, position) ;
	gPosObj = m_bb.center() ;
	float tailleX = m_bb.size(0) ;
	float tailleY = m_bb.size(1) ;
	float tailleZ = m_bb.size(2) ;
	gWidthObj = std::max<float>(std::max<float>(tailleX, tailleY), tailleZ) ;

	m_positionVBO->updateData(position) ;

	setParamObject(gWidthObj, gPosObj.data()) ;

830
	updateGLMatrices();
831
832

	m_shader->setClipColorAttenuationFactorRelative(m_bb.maxSize(), 5.0);
833
834
835
836
837
838
}

/*******************************************************************************
 *														GL FUNCTIONS
 *******************************************************************************/

839
void Clipping::cb_initGL()
840
841
842
843
844
845
{
	// choose to use GL version 2
	Utils::GLSLShader::setCurrentOGLVersion(2);

	// create the render
	m_render = new Algo::Render::GL2::MapRender();
846
	m_render_topo = new Algo::Render::GL2::Topo3Render<PFP>();
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863

	// create VBO for position
	m_positionVBO = new Utils::VBO();

	// using simple shader with color
	m_shader = new Utils::ShaderSimpleColor();
	m_shader->setAttributePosition(m_positionVBO);
	m_shader->setColor(Geom::Vec4f(0.,1.,0.,0.));

	registerShader(m_shader);

	// setup clipping
	m_shader->insertClippingCode();

	// setup clipping shapes
	m_planeDrawable = new Utils::Grid;
	m_planeDrawable->setColor(Geom::Vec4f(1.0, 0.0, 0.0, 1.0));
864
865
	m_planeDrawable->updatePrecisionDrawing(5);
	m_sphereDrawable = new Utils::IcoSphere;
866
	m_sphereDrawable->setColor(Geom::Vec4f(0.0, 0.4, 1.0, 1.0));
867
	m_sphereDrawable->updatePrecisionDrawing(1);
868
869
870

	// setup clipping picking frame
	m_frameManipulator = new Utils::FrameManipulator();
871
	m_lastPickedObject = NULL;
872
873
}

874
void Clipping::updateVBOprimitives(int upType)
875
876
{
	if(upType & Algo::Render::GL2::TRIANGLES)
877
		m_render->initPrimitives<PFP>(myMap, Algo::Render::GL2::TRIANGLES) ;
878
879

	if(upType & Algo::Render::GL2::LINES)
880
		m_render->initPrimitives<PFP>(myMap, Algo::Render::GL2::LINES,false) ;
881
882

	if(upType & Algo::Render::GL2::POINTS)
883
		m_render->initPrimitives<PFP>(myMap, Algo::Render::GL2::POINTS) ;
884
885
}

886
void Clipping::cb_redraw()
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
{
	if(m_drawVertices)
	{
		m_shader->setColor(Geom::Vec4f(0.,0.,1.,0.));
		m_render->draw(m_shader, Algo::Render::GL2::POINTS);
	}

	if(m_drawLines)
	{
		glLineWidth(2.0f);
		m_shader->setColor(Geom::Vec4f(1.,1.,0.,0.));
		m_render->draw(m_shader, Algo::Render::GL2::LINES);
	}

	if(m_drawFaces)
	{
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
		glEnable(GL_LIGHTING);
		glEnable(GL_POLYGON_OFFSET_FILL);
		glPolygonOffset(1.0f, 1.0f);
		m_shader->setColor(Geom::Vec4f(0.,1.,0.,0.));
		m_render->draw(m_shader, Algo::Render::GL2::TRIANGLES);
		glDisable(GL_POLYGON_OFFSET_FILL);
	}

	if (m_drawTopo)
		m_render_topo->drawTopo();

	// Display clipping shapes
Maire Nicolas's avatar
Maire Nicolas committed
916
	for (size_t i = 0; i < m_pickablePlanes.size(); i++)
917
918
919
920
921
	{
		if (m_pickablePlanes[i] == m_lastPickedObject)
			glLineWidth(5.0);
		else
			glLineWidth(2.0);
Maire Nicolas's avatar
Maire Nicolas committed
922
		m_pickablePlanes[i]->draw();
923
	}
Maire Nicolas's avatar
Maire Nicolas committed
924
	for (size_t i = 0; i < m_pickableSpheres.size(); i++)
925
926
927
928
929
	{
		if (m_pickableSpheres[i] == m_lastPickedObject)
			glLineWidth(5.0);
		else
			glLineWidth(2.0);
Maire Nicolas's avatar
Maire Nicolas committed
930
		m_pickableSpheres[i]->draw();
931
	}
932

933
934
935
936
	// Display picking frame
	if (m_lastPickedObject)
		m_frameManipulator->draw();

937
938
}

939
void Clipping::cb_keyPress(int code)
940
{
941
942
943
	switch (code)
	{
		case 16777223 : // Suppr
944
			slot_pushButton_deleteSelectedObject();
945
			break;
Maire Nicolas's avatar
Maire Nicolas committed
946
947
948
949
950
951
952
953
954
955

		case '+' :
			dock.doubleSpinBox_AnimatedClippingPresetSpeed->setValue(
					dock.doubleSpinBox_AnimatedClippingPresetSpeed->value() + 0.1);
			break;

		case '-' :
			dock.doubleSpinBox_AnimatedClippingPresetSpeed->setValue(
					dock.doubleSpinBox_AnimatedClippingPresetSpeed->value() - 0.1);
			break;
956
	}
957
958
}

959
void Clipping::cb_mousePress(int /*button*/, int x, int y)
960
{
Maire Nicolas's avatar
Maire Nicolas committed
961
962
963
964
	// Check if no animation is active
	if (m_lastAnimatedClippingPreset != NULL)
		return;

Maire Nicolas's avatar
Maire Nicolas committed
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
	if (!Shift())
		return;

	m_lastClickedX = x;
	m_lastClickedY = y;

	// get ray of selection
	Geom::Vec3f rayA, rayB;
	float dist = getOrthoScreenRay(x, y, rayA, rayB);
	Geom::Vec3f AB = rayB - rayA;


	unsigned int newPickedFrameAxis = 0;
	unsigned int lastPickedFrameAxis = m_frameManipulatorPickedAxis;
	if (m_lastPickedObject)	// an object is already picked ? => frame is drawn
	{
		// picking the frame -> axis
		newPickedFrameAxis = m_frameManipulator->pick(rayA, AB, dist);
		m_frameManipulatorPickedAxis = newPickedFrameAxis;

985
986
987
988
		// highlight new axis
		if (lastPickedFrameAxis != newPickedFrameAxis)
			m_frameManipulator->highlight(m_frameManipulatorPickedAxis);
	}
Maire Nicolas's avatar
Maire Nicolas committed
989
990
991

	if (newPickedFrameAxis == 0)	// frame not picked -> pick the pickable objects
	{
992
993
994
995
		std::vector<Utils::Pickable*> tempo = m_pickablePlanes;
		tempo.insert(tempo.end(), m_pickableSpheres.begin(), m_pickableSpheres.end());
		m_lastPickedObject = Utils::Pickable::pick(tempo, rayA, AB);

Maire Nicolas's avatar
Maire Nicolas committed
996
997
		// set FrameManipulator on picked object
		if (m_lastPickedObject)
998
		{
Maire Nicolas's avatar
Maire Nicolas committed
999
			m_frameManipulator->setTransformation(m_lastPickedObject->transfo());
1000
1001
1002
1003
1004
1005

			// Lock individual scale axes for the sphere
			if (m_lastPickedObject->checkType<Utils::Grid>())
				m_frameManipulator->unlock(Utils::FrameManipulator::Scales);
			else if (m_lastPickedObject->checkType<Utils::Sphere>())
				m_frameManipulator->lock(Utils::FrameManipulator::Scales);
1006
		}
Maire Nicolas's avatar
Maire Nicolas committed
1007
1008
1009
1010
1011
1012
1013
1014
	}

	// store origin & selected axis on screen projection for easy manipulation.
	m_frameManipulator->storeProjection(m_frameManipulatorPickedAxis);

	updateGL();
}

1015
void Clipping::cb_mouseMove(int buttons, int x, int y)
Maire Nicolas's avatar
Maire Nicolas committed
1016
{
Maire Nicolas's avatar
Maire Nicolas committed
1017
1018
1019
1020
	// Check if no animation is active
	if (m_lastAnimatedClippingPreset != NULL)
		return;

Maire Nicolas's avatar
Maire Nicolas committed
1021
1022
1023
	if (!Shift())
		return;

1024
1025
	bool clippingUpdateNeeded = false;

Maire Nicolas's avatar
Maire Nicolas committed
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
	// rotation selected ?
	if (Utils::FrameManipulator::rotationAxis(m_frameManipulatorPickedAxis))
	{
		if (buttons & 1)
		{
			float angle = m_frameManipulator->angleFromMouse(x, y, x - m_lastClickedX, y - m_lastClickedY);
			m_frameManipulator->rotate(m_frameManipulatorPickedAxis, angle);
		}
		else if (buttons & 2)
			m_frameManipulator->rotateInScreen(x - m_lastClickedX, y - m_lastClickedY);

		m_lastPickedObject->transfo() = m_frameManipulator->transfo();
1038
1039

		clippingUpdateNeeded = true;
Maire Nicolas's avatar
Maire Nicolas committed
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
	}
	// translation selected
	else if (Utils::FrameManipulator::translationAxis(m_frameManipulatorPickedAxis))
	{
		if (buttons & 1)
		{
			float dist =  m_frameManipulator->distanceFromMouse(x - m_lastClickedX, y - m_lastClickedY);
			m_frameManipulator->translate(m_frameManipulatorPickedAxis, dist);
		}
		else if (buttons & 2)
			m_frameManipulator->translateInScreen(x - m_lastClickedX, y - m_lastClickedY);

		m_lastPickedObject->transfo() = m_frameManipulator->transfo();
1053
1054

		clippingUpdateNeeded = true;
Maire Nicolas's avatar
Maire Nicolas committed
1055
1056
1057
1058
1059
1060
1061
	}
	// scale selected
	else if (Utils::FrameManipulator::scaleAxis(m_frameManipulatorPickedAxis) )
	{
		float scale = m_frameManipulator->scaleFromMouse(x - m_lastClickedX, y - m_lastClickedY);
		m_frameManipulator->scale(m_frameManipulatorPickedAxis, scale );
		m_lastPickedObject->transfo() = m_frameManipulator->transfo();
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088

		clippingUpdateNeeded = true;
	}

	// Update clipping shape if needed
	if (clippingUpdateNeeded && m_lastPickedObject)
	{
		if (m_lastPickedObject->checkType<Utils::Grid>())
		{
			// Get plane position and normal
			Geom::Vec3f planeNewPos = m_lastPickedObject->getPosition();
			float planeNewAxisScale; // Not used
			Geom::Vec3f planeNewNormal = m_lastPickedObject->getAxisScale(2, planeNewAxisScale); // 2 = Z axis = plane normal

			// Update clipping shape
			m_shader->setClipPlaneParamsAll(m_lastPickedObject->id(), planeNewNormal, planeNewPos);
		}
		else if (m_lastPickedObject->checkType<Utils::Sphere>())
		{
			// Get sphere position and size
			Geom::Vec3f sphereNewPos = m_lastPickedObject->getPosition();
			float sphereNewSize;
			m_lastPickedObject->getAxisScale(0, sphereNewSize); // On the sphere, every axis has the same size, so take 0 as default

			// Update clipping shape
			m_shader->setClipSphereParamsAll(m_lastPickedObject->id(), sphereNewPos, sphereNewSize);
		}
Maire Nicolas's avatar
Maire Nicolas committed
1089
1090
1091
1092
1093
1094
	}

	m_lastClickedX = x;
	m_lastClickedY = y;

	updateGL();
1095
1096
1097
1098
1099
1100
1101
1102
1103

}

/**********************************************************************************************
 *                  MAIN FUNCTION                         								      *
 **********************************************************************************************/

int main(int argc, char** argv)
{
1104
    QApplication app(argc, argv);
1105

1106
    Clipping sqt;
1107
1108
    sqt.setGeometry(0, 0, 1000, 800);
    sqt.show();
1109

1110
	if(argc == 2)
1111
    {
1112
1113
		std::string filename(argv[1]);
		sqt.importMesh(filename);
1114
1115
1116
    }
	else
	{
untereiner's avatar
untereiner committed
1117
1118
1119
1120
        sqt.position = sqt.myMap.addAttribute<PFP::VEC3, VERTEX>("position");

        Algo::Volume::Tilings::Cubic::Grid<PFP> cubic(sqt.myMap, 10,10,10);
        cubic.embedIntoGrid(sqt.position, 1.0f, 1.0f, 1.0f);
1121
1122
	}

1123
    sqt.initGUI();
1124

1125
    return app.exec();
1126
}