private void FinishMaterial(BatchInfo material)
{
//DrawTechnique tech = material.Technique.Res;
this.SetupBlendType(BlendMode.Reset);
NativeShaderProgram.Bind(null);
NativeTexture.ResetBinding(this.sharedSamplerBindings);
}
/// <summary>
/// Applies the specified parameter values to all currently active shaders.
/// </summary>
/// <param name="sharedParams"></param>
/// <seealso cref="RetrieveActiveShaders"/>
private void SetupSharedParameters(ShaderParameterCollection sharedParams)
{
this.sharedSamplerBindings = 0;
this.sharedShaderParameters.Clear();
if (sharedParams == null)
{
return;
}
foreach (NativeShaderProgram shader in this.activeShaders)
{
NativeShaderProgram.Bind(shader);
ShaderFieldInfo[] varInfo = shader.Fields;
int[] locations = shader.FieldLocations;
// Setup shared sampler bindings and uniform data
for (int i = 0; i < varInfo.Length; i++)
{
ref ShaderFieldInfo field = ref varInfo[i];
if (field.Scope == ShaderFieldScope.Attribute)
{
continue;
}
if (field.Type == ShaderFieldType.Sampler2D)
{
ContentRef <Texture> texRef;
if (!sharedParams.TryGetInternal(field.Name, out texRef))
{
continue;
}
NativeTexture.Bind(texRef, this.sharedSamplerBindings);
GL.Uniform1(locations[i], this.sharedSamplerBindings);
this.sharedSamplerBindings++;
}
else
{
float[] data;
if (!sharedParams.TryGetInternal(field.Name, out data))
{
continue;
}
NativeShaderProgram.SetUniform(ref field, locations[i], data);
}
this.sharedShaderParameters.Add(field.Name);
}
}
public static void Bind(NativeShaderProgram prog)
{
if (curBound == prog)
{
return;
}
if (prog == null)
{
GL.UseProgram(0);
curBound = null;
}
else
{
GL.UseProgram(prog.Handle);
curBound = prog;
}
}
private void FinishVertexFormat(BatchInfo material, VertexDeclaration vertexDeclaration)
{
DrawTechnique technique = material.Technique.Res ?? DrawTechnique.Solid.Res;
NativeShaderProgram program = (technique.Shader.Res != null ? technique.Shader.Res.Native : null) as NativeShaderProgram;
VertexElement[] elements = vertexDeclaration.Elements;
for (int elementIndex = 0; elementIndex < elements.Length; elementIndex++)
{
switch (elements[elementIndex].Role)
{
case VertexElementRole.Position:
{
GL.DisableClientState(ArrayCap.VertexArray);
break;
}
case VertexElementRole.TexCoord:
{
GL.DisableClientState(ArrayCap.TextureCoordArray);
break;
}
case VertexElementRole.Color:
{
GL.DisableClientState(ArrayCap.ColorArray);
break;
}
default:
{
if (program != null)
{
ShaderFieldInfo[] varInfo = program.Fields;
int[] locations = program.FieldLocations;
int selectedVar = -1;
for (int varIndex = 0; varIndex < varInfo.Length; varIndex++)
{
if (locations[varIndex] == -1)
{
continue;
}
if (!ShaderVarMatches(
ref varInfo[varIndex],
elements[elementIndex].Type,
elements[elementIndex].Count))
{
continue;
}
selectedVar = varIndex;
break;
}
if (selectedVar == -1)
{
break;
}
GL.DisableVertexAttribArray(locations[selectedVar]);
}
break;
}
}
}
}
private void SetupMaterial(BatchInfo material, BatchInfo lastMaterial)
{
DrawTechnique tech = material.Technique.Res ?? DrawTechnique.Solid.Res;
DrawTechnique lastTech = lastMaterial != null ? lastMaterial.Technique.Res : null;
// Setup BlendType
if (lastTech == null || tech.Blending != lastTech.Blending)
{
this.SetupBlendType(tech.Blending, this.currentDevice.DepthWrite);
}
// Bind Shader
ShaderProgram shader = tech.Shader.Res ?? ShaderProgram.Minimal.Res;
NativeShaderProgram nativeShader = shader.Native as NativeShaderProgram;
NativeShaderProgram.Bind(nativeShader);
// Setup shader data
ShaderFieldInfo[] varInfo = nativeShader.Fields;
int[] locations = nativeShader.FieldLocations;
// Setup sampler bindings
int curSamplerIndex = this.sharedSamplerBindings;
for (int i = 0; i < varInfo.Length; i++)
{
if (locations[i] == -1)
{
continue;
}
if (varInfo[i].Type != ShaderFieldType.Sampler2D)
{
continue;
}
if (this.sharedShaderParameters.Contains(varInfo[i].Name))
{
continue;
}
ContentRef <Texture> texRef = material.GetInternalTexture(varInfo[i].Name);
NativeTexture.Bind(texRef, curSamplerIndex);
GL.Uniform1(locations[i], curSamplerIndex);
curSamplerIndex++;
}
NativeTexture.ResetBinding(curSamplerIndex);
// Setup uniform data
for (int i = 0; i < varInfo.Length; i++)
{
if (locations[i] == -1)
{
continue;
}
if (varInfo[i].Type == ShaderFieldType.Sampler2D)
{
continue;
}
if (this.sharedShaderParameters.Contains(varInfo[i].Name))
{
continue;
}
float[] data = material.GetInternalData(varInfo[i].Name);
if (data == null)
{
continue;
}
NativeShaderProgram.SetUniform(ref varInfo[i], locations[i], data);
}
}
private void SetupVertexFormat(BatchInfo material, VertexDeclaration vertexDeclaration)
{
DrawTechnique technique = material.Technique.Res ?? DrawTechnique.Solid.Res;
NativeShaderProgram program = (technique.Shader.Res != null ? technique.Shader.Res.Native : null) as NativeShaderProgram;
VertexElement[] elements = vertexDeclaration.Elements;
for (int elementIndex = 0; elementIndex < elements.Length; elementIndex++)
{
switch (elements[elementIndex].Role)
{
case VertexElementRole.Position:
{
GL.EnableClientState(ArrayCap.VertexArray);
GL.VertexPointer(
elements[elementIndex].Count,
VertexPointerType.Float,
vertexDeclaration.Size,
elements[elementIndex].Offset);
break;
}
case VertexElementRole.TexCoord:
{
GL.EnableClientState(ArrayCap.TextureCoordArray);
GL.TexCoordPointer(
elements[elementIndex].Count,
TexCoordPointerType.Float,
vertexDeclaration.Size,
elements[elementIndex].Offset);
break;
}
case VertexElementRole.Color:
{
ColorPointerType attribType;
switch (elements[elementIndex].Type)
{
default:
case VertexElementType.Float: attribType = ColorPointerType.Float; break;
case VertexElementType.Byte: attribType = ColorPointerType.UnsignedByte; break;
}
GL.EnableClientState(ArrayCap.ColorArray);
GL.ColorPointer(
elements[elementIndex].Count,
attribType,
vertexDeclaration.Size,
elements[elementIndex].Offset);
break;
}
default:
{
if (program != null)
{
ShaderFieldInfo[] varInfo = program.Fields;
int[] locations = program.FieldLocations;
int selectedVar = -1;
for (int varIndex = 0; varIndex < varInfo.Length; varIndex++)
{
if (locations[varIndex] == -1)
{
continue;
}
if (!ShaderVarMatches(
ref varInfo[varIndex],
elements[elementIndex].Type,
elements[elementIndex].Count))
{
continue;
}
selectedVar = varIndex;
break;
}
if (selectedVar == -1)
{
break;
}
VertexAttribPointerType attribType;
switch (elements[elementIndex].Type)
{
default:
case VertexElementType.Float: attribType = VertexAttribPointerType.Float; break;
case VertexElementType.Byte: attribType = VertexAttribPointerType.UnsignedByte; break;
}
GL.EnableVertexAttribArray(locations[selectedVar]);
GL.VertexAttribPointer(
locations[selectedVar],
elements[elementIndex].Count,
attribType,
false,
vertexDeclaration.Size,
elements[elementIndex].Offset);
}
break;
}
}
}
}
