private static void BindGLTexture(MatTexture tex, SF.Shader shader, STGenericTexture texture)
{
//If the texture is still not initialized then return
if (!texture.RenderableTex.GLInitialized)
{
return;
}
if (tex.Type == STGenericMatTexture.TextureType.Diffuse)
{
shader.SetInt("RedChannel", (int)texture.RedChannel);
shader.SetInt("GreenChannel", (int)texture.GreenChannel);
shader.SetInt("BlueChannel", (int)texture.BlueChannel);
shader.SetInt("AlphaChannel", (int)texture.AlphaChannel);
}
// GL.ActiveTexture(TextureUnit.Texture0 + texid);
GL.BindTexture(TextureTarget.Texture2D, texture.RenderableTex.TexID);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)MatTexture.wrapmode[tex.WrapModeS]);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)MatTexture.wrapmode[tex.WrapModeT]);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)MatTexture.minfilter[tex.MinFilter]);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)MatTexture.magfilter[tex.MagFilter]);
GL.TexParameter(TextureTarget.Texture2D, (TextureParameterName)ExtTextureFilterAnisotropic.TextureMaxAnisotropyExt, 0.0f);
}
private static void ApplyTransformFix(FMDL fmdl, FSHP m, SF.Shader shader)
{
Matrix4 idenity = Matrix4.Identity;
shader.SetInt("NoSkinning", 0);
shader.SetInt("RigidSkinning", 0);
shader.SetInt("SingleBoneIndex", m.BoneIndex);
shader.SetMatrix4x4("SingleBoneBindTransform", ref idenity);
//Some objects will have no weights or indices. These will weigh to the bone index in the shape section.
if (m.VertexSkinCount == 1)
{
shader.SetInt("RigidSkinning", 1);
}
if (m.VertexSkinCount == 0)
{
if (fmdl.Skeleton.bones.Count > 0)
{
Matrix4 transform = fmdl.Skeleton.bones[m.BoneIndex].invert * fmdl.Skeleton.bones[m.BoneIndex].Transform;
shader.SetMatrix4x4("SingleBoneBindTransform", ref transform);
shader.SetInt("NoSkinning", 1);
}
}
}
private static void SetBoneUniforms(SF.Shader shader, FMDL fmdl, FSHP fshp)
{
for (int i = 0; i < fmdl.Skeleton.Node_Array.Length; i++)
{
GL.Uniform1(GL.GetUniformLocation(shader.Id, String.Format("boneIds[{0}]", i)), fmdl.Skeleton.Node_Array[i]);
Matrix4 transform = fmdl.Skeleton.bones[fmdl.Skeleton.Node_Array[i]].invert * fmdl.Skeleton.bones[fmdl.Skeleton.Node_Array[i]].Transform;
GL.UniformMatrix4(GL.GetUniformLocation(shader.Id, String.Format("bones[{0}]", i)), false, ref transform);
}
}
private static void DrawModelWireframe(STGenericObject p, SF.Shader shader)
{
// use vertex color for wireframe color
shader.SetInt("colorOverride", 1);
GL.PolygonMode(MaterialFace.Front, PolygonMode.Line);
GL.Enable(EnableCap.LineSmooth);
GL.LineWidth(1.5f);
GL.DrawElements(PrimitiveType.Triangles, p.lodMeshes[p.DisplayLODIndex].displayFaceSize, DrawElementsType.UnsignedInt, p.Offset);
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
shader.SetInt("colorOverride", 0);
}
private static bool BindBNTX(BNTX bntx, MatTexture tex, SF.Shader shader, string activeTex)
{
if (bntx.Textures[activeTex].RenderableTex == null ||
!bntx.Textures[activeTex].RenderableTex.GLInitialized)
{
bntx.Textures[activeTex].LoadOpenGLTexture();
}
BindGLTexture(tex, shader, bntx.Textures[activeTex]);
return(bntx.Textures[activeTex].RenderableTex.GLInitialized);
}
private static bool BindFTEX(BFRESGroupNode ftexContainer, MatTexture tex, SF.Shader shader, string activeTex)
{
FTEX ftex = (FTEX)ftexContainer.ResourceNodes[activeTex];
if (ftex.RenderableTex == null || !ftex.RenderableTex.GLInitialized)
{
ftex.LoadOpenGLTexture();
}
BindGLTexture(tex, shader, ftex);
return(ftex.RenderableTex.GLInitialized);
}
private static void DrawMdoelHoverSelection(STGenericObject p, SF.Shader shader,
bool IsSelected, bool IsHovered)
{
if (IsHovered && IsSelected)
{
shader.SetVector4("pickingColor", hoverColor);
}
else if (IsHovered || IsSelected)
{
shader.SetVector4("pickingColor", selectColor);
}
else
{
shader.SetVector4("pickingColor", new Vector4(1));
}
}
private static void LoadPBRMaps(SF.Shader shader)
{
GL.ActiveTexture(TextureUnit.Texture0 + 26);
RenderTools.specularPbr.Bind();
GL.Uniform1(shader.GetUniformLocation("specularIbl"), 26);
// GL.GenerateMipmap(GenerateMipmapTarget.TextureCubeMap);
// PBR IBL
GL.ActiveTexture(TextureUnit.Texture0 + 25);
RenderTools.diffusePbr.Bind();
GL.Uniform1(shader.GetUniformLocation("irradianceMap"), 25);
GL.ActiveTexture(TextureUnit.Texture0 + 27);
RenderTools.brdfPbr.Bind();
GL.Uniform1(shader.GetUniformLocation("brdfLUT"), 27);
}
private void SetVertexAttributes(FSHP m, SF.Shader shader)
{
GL.BindBuffer(BufferTarget.ArrayBuffer, vbo_position);
GL.VertexAttribPointer(shader.GetAttribLocation("vPosition"), 3, VertexAttribPointerType.Float, false, DisplayVertex.Size, 0);
GL.VertexAttribPointer(shader.GetAttribLocation("vNormal"), 3, VertexAttribPointerType.Float, false, DisplayVertex.Size, 12);
GL.VertexAttribPointer(shader.GetAttribLocation("vTangent"), 3, VertexAttribPointerType.Float, false, DisplayVertex.Size, 24);
GL.VertexAttribPointer(shader.GetAttribLocation("vBitangent"), 3, VertexAttribPointerType.Float, false, DisplayVertex.Size, 36);
GL.VertexAttribPointer(shader.GetAttribLocation("vUV0"), 2, VertexAttribPointerType.Float, false, DisplayVertex.Size, 48);
GL.VertexAttribPointer(shader.GetAttribLocation("vColor"), 4, VertexAttribPointerType.Float, false, DisplayVertex.Size, 56);
GL.VertexAttribIPointer(shader.GetAttribLocation("vBone"), 4, VertexAttribIntegerType.Int, DisplayVertex.Size, new IntPtr(72));
GL.VertexAttribPointer(shader.GetAttribLocation("vWeight"), 4, VertexAttribPointerType.Float, false, DisplayVertex.Size, 88);
GL.VertexAttribPointer(shader.GetAttribLocation("vUV1"), 2, VertexAttribPointerType.Float, false, DisplayVertex.Size, 104);
GL.VertexAttribPointer(shader.GetAttribLocation("vUV2"), 2, VertexAttribPointerType.Float, false, DisplayVertex.Size, 112);
GL.VertexAttribPointer(shader.GetAttribLocation("vPosition2"), 3, VertexAttribPointerType.Float, false, DisplayVertex.Size, 124);
GL.VertexAttribPointer(shader.GetAttribLocation("vPosition3"), 3, VertexAttribPointerType.Float, false, DisplayVertex.Size, 136);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, ibo_elements);
}
private static void SetDefaultTextureAttributes(FMAT mat, SF.Shader shader)
{
shader.SetBoolToInt("HasDiffuse", mat.HasDiffuseMap);
shader.SetBoolToInt("HasDiffuseLayer", mat.HasDiffuseLayer);
shader.SetBoolToInt("HasNormalMap", mat.HasNormalMap);
shader.SetBoolToInt("HasEmissionMap", mat.HasEmissionMap);
shader.SetBoolToInt("HasLightMap", mat.HasLightMap);
shader.SetBoolToInt("HasShadowMap", mat.HasShadowMap);
shader.SetBoolToInt("HasSpecularMap", mat.HasSpecularMap);
shader.SetBoolToInt("HasTeamColorMap", mat.HasTeamColorMap);
shader.SetBoolToInt("HasSphereMap", mat.HasSphereMap);
shader.SetBoolToInt("HasSubSurfaceScatteringMap", mat.HasSubSurfaceScatteringMap);
//Unused atm untill I do PBR shader
shader.SetBoolToInt("HasMetalnessMap", mat.HasMetalnessMap);
shader.SetBoolToInt("HasRoughnessMap", mat.HasRoughnessMap);
shader.SetBoolToInt("HasMRA", mat.HasMRA);
}
private void SetRenderSettings(SF.Shader shader, bool useVertexColors)
{
shader.SetBoolToInt("renderVertColor", Runtime.renderVertColor && useVertexColors);
shader.SetBoolToInt("useNormalMap", Runtime.useNormalMap);
shader.SetBoolToInt("renderR", Runtime.renderR);
shader.SetBoolToInt("renderG", Runtime.renderG);
shader.SetBoolToInt("renderB", Runtime.renderB);
shader.SetBoolToInt("renderAlpha", Runtime.renderAlpha);
shader.SetInt("renderType", (int)Runtime.viewportShading);
shader.SetInt("uvChannel", (int)Runtime.uvChannel);
shader.SetBoolToInt("renderFog", Runtime.renderFog);
shader.SetBoolToInt("renderDiffuse", Runtime.renderDiffuse);
shader.SetBoolToInt("renderSpecular", Runtime.renderSpecular);
shader.SetBoolToInt("renderFresnel", Runtime.renderFresnel);
}
private static void DrawModelSelection(STGenericObject p, SF.Shader shader)
{
//This part needs to be reworked for proper outline. Currently would make model disappear
/* GL.Enable(EnableCap.DepthTest);
* GL.StencilOp(StencilOp.Keep, StencilOp.Keep, StencilOp.Replace);
*
* GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit | ClearBufferMask.StencilBufferBit);
*
* GL.StencilMask(0x00);
*
* GL.StencilFunc(StencilFunction.Always, 1, 0xFF); // all fragments should update the stencil buffer
* GL.StencilMask(0xFF); // enable writing to the stencil buffer
* GL.DrawElements(PrimitiveType.Triangles, p.lodMeshes[p.DisplayLODIndex].displayFaceSize, DrawElementsType.UnsignedInt, p.Offset);
*
* GL.StencilFunc(StencilFunction.Notequal, 1, 0xFF);
* GL.StencilMask(0x00); // enable writing to the stencil buffer
* GL.Disable(EnableCap.DepthTest);
*
* shader.SetInt("colorOverride", 1);
*
* GL.PolygonMode(MaterialFace.Front, PolygonMode.Line);
* GL.LineWidth(2.0f);
* GL.DrawElements(PrimitiveType.Triangles, p.lodMeshes[p.DisplayLODIndex].displayFaceSize, DrawElementsType.UnsignedInt, p.Offset);
* GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
*
* shader.SetInt("colorOverride", 0);
*
* GL.StencilMask(0xFF);
* GL.Enable(EnableCap.DepthTest);*/
// Override the model color with white in the shader.
shader.SetInt("colorOverride", 1);
GL.PolygonMode(MaterialFace.Front, PolygonMode.Line);
GL.Enable(EnableCap.LineSmooth);
GL.LineWidth(1.3f);
GL.DrawElements(PrimitiveType.Triangles, p.lodMeshes[p.DisplayLODIndex].displayFaceSize, DrawElementsType.UnsignedInt, p.Offset);
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
shader.SetInt("colorOverride", 0);
GL.DrawElements(PrimitiveType.Triangles, p.lodMeshes[p.DisplayLODIndex].displayFaceSize, DrawElementsType.UnsignedInt, p.Offset);
}
private static bool TextureUniform(SF.Shader shader, FMAT mat, string name, MatTexture mattex)
{
if (mattex.textureState == STGenericMatTexture.TextureState.Binded)
{
return(true);
}
// Bind the texture and create the uniform if the material has the right textures.
bool IsBound = BindTexture(mattex, mat, shader, mat.GetResFileU() != null);
int texId = mattex.textureUnit + 1;
if (IsBound)
{
GL.Uniform1(shader.GetUniformLocation(name), texId);
}
else
{
return(false);
}
return(true);
}
private void DrawModels(SF.Shader shader, GL_ControlModern control)
{
shader.EnableVertexAttributes();
for (int m = 0; m < models.Count; m++)
{
if (models[m].Checked)
{
List <FSHP> opaque = new List <FSHP>();
List <FSHP> transparent = new List <FSHP>();
for (int shp = 0; shp < models[m].shapes.Count; shp++)
{
if (models[m].shapes[shp].GetFMAT().isTransparent)
{
transparent.Add(models[m].shapes[shp]);
}
else
{
opaque.Add(models[m].shapes[shp]);
}
}
for (int shp = 0; shp < transparent.Count; shp++)
{
DrawModel(transparent[shp], models[m], shader, models[m].IsSelected);
}
for (int shp = 0; shp < opaque.Count; shp++)
{
DrawModel(opaque[shp], models[m], shader, models[m].IsSelected);
}
}
}
shader.DisableVertexAttributes();
}
private void Draw(SF.Shader shader)
{
Attributes(shader);
GL.DrawArrays(PrimitiveType.Lines, 0, Vertices.Length);
}
private void Attributes(SF.Shader shader)
{
GL.BindBuffer(BufferTarget.ArrayBuffer, vbo_position);
GL.VertexAttribPointer(shader.GetAttribLocation("point"), 4, VertexAttribPointerType.Float, false, 16, 0);
}
public override void Draw(GL_ControlModern control, Pass pass, EditorSceneBase editorScene)
{
CheckBuffers();
if (!Runtime.OpenTKInitialized || !Runtime.renderBones || !Visible)
{
return;
}
SF.Shader shader = OpenTKSharedResources.shaders["BONE"];
shader.UseProgram();
GL.Disable(EnableCap.CullFace);
if (Runtime.boneXrayDisplay)
{
GL.Disable(EnableCap.DepthTest);
}
if (Runtime.renderBoundingBoxes)
{
DrawBoundingBoxes();
}
control.UpdateModelMatrix(
Matrix4.CreateScale(Runtime.previewScale * PreviewScale) *
Matrix4.CreateTranslation(Selected ? editorScene.CurrentAction.NewPos(position) : position));
shader.EnableVertexAttributes();
shader.SetMatrix4x4("rotation", ref prismRotation);
Matrix4 camMat = control.CameraMatrix;
Matrix4 mdlMat = control.ModelMatrix;
Matrix4 projMat = control.ProjectionMatrix;
Matrix4 computedCamMtx = camMat * projMat;
shader.SetMatrix4x4("mtxCam", ref computedCamMtx);
shader.SetMatrix4x4("mtxMdl", ref mdlMat);
foreach (STBone bn in bones)
{
if (!bn.Checked)
{
continue;
}
shader.SetVector4("boneColor", ColorUtility.ToVector4(boneColor));
shader.SetFloat("scale", Runtime.bonePointSize * BonePointScale);
shader.SetMatrix4x4("ModelMatrix", ref bn.ModelMatrix);
Matrix4 transform = bn.Transform;
shader.SetMatrix4x4("bone", ref transform);
shader.SetInt("hasParent", bn.parentIndex != -1 ? 1 : 0);
if (bn.parentIndex != -1)
{
var transformParent = ((STBone)bn.Parent).Transform;
shader.SetMatrix4x4("parent", ref transformParent);
}
Draw(shader);
if (Runtime.SelectedBoneIndex == bn.GetIndex())
{
shader.SetVector4("boneColor", ColorUtility.ToVector4(selectedBoneColor));
}
shader.SetInt("hasParent", 0);
Draw(shader);
}
shader.DisableVertexAttributes();
GL.UseProgram(0);
GL.Enable(EnableCap.CullFace);
GL.Enable(EnableCap.DepthTest);
}
private static void SetUniformData(FMAT mat, SF.Shader shader, string propertyName)
{
if (mat.shaderassign.options.ContainsKey(propertyName))
{
float value = float.Parse(mat.shaderassign.options[propertyName]);
shader.SetFloat(propertyName, value);
}
Dictionary <string, BfresShaderParam> matParams = mat.matparam;
if (mat.animatedMatParams.ContainsKey(propertyName))
{
matParams = mat.animatedMatParams;
}
if (matParams.ContainsKey(propertyName))
{
if (matParams[propertyName].Type == ShaderParamType.Float)
{
if (mat.anims.ContainsKey(propertyName))
{
matParams[propertyName].ValueFloat[0] = mat.anims[propertyName][0];
}
shader.SetFloat(propertyName, matParams[propertyName].ValueFloat[0]);
}
if (matParams[propertyName].Type == ShaderParamType.Float2)
{
if (mat.anims.ContainsKey(propertyName))
{
matParams[propertyName].ValueFloat = new float[2] {
mat.anims[propertyName][0], mat.anims[propertyName][1]
};
}
shader.SetVector2(propertyName, Utils.ToVec2(matParams[propertyName].ValueFloat));
}
if (matParams[propertyName].Type == ShaderParamType.Float3)
{
if (mat.anims.ContainsKey(propertyName))
{
matParams[propertyName].ValueFloat = new float[3] {
mat.anims[propertyName][0],
mat.anims[propertyName][1],
mat.anims[propertyName][2]
};
}
shader.SetVector3(propertyName, Utils.ToVec3(matParams[propertyName].ValueFloat));
}
if (matParams[propertyName].Type == ShaderParamType.Float4)
{
if (mat.anims.ContainsKey(propertyName))
{
matParams[propertyName].ValueFloat = new float[4] {
mat.anims[propertyName][0], mat.anims[propertyName][1],
mat.anims[propertyName][2], mat.anims[propertyName][3]
};
}
shader.SetVector4(propertyName, Utils.ToVec4(matParams[propertyName].ValueFloat));
}
if (matParams[propertyName].Type == ShaderParamType.TexSrt)
{
// Vector 2 Scale
// 1 roation float
// Vector2 translate
TexSrt texSRT = matParams[propertyName].ValueTexSrt;
shader.SetVector2("SRT_Scale", Utils.ToVec2(texSRT.Scaling));
shader.SetFloat("SRT_Rotate", texSRT.Rotation);
shader.SetVector2("SRT_Translate", Utils.ToVec2(texSRT.Translation));
}
if (matParams[propertyName].Type == ShaderParamType.TexSrtEx)
{
// Vector 2 Scale
// 1 roation float
// Vector2 translate
TexSrtEx texSRT = matParams[propertyName].ValueTexSrtEx;
shader.SetVector2("SRT_Scale", Utils.ToVec2(texSRT.Scaling));
shader.SetFloat("SRT_Rotate", texSRT.Rotation);
shader.SetVector2("SRT_Translate", Utils.ToVec2(texSRT.Translation));
}
//MTA SRT
if (propertyName == "texsrt0" && mat.shaderassign.ShaderArchive == "ssg")
{
TexSrt texSRT = matParams[propertyName].ValueTexSrt;
shader.SetVector2("SRT_Scale", Utils.ToVec2(texSRT.Scaling));
shader.SetFloat("SRT_Rotate", texSRT.Rotation);
shader.SetVector2("SRT_Translate", Utils.ToVec2(texSRT.Translation));
}
}
}
private static void SetUniforms(FMAT mat, SF.Shader shader, FSHP m, int id)
{
shader.SetBoolToInt("isTransparent", mat.isTransparent);
shader.SetFloat("ao_density", 1);
shader.SetFloat("shadow_density", 1);
shader.SetFloat("normal_map_weight", 1);
//Bake map UV coordinate ST
shader.SetVector4("gsys_bake_st0", new Vector4(1, 1, 0, 0));
shader.SetVector4("gsys_bake_st1", new Vector4(1, 1, 0, 0));
shader.SetBoolToInt("UseSpecularColor",
(mat.GetOptionValue("specular_mask_is_color") == 1) ||
mat.GetOptionValue("enable_specular_color") == 1);
shader.SetBoolToInt("UseMultiTexture", mat.GetOptionValue("enable_multi_texture") == 1);
//Colors
shader.SetVector4("const_color0", new Vector4(1, 1, 1, 1));
shader.SetVector4("base_color_mul_color", new Vector4(1, 1, 1, 1));
shader.SetVector3("albedo_tex_color", new Vector3(1, 1, 1));
shader.SetVector3("emission_color", new Vector3(1, 1, 1));
shader.SetVector3("specular_color", new Vector3(1, 1, 1));
shader.SetFloat("fuv1_mtx", 0);
//SRT
shader.SetVector4("tex_mtx0", new Vector4(1, 1, 1, 1));
shader.SetVector2("SRT_Scale", new Vector2(1, 1));
shader.SetFloat("SRT_Rotate", 0);
shader.SetVector2("SRT_Translate", new Vector2(0, 0));
shader.SetInt("selectedBoneIndex", Runtime.SelectedBoneIndex);
SetUniformData(mat, shader, "base_color_mul_color");
shader.SetInt("enableCellShading", 0);
bool HasTans = m.vertexAttributes.Any(x => x.Name == "_t0");
shader.SetBoolToInt("hasTangents", HasTans);
SetUniformData(mat, shader, "fuv1_mtx");
SetUniformData(mat, shader, "gsys_bake_st0");
SetUniformData(mat, shader, "gsys_bake_st1");
SetUniformData(mat, shader, "ao_density");
SetUniformData(mat, shader, "shadow_density");
SetUniformData(mat, shader, "normal_map_weight");
SetUniformData(mat, shader, "const_color0");
SetUniformData(mat, shader, "base_color_mul_color");
SetUniformData(mat, shader, "albedo_tex_color");
SetUniformData(mat, shader, "emission_color");
SetUniformData(mat, shader, "specular_color");
//This uniform sets various maps for BOTW to use second UV channel
SetUniformData(mat, shader, "uking_texture2_texcoord");
SetUniformData(mat, shader, "cIsEnableNormalMap");
SetUniformData(mat, shader, "texsrt0");
SetUniformData(mat, shader, "tex_mtx0");
SetUniformData(mat, shader, "texmtx0");
//Sets shadow type
//0 = Ambient occusion bake map
//1 = Shadow
//2 = Shadow + Ambient occusion map
SetUniformData(mat, shader, "bake_shadow_type");
SetUniformData(mat, shader, "bake_light_type");
SetUniformData(mat, shader, "gsys_bake_light_scale");
SetUniformData(mat, shader, "enable_projection_light");
SetUniformData(mat, shader, "enable_actor_light");
SetUniformData(mat, shader, "bake_calc_type");
}
private void DrawBfres(GL_ControlModern control, Pass pass)
{
if (!Runtime.OpenTKInitialized || pass == Pass.TRANSPARENT || Disposing)
{
return;
}
bool buffersWereInitialized = ibo_elements != 0 && vbo_position != 0;
if (!buffersWereInitialized)
{
GenerateBuffers();
}
if (Hovered == true)
{
throw new Exception("model selected");
}
//Temporarily revert to using this shader system as it is easy to port back
//This is much quicker. Will change after shaders are handled faster
SF.Shader shader = OpenTKSharedResources.shaders["BFRES"];
if (Runtime.EnablePBR)
{
shader = OpenTKSharedResources.shaders["BFRES_PBR"];
}
if (models.Count > 0)
{
if (models[0].shapes.Count > 0)
{
if (models[0].shapes[0].GetFMAT().shaderassign.ShaderModel == "uking_mat")
{
shader = OpenTKSharedResources.shaders["BFRES_Botw"];
//Botw uses small models so lower the bone size
Runtime.bonePointSize = 0.040f;
}
}
}
if (Runtime.viewportShading != Runtime.ViewportShading.Default)
{
shader = OpenTKSharedResources.shaders["BFRES_Debug"];
}
if (Runtime.viewportShading == Runtime.ViewportShading.Lighting && Runtime.EnablePBR)
{
shader = OpenTKSharedResources.shaders["BFRES_PBR"];
}
shader.UseProgram();
control.UpdateModelMatrix(ModelTransform * Matrix4.CreateScale(Runtime.previewScale));
Matrix4 camMat = control.CameraMatrix;
Matrix4 mdlMat = control.ModelMatrix;
Matrix4 projMat = control.ProjectionMatrix;
Matrix4 computedCamMtx = camMat * projMat;
Matrix4 mvpMat = control.ModelMatrix * control.CameraMatrix * control.ProjectionMatrix;
Matrix4 sphereMatrix = mvpMat;
Matrix4 invertedCamera = Matrix4.Identity;
// invertedCamera = mvpMat.Inverted();
// if (invertedCamera.Determinant == 0)
// invertedCamera = Matrix4.Identity;
sphereMatrix = invertedCamera;
sphereMatrix.Transpose();
invertedCamera = mvpMat.Inverted();
Vector3 lightDirection = new Vector3(0f, 0f, -1f);
shader.SetVector3("specLightDirection", Vector3.TransformNormal(lightDirection, invertedCamera).Normalized());
shader.SetVector3("difLightDirection", Vector3.TransformNormal(lightDirection, invertedCamera).Normalized());
shader.SetMatrix4x4("sphereMatrix", ref sphereMatrix);
shader.SetMatrix4x4("mtxCam", ref computedCamMtx);
shader.SetMatrix4x4("mtxMdl", ref mdlMat);
shader.SetVector3("cameraPosition", control.CameraPosition);
Vector4 pickingColor = control.NextPickingColor();
shader.SetVector3("difLightColor", new Vector3(1));
shader.SetVector3("ambLightColor", new Vector3(1));
GL.Enable(EnableCap.AlphaTest);
GL.AlphaFunc(AlphaFunction.Gequal, 0.1f);
DrawModels(shader, control);
if (Runtime.renderNormalsPoints)
{
shader = OpenTKSharedResources.shaders["BFRES_Normals"];
shader.UseProgram();
shader.SetMatrix4x4("camMtx", ref camMat);
shader.SetMatrix4x4("mtxProj", ref projMat);
shader.SetMatrix4x4("mtxCam", ref computedCamMtx);
shader.SetMatrix4x4("mtxMdl", ref mdlMat);
shader.SetFloat("normalsLength", Runtime.normalsLineLength);
DrawModels(shader, control);
}
GL.UseProgram(0);
GL.Disable(EnableCap.DepthTest);
GL.Enable(EnableCap.DepthTest);
GL.Enable(EnableCap.CullFace);
}
private void DrawModel(FSHP m, FMDL mdl, SF.Shader shader, bool ModelSelected)
{
if (m.lodMeshes[m.DisplayLODIndex].faces.Count <= 3)
{
return;
}
var mat = m.GetFMAT();
if (shader != OpenTKSharedResources.shaders["BFRES_Normals"])
{
bool useVertexColors = true;
if (mat.shaderassign.ShaderArchive == "Park_UBER")
{
useVertexColors = false;
}
SetRenderSettings(shader, useVertexColors);
SetRenderPass(mat);
SetUniforms(mat, shader, m, m.DisplayId);
SetTextureUniforms(mat, m, shader);
}
SetBoneUniforms(shader, mdl, m);
ApplyTransformFix(mdl, m, shader);
SetVertexAttributes(m, shader);
//Check the binded bone if it's visible from bone visual anims
// if (!mdl.Skeleton.bones[m.boneIndx].Visible)
// m.Checked = false;
if (m.Checked && mdl.Skeleton.bones.Count > 0 && mdl.Skeleton.bones[m.BoneIndex].Visible && mat.Enabled)
{
shader.SetVector3("materialSelectColor", new Vector3(0));
if (m.GetMaterial().IsSelected)
{
shader.SetVector3("materialSelectColor", ColorUtility.ToVector3(Color.FromArgb(0, 163, 204)));
DrawModelSelection(m, shader);
}
else if (m.IsSelected || ModelSelected)
{
DrawModelSelection(m, shader);
}
else
{
if (Runtime.RenderModelWireframe)
{
DrawModelWireframe(m, shader);
}
if (Runtime.RenderModels)
{
DrawMdoelHoverSelection(m, shader, IsSelected(), Hovered);
PrimitiveType primitiveType = PrimitiveType.Triangles;
switch (m.lodMeshes[m.DisplayLODIndex].PrimativeType)
{
case STPrimitiveType.Lines:
primitiveType = PrimitiveType.Lines;
break;
case STPrimitiveType.LineStrips:
primitiveType = PrimitiveType.LineStrip;
break;
case STPrimitiveType.Points:
primitiveType = PrimitiveType.Points;
break;
case STPrimitiveType.Triangles:
primitiveType = PrimitiveType.Triangles;
break;
}
GL.DrawElements(primitiveType, m.lodMeshes[m.DisplayLODIndex].displayFaceSize, DrawElementsType.UnsignedInt, m.Offset);
}
}
}
}
private static void SetTextureUniforms(FMAT mat, FSHP m, SF.Shader shader)
{
GL.ActiveTexture(TextureUnit.Texture0 + 1);
GL.BindTexture(TextureTarget.Texture2D, RenderTools.defaultTex.RenderableTex.TexID);
GL.ActiveTexture(TextureUnit.Texture11);
GL.Uniform1(shader.GetUniformLocation("weightRamp1"), 11);
GL.BindTexture(TextureTarget.Texture2D, RenderTools.BoneWeightGradient.Id);
GL.ActiveTexture(TextureUnit.Texture12);
GL.Uniform1(shader.GetUniformLocation("weightRamp2"), 12);
GL.BindTexture(TextureTarget.Texture2D, RenderTools.BoneWeightGradient2.Id);
GL.Uniform1(shader.GetUniformLocation("debugOption"), 2);
GL.ActiveTexture(TextureUnit.Texture10);
GL.Uniform1(shader.GetUniformLocation("UVTestPattern"), 10);
GL.BindTexture(TextureTarget.Texture2D, RenderTools.uvTestPattern.RenderableTex.TexID);
GL.Uniform1(shader.GetUniformLocation("normalMap"), 0);
GL.Uniform1(shader.GetUniformLocation("BakeShadowMap"), 0);
shader.SetInt("RedChannel", 0);
shader.SetInt("GreenChannel", 1);
shader.SetInt("BlueChannel", 2);
shader.SetInt("AlphaChannel", 3);
LoadPBRMaps(shader);
for (int t = 0; t < mat.TextureMaps.Count; t++)
{
MatTexture matex = (MatTexture)mat.TextureMaps[t];
if (matex.Type == MatTexture.TextureType.Diffuse)
{
mat.HasDiffuseMap = TextureUniform(shader, mat, "DiffuseMap", matex);
}
else if (matex.Type == MatTexture.TextureType.Normal)
{
mat.HasNormalMap = TextureUniform(shader, mat, "NormalMap", matex);
}
else if (matex.Type == MatTexture.TextureType.Emission)
{
mat.HasEmissionMap = TextureUniform(shader, mat, "EmissionMap", matex);
}
else if (matex.Type == MatTexture.TextureType.Specular)
{
mat.HasSpecularMap = TextureUniform(shader, mat, "SpecularMap", matex);
}
else if (matex.Type == MatTexture.TextureType.Shadow)
{
mat.HasShadowMap = TextureUniform(shader, mat, "BakeShadowMap", matex);
}
else if (matex.Type == MatTexture.TextureType.Light)
{
mat.HasLightMap = TextureUniform(shader, mat, "BakeLightMap", matex);
}
else if (matex.Type == MatTexture.TextureType.Metalness)
{
mat.HasMetalnessMap = TextureUniform(shader, mat, "MetalnessMap", matex);
}
else if (matex.Type == MatTexture.TextureType.Roughness)
{
mat.HasRoughnessMap = TextureUniform(shader, mat, "RoughnessMap", matex);
}
else if (matex.Type == MatTexture.TextureType.TeamColor)
{
mat.HasTeamColorMap = TextureUniform(shader, mat, "TeamColorMap", matex);
}
else if (matex.Type == MatTexture.TextureType.Transparency)
{
mat.HasTransparencyMap = TextureUniform(shader, mat, "TransparencyMap", matex);
}
else if (matex.Type == MatTexture.TextureType.DiffuseLayer2)
{
mat.HasDiffuseLayer = TextureUniform(shader, mat, "DiffuseLayer", matex);
}
else if (matex.Type == MatTexture.TextureType.SphereMap)
{
mat.HasSphereMap = mat.HasSphereMap = TextureUniform(shader, mat, "SphereMap", matex);
}
else if (matex.Type == MatTexture.TextureType.SubSurfaceScattering)
{
mat.HasSubSurfaceScatteringMap = TextureUniform(shader, mat, "SubSurfaceScatteringMap", matex);
}
else if (matex.Type == MatTexture.TextureType.MRA)
{
mat.HasMRA = TextureUniform(shader, mat, "MRA", matex);
}
}
SetDefaultTextureAttributes(mat, shader);
}
public static bool BindTexture(MatTexture tex, FMAT material, SF.Shader shader, bool IsWiiU)
{
BFRES bfres = (BFRES)material.Parent.Parent.Parent.Parent;
GL.ActiveTexture(TextureUnit.Texture0 + tex.textureUnit + 1);
GL.BindTexture(TextureTarget.Texture2D, RenderTools.defaultTex.RenderableTex.TexID);
string activeTex = tex.Name;
if (tex.animatedTexName != "")
{
activeTex = tex.animatedTexName;
}
if (IsWiiU)
{
if (bfres.HasTextures)
{
var ftexCont = bfres.GetFTEXContainer;
if (ftexCont != null)
{
if (ftexCont.ResourceNodes.ContainsKey(activeTex))
{
return(BindFTEX(ftexCont, tex, shader, activeTex));
}
}
}
foreach (var ftexContainer in PluginRuntime.ftexContainers)
{
if (ftexContainer.ResourceNodes.ContainsKey(activeTex))
{
return(BindFTEX(ftexContainer, tex, shader, activeTex));
}
}
}
else
{
if (bfres.HasTextures)
{
var bntx = bfres.GetBNTX;
if (bntx != null)
{
if (bntx.Textures.ContainsKey(activeTex))
{
return(BindBNTX(bntx, tex, shader, activeTex));
}
}
}
foreach (var bntx in PluginRuntime.bntxContainers)
{
if (bntx.Textures.ContainsKey(activeTex))
{
return(BindBNTX(bntx, tex, shader, activeTex));
}
}
}
return(true);
}
