public virtual int BindTexture(STGenericMatTexture tex, ShaderProgram shader)
{
GL.ActiveTexture(TextureUnit.Texture0 + tex.textureUnit + 1);
GL.BindTexture(TextureTarget.Texture2D, RenderTools.defaultTex.RenderableTex.TexID);
string activeTex = tex.Name;
foreach (var container in TextureContainers)
{
if (container.Textures.ContainsKey(activeTex))
{
BindGLTexture(tex, shader, container.Textures[activeTex]);
return(tex.textureUnit + 1);
}
}
return(tex.textureUnit + 1);
}
public override int BindTexture(STGenericMatTexture tex, ShaderProgram shader)
{
GL.ActiveTexture(TextureUnit.Texture0 + tex.textureUnit + 1);
GL.BindTexture(TextureTarget.Texture2D, RenderTools.defaultTex.RenderableTex.TexID);
string activeTex = tex.Name;
foreach (var texture in TextureList)
{
if (texture.ID2.ToString("x") == tex.Name)
{
BindGLTexture(tex, shader, texture);
return(tex.textureUnit + 1);
}
}
return(tex.textureUnit + 1);
}
public override int BindTexture(STGenericMatTexture tex, ShaderProgram shader)
{
GL.ActiveTexture(TextureUnit.Texture0 + tex.textureUnit + 1);
GL.BindTexture(TextureTarget.Texture2D, RenderTools.defaultTex.RenderableTex.TexID);
string activeTex = tex.Name;
foreach (var texture in TextureList)
{
if (TextureList.IndexOf(texture) == ((CMB.CMBTextureMapWrapper)tex).TextureIndex)
{
BindGLTexture(tex, shader, TextureList[((CMB.CMBTextureMapWrapper)tex).TextureIndex]);
return(tex.textureUnit + 1);
}
}
return(tex.textureUnit + 1);
}
private static void BindGLTexture(STGenericMatTexture tex, ShaderProgram shader, STGenericTexture texture)
{
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)STGenericMatTexture.wrapmode[tex.WrapModeS]);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)STGenericMatTexture.wrapmode[tex.WrapModeT]);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)STGenericMatTexture.minfilter[tex.MinFilter]);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)STGenericMatTexture.magfilter[tex.MagFilter]);
GL.TexParameter(TextureTarget.Texture2D, (TextureParameterName)ExtTextureFilterAnisotropic.TextureMaxAnisotropyExt, 0.0f);
}
public static int BindTexture(STGenericMatTexture tex, ShaderProgram shader)
{
GL.ActiveTexture(TextureUnit.Texture0 + tex.textureUnit + 1);
GL.BindTexture(TextureTarget.Texture2D, RenderTools.defaultTex.RenderableTex.TexID);
string activeTex = tex.Name;
foreach (var bntx in PluginRuntime.bntxContainers)
{
if (bntx.Textures.ContainsKey(activeTex))
{
BindBNTX(bntx, tex, shader, activeTex);
return(tex.textureUnit + 1);
}
}
return(tex.textureUnit + 1);
}
public virtual int BindTexture(STGenericMatTexture tex, ShaderProgram shader)
{
GL.ActiveTexture(TextureUnit.Texture0 + tex.textureUnit + 1);
GL.BindTexture(TextureTarget.Texture2D, RenderTools.defaultTex.RenderableTex.TexID);
string activeTex = tex.Name;
foreach (var container in TextureContainers)
{
for (int i = 0; i < container.TextureList?.Count; i++)
{
if (activeTex == container.TextureList[i].Text)
{
BindGLTexture(tex, shader, container.TextureList[i]);
return(tex.textureUnit + 1);
}
}
}
return(tex.textureUnit + 1);
}
public static int BindTexture(STGenericMatTexture tex)
{
GL.ActiveTexture(TextureUnit.Texture0 + tex.textureUnit + 1);
GL.BindTexture(TextureTarget.Texture2D, RenderTools.defaultTex.RenderableTex.TexID);
string activeTex = tex.Name;
foreach (var bcresTexContainer in PluginRuntime.bcresTexContainers)
{
if (bcresTexContainer.ResourceNodes.ContainsKey(activeTex))
{
TXOBWrapper txob = (TXOBWrapper)bcresTexContainer.ResourceNodes[activeTex];
if (txob.RenderableTex == null || !txob.RenderableTex.GLInitialized)
{
txob.LoadOpenGLTexture();
}
BindGLTexture(tex, txob.RenderableTex.TexID);
break;
}
}
return(tex.textureUnit + 1);
}
private BcresTextureMapWrapper CreateGenericMatTexture(int textureUnit, BCRES bcres, TextureMapInfo TextureMapInfo)
{
STGenericMatTexture tex1 = new STGenericMatTexture();
var TexRef = TextureMapInfo.TextureRef;
var Sampler = TextureMapInfo.Sampler;
tex1.textureUnit = textureUnit++;
tex1.Name = TexRef.Reference.Name;
tex1.Type = STGenericMatTexture.TextureType.Diffuse;
TextureMaps.Add(tex1);
switch (TextureMapInfo.WrapU)
{
case PICATextureWrap.Repeat: tex1.wrapModeS = 0; break;
case PICATextureWrap.Mirror: tex1.wrapModeS = 1; break;
case PICATextureWrap.ClampToEdge: tex1.wrapModeS = 2; break;
case PICATextureWrap.ClampToBorder: tex1.wrapModeS = 2; break;
}
switch (TextureMapInfo.WrapV)
{
case PICATextureWrap.Repeat: tex1.wrapModeT = 0; break;
case PICATextureWrap.Mirror: tex1.wrapModeT = 1; break;
case PICATextureWrap.ClampToEdge: tex1.wrapModeT = 2; break;
case PICATextureWrap.ClampToBorder: tex1.wrapModeT = 2; break;
}
switch (TextureMapInfo.MagFilter)
{
case PICATextureFilter.Linear: tex1.magFilter = 0; break;
case PICATextureFilter.Nearest: tex1.magFilter = 1; break;
}
switch (TextureMapInfo.MinFilter)
{
case PICATextureFilter.Linear: tex1.minFilter = 0; break;
case PICATextureFilter.Nearest: tex1.minFilter = 1; break;
}
switch (TextureMapInfo.MipFilter)
{
case PICATextureFilter.Linear: tex1.mipDetail = 0; break;
case PICATextureFilter.Nearest: tex1.mipDetail = 1; break;
}
switch (TextureMapInfo.WrapV)
{
case PICATextureWrap.Repeat: tex1.wrapModeT = 0; break;
case PICATextureWrap.Mirror: tex1.wrapModeT = 1; break;
case PICATextureWrap.ClampToEdge: tex1.wrapModeT = 2; break;
case PICATextureWrap.ClampToBorder: tex1.wrapModeT = 2; break;
}
var wrapperTexMap = new BcresTextureMapWrapper(bcres, TextureMapInfo, tex1);
return(wrapperTexMap);
}
private void TextureUniform(ShaderProgram shader, STGenericMaterial mat, bool hasTex, string name, STGenericMatTexture mattex)
{
if (mattex.textureState == STGenericMatTexture.TextureState.Binded)
{
return;
}
// Bind the texture and create the uniform if the material has the right textures.
if (hasTex)
{
GL.Uniform1(shader[name], BindTexture(mattex, shader));
}
}
public void Read(FileReader reader, LM2_ARCADE_Model root)
{
Skeleton = new STSkeleton();
DrawableRenderer = new GenericModelRenderer();
root.DrawableContainer.Drawables.Add(Skeleton);
root.DrawableContainer.Drawables.Add(DrawableRenderer);
reader.ReadSignature(4, "VM61");
ushort Type = reader.ReadUInt16();
ushort Unknown = reader.ReadUInt16();
if (Type == 0)
{
}
else if ((Type == 1))
{
throw new Exception("Animation files not supported yet!");
}
else
{
throw new Exception("Unknown type found! " + Type);
}
Alignment = reader.ReadUInt32();
uint Padding = reader.ReadUInt32();
ulong MaterialCount = reader.ReadUInt64();
HeaderSize = reader.ReadUInt64();
ulong TextureMapsCount = reader.ReadUInt64();
ulong TextureMapsOffset = reader.ReadUInt64();
ulong BoneCount = reader.ReadUInt64();
ulong BoneOffset = reader.ReadUInt64();
ulong FirstNodeOffset = reader.ReadUInt64(); //Either an offset or the total size of section up to the node
ulong LinkNodeCount = reader.ReadUInt64();
ulong LinkNodeOffset = reader.ReadUInt64();
ulong TotalNodeCount = reader.ReadUInt64();
ulong TotalNodeOffset = reader.ReadUInt64();
ulong Padding2 = reader.ReadUInt64();
root.Nodes.Add("Materials");
root.Nodes.Add("Root");
root.Nodes.Add("All Nodes");
long pos = reader.Position;
if (TextureMapsOffset != 0)
{
reader.SeekBegin(TextureMapsOffset);
for (int i = 0; i < (int)TextureMapsCount; i++)
{
TextureMaps.Add(reader.ReadNameOffset(false, typeof(ulong)));
}
}
reader.SeekBegin(pos);
for (int i = 0; i < (int)MaterialCount; i++)
{
Material mat = new Material();
mat.Read(reader);
Materials.Add(mat);
var genericMat = new STGenericMaterial();
genericMat.Text = mat.Name;
for (int t = 0; t < mat.TextureIndices.Length; t++)
{
if (mat.TextureIndices[t] != -1)
{
Console.WriteLine("TextureIndices " + mat.TextureIndices[t]);
string Texture = TextureMaps[mat.TextureIndices[t]];
var textureMap = new STGenericMatTexture();
textureMap.Name = Texture;
genericMat.TextureMaps.Add(textureMap);
if (Texture.EndsWith("col.dds"))
{
textureMap.Type = STGenericMatTexture.TextureType.Diffuse;
}
if (Texture.EndsWith("col.mot"))
{
textureMap.Type = STGenericMatTexture.TextureType.Diffuse;
}
}
}
root.Nodes[0].Nodes.Add(genericMat);
}
if (TotalNodeCount != 0)
{
for (int i = 0; i < (int)TotalNodeCount; i++)
{
reader.SeekBegin((int)TotalNodeOffset + (i * 16));
string NodeName = reader.ReadNameOffset(false, typeof(ulong));
var Offset = reader.ReadUInt64();
Console.WriteLine($"{NodeName}");
if (Offset != 0)
{
reader.SeekBegin(Offset);
Node node = new Node();
node.Name = NodeName;
node.Read(reader);
TotalNodes.Add(node);
}
}
}
if (BoneCount != 0)
{
for (int i = 0; i < (int)BoneCount; i++)
{
reader.SeekBegin((int)BoneOffset + (i * 16));
string NodeName = reader.ReadNameOffset(false, typeof(ulong));
ulong Offset = reader.ReadUInt64();
if (Offset != 0)
{
reader.SeekBegin(Offset);
Node node = new Node();
node.Name = NodeName;
node.Read(reader);
BoneList.Add(node); //This list is for mapping to meshes
}
}
}
foreach (var node in TotalNodes)
{
// TreeNode lowerWrapper = new TreeNode($"{node.Name}");
// root.Nodes[3].Nodes.Add(lowerWrapper);
LoadChildern(TotalNodes, node, root.Nodes[2]);
}
if (FirstNodeOffset != 0)
{
reader.SeekBegin(FirstNodeOffset);
ulong NodeOffset = reader.ReadUInt64();
reader.SeekBegin(NodeOffset);
Node node = new Node();
node.Name = GetNodeName(TotalNodes, node);
node.Read(reader);
LoadBones(TotalNodes, node, root.Nodes[1]);
}
if (LinkNodeCount != 0)
{
root.Nodes.Add("Links");
for (int i = 0; i < (int)LinkNodeCount; i++)
{
TreeNode linkWrapper = new TreeNode($"Link {i}");
root.Nodes[3].Nodes.Add(linkWrapper);
reader.SeekBegin((int)LinkNodeOffset + (i * 16));
ulong NodeOffset1 = reader.ReadUInt64();
ulong NodeOffset2 = reader.ReadUInt64();
reader.SeekBegin(NodeOffset1);
Node node1 = new Node();
node1.Name = GetNodeName(TotalNodes, node1);
node1.Read(reader);
reader.SeekBegin(NodeOffset2);
Node node2 = new Node();
node2.Name = GetNodeName(TotalNodes, node1);
node2.Read(reader);
// LoadChildern(TotalNodes, node1, linkWrapper);
// LoadChildern(TotalNodes, node2, linkWrapper);
LinkNodes.Add(Tuple.Create(node1, node2));
}
}
Skeleton.update();
Skeleton.reset();
}
public void DrawUVs(int PolygonGroupIndex, int UvChannelIndex, List <STGenericObject> genericObjects, STGenericMatTexture 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 <int> f = new List <int>();
int displayFaceSize = 0;
if (genericObject.lodMeshes.Count > 0)
{
f = genericObject.lodMeshes[0].getDisplayFace();
displayFaceSize = genericObject.lodMeshes[0].displayFaceSize;
}
if (genericObject.PolygonGroups.Count > 0)
{
if (PolygonGroupIndex == -1)
{
foreach (var group in genericObject.PolygonGroups)
{
f.AddRange(group.GetDisplayFace());
displayFaceSize += group.displayFaceSize;
}
}
else
{
if (genericObject.PolygonGroups.Count > PolygonGroupIndex)
{
f = genericObject.PolygonGroups[PolygonGroupIndex].GetDisplayFace();
displayFaceSize = genericObject.PolygonGroups[PolygonGroupIndex].displayFaceSize;
}
}
}
Console.WriteLine($"displayFaceSize {f.Count} {displayFaceSize} {genericObject.vertices.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 (UvChannelIndex == 0)
{
v1 = genericObject.vertices[f[v]].uv0;
v2 = genericObject.vertices[f[v + 1]].uv0;
v3 = genericObject.vertices[f[v + 2]].uv0;
}
if (UvChannelIndex == 1)
{
v1 = genericObject.vertices[f[v]].uv1;
v2 = genericObject.vertices[f[v + 1]].uv1;
v3 = genericObject.vertices[f[v + 2]].uv1;
}
if (UvChannelIndex == 2)
{
v1 = genericObject.vertices[f[v]].uv2;
v2 = genericObject.vertices[f[v + 1]].uv2;
v3 = genericObject.vertices[f[v + 2]].uv2;
}
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, STGenericMatTexture 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);
}
