private void SetLightUniforms(UniformBlock block)
{
Matrix4 lightMatrix = Matrix4.Identity;
Matrix4 cloudProjMatrix = Matrix4.Identity;
for (int i = 0; i < 4; i++)
{
block.Add(lightMatrix.Column0);
block.Add(lightMatrix.Column1);
block.Add(lightMatrix.Column2);
block.Add(lightMatrix.Column3);
}
block.Add(new Vector4(1));
//Cloud proj mtx
block.Add(cloudProjMatrix.Column0);
block.Add(cloudProjMatrix.Column1);
block.Add(cloudProjMatrix.Column2);
block.Add(cloudProjMatrix.Column3);
//Depth shadow pow
block.Add(1);
block.Add(1);
block.Add(1);
block.Add(1);
block.Add(new Vector4(1));
//light pre pass param
block.Add(new Vector4(1));
}
private void SetSceneMatUniforms(UniformBlock block)
{
float light_intensity = 1.0f; //Multipled by light scale param (fp_c7_data[2].y)
//Note alpha for colors also are intensity factors
Vector4 shadow_color = new Vector4(0, 0, 0, 1);
Vector4 ao_color = new Vector4(0, 0, 0, 1);
Vector4 lighting = new Vector4(1.0f, light_intensity, 1.0f, 1.0f);
Vector4 lighting_specular = new Vector4(1, 0.9f, 1, 1);
Vector4 light_prepass_param = new Vector4(1, 1, 0, 1);
Vector4 exposure = new Vector4(1);
block.Buffer.Clear();
block.Add(shadow_color);
block.Add(ao_color);
block.Add(lighting);
block.Add(lighting_specular);
block.Add(light_prepass_param);
block.Add(exposure);
if (block.Buffer.Count != 96)
{
throw new Exception("Invalid gsys_scene_material size");
}
}
private void FindUniformBlocks()
{
int count;
GL.GetProgram(ProgramID, GetProgramParameterName.ActiveUniformBlocks, out count);
for (int i = 0; i < count; i++)
{
int length;
StringBuilder nameBuilder = new StringBuilder(255);
GL.GetActiveUniformBlockName(ProgramID, i, 255, out length, nameBuilder);
string name = nameBuilder.ToString(0, length);
int location = GL.GetUniformBlockIndex(ProgramID, name);
int size;
GL.GetActiveUniformBlock(ProgramID, i, ActiveUniformBlockParameter.UniformBlockDataSize, out size);
uniformBlocks[name] = new UniformBlock()
{
Size = size,
Name = name,
Index = location,
};
}
}
/// <summary>
/// A helper method to set a common skeleton bone block layout.
/// Note not all games use the same skeleton bone block data!
/// </summary>
public virtual void SetBoneMatrixBlock(STSkeleton skeleton, bool useInverse, UniformBlock block, int maxTransforms = 170)
{
block.Buffer.Clear();
//Fixed buffer of max amount of transform values
for (int i = 0; i < maxTransforms; i++)
{
Matrix4 value = Matrix4.Zero;
//Set the inverse matrix and load the matrix data into 3 vec4s
if (i < skeleton.Bones.Count)
{
//Check if the bone is smooth skinning aswell for accuracy purposes.
if (useInverse || ((BfresBone)skeleton.Bones[i]).UseSmoothMatrix) //Use inverse transforms for smooth skinning
{
value = skeleton.Bones[i].Inverse * skeleton.Bones[i].Transform;
}
else
{
value = skeleton.Bones[i].Transform;
}
}
block.Add(value.Column0);
block.Add(value.Column1);
block.Add(value.Column2);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GLRectangle"/> class.
/// </summary>
/// <param name="dimensions">The size and location of this object.</param>
/// <param name="name">The name of this particular object.</param>
public GLRectangle(RectangleF dimensions, string name)
{
this.Name = name;
Vertex[] vertices =
{
new Vertex(new Vec3(dimensions.Right, dimensions.Bottom, 0.0f)),
new Vertex(new Vec3(dimensions.Right, dimensions.Top, 0.0f)),
new Vertex(new Vec3(dimensions.Left, dimensions.Top, 0.0f)),
new Vertex(new Vec3(dimensions.Left, dimensions.Bottom, 0.0f))
};
short[] indices =
{
0, 1, 3, // first Triangle
1, 2, 3 // second Triangle
};
Shader tri1_vertexShader = Shader.LoadVertexShader(@"Shader\Source\moreShaders.vert.glsl");
Shader tri1_fragmentShader = Shader.LoadFragmentShader(@"Shader\Source\moreShaders.frag.glsl");
this.LoadObjectData(vertices, indices, new List <Shader>()
{
tri1_vertexShader, tri1_fragmentShader
});
this.Uniforms.Add(new UniformVec3(Vec3.None, "ourColor", this.ShaderProgram));
UniformBlock cameraBlock = new UniformBlock(Camera.GlobalUBO, this.ShaderProgram);
}
public void UploadUBOdata(CameraData camera, UniformBlock ubo, int lightIndex)
{
ubo.light.color = this.Color;
if (LighType == LightType.Directional)
{
ubo.light.position = Vector3.Zero;
}
else
{
ubo.light.position = camera.ViewPointPosition.Towards(this.Entity.Transform.Position).ToVector3();
}
if (LighType == LightType.Point)
{
ubo.light.direction = Vector3.Zero;
}
else
{
ubo.light.direction = this.Entity.Transform.Forward.Normalized();
}
ubo.light.spotExponent = this.SpotExponent;
ubo.light.spotCutOff = this.SpotCutOff;
ubo.light.hasShadows = HasShadows ? 1 : 0;
ubo.light.lightIndex = lightIndex;
ubo.lightUBO.UploadToGPU();
}
public void SetBoneMatrixBlock(STSkeleton skeleton, bool useInverse, UniformBlock block, int maxTransforms = 64)
{
block.Buffer.Clear();
//Fixed buffer of max amount of transform values
for (int i = 0; i < maxTransforms; i++)
{
Matrix4 value = Matrix4.Zero;
//Set the inverse matrix and load the matrix data into 3 vec4s
if (i < skeleton.Bones.Count)
{
if (useInverse) //Use inverse transforms for smooth skinning
{
value = skeleton.Bones[i].Inverse * skeleton.Bones[i].Transform;
}
else
{
value = skeleton.Bones[i].Transform;
}
}
block.Add(value.Column0);
block.Add(value.Column1);
block.Add(value.Column2);
}
}
private void SetParamAsVec4Debug(UniformBlock uniformBlock, MatlEnums.ParamId paramId)
{
// Convert parameters into colors for easier visualization.
var name = "vec4Param";
if (vec4ByParamId.ContainsKey(paramId))
{
var value = vec4ByParamId[paramId];
uniformBlock.SetValue(name, value);
}
else if (boolByParamId.ContainsKey(paramId))
{
var value = boolByParamId[paramId];
if (value)
{
uniformBlock.SetValue(name, new Vector4(1, 0, 1, 0));
}
else
{
uniformBlock.SetValue(name, new Vector4(0, 0, 1, 0));
}
}
else if (floatByParamId.ContainsKey(paramId))
{
var value = floatByParamId[paramId];
uniformBlock.SetValue(name, new Vector4(value, value, value, 0));
}
else
{
uniformBlock.SetValue(name, Vector4.Zero);
}
}
/// <summary>
/// A helper method to set a material option block layout.
/// </summary>
public virtual void SetMaterialOptionsBlock(FMAT mat, UniformBlock block)
{
var uniformBlock = ShaderModel.UniformBlocks.Values.FirstOrDefault(
x => x.Type == (BfshaLibrary.UniformBlock.BlockType) 4);
//Fill the buffer by program offsets
var mem = new System.IO.MemoryStream();
using (var writer = new Toolbox.Core.IO.FileWriter(mem))
{
writer.SeekBegin(0);
int index = 0;
foreach (var param in uniformBlock.Uniforms.Values)
{
var uniformName = uniformBlock.Uniforms.GetKey(index++);
writer.SeekBegin(param.Offset - 1);
if (mat.ShaderOptions.ContainsKey(uniformName))
{
var option = mat.ShaderOptions[uniformName];
int value = int.Parse(option);
writer.Write(value);
}
}
}
block.Buffer.Clear();
block.Buffer.AddRange(mem.ToArray());
}
public static void SetMaterialPropertyUniforms(UniformBlock uniformBlock, Shader shader, Nud.Material mat)
{
// Skip expensive buffer updates for redundant value updates.
if (mat.ShouldUpdateRendering)
{
foreach (var property in defaultValueByProperty)
{
MatPropertyShaderUniform(uniformBlock, mat, property.Key, property.Value);
}
mat.ShouldUpdateRendering = false;
}
// Always bind the uniform block because each polygon has its own uniform block.
uniformBlock.BindBlock(shader, "MaterialProperties");
// Create some conditionals rather than using different shaders.
var genericMaterial = new GenericMaterial();
HasMatPropertyShaderUniform(genericMaterial, mat, "NU_softLightingParams", "hasSoftLight");
HasMatPropertyShaderUniform(genericMaterial, mat, "NU_customSoftLightParams", "hasCustomSoftLight");
HasMatPropertyShaderUniform(genericMaterial, mat, "NU_specularParams", "hasSpecularParams");
HasMatPropertyShaderUniform(genericMaterial, mat, "NU_dualNormalScrollParams", "hasDualNormal");
HasMatPropertyShaderUniform(genericMaterial, mat, "NU_normalSamplerAUV", "hasNrmSamplerAUV");
HasMatPropertyShaderUniform(genericMaterial, mat, "NU_normalSamplerBUV", "hasNrmSamplerBUV");
HasMatPropertyShaderUniform(genericMaterial, mat, "NU_finalColorGain", "hasFinalColorGain");
HasMatPropertyShaderUniform(genericMaterial, mat, "NU_effUniverseParam", "hasUniverseParam");
genericMaterial.SetShaderUniforms(shader);
}
private void SetVectors(UniformBlock uniformBlock)
{
// Use a 16 byte type to avoid alignment issues.
var customVectors = new Vector4[64];
customVectors[3] = Vector4.One;
customVectors[6] = new Vector4(1, 1, 0, 0);
customVectors[8] = Vector4.One;
customVectors[13] = Vector4.One;
customVectors[18] = Vector4.One;
customVectors[31] = new Vector4(1, 1, 0, 0);
customVectors[32] = new Vector4(1, 1, 0, 0);
// Set values from the material.
foreach (var param in vec4ByParamId)
{
customVectors[param.Key.ToVectorIndex()] = param.Value;
}
// Override the defaults or material values with animation data.
foreach (var param in Vec4ParamsMaterialAnimation)
{
customVectors[param.Key.ToVectorIndex()] = param.Value;
}
uniformBlock.SetValues("CustomVector", customVectors);
}
static void SetupBlocks(out byte[] shBlock, out byte[] infoBlock)
{
var mem = new MemoryStream();
var mem2 = new MemoryStream();
numDraw = 0;
using (var writer2 = new FileWriter(mem2))
using (var writer = new FileWriter(mem))
{
for (int i = 0; i < ProbeInstances.Count; i++)
{
if (!ProbeInstances[i].isVisible)
{
continue;
}
if (numDraw > MAX_DRAW)
{
break;
}
writer2.Write(new Vector4(ProbeInstances[i].Position, ProbeInstances[i].Size));
writer.Write(ProbeInstances[i].SHData);
writer.Write(0);
numDraw++;
}
}
shBlock = mem.ToArray();
infoBlock = mem2.ToArray();
}
public void SetMaterialUniforms(Shader shader, Material previousMaterial)
{
// TODO: This code could be moved to the constructor.
if (genericMaterial == null || shouldUpdateTextures)
{
genericMaterial = CreateGenericMaterial();
shouldUpdateTextures = true;
}
if (uniformBlock == null)
{
uniformBlock = new UniformBlock(shader, "MaterialParams")
{
BlockBinding = 1
};
SetMaterialParams(uniformBlock);
}
if (shouldUpdateUniformBlock)
{
SetMaterialParams(uniformBlock);
shouldUpdateUniformBlock = false;
}
// This needs to be updated more than once.
AddDebugParams(uniformBlock);
// Update the uniform values.
genericMaterial.SetShaderUniforms(shader, previousMaterial?.genericMaterial);
uniformBlock.BindBlock(shader);
}
static void LoadUniforms(int programID, Vector4[] shData)
{
UniformBlock paramBlock = GetBlock("paramBlock");
paramBlock.Buffer.Clear();
//Variables from the sharcfb binaries
paramBlock.Add(new Vector4(LightmapWeight[0], 0, 0, 0));
paramBlock.Add(new Vector4(LightmapWeight[1], 0, 0, 0));
paramBlock.Add(new Vector4(LightmapArrayIndex[0], 0, 0, 0));
paramBlock.Add(new Vector4(LightmapArrayIndex[1], 0, 0, 0));
paramBlock.Add(new Vector4(SHWeight[0], 0, 0, 0));
paramBlock.RenderBuffer(programID, "cbuf_block3");
UniformBlock dataBlock = GetBlock("shBlock");
dataBlock.Buffer.Clear();
dataBlock.Add(shData[0]);
dataBlock.Add(shData[1]);
dataBlock.Add(shData[2]);
dataBlock.Add(shData[3]);
dataBlock.Add(shData[4]);
dataBlock.Add(shData[5]);
dataBlock.Add(shData[6]);
dataBlock.RenderBuffer(programID, "cbuf_block4");
}
private void SetEnvUniforms(GLContext control, UniformBlock block)
{
Fog[] fog = new Fog[4];
for (int i = 0; i < 4; i++)
{
fog[i] = new Fog();
}
fog[0] = new Fog()
{
Start = 1000000,
End = 1000000,
Color = new Vector4(1, 0, 0, 1),
Direciton = new Vector3(0, 1, 0),
};
if (AreaIndex != -1 && control.EnableFog)
{
var courseArea = LightingEngine.LightSettings.Resources.EnvFiles["course_area.baglenv"];
var areaFog = courseArea.GetAreaFog(false, AreaIndex);
if (areaFog != null && areaFog.Enable)
{
var color = areaFog.Color.ToColorF();
fog[0] = new Fog()
{
Start = areaFog.Start,
End = areaFog.End,
Color = new Vector4(color.X, color.Y, color.Z, color.W),
Direciton = new Vector3(
areaFog.Direction.X,
areaFog.Direction.Y,
areaFog.Direction.Z),
};
}
}
var mem = new MemoryStream();
using (var writer = new Toolbox.Core.IO.FileWriter(mem))
{
writer.SeekBegin(10 * 16);
for (int i = 0; i < 1; i++)
{
writer.Write(fog[i].Color);
writer.Write(fog[i].Direciton);
writer.Write(fog[i].StartC);
writer.Write(fog[i].EndC);
}
float amount = 0.1f;
writer.Write(new Vector4(1, 0, 0, amount));
writer.Write(new Vector3(0.6771527f, -0.4863142f, 131.3442f));
}
block.Buffer.Clear();
block.Add(mem.ToArray());
}
public void AddBlock(UniformBlock block)
{
block.Add(shadow_color);
block.Add(ao_color);
block.Add(lighting);
block.Add(lighting_specular);
block.Add(light_prepass_param);
block.Add(exposure);
}
public RModel()
{
var shader = ShaderContainer.GetShader("RModel");
if (shader.LinkStatusIsOk)
{
boneUniformBuffer = new UniformBlock(shader, "Bones");
}
}
private void SetViewportUniforms(Camera camera, UniformBlock block)
{
Matrix4 mdlMat = camera.ModelMatrix;
var viewMatrix = camera.ViewMatrix;
var projMatrix = camera.ProjectionMatrix;
var viewProjMatrix = mdlMat * viewMatrix * projMatrix;
Vector4[] cView = new Vector4[3]
{
viewMatrix.Column0,
viewMatrix.Column1,
viewMatrix.Column2,
};
Vector4[] cViewProj = new Vector4[4]
{
viewProjMatrix.Column0,
viewProjMatrix.Column1,
viewProjMatrix.Column2,
viewProjMatrix.Column3,
};
Vector4[] cProj = new Vector4[4]
{
projMatrix.Column0,
projMatrix.Column1,
projMatrix.Column2,
projMatrix.Column3,
};
Vector4[] cLightDiffDir = new Vector4[8];
Vector4[] cLightDiffColor = new Vector4[8];
Vector4[] cAmbColor = new Vector4[2];
Vector3 cFogColor = new Vector3(1);
float cFogStart = 0;
float cFogStartEndInv = 0;
for (int i = 0; i < 2; i++)
{
cAmbColor[i] = new Vector4(1);
}
for (int i = 0; i < 8; i++)
{
cLightDiffDir[i] = new Vector4(0.1f, -0.5f, -0.5f, 0);
cLightDiffColor[i] = new Vector4(1);
}
block.Buffer.Clear();
block.Add(cView);
block.Add(cViewProj);
block.Add(cLightDiffDir);
block.Add(cLightDiffColor);
block.Add(cAmbColor);
block.Add(cFogColor);
block.Add(cFogStart);
block.Add(cFogStartEndInv);
block.Add(0);
block.Add(0);
block.Add(cProj);
}
private void SetViewportUniforms(Camera camera, UniformBlock block)
{
Matrix4 mdlMat = camera.ModelMatrix;
var viewMatrix = camera.ViewMatrix;
var projMatrix = camera.ProjectionMatrix;
var viewProjMatrix = mdlMat * viewMatrix * projMatrix;
//cView used for matcaps. Invert and transpose it
viewMatrix.Invert();
viewMatrix.Transpose();
Vector4[] cView = new Vector4[3]
{
viewMatrix.Column0,
viewMatrix.Column1,
viewMatrix.Column2,
};
Vector4[] cViewProj = new Vector4[4]
{
viewProjMatrix.Column0,
viewProjMatrix.Column1,
viewProjMatrix.Column2,
viewProjMatrix.Column3,
};
Vector4[] cLightDiffDir = new Vector4[8];
Vector4[] cLightDiffColor = new Vector4[8];
Vector4[] cAmbColor = new Vector4[2];
Vector4[] cFogColor = new Vector4[8];
Vector4[] cFogStart = new Vector4[8];
Vector4[] cFogStartEndInv = new Vector4[8];
for (int i = 0; i < 2; i++)
{
cAmbColor[i] = new Vector4(1);
}
for (int i = 0; i < 8; i++)
{
cLightDiffDir[i] = new Vector4(0.1f, -0.5f, -0.5f, 0);
cLightDiffColor[i] = new Vector4(1);
}
for (int i = 0; i < 8; i++)
{
cFogColor[i] = new Vector4(1);
cFogStart[i] = new Vector4(10000000, 0, 0, 0);
cFogStartEndInv[i] = new Vector4(0.00003f, 0, 0, 0);
}
block.Add(cView);
block.Add(cViewProj);
block.Add(cLightDiffDir);
block.Add(cLightDiffColor);
block.Add(cAmbColor);
block.Add(cFogColor);
block.Add(cFogStart);
block.Add(cFogStartEndInv);
}
private static void MatPropertyShaderUniform(UniformBlock uniformBlock, Nud.Material mat, string propertyName,
Vector4 defaultValue)
{
// Attempt to get the values from the material.
var newValues = GetValues(mat, propertyName, defaultValue);
string uniformName = propertyName.Replace("NU_", "");
uniformBlock.SetValue(uniformName, new Vector4(newValues[0], newValues[1], newValues[2], newValues[3]));
}
/// <summary>
/// A helper method to set a common shape block layout.
/// Note not all games use the same shape block data!
/// </summary>
public virtual void SetShapeBlock(BfresMeshAsset mesh, Matrix4 transform, UniformBlock block)
{
int numSkinning = (int)mesh.SkinCount;
block.Buffer.Clear();
block.Add(transform.Column0);
block.Add(transform.Column1);
block.Add(transform.Column2);
block.AddInt(numSkinning);
}
private void SetHdrUniforms(UniformBlock block)
{
float pow = 4.0f;
float range = 8192.0f;
//The current cubemap used uses 1024 but in game it's usually 8192
range = 1024.0f;
block.Add(new Vector4(pow, range, 0.0f, 0.0f));
}
public void SetModelBlock(UniformBlock block)
{
Matrix4 transform = Matrix4.Identity;
block.Buffer.Clear();
block.Add(transform.Column0);
block.Add(transform.Column1);
block.Add(transform.Column2);
block.Add(transform.Column3);
}
private void SetFloats(UniformBlock uniformBlock)
{
// Use a 16 byte type to avoid alignment issues.
var customFloatData = new Vector4[20];
foreach (var param in floatByParamId)
{
customFloatData[param.Key.ToFloatIndex()] = new Vector4(param.Value, 0f, 0f, 0f);
}
uniformBlock.SetValues("CustomFloat", customFloatData);
}
override internal void UploadUBOandDraw(Camera camera, UniformBlock ubo)
{
var modelMat = this.gameObject.transform.localToWorldMatrix;
var modelViewMat = modelMat * camera.GetViewMat();
ubo.model.modelMatrix = modelMat;
ubo.model.modelViewMatrix = modelViewMat;
ubo.model.modelViewProjectionMatrix = modelViewMat * camera.GetProjectionMat();
ubo.modelUBO.UploadData();
particleMesh.Draw();
}
public override void UploadUBOandDraw(CameraData camera, UniformBlock ubo)
{
var modelMatrix = this.Entity.Transform.GetLocalToWorldMatrix(camera.ViewPointPosition - Offset);
var modelViewMatrix = modelMatrix * camera.GetRotationMatrix();
ubo.model.modelMatrix = modelMatrix;
ubo.model.modelViewMatrix = modelViewMatrix;
ubo.model.modelViewProjectionMatrix = modelViewMatrix * camera.GetProjectionMatrix();
ubo.model.worldPosition = this.Entity.Transform.Position.ToVector3();
ubo.modelUBO.UploadToGPU();
Mesh.Draw(Material.RenderShader.HasTesselation);
}
private void RenderBlock(UniformBlock block, int programID, int vertexLocation, int fragmentLocation, int binding)
{
if (vertexLocation != -1)
{
block.RenderBuffer(programID, IsSwitch ? $"vp_c{vertexLocation + 3}" : $"vp_{vertexLocation}", binding);
}
if (fragmentLocation != -1)
{
block.RenderBuffer(programID, IsSwitch ? $"fp_c{fragmentLocation + 3}" : $"fp_{fragmentLocation}", binding);
}
}
public void RenderBlock(UniformBlock block, int programID, int vertexLocation, int fragmentLocation, int bindings)
{
if (vertexLocation != -1)
{
block.RenderBuffer(programID, $"vp_{vertexLocation}", bindings);
}
if (fragmentLocation != -1)
{
block.RenderBuffer(programID, $"fp_{fragmentLocation}", bindings);
}
}
private void SetMaterialParams(UniformBlock uniformBlock)
{
SetVec4(uniformBlock, MatlEnums.ParamId.CustomVector0, Vector4.Zero);
SetVec4(uniformBlock, MatlEnums.ParamId.CustomVector3, Vector4.One);
SetVec4(uniformBlock, MatlEnums.ParamId.CustomVector6, new Vector4(1, 1, 0, 0));
SetVec4(uniformBlock, MatlEnums.ParamId.CustomVector8, Vector4.One);
SetVec4(uniformBlock, MatlEnums.ParamId.CustomVector11, Vector4.Zero);
SetVec4(uniformBlock, MatlEnums.ParamId.CustomVector13, Vector4.One);
SetVec4(uniformBlock, MatlEnums.ParamId.CustomVector14, Vector4.One);
SetVec4(uniformBlock, MatlEnums.ParamId.CustomVector18, Vector4.One);
SetVec4(uniformBlock, MatlEnums.ParamId.CustomVector30, Vector4.Zero);
SetVec4(uniformBlock, MatlEnums.ParamId.CustomVector31, new Vector4(1, 1, 0, 0));
SetVec4(uniformBlock, MatlEnums.ParamId.CustomVector32, new Vector4(1, 1, 0, 0));
SetVec4(uniformBlock, MatlEnums.ParamId.CustomVector44, Vector4.Zero);
SetVec4(uniformBlock, MatlEnums.ParamId.CustomVector45, Vector4.Zero);
SetVec4(uniformBlock, MatlEnums.ParamId.CustomVector47, Vector4.Zero);
SetBool(uniformBlock, MatlEnums.ParamId.CustomBoolean1, false);
SetBool(uniformBlock, MatlEnums.ParamId.CustomBoolean2, true);
SetBool(uniformBlock, MatlEnums.ParamId.CustomBoolean3, true);
SetBool(uniformBlock, MatlEnums.ParamId.CustomBoolean4, true);
SetBool(uniformBlock, MatlEnums.ParamId.CustomBoolean5, false);
SetBool(uniformBlock, MatlEnums.ParamId.CustomBoolean6, false);
SetBool(uniformBlock, MatlEnums.ParamId.CustomBoolean9, false);
SetBool(uniformBlock, MatlEnums.ParamId.CustomBoolean11, true);
SetFloat(uniformBlock, MatlEnums.ParamId.CustomFloat1, 0.0f);
SetFloat(uniformBlock, MatlEnums.ParamId.CustomFloat4, 0.0f);
SetFloat(uniformBlock, MatlEnums.ParamId.CustomFloat8, 0.0f);
SetFloat(uniformBlock, MatlEnums.ParamId.CustomFloat10, 0.0f);
SetFloat(uniformBlock, MatlEnums.ParamId.CustomFloat19, 0.0f);
uniformBlock.SetValue("hasCustomVector11", vec4ByParamId.ContainsKey(MatlEnums.ParamId.CustomVector11));
uniformBlock.SetValue("hasCustomVector44", vec4ByParamId.ContainsKey(MatlEnums.ParamId.CustomVector44));
uniformBlock.SetValue("hasCustomVector47", vec4ByParamId.ContainsKey(MatlEnums.ParamId.CustomVector47));
uniformBlock.SetValue("hasCustomFloat10", floatByParamId.ContainsKey(MatlEnums.ParamId.CustomFloat10));
uniformBlock.SetValue("hasCustomBoolean1", boolByParamId.ContainsKey(MatlEnums.ParamId.CustomBoolean1));
uniformBlock.SetValue("hasColMap", HasCol);
uniformBlock.SetValue("hasCol2Map", HasCol2);
uniformBlock.SetValue("hasInkNorMap", HasInkNorMap);
uniformBlock.SetValue("hasDifCubeMap", HasDifCube);
uniformBlock.SetValue("hasDiffuse", HasDiffuse);
uniformBlock.SetValue("hasDiffuse2", HasDiffuse2);
uniformBlock.SetValue("hasDiffuse3", HasDiffuse3);
// HACK: There's probably a better way to handle blending emission and base color maps.
var hasDiffuseMaps = HasCol || HasCol2 || HasDiffuse || HasDiffuse2 || HasDiffuse3;
var hasEmiMaps = HasEmi || HasEmi2;
uniformBlock.SetValue("emissionOverride", hasEmiMaps && !hasDiffuseMaps);
}
private void SetModelUniforms(UniformBlock block)
{
var matrix = Matrix4.Identity;
block.Add(new Vector4(1, 1, 0.5f, 0.5f));
for (int i = 0; i < 7; i++)
{
block.Add(matrix.Column0);
block.Add(matrix.Column1);
block.Add(matrix.Column2);
block.Add(matrix.Column3);
}
}
public void Update(int program, int width, int height, int widthTex, int heightTex)
{
// GET OR CREATE POISSON DISC UNIFORMS FOR program
UniformBlock<Names> unif;
if (uniform.TryGetValue(program, out unif) == false)
{
uniform.Add(program, unif = new UniformBlock<Names>(program, name));
// SET UNIFORM VALUES
unif.Set(Names.numPoints, new[] { points.GetLength(0) });
unif.Set(Names.points, points);
// UPDATE UNIFORM BUFFER
unif.Update();
}
unif.Bind();
}
public void Update(int program, int width, int height, int widthTex, int heightTex)
{
// This function is executed every frame at the beginning of a pass.
view = Matrix4.CreateTranslation(-pos[0], -pos[1], -pos[2])
* Matrix4.CreateRotationY(-rot[1] * rad2deg)
* Matrix4.CreateRotationX(-rot[0] * rad2deg);
float aspect = (float)width / height;
Matrix4 proj = Matrix4.CreatePerspectiveFieldOfView(fov * rad2deg, aspect, near, far);
// GET OR CREATE CAMERA UNIFORMS FOR program
UniformBlock<Names> unif;
if (uniform.TryGetValue(program, out unif) == false)
uniform.Add(program, unif = new UniformBlock<Names>(program, name));
// SET UNIFORM VALUES
if (unif.Has(Names.view))
unif.Set(Names.view, view.AsInt32());
if (unif.Has(Names.proj))
unif.Set(Names.proj, proj.AsInt32());
if (unif.Has(Names.viewProj))
unif.Set(Names.viewProj, (view * proj).AsInt32());
if (unif.Has(Names.camera))
unif.Set(Names.camera, new[] { fov * rad2deg, aspect, near, far }.AsInt32());
if (unif.Has(Names.position))
unif.Set(Names.position, pos.AsInt32());
if (unif.Has(Names.rotation))
unif.Set(Names.rotation, rot.AsInt32());
// UPDATE UNIFORM BUFFER
unif.Update();
unif.Bind();
}
public void Update(int program, int widthScreen, int heightScreen, int widthTex, int heightTex)
{
var sub = quests[activeQuest];
var size = artifactSize[sub.artifactId];
var angle = lineAngles[sub.lineId];
var samples = poissonDisc[sub.poissonId] != null
? poissonDisc[sub.poissonId].points.GetLength(0) : 0;
var line = new[] { (float)Math.Sin(angle), (float)Math.Cos(angle), 0 };
line[2] = line[0] * widthTex / 2 + line[1] * heightTex / 2;
// GET OR CREATE CAMERA UNIFORMS FOR program
UniformBlock<Names> unif;
UniformBlock<Disc> unifDisc;
if (uniform.TryGetValue(program, out unif) == false)
uniform.Add(program, unif = new UniformBlock<Names>(program, name));
if (uniformDisc.TryGetValue(program, out unifDisc) == false)
uniformDisc.Add(program, unifDisc = new UniformBlock<Disc>(program, name + "Disc"));
// SET UNIFORM VALUES
unif.Set(Names.rendertargetSize, new[] {
widthTex, heightTex, widthScreen, heightScreen,
});
unif.Set(Names.lineAngle, new[] {
(float)angle, randomAngle, size, sub.radius
});
unifDisc.Set(Disc.nPoints, new[] { samples });
if (samples > 0)
unifDisc.Set(Disc.points, poissonDisc[sub.poissonId].points);
// UPDATE UNIFORM BUFFER
unif.Update();
unif.Bind();
unifDisc.Update();
unifDisc.Bind();
}
