public static GLTexture BindTexture(ShaderProgram shader, Dictionary <string, STGenericTexture> textures,
STGenericTextureMap textureMap, string name, int id)
{
GL.ActiveTexture(TextureUnit.Texture0 + id);
GL.BindTexture(TextureTarget.Texture2D, RenderTools.defaultTex.ID);
if (textures.ContainsKey(name))
{
return(BindGLTexture(textures[name], textureMap, shader));
}
foreach (var tex in Runtime.TextureCache)
{
if (tex.Name == name)
{
return(BindGLTexture(tex, textureMap, shader));
}
}
foreach (var model in DataCache.ModelCache.Values)
{
if (model.Textures.ContainsKey(name))
{
return(BindGLTexture(model.Textures[name], textureMap, shader));
}
}
return(null);
}
private static GLTexture BindGLTexture(STGenericTexture texture, STGenericTextureMap textureMap, ShaderProgram shader)
{
if (texture.RenderableTex == null)
{
texture.LoadRenderableTexture();
}
if (texture.RenderableTex == null)
{
return(null);
}
var target = ((GLTexture)texture.RenderableTex).Target;
GL.BindTexture(target, texture.RenderableTex.ID);
GL.TexParameter(target, TextureParameterName.TextureWrapS, (int)OpenGLHelper.WrapMode[textureMap.WrapU]);
GL.TexParameter(target, TextureParameterName.TextureWrapT, (int)OpenGLHelper.WrapMode[textureMap.WrapV]);
GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)OpenGLHelper.MinFilter[textureMap.MinFilter]);
GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)OpenGLHelper.MagFilter[textureMap.MagFilter]);
GL.TexParameter(target, TextureParameterName.TextureLodBias, textureMap.LODBias);
GL.TexParameter(target, TextureParameterName.TextureMaxLod, textureMap.MaxLOD);
GL.TexParameter(target, TextureParameterName.TextureMinLod, textureMap.MinLOD);
int[] mask = new int[4]
{
OpenGLHelper.GetSwizzle(texture.RedChannel),
OpenGLHelper.GetSwizzle(texture.GreenChannel),
OpenGLHelper.GetSwizzle(texture.BlueChannel),
OpenGLHelper.GetSwizzle(texture.AlphaChannel),
};
GL.TexParameter(target, TextureParameterName.TextureSwizzleRgba, mask);
return((GLTexture)texture.RenderableTex);
}
public static void Draw(STGenericTexture texture,
STGenericTextureMap textureMap, int width, int height, Vector2 aspectScale, Viewport2D.Camera2D camera)
{
Vector2 bgscale = new Vector2(100, 100);
Init();
GL.Disable(EnableCap.CullFace);
var shader = GlobalShaders.GetShader("UV_WINDOW");
shader.Enable();
var cameraMtx = camera.ViewMatrix * camera.ProjectionMatrix;
shader.SetMatrix4x4("mtxCam", ref cameraMtx);
GL.ActiveTexture(TextureUnit.Texture1);
BindTexture(texture, textureMap);
shader.SetInt("uvTexture", 1);
shader.SetInt("hasTexture", 1);
shader.SetVector2("scale", bgscale * aspectScale);
shader.SetVector2("texCoordScale", bgscale);
shader.SetVector4("uColor", new Vector4(0.5f, 0.5f, 0.5f, 1.0f));
if (texture != null)
{
shader.SetBoolToInt("isSRGB", texture.IsSRGB);
}
//Draw background
vao.Enable(shader);
vao.Use();
GL.DrawArrays(PrimitiveType.TriangleStrip, 0, Length);
//Draw main texture quad inside boundings (0, 1)
shader.SetVector2("scale", aspectScale);
shader.SetVector2("texCoordScale", new Vector2(1));
shader.SetVector4("uColor", new Vector4(1));
vao.Enable(shader);
vao.Use();
GL.DrawArrays(PrimitiveType.TriangleStrip, 0, Length);
//Draw outline of boundings (0, 1)
shader.SetInt("hasTexture", 0);
shader.SetVector2("scale", aspectScale);
shader.SetVector2("texCoordScale", new Vector2(1));
shader.SetVector4("uColor", new Vector4(0, 0, 0, 1));
vao.Enable(shader);
vao.Use();
GL.LineWidth(1);
GL.DrawArrays(PrimitiveType.LineLoop, 0, Length);
GL.Enable(EnableCap.CullFace);
}
private static bool BindTexture(ShaderProgram shader, List <STGenericTexture> textures,
STGenericTextureMap texture, int id)
{
GL.ActiveTexture(TextureUnit.Texture0 + id);
GL.BindTexture(TextureTarget.Texture2D, RenderTools.defaultTex.RenderableTex.TexID);
for (int i = 0; i < textures.Count; i++)
{
if (textures[i].Name == texture.Name)
{
BindGLTexture(textures[i], texture, shader);
}
}
return(false);
}
static void BindTexture(STGenericTexture tex, STGenericTextureMap texMap)
{
if (tex == null)
{
return;
}
if (tex.RenderableTex == null)
{
tex.LoadRenderableTexture();
}
var target = ((GLTexture)tex.RenderableTex).Target;
var texID = tex.RenderableTex.ID;
if (tex.Platform.OutputFormat == TexFormat.BC5_SNORM)
{
if (!GLTextureCache.DecodedFormats.ContainsKey(texID))
{
var reloaded = GLTexture2D.FromGeneric(tex, new ImageParameters()
{
UseSoftwareDecoder = true,
});
GLTextureCache.DecodedFormats.Add(texID, reloaded.ID);
}
texID = GLTextureCache.DecodedFormats[texID];
}
GL.BindTexture(target, texID);
GL.TexParameter(target, TextureParameterName.TextureWrapS, (float)OpenGLHelper.WrapMode[texMap.WrapU]);
GL.TexParameter(target, TextureParameterName.TextureWrapT, (float)OpenGLHelper.WrapMode[texMap.WrapV]);
GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)OpenGLHelper.MinFilter[texMap.MinFilter]);
GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)OpenGLHelper.MagFilter[texMap.MagFilter]);
int[] mask = new int[4]
{
GetSwizzle(tex.RedChannel),
GetSwizzle(tex.GreenChannel),
GetSwizzle(tex.BlueChannel),
GetSwizzle(tex.AlphaChannel),
};
GL.TexParameter(target, TextureParameterName.TextureSwizzleRgba, mask);
}
private static void BindGLTexture(STGenericTexture texture, STGenericTextureMap matTex, ShaderProgram shader)
{
if (texture.RenderableTex == null || !texture.RenderableTex.GLInitialized)
{
texture.LoadOpenGLTexture();
}
//If the texture is still not initialized then return
if (!texture.RenderableTex.GLInitialized)
{
return;
}
GL.BindTexture(TextureTarget.Texture2D, texture.RenderableTex.TexID);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)OpenGLHelper.WrapMode[matTex.WrapU]);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)OpenGLHelper.WrapMode[matTex.WrapV]);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)OpenGLHelper.MinFilter[matTex.MinFilter]);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)OpenGLHelper.MagFilter[matTex.MagFilter]);
GL.TexParameter(TextureTarget.Texture2D, (TextureParameterName)ExtTextureFilterAnisotropic.TextureMaxAnisotropyExt, 0.0f);
}
public STGenericModel ToGeneric()
{
if (CachedModel != null)
{
return(CachedModel);
}
STGenericModel model = new STGenericModel("Model");
foreach (var shape in Meshes)
{
foreach (var meshGroup in shape.Groups)
{
var genericMesh = new STGenericMesh();
genericMesh.Name = $"Mesh{model.Meshes.Count}";
genericMesh.Vertices.AddRange(meshGroup.Vertices);
var group = new STPolygonGroup();
genericMesh.PolygonGroups.Add(group);
var mat = new STGenericMaterial();
mat.DiffuseColor = meshGroup.Color;
group.Material = mat;
if (meshGroup.TextureIndex != -1)
{
var texMap = new STGenericTextureMap()
{
Name = $"Texture{meshGroup.TextureIndex}",
Type = STTextureType.Diffuse,
};
mat.TextureMaps.Add(texMap);
}
genericMesh.Optmize(group);
model.Meshes.Add(genericMesh);
}
}
CachedModel = model;
return(model);
}
public STGenericModel ToGeneric()
{
if (CachedModel != null) return CachedModel;
STGenericModel model = new STGenericModel(FileName);
foreach (var shape in Meshes)
{
foreach (var meshGroup in shape.Groups)
{
var genericMesh = new STGenericMesh();
genericMesh.Name = $"Mesh{model.Meshes.Count}";
genericMesh.Vertices.AddRange(meshGroup.Vertices);
var group = new STPolygonGroup();
genericMesh.PolygonGroups.Add(group);
genericMesh.Optmize(group);
model.Meshes.Add(genericMesh);
var mat = new STGenericMaterial();
group.Material = mat;
// group.IsTransparentPass = true;
if (TextureContainer.Textures.Count > 0)
{
var texMap = new STGenericTextureMap()
{
Name = $"Texture{meshGroup.TextureIndex}",
Type = STTextureType.Diffuse,
};
mat.TextureMaps.Add(texMap);
}
}
}
foreach (var tex in TextureContainer.Textures)
model.Textures.Add(tex);
CachedModel = model;
return model;
}
public void DrawUVs(int PolygonGroupIndex, int UvChannelIndex, List <STGenericMesh> genericObjects, STGenericTextureMap textureMap)
{
if (genericObjects.Count == 0)
{
return;
}
foreach (var genericObject in genericObjects)
{
int divisions = 4;
int lineWidth = 1;
Color uvColor = Runtime.UVEditor.UVColor;
Color gridColor = Color.Black;
List <uint> f = new List <uint>();
int displayFaceSize = 0;
if (genericObject.PolygonGroups.Count > 0)
{
if (PolygonGroupIndex == -1)
{
foreach (var group in genericObject.PolygonGroups)
{
f.AddRange(group.Faces);
displayFaceSize += group.Faces.Count;
}
}
else
{
if (genericObject.PolygonGroups.Count > PolygonGroupIndex)
{
f = genericObject.PolygonGroups[PolygonGroupIndex].Faces;
displayFaceSize = genericObject.PolygonGroups[PolygonGroupIndex].Faces.Count;
}
}
}
for (int v = 0; v < displayFaceSize; v += 3)
{
if (displayFaceSize < 3 || genericObject.Vertices.Count < 3)
{
return;
}
Vector2 v1 = new Vector2(0);
Vector2 v2 = new Vector2(0);
Vector2 v3 = new Vector2(0);
if (f.Count <= v + 2)
{
continue;
}
if (genericObject.Vertices.Count > f[v + 2])
{
v1 = genericObject.Vertices[(int)f[v]].TexCoords[UvChannelIndex];
v2 = genericObject.Vertices[(int)f[v + 1]].TexCoords[UvChannelIndex];
v3 = genericObject.Vertices[(int)f[v + 2]].TexCoords[UvChannelIndex];
v1 = new Vector2(v1.X, 1 - v1.Y);
v2 = new Vector2(v2.X, 1 - v2.Y);
v3 = new Vector2(v3.X, 1 - v3.Y);
DrawUVTriangleAndGrid(v1, v2, v3, divisions, uvColor, lineWidth, gridColor, textureMap);
}
}
}
}
private void DrawUVTriangleAndGrid(Vector2 v1, Vector2 v2, Vector2 v3, int divisions,
Color uvColor, int lineWidth, Color gridColor, STGenericTextureMap textureMap)
{
GL.UseProgram(0);
float bounds = 1;
Vector2 scaleUv = new Vector2(2);
Vector2 transUv = new Vector2(-1f);
if (textureMap != null && textureMap.Transform != null)
{
scaleUv *= textureMap.Transform.Scale;
transUv += textureMap.Transform.Translate;
}
//Disable textures so they don't affect color
GL.Disable(EnableCap.Texture2D);
DrawUvTriangle(v1, v2, v3, uvColor, scaleUv, transUv);
// Draw Grid
GL.Color3(gridColor);
GL.LineWidth(1);
// DrawHorizontalGrid(divisions, bounds, scaleUv);
// DrawVerticalGrid(divisions, bounds, scaleUv);
}
public void UpdateVertexBuffer(int PolygonGroupIndex, int UvChannelIndex, List <STGenericMesh> genericObjects, STGenericTextureMap textureMap)
{
Init();
if (Points.Count > 0)
{
return;
}
if (genericObjects.Count == 0)
{
return;
}
foreach (var genericObject in genericObjects)
{
int divisions = 4;
int lineWidth = 1;
System.Drawing.Color uvColor = Runtime.UVEditor.UVColor;
System.Drawing.Color gridColor = System.Drawing.Color.Black;
List <uint> f = new List <uint>();
int displayFaceSize = 0;
if (genericObject.PolygonGroups.Count > 0)
{
if (PolygonGroupIndex == -1)
{
foreach (var group in genericObject.PolygonGroups)
{
f.AddRange(group.Faces);
displayFaceSize += group.Faces.Count;
}
}
else
{
if (genericObject.PolygonGroups.Count > PolygonGroupIndex)
{
f = genericObject.PolygonGroups[PolygonGroupIndex].Faces;
displayFaceSize = genericObject.PolygonGroups[PolygonGroupIndex].Faces.Count;
}
}
}
if (genericObject.Vertices.Count == 0 ||
genericObject.Vertices[0].TexCoords.Length == 0)
{
return;
}
for (int v = 0; v < displayFaceSize; v += 3)
{
if (displayFaceSize < 3 || genericObject.Vertices.Count < 3)
{
return;
}
Vector2 v1 = new Vector2(0);
Vector2 v2 = new Vector2(0);
Vector2 v3 = new Vector2(0);
if (f.Count <= v + 2)
{
continue;
}
if (genericObject.Vertices.Count > f[v + 2])
{
v1 = genericObject.Vertices[(int)f[v]].TexCoords[UvChannelIndex];
v2 = genericObject.Vertices[(int)f[v + 1]].TexCoords[UvChannelIndex];
v3 = genericObject.Vertices[(int)f[v + 2]].TexCoords[UvChannelIndex];
v1 = new Vector2(v1.X, 1 - v1.Y);
v2 = new Vector2(v2.X, 1 - v2.Y);
v3 = new Vector2(v3.X, 1 - v3.Y);
DrawUVTriangleAndGrid(v1, v2, v3, divisions, uvColor, lineWidth, gridColor, textureMap);
}
}
}
List <float> list = new List <float>();
for (int i = 0; i < Points.Count; i++)
{
list.Add(Points[i].X);
list.Add(Points[i].Y);
}
vao.Bind();
float[] data = list.ToArray();
GL.BufferData(BufferTarget.ArrayBuffer, sizeof(float) * data.Length, data, BufferUsageHint.StaticDraw);
}
private void DrawUVTriangleAndGrid(Vector2 v1, Vector2 v2, Vector2 v3, int divisions,
System.Drawing.Color uvColor, int lineWidth, System.Drawing.Color gridColor, STGenericTextureMap textureMap)
{
GL.UseProgram(0);
Vector2 scaleUv = new Vector2(2);
Vector2 transUv = new Vector2(-1f);
if (textureMap != null && textureMap.Transform != null)
{
scaleUv *= textureMap.Transform.Scale;
transUv += textureMap.Transform.Translate;
}
Points.AddRange(DrawUvTriangle(v1, v2, v3, uvColor, scaleUv, transUv));
}
public STGenericModel ToGeneric()
{
if (Model != null)
{
return(Model);
}
var model = new STGenericModel(FileInfo.FileName);
var sectionData = Header.FileHeader.SectionData;
foreach (var bone in sectionData.SkeletonChunk.Bones)
{
model.Skeleton.Bones.Add(new STBone(model.Skeleton)
{
Name = $"Bone{bone.ID}",
Position = new Vector3(
bone.Translation.X,
bone.Translation.Y,
bone.Translation.Z),
Scale = new Vector3(
bone.Scale.X,
bone.Scale.Y,
bone.Scale.Z),
EulerRotation = new Vector3(
bone.Rotation.X,
bone.Rotation.Y,
bone.Rotation.Z),
ParentIndex = bone.ParentIndex,
});
}
model.Skeleton.Reset();
model.Skeleton.Update();
foreach (var tex in sectionData.TextureChunk.Textures)
{
model.Textures.Add(new CTXB.TextureWrapper(tex)
{
Name = $"Texture{model.Textures.Count}"
});
}
foreach (var mat in sectionData.MaterialChunk.Materials)
{
STGenericMaterial genericMat = new STGenericMaterial();
genericMat.Name = $"Material{model.Materials.Count}";
model.Materials.Add(genericMat);
bool HasDiffuse = false;
foreach (var tex in mat.TextureMaps)
{
if (tex.TextureIndex != -1)
{
STGenericTextureMap matTexture = new STGenericTextureMap();
genericMat.TextureMaps.Add(matTexture);
if (tex.TextureIndex < model.Textures.Count)
{
matTexture.Name = model.Textures[tex.TextureIndex].Name;
}
if (!HasDiffuse && matTexture.Name != "bg_syadowmap") //Quick hack till i do texture env stuff
{
matTexture.Type = STTextureType.Diffuse;
HasDiffuse = true;
}
}
}
}
var shapeData = sectionData.SkeletalMeshChunk.ShapeChunk;
var meshData = sectionData.SkeletalMeshChunk.MeshChunk;
foreach (var mesh in meshData.Meshes)
{
STGenericMesh genericMesh = new STGenericMesh();
genericMesh.Name = $"Mesh_{model.Meshes.Count}";
model.Meshes.Add(genericMesh);
var shape = shapeData.SeperateShapes[(int)mesh.SepdIndex];
List <ushort> SkinnedBoneTable = new List <ushort>();
foreach (var prim in shape.Primatives)
{
if (prim.BoneIndexTable != null)
{
SkinnedBoneTable.AddRange(prim.BoneIndexTable);
}
}
//Now load the vertex and face data
if (shape.Position.VertexData != null)
{
int VertexCount = shape.Position.VertexData.Length;
for (int v = 0; v < VertexCount; v++)
{
STVertex vert = new STVertex();
vert.TexCoords = new Vector2[1];
vert.Position = new OpenTK.Vector3(
shape.Position.VertexData[v].X,
shape.Position.VertexData[v].Y,
shape.Position.VertexData[v].Z);
if (shape.Normal.VertexData != null && shape.Normal.VertexData.Length > v)
{
vert.Normal = new OpenTK.Vector3(
shape.Normal.VertexData[v].X,
shape.Normal.VertexData[v].Y,
shape.Normal.VertexData[v].Z).Normalized();
}
if (shape.Color.VertexData != null && shape.Color.VertexData.Length > v)
{
vert.Colors = new Vector4[1]
{
new OpenTK.Vector4(
shape.Color.VertexData[v].X,
shape.Color.VertexData[v].Y,
shape.Color.VertexData[v].Z,
shape.Color.VertexData[v].W).Normalized()
};
}
if (shape.TexCoord0.VertexData != null && shape.TexCoord0.VertexData.Length > v)
{
vert.TexCoords[0] = new OpenTK.Vector2(
shape.TexCoord0.VertexData[v].X,
1 - shape.TexCoord0.VertexData[v].Y);
}
if (shape.TexCoord1.VertexData != null)
{
}
if (shape.TexCoord2.VertexData != null)
{
}
for (int i = 0; i < 16; i++)
{
if (i < shape.Primatives[0].BoneIndexTable.Length)
{
int boneId = shape.Primatives[0].BoneIndexTable[i];
if (shape.Primatives[0].SkinningMode == SkinningMode.RIGID_SKINNING)
{
vert.Position = Vector3.TransformPosition(vert.Position, model.Skeleton.Bones[boneId].Transform);
vert.Normal = Vector3.TransformNormal(vert.Position, model.Skeleton.Bones[boneId].Transform);
}
}
}
bool HasSkinning = shape.Primatives[0].SkinningMode != SkinningMode.SINGLE_BONE &&
shape.BoneIndices.Type == CmbDataType.UByte; //Noclip checks the type for ubyte so do the same
bool HasWeights = shape.Primatives[0].SkinningMode == SkinningMode.SMOOTH_SKINNING;
if (shape.BoneIndices.VertexData != null && HasSkinning && shape.BoneIndices.VertexData.Length > v)
{
var BoneIndices = shape.BoneIndices.VertexData[v];
for (int j = 0; j < shape.boneDimension; j++)
{
if (BoneIndices[j] < SkinnedBoneTable.Count)
{
vert.BoneIndices.Add((int)SkinnedBoneTable[(int)BoneIndices[j]]);
}
// Console.WriteLine("boneIds " + BoneIndices[j]);
// ushort index = shape.Primatives[0].BoneIndexTable[(uint)BoneIndices[j]];
}
}
if (shape.BoneWeights.VertexData != null && HasWeights && shape.BoneWeights.VertexData.Length > v)
{
var BoneWeights = shape.BoneWeights.VertexData[v];
for (int j = 0; j < shape.boneDimension; j++)
{
vert.BoneWeights.Add(BoneWeights[j]);
}
}
genericMesh.Vertices.Add(vert);
}
}
foreach (var prim in shape.Primatives)
{
STPolygonGroup group = new STPolygonGroup();
genericMesh.PolygonGroups.Add(group);
group.MaterialIndex = mesh.MaterialIndex;
// for (int i = 0; i < prim.Primatives[0].Indices.Length; i++)
// group.Faces.Add(prim.Primatives[0].Indices[i]);
}
}
Model = model;
return(model);
}
