public void SetArrayData(ShaderProgram shader
, ShaderUniformName arrayName
, ShaderUniformName dataName
, IShaderDataOwner provider
, int index)
{
foreach (ShaderUniform uni in shader.uniforms)
{
if (uni.name == dataName && uni.arrayName == arrayName && uni.arrayIndex == index)
{
bool set = provider.SetUniform(shader, uni.location, uni.name);
if (!set)
{
Logger.LogError(Logger.ErrorState.Critical, "ShaderUniformManager.SetArrayData. Provider does not have "
+ GetUniformName(arrayName) + "." + GetUniformName(dataName));
}
return;
}
}
Logger.LogError(Logger.ErrorState.Critical, "ShaderUniformManager.SetArrayData. Shader " + shader.programName + " does not use data: "
+ GetUniformName(arrayName) + "[" + index + "]." + GetUniformName(dataName));
foreach (ShaderUniform uni in shader.uniforms)
{
if (uni.arrayIndex != -1)
{
Logger.LogInfo(shader.programName + " uses "
+ GetUniformName(uni.arrayName) + "[" + uni.arrayIndex + "]." + GetUniformName(uni.name));
}
}
}
public void SetGlobalUniform(ShaderUniformName name, Vector4 value)
{
foreach (var @container in Containers.Values)
{
@container.SetGlobalUniform(name, value);
}
}
public int GetTextureUnitForMap(ShaderUniformName uniform)
{
int textureUnit = -1;
if (uniform == ShaderUniformName.DiffuseMap)
{
textureUnit = 0;
}
else if (uniform == ShaderUniformName.IlluminationMap)
{
textureUnit = 1;
}
else if (uniform == ShaderUniformName.NormalMap)
{
textureUnit = 2;
}
else if (uniform == ShaderUniformName.RoughnessMap)
{
textureUnit = 3;
}
else if (uniform == ShaderUniformName.MetallicMap)
{
textureUnit = 4;
}
else if (uniform == ShaderUniformName.HeightMap)
{
textureUnit = 5;
}
else if (uniform == ShaderUniformName.CubeMap)
{
textureUnit = 6;
}
return(textureUnit);
}
public bool DoesShaderSupportArrayUniform(ShaderProgram program, ShaderUniformName arrayUniformName)
{
foreach (ShaderUniform uni in program.uniforms)
{
if (uni.arrayName == arrayUniformName)
{
return(true);
}
}
return(false);
}
public bool DoesShaderSupportUniform(ShaderProgram program, ShaderUniformName uniform)
{
foreach (ShaderUniform uni in program.uniforms)
{
if (uni.name == uniform)
{
return(true);
}
}
return(false);
}
public ShaderUniform(ShaderUniformName nameParam, ShaderDataType dataTypeParam
, int locationParam = -1
, ShaderUniformName arrayNameParam = ShaderUniformName.InvalidUniformName
, int arrayIndexParam = -1)
{
name = nameParam;
dataType = dataTypeParam;
location = locationParam;
arrayName = arrayNameParam;
arrayIndex = arrayIndexParam;
}
public void SetFloatUniform(ShaderUniformName uniformName, float value)
{
foreach (ShaderUniform u in uniforms)
{
if (u.name == uniformName)
{
SetFloatUniform(u.location, value);
break;
}
}
}
public TextureMap GetMap(ShaderUniformName uniformName)
{
if (textureMaps.ContainsKey(uniformName))
{
return(textureMaps[uniformName]);
}
else
{
Logger.LogError(Logger.ErrorState.Limited, "Material " + materialName + " does not have a map for " + ShaderUniformManager.GetSingleton().GetUniformName(uniformName) + "");
return(MaterialManager.GetSingleton().GetDefaultMap(uniformName));
}
}
public void SetData(ShaderProgram shader
, ShaderUniformName dataName
, IShaderDataOwner provider)
{
bool set = TrySetData(shader, dataName, provider);
if (!set)
{
Logger.LogError(Logger.ErrorState.Unoptimal, "ShaderUniformManager.SetData. Shader " + shader.programName + " does not use "
+ GetUniformName(dataName));
}
}
public int GetDataLocation(ShaderProgram shader
, ShaderUniformName dataName)
{
foreach (ShaderUniform uni in shader.uniforms)
{
if (uni.name == dataName)
{
return(uni.location);
}
}
return(GetInvalidDataLocation());
}
public TextureMap GetDefaultMap(ShaderUniformName uniformName)
{
if (defaultMaterial.textureMaps.ContainsKey(uniformName))
{
return(defaultMaterial.textureMaps[uniformName]);
}
else
{
Logger.LogError(Logger.ErrorState.Critical, "MaterialManager's default material does not have map for " + ShaderUniformManager.GetSingleton().GetUniformName(uniformName));
return(null);
}
}
public void SetFromMaterialToShader(Material mat, ShaderUniformName uniform, ShaderProgram program)
{
ShaderUniformManager man = ShaderUniformManager.GetSingleton();
if (man.DoesShaderSupportUniform(program, uniform))
{
int location = man.GetDataLocation(program, uniform);
if (mat.textureMaps.ContainsKey(uniform))
{
SetTextureUniform(program, location, uniform, mat.textureMaps[uniform]);
}
}
}
public int GetUniformLocation(ShaderUniformName uniformName)
{
foreach (ShaderUniform a in uniforms)
{
if (a.name == uniformName)
{
return(a.location);
}
}
ShaderUniformManager uniMan = ShaderUniformManager.GetSingleton();
Logger.LogError(Logger.ErrorState.Limited, "Uniform " + uniMan.GetUniformName(uniformName) + " location not found in shader program " + programName);
return(-1);
}
// Sets all materials that apply
public void SetMaterialToShader(Material meshMaterial, ShaderProgram program)
{
if (program == null)
{
Logger.LogError(Logger.ErrorState.Limited, "MaterialManager> No program given, cannot set material");
return;
}
if (meshMaterial == null)
{
SetMaterialToShader(defaultMaterial, program);
return;
}
ShaderUniformManager man = ShaderUniformManager.GetSingleton();
// Must try each supported texture uniform
foreach (KeyValuePair <ShaderUniformName, TextureMap> entry in defaultMaterial.textureMaps)
{
ShaderUniformName uniform = entry.Key;
if (!man.DoesShaderSupportUniform(program, uniform))
{
continue;
}
int location = man.GetDataLocation(program, uniform);
if (location == ShaderUniformManager.GetInvalidDataLocation())
{
Logger.LogError(Logger.ErrorState.Limited, "MaterialManager: Shader says to support texture map " + man.GetUniformName(uniform) + " but there is no location for it");
continue;
}
// IMPORTANT PART !
if (meshMaterial.textureMaps.ContainsKey(uniform))
{
SetTextureUniform(program, location, uniform, meshMaterial.textureMaps[uniform]);
}
else
{
if (defaultMaterial.textureMaps.ContainsKey(uniform))
{
SetTextureUniform(program, location, uniform, defaultMaterial.textureMaps[uniform]);
}
else
{
Logger.LogError(Logger.ErrorState.Limited, "MaterialManager: Shader wants a texture map " + man.GetUniformName(uniform) + " that is not in default material");
}
}
}
}
public void SetTextureUniform(ShaderProgram shaderProgram, int location, ShaderUniformName uniform, TextureMap map)
{
int textureUnit = GetTextureUnitForMap(uniform);
if (uniform == ShaderUniformName.DiffuseMap)
{
GL.ActiveTexture(TextureUnit.Texture0);
}
else if (uniform == ShaderUniformName.IlluminationMap)
{
GL.ActiveTexture(TextureUnit.Texture1);
}
else if (uniform == ShaderUniformName.NormalMap)
{
GL.ActiveTexture(TextureUnit.Texture2);
}
else if (uniform == ShaderUniformName.RoughnessMap)
{
GL.ActiveTexture(TextureUnit.Texture3);
}
else if (uniform == ShaderUniformName.MetallicMap)
{
GL.ActiveTexture(TextureUnit.Texture4);
}
else if (uniform == ShaderUniformName.HeightMap)
{
GL.ActiveTexture(TextureUnit.Texture5);
}
else if (uniform == ShaderUniformName.CubeMap)
{
GL.ActiveTexture(TextureUnit.Texture6);
}
if (textureUnit == -1)
{
Logger.LogError(Logger.ErrorState.Limited, "No defined texture unit for uniform " + ShaderUniformManager.GetSingleton().GetUniformName(uniform) + ", cannot bind");
}
if (uniform == ShaderUniformName.CubeMap)
{
GL.BindTexture(TextureTarget.TextureCubeMap, map.textureGLIndex);
}
else
{
GL.BindTexture(TextureTarget.Texture2D, map.textureGLIndex);
}
shaderProgram.SetSamplerUniform(location, textureUnit);
}
public bool SetUniform(ShaderProgram program, int location, ShaderUniformName name)
{
switch (name)
{
case ShaderUniformName.WorldMatrix:
if (Transform != null)
{
Transform.UpdateWorldMatrix();
Transform.worldMatrix.SetToShader(program, location);
}
break;
default:
return(false);
}
return(true);
}
public bool SetUniform(ShaderProgram program, int location, ShaderUniformName name)
{
switch (name)
{
case ShaderUniformName.DiffuseColor:
program.SetVec3Uniform(location, light.color);
break;
case ShaderUniformName.Alpha:
program.SetFloatUniform(location, 1.0f);
break;
default:
return(false);
}
return(true);
}
public string GetUniformName(ShaderUniformName name)
{
switch (name)
{
case ShaderUniformName.ViewMatrix: return("uViewMatrix");
case ShaderUniformName.ProjectionMatrix: return("uProjectionMatrix");
case ShaderUniformName.WorldMatrix: return("uWorldMatrix");
case ShaderUniformName.SkyboxRotationMatrix: return("uSkyboxRotationMatrix");
case ShaderUniformName.CameraPosition: return("uCameraPosition");
case ShaderUniformName.LightsArray: return("uLights");
case ShaderUniformName.LightPositionOrDirection: return("positionDirection");
case ShaderUniformName.LightColor: return("color");
case ShaderUniformName.LinearAttenuation: return("linearAttenuation");
case ShaderUniformName.QuadraticAttenuation: return("quadraticAttenuation");
case ShaderUniformName.Alpha: return("uAlpha");
case ShaderUniformName.DiffuseColor: return("uDiffuseColor");
case ShaderUniformName.DiffuseMap: return("uDiffuseMap");
case ShaderUniformName.NormalMap: return("uNormalMap");
case ShaderUniformName.IlluminationMap: return("uIlluminationMap");
case ShaderUniformName.RoughnessMap: return("uRoughnessMap");
case ShaderUniformName.HeightMap: return("uHeightMap");
case ShaderUniformName.MetallicMap: return("uMetallicMap");
case ShaderUniformName.CubeMap: return("uCubeMap");
default: return(string.Empty);
}
}
public bool TrySetData(ShaderProgram shader
, ShaderUniformName dataName
, IShaderDataOwner provider)
{
bool set = false;
foreach (ShaderUniform uni in shader.uniforms)
{
if (uni.name == dataName)
{
set = provider.SetUniform(shader, uni.location, uni.name);
if (!set)
{
Logger.LogError(Logger.ErrorState.Critical, "ShaderUniformManager.SetData. Provider does not have "
+ GetUniformName(dataName));
}
break;
}
}
return(set);
}
public bool SetUniform(ShaderProgram program, int location, ShaderUniformName name)
{
switch (name)
{
case ShaderUniformName.ViewMatrix:
viewMatrix.Matrix = GetViewMatrix();
viewMatrix.SetToShader(program, location);
break;
case ShaderUniformName.ProjectionMatrix:
projectionMatrix.SetToShader(program, location);
break;
case ShaderUniformName.CameraPosition:
program.SetVec3Uniform(location, Position);
break;
default:
return(false);
}
return(true);
}
public bool SetUniform(ShaderProgram shaderProgram, int location, ShaderUniformName dataName)
{
switch (dataName)
{
case ShaderUniformName.LightPositionOrDirection:
shaderProgram.SetVec3Uniform(location, GetPosDir());
break;
case ShaderUniformName.LightColor: shaderProgram.SetVec3Uniform(location, color);
break;
case ShaderUniformName.LinearAttenuation:
shaderProgram.SetFloatUniform(location, linearAttenuation);
break;
case ShaderUniformName.QuadraticAttenuation:
shaderProgram.SetFloatUniform(location, quadraticAttenuation);
break;
default:
return(false);
}
return(true);
}
public void SetGlobalUniform(ShaderUniformName name, Vector4 value)
{
ForeachObject(aGrassPack => aGrassPack.MyBlock.AddGlobalUniform(name.ToString(), value));
}
public void AddUniform(ShaderUniformName name, float value)
{
_floatUniforms.RemoveAll(x => x.Name.Equals(name.ToString()));
_floatUniforms.Add(new ShaderUniform <float>(name, value));
}
public void AddUniform(ShaderUniformName name, Vector4 value)
{
_vector4Uniforms.RemoveAll(x => x.Name.Equals(name.ToString()));
_vector4Uniforms.Add(new ShaderUniform <Vector4>(name, value));
}
public void AddUniform(ShaderUniformName name, Color value)
{
AddUniform(name, new Vector4(value.r, value.b, value.g, value.a));
}
public void SetGlobalUniform(ShaderUniformName name, Vector4 value)
{
ForeachObject((aObject) => aObject.GetComponent <Renderer>().material.SetVector(name.ToString(), value));
}
private void AddSupportedUniform(ShaderUniformName name, ShaderDataType type)
{
supportedUniforms.Add(GetUniformName(name), new ShaderUniform(name, type));
}
public Matrix4Uniform(ShaderUniformName nameParam)
{
name = nameParam;
matrix = Matrix4.Identity;
}
