void SpriteRenderNode::render() {
	if(!hidden && (!scene->isPaused() || renderWhenPaused)) {
		bool renderSprites = scene->getAttribute(RENDER_SPRITES)->getBooleanValue();
		if(renderSprites) {
			pantheios::log(pantheios::debug, "Rendering Sprite ", HashedStringInserter(texture), " for ", GameObjectInserter(*(getOwner())));
			
			Texture* tex = CalicoAPI::getResourceManager()->getTexture(texture);
			assert(tex != NULL);
			
			if(tex != NULL) {
				if(needToRegenerateVBO) {
					generateVBO();
				}
				
				Rect2D boundsRect = getWorldRect();
				
				Transform* ownerTransform = owner->getTransform();
				Vector3 ownerPosition = *(ownerTransform->getPosition());
				Rect2D spriteBounds(Vector2(ownerPosition.X() + boundsRect.min.X(), ownerPosition.Y() + boundsRect.min.Y()), 
									Vector2(ownerPosition.X() + boundsRect.max.X(), ownerPosition.Y() + boundsRect.max.Y()));
				Rect2D cameraBounds = layer->getCamera()->getWorldBounds();
				
				// only draw if the sprite is actually on-screen
				
				// TODO - this is buggy!
//				if(spriteBounds.intersects(cameraBounds)) {
					glPushMatrix();
					glMultMatrixf(ownerTransform->ToGlWorldMatrix(flip));
					
					tex->bind();
					
					glEnableClientState(GL_TEXTURE_COORD_ARRAY);
					glEnableClientState(GL_COLOR_ARRAY);
					
					glBindBuffer(GL_ARRAY_BUFFER, vbo);
					glVertexPointer(2, GL_FLOAT, sizeof(VertexPt), 0);
					glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(VertexPt), (unsigned char*) (sizeof(GLfloat) * 2));
					glTexCoordPointer(2, GL_FLOAT, sizeof(VertexPt), (unsigned char*) (sizeof(GLfloat) * 2 + sizeof(GLubyte) * 4));
					
					glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
					
					glBindBuffer(GL_ARRAY_BUFFER, 0);
					
					glPopMatrix();
//				}
			}
		}
	}
}
void c3_exercise_1::run()
{
	SDL_Init(SDL_INIT_VIDEO);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);

	SDL_Window *window = SDL_CreateWindow("OpenGL", 100, 100, 800, 600, SDL_WINDOW_OPENGL);
	SDL_GLContext context = SDL_GL_CreateContext(window);

	glewExperimental = GL_TRUE;
	glewInit();

	GLuint vao;
	glGenVertexArrays(1, &vao);
	glBindVertexArray(vao);

	GLuint vbo = generateVBO();
	GLuint ebo = generateEBO();

	GLuint vertexShader = compileShader(vertexSource(), GL_VERTEX_SHADER);
	GLuint fragmentShader = compileShader(fragmentSource(), GL_FRAGMENT_SHADER);

	GLuint shaderProgram = glCreateProgram();
	glAttachShader(shaderProgram, vertexShader);
	glAttachShader(shaderProgram, fragmentShader);
	//glBindFragDataLocation(shaderProgram, 0, "outColor"); // Not necessary since there is only one output
	glLinkProgram(shaderProgram);
	glUseProgram(shaderProgram);

	size_t floatSize = sizeof(float);
	size_t stride = 7;

	GLint posAttrib = glGetAttribLocation(shaderProgram, "position");
	glEnableVertexAttribArray(posAttrib);
	glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, stride * floatSize, 0);

	GLint colAttrib = glGetAttribLocation(shaderProgram, "color");
	glEnableVertexAttribArray(colAttrib);
	glVertexAttribPointer(colAttrib, 3, GL_FLOAT, GL_FALSE, stride * floatSize, (GLvoid *)(2 * floatSize));

	GLint texAttrib = glGetAttribLocation(shaderProgram, "texcoord");
	glEnableVertexAttribArray(texAttrib);
	glVertexAttribPointer(texAttrib, 2, GL_FLOAT, GL_FALSE, stride * floatSize, (GLvoid *)(5 * floatSize));

	std::array<GLuint, 2> textures{};
	loadTextures(textures, shaderProgram);

	GLint uniTime = glGetUniformLocation(shaderProgram, "time");

	SDL_Event windowEvent;
	while (true)
	{
		if (SDL_PollEvent(&windowEvent))
		{
			if (windowEvent.type == SDL_QUIT)
			{
				break;
			}

			if (windowEvent.type == SDL_KEYUP && windowEvent.key.keysym.sym == SDLK_ESCAPE)
			{
				break;
			}
		}

		glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);

		glUniform1f(uniTime, (GLfloat)clock() / (GLfloat)CLOCKS_PER_SEC);

		glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

		SDL_GL_SwapWindow(window);
	}

	glDeleteTextures(2, textures.data());

	glDeleteProgram(shaderProgram);
	glDeleteShader(vertexShader);
	glDeleteShader(fragmentShader);

	glDeleteBuffers(1, &vbo);

	glDeleteVertexArrays(1, &vao);

	SDL_GL_DeleteContext(context);
	SDL_Quit();
}
Exemple #3
0
void OGLGameObject::createFromFile(std::string filename)
{
   vertexData.readFromFile(filename);
   generateVBO();
}