public bool IsEnabled(EnableMode mode) { EnableCap mode_ = 0; //FIXME: switch (mode) { case EnableMode.CullFace: mode_ = EnableCap.CullFace; break; case EnableMode.DepthTest: mode_ = EnableCap.DepthTest; break; case EnableMode.Blend: mode_ = EnableCap.Blend; break; case EnableMode.ScissorTest: mode_ = EnableCap.ScissorTest; break; case EnableMode.StencilTest: mode_ = EnableCap.StencilTest; break; default: Debug.Assert(false); break; } return(GL.IsEnabled(mode_)); }
public static void Disable(EnableCap cap) { if (states[cap]) { if (CheckForErrors) { GLError.Begin(); } states[cap] = false; GL.Disable(cap); if (CheckForErrors) { ErrorCode glError = GLError.End(); if (glError == ErrorCode.InvalidEnum) { throw new Exception(string.Format("Invalid glEnable Enum: {0}", cap)); } else if (glError == ErrorCode.InvalidValue) { throw new Exception(string.Format("Invalid glEnable Value: {0}", cap)); } } } }
public static void Disable(EnableCap cap) { IsEnabled[cap] = false; Instance?.Disable(cap); CheckForError(); }
public static void ArrayObjectATI(EnableCap array, Int32 size, Int32 type, Int32 stride, UInt32 buffer, UInt32 offset) { Debug.Assert(Delegates.pglArrayObjectATI != null, "pglArrayObjectATI not implemented"); Delegates.pglArrayObjectATI((Int32)array, size, type, stride, buffer, offset); LogCommand("glArrayObjectATI", null, array, size, type, stride, buffer, offset); DebugCheckErrors(null); }
public static void ArrayObjectATI(EnableCap array, Int32 size, Int32 type, Int32 stride, UInt32 buffer, UInt32 offset) { Debug.Assert(Delegates.pglArrayObjectATI != null, "pglArrayObjectATI not implemented"); Delegates.pglArrayObjectATI((Int32)array, size, type, stride, buffer, offset); LogFunction("glArrayObjectATI({0}, {1}, {2}, {3}, {4}, {5})", array, size, LogEnumName(type), stride, buffer, offset); DebugCheckErrors(null); }
static void Enable(EnableCap cap, bool enabled) { if (enabled) { GL.Enable(cap); } }
public static void ArrayObjectATI(EnableCap array, int size, int type, int stride, uint buffer, uint offset) { Debug.Assert(Delegates.pglArrayObjectATI != null, "pglArrayObjectATI not implemented"); Delegates.pglArrayObjectATI((int)array, size, type, stride, buffer, offset); LogCommand("glArrayObjectATI", null, array, size, type, stride, buffer, offset); DebugCheckErrors(null); }
public static void Disable(EnableCap enableCap) { if (enableCapSet.Contains(enableCap)) { enableCapSet.Remove(enableCap); GL.Disable(enableCap); } }
public static void Enable(EnableCap enableCap) { if (!enableCapSet.Contains(enableCap)) { enableCapSet.Add(enableCap); GL.Enable(enableCap); } }
public static void SafeDisable(EnableCap cap, Action code) { GL.Disable(cap); code(); GL.Enable(cap); }
public Light() { enableCap = EnableCap.Light0; // Default: Light source 0 position = new List <float>() { 0f, -5f, 0f, 1f }; // Light at z = 10 (last index = 0 =-> infinity) }
public static void Disable(EnableCap cap) { #if USE_OPENGL OpenTK.Graphics.OpenGL.GL.Disable((OpenTK.Graphics.OpenGL.EnableCap)cap); #else OpenTK.Graphics.ES11.GL.Disable((OpenTK.Graphics.ES11.All)cap); #endif }
public static bool EnableState(EnableCap cap) { if (isEnabled.ContainsKey(cap)) { return(isEnabled[cap]); } return(false); }
public GLEnableCap(EnableCap cap) { _cap = cap; _was_enabled = GL.IsEnabled(cap); if (!_was_enabled) { GL.Enable(cap); } }
public static void Enable(EnableCap cap) { GL.Enable(cap); if (enableErrorCheck) { LogErrors(); } }
public override void DoLighting(LightManager lights) { FlushDrawBuffer(); if (lights.Enabled == false) { GL.Disable(EnableCap.Lighting); return; } float[] array = new float[4]; GL.Enable(EnableCap.Lighting); SetArray(array, lights.Ambient); GL.LightModelv(LightModelParameter.LightModelAmbient, array); GL.Enable(EnableCap.ColorMaterial); GL.ColorMaterial(MaterialFace.FrontAndBack, ColorMaterialParameter.AmbientAndDiffuse); for (int i = 0; i < lights.Count || i < mMaxLightsUsed; i++) { EnableCap lightID = (EnableCap)((int)EnableCap.Light0 + i); LightName lightName = (LightName)((int)LightName.Light0 + i); if (i >= lights.Count) { GL.Disable(lightID); continue; } if (lights[i].Enabled == false) { GL.Disable(lightID); continue; } GL.Enable(lightID); SetArray(array, lights[i].Diffuse); GL.Lightv(lightName, LightParameter.Diffuse, array); SetArray(array, lights[i].Ambient); GL.Lightv(lightName, LightParameter.Ambient, array); SetArray(array, lights[i].Position); GL.Lightv(lightName, LightParameter.Position, array); GL.Light(lightName, LightParameter.ConstantAttenuation, lights[i].AttenuationConstant); GL.Light(lightName, LightParameter.LinearAttenuation, lights[i].AttenuationLinear); GL.Light(lightName, LightParameter.QuadraticAttenuation, lights[i].AttenuationQuadratic); } mMaxLightsUsed = lights.Count; }
private static void SetState(EnableCap Cap, bool Value) { if (Value) { GL.Enable(Cap); } else { GL.Disable(Cap); } }
private void Enable(EnableCap Cap, bool Enabled) { if (Enabled) { GL.Enable(Cap); } else { GL.Disable(Cap); } }
private void Enable(EnableCap cap, bool value) { if (value) { Gl.Enable(cap); } else { Gl.Disable(cap); } }
private static void SetGLEnableCap(EnableCap enableCap, bool enabled) { if (enabled) { GL.Enable(enableCap); } else { GL.Disable(enableCap); } }
public static void Toggle(EnableCap cap, bool state) { if (state) { Enable(cap); } else { Disable(cap); } }
public static void Enable (EnableCap enable) { EnableMode m; if(Enum.TryParse<EnableMode>(enable.ToString(), out m)) graphics.Enable(m); //If PSM supports the requested feature, enable it else if(enable.HasFlag(EnableCap.Multisample)) { GraphicsContext temp = graphics; //Create a copy graphics = new GraphicsContext(temp.Screen.Width, temp.Screen.Height,PixelFormat.RgbaH, PixelFormat.Depth24Stencil8, MultiSampleMode.Msaa2x); } }
private void Enable(EnableCap cap, bool enabled) { if (enabled) { GL.Enable(cap); } else { GL.Disable(cap); } }
public static void SetCap(EnableCap cap, bool value) { if (value) { GL.Enable(cap); } else { GL.Disable(cap); } }
private static void SetEnabled(EnableCap cap, bool enabled) { if (enabled == true) { Gl.Enable(cap); } else { Gl.Disable(cap); } }
static void Toggle(EnableCap cap, bool value) { if (value) { GL.Enable(cap); } else { GL.Disable(cap); } }
private static void Update(bool enabled, EnableCap cap) { if (enabled) { GL.Enable(cap); } else { GL.Disable(cap); } }
/// <summary> /// 設定を有効化または無効化する /// </summary> /// <param name="capabilities">設定</param> public void Enable(EnableCap capabilities) { // コントロールを有効化 this.target.MakeCurrent(); // 自分のプログラムを使用 GL.UseProgram(this.ID); // 設定する GL.Enable(capabilities); }
/// <summary> /// Set a EnableCap flag to state /// </summary> public static void SetEnable(EnableCap c, bool state) { if (state) { GL.Enable(c); } else { GL.Disable(c); } }
public void setLight() { LightName lightname = LightName.Light0; EnableCap enablename = EnableCap.Light0; if (playn == 1) { lightname = LightName.Light1; enablename = EnableCap.Light1; } else if (playn == 2) { lightname = LightName.Light2; enablename = EnableCap.Light2; } else if (playn == 3) { lightname = LightName.Light3; enablename = EnableCap.Light3; } else if (playn == 4) { lightname = LightName.Light4; enablename = EnableCap.Light4; } if (!Visible) { GL.Disable(enablename); return; } const float k_amb = 0.6f; const float k_diff = 0.3f; const float k_spec = 1.0f; Color4 Color = theAppearance.Color; Color4 light_ambient = new Color4(Color.R * k_amb, Color.G * k_amb, Color.B * k_amb, 1); Color4 light_diffuse = new Color4(Color.R * k_diff, Color.G * k_diff, Color.B * k_diff, 1); Color4 light_specular = new Color4(k_spec, k_spec, k_spec, 1.0f); Vector4 light_pos = new Vector4(Center.X, Center.Y, Center.Z - 4, 1); Vector4 light_dir = new Vector4(0, 0, 1, 1); GL.Light(lightname, LightParameter.Ambient, light_ambient); GL.Light(lightname, LightParameter.Diffuse, light_diffuse); GL.Light(lightname, LightParameter.Specular, light_specular); GL.Light(lightname, LightParameter.Position, light_pos); GL.Light(lightname, LightParameter.SpotDirection, light_dir); GL.Light(lightname, LightParameter.SpotCutoff, 30.0f); GL.Enable(enablename); }
public static void Disable(EnableCap cap) { #if USE_OPENGL if (HardwareAvailable) { OpenTK.Graphics.OpenGL.GL.Disable((OpenTK.Graphics.OpenGL.EnableCap)cap); } #else OpenTK.Graphics.ES11.GL.Disable((OpenTK.Graphics.ES11.All)cap); #endif }
private static bool GlEnableDisable(EnableCap EnableCap, bool EnableDisable) { if (EnableDisable) { GL.Enable(EnableCap); } else { GL.Disable(EnableCap); } return EnableDisable; }
public Handle(EnableCap state, bool enable = true) { var stateIsEnabled = GL.IsEnabled(state); // is not enabled and we want to enable it if (!stateIsEnabled && enable) GL.Enable(state); // is enabled and we want to disable it else if (stateIsEnabled && !enable) GL.Disable(state); // store previous state this.state = state; this.stateWasEnabled = stateIsEnabled; }
public static void DisableClientStateEXT(EnableCap array, UInt32 index) { Debug.Assert(Delegates.pglDisableClientStateiEXT != null, "pglDisableClientStateiEXT not implemented"); Delegates.pglDisableClientStateiEXT((Int32)array, index); CallLog("glDisableClientStateiEXT({0}, {1})", array, index); DebugCheckErrors(); }
internal void SetEnabled(EnableCap cap, bool value) { using (Lock()) if (value) GL.Enable(cap); else GL.Disable(cap); }
public extern void Enable(EnableCap cap);
void SetCapability(EnableCap capability, bool value) { if (value) GL.Enable(capability); else GL.Disable(capability); }
public static extern bool IsEnabled( EnableCap cap );
internal static extern void glEnable(EnableCap cap);
static void ToggleCap( EnableCap cap, bool value ) { if( value ) GL.Enable( cap ); else GL.Disable( cap ); }
public static void DisableVertexArrayEXT(UInt32 vaobj, EnableCap array) { Debug.Assert(Delegates.pglDisableVertexArrayEXT != null, "pglDisableVertexArrayEXT not implemented"); Delegates.pglDisableVertexArrayEXT(vaobj, (Int32)array); CallLog("glDisableVertexArrayEXT({0}, {1})", vaobj, array); DebugCheckErrors(); }
public GLEnable(EnableCap cap) { Cap=cap; GL.Enable(Cap); }
internal bool IsEnabled(EnableCap cap) { using (Lock()) return GL.IsEnabled(cap); }
public static void ArrayObjectATI( EnableCap array, int size, uint type, int stride, uint buffer, uint offset ) { if (_ArrayObjectATI == null) throw new Exception( "Extension method ArrayObjectATI not found" ); _ArrayObjectATI( array, size, type, stride, buffer, offset ); }
private SizeF PrintOrMeasure(ProcessedText processedText, bool measureOnly) { // init values we'll return float maxMeasuredWidth = 0f; float xPos = 0f; float yPos = 0f; float xOffset = xPos; float yOffset = yPos; // determine what capacities we need var caps = new EnableCap[] { }; if (!measureOnly && !UsingVertexBuffers) { GL.Color4(1.0f, 1.0f, 1.0f, 1.0f); caps = new EnableCap[] { EnableCap.Texture2D, EnableCap.Blend }; } Helper.SafeGLEnable(caps, () => { if (!measureOnly && !UsingVertexBuffers && Options.UseDefaultBlendFunction) GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha); float maxWidth = processedText.maxSize.Width; var alignment = processedText.alignment; //TODO - use these instead of translate when rendering by position (at some point) var nodeList = processedText.textNodeList; for (TextNode node = nodeList.Head; node != null; node = node.Next) node.LengthTweak = 0f; //reset tweaks if (alignment == QFontAlignment.Right) xOffset -= (float)Math.Ceiling(TextNodeLineLength(nodeList.Head, maxWidth) - maxWidth); else if (alignment == QFontAlignment.Centre) xOffset -= (float)Math.Ceiling(0.5f * TextNodeLineLength(nodeList.Head, maxWidth)); else if (alignment == QFontAlignment.Justify) JustifyLine(nodeList.Head, maxWidth); bool atLeastOneNodeCosumedOnLine = false; float length = 0f; for (TextNode node = nodeList.Head; node != null; node = node.Next) { bool newLine = false; if (node.Type == TextNodeType.LineBreak) { newLine = true; } else { if (Options.WordWrap && SkipTrailingSpace(node, length, maxWidth) && atLeastOneNodeCosumedOnLine) { newLine = true; } else if (length + node.ModifiedLength <= maxWidth || !atLeastOneNodeCosumedOnLine) { atLeastOneNodeCosumedOnLine = true; if (!measureOnly) RenderWord(xOffset + length, yOffset, node); length += node.ModifiedLength; maxMeasuredWidth = Math.Max(length, maxMeasuredWidth); } else if (Options.WordWrap) { newLine = true; if (node.Previous != null) node = node.Previous; } else continue; // continue so we still read line breaks even if reached max width } if (newLine) { if (yOffset + LineSpacing - yPos >= processedText.maxSize.Height) break; yOffset += LineSpacing; xOffset = xPos; length = 0f; atLeastOneNodeCosumedOnLine = false; if (node.Next != null) { if (alignment == QFontAlignment.Right) xOffset -= (float)Math.Ceiling(TextNodeLineLength(node.Next, maxWidth) - maxWidth); else if (alignment == QFontAlignment.Centre) xOffset -= (float)Math.Ceiling(0.5f * TextNodeLineLength(node.Next, maxWidth)); else if (alignment == QFontAlignment.Justify) JustifyLine(node.Next, maxWidth); } } } }); return new SizeF(maxMeasuredWidth, yOffset + LineSpacing - yPos); }
public static void GetArrayObjectivATI( EnableCap array, uint pname, [Out]int[] @params ) { if (_GetArrayObjectivATI == null) throw new Exception( "Extension method GetArrayObjectivATI not found" ); _GetArrayObjectivATI( array, pname, @params ); }
public static bool IsEnabled(EnableCap cap) { bool retValue; Debug.Assert(Delegates.pglIsEnabled != null, "pglIsEnabled not implemented"); retValue = Delegates.pglIsEnabled((Int32)cap); CallLog("glIsEnabled({0}) = {1}", cap, retValue); DebugCheckErrors(); return (retValue); }
protected static void Enable(EnableCap enableCap, bool enable) { if (enable) { GL.Enable(enableCap); } else { GL.Disable(enableCap); } }
private SizeF PrintOrMeasure(string text, QFontAlignment alignment, bool measureOnly) { float maxWidth = 0f; float xOffset = 0f; float yOffset = 0f; var caps = new EnableCap[] { }; if(!UsingVertexBuffers) caps = new EnableCap[] { EnableCap.Texture2D, EnableCap.Blend }; Helper.SafeGLEnable(caps, () => { float maxXpos = float.MinValue; float minXPos = float.MaxValue; if (!UsingVertexBuffers) { GL.Color4(1.0f, 1.0f, 1.0f, 1.0f); if (Options.UseDefaultBlendFunction) GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha); } text = text.Replace("\r\n", "\r"); if (alignment == QFontAlignment.Right) xOffset -= MeasureNextlineLength(text); else if (alignment == QFontAlignment.Centre) xOffset -= (int)(0.5f * MeasureNextlineLength(text)); for (int i = 0; i < text.Length; i++) { char c = text[i]; //newline if (c == '\r' || c == '\n') { yOffset += LineSpacing; xOffset = 0f; if (alignment == QFontAlignment.Right) xOffset -= MeasureNextlineLength(text.Substring(i + 1)); else if (alignment == QFontAlignment.Centre) xOffset -= (int)(0.5f * MeasureNextlineLength(text.Substring(i + 1))); } else { minXPos = Math.Min(xOffset, minXPos); //normal character if (c != ' ' && fontData.CharSetMapping.ContainsKey(c)) { QFontGlyph glyph = fontData.CharSetMapping[c]; if (!measureOnly) RenderGlyph(xOffset, yOffset, c, false); } if (IsMonospacingActive) xOffset += MonoSpaceWidth; else { if (c == ' ') xOffset += (float)Math.Ceiling(fontData.meanGlyphWidth * Options.WordSpacing); //normal character else if (fontData.CharSetMapping.ContainsKey(c)) { QFontGlyph glyph = fontData.CharSetMapping[c]; xOffset += (float)Math.Ceiling(glyph.rect.Width + fontData.meanGlyphWidth * Options.CharacterSpacing + fontData.GetKerningPairCorrection(i, text, null)); } } maxXpos = Math.Max(xOffset, maxXpos); } } if (minXPos != float.MaxValue) maxWidth = maxXpos - minXPos; }); return new SizeF(maxWidth, yOffset + LineSpacing); }
public static void Disable(EnableCap cap) { #if USE_OPENGL if (openGlHardwareAvailable) { OpenTK.Graphics.OpenGL.GL.Disable((OpenTK.Graphics.OpenGL.EnableCap)cap); } #else OpenTK.Graphics.ES11.GL.Disable((OpenTK.Graphics.ES11.All)cap); #endif }
public static extern void Disable( EnableCap cap );
internal static extern bool glIsEnabled(EnableCap cap);
public static void EnableClientState(EnableCap array) { Debug.Assert(Delegates.pglEnableClientState != null, "pglEnableClientState not implemented"); Delegates.pglEnableClientState((Int32)array); LogFunction("glEnableClientState({0})", array); DebugCheckErrors(null); }
public static void Enable(EnableCap cap) { Debug.Assert(Delegates.pglEnable != null, "pglEnable not implemented"); Delegates.pglEnable((Int32)cap); CallLog("glEnable({0})", cap); DebugCheckErrors(); }
public static void ArrayObjectATI(EnableCap array, Int32 size, Int32 type, Int32 stride, UInt32 buffer, UInt32 offset) { Debug.Assert(Delegates.pglArrayObjectATI != null, "pglArrayObjectATI not implemented"); Delegates.pglArrayObjectATI((Int32)array, size, type, stride, buffer, offset); CallLog("glArrayObjectATI({0}, {1}, {2}, {3}, {4}, {5})", array, size, type, stride, buffer, offset); DebugCheckErrors(); }
/// <summary> /// Disables the OpenGL capability for the lifespan of this object then enables the capability again /// </summary> /// <param name="state">Specifies a symbolic constant indicating a GL capability.</param> /// <returns>Resource Handle for this capability</returns> public static IDisposable Disable(EnableCap state) { return new Handle(state, false); }
public static void GetArrayObjectATI(EnableCap array, Int32 pname, out Int32 @params) { unsafe { fixed (Int32* p_params = &@params) { Debug.Assert(Delegates.pglGetArrayObjectivATI != null, "pglGetArrayObjectivATI not implemented"); Delegates.pglGetArrayObjectivATI((Int32)array, pname, p_params); CallLog("glGetArrayObjectivATI({0}, {1}, {2})", array, pname, @params); } } DebugCheckErrors(); }