public override void Draw(GL_ControlModern control)
{
foreach (STBone bn in bones)
{
bn.Render();
}
}
public override void Draw(GL_ControlModern control, Pass pass)
{
foreach (IEditableObject obj in GetObjects())
{
if (obj.Visible)
{
control.LimitPickingColors(obj.GetPickableSpan());
obj.Draw(control, pass, this);
}
}
control.UnlimitPickingColors();
foreach (AbstractGlDrawable obj in StaticObjects)
{
if (obj.Visible)
{
obj.Draw(control, pass);
}
}
if (pass == Pass.OPAQUE)
{
SelectionTransformAction.Draw(control);
CurrentAction?.Draw(control);
}
}
public override void Prepare(GL_ControlModern control)
{
base.Prepare(control);
if (!Zone.IsPrepared)
{
Matrix3 rotMat = Framework.Mat3FromEulerAnglesDeg(Rotation);
SceneDrawState.ZoneTransform = new ZoneTransform(
new Matrix4(rotMat) * Matrix4.CreateTranslation(Position),
rotMat);
SceneObjectIterState.InLinks = false;
foreach (ObjectList objects in Zone.ObjLists.Values)
{
foreach (I3dWorldObject obj in objects)
{
obj.Prepare(control);
}
}
SceneObjectIterState.InLinks = true;
foreach (I3dWorldObject obj in Zone.LinkedObjects)
{
obj.Prepare(control);
}
Zone.IsPrepared = true;
}
SceneDrawState.ZoneTransform = ZoneTransform.Identity;
}
public override void Draw(GL_ControlModern control, Pass pass)
{
foreach (AbstractGlDrawable obj in GetDrawables())
{
obj.Draw(control, pass);
}
}
public override void DrawModels(ShaderProgram shader, GL_ControlModern control)
{
shader.EnableVertexAttributes();
List <STGenericObject> opaque = new List <STGenericObject>();
List <STGenericObject> transparent = new List <STGenericObject>();
for (int m = 0; m < Meshes.Count; m++)
{
if (((BMDMaterialWrapper)Meshes[m].GetMaterial()).isTransparent)
{
transparent.Add(Meshes[m]);
}
else
{
opaque.Add(Meshes[m]);
}
}
for (int m = 0; m < transparent.Count; m++)
{
DrawModel(control, Skeleton, transparent[m].GetMaterial(), transparent[m], shader);
}
for (int m = 0; m < opaque.Count; m++)
{
DrawModel(control, Skeleton, opaque[m].GetMaterial(), opaque[m], shader);
}
shader.DisableVertexAttributes();
}
public override void Prepare(GL_ControlModern control)
{
var defaultFrag = new FragmentShader(FragmentShader);
var defaultVert = new VertexShader(VertexShader);
defaultShaderProgram = new ShaderProgram(defaultFrag, defaultVert, control);
}
public static void DrawWithoutTextures(GL_ControlModern control, Pass pass, Vector4 boxColor, Vector4 lineColor, Vector4 pickingColor)
{
control.CurrentShader = SolidColorShaderProgram;
if (pass == Pass.OPAQUE)
{
SolidColorShaderProgram.SetVector4("color", boxColor);
blockVao.Use(control);
GL.DrawArrays(PrimitiveType.Quads, 0, 24);
#region outlines
GL.LineWidth(1);
SolidColorShaderProgram.SetVector4("color", lineColor);
linesVao.Use(control);
GL.DrawArrays(PrimitiveType.Lines, 0, 24);
GL.LineWidth(2);
#endregion
}
else
{
SolidColorShaderProgram.SetVector4("color", pickingColor);
blockVao.Use(control);
GL.DrawArrays(PrimitiveType.Quads, 0, 24);
}
}
public override void Prepare(GL_ControlModern control)
{
if (Initialized)
{
return;
}
var solidColorFrag = new FragmentShader(
@"#version 330
in vec3 color;
out vec4 FragColor;
void main(){
FragColor = vec4(color, 0.2);
}" );
var solidColorVert = new VertexShader(
@"#version 330
in vec3 vPosition;
in vec3 vColor;
out vec3 color;
uniform mat4 mtxCam;
uniform mat4 mtxMdl;
void main(){
color = vColor;
gl_Position = mtxCam * mtxMdl * vec4(vPosition.xyz, 1);
}" );
defaultShaderProgram = new ShaderProgram(solidColorFrag, solidColorVert, control);
Initialized = true;
}
public override void Prepare(GL_ControlModern control)
{
var solidColorFrag = new FragmentShader(
@"#version 330
uniform vec4 bottomColor;
uniform vec4 topColor;
in vec2 texCoord;
out vec4 FragColor;
void main(){
FragColor = mix(bottomColor, topColor, texCoord.y);
}" );
var solidColorVert = new VertexShader(
@"#version 330
layout(location = 0) in vec3 position;
out vec2 texCoord;
void main(){
texCoord.xy = (position.xy + vec2(1.0)) * 0.5;
gl_Position = vec4(position, 1);
}" );
solidColorShaderProgram = new ShaderProgram(solidColorFrag, solidColorVert);
}
public static void Draw(GL_ControlModern control, Pass pass, Vector4 boxColor, Vector4 outlineColor, Vector4 pickingColor)
{
if (pass == Pass.OPAQUE)
{
control.CurrentShader = DefaultShaderProgram;
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, Framework.TextureSheet);
DefaultShaderProgram.SetVector4("color", boxColor);
blockVao.Use(control);
GL.DrawArrays(PrimitiveType.Quads, 0, 24);
#region outlines
GL.LineWidth(1);
control.CurrentShader = SolidColorShaderProgram;
SolidColorShaderProgram.SetVector4("color", outlineColor);
linesVao.Use(control);
GL.DrawArrays(PrimitiveType.Lines, 0, 24);
GL.LineWidth(2);
#endregion
}
else
{
control.CurrentShader = SolidColorShaderProgram;
SolidColorShaderProgram.SetVector4("color", pickingColor);
blockVao.Use(control);
GL.DrawArrays(PrimitiveType.Quads, 0, 24);
}
}
public override void Draw(GL_ControlModern control, Pass pass)
{
if (defaultShaderProgram == null)
{
return;
}
control.CurrentShader = defaultShaderProgram;
control.UpdateModelMatrix(Matrix4.Identity);
defaultShaderProgram.SetVector4("color", ColorUtility.ToVector4(Color));
GL.LineWidth(Width);
vao.Enable(control);
if (Color.A != 255)
{
if (pass == Pass.TRANSPARENT)
{
GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
GL.Enable(EnableCap.Blend);
vao.Use(control);
GL.DrawArrays(PrimitiveType.Lines, 0, Vertices.Length);
}
}
else
{
vao.Use(control);
GL.DrawArrays(PrimitiveType.Lines, 0, Vertices.Length);
}
GL.LineWidth(1f);
GL.Disable(EnableCap.Blend);
}
public override void Draw(GL_ControlModern control)
{
control.CurrentShader = testShaderProgram;
control.ResetModelMatrix();
GL.BindVertexArray(testVao);
GL.DrawArrays(PrimitiveType.Quads, 0, 4);
GL.BindVertexArray(marioTestVao);
control.CurrentShader = defaultShaderProgram;
defaultShaderProgram.SetVertexShader(defaultVert);
control.ApplyModelTransform(Matrix4.CreateTranslation(-8, 0, 0));
for (int i = 0; i < 5; i++)
{
if (i + 1 == selectedIndex)
{
GL.Uniform4(defaultShaderProgram["highlightColor"], 1f, 1f, 0.2f, 0.5f);
}
else if (i + 1 == pickedIndex)
{
GL.Uniform4(defaultShaderProgram["highlightColor"], 1f, 1f, 0.5f, 0.2f);
}
else
{
GL.Uniform4(defaultShaderProgram["highlightColor"], 0f, 0f, 0f, 0f);
}
GL.DrawArrays(PrimitiveType.Quads, 0, 11 * 4);
control.ApplyModelTransform(Matrix4.CreateTranslation(4, 0, 0));
}
}
public void Draw(GL_ControlModern control, Pass pass, Vector4 highlightColor)
{
if (pass == Pass.PICKING)
{
control.CurrentShader = Framework.SolidColorShaderProgram;
GL.LineWidth(5);
control.CurrentShader.SetVector4("color", control.NextPickingColor());
}
else if (pass == Pass)
{
control.CurrentShader = ExtraModelShaderProgram;
if (pass == Pass.TRANSPARENT)
{
GL.Enable(EnableCap.Blend);
}
GL.LineWidth(3);
control.CurrentShader.SetVector4("highlight_color", highlightColor);
}
else
{
return;
}
Vao.Use(control);
GL.DrawElements(PrimitiveType, IndexCount, DrawElementsType.UnsignedInt, 0);
GL.LineWidth(2);
GL.Disable(EnableCap.Blend);
}
public override void Prepare(GL_ControlModern control)
{
foreach (AbstractGlDrawable obj in GetDrawables())
{
obj.Prepare(control);
}
}
public override void Prepare(GL_ControlModern control)
{
if (UsePBR)
{
string pathFrag = System.IO.Path.Combine(Runtime.ExecutableDir, "Shader", "GFBModel.frag");
string pathVert = System.IO.Path.Combine(Runtime.ExecutableDir, "Shader", "GFBModel.vert");
string pathPbrUtiltyFrag = System.IO.Path.Combine(Runtime.ExecutableDir, "Shader", "Utility") + "\\PbrUtility.frag";
string pathUtiltyFrag = System.IO.Path.Combine(Runtime.ExecutableDir, "Shader", "Utility") + "\\Utility.frag";
var defaultFrag = new FragmentShader(File.ReadAllText(pathFrag));
var defaultVert = new VertexShader(File.ReadAllText(pathVert));
var pbrUtiltyFrag = new FragmentShader(System.IO.File.ReadAllText(pathPbrUtiltyFrag));
var utiltyFrag = new FragmentShader(System.IO.File.ReadAllText(pathUtiltyFrag));
defaultShaderProgram = new ShaderProgram(new Shader[]
{ utiltyFrag, pbrUtiltyFrag, defaultVert, defaultFrag }, control);
}
else
{
string pathFrag = System.IO.Path.Combine(Runtime.ExecutableDir, "Shader", "GenericShader.frag");
string pathVert = System.IO.Path.Combine(Runtime.ExecutableDir, "Shader", "GenericShader.vert");
string pathUtiltyFrag = System.IO.Path.Combine(Runtime.ExecutableDir, "Shader", "Utility") + "\\Utility.frag";
var defaultFrag = new FragmentShader(File.ReadAllText(pathFrag));
var defaultVert = new VertexShader(File.ReadAllText(pathVert));
var utiltyFrag = new FragmentShader(System.IO.File.ReadAllText(pathUtiltyFrag));
defaultShaderProgram = new ShaderProgram(new Shader[]
{ utiltyFrag, defaultVert, defaultFrag }, control);
}
}
public override void Prepare(GL_ControlModern control)
{
var solidColorFrag = new FragmentShader(
@"#version 330
in vec3 color;
void main(){
gl_FragColor = vec4(color, 0.2);
}" );
var solidColorVert = new VertexShader(
@"#version 330
in vec3 vPosition;
in vec3 vColor;
out vec3 color;
uniform mat4 mtxCam;
uniform mat4 mtxMdl;
void main(){
color = vColor;
gl_Position = mtxCam * mtxMdl * vec4(vPosition.xyz, 1);
}" );
solidColorShaderProgram = new ShaderProgram(solidColorFrag, solidColorVert);
}
public override void Draw(GL_ControlModern control, Pass pass)
{
control.CurrentShader = defaultShaderProgram;
defaultShaderProgram.SetVector4("LineColor", ColorUtility.ToVector4(LineColor));
int p = 0;
foreach (var point in Points)
{
if (!point.Visible)
{
continue;
}
if (p < Points.Count)
{
GL.LineWidth(2f);
GL.Color3(LineColor);
GL.Begin(PrimitiveType.Lines);
GL.Vertex3(point.Position);
GL.Vertex3(Points[p].Position);
GL.End();
}
p++;
}
}
public override void Draw(GL_ControlModern control, Pass pass)
{
if (pass == Pass.TRANSPARENT || gridShaderProgram == null)
{
return;
}
bool buffersWereInitialized = vbo_position != 0;
if (!buffersWereInitialized)
{
UpdateVertexData();
}
if (!Runtime.OpenTKInitialized)
{
return;
}
control.CurrentShader = gridShaderProgram;
control.UpdateModelMatrix(Matrix4.Identity);
Matrix4 previewScale = Utils.TransformValues(Vector3.Zero, Vector3.Zero, Runtime.previewScale);
gridShaderProgram.SetMatrix4x4("previewScale", ref previewScale);
gridShaderProgram.EnableVertexAttributes();
Draw(gridShaderProgram);
gridShaderProgram.DisableVertexAttributes();
GL.UseProgram(0);
// GL.Enable(EnableCap.CullFace);
}
public override void Prepare(GL_ControlModern control)
{
var solidColorFrag = new FragmentShader(
@"#version 330
uniform vec4 color;
out vec4 FragColor;
void main(){
FragColor = color;
}" );
var solidColorVert = new VertexShader(
@"#version 330
in vec3 vPosition;
uniform mat4 mtxMdl;
uniform mat4 mtxCam;
void main(){
gl_Position = mtxMdl * mtxCam * vec4(vPosition.xyz, 1);
}" );
defaultShaderProgram = new ShaderProgram(solidColorFrag, solidColorVert, control);
int buffer = GL.GenBuffer();
vao = new VertexArrayObject(buffer);
vao.AddAttribute(0, 3, VertexAttribPointerType.Float, false, 12, 0);
vao.Initialize(control);
}
public override void Draw(GL_ControlModern control, Pass pass)
{
if (!Runtime.OpenTKInitialized || pass == Pass.TRANSPARENT)
{
return;
}
bool buffersWereInitialized = vbo_position != 0;
if (!buffersWereInitialized)
{
UpdateVertexData();
}
GL.UseProgram(0);
GL.Disable(EnableCap.CullFace);
GL.Disable(EnableCap.DepthTest);
control.CurrentShader = defaultShaderProgram;
control.UpdateModelMatrix(Matrix4.Identity);
Matrix4 previewScale = Matrix4.CreateScale(Runtime.Preview3DScale);
defaultShaderProgram.EnableVertexAttributes();
Draw(defaultShaderProgram);
defaultShaderProgram.DisableVertexAttributes();
GL.UseProgram(0);
GL.Enable(EnableCap.CullFace);
GL.Enable(EnableCap.DepthTest);
}
private void DrawModels(ShaderProgram shader, GL_ControlModern control)
{
shader.EnableVertexAttributes();
foreach (FMDL mdl in models)
{
if (mdl.Checked)
{
List <FSHP> opaque = new List <FSHP>();
List <FSHP> transparent = new List <FSHP>();
foreach (FSHP m in mdl.depthSortedMeshes)
{
if (m.GetMaterial().isTransparent)
{
transparent.Add(m);
}
else
{
opaque.Add(m);
}
}
foreach (FSHP shp in mdl.shapes)
{
DrawModel(shp, mdl, shader, mdl.IsSelected);
}
}
}
shader.DisableVertexAttributes();
}
public override void Draw(GL_ControlModern control, Pass pass, EditorSceneBase editorScene)
{
Vector4 hightlightColor;
if (Selected && editorScene.Hovered == this)
{
hightlightColor = General3dWorldObject.hoverSelectColor;
}
else if (Selected)
{
hightlightColor = General3dWorldObject.selectColor;
}
else if (editorScene.Hovered == this)
{
hightlightColor = General3dWorldObject.hoverColor;
}
else
{
hightlightColor = Vector4.Zero;
}
Matrix3 rotMat = Framework.Mat3FromEulerAnglesDeg(Rotation);
rotMat = Selected ? editorScene.SelectionTransformAction.NewRot(rotMat) : rotMat;
Matrix4 transform = new Matrix4(rotMat) * Matrix4.CreateTranslation(Selected ? editorScene.SelectionTransformAction.NewPos(Position) : Position);
Vector4 pickingColor = control.NextPickingColor();
foreach (var renderer in Zone.ZoneBatch.BatchRenderers)
{
renderer.Draw(control, pass, hightlightColor, transform, pickingColor);
}
}
public override void Draw(GL_ControlModern controlModern)
{
if (axisRestriction == AxisRestriction.NONE)
{
return;
}
controlModern.CurrentShader = Renderers.ColorBlockRenderer.SolidColorShaderProgram;
control.ResetModelMatrix();
GL.LineWidth(1.0f);
Renderers.ColorBlockRenderer.SolidColorShaderProgram.SetVector4("color", new Vector4(1, 1, 1, 1));
Vector3 vec = center;
if (axisRestriction == AxisRestriction.X)
{
vec.X = -planeOrigin.X;
}
else if (axisRestriction == AxisRestriction.Y)
{
vec.Y = -planeOrigin.Y;
}
else
{
vec.Z = -planeOrigin.Z;
}
if (showRotationInicator)
{
GL.Begin(PrimitiveType.Lines);
GL.Vertex3(vec);
GL.Vertex3(lastIntersection);
GL.End();
}
if (axisRestriction == AxisRestriction.X)
{
Renderers.ColorBlockRenderer.SolidColorShaderProgram.SetVector4("color", colorX);
GL.Begin(PrimitiveType.Lines);
GL.Vertex3(vec + Vector3.UnitX * control.ZFar);
GL.Vertex3(vec - Vector3.UnitX * control.ZFar);
}
else if (axisRestriction == AxisRestriction.Y)
{
Renderers.ColorBlockRenderer.SolidColorShaderProgram.SetVector4("color", colorY);
GL.Begin(PrimitiveType.Lines);
GL.Vertex3(vec + Vector3.UnitY * control.ZFar);
GL.Vertex3(vec - Vector3.UnitY * control.ZFar);
}
else if (axisRestriction == AxisRestriction.Z)
{
Renderers.ColorBlockRenderer.SolidColorShaderProgram.SetVector4("color", colorZ);
GL.Begin(PrimitiveType.Lines);
GL.Vertex3(vec + Vector3.UnitZ * control.ZFar);
GL.Vertex3(vec - Vector3.UnitZ * control.ZFar);
}
GL.End();
}
public override void Draw(GL_ControlModern control, Pass pass, EditorSceneBase editorScene)
{
if (pass == Pass.TRANSPARENT)
{
return;
}
if (!editorScene.ShouldBeDrawn(this))
{
return;
}
bool hovered = editorScene.Hovered == this;
Matrix4 mtx = Matrix4.CreateScale(1f, 0.25f, 1f);
mtx *= Matrix4.CreateFromAxisAngle(Vector3.UnitY, -Framework.HALF_PI);
mtx *= Matrix4.CreateTranslation(Selected ? editorScene.CurrentAction.NewPos(Position) : Position);
Vector4 pickingColor = control.NextPickingColor();
Vector4 lineBoxColor;
if (hovered && Selected)
{
lineBoxColor = hoverSelectColor;
}
else if (Selected)
{
lineBoxColor = selectColor;
}
else if (hovered)
{
lineBoxColor = hoverColor;
}
else
{
lineBoxColor = new Vector4(0.75f, 0.75f, 0.75f, 1);
}
if (Selected)
{
control.UpdateModelMatrix(mtx * Matrix4.CreateTranslation(Vector3.UnitX * (3f - Math.Abs((control.RedrawerFrame - animationStartFrame) * 0.0625f % 6f - 3f))));
}
else
{
control.UpdateModelMatrix(mtx);
}
Renderers.ColorBlockRenderer.Draw(control, pass, Color, Color, pickingColor);
control.UpdateModelMatrix(mtx);
Renderers.ColorBlockRenderer.DrawLineBox(control, pass, lineBoxColor, pickingColor);
control.UpdateModelMatrix(mtx * Matrix4.CreateTranslation(Vector3.UnitX * 3f));
Renderers.ColorBlockRenderer.DrawLineBox(control, pass, lineBoxColor, pickingColor);
}
public static void ReloadModel(string ModelName, GL_ControlModern control)
{
if (cache.ContainsKey(ModelName))
{
cache.Remove(ModelName);
Submit(ModelName, new MemoryStream(SARC.UnpackRamN(new MemoryStream(YAZ0.Decompress(Program.TryGetPathViaProject("ObjectData", ModelName + ".szs")))).Files[ModelName + ".bfres"]), control);
}
}
public override void Draw(GL_ControlModern control, Pass pass, EditorSceneBase editorScene)
{
if (!ObjectRenderState.ShouldBeDrawn(this) || pass != Pass.OPAQUE)
{
return;
}
bool hovered = editorScene.Hovered == this;
if (!CanPick)
{
control.SkipPickingColors(1);
Selected = false;
hovered = false;
if (pass == Pass.PICKING)
{
return;
}
}
Matrix3 rotMtx = GlobalRotation;
Vector4 highlightColor = Vector4.Zero;
if (Selected && hovered)
{
highlightColor = hoverSelectColor;
}
else if (Selected)
{
highlightColor = selectColor;
}
else if (hovered)
{
highlightColor = hoverColor;
}
bool positionChanged = false;
Vector3 position = !Selected ? GlobalPosition :
editorScene.CurrentAction.NewPos(GlobalPosition, out positionChanged);
if (positionChanged && editorScene.CurrentAction is TranslateAction)
{
var newPosition = OnPositionChanged(position);
if (newPosition != position)
{
((TranslateAction)editorScene.CurrentAction).SetAxisXZ();
}
position = newPosition;
}
control.UpdateModelMatrix(
Matrix4.CreateScale((Selected ? editorScene.CurrentAction.NewScale(GlobalScale, rotMtx) : GlobalScale)) *
new Matrix4(Selected ? editorScene.CurrentAction.NewRot(rotMtx) : rotMtx) *
Matrix4.CreateTranslation(position));
DrawModel(control, editorScene, pass, highlightColor);
}
public override void Draw(GL_ControlModern control, Pass pass)
{
if (!Runtime.OpenTKInitialized || pass == Pass.TRANSPARENT || defaultShaderProgram == null || !Visible)
{
return;
}
if (UseOverlay && pass == Pass.PICKING)
{
return;
}
CheckBuffers();
Matrix4 camMat = control.ModelMatrix * control.CameraMatrix * control.ProjectionMatrix;
if (DrawGlobalOctrees)
{
DrawGlobalOctree(ref camMat);
}
control.CurrentShader = defaultShaderProgram;
if (UseOverlay)
{
control.UpdateModelMatrix(
Matrix4.CreateScale(1.0002f));
}
else
{
control.UpdateModelMatrix(
Matrix4.CreateScale(Runtime.previewScale));
}
SetRenderSettings(defaultShaderProgram);
GL.Disable(EnableCap.CullFace);
GL.Uniform3(defaultShaderProgram["difLightDirection"], Vector3.TransformNormal(new Vector3(0f, 0f, -1f), camMat.Inverted()).Normalized());
GL.Uniform3(defaultShaderProgram["difLightColor"], new Vector3(1));
GL.Uniform3(defaultShaderProgram["ambLightColor"], new Vector3(1));
defaultShaderProgram.EnableVertexAttributes();
foreach (KCL.KCLModel mdl in models)
{
DrawModel(mdl, defaultShaderProgram);
}
defaultShaderProgram.DisableVertexAttributes();
GL.UseProgram(0);
GL.Disable(EnableCap.DepthTest);
GL.Enable(EnableCap.DepthTest);
GL.Enable(EnableCap.CullFace);
}
public override void Prepare(GL_ControlModern control)
{
base.Prepare(control);
Program.TrySubmitCobModel("cobCourse", control);
Program.TrySubmitCobModel("cobCannon", control);
Program.TrySubmitCobModel("cobSwitchA", control);
Program.TrySubmitCobModel("cobSwitchB", control);
}
public override void Prepare(GL_ControlModern control)
{
if (Shader != null && Shader.programs.ContainsKey(control))
{
return;
}
var solidColorFrag = new FragmentShader(
@"#version 330
in vec3 position;
in vec3 normal;
in vec4 color;
uniform int selectionOverride;
uniform int colorOverride;
out vec4 FragColor;
void main(){
vec4 highlighted = vec4(1);
if (selectionOverride == 1) {
highlighted = vec4(1,0,0,1);
}
vec3 displayNormal = (normal.xyz * 0.5) + 0.5;
float halfLambert = max(displayNormal.y,0.5);
FragColor = vec4(vec3(color.rgb * halfLambert), 1.0f) * highlighted;
if (colorOverride == 1)
FragColor = vec4(0,0,0,1);
}" );
var solidColorVert = new VertexShader(
@"#version 330
layout(location = 0) in vec3 vPosition;
layout(location = 1) in vec3 vNormal;
layout(location = 2) in vec4 vColor;
layout(location = 3) in float vIndex;
out vec3 position;
out vec3 normal;
out vec4 color;
uniform mat4 mtxMdl;
uniform mat4 mtxCam;
void main(){
position = vPosition;
normal = vNormal;
color = vColor;
gl_Position = mtxCam * mtxMdl * vec4(vPosition.xyz, 1.0);
}" );
Shader = new ShaderProgram(solidColorFrag, solidColorVert, control);
PrepareModel(control);
}
public static void Submit(string modelName, Stream stream, GL_ControlModern control, string textureArc = null)
{
ResFile bfres = new ResFile(stream);
if (!cache.ContainsKey(modelName) && bfres.Models.Count > 0)
{
cache[modelName] = new CachedModel(bfres, textureArc, control);
}
}
