Пример #1
0
	bool GuiButton(ui_context & ui, const ui_id id, string sprite, Transform & transform,
		           int x, int y, int width, int height, const mouse_info & mouse)
	{
		bool result = false;
		bool mouseover = false;
		int frame = 0;

		int x1 = x - width / 2;
		int x2 = x + width / 2;
		int y1 = y - height / 2;
		int y2 = y + height / 2;

		if (!result && (mouse.x > x1 && mouse.x < x2) && (mouse.y > y1 && mouse.y < y2)) {
			mouseover = true;
		}

		if (ui.active == id) {
			frame = 2;
			if (mouse.LMB == false) {
				if (mouseover && ui.hot == id) {
					result = true;
				}
				ui.active.owner = NULL;
			}
		} else if (ui.hot == id) {
			if (!mouseover) {
				ui.hot == NULL;
			}
			else if (mouse.LMB == true) {
				ui.active = id;
			}
		}

		if (mouseover && ui.active.owner == NULL) {
			ui.hot = id;
			frame = 1;
		}

		// get dimensions of sprite
		SpritePtr btnSprite = g_Sprite.GetSprite(sprite);
		const ivec4 & size = btnSprite->GetSize();
		double wRatio = (double) width / (double) size.x;
		double hRatio = (double) height / (double) size.y;

		// draw the button
		MatrixStack * mv = transform.GetModelViewStack();
		mv->PushMatrix();
		mv->Translate((float)x, (float)y, 0);
		mv->Scale((float)wRatio, (float)hRatio, 1);
		btnSprite->Draw(frame, transform);
		mv->PopMatrix();

		return result;
	}
Пример #2
0
void Sphere::drawTransformedGeometry(MatrixStack &mv_s)
{
	/// Update parent-to-child and local transforms
	parentChild.update();
	local.update();
	/// save state of matrixstack
	mv_s.PushMatrix();
	/// Evaluate the affine transform
	mv_s.MultMatrix(parentChild.m);
	mv_s.MultMatrix(local.m);
	glLoadMatrixf(mv_s.last());
	(Logger::Instance()).checkAndReportGLError("Failed to load matrix onto the openGL modelview matrixstack",'e',4,__LINE__,__FILE__);
	/// Render the object
	this->drawGeometry();
	/// Restore state of matrixstack
	mv_s.PopMatrix();
}
Пример #3
0
	void Sprite::Draw(int frame, Transform & transform, int anchor, vec4 color)
	{
		// calculate st.uv texture offsets
		assert(frame >= 0 && frame < frameCount);

		int cols = size.z;
		int rows = size.w;

		vec4 offset;
    
		//  0   1   2   3   4
		//  5   6   7   8   9
		// 10  11  12  13  14
		// 15  16  17  18  19
		// 20  21  22  23  24
	
		int frameCol = frame % cols;
		int frameRow = frame / cols;	

		// 0 -  row 0, col 0
		// 12 - row 2, col 2
		// 24 - row 4, col 4

		float tX = 1.f / cols;
		float tY = 1.f / rows;

		offset.x = tX * frameCol;
		offset.y = tY * frameRow;

		MatrixStack * mv = transform.GetModelViewStack();
		mv->PushMatrix();

		vec2 renderPos = GetAnchorCoords(anchor, vec2(0, 0), vec2(size.x, size.y));
		renderPos += (size.xy() / 2);
		mv->Translate(renderPos.x, renderPos.y, 0);
		g_Sprite.SetupShader(transform.GetMVP(), offset, texture, color);
		buffer.render(GL_TRIANGLE_STRIP);

		mv->PopMatrix();
	}
Пример #4
0
    void App::Render(const delta_t dt, const delta_t elapsed)
    {	
		// clear buffer and save matrix state
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		// position camera
		mat4 camera;
		cameraFrame.GetCameraMatrix(camera);
		mv.PushMatrix(camera);

			// create point light
			vec4 vLightPos(sin(elapsed) * 10, 5, -8 + (cos(elapsed) * 15), 1);
			vec4 vLightEyePos;
			vec4 vAmbientColor(0.1f, 0.1f, 0.1f, 1);
			vec4 vDiffuseColor(1, 1, 1, 1);
			vec4 vSpecularColor(1, 1, 1, 1);

			// use smoothstep to animate the cube movement
			static float xPos;
			xPos = ((float)sin(elapsed * 3.1) + 1.0f) / 2.0f;
			xPos = (xPos) * (xPos) * (3.0f - 2.0f * (xPos));
			xPos = (-1.5f * xPos) + (1.5f * (1.0f - xPos));

			// copy uniform information to shader 
			GL_DEBUG(glUseProgram(phongShader));
			vLightEyePos = mv.Transform(vLightPos);
			GL_DEBUG(glUniformMatrix3fv(locNM , 1, GL_FALSE, transform.GetNormalMatrix() ));
			GL_DEBUG(glUniformMatrix4fv(locMV , 1, GL_FALSE, transform.GetModelView() ));
			GL_DEBUG(glUniformMatrix4fv(locMVP, 1, GL_FALSE, transform.GetMVP() ));
			GL_DEBUG(glUniform4fv(locAmbient, 1, &vAmbientColor[0]));
			GL_DEBUG(glUniform4fv(locDiffuse, 1, &vDiffuseColor[0]));
			GL_DEBUG(glUniform4fv(locSpecular, 1, &vSpecularColor[0]));
			GL_DEBUG(glUniform3fv(locLightPos, 1, &vLightEyePos[0]));
			GL_DEBUG(glUniform1i(locTexture, 0));

			// render the floor
			glActiveTexture(GL_TEXTURE0);
			glBindTexture(GL_TEXTURE_2D, baseTexture);
			base.Draw();

			// transform modelview to rotate cube
			mv.PushMatrix();
				mat4 cubePos = translate(mat4(), vec3(xPos, -0.5f, -15.f));
				cubePos = rotate(cubePos, 100.0f * (float)sin(elapsed), vec3(1.0f, 0.0f, 0.0f));
				cubePos = rotate(cubePos, 20.0f * (float)elapsed, vec3(0.0f, 1.0f, 0.0f));
				mv.MultMatrix(cubePos);

				// copy uniform information to shader for cube
				vLightEyePos = mv.Transform(vLightPos);
				GL_DEBUG(glUniform3fv(locLightPos, 1, &vLightEyePos[0]));
				GL_DEBUG(glUniformMatrix3fv(locNM , 1, GL_FALSE, transform.GetNormalMatrix() ));
				GL_DEBUG(glUniformMatrix4fv(locMV , 1, GL_FALSE, transform.GetModelView() ));
				GL_DEBUG(glUniformMatrix4fv(locMVP, 1, GL_FALSE, transform.GetMVP() ));
				glBindTexture(GL_TEXTURE_2D, cubeTexture);

				// render geometry
				cube.Draw();
			mv.PopMatrix();

			// draw cube at light position
			mv.PushMatrix();
				cubePos = translate(mat4(), vLightPos.xyz());
				mv.MultMatrix(cubePos);
				vLightEyePos = mv.Transform(vLightPos);
				GL_DEBUG(glUniform3fv(locLightPos, 1, &vLightEyePos[0]));
				GL_DEBUG(glUniformMatrix3fv(locNM , 1, GL_FALSE, transform.GetNormalMatrix() ));
				GL_DEBUG(glUniformMatrix4fv(locMV , 1, GL_FALSE, transform.GetModelView() ));
				GL_DEBUG(glUniformMatrix4fv(locMVP, 1, GL_FALSE, transform.GetMVP() ));
				glBindTexture(GL_TEXTURE_2D, cubeTexture);
				cube.Draw();
			mv.PopMatrix();

			// draw a stationary cube
			mv.PushMatrix();
				cubePos = translate(mat4(), vec3(-5, 0, 0));
				cubePos = rotate(cubePos, 45.0f, vec3(1, 0, 0));
				mv.MultMatrix(cubePos);
				vLightEyePos = mv.Transform(vLightPos);
				GL_DEBUG(glUniform3fv(locLightPos, 1, &vLightEyePos[0]));
				GL_DEBUG(glUniformMatrix3fv(locNM , 1, GL_FALSE, transform.GetNormalMatrix() ));
				GL_DEBUG(glUniformMatrix4fv(locMV , 1, GL_FALSE, transform.GetModelView() ));
				GL_DEBUG(glUniformMatrix4fv(locMVP, 1, GL_FALSE, transform.GetMVP() ));
				glBindTexture(GL_TEXTURE_2D, cubeTexture);
				cube.Draw();
			mv.PopMatrix();

		mv.PopMatrix();

		// update blur frame textures
		blurTimer += (float)dt;
		if (blurTimer > BLUR_FRAME_DELAY)
		{
			// save frame buffer to pbo
			glBindBuffer(GL_PIXEL_PACK_BUFFER, pbo);
			glReadPixels(0, 0, g_App.GetWidth(), g_App.GetHeight(), GL_RGB, GL_UNSIGNED_BYTE, NULL);
			glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);

			// save pixel buffer to texture and increment frame index
			glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo);
			glActiveTexture(GL_TEXTURE0 + GetBlurFrame0());
			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, g_App.GetWidth(), g_App.GetHeight(), 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
			glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);

			// reset iterator variables
			blurTimer = 0;
			AdvanceBlurFrame();
		}

		// use stored blur textures to generate frame
		if (blurEnabled && moveBlur) 
		{
			// render quad to the screen
			mat4 ortho = glm::ortho(0.0f, (float)g_App.GetWidth(), 0.0f, (float)g_App.GetHeight());
			glDisable(GL_DEPTH_TEST);
			glUseProgram(blurShader);
			glUniformMatrix4fv(locBlurMVP, 1, GL_FALSE, value_ptr(ortho));
			glUniform1i(glGetUniformLocation(blurShader, "blurFrame0"), GetBlurFrame0());
			glUniform1i(glGetUniformLocation(blurShader, "blurFrame1"), GetBlurFrame1());
			glUniform1i(glGetUniformLocation(blurShader, "blurFrame2"), GetBlurFrame2());
			glUniform1i(glGetUniformLocation(blurShader, "blurFrame3"), GetBlurFrame3());
			screen.Draw();
			glEnable(GL_DEPTH_TEST);
		}
	}