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; }