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 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);
}
/// <summary>
/// 設定を有効化または無効化する
/// </summary>
/// <param name="capabilities">設定</param>
public void Enable(EnableCap capabilities)
{
// コントロールを有効化
this.target.MakeCurrent();
// 自分のプログラムを使用
GL.UseProgram(this.ID);
// 設定する
GL.Enable(capabilities);
}
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 );
public static void Enable(EnableCap enableCap)
{
if (!enableCapSet.Contains(enableCap))
{
enableCapSet.Add(enableCap);
GL.Enable(enableCap);
}
}
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();
}
