Shader::Shader(string vFile, string fFile, string gFile)	{
	program		= glCreateProgram();
	objects[SHADER_VERTEX]		= GenerateShader(vFile,GL_VERTEX_SHADER);
	objects[SHADER_FRAGMENT]	= GenerateShader(fFile,GL_FRAGMENT_SHADER);
	objects[SHADER_GEOMETRY]	= 0;

	if(!gFile.empty()) {
		objects[SHADER_GEOMETRY]	= GenerateShader(gFile,GL_GEOMETRY_SHADER);
		glAttachShader(program,objects[SHADER_GEOMETRY]);
	}

	glAttachShader(program,objects[SHADER_VERTEX]);
	glAttachShader(program,objects[SHADER_FRAGMENT]);

	SetDefaultAttributes();
}
Example #2
0
const NzUberShaderInstance* NzMaterial::GetShaderInstance(nzUInt32 flags) const
{
	if (!m_shaders[flags].uberInstance)
		GenerateShader(flags);

    return m_shaders[flags].uberInstance;
}
Example #3
0
const NzShader* NzMaterial::Apply(nzUInt32 shaderFlags, nzUInt8 textureUnit, nzUInt8* lastUsedUnit) const
{
	const ShaderInstance& instance = m_shaders[shaderFlags];
	if (!instance.uberInstance)
		GenerateShader(shaderFlags);

	instance.uberInstance->Activate();

	if (instance.uniforms[nzMaterialUniform_AlphaThreshold] != -1)
		instance.shader->SendFloat(instance.uniforms[nzMaterialUniform_AlphaThreshold], m_alphaThreshold);

	if (instance.uniforms[nzMaterialUniform_Ambient] != -1)
		instance.shader->SendColor(instance.uniforms[nzMaterialUniform_Ambient], m_ambientColor);

	if (instance.uniforms[nzMaterialUniform_Diffuse] != -1)
		instance.shader->SendColor(instance.uniforms[nzMaterialUniform_Diffuse], m_diffuseColor);

	if (instance.uniforms[nzMaterialUniform_Shininess] != -1)
		instance.shader->SendFloat(instance.uniforms[nzMaterialUniform_Shininess], m_shininess);

	if (instance.uniforms[nzMaterialUniform_Specular] != -1)
		instance.shader->SendColor(instance.uniforms[nzMaterialUniform_Specular], m_specularColor);

	if (m_alphaMap && instance.uniforms[nzMaterialUniform_AlphaMap] != -1)
	{
		NzRenderer::SetTexture(textureUnit, m_alphaMap);
		NzRenderer::SetTextureSampler(textureUnit, m_diffuseSampler);
		instance.shader->SendInteger(instance.uniforms[nzMaterialUniform_AlphaMap], textureUnit);
		textureUnit++;
	}

	if (m_diffuseMap && instance.uniforms[nzMaterialUniform_DiffuseMap] != -1)
	{
		NzRenderer::SetTexture(textureUnit, m_diffuseMap);
		NzRenderer::SetTextureSampler(textureUnit, m_diffuseSampler);
		instance.shader->SendInteger(instance.uniforms[nzMaterialUniform_DiffuseMap], textureUnit);
		textureUnit++;
	}

	if (m_emissiveMap && instance.uniforms[nzMaterialUniform_EmissiveMap] != -1)
	{
		NzRenderer::SetTexture(textureUnit, m_emissiveMap);
		NzRenderer::SetTextureSampler(textureUnit, m_diffuseSampler);
		instance.shader->SendInteger(instance.uniforms[nzMaterialUniform_EmissiveMap], textureUnit);
		textureUnit++;
	}

	if (m_heightMap && instance.uniforms[nzMaterialUniform_HeightMap] != -1)
	{
		NzRenderer::SetTexture(textureUnit, m_heightMap);
		NzRenderer::SetTextureSampler(textureUnit, m_diffuseSampler);
		instance.shader->SendInteger(instance.uniforms[nzMaterialUniform_HeightMap], textureUnit);
		textureUnit++;
	}

	if (m_normalMap && instance.uniforms[nzMaterialUniform_NormalMap] != -1)
	{
		NzRenderer::SetTexture(textureUnit, m_normalMap);
		NzRenderer::SetTextureSampler(textureUnit, m_diffuseSampler);
		instance.shader->SendInteger(instance.uniforms[nzMaterialUniform_NormalMap], textureUnit);
		textureUnit++;
	}

	if (m_specularMap && instance.uniforms[nzMaterialUniform_SpecularMap] != -1)
	{
		NzRenderer::SetTexture(textureUnit, m_specularMap);
		NzRenderer::SetTextureSampler(textureUnit, m_specularSampler);
		instance.shader->SendInteger(instance.uniforms[nzMaterialUniform_SpecularMap], textureUnit);
		textureUnit++;
	}

	NzRenderer::SetRenderStates(m_states);

	if (lastUsedUnit)
		*lastUsedUnit = textureUnit;

	return instance.shader;
}