Updated sprite rendering example with and without custom shader

Author: NickHardeman

examples/gl/pointsAsTexturesExample/bin/data/ofLogo.png

@@ -0,0 +1,12 @@
+OF_GLSL_SHADER_HEADER
+uniform sampler2D tex;
+
+in vec4 in_Color;
+
+out vec4 out_Color;
+
+void main (void) {
+    
+    out_Color = texture(tex, gl_PointCoord) * in_Color;
+    
+}

examples/gl/pointsAsTexturesExample/bin/data/shader.frag

@@ -0,0 +1,19 @@
+OF_GLSL_SHADER_HEADER
+
+uniform mat4 modelViewProjectionMatrix;
+uniform vec4 globalColor;
+in vec4 position;
+in vec3 normal;
+in vec4 color;
+
+out vec4 in_Color;
+
+uniform float pointSize;
+
+void main() {
+    gl_Position = modelViewProjectionMatrix * position;
+	// we are passing in size variations via the normal.x
+	gl_PointSize  = normal.x * pointSize;
+	in_Color = color;
+
+}

examples/gl/pointsAsTexturesExample/bin/data/shader.vert

@@ -13,6 +13,7 @@ int main( ){
 
 	//Use ofGLFWWindowSettings for more options like multi-monitor fullscreen
 	ofGLWindowSettings settings;
+	settings.setGLVersion(3, 2);
 	settings.setSize(1024, 768);
 	settings.windowMode = OF_WINDOW; //can also be OF_FULLSCREEN
 

examples/gl/pointsAsTexturesExample/bin/data/shaders_gl3/shader.frag

@@ -2,17 +2,18 @@
 
 //--------------------------------------------------------------
 void ofApp::setup() {
-	
+
 	ofBackgroundHex(0x000000);
 	ofSetFrameRate(60);
 	ofSetVerticalSync(true);
-	
+
 	// load the texure
 	ofDisableArbTex();
 	ofLoadImage(texture, "dot.png");
-	
+	ofLoadImage(logoTexture, "ofLogo.png");
+
 	// set the camera distance
-	camDist  = 1605;
+	camDist = 1605;
 	camera.setDistance(camDist);
 
 	// randomly add a point on a sphere
@@ -27,29 +28,46 @@ void ofApp::setup() {
 		p.x = std::cos( theta1 ) * std::cos( theta2 );
 		p.y = std::sin( theta1 );
 		p.z = std::cos( theta1 ) * std::sin( theta2 );
+
 		p *= radius;
 
 		addPoint(p.x, p.y, p.z);
-	
 	}
 
 	// upload the data to the vbo
 	int total = (int)points.size();
 	vbo.setVertexData(&points[0], total, GL_STATIC_DRAW);
 	vbo.setNormalData(&sizes[0], total, GL_STATIC_DRAW);
+	vbo.setColorData(&colors[0], total, GL_STATIC_DRAW);
 
-	
-	// load the shader
-	#ifdef TARGET_OPENGLES
-		shader.load("shaders_gles/shader");
-	#else
-		shader.load("shaders/shader"); 
-		#endif
+	// we will be drawing point sprites, so set mode on mesh to POINTS
+	mesh.setMode(OF_PRIMITIVE_POINTS);
+
+	if( ofIsGLProgrammableRenderer() ) {
+		shader.load("shaders_gl3/shader");
+	} else {
+		shader.load("shaders/shader");
+	}
 
 }
 
 //--------------------------------------------------------------
 void ofApp::update() {
+	pointSize = ofMap(ofGetMouseX(), 100.f, ofGetWidth() - 50.0f, 1.0f, 60.f, true);
+	ofSetPointSize(pointSize);
+
+	if( bUseShader ) {
+		mesh.enableColors();
+		vbo.enableColors();
+	} else {
+		if( bUseColors ) {
+			mesh.enableColors();
+			vbo.enableColors();
+		} else {
+			mesh.disableColors();
+			vbo.disableColors();
+		}
+	}
 }
 
 //--------------------------------------------------------------
@@ -58,30 +76,74 @@ void ofApp::draw() {
 	glDepthMask(GL_FALSE);
 
 	ofSetColor(255, 100, 90);
+
+	ofEnableAlphaBlending();
 
 	// this makes everything look glowy :)
 	ofEnableBlendMode(OF_BLENDMODE_ADD);
 	ofEnablePointSprites();
+
+	if (bSmoothing) {
+		ofEnableSmoothing();
+	} else {
+		ofDisableSmoothing();
+	}
+	
+	// determine if we should bind a texture for our points to draw
+	ofTexture* tex = nullptr;
+	if (bUseShader) {
+		// we are using a shader and it expects a texture 
+		tex = &texture;
+	} else {
+		if( texIndex == 1 ) {
+			tex = &texture;
+		} else if( texIndex == 2 ) {
+			tex = &logoTexture;
+		}
+	}
 
 	// bind the shader and camera
 	// everything inside this function
 	// will be effected by the shader/camera
-	shader.begin();
 	camera.begin();
+	if (bUseShader) {
+		shader.begin();
+		// pass the point size to the shader
+		shader.setUniform1f("pointSize", pointSize);
+	}
+	
+	if( tex != nullptr) {
+		// bind the texture so that when all the points
+		// are drawn they are replace with our dot image
+		tex->bind();
+	}
 
-	// bind the texture so that when all the points 
-	// are drawn they are replace with our dot image
-	texture.bind();
-	vbo.draw(GL_POINTS, 0, (int)points.size());
-	texture.unbind();
 
-	camera.end();
-	shader.end();
+	if (bUseShader) {
+		// draw via the vbo for the custom shader
+		vbo.draw(GL_POINTS, 0, (int)points.size());
+	} else {
+		// lets draw the mesh
+		mesh.drawVertices();
+	}
 
+	if (tex != nullptr) {
+		tex->unbind();
+	}
+	
+	if (bUseShader){
+		shader.end();
+	} else {
+		
+	}
+
 	ofDisablePointSprites();
+
+	camera.end();
+	
 	ofDisableBlendMode();
 
-	// check to see if the points are 
+	// check to see if the points are
 	// sizing to the right size
 	ofEnableAlphaBlending();
 	camera.begin();
@@ -91,31 +153,44 @@ void ofApp::draw() {
 		mid = glm::normalize(mid);
 		mid *= 300;
 		ofDrawLine(points[i], mid);
-	} 
+	}
 	camera.end();
-	
+
 	glDepthMask(GL_TRUE);
-	
+
 	ofSetColor(255, 100);
-	ofDrawRectangle(0, 0, 250, 90);
+	ofDrawRectangle(0, 0, 250, bUseShader ? 90 : 120);
 	ofSetColor(0);
 	string info = "FPS "+ofToString(ofGetFrameRate(), 0) + "\n";
 	info += "Total Points "+ofToString((int)points.size())+"\n";
 	info += "Press 'a' to add more\n";
-	info += "Press 'c' to remove all";
-	
+	info += "Press 'c' to remove all\n";
+	info += "Press 's' for shader: " + string(bUseShader ? "yes":"no")+"\n";
+	if( !bUseShader) {
+		info += "Press 'x' for colors: " + string(bUseColors ? "yes" : "no") + "\n";
+		info += "Press 't' for texture: " + string(texIndex == 0 ? "no" : "yes") + "\n";
+		info += "Press 'z' for smoothing: " + string(bSmoothing ? "yes" : "no") + "\n";
+	}
+
 	ofDrawBitmapString(info, 20, 20);
-	
 }
 
 //--------------------------------------------------------------
 void ofApp::addPoint(float x, float y, float z) {
 	glm::vec3 p(x, y, z);
 	points.push_back(p);
 
-	// we are passing the size in as a normal x position
-	float size = ofRandom(5, 50);
+	// we are passing the size varation per point via the normal x
+	float size = ofRandom(1.f, 2.f);
 	sizes.push_back(glm::vec3(size));
+
+	ofFloatColor tc;
+	tc.setHsb(ofRandom(0.5f, 1.0f), 0.7f, 0.8f, 1.0f);
+
+	colors.push_back(tc);
+	mesh.addColor(tc);
+	mesh.addVertex(p);
+	mesh.addNormal(glm::vec3(size));
 }
 
 //--------------------------------------------------------------
@@ -133,6 +208,9 @@ void ofApp::keyPressed(int key) {
 	// clear all the points
 	if(key == 'c') {
 		points.clear();
+		sizes.clear();
+		colors.clear();
+		mesh.clear();
 	}
 
 	// add crazy amount
@@ -148,9 +226,24 @@ void ofApp::keyPressed(int key) {
 		int total = (int)points.size();
 		vbo.setVertexData(&points[0], total, GL_STATIC_DRAW);
 		vbo.setNormalData(&sizes[0], total, GL_STATIC_DRAW);
-		
+		vbo.setColorData(&colors[0], total, GL_STATIC_DRAW);
 	}
 
+	if( key == 's' ) {
+		bUseShader = !bUseShader;
+	}
+	if( key == 't') {
+		texIndex ++;
+		if( texIndex > 2 ) {
+			texIndex = 0;
+		}
+	}
+	if( key == 'z' ) {
+		bSmoothing = !bSmoothing;
+	}
+	if( key == 'x') {
+		bUseColors = !bUseColors;
+	}
 }
 
 //--------------------------------------------------------------

examples/gl/pointsAsTexturesExample/bin/data/shaders_gl3/shader.vert

@@ -25,12 +25,21 @@ class ofApp : public ofBaseApp {
 		// vector to store all values
 		vector <glm::vec3> points;
 		vector <glm::vec3> sizes;
-		
+		vector<ofFloatColor> colors;
+
 		ofVbo vbo;
+		ofMesh mesh;
+		bool bUseShader = true;
 		ofShader shader;
 		ofEasyCam camera;
 
 		float camDist;
+		bool bUseColors = false;
+
+		float pointSize = 10.0f;
+		bool bSmoothing = false;
 
-		ofTexture texture;
+		ofTexture texture, logoTexture;
+		int texIndex = 1;
+	
 };