Example #1
0
QENGINE_API void renderFullscreenTexturedQuad()
{
	int isDepthEnabled = isZTestEnabled();
	disableZTest();

	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_TEXTURE_2D);


//	g_pTexturedEffect->Bind();

//	float verts[20] = {-1.0f, -1.0f, 1.0f, 0.0f, 0.0f,
//					   1.0f, -1.0f, 1.0f, 1.0f, 0.0f,
//					   1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 
//					   -1.0f, 1.0f, 1.0f, 0.0f, 1.0f};
//	unsigned int indices[6] = {0, 1, 2, 0, 2, 3};
//	glVertexAttribPointer(LOC_POSITION, 3, GL_FLOAT, GL_FALSE, 20, verts);
//	glVertexAttribPointer(LOC_TEXCOORD0, 2, GL_FLOAT, GL_TRUE, 20, (float*)&verts[3]);
//	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, indices);

//	g_pTexturedEffect->EvictTextures();
//	g_pTexturedEffect->Unbind();

	bindBuffer(g_fullscreenQuad);
	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, BUFFER_OFFSET(0));
	bindDefaultBuffer();

	glDisable(GL_BLEND);

	if(isDepthEnabled)
		enableZTest();		
}
Example #2
0
Material::Material(const Path& path, ResourceManager& resource_manager, IAllocator& allocator)
	: Resource(path, resource_manager, allocator)
	, m_shader(nullptr)
	, m_uniforms(allocator)
	, m_allocator(allocator)
	, m_texture_count(0)
	, m_render_states(0)
	, m_specular(1, 1, 1)
	, m_shininess(4)
	, m_shader_instance(nullptr)
	, m_shader_mask(0)
{
	auto* manager = resource_manager.get(ResourceManager::MATERIAL);
	auto* mat_manager = static_cast<MaterialManager*>(manager);

	s_alpha_cutout_define_idx = mat_manager->getRenderer().getShaderDefineIdx("ALPHA_CUTOUT");
	s_shadow_receiver_define_idx = mat_manager->getRenderer().getShaderDefineIdx("SHADOW_RECEIVER");

	enableZTest(true);
	enableBackfaceCulling(true);
	enableShadowReceiving(true);
	for (int i = 0; i < MAX_TEXTURE_COUNT; ++i)
	{
		m_textures[i] = nullptr;
	}
}
void DebugEmitterComponent::Render(const UpdateContext& updateContext)
{
	if (!_model)
		return;

	auto parent = GetParentEntity();
	vec3f center = GetModelCenter();
	vec3f desiredPos = parent->GetPosition();
	vec3f desiredScale = parent->GetScale();
	mat4f desiredPose = parent->GetPose();

	enableZTest();
	changeZTest(GL_LEQUAL);

	mat4f ident, NT, T, S, R, x, y, z;
	ident.loadIdentity();
	_matrixStack.PushMatrix(ident);
	//NT.loadTranslation(-center.x, -center.y, -center.z);
	T.loadTranslation(desiredPos.x, desiredPos.y, desiredPos.z);
	S.loadScale(desiredScale.x, desiredScale.y, desiredScale.z);
	R = desiredPose;
	R.m[12] = 0.0f;
	R.m[13] = 0.0f;
	R.m[14] = 0.0f;
	R.m[15] = 1.0f;

	_matrixStack.MultiplyMatrix(T);
	_matrixStack.MultiplyMatrix(S);
	_matrixStack.MultiplyMatrix(R);
	//_matrixStack.MultiplyMatrix(NT);
	//	_matrixStack.MultiplyMatrix(parent->GetTransform());

	/*vec3f rot = parent->GetDirection();
	mat4f xRot, yRot, zRot;

	xRot.loadXRotation(rot.x);
	yRot.loadYRotation(rot.y);
	zRot.loadZRotation(rot.z);

	xRot *= yRot;
	xRot *= zRot;
	_matrixStack.MultiplyMatrix(xRot);*/

	mat4f MV;
	MV = getMatrix(MATRIX_MODEL);
	_RenderNode(_model->RootNode, updateContext);
	_matrixStack.PopMatrix();
	setMatrix(MATRIX_MODEL, MV);
}
Example #4
0
QENGINE_API void renderFullscreenTexturedQuad(bool invertV, unsigned int texID)
{
	if(texID <= 0)
		return;

	int isDepthEnabled = isZTestEnabled();
//	float minV, maxV;
//	minV = 0.0f; maxV = 1.0f;
//	if (invertV)
//	{
//		minV = 1.0f; maxV = 0.0f;
//	}
	disableZTest();

	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_TEXTURE_2D);

	mat4f ID;
	ID.loadIdentity();
	pushMatrix(MATRIX_MODEL, ID);
	pushMatrix(MATRIX_VIEW, ID);
	pushMatrix(MATRIX_PROJECTION, ID);

	float a = 1.0f;
	float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
	g_pTexturedEffect->Bind();
	g_pTexturedEffect->BindTexture("s0", texID);
	g_pTexturedEffect->BindBool("invert", invertV);
	g_pTexturedEffect->BindFloat("globalColor", color, 4);
	g_pTexturedEffect->BindStateMatrix("MVP", MATRIX_MODEL | MATRIX_VIEW | MATRIX_PROJECTION);

	bindBuffer(g_fullscreenQuad);
	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, BUFFER_OFFSET(0));
	bindDefaultBuffer();

	g_pTexturedEffect->EvictTextures();
	g_pTexturedEffect->Unbind();
	
	glDisable(GL_BLEND);

	popMatrix(MATRIX_MODEL);
	popMatrix(MATRIX_VIEW);
	popMatrix(MATRIX_PROJECTION);

	if(isDepthEnabled)
		enableZTest();	
}
Example #5
0
QENGINE_API void renderFullscreenQuad(const texture_rect& rect, unsigned int w, unsigned int h)
{
	int isDepthEnabled = isZTestEnabled();
	disableZTest();

//	glMatrixMode(GL_MODELVIEW);
//	glPushMatrix();
//	glLoadIdentity();
//	glMatrixMode(GL_PROJECTION);
//	glPushMatrix();
//	glLoadIdentity();

	float fWidth5 = (float)w - 0.5f;
	float fHeight5 = (float)h - 0.5f;

//	glBegin(GL_QUADS);
//		glTexCoord2f(rect.leftU, rect.bottomV);
//		glVertex3f(-1.0f, -1.0f, 1.0f);
//		glTexCoord2f(rect.rightU, rect.bottomV);
//		glVertex3f(1.0f, -1.0f, 1.0f);
//		glTexCoord2f(rect.rightU, rect.topV);
//		glVertex3f(1.0f, 1.0f, 1.0f);
//		glTexCoord2f(rect.leftU, rect.topV);
//		glVertex3f(-1.0F, 1.0F, 1.0f);
//	glEnd();

//	glPopMatrix();
//	glMatrixMode(GL_PROJECTION);
//	glPopMatrix();

	float verts[20] = {-1.0f, -1.0f, 1.0f, rect.leftU, rect.bottomV,
					   1.0f, -1.0f, 1.0f, rect.rightU, rect.bottomV,
					   1.0f, 1.0f, 1.0f, rect.rightU, rect.topV, 
					   -1.0f, 1.0f, 1.0f, rect.leftU, rect.topV};
	unsigned int indices[6] = {0, 1, 2, 0, 2, 3};
	glEnableVertexAttribArray(LOC_POSITION);
	glEnableVertexAttribArray(LOC_TEXCOORD0);
	glVertexAttribPointer(LOC_POSITION, 3, GL_FLOAT, GL_FALSE, 20, verts);
	glVertexAttribPointer(LOC_TEXCOORD0, 2, GL_FLOAT, GL_TRUE, 20, (float*)&verts[3]);
	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, indices);
	glDisableVertexAttribArray(LOC_POSITION);
	glDisableVertexAttribArray(LOC_TEXCOORD0);

	if(isDepthEnabled)
		enableZTest();

}
Example #6
0
QENGINE_API void renderFullscreenQuad(float r, float g, float b, float a)
{
	float verts[28] = { -1.0f, -1.0f, 1.0f, r, g, b, a,
						1.0f, -1.0f, 1.0f, r, g, b, a,
						1.0f, 1.0f, 1.0f, r, g, b, a,
						-1.0f, 1.0f, 1.0f, r, g, b, a };
	uint32_t indices[6] = { 0, 1, 2, 0, 2, 3 };

	int isDepthEnabled = isZTestEnabled();
	disableZTest();

	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	mat4f id;
	id.loadIdentity();
	pushMatrix(MATRIX_PROJECTION, id);
	pushMatrix(MATRIX_VIEW, id);
	g_pColoredEffect->Bind();
	g_pColoredEffect->BindStateMatrix("MVP", MATRIX_MODEL | MATRIX_VIEW | MATRIX_PROJECTION);

	glEnableVertexAttribArray(LOC_POSITION);
	glEnableVertexAttribArray(LOC_COLOR);
	glVertexAttribPointer(LOC_POSITION, 3, GL_FLOAT, GL_FALSE, 28, verts);
	glVertexAttribPointer(LOC_COLOR, 4, GL_FLOAT, GL_TRUE, 28, (float*)&verts[3]);
	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, indices);
	glDisableVertexAttribArray(LOC_POSITION);
	glDisableVertexAttribArray(LOC_COLOR);
	g_pColoredEffect->Unbind();

	if(isDepthEnabled)
		enableZTest();

	glDisable(GL_BLEND);
	popMatrix(MATRIX_PROJECTION);
	popMatrix(MATRIX_VIEW);
}
Example #7
0
bool Material::load(FS::IFile& file)
{
	PROFILE_FUNCTION();

	m_render_states = BGFX_STATE_DEPTH_TEST_LEQUAL | BGFX_STATE_CULL_CW;
	m_uniforms.clear();
	JsonSerializer serializer(file, JsonSerializer::READ, getPath().c_str(), m_allocator);
	serializer.deserializeObjectBegin();
	char path[MAX_PATH_LENGTH];
	char label[256];
	char material_dir[MAX_PATH_LENGTH];
	PathUtils::getDir(material_dir, MAX_PATH_LENGTH, getPath().c_str());
	bool b_value;
	while (!serializer.isObjectEnd())
	{
		serializer.deserializeLabel(label, 255);
		if (compareString(label, "uniforms") == 0)
		{
			deserializeUniforms(serializer);
		}
		else if (compareString(label, "texture") == 0)
		{
			if (!deserializeTexture(serializer, material_dir))
			{
				return false;
			}
		}
		else if (compareString(label, "alpha_cutout") == 0)
		{
			bool b;
			serializer.deserialize(b, false);
			enableAlphaCutout(b);
		}
		else if (compareString(label, "alpha_blending") == 0)
		{
			if (serializer.isNextBoolean())
			{
				bool is_alpha_blending;
				serializer.deserialize(is_alpha_blending, false);
				if (is_alpha_blending)
				{
					m_render_states |= BGFX_STATE_BLEND_ADD;
				}
				else
				{
					m_render_states &= ~BGFX_STATE_BLEND_MASK;
				}
			}
			else
			{
				serializer.deserialize(label, 255, "alpha");
				if (compareString(label, "alpha") == 0)
				{
					m_render_states |= BGFX_STATE_BLEND_ALPHA;
				}
				else if (compareString(label, "add") == 0)
				{
					m_render_states |= BGFX_STATE_BLEND_ADD;
				}
				else if (compareString(label, "disabled") == 0)
				{
					m_render_states &= ~BGFX_STATE_BLEND_MASK;
				}
			}
		}
		else if (compareString(label, "specular") == 0)
		{
			serializer.deserializeArrayBegin();
			serializer.deserializeArrayItem(m_specular.x, 1.0f);
			serializer.deserializeArrayItem(m_specular.y, 1.0f);
			serializer.deserializeArrayItem(m_specular.z, 1.0f);
			serializer.deserializeArrayEnd();
		}
		else if (compareString(label, "shininess") == 0)
		{
			serializer.deserialize(m_shininess, 4.0f);
		}
		else if (compareString(label, "shadow_receiver") == 0)
		{
			bool b;
			serializer.deserialize(b, true);
			enableShadowReceiving(b);
		}
		else if (compareString(label, "shader") == 0)
		{
			serializer.deserialize(path, MAX_PATH_LENGTH, "");
			setShader(static_cast<Shader*>(
				m_resource_manager.get(ResourceManager::SHADER)->load(Path(path))));
		}
		else if (compareString(label, "z_test") == 0)
		{
			serializer.deserialize(b_value, true);
			enableZTest(b_value);
		}
		else if (compareString(label, "backface_culling") == 0)
		{
			serializer.deserialize(b_value, true);
			enableBackfaceCulling(b_value);
		}
		else
		{
			g_log_warning.log("renderer") << "Unknown parameter " << label << " in material "
										  << getPath().c_str();
		}
	}
	serializer.deserializeObjectEnd();

	if (!m_shader)
	{
		g_log_error.log("renderer") << "Material " << getPath().c_str() << " without a shader";
		return false;
	}

	m_size = file.size();
	return true;
}