atomsGL.cpp 16.5 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
#include <math.h>

#include "eprintf.h"
#include "TessShaders.h"
#include "UnitCellShaders.h"
#include "atomsGL.h"
#include "atoms.hpp"
#include "ConfigFile.h"
#include "CompileGLShader.h"
#include "polyhedron.h"
11
#include "Grid.h"
12

13
14
15
16
17
18
19
20
int getAtomTimesteps() 
{
	if (fixedAtoms)
		return 1;
	else
		return TIMESTEPS;
}

21
22
23
24
GLenum atomTexture(GLuint t)
{
	GLenum e;
	//rgh: scale atoms here
25
26
27
28
29
30
31
32
	//in google cardboard, this is called again if the program is running, so leave original or atoms get progresivelly smaller!
	float *a=new float[118*4];
	for (int i = 0; i < 118; i++) {
		a[i*4+0]=atomColours[i][0];
		a[i*4+1]=atomColours[i][1];
		a[i*4+2]=atomColours[i][2];
		a[i*4+3]=atomColours[i][3] * atomScaling;
	}
33
34
35
36
37
	glBindTexture(GL_TEXTURE_2D, t); //atom texture
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
38
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 118, 1, 0, GL_RGBA, GL_FLOAT, a);
39
40
41
42
43

	glBindTexture( GL_TEXTURE_2D, 0 );
	if ((e = glGetError()) != GL_NO_ERROR) {
		eprintf( "opengl error %d, atomTexture\n", e);
	}
44
	delete [] a;
45
46
47
48
49
50
	return e;
}

//WARNING: This should be called after SetupAtoms
//This means that numAtoms now has the cummulative distribution!
//This should be called after the atom texture is prepared, and therefore has the atomscaling pre-multiplied
51
52
53
GLenum SetupAtomsNoTess (GLuint **AtomVAO /*[3]*/, GLuint **AtomVertBuffer/*[2]*/, GLuint **AtomIndexBuffer/*[3]*/)
	//atoms, cloned atoms
	//rgh: FIXME: add AtomVAO[2] for atom trajectories
54
55
56
57
58
{
	//eprintf ("SetupAtomsNoTess 1");
if (!numAtoms)
		return 0;

59
60
61
62
63
if (!solid) {
	eprintf ("SetupAtomsNoTess, error: no solid defined");
	return 0;
}

64
65
66
67
68
69
//eprintf ("SetupAtomsNoTess 2");
	//for now, render an icosahedron
	//http://prideout.net/blog/?p=48 //public domain code
	//xyz nxnynz u=atom type ; 7 floats
	int e;

70
	int totalatoms=numAtoms[getAtomTimesteps() -1];
71
72
	
//eprintf ("SetupAtomsNoTess 2");
73
	*AtomVAO = new GLuint[3]; //atoms, cloned atoms, unused (bonds use Tess atom positions)
74
75
	*AtomIndexBuffer= new GLuint[3];//atoms, cloned atoms, bonds
	*AtomVertBuffer = new GLuint[2];//atoms, cloned atoms
76

77
	glGenVertexArrays(3, *AtomVAO);
78
79
80
81
82
83
84
85
86
87
88
	glGenBuffers(2, *AtomIndexBuffer);
	glGenBuffers(2, *AtomVertBuffer);
//eprintf ("SetupAtomsNoTess 3");
	glBindVertexArray((*AtomVAO)[0]);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, (*AtomIndexBuffer)[0]);
	glBindBuffer(GL_ARRAY_BUFFER, (*AtomVertBuffer)[0]);
//eprintf ("SetupAtomsNoTess 4");
	glEnableVertexAttribArray(0);
	glEnableVertexAttribArray(1);
	glEnableVertexAttribArray(2);
	glDisableVertexAttribArray(3);
89
90
	//eprintf ("SetupAtomsNoTess 5, totalatoms=%d, nVerts=%d", totalatoms, solid->nVerts);
	float *tmp = new float[solid->nVerts * 7 * totalatoms];
91
92
	//eprintf ("SetupAtomsNoTess 6");
#ifdef INDICESGL32		
93
	int *tmpi = new int[solid->nFaces*3 * totalatoms];
94
95
96
	//eprintf ("SetupAtomsNoTess 7");
	int *currenti=tmpi;
#else
97
	unsigned short *tmpi = new unsigned short[solid->nFaces*3 * totalatoms];
98
99
100
101
102
103
	//eprintf ("SetupAtomsNoTess 7B");
	unsigned short *currenti=tmpi;
#endif

	float *current=tmp;
	//eprintf ("Before For 1");
104
	for (int p=0;p<getAtomTimesteps() ;p++) {
105
106
		for (int a = 0; a < numAtoms[p]-(p==0?0:numAtoms[p-1]); a++) {
			const int atomNumber = static_cast<int>(atoms[p][4 * a + 3]);
107
			const float radius = atomRadius(atomNumber)*atomScaling;
108
			for (int i = 0; i < solid->nVerts; i++) { //verts
109
				for (int k = 0; k < 3; k++) {
110
					*current++ = solid->Verts[3 * i + k]* radius +atoms[p][4 * a + k]; //pos
111
112
				}
				for (int k = 0; k < 3; k++) {
113
					*current++ = solid->Verts[3 * i + k]; //normal
114
				}
115
				*current++ = static_cast<float>(atomNumber);
116
			} //i
117
118
			for (int i = 0; i < solid->nFaces * 3; i++)
				*currenti++ = solid->Faces[i] + (a+(p==0?0:numAtoms[p-1]))*solid->nVerts;
119
120
		} //a
	} //p
121
		glBufferData(GL_ARRAY_BUFFER, sizeof(float) *totalatoms* 7 * solid->nVerts, tmp,
122
123
124
125
126
127
128
129
130
131
			GL_STATIC_DRAW);
		if ((e = glGetError()) != GL_NO_ERROR)
			eprintf("opengl error %d, glBufferData, l %d\n", e, __LINE__);

		glBufferData(GL_ELEMENT_ARRAY_BUFFER, 
#ifdef INDICESGL32		
	sizeof(int)
#else
	sizeof(unsigned int)
#endif
132
		* totalatoms * 3 * solid->nFaces, tmpi, GL_STATIC_DRAW);
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149


	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 7*sizeof(float), (const void *)0);
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 7 * sizeof(float), (const void *)(3*sizeof(float)));
	glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, 7 * sizeof(float), (const void *)(6 * sizeof(float)));

	if (glGetError() != GL_NO_ERROR)
		eprintf("opengl error attrib pointer 0\n");

	//glBindVertexArray(0);
	//glDisableVertexAttribArray(0);
	delete[] tmp;
	delete[] tmpi;
	if ((e = glGetError()) != GL_NO_ERROR)
		eprintf("opengl error %d, end of SetupAtoms, l %d\n", e, __LINE__);

	//FIXME TODO: cloned atoms
150
	tmp = new float[solid->nVerts * 7 * numClonedAtoms];
151
152
153
	current=tmp;
	//eprintf ("SetupAtomsNoTess 6");
#ifdef INDICESGL32		
154
	tmpi = new int[solid->nFaces*3 * numClonedAtoms];
155
156
157
	//eprintf ("SetupAtomsNoTess 7");
	currenti=tmpi;
#else
158
	tmpi = new unsigned short[solid->nFaces*3 * numClonedAtoms];
159
160
161
162
163
164
165
	//eprintf ("SetupAtomsNoTess 7B");
	currenti=tmpi;
#endif
	//eprintf ("Before For 2");

	for (int a = 0; a < numClonedAtoms; a++) {
		const int atomNumber = static_cast<int>(clonedAtoms[0][4 * a + 3]);
166
		const float radius = atomRadius(atomNumber)*atomScaling;
167
		for (int i = 0; i < solid->nVerts; i++) { //verts
168
				for (int k = 0; k < 3; k++) {
169
					*current++ = solid->Verts[3 * i + k]* radius +clonedAtoms[0][4 * a + k]; //pos
170
171
				}
				for (int k = 0; k < 3; k++) {
172
					*current++ = solid->Verts[3 * i + k]; //normal
173
				}
174
				*current++ =  static_cast<float>(atomNumber);
175
		} //i
176
177
		for (int i = 0; i < solid->nFaces * 3; i++)
			*currenti++ = solid->Faces[i] + a*solid->nVerts;
178
179
180
181
182
183
184
185
186
187
188
189
190
191
	} //a
	
	//eprintf ("After For 2");


	glBindVertexArray((*AtomVAO)[1]);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, (*AtomIndexBuffer)[1]);
	glBindBuffer(GL_ARRAY_BUFFER, (*AtomVertBuffer)[1]);

	glEnableVertexAttribArray(0);
	glEnableVertexAttribArray(1);
	glEnableVertexAttribArray(2);
	glDisableVertexAttribArray(3);

192
	glBufferData(GL_ARRAY_BUFFER, sizeof(float) *numClonedAtoms* 7 * solid->nVerts, tmp,
193
194
195
196
197
198
199
200
201
202
			GL_STATIC_DRAW);
		if ((e = glGetError()) != GL_NO_ERROR)
			eprintf("opengl error %d, glBufferData, l %d\n", e, __LINE__);
	//eprintf ("After bufferdata, array buffer");
		glBufferData(GL_ELEMENT_ARRAY_BUFFER, 
#ifdef INDICESGL32		
	sizeof(int)
#else
	sizeof(unsigned int)
#endif
203
		* numClonedAtoms * 3 * solid->nFaces, tmpi, GL_STATIC_DRAW);
204
205
206
207
208
209
210
211
212
213
	//eprintf ("After bufferdata, element array buffer");
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 7*sizeof(float), (const void *)0);
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 7 * sizeof(float), (const void *)(3*sizeof(float)));
	glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, 7 * sizeof(float), (const void *)(6 * sizeof(float)));

	if ((e = glGetError()) != GL_NO_ERROR)
		eprintf("opengl error %d, glVertexAttribPointer, l %d\n", e, __LINE__);

	delete[] tmp;
	delete[] tmpi;
214

215
	glBindVertexArray(0);
216
217
218
219
	return e;
} //SetupAtomsNoTess


220
GLenum SetupAtoms(GLuint **AtomVAO /*[3]*/, GLuint **AtomVertBuffer /*[2]*/, GLuint *BondIndices)
221
222
{
	if (!numAtoms)
223
		return glGetError();
224
225
226
227
228
229
230
	//rgh FIXME: put this all in the same vao
	
	//http://prideout.net/blog/?p=48 //public domain code
	//xyz u=atom type ; 4 floats
	int e;

	int totalatoms=0;
231
	for (int i=0;i<getAtomTimesteps() ;i++) {
232
233
234
235
		totalatoms += numAtoms[i];
	}
	eprintf("SetupAtoms: totalatoms=%d", totalatoms);

236
	*AtomVAO = new GLuint[3]; //atoms, cloned atoms, bonds
237
	*AtomVertBuffer = new GLuint[2];
238
239

	glGenVertexArrays(3, *AtomVAO);
240
	glGenBuffers(2, *AtomVertBuffer);
241
	glGenBuffers(1, BondIndices);
242
243
244
245
246
247
248
249

	glBindVertexArray((*AtomVAO)[0]);
	glBindBuffer(GL_ARRAY_BUFFER, (*AtomVertBuffer)[0]);

	glEnableVertexAttribArray(0);
	glEnableVertexAttribArray(1);
	glDisableVertexAttribArray(2);
	glDisableVertexAttribArray(3);
250
251
252
253

	e=glGetError();
	if (e!=GL_NO_ERROR)
		eprintf ("gl error %d, %s %d", e, __FILE__, __LINE__);
254
255
	float *tmp = new float[4 * totalatoms];
	float *current=tmp;
256
257
258
	
	const int atomlimit=30;

259
260
	numBonds=new int[getAtomTimesteps() ];
	for (int p=0;p<getAtomTimesteps() ;p++) {
261

262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
			for (int a = 0; a < numAtoms[p]; a++) {
				for (int k = 0; k < 4; k++) {
					*current++ = atoms[p][4 * a + k];
				}
			} //a

		if (numAtoms[0]<atomlimit) {
		//eprintf ("searching bonds basic");
		//bonds FIXME quadractic complexity	
				for (int a1=0; a1 < numAtoms[p]; a1++) {
					for (int a2=a1+1; a2 < numAtoms[p]; a2++) {
						float d=0, r;
						for (int k=0;k<3;k++) {
							float dif=atoms[p][4 * a1 + k]-atoms[p][4 * a2 + k];
							d+=dif*dif;
						}
						r=atomRadius(static_cast<int>(atoms[p][4 * a1 + 3]))+
							atomRadius(static_cast<int>(atoms[p][4 * a2 + 3]));
						if (d*0.9f<r*r) {// bond
							bonds.push_back(a1+(p==0?0:numAtoms[p-1]));
							bonds.push_back(a2+(p==0?0:numAtoms[p-1]));
						}
					}
				}
		} else { //more than 30 atoms, try grid optimization
		//eprintf ("searching bonds grid");

			float m[3];
			float M[3];
			for (int k=0; k<3;k++) {
292
				m[k]=M[k]=atoms[p][k];
293
			}
294
295
			for (int a = 1; a < numAtoms[p]; a++) {
				for (int k=0; k<3;k++) {
296
297
298
299
					if (m[k]>atoms[p][4*a+k])
						m[k]=atoms[p][4*a+k];
					if (M[k]<atoms[p][4*a+k])
						M[k]=atoms[p][4*a+k];
300
301
302
303
				}
			}
			grid g(m, M, pow(numAtoms[p], 1.0/3), 0.9f);
			for (int a = 1; a < numAtoms[p]; a++) 
304
				g.add(atoms[p]+4*a);
305
			for (int a = 0; a < numAtoms[p]; a++) {
306
				std::vector<float*> found=g.find(atoms[p]+4*a);
307
308
309
310
				for (int b=0;b<found.size();b++) {
					//if (found[b] < tmp+4*a) // already got this bound
					//	continue;
					bonds.push_back(a+(p==0?0:numAtoms[p-1]));
311
					bonds.push_back(((found[b]-atoms[p])/4)+(p==0?0:numAtoms[p-1]));
312
313
314
315
				}
			}
		}
		numBonds[p]=bonds.size();
316
317
318
		if (p!=0)
			numAtoms[p]+=numAtoms[p-1];
	} //p
319

320
321
322
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (const void *)(0));
	glVertexAttribPointer(1, 1, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (const void *)(3 * sizeof(float)));
	glBufferData(GL_ARRAY_BUFFER, sizeof(float) * totalatoms * 4 , tmp,
323
324
325
		GL_STATIC_DRAW);
	if ((e = glGetError()) != GL_NO_ERROR)
		eprintf( "opengl error %d, glBufferData, l %d\n", e, __LINE__);
326

327
	glBindVertexArray(0);
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345

	if ((e = glGetError()) != GL_NO_ERROR)
		eprintf( "opengl error %d, end of SetupAtoms, l %d\n", e, __LINE__);

	if (showTrajectories) {
			//fill the restart buffer
		//use abc for measuring
		float max=0;
		if (has_abc) {
			for (int i=0;i<3;i++)
				for (int j=0;j<3;j++)
				max+=abc[i][j];
			max /=9*2;
		}

		for (unsigned int t=0;t<atomtrajectories.size();t++) {
			atomtrajectoryrestarts.push_back(std::vector<int>());
			atomtrajectoryrestarts[t].push_back(0);
346
			for (int p=1;p<getAtomTimesteps() ;p++) {
347
				int a=atomtrajectories[t];
348
349
350
351
352
				if (has_abc)
					if (fabs(atoms[p][a*4+0]-atoms[p-1][a*4+0])+
						fabs(atoms[p][a*4+1]-atoms[p-1][a*4+1])+
						fabs(atoms[p][a*4+2]-atoms[p-1][a*4+2])>max)
							atomtrajectoryrestarts[t].push_back(p);
353
			}
354
			atomtrajectoryrestarts[t].push_back(getAtomTimesteps() );
355
356
357
		}
	}
	delete[] tmp;
358
359
360
361
362
363
364
365
366
367
368
369
	//bonds
	glBindVertexArray((*AtomVAO)[2]);
	glBindBuffer(GL_ARRAY_BUFFER, (*AtomVertBuffer)[0]);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, *BondIndices);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(int)*bonds.size(), bonds.data(), GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (const void *)(0));
	glEnableVertexAttribArray(0);
	glBindVertexArray(0);

	e=glGetError();
	if ((e = glGetError()) != GL_NO_ERROR)
		eprintf( "opengl error %d, creating chemical bonds, l %d\n", e, __LINE__);
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389

	//now clones
	if (basisvectorreps ||!clonedAtoms) //do not replicate
		return e;


	glBindVertexArray((*AtomVAO)[1]); //rgh FIXME, only works for TIMESTEPS=1
	glBindBuffer(GL_ARRAY_BUFFER, (*AtomVertBuffer)[1]);
	glBufferData(GL_ARRAY_BUFFER, sizeof(float) * clonedAtoms[0].size(), clonedAtoms[0].data(),
			GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (const void *)(0));
	glVertexAttribPointer(1, 1, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (const void *)(3 * sizeof(float)));
	glEnableVertexAttribArray(0);
	glEnableVertexAttribArray(1);
	if ((e = glGetError()) != GL_NO_ERROR)
		eprintf( "opengl error %d, end of Setup cloned Atoms, l %d\n", e, __LINE__);

	//rgh: we will need these again if we don't have tesselation
	//delete[] clonedAtoms;
	//clonedAtoms=0;
390
	glBindVertexArray(0);
391
392
393
394
395
396
	return e;
}

GLenum SetupUnitCell(GLuint *UnitCellVAO, GLuint *UnitCellVertBuffer, GLuint *UnitCellIndexBuffer)
{
	GLenum e;
397
398
399
400
	if ((e = glGetError()) != GL_NO_ERROR)
		eprintf( "opengl error %d, begin of SetupUnitCell\n", e, __LINE__);
	if (!has_abc)
		return e;
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
	glGenVertexArrays(1, UnitCellVAO);
	glGenBuffers(1, UnitCellVertBuffer);
	glGenBuffers(1, UnitCellIndexBuffer);
	if ((e = glGetError()) != GL_NO_ERROR)
		eprintf( "opengl error %d, glGenBuffers, l %d\n", e, __LINE__);

	glBindVertexArray(*UnitCellVAO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, *UnitCellIndexBuffer);
	glBindBuffer(GL_ARRAY_BUFFER, *UnitCellVertBuffer);

	glEnableVertexAttribArray(0);
	glDisableVertexAttribArray(1);
	glDisableVertexAttribArray(2);
	glDisableVertexAttribArray(3);

	float *tmp = new float[3*8];
	//0, a, b, c, a+b+c, b+c, a+c, a+b
	for (int i=0;i<3;i++) {
		tmp[0+i]=0;
		for (int j=0;j<3;j++)
			tmp[3*(j+1)+i]=abc[j][i];
		tmp[3*4+i]=abc[0][i]+abc[1][i]+abc[2][i];
		tmp[3*5+i]=			abc[1][i]+abc[2][i];
		tmp[3*6+i]=abc[0][i]+		abc[2][i];
		tmp[3*7+i]=abc[0][i]+abc[1][i];
	}

	int tmpi[12*2]={ //lines
		0,1, 
		1,6,
		6,3,
		3,0,
		2,7,
		7,4,
		4,5,
		5,2,
		0,2,
		1,7,
		6,4,
		3,5
	};
	glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 3*8 , tmp,
			GL_STATIC_DRAW);
	if ((e = glGetError()) != GL_NO_ERROR)
445
		eprintf( "opengl error %d, glBufferData vertex, l %d\n", e, __LINE__);
446
447
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (const void *)(0));
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(tmpi), tmpi, GL_STATIC_DRAW);
448
449
	if ((e = glGetError()) != GL_NO_ERROR)
		eprintf( "opengl error %d, glBufferData index, l %d\n", e, __LINE__);
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
	return e;
}


bool PrepareUnitCellAtomShader (GLuint *AtomP, GLuint *cellP, GLint *AtomMatrixLocation, GLint *UnitCellMatrixLocation,  GLint *UnitCellColourLocation){
	if (!PrepareAtomShader(AtomP, AtomMatrixLocation))
		return false;

	if (!PrepareUnitCellShader(cellP, UnitCellMatrixLocation, UnitCellColourLocation))
		return false;

	return true;
}

bool PrepareAtomShader (GLuint *AtomP, GLint *AtomMatrixLocation){
		//https://www.gamedev.net/topic/591110-geometry-shader-point-sprites-to-spheres/
	//no rotation, only translations means we can do directional lighting in the shader.
	//FIXME
	//http://stackoverflow.com/questions/40101023/flat-shading-in-webgl
	*AtomP = CompileGLShader(
		AtomShaders[SHADERNAME],
		AtomShaders[SHADERVERTEX],
		AtomShaders[SHADERFRAGMENT],
		AtomShaders[SHADERTESSEVAL]
		);
	*AtomMatrixLocation=glGetUniformLocation(*AtomP, "matrix");
	if( *AtomMatrixLocation == -1 )
	{
		eprintf( "Unable to find matrix uniform in atom shader\n" );
		return false;
	}
	return true;
}

bool PrepareAtomShaderNoTess (GLuint *AtomP, GLint *AtomMatrixLocation){
		//https://www.gamedev.net/topic/591110-geometry-shader-point-sprites-to-spheres/
	//no rotation, only translations means we can do directional lighting in the shader.
	//FIXME
	//http://stackoverflow.com/questions/40101023/flat-shading-in-webgl
	*AtomP = CompileGLShader(
		AtomShadersNoTess[SHADERNAME],
		AtomShadersNoTess[SHADERVERTEX],
		AtomShadersNoTess[SHADERFRAGMENT],
		AtomShadersNoTess[SHADERTESSEVAL]
		);
	*AtomMatrixLocation=glGetUniformLocation(*AtomP, "matrix");
	if( *AtomMatrixLocation == -1 )
	{
		eprintf( "Unable to find matrix uniform in atom shader no tess\n" );
		return false;
	}
	return true;
}


bool PrepareUnitCellShader (GLuint *cellP, GLint *UnitCellMatrixLocation,  GLint *UnitCellColourLocation){
	*cellP= CompileGLShader(
		UnitCellShaders[SHADERNAME],
		UnitCellShaders[SHADERVERTEX],
		UnitCellShaders[SHADERFRAGMENT],
		UnitCellShaders[SHADERTESSEVAL]
		);
	*UnitCellMatrixLocation=glGetUniformLocation(*cellP, "matrix");
	if( *UnitCellMatrixLocation == -1 )
	{
		eprintf( "Unable to find matrix uniform in UnitCell shader\n" );
		return false;
	}
	*UnitCellColourLocation=glGetUniformLocation(*cellP, "color");
	if( *UnitCellColourLocation == -1 )
	{
		eprintf( "Unable to find color uniform in UnitCell shader\n" );
		return false;
	}
	return true;
}


/**p: input, f: output*/
void GetDisplacement(int p[3], float f[3])
{
float delta[3][3];
for (int ss=0;ss<3;ss++)
	for (int i=0;i<3;i++)
		delta[ss][i]=static_cast<float>(p[ss])*abc[ss][i];

for (int i=0;i<3;i++)
	f[i]=0;

for (int ss=0;ss<3;ss++)
	for (int i=0;i<3;i++)
		f[i]+=delta[ss][i];
542
}