Add support for markers and supercells (to support excitons for the Long

Night of Science in Berlin at the end of June 2017)
The initial user position is no longer scaled by 0.04

NOMADVRLib/ConfigFile.cpp

@@ -15,6 +15,8 @@ float **isocolours; // [ISOS][4];
 const char **plyfiles;
 float **translations;
 float userpos[3];
+float scaling;
+float markerscaling;
 
 float BACKGROUND[3];
 int* numAtoms; //[timesteps]
@@ -25,6 +27,7 @@ float atomScaling;
 std::vector<float> *clonedAtoms;
 std::vector<int> bonds;
 int *numBonds;
+bool displaybonds;
 int numClonedAtoms;
 int *basisvectorreps;
 
@@ -34,10 +37,17 @@ std::vector<std::vector<int>> atomtrajectoryrestarts;
 
 float abc[3][3]; //basis vectors
 bool has_abc = false;
+bool displayunitcell;
+float supercell[3];
+int voxelSize[3];
 
 int repetitions[3];
 Solid *solid;
 
+//markers such as hole positions and electron positions
+float ** markers;
+float ** markercolours;
+float cubetrans[3];
 const char * loadConfigFileErrors[] =
 {
 	"All Ok",//0
@@ -57,6 +67,8 @@ const char * loadConfigFileErrors[] =
 	"Error loading config file",// -14
 	"Error reading atomglyph", //-15
 	"Error reading token", //-16
+	"markers with no previous correct timesteps parameter", //-17
+	"markercolours with no previous correct timesteps parameter", //-18
 	"Error loading xyz file, add 100 to see the error",//<-100
 	"Error loading cube file, add 100 to see the error",//<-200
 	"Error loading json file, add 200 to see the error",//<-300
@@ -133,6 +145,7 @@ int loadConfigFile(const char * f)
 	clonedAtoms=0;
 	fixedAtoms=false;
 	bonds.clear();
+	displaybonds=false;
 	showTrajectories = false;
 	basisvectorreps=0;
 	numClonedAtoms=0;
@@ -141,8 +154,20 @@ int loadConfigFile(const char * f)
 		repetitions[i]=1;
 	for (int i=0;i<3;i++)
 		userpos[i] = 0;
+	for (int i=0;i<3;i++)
+		supercell[i] = 1;
 	solid=0;
 	char *token=0;
+	markers=nullptr;
+	markercolours=nullptr;
+	displayunitcell=false;
+	scaling =1;
+	markerscaling=0.8;
+	for (int i=0;i<3;i++)
+		cubetrans[i]=0;
+	translations=nullptr;
+	for (int i=0;i<3;i++)
+		voxelSize[i]=-1;
 	//
 	FILE *F = fopen(f, "r");
 	if (F == 0)
@@ -279,6 +304,9 @@ int loadConfigFile(const char * f)
 		else if (!strcmp(s, "atomscaling")) {
 			r = fscanf(F, "%f", &atomScaling);
 		}
+		else if (!strcmp(s, "scaling")) {
+			r = fscanf(F, "%f", &scaling);
+		}
 		else if (!strcmp(s, "abc")) {
 			for (int i=0;i<3;i++)
 				for (int j=0;j<3;j++) {
@@ -365,6 +393,58 @@ int loadConfigFile(const char * f)
 				return -16;
 		} else if (!strcmp (s, "fixedatoms")) {
 			fixedAtoms=true;
+		} else if (!strcmp (s, "markers")) {
+			if (TIMESTEPS == 0) {
+				eprintf( "markers with no previous correct timesteps parameter\n");
+				fclose(F);
+				return -17;
+			}
+			markers=new float* [TIMESTEPS];
+			for (int i=0;i<TIMESTEPS;i++) {
+				markers[i]=new float[3];
+				//in abc coordinates if they exist
+				float tmp[3];
+				for (int j = 0; j < 3; j++) {
+					r = fscanf(F, "%f", &(tmp[j]));
+				}
+				if (has_abc) {
+					//for (int s=0;s<3;s++) 
+					//	tmp[s]-=translations[0][s]; //using translation of iso 0
+					//check if coordinates are outside of cell
+					for (int s=0;s<3;s++) {
+						while (tmp[s]<-translations[0][s])
+							tmp[s]+=supercell[2-s];
+					}
+					for (int s=0;s<3;s++) {
+						markers[i][s]=tmp[2]*abc[0][s]+tmp[1]*abc[1][s]+tmp[0]*abc[2][s]; //hole positions seem to be in zyx
+					}
+				}
+				else
+					for (int s=0;s<3;s++)
+						markers[i][s]=tmp[s];
+
+			}
+		} else if (!strcmp (s, "markercolours")) {
+		if (TIMESTEPS == 0) {
+			eprintf( "markecolours with no previous correct timesteps parameter\n");
+			fclose(F);
+			return -18;
+		}
+		markercolours=new float* [TIMESTEPS];
+		for (int i=0;i<TIMESTEPS;i++) {
+			markercolours[i]=new float[4];
+			for (int j = 0; j < 4; j++) {
+				r = fscanf(F, "%f", &(markercolours[i][j]));
+			}
+		}
+		} else if (!strcmp (s, "displaybonds")) {
+			displaybonds=true;
+		} else if (!strcmp (s, "markerscaling")) {
+			r = fscanf(F, "%f", &markerscaling);
+		} else if (!strcmp (s, "displayunitcell")) {
+			displayunitcell=true;
+		} else if (!strcmp (s, "supercell")) {
+			r=fscanf (F, "%f %f %f", supercell, supercell+1, supercell+2);
 		} else if (!strcmp (s, "\x0d")) { //discard windows newline (problem in Sebastian Kokott's phone (?!)
 			continue;
 		} else {
@@ -379,10 +459,10 @@ int loadConfigFile(const char * f)
 //verification and additional processing
 	fclose(F);
 
-	if (ISOS == 0 && numAtoms==0) {
+	/*if (ISOS == 0 && numAtoms==0) {
 		eprintf( "Missing isos and atomfile parameter\n");
 		return -6;
-	} 
+	} */
 	if (ISOS !=0 && plyfiles[0] == 0) {
 		eprintf( "Missing values parameter\n");
 		fclose(F);

NOMADVRLib/ConfigFile.h

@@ -11,6 +11,7 @@ extern float **isocolours; // [ISOS][4];
 extern const char **plyfiles;
 extern float **translations;
 extern float userpos[3];
+extern float scaling;
 
 extern float BACKGROUND[3];
 extern int* numAtoms; //[timesteps]
@@ -20,6 +21,7 @@ extern float atomScaling;
 extern std::vector<float> *clonedAtoms;
 extern std::vector<int> bonds;
 extern int *numBonds;
+extern bool displaybonds;
 extern int numClonedAtoms;
 extern int *basisvectorreps;
 
@@ -29,11 +31,20 @@ extern std::vector<std::vector<int>> atomtrajectoryrestarts;
 
 extern float abc[3][3]; //basis vectors
 extern bool has_abc;
+extern bool displayunitcell;
+extern float supercell[3];
+extern float markerscaling;
 
 extern int repetitions[3];
 
 extern Solid *solid;
 
+//markers such as hole positions and electron positions
+extern float ** markers;
+extern float ** markercolours;
+extern float cubetrans[3];
+extern int voxelSize[3];
+
 extern const char * loadConfigFileErrors[];
 
 int loadConfigFile(const char * f);

NOMADVRLib/IsosurfacesGL.cpp

@@ -207,14 +207,15 @@ GLenum PrepareGLiso (GLuint vao, GLuint vertbuffer, const std::vector<float> &ve
 
 		// populate the index buffer
 	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indbuffer);
-	glBufferData(GL_ELEMENT_ARRAY_BUFFER, 
-#ifndef INDICESGL32
-		sizeof(uint16_t)
-#else
-		sizeof(GLuint)
-#endif
-		* vertindices.size(),
-		&vertindices[0], GL_STATIC_DRAW);
+	if (vertindices.size() !=0)
+		glBufferData(GL_ELEMENT_ARRAY_BUFFER, 
+	#ifndef INDICESGL32
+			sizeof(uint16_t)
+	#else
+			sizeof(GLuint)
+	#endif
+			* vertindices.size(),
+			&vertindices[0], GL_STATIC_DRAW);
 
 	if ((e=glGetError()) != GL_NO_ERROR)
 		eprintf("opengl error\n");

NOMADVRLib/TessShaders.cpp

@@ -48,7 +48,9 @@ const char * const AtomShaders [] = {
 	"lowp float a=abs(dot(nn, vec3(0,sqrt(2.0)/2.0,sqrt(2.0)/2.0)));\n"
 	"lowp float b=max(0.0, dot(nn, vec3(0,0,1)));\n"
 	"highp vec4 res=color;\n"
-	"	outputColor = vec4 ((res.rgb) * (0.1 + 0.2*a), color.a);\n"
+//rgh FIXME: make this depend on the background colour. Otherwise looks almost black with white background
+//version for white background:
+	"	outputColor = vec4 ((res.rgb) * (0.4 + 0.3*a + 0.3*b), color.a);\n"
 	"}\n",
 
 	//tess eval
@@ -67,8 +69,8 @@ const char * const AtomShaders [] = {
 	"out vec4 color;\n" //color 
 	"out vec3 normal;\n"
 //	"out vec3 vertex;"
-	"uniform mat4 Projection;\n"
-	"uniform mat4 Modelview;\n"
+//	"uniform mat4 Projection;\n"
+//	"uniform mat4 Modelview;\n"
 
 	"void main()\n"
 	"{\n"

NOMADVRLib/atoms.cpp

@@ -266,9 +266,9 @@ const char * readAtomsCubeErrors [] ={
 //rgh FIXME, untested code
 int readAtomsCube(const char *const file, int **numatoms, int *timesteps, float ***pos)
 {
-	float isoTrans[3];
-	int voxelSize[3];
-	float abc[9];
+	//float isoTrans[3];
+	//float abc[9];
+	has_abc=true;
 	FILE *f = fopen(file, "r");
 	int r;
 	if (f == 0) {
@@ -286,34 +286,56 @@ int readAtomsCube(const char *const file, int **numatoms, int *timesteps, float
 
 	discardline(f); //two comments
 	discardline(f);
-	r = fscanf(f, "%d %f %f %f", *numatoms, isoTrans + 0, isoTrans + 1, isoTrans + 2);
+	r = fscanf(f, "%d %f %f %f", *numatoms, cubetrans + 0, cubetrans + 1, cubetrans + 2);
 	if (r < 4)
 		return -2;
 
+	//rgh FIXME. Is this always bohr?
+	for (int i=0;i<3;i++)
+		cubetrans[i]*= 0.52918f;
+
 	**pos = new float[4 * **numatoms];
+	bool bohr=true;
 
+	// dnabok <dnabok@physik.hu-berlin.de>  2/6/2017, 3:36 PM: vectors are c, b, a
 	for (int i = 0; i < 3; i++) {
-		r = fscanf(f, "%d %f %f %f", voxelSize+i, abc + 0 + 3 * i, abc + 1 + 3 * i, abc + 2 + 3 * i);
+		r = fscanf(f, "%d %f %f %f", voxelSize+(i), &(abc[i][0]), &(abc[i][1]), &(abc[i][2]));
 		if (r < 4)
 			return -3;
 		//positive then the units are Bohr, if negative then Angstroms.
-		if (voxelSize[i] < 0)
+		if (voxelSize[i] < 0) { //angstrom, no change
 			voxelSize[i] = -voxelSize[i];
-		else {
+			bohr=false;
+		} else { //bohr
 			for (int j = 0; j < 3; j++)
-				abc[j + 3 * i] *= 0.52918f;
+				abc[i][j] *= 0.52918f;
 		}
 	}
 
 	for (int i = 0; i < **numatoms; i++) {
 		int a;
-		float unused;
-		r = fscanf(f, "%d %f %f %f %f", &a, &unused, &((**pos)[4 * i + 0]), &((**pos)[4 * i + 1]), &((**pos)[4 * i + 2]));
+		float tmp[3];
+		float charge;
+		r = fscanf(f, "%d %f %f %f %f", &a, &charge, tmp, tmp+1, tmp+2);
 		if (r < 5)
 			return -4;
+
+		//atoms are not in abc coordinates, but in bohr (I suppose that also ansgrom if voxelsize < 0)
+		if (bohr)
+			for (int s=0;s<3;s++)
+				(**pos)[4*i+s]=tmp[s]*0.52918f;
+		else 
+			for (int s=0;s<3;s++)
+				(**pos)[4*i+s]=tmp[s];
+
 		(**pos)[4 * i + 3] = float(a - 1);
 	}
 
+
+	for (int i=0;i<3;i++)
+		for (int j=0;j<3;j++)
+			abc[i][j]*=(voxelSize[i]-1)/supercell[i]; 
+
 //rgh FIXME, discard the volumetric data for now
 
 	fclose(f);

NOMADVRLib/atomsGL.cpp

@@ -3,6 +3,7 @@
 #include "eprintf.h"
 #include "TessShaders.h"
 #include "UnitCellShaders.h"
+#include "markerShaders.h"
 #include "atomsGL.h"
 #include "atoms.hpp"
 #include "ConfigFile.h"
@@ -233,7 +234,7 @@ GLenum SetupAtoms(GLuint **AtomVAO /*[3]*/, GLuint **AtomVertBuffer /*[2]*/, GLu
 	}
 	eprintf("SetupAtoms: totalatoms=%d", totalatoms);
 
-	*AtomVAO = new GLuint[3]; //atoms, cloned atoms, bonds
+	*AtomVAO = new GLuint[3]; //atoms, cloned atoms, bonds //rgh fixme: for trajectories, we want to create another vao 
 	*AtomVertBuffer = new GLuint[2];
 
 	glGenVertexArrays(3, *AtomVAO);
@@ -391,8 +392,50 @@ GLenum SetupAtoms(GLuint **AtomVAO /*[3]*/, GLuint **AtomVertBuffer /*[2]*/, GLu
 	return e;
 }
 
+GLenum SetupMarker(GLuint *MarkerVAO, GLuint *MarkerVertBuffer)
+{
+	if (!markers)
+		return glGetError();
+	GLenum e;
+	if ((e = glGetError()) != GL_NO_ERROR)
+		eprintf( "opengl error %d, begin of SetupMarker\n", e, __LINE__);
+
+	glGenVertexArrays(1, MarkerVAO);
+	glGenBuffers(1, MarkerVertBuffer);
+	if ((e = glGetError()) != GL_NO_ERROR)
+		eprintf( "opengl error %d, glGenBuffers, l %d\n", e, __LINE__);
+
+	glBindVertexArray(*MarkerVAO);
+	glBindBuffer(GL_ARRAY_BUFFER, *MarkerVertBuffer);
+
+	glEnableVertexAttribArray(0);
+	glEnableVertexAttribArray(1);
+	glDisableVertexAttribArray(2);
+	glDisableVertexAttribArray(3);
+
+	const float size=atomRadius(0)*atomScaling*markerscaling;
+	float *tmp = new float [8*TIMESTEPS];
+	for (int i=0;i<TIMESTEPS;i++) {
+		for (int j=0;j<3;j++) { //center [3]
+			tmp[i*8+j]=markers[i][j];
+		}
+		tmp[i*8+3]=0.8*size; //size [1]
+		for (int j=0;j<4;j++) {//colour[4]
+			tmp[i*8+4+j]=markercolours[i][j];
+		}
+	}
+	
+	glBufferData(GL_ARRAY_BUFFER, sizeof(float) * TIMESTEPS*8 , tmp,
+			GL_STATIC_DRAW);
+	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (const void *)(0));
+	glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (const void *)(4*sizeof(float)));
+	glBindVertexArray(0);
+	return glGetError();
+}
+
 GLenum SetupUnitCell(GLuint *UnitCellVAO, GLuint *UnitCellVertBuffer, GLuint *UnitCellIndexBuffer)
 {
+	//add here both unit cell and supercell
 	GLenum e;
 	if ((e = glGetError()) != GL_NO_ERROR)
 		eprintf( "opengl error %d, begin of SetupUnitCell\n", e, __LINE__);
@@ -413,9 +456,9 @@ GLenum SetupUnitCell(GLuint *UnitCellVAO, GLuint *UnitCellVertBuffer, GLuint *Un
 	glDisableVertexAttribArray(2);
 	glDisableVertexAttribArray(3);
 
-	float *tmp = new float[3*8];
+	float *tmp = new float[3*8*2];
 	//0, a, b, c, a+b+c, b+c, a+c, a+b
-	for (int i=0;i<3;i++) {
+	for (int i=0;i<3;i++) { //unit cell
 		tmp[0+i]=0;
 		for (int j=0;j<3;j++)
 			tmp[3*(j+1)+i]=abc[j][i];
@@ -424,8 +467,21 @@ GLenum SetupUnitCell(GLuint *UnitCellVAO, GLuint *UnitCellVertBuffer, GLuint *Un
 		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
+	float displ[3]={0,0,0};
+	if (translations && ISOS) 
+		for (int j=0;j<3;j++)
+			for (int i=0;i<3;i++)
+				displ[i]+=-translations[0][i]*abc[j][i];
+	for (int i=0;i<3;i++) { //rgh fixme, add displacement here as well
+		tmp[3*8+i]=displ[i];
+		for (int j=0;j<3;j++)
+			tmp[3*(j+8+1)+i]=abc[j][i]*supercell[j]+displ[i];
+		tmp[3*12+i]=abc[0][i]*supercell[0]+abc[1][i]*supercell[1]+abc[2][i]*supercell[2]+displ[i];
+		tmp[3*13+i]=			abc[1][i]*supercell[1]+abc[2][i]*supercell[2]+displ[i];
+		tmp[3*14+i]=abc[0][i]*supercell[0]+		abc[2][i]*supercell[2]+displ[i];
+		tmp[3*15+i]=abc[0][i]*supercell[0]+abc[1][i]*supercell[1]+displ[i];
+	}
+	int tmpi[12*2*2]={ //lines, unit cell, 
 		0,1, 
 		1,6,
 		6,3,
@@ -437,9 +493,21 @@ GLenum SetupUnitCell(GLuint *UnitCellVAO, GLuint *UnitCellVertBuffer, GLuint *Un
 		0,2,
 		1,7,
 		6,4,
-		3,5
+		3,5, // supercell
+		0+8,1+8, 
+		1+8,6+8,
+		6+8,3+8,
+		3+8,0+8,
+		2+8,7+8,
+		7+8,4+8,
+		4+8,5+8,
+		5+8,2+8,
+		0+8,2+8,
+		1+8,7+8,
+		6+8,4+8,
+		3+8,5+8
 	};
-	glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 3*8 , tmp,
+	glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 3*8*2 , tmp,
 			GL_STATIC_DRAW);
 	if ((e = glGetError()) != GL_NO_ERROR)
 		eprintf( "opengl error %d, glBufferData vertex, l %d\n", e, __LINE__);
@@ -447,17 +515,23 @@ GLenum SetupUnitCell(GLuint *UnitCellVAO, GLuint *UnitCellVertBuffer, GLuint *Un
 	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(tmpi), tmpi, GL_STATIC_DRAW);
 	if ((e = glGetError()) != GL_NO_ERROR)
 		eprintf( "opengl error %d, glBufferData index, l %d\n", e, __LINE__);
+	glBindVertexArray(0);
 	return e;
 }
 
 
-bool PrepareUnitCellAtomShader (GLuint *AtomP, GLuint *cellP, GLint *AtomMatrixLocation, GLint *UnitCellMatrixLocation,  GLint *UnitCellColourLocation){
+bool PrepareUnitCellAtomShader (GLuint *AtomP, GLuint *cellP, GLuint *MarkerP, 
+								GLint *AtomMatrixLocation, GLint *UnitCellMatrixLocation,  GLint *UnitCellColourLocation,
+								GLint *MarkerMatrixLocation){
 	if (!PrepareAtomShader(AtomP, AtomMatrixLocation))
 		return false;
 
 	if (!PrepareUnitCellShader(cellP, UnitCellMatrixLocation, UnitCellColourLocation))
 		return false;
 
+	if (!PrepareMarkerShader(MarkerP, MarkerMatrixLocation))
+		return false;
+
 	return true;
 }
 
@@ -481,6 +555,26 @@ bool PrepareAtomShader (GLuint *AtomP, GLint *AtomMatrixLocation){
 	return true;
 }
 
+bool PrepareMarkerShader (GLuint *MP, GLint *MMatrixLocation){
+		//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
+	*MP = CompileGLShader(
+		MarkerShaders[SHADERNAME],
+		MarkerShaders[SHADERVERTEX],
+		MarkerShaders[SHADERFRAGMENT],
+		MarkerShaders[SHADERTESSEVAL]
+		);
+	*MMatrixLocation=glGetUniformLocation(*MP, "matrix");
+	if( *MMatrixLocation == -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.

NOMADVRLib/atomsGL.h

@@ -7,11 +7,15 @@ GLenum atomTexture(GLuint t);
 GLenum SetupAtoms(GLuint **AtomVAO, GLuint **AtomVertBuffer, GLuint *BondIndices);
 GLenum SetupAtomsNoTess (GLuint **AtomVAO, GLuint **AtomVertBuffer, GLuint **AtomIndexBuffer);
 GLenum SetupUnitCell(GLuint *UnitCellVAO, GLuint *UnitCellVertBuffer, GLuint *UnitCellIndexBuffer);
+GLenum SetupMarker(GLuint *MarkerVAO, GLuint *MarkerVertBuffer);
 
-bool PrepareUnitCellAtomShader (GLuint *AtomP, GLuint *cellP, GLint *AtomMatrixLocation, GLint *UnitCellMatrixLocation,  GLint *UnitCellColourLocation);
+bool PrepareUnitCellAtomShader (GLuint *AtomP, GLuint *cellP, GLuint *MarkerP, 
+								GLint *AtomMatrixLocation, GLint *UnitCellMatrixLocation,  GLint *UnitCellColourLocation,
+								GLint *MarkerMatrixLocation);
 bool PrepareAtomShader (GLuint *AtomP, GLint *AtomMatrixLocation);
 bool PrepareAtomShaderNoTess (GLuint *AtomP, GLint *AtomMatrixLocation);
 bool PrepareUnitCellShader (GLuint *cellP, GLint *UnitCellMatrixLocation,  GLint *UnitCellColourLocation);
+bool PrepareMarkerShader (GLuint *MP, GLint *MMatrixLocation);
 
 void GetDisplacement(int p[3], float f[3]);
 

NOMADVRLib/markerShaders.cpp

+#include "markerShaders.h"
+
+const char * const MarkerShaders [] = {
+	"Marker Renderer",
+
+// vertex shader
+//Android 21 gives error: only supports up to '310 es'
+#if defined(WIN32) || defined(CAVE)
+	"#version 410\n"
+#else
+"#version 300 es\n"
+#endif
+	"layout(location = 0) in vec4 centersize;\n"
+	"layout(location = 1) in vec4 colour;\n"
+	"out vec4 vcolor;\n" //color
+	"out vec3 vcen;"
+	"out vec3 vrad;" // ellipsoid
+	"void main()\n"
+	"{\n"
+	//"gl_Position = matrix * vec4(position+center, 1);\n"
+	"vcolor=colour;\n"
+	"vcen=centersize.xyz;\n"
+	"vec3 sc=vec3(0.5, 0.5, 0.5);\n"
+	"if (gl_InstanceID==0)\n"
+		"sc.x=2;\n"
+	"else if (gl_InstanceID==1)\n"
+		"sc.y=2;\n"
+	"else if (gl_InstanceID==2)\n"
+		"sc.z=2;\n"
+
+	"vrad=centersize.aaa*sc;\n"
+	"}\n",
+
+	//fragment shader
+#if defined(WIN32) || defined(CAVE)
+	"#version 410 core\n"
+#else
+"#version 300 es\n"
+#endif
+	"in lowp vec4 color;\n"
+	"in highp vec3 normal;"
+	"out lowp vec4 outputColor;\n"
+	"void main()\n"
+	"{\n"
+	"highp vec3 nn = normalize(normal);"
+	"lowp float a=abs(dot(nn, vec3(0,sqrt(2.0)/2.0,sqrt(2.0)/2.0)));\n"
+	"lowp float b=max(0.0, dot(nn, vec3(0,0,1)));\n"
+	"highp vec4 res=color;\n"
+	"	outputColor = vec4 ((res.rgb) * (0.4 + 0.3*a + 0.3*b), color.a);\n"
+	"}\n",
+
+		//tess eval
+#if defined(WIN32) || defined(CAVE)
+	"#version 400\n"
+#else
+"#version 320 es\n"
+#endif
+	//"layout(triangles, equal_spacing, cw) in;\n"
+	"layout(quads, equal_spacing, cw) in;\n"
+	"#define pi 3.1415926535897932384626433832795\n"
+	"uniform mat4 matrix;\n"
+	//"uniform mat4 mv;\n"
+	"in vec4 vcolor[];\n" //color
+	"in vec3 vcen[];"
+	"in vec3 vrad[];" // ellipsoid
+	"out vec4 color;\n" //color 
+	"out vec3 normal;\n"
+	"void main()\n"
+	"{\n"
+	"normal=vec3(sin(gl_TessCoord.x*2*pi)*cos((gl_TessCoord.y-0.5)*pi), "
+	"cos(gl_TessCoord.x*2*pi)*cos((gl_TessCoord.y-0.5)*pi), "
+	"sin((gl_TessCoord.y-0.5)*pi));"
+	"vec3	vertex = normal * vrad[0]  + vcen[0];\n"
+	"color=vcolor[0];"
+	"gl_Position = matrix * vec4(vertex, 1);\n"
+"}\n"
+
+};
\ No newline at end of file

NOMADVRLib/markerShaders.h

+extern const char * const MarkerShaders [];
\ No newline at end of file

OpenVR/TimestepData/hellovr_opengl.vcxproj

@@ -49,7 +49,7 @@
     <UseDebugLibraries>false</UseDebugLibraries>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v110</PlatformToolset>
+    <PlatformToolset>v120</PlatformToolset>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
@@ -181,6 +181,7 @@
     <ClCompile Include="NOMADVRLib\Grid.cpp" />
     <ClCompile Include="NOMADVRLib\IsoShaders.cpp" />
     <ClCompile Include="NOMADVRLib\IsosurfacesGL.cpp" />
+    <ClCompile Include="NOMADVRLib\markerShaders.cpp" />
     <ClCompile Include="NOMADVRLib\polyhedron.cpp" />
     <ClCompile Include="NOMADVRLib\TessShaders.cpp" />
     <ClCompile Include="NOMADVRLib\UnitCellShaders.cpp" />
@@ -201,6 +202,7 @@
     <ClInclude Include="NOMADVRLib\Grid.h" />
     <ClInclude Include="NOMADVRLib\IsoShaders.h" />
     <ClInclude Include="NOMADVRLib\IsosurfacesGL.h" />
+    <ClInclude Include="NOMADVRLib\markerShaders.h" />
     <ClInclude Include="NOMADVRLib\MyGL.h" />
     <ClInclude Include="NOMADVRLib\polyhedron.h" />
     <ClInclude Include="NOMADVRLib\TessShaders.h" />