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); } }