public static void Set(MatrixMode mode)
{
if (CurrentMode != mode)
{
GL.MatrixMode(mode);
}
}
public StereoTransformApply(Matrix4x4 Left, Matrix4x4 Right, MatrixMode Mode, LoadOrMultiply LoadOrMultiply)
{
this.Left = UMath.ToGL(Left);
this.Right = UMath.ToGL(Right);
this.Mode = Mode;
this.LoadOrMultiply = LoadOrMultiply;
}
public static void MatrixMode(MatrixMode mode)
{
#if USE_OPENGL
OpenTK.Graphics.OpenGL.GL.MatrixMode((OpenTK.Graphics.OpenGL.MatrixMode)mode);
#else
OpenTK.Graphics.ES11.GL.MatrixMode((OpenTK.Graphics.ES11.All)mode);
#endif
}
/// <summary>
/// Gets the topmost matrix from the specified MatrixMode stack
/// </summary>
/// <param name="mode">The type of matrix to retrieve</param>
/// <returns>The topmost matrix on the specified MatrixMode stack</returns>
public Matrix GetMatrix(MatrixMode mode)
{
if (mMatrices[mode].Count == 0)
{
throw new InvalidOperationException(string.Format("Attempt to retrieve a {0} Matrix from a stack of size 0", mode.ToString()));
}
return(mMatrices[mode].Peek());
}
public override void SetMatrixMode(MatrixType mode)
{
MatrixMode glMode = matrixModes[(int)mode];
if (glMode != lastMode)
{
GL.MatrixMode(glMode);
lastMode = glMode;
}
}
public static void MatrixMode(MatrixMode mode)
{
#if USE_OPENGL
if (HardwareAvailable)
{
OpenTK.Graphics.OpenGL.GL.MatrixMode((OpenTK.Graphics.OpenGL.MatrixMode)mode);
}
#else
OpenTK.Graphics.ES11.GL.MatrixMode((OpenTK.Graphics.ES11.All)mode);
#endif
}
public static void MatrixLoadEXT(MatrixMode mode, float[] m)
{
unsafe {
fixed (float* p_m = m)
{
Debug.Assert(Delegates.pglMatrixLoadfEXT != null, "pglMatrixLoadfEXT not implemented");
Delegates.pglMatrixLoadfEXT((Int32)mode, p_m);
LogFunction("glMatrixLoadfEXT({0}, {1})", mode, LogValue(m));
}
}
DebugCheckErrors(null);
}
public static void MatrixLoadEXT(MatrixMode mode, double[] m)
{
unsafe {
fixed (double* p_m = m)
{
Debug.Assert(Delegates.pglMatrixLoaddEXT != null, "pglMatrixLoaddEXT not implemented");
Delegates.pglMatrixLoaddEXT((Int32)mode, p_m);
CallLog("glMatrixLoaddEXT({0}, {1})", mode, m);
}
}
DebugCheckErrors();
}
internal static Constants.MatrixMode MatrixModeToGLMatrixMode(MatrixMode mode)
{
switch (mode)
{
case MatrixMode.Color: return(Constants.MatrixMode.Color);
case MatrixMode.ModelView: return(Constants.MatrixMode.ModelView);
case MatrixMode.Projection: return(Constants.MatrixMode.Projection);
case MatrixMode.Texture: return(Constants.MatrixMode.Texture);
}
throw new InvalidEnumerationException();
}
public void PushMatrix(MatrixMode Mode)
{
switch (Mode)
{
case MatrixMode.Modelview:
viewMatrixList.Add(CurrentViewMatrix);
break;
case MatrixMode.Projection:
projectionMatrixList.Add(CurrentProjectionMatrix);
break;
default:
throw new ArgumentOutOfRangeException(nameof(Mode), Mode, null);
}
}
public void PopMatrix(MatrixMode Mode)
{
switch (Mode)
{
case MatrixMode.Modelview:
CurrentViewMatrix = viewMatrixList.Last();
viewMatrixList.RemoveAt(viewMatrixList.Count - 1);
break;
case MatrixMode.Projection:
CurrentProjectionMatrix = projectionMatrixList.Last();
projectionMatrixList.RemoveAt(projectionMatrixList.Count - 1);
break;
default:
throw new ArgumentOutOfRangeException(nameof(Mode), Mode, null);
}
}
/// <summary>
/// Creates a new instance of PickBuffer
/// </summary>
/// <param name="graphics">The IGraphicsDeviceService to be used for rendering</param>
public XPickBuffer(IGraphicsDeviceService graphics)
{
// store graphics device service
mGraphics = graphics;
// Render queue
mRenderables = new Queue <PickRenderable>();
// Matrix stacks for each MatrixMode
mMatrices = new Dictionary <MatrixMode, Stack <Matrix> >();
for (MatrixMode m = MatrixMode.World; m <= MatrixMode.Projection; ++m)
{
mMatrices[m] = new Stack <Matrix>();
}
// Vertex and index data stacks
mVertexDeclaration = new Stack <VertexDeclaration>();
mVertexBuffer = new Stack <VertexBuffer>();
mIndexBuffer = new Stack <IndexBuffer>();
// Pick id stack
mPickID = new Stack <uint>();
// Hook into the device created and reset events so we can re-create our
// render target buffer when necessary
mGraphics.DeviceCreated += new EventHandler(CreateBuffer);
mGraphics.DeviceReset += new EventHandler(CreateBuffer);
mGraphics.DeviceResetting += new EventHandler(DisposeBuffer);
mGraphics.DeviceDisposing += new EventHandler(DisposeBuffer);
// If the graphics device is already up and running we won't hit the above events,
// so check manually for whether or not we need to create the render target
// buffer right now
if ((mGraphics.GraphicsDevice != null) && !mGraphics.GraphicsDevice.IsDisposed)
{
CreateBuffer(this, null);
}
mEffect = new XPickEffect(mGraphics);
}
private void DecodeTransponderData(byte[] section, int endOfSection, ref int pointer)
{
if (pointer + 6 > endOfSection)
{
throw new Exception(string.Format("NIT: corruption detected at transponder data, pointer = {0}, end of section = {1}", pointer, endOfSection));
}
bool isMpeg2Transport = ((section[pointer] & 0x80) == 0);
bool isVerticalRightPolarisation = ((section[pointer] & 0x40) != 0);
int transponderNumber = (section[pointer++] & 0x3f);
byte cdsReference = section[pointer++];
Log.Log.Debug("NIT: transponder data, is MPEG 2 transport = {0}, is vertical/right polarisation = {1}, transponder number = {2}, CDS reference = {3}",
isMpeg2Transport, isVerticalRightPolarisation, transponderNumber, cdsReference);
if (isMpeg2Transport)
{
byte mmsReference = section[pointer++];
int vctId = (section[pointer] << 8) + section[pointer + 1];
pointer += 2;
bool isRootTransponder = ((section[pointer++] & 0x80) != 0);
Log.Log.Debug("NIT: MPEG 2 transponder data, MMS reference = {0}, VCT ID = 0x{1:x}, is root transponder = {2}", mmsReference, vctId, isRootTransponder);
}
else
{
bool isWideBandwidthVideo = ((section[pointer] & 0x80) != 0);
WaveformStandard waveformStandard = (WaveformStandard)(section[pointer++] & 0x1f);
bool isWideBandwidthAudio = ((section[pointer] & 0x80) != 0);
bool isCompandedAudio = ((section[pointer] & 0x40) != 0);
MatrixMode matrixMode = (MatrixMode)((section[pointer] >> 4) & 0x03);
int subcarrier2Offset = 10 * (((section[pointer] & 0x0f) << 6) + (section[pointer + 1] >> 2)); // kHz
pointer++;
int subcarrier1Offset = 10 * (((section[pointer] & 0x03) << 8) + section[pointer + 1]);
pointer += 2;
Log.Log.Debug("NIT: non-MPEG 2 transponder data, is WB video = {0}, waveform standard = {1}, is WB audio = {2}, is companded audio = {3}, matrix mode = {4}, subcarrier 2 offset = {5} kHz, subcarrier 1 offset = {6} kHz",
isWideBandwidthVideo, waveformStandard, isWideBandwidthAudio, isCompandedAudio, matrixMode, subcarrier2Offset, subcarrier1Offset);
}
}
public void MatrixMode(MatrixMode mode)
{
GL.MatrixMode(mode);
}
public static void glMatrixMode(MatrixMode mode)
{
i_OpenGL1_0.glMatrixMode(mode);
}
public static void MatrixPushEXT(MatrixMode mode)
{
Debug.Assert(Delegates.pglMatrixPushEXT != null, "pglMatrixPushEXT not implemented");
Delegates.pglMatrixPushEXT((Int32)mode);
LogFunction("glMatrixPushEXT({0})", mode);
DebugCheckErrors(null);
}
private static Dictionary <string, double[, ]> GetIntervalConfusionMatrix(Dictionary <string, Dictionary <string, List <List <Interval> > > > data, MatrixMode mode)
{
Console.WriteLine("- CALCULATING CONFUSION MATRIX:");
Dictionary <string, double[, ]> confuMatrix = new Dictionary <string, double[, ]>();
for (int i = 0; i < midiNames.Length; i++)
{
confuMatrix.Add(midiNames[i], new double[data.Count, data.Count]);
}
int participantCount1 = 0, participantCount2 = 0;
int totalMatches = data.Count * data.Count;
int runningMatches = 0;
Dictionary <string, List <Pattern> > annotationsPerParticipant = new Dictionary <string, List <Pattern> >();
foreach (KeyValuePair <string, Dictionary <string, List <List <Interval> > > > annotations in data)
{
foreach (KeyValuePair <string, Dictionary <string, List <List <Interval> > > > annotations2 in data)
{
foreach (KeyValuePair <string, List <List <Interval> > > files in annotations.Value)
{
switch (mode)
{
case MatrixMode.PRECISION:
confuMatrix[files.Key][int.Parse(annotations.Key) - 1, int.Parse(annotations2.Key) - 1] = Math.Round(IntervalsPrecision(annotations.Value[files.Key], annotations2.Value[files.Key]), 2);
break;
case MatrixMode.RECALL:
confuMatrix[files.Key][int.Parse(annotations.Key) - 1, int.Parse(annotations2.Key) - 1] = Math.Round(IntervalsRecall(annotations.Value[files.Key], annotations2.Value[files.Key]), 2);
break;
case MatrixMode.FSCORE:
confuMatrix[files.Key][int.Parse(annotations.Key) - 1, int.Parse(annotations2.Key) - 1] = Math.Round(IntervalsFScore(annotations.Value[files.Key], annotations2.Value[files.Key]), 2);
break;
}
}
participantCount2++;
runningMatches++;
Console.Write("\r-- " + ((runningMatches * 100) / (totalMatches)) + "%");
}
participantCount1++;
participantCount2 = 0;
}
Console.WriteLine(": Done!");
Console.WriteLine();
return(confuMatrix);
}
public static void MatrixScaleEXT(MatrixMode mode, double x, double y, double z)
{
Debug.Assert(Delegates.pglMatrixScaledEXT != null, "pglMatrixScaledEXT not implemented");
Delegates.pglMatrixScaledEXT((Int32)mode, x, y, z);
LogFunction("glMatrixScaledEXT({0}, {1}, {2}, {3})", mode, x, y, z);
DebugCheckErrors(null);
}
public TransformApply(Matrix4x4 Matrix, MatrixMode Mode, LoadOrMultiply LoadOrMultiply)
{
this.Matrix = UMath.ToGL(Matrix);
this.Mode = Mode;
this.LoadOrMultiply = LoadOrMultiply;
}
public static extern void MatrixMode( MatrixMode mode );
protected abstract void SetMatrixModeInternal(MatrixMode mode);
public static void MatrixMode(MatrixMode mode)
{
Delegates.MatrixMode(mode);
}
public static extern void glMatrixMode(MatrixMode mode);
private void DecodeVirtualChannelMap(byte[] section, int endOfSection, ref int pointer, AtscTransmissionMedium transmissionMedium, int vctId)
{
// Virtual channel formats depend on transmission medium.
if (pointer + 7 > endOfSection)
{
throw new Exception(string.Format("S-VCT: corruption detected at virtual channel map, pointer = {0}, end of section = {1}", pointer, endOfSection));
}
bool freqSpecIncluded = ((section[pointer] & 0x80) != 0);
bool symbolRateIncluded = ((section[pointer] & 0x40) != 0);
bool descriptorsIncluded = ((section[pointer++] & 0x20) != 0);
bool splice = ((section[pointer++] & 0x80) != 0);
uint activationTime = 0;
for (byte b = 0; b < 4; b++)
{
activationTime = activationTime << 8;
activationTime = section[pointer++];
}
byte numberOfVcRecords = section[pointer++];
Log.Log.Debug("S-VCT: virtual channel map, transmission medium = {0}, freq. spec. included = {1}, symbol rate included = {2}, descriptors included = {3}, splice = {4}, activation time = {5}, number of VC records = {6}",
transmissionMedium, freqSpecIncluded, symbolRateIncluded, descriptorsIncluded, splice, activationTime, numberOfVcRecords);
for (byte i = 0; i < numberOfVcRecords; i++)
{
if (pointer + 9 > endOfSection)
{
throw new Exception(string.Format("S-VCT: detected number of virtual channel records {0} is invalid, pointer = {1}, end of section = {2}, loop = {3}", numberOfVcRecords, pointer, endOfSection, i));
}
int virtualChannelNumber = ((section[pointer] & 0x0f) << 8) + section[pointer + 1];
pointer += 2;
_channelDefinitions.Add(virtualChannelNumber);
bool applicationVirtualChannel = ((section[pointer] & 0x80) != 0);
int bitstreamSelect = ((section[pointer] & 0x40) >> 6); // broadcast reserved
int pathSelect = ((section[pointer] & 0x20) >> 5); // satellite, SMATV, broadcast reserved
TransportType transportType = (TransportType)((section[pointer] & 0x10) >> 4);
ChannelType channelType = (ChannelType)(section[pointer++] & 0x0f);
int sourceId = (section[pointer] << 8) + section[pointer + 1];
pointer += 2;
Log.Log.Debug("S-VCT: virtual channel number = {0}, application virtual channel = {1}, bitstream select = {2}, path select = {3}, transport type = {4}, channel type = {5}, source ID = 0x{6:x}",
virtualChannelNumber, applicationVirtualChannel, bitstreamSelect, pathSelect, transportType, channelType, sourceId);
if (channelType == ChannelType.NvodAccess)
{
int nvodChannelBase = ((section[pointer] & 0x0f) << 8) + section[pointer + 1];
pointer += 2;
if (transmissionMedium == AtscTransmissionMedium.Smatv)
{
pointer += 3;
}
else if (transmissionMedium != AtscTransmissionMedium.OverTheAir)
{
pointer += 2;
}
Log.Log.Debug("S-VCT: NVOD channel base = 0x{0:x}", nvodChannelBase);
}
else
{
switch (transmissionMedium)
{
case AtscTransmissionMedium.Satellite:
if (transportType == TransportType.Mpeg2)
{
byte satellite = section[pointer++];
int transponder = (section[pointer++] & 0x3f);
int programNumber = (section[pointer] << 8) + section[pointer + 1];
pointer += 2;
Log.Log.Debug("S-VCT: satellite = {0}, transponder = {1}, program number = 0x{2:x}", satellite, transponder, programNumber);
}
else
{
byte satellite = section[pointer++];
int transponder = (section[pointer++] & 0x3f);
pointer += 2;
Log.Log.Debug("S-VCT: satellite = {0}, transponder = {1}", satellite, transponder);
}
break;
case AtscTransmissionMedium.Smatv:
if (transportType == TransportType.Mpeg2)
{
byte cdsReference = section[pointer++];
int programNumber = (section[pointer] << 8) + section[pointer + 1];
pointer += 2;
byte mmsReference = section[pointer++];
pointer++;
Log.Log.Debug("S-VCT: CDS reference = {0}, program number = 0x{1:x}, MMS reference = {2}", cdsReference, programNumber, mmsReference);
}
else
{
byte cdsReference = section[pointer++];
bool scrambled = ((section[pointer] & 0x80) != 0);
VideoStandard videoStandard = (VideoStandard)(section[pointer++] & 0x0f);
bool isWideBandwidthVideo = ((section[pointer] & 0x80) != 0);
WaveformStandard waveformStandard = (WaveformStandard)(section[pointer++] & 0x1f);
bool isWideBandwidthAudio = ((section[pointer] & 0x80) != 0);
bool isCompandedAudio = ((section[pointer] & 0x40) != 0);
MatrixMode matrixMode = (MatrixMode)((section[pointer] >> 4) & 0x03);
int subcarrier2Offset = 10 * (((section[pointer] & 0x0f) << 6) + (section[pointer + 1] >> 2)); // kHz
pointer++;
int subcarrier1Offset = 10 * (((section[pointer] & 0x03) << 8) + section[pointer + 1]);
pointer += 2;
Log.Log.Debug("S-VCT: CDS reference = {0}, scrambled = {1}, video standard = {2}, is WB video = {3}, waveform standard = {4}, is WB audio = {5}, is companded audio = {6}, matrix mode = {7}, subcarrier 2 offset = {8} kHz, subcarrier 1 offset = {9} kHz",
cdsReference, scrambled, videoStandard, isWideBandwidthVideo, waveformStandard, isWideBandwidthAudio,
isCompandedAudio, matrixMode, subcarrier2Offset, subcarrier1Offset);
}
break;
case AtscTransmissionMedium.OverTheAir:
if (transportType == TransportType.Mpeg2)
{
int programNumber = (section[pointer] << 8) + section[pointer + 1];
pointer += 2;
Log.Log.Debug("S-VCT: program number = 0x{0:x}", programNumber);
}
else
{
bool scrambled = ((section[pointer] & 0x80) != 0);
VideoStandard videoStandard = (VideoStandard)(section[pointer++] & 0x0f);
pointer++;
Log.Log.Debug("S-VCT: scrambled = {0}, video standard = {1}", scrambled, videoStandard);
}
break;
case AtscTransmissionMedium.Cable:
case AtscTransmissionMedium.Mmds:
if (transportType == TransportType.Mpeg2)
{
byte cdsReference = section[pointer++];
int programNumber = (section[pointer] << 8) + section[pointer + 1];
pointer += 2;
byte mmsReference = section[pointer++];
Log.Log.Debug("S-VCT: CDS reference = {0}, program number = 0x{1:x}, MMS reference = {2}", cdsReference, programNumber, mmsReference);
if (OnChannelDetail != null)
{
OnChannelDetail(transmissionMedium, vctId, virtualChannelNumber, applicationVirtualChannel, bitstreamSelect,
pathSelect, channelType, sourceId, cdsReference, programNumber, mmsReference);
}
}
else
{
byte cdsReference = section[pointer++];
bool scrambled = ((section[pointer] & 0x80) != 0);
VideoStandard videoStandard = (VideoStandard)(section[pointer++] & 0x0f);
pointer += 2;
Log.Log.Debug("S-VCT: CDS reference = {0}, scrambled = {1}, video standard = {2}", cdsReference, scrambled, videoStandard);
}
break;
default:
throw new Exception(string.Format("S-VCT: unsupported transmission medium {0}", transmissionMedium));
}
}
if (freqSpecIncluded || transmissionMedium == AtscTransmissionMedium.OverTheAir)
{
int frequencyUnit = 10; // kHz
if ((section[pointer] & 0x80) != 0)
{
frequencyUnit = 125; // kHz
}
int carrierFrequency = frequencyUnit * (((section[pointer] & 0x7f) << 8) + section[pointer + 1]); // kHz
pointer += 2;
Log.Log.Debug("S-VCT: frequency, unit = {0} kHz, carrier = {1} kHz", frequencyUnit, carrierFrequency);
}
if (symbolRateIncluded && transmissionMedium != AtscTransmissionMedium.OverTheAir)
{
// s/s
int symbolRate = ((section[pointer] & 0x0f) << 24) + (section[pointer + 1] << 16) + (section[pointer + 2] << 8) + section[pointer + 3];
pointer += 4;
Log.Log.Debug("S-VCT: symbol rate = {0} s/s", symbolRate);
}
if (descriptorsIncluded)
{
if (pointer >= endOfSection)
{
throw new Exception(string.Format("S-VCT: invalid section length at virtual channel map descriptor count, pointer = {0}, end of section = {1}, loop = {2}", pointer, endOfSection, i));
}
byte descriptorCount = section[pointer++];
for (byte d = 0; d < descriptorCount; d++)
{
if (pointer + 2 > endOfSection)
{
throw new Exception(string.Format("S-VCT: detected virtual channel map descriptor count {0} is invalid, pointer = {1}, end of section = {2}, loop = {3}, inner loop = {4}", descriptorCount, pointer, endOfSection, i, d));
}
byte tag = section[pointer++];
byte length = section[pointer++];
Log.Log.Debug("S-VCT: virtual channel map descriptor, tag = 0x{0:x}, length = {1}", tag, length);
if (pointer + length > endOfSection)
{
throw new Exception(string.Format("S-VCT: invalid virtual channel map descriptor length {0}, pointer = {1}, end of section = {2}, loop = {3}, inner loop = {4}", length, pointer, endOfSection, i, d));
}
pointer += length;
}
}
}
}
public void MatrixMode(MatrixMode mode)
{
glMatrixMode((int)mode);
}
public void MatrixMode(MatrixMode projection)
{
GL.MatrixMode(projection);
}
public void MatrixMode(MatrixMode mode)
{
gl.glMatrixMode((int)mode);
CheckException();
}
internal static extern void glMatrixMode(MatrixMode mode);
public static void glMatrixMode(MatrixMode mode)
{
switch (Environment.OSVersion.Platform)
{
case PlatformID.MacOSX:
break;
case PlatformID.Unix:
Linux.Methods.glMatrixMode(mode);
return;
case PlatformID.Win32NT:
case PlatformID.Win32S:
case PlatformID.Win32Windows:
case PlatformID.WinCE:
Windows.Methods.glMatrixMode(mode);
return;
case PlatformID.Xbox:
break;
}
throw new PlatformNotSupportedException();
}
public static void MatrixMultTransposeEXT(MatrixMode mode, double[] m)
{
unsafe {
fixed (double* p_m = m)
{
Debug.Assert(Delegates.pglMatrixMultTransposedEXT != null, "pglMatrixMultTransposedEXT not implemented");
Delegates.pglMatrixMultTransposedEXT((Int32)mode, p_m);
LogFunction("glMatrixMultTransposedEXT({0}, {1})", mode, LogValue(m));
}
}
DebugCheckErrors(null);
}
protected override void SetMatrixModeInternal(MatrixMode mode)
{
Internal.OpenGL.Methods.glMatrixMode(OpenGLEngine.MatrixModeToGLMatrixMode(mode));
}
public static void MatrixTranslateEXT(MatrixMode mode, double x, double y, double z)
{
Debug.Assert(Delegates.pglMatrixTranslatedEXT != null, "pglMatrixTranslatedEXT not implemented");
Delegates.pglMatrixTranslatedEXT((Int32)mode, x, y, z);
CallLog("glMatrixTranslatedEXT({0}, {1}, {2}, {3})", mode, x, y, z);
DebugCheckErrors();
}
internal static extern void glMatrixMode(MatrixMode mode);
public static void MatrixMultTransposeEXT(MatrixMode mode, float[] m)
{
unsafe {
fixed (float* p_m = m)
{
Debug.Assert(Delegates.pglMatrixMultTransposefEXT != null, "pglMatrixMultTransposefEXT not implemented");
Delegates.pglMatrixMultTransposefEXT((Int32)mode, p_m);
CallLog("glMatrixMultTransposefEXT({0}, {1})", mode, m);
}
}
DebugCheckErrors();
}
public static void MatrixScaleEXT(MatrixMode mode, float x, float y, float z)
{
Debug.Assert(Delegates.pglMatrixScalefEXT != null, "pglMatrixScalefEXT not implemented");
Delegates.pglMatrixScalefEXT((Int32)mode, x, y, z);
CallLog("glMatrixScalefEXT({0}, {1}, {2}, {3})", mode, x, y, z);
DebugCheckErrors();
}
public static void MatrixTranslateEXT(MatrixMode mode, float x, float y, float z)
{
Debug.Assert(Delegates.pglMatrixTranslatefEXT != null, "pglMatrixTranslatefEXT not implemented");
Delegates.pglMatrixTranslatefEXT((Int32)mode, x, y, z);
LogFunction("glMatrixTranslatefEXT({0}, {1}, {2}, {3})", mode, x, y, z);
DebugCheckErrors(null);
}
public static void MatrixOrthoEXT(MatrixMode mode, double left, double right, double bottom, double top, double zNear, double zFar)
{
Debug.Assert(Delegates.pglMatrixOrthoEXT != null, "pglMatrixOrthoEXT not implemented");
Delegates.pglMatrixOrthoEXT((Int32)mode, left, right, bottom, top, zNear, zFar);
CallLog("glMatrixOrthoEXT({0}, {1}, {2}, {3}, {4}, {5}, {6})", mode, left, right, bottom, top, zNear, zFar);
DebugCheckErrors();
}
public static void rlMatrixMode(MatrixMode mode)
{
rlMatrixMode((int)mode);
}
public static void MatrixMode(MatrixMode mode)
{
Debug.Assert(Delegates.pglMatrixMode != null, "pglMatrixMode not implemented");
Delegates.pglMatrixMode((Int32)mode);
CallLog("glMatrixMode({0})", mode);
DebugCheckErrors();
}
public void MatrixMode(MatrixMode mode)
{
GL.MatrixMode(mode);
}
public static void MatrixMode(MatrixMode mode)
{
gl.glMatrixMode((int)mode);
}
/// <summary>
/// Pushes a matrix of the specified MatrixMode onto the matrix stack
/// </summary>
/// <param name="mode">The type of matrix to push onto the corresponding stack</param>
/// <param name="mtx">The matrix to push onto the stack</param>
public void PushMatrix(MatrixMode mode, Matrix mtx)
{
mMatrices[mode].Push(mtx);
}
static extern void matrixMode(MatrixMode mode);
public void MatrixMode(MatrixMode mode) => matrixMode(mode);
public static void MatrixMode(MatrixMode mode)
{
#if USE_OPENGL
if (openGlHardwareAvailable)
{
OpenTK.Graphics.OpenGL.GL.MatrixMode((OpenTK.Graphics.OpenGL.MatrixMode)mode);
}
#else
OpenTK.Graphics.ES11.GL.MatrixMode((OpenTK.Graphics.ES11.All)mode);
#endif
}
public static void MatrixMode(MatrixMode mode)
{
matrixMode = mode;
Instance?.MatrixMode(mode);
CheckForError();
}
public static void MatrixMode(MatrixMode mode)
{
Instance?.MatrixMode(mode);
}
public static void Set(MatrixMode mode)
{
if (CurrentMode != mode) {
GL.MatrixMode(mode);
}
}
